Exemplo n.º 1
0
    def apply(self, img):
        if not(self.initialized and (img.shape == self.image_dimension)):
            if name == 'LDDMM':
                fimg = np.rfftn(img)
                if len(self.dimension)==3:
                    (x,y,z) = np.mgrid(0:img.shape[0], 0:img.shape[1], 0:img.shape[2])
                    u = (self.gamma + self.alpha *(x**2 +y**2+z**2))**(2*self.lddmm_order)
                elif len(self.dimension)==2:
                    (x,y) = np.mgrid(0:img.shape[0], 0:img.shape[1])
                    u = (self.gamma + self.alpha *(x**2 +y**2))**(-2*self.lddmm_order)
                elif len(self.dimension)==1:
                    x = np.mgrid(0:img.shape[0])
                    u = (self.gamma + self.alpha *(x**2))**(2*self.lddmm_order)
                else:
                    print 'use lddmm kernel in dimension 1 , 2 or 3'
                    return
                self.image_dimension = copy(img.shape)
                self.fft = np.rfftn(u)
                
            else:
                self.image_dimension = img.shape + self.dimension/2 + 1
                fimg = np.rfftn(img, self.image_dimension)
                self.fft = np.ifftshift(np.rfftn(self.values, self.image_dimension))

                
            print 'kernel is not implemented (yet...)'
            return

        u = np.multiply(self.fft, fimg)
        res = np.ifftn(u)
        return res
Exemplo n.º 2
0
 def __init__(dimension = None, name = 'gauss', sigma = 6.5, order = 3, lddmm_order = 1, alpha = 0.01, gamma = 1, w1 = 1.0, w2 = 1.0, dim = 3, center = [0,0,0]):
     self.name = name
     self.sigma = sigma
     self.order = order
     self.alpha = alpha
     self.gamma = gamma
     self.w1 = w1
     self.w2 = w2
     self.dim = dim
     self.center = center
     self.dimension = dimension
     self.image_dimension = None
     self.initialized = False
     if name == 'gauss' || name == 'laplacian':
         center = self.dimension/2 ;
         if len(self.dimension)==3:
             (x,y,z) = np.mgrid(0:self.dimension[0], 0:self.dimension[1], 0:self.dimension[2])
             u = (x-self.center[0])**2 + (y-self.center[1])**2 + (z-self.center[2])**2
         elif len(self.dimension)==2:
             (x,y) = np.mgrid(0:self.dimension[0], 0:self.dimension[1])
             u = (x-self.center[0])**2 + (y-self.center[1])**2 
         elif len(self.dimension)==1:
             (x,y) = np.mgrid(0:self.dimension[0])
             u = (x-self.center[0])**2
         else:
             print 'use lddmm kernel in dimension 1 , 2 or 3'
             return
         if name == 'gauss':
             self.values = np.exp(-u/(2*sigma**2))
         elif name=='laplacian':
             u = np.sqrt(u) / sigma
             if order == 0:
                 pol = np.ones(u.shape)
             elif order == 1:
                 pol = 1 + u
             elif order == 2:
                 pol = 1 + u + u*u/3 
             elif order == 3:
                 pol = 1 + u + 0.4*u*u + u**3/15
             elif order == 4:
                 pol = 1 + u + (3./7)*(u*u) + (u**3)/10.5 + (u**4)/105
             else:
                 print "Laplacian kernel defined up to order 4"
                 return
             self.values = pol * np.exp(-u)
Exemplo n.º 3
0
def Matrix2GCP(x_vec, y_vec, lon, lat):
    y_lim = y_vec[-1] + 1
    x_lim = x_vec[-1] + 1
    y = y_vec.max - y_vec
    xx, yy = np.mgrid(x_vec, y)
    x, y = xx.ravel(), yy.ravel()
    lon_n, lat_n = lon.ravel(), lat.ravel()
    GCP = np.empty([len(x), 4])
    GCP[:, 0], GCP[:, 1] = x, y
    GCP[:, 2], GCP[:, 3] = lon_n, lat_n
    GCP = GCP.tolist()
    return GCP, x_lim, y_lim
Exemplo n.º 4
0
def fq2_4circ(Q, pars):
    '''NOTE: This is slow.
        Compute the |Fourier transform|**2 of a quarter circle. This is an analytical
        calculation. It is assumed that not more than a 10 oscilations would
        be needed so circle is made to be 1/10th of image. 1000 x1000 pixels
        are used.
        The interpolation function's domain is in units of radians per pixel for a
        half circle at 100 pixels in radius.
    '''
    global F4Cinterp
    if (F4Cinterp is None):
        print(
            "F4 interpolation function empty, creating it for the first time..."
        )
        N = 1000
        X, Y = np.mgrid(N, N)
        QCimg = (sqrt(X**2 + Y**2) < 100**2).astype(int)
        FQC = fftshift(fft2(Qimg))
        X = (X - N / 2.) * 2 * np.pi / N
        Y = (Y - N / 2.) * 2 * np.pi / N
        F4Cinterp = RectBivariateSpline(X, Y, FQC)
    radius = pars['radius']
    Q = radius / 100. * Q
    F4c = F4Cinterp(Q[0], Q[1])
Exemplo n.º 5
0
# Triangulate based on X, Y with Delaunay 2D algorithm.
# Save resulting triangulation.
mesh = mlab.pipeline.delaunay2d(pts)

# Remove the point representation from the plot
pts.remove()

# Draw a surface based on the triangulation
surf = mlab.pipeline.surface(mesh)

# Simple plot.
mlab.xlabel("x")
mlab.ylabel("y")
mlab.zlabel("z")
mlab.show()





x, y, z = np.ogrid[-10:10:20j, -10:10:20j, -10:10:20j]
a = np.sin(x*y*z)/(x*y*z)
mlab.contour3d( a )
mlab.show()

bx = np.mgrid([0.,1.,2.,7.])
by = np.array([5.,4.,3.,8.])
bz = np.array([7.,8.,9.,3.])
b = np.vstack(np.meshgrid(bx,by,bz)).reshape(3,-1).T
#ax.plot3D(* x_axis_vec,c='r',marker=marker,markersize=10)
Exemplo n.º 6
0
import numpy as np
import scipy.integrate as int
import scipy.interpolate as ntp
import matplotlib.pyplot as plt

x = np.linspace(-5, 5, 1)
y = np.linspace(-5, 5, 1)

xx, yy = np.mgrid()

r = 3
h = 3


def func(x, y, r, h):
    return np.sqrt((x**2 + y**2) / (r / h))
Exemplo n.º 7
0
 def axis_x( self, n, nodal ):
     """ 1D array along axis n """
     return np.mgrid(self.axis_slice(n,nodal))