def _slow_znl(blank_image, Y,X,P,n,l):
    def _polar(r,theta):
        x = r * cos(theta)
        y = r * sin(theta)
        return 1.*x+1.j*y

    v = 0.+0.j
    def _factorial(n):
        if n == 0: return 1.
        return n * _factorial(n - 1)
    y,x = Y[0],X[0]
    for x,y,p in zip(X,Y,P):
        Vnl = 0.
        for m in range( int( (n-l)//2 ) + 1 ):
            Vnl += (-1.)**m * _factorial(n-m) /  \
                ( _factorial(m) * _factorial((n - 2*m + l) // 2) * _factorial((n - 2*m - l) // 2) ) * \
                ( sqrt(x*x + y*y)**(n - 2*m) * _polar(1.0, l*atan2(y,x)) )
        v += p * conjugate(Vnl)

        #This is probably wrong, I am not sure if v represents the coefficients, does it?
        blank_image[x][y] = v

    v *= (n+1)/pi

    #I get a bunch of zeros at this point, probably v being casted to uint8, so I presume something must happen before this point
    print blank_image

    #This transpose method is not the one you refer, I am quite sure.
    cv2.imshow("transposed image", cv2.transpose(blank_image))

    return v

def _slow_zernike(img, radius, D, cof=None):
    zvalues = []

    Y,X = np.where(img > 0)
    P = img[Y,X].ravel()

    #blank image
    height, width = img.shape
    blank_image = np.zeros((height, width, 3), np.uint8)

    if cof is None:
        cofy,cofx = center_of_mass(img)
    else:
        cofy,cofx = cof
    Yn = ( (Y -cofy)/radius).ravel()
    Xn = ( (X -cofx)/radius).ravel()
    k = (np.sqrt(Xn**2 + Yn**2) <= 1.)
    frac_center = np.array(P[k], np.double)
    frac_center /= frac_center.sum()
    Yn = Yn[k]
    Xn = Xn[k]
    frac_center = frac_center.ravel()

    for n in range(D+1):
        for l in range(n+1):
            if (n-l)%2 == 0:
                z = _slow_znl(blank_image, Yn, Xn, frac_center, float(n), float(l))
                zvalues.append(abs(z))
    return np.array(zvalues)