Exemple #1
0
 def fresnelSingleTransformFW(self,d) :
     i2 = Intensity2D(self.nx,self.startx,self.endx,
                      self.ny,self.starty,self.endy,
                      self.wl)
     u1p   = self.i*pl.exp(-1j*pl.pi/(d*self.wl)*(self.xgrid**2+self.ygrid**2))
     ftu1p = pl.fftshift(pl.fft2(pl.fftshift(u1p)))
     i2.i  = ftu1p*1j/(d*self.wl)*pl.exp(-1j*pl.pi/(d*self.wl)*(self.xgrid**2+self.ygrid**2))
     return i2
Exemple #2
0
 def fresnelSingleTransformFW(self, d):
     i2 = Intensity2D(self.nx, self.startx, self.endx, self.ny, self.starty,
                      self.endy, self.wl)
     u1p = self.i * pl.exp(-1j * pl.pi / (d * self.wl) *
                           (self.xgrid**2 + self.ygrid**2))
     ftu1p = pl.fftshift(pl.fft2(pl.fftshift(u1p)))
     i2.i = ftu1p * 1j / (d * self.wl) * pl.exp(
         -1j * pl.pi / (d * self.wl) * (self.xgrid**2 + self.ygrid**2))
     return i2
Exemple #3
0
def frc(image):
    from PYME.Analysis import binAvg
    import numpy as np
    import pylab

    voxelsize = image.voxelsize

    shape = image.data.shape[0:2]
    hwin = np.sqrt(np.outer(np.hanning(shape[0]), np.hanning(shape[1])))

    #assume we have exactly 2 channels #FIXME - add a selector
    #grab image data
    imA = hwin * image.data[:, :, :, 0].squeeze()
    imB = hwin * image.data[:, :, :, 1].squeeze()

    X, Y = np.mgrid[0:float(imA.shape[0]), 0:float(imA.shape[1])]
    X = X / X.shape[0]
    Y = Y / X.shape[1]
    X = X - .5
    Y = Y - .5
    R = np.sqrt(X**2 + Y**2)

    H1 = pylab.fft2(imA)
    H2 = pylab.fft2(imB)

    ringwidth = 1  # in pixels
    rB = np.linspace(0, 0.5, 0.5 * imA.shape[0] / ringwidth)

    bn, bm, bs = binSum(R, pylab.fftshift(H1 * H2.conjugate()), rB)

    bn1, bm1, bs1 = binSum(R, pylab.fftshift(abs(H1 * H1.conjugate())), rB)
    bn2, bm2, bs2 = binSum(R, pylab.fftshift(abs(H2 * H2.conjugate())), rB)

    bmr = np.real(bm)

    pylab.figure()

    ax = pylab.gca()

    freqpnm = rB / voxelsize[0]
    ax.plot(freqpnm[:-1], bmr / np.sqrt(bm1 * bm2))
    ax.plot(freqpnm[:-1], 2. / np.sqrt(bn / 2))
    ax.plot(freqpnm[:-1], 0 * bmr + 1.0 / 7)
    ax.plot(freqpnm[:-1], 0 * bmr, '--')

    xt = np.array([10., 15, 20, 30, 50, 80, 100, 150])
    rt = 1.0 / xt

    pylab.xticks(rt[::-1], ['%d' % xi for xi in xt[::-1]])

    pylab.show()

    return H1, H2, R, bmr / np.sqrt(bm1 * bm2), bn, bm, bm1, bm2, rB
Exemple #4
0
    def fresnelSingleTransformVW(self,d) :
        # compute new window
        x2 = self.nx*pl.absolute(d)*self.wl/(self.endx-self.startx)
        y2 = self.ny*pl.absolute(d)*self.wl/(self.endy-self.starty)

        # create new intensity object
        i2 = Intensity2D(self.nx,-x2/2,x2/2,
                         self.ny,-y2/2,y2/2,
                         self.wl)

        # compute intensity
        u1p   = self.i*pl.exp(-1j*pl.pi/(d*self.wl)*(self.xgrid**2+self.ygrid**2))
        ftu1p = pl.fftshift(pl.fft2(pl.fftshift(u1p)))
        i2.i  = ftu1p*1j/(d*i2.wl)*pl.exp(-1j*pl.pi/(d*i2.wl)*(i2.xgrid**2+i2.ygrid**2))
        return i2
Exemple #5
0
def Fraunhofer(i, z) :
    print "Propagation:Fraunhofer"
    ft = pl.fftshift(pl.fftn(pl.fftshift(i.i)))
    dx = i.wl*z/(i.nx*i.dx)
    dy = i.wl*z/(i.ny*i.dy)
    po = pl.exp(1j*2*pl.pi/i.wl*i.dx*i.dx)/(1j*i.wl*z)
    p = pl.arange(0,i.nx)-(i.nx+0.5)/2.0
    q = pl.arange(0,i.ny)-(i.ny+0.5)/2.0
    [pp,qq] = pl.meshgrid(p,q)
    pm = pl.exp(1j*pl.pi/(i.wl*z)*((pp*dx)**2+(qq*dy)**2))
    i2 = Intensity.Intensity2D(i.nx,-i.nx*dx/2,i.nx*dy/2,i.ny,-i.ny*dy/2,i.ny*dy/2)
    i2.i = po*pm*ft
    return i2
    
    print "Propagation:Fraunhofer>",dx,dy,i.nx*dx,i.ny*dy
Exemple #6
0
    def compute_response(self, **kargs):
        """Compute the window data frequency response

        :param norm: True by default. normalised the frequency data.
        :param int NFFT:       total length of the final data sets( 2048 by default. if less than data length, then 
            NFFT is set to the data length*2).
            
        The response is stored in :attr:`response`.
        
        .. note:: Units are dB (20 log10) since we plot the frequency response)
        
        
        """
        from pylab import fft, fftshift, log10

        norm = kargs.get('norm', self.norm)

        # do some padding. Default is max(2048, data.len*2)
        NFFT = kargs.get('NFFT', 2048)
        if NFFT < len(self.data):
            NFFT = self.data.size * 2

        # compute the fft modulus
        A = fft(self.data, NFFT)
        mag = abs(fftshift(A))

        # do we want to normalise the data
        if norm is True:
            mag = mag / max(mag)
        response = 20. * log10(mag)  # factor 20 we are looking at the response
        # not the powe
        #response = clip(response,mindB,100)
        self.__response = response
Exemple #7
0
    def compute_response(self, **kargs):
        """Compute the window data frequency response

        :param norm: True by default. normalised the frequency data.
        :param int NFFT:       total length of the final data sets( 2048 by default. if less than data length, then
            NFFT is set to the data length*2).

        The response is stored in :attr:`response`.

        .. note:: Units are dB (20 log10) since we plot the frequency response)


        """
        from pylab import fft, fftshift, log10

        norm = kargs.get('norm', self.norm)

        # do some padding. Default is max(2048, data.len*2)
        NFFT = kargs.get('NFFT', 2048)
        if NFFT < len(self.data):
            NFFT = self.data.size * 2

        # compute the fft modulus
        A = fft(self.data, NFFT)
        mag = abs(fftshift(A))

        # do we want to normalise the data
        if norm is True:
            mag = mag / max(mag)
        response = 20. * log10(mag) # factor 20 we are looking at the response
                                    # not the powe
        #response = clip(response,mindB,100)
        self.__response = response
Exemple #8
0
    def fresnelConvolutionTransform(self, d):
        # make intensity distribution
        i2 = Intensity2D(self.nx, self.startx, self.endx, self.ny, self.starty,
                         self.endy, self.wl)

        # FT on inital distribution
        u1ft = pl.fft2(self.i)

        # 2d convolution kernel
        k = 2 * pl.pi / i2.wl

        # make spatial frequency matrix
        maxsfx = 2 * pl.pi / self.dx
        maxsfy = 2 * pl.pi / self.dy

        dsfx = 2 * maxsfx / (self.nx)
        dsfy = 2 * maxsfy / (self.ny)

        self.sfx = pl.arange(-maxsfx / 2, maxsfx / 2 + 1e-15, dsfx / 2)
        self.sfy = pl.arange(-maxsfy / 2, maxsfy / 2 + 1e-15, dsfy / 2)

        [self.sfxgrid,
         self.sfygrid] = pl.fftshift(pl.meshgrid(self.sfx, self.sfy))

        # make convolution kernel
        kern = pl.exp(1j * d * (self.sfxgrid**2 + self.sfygrid**2) / (2 * k))

        # apply convolution kernel and invert
        i2.i = pl.ifft2(kern * u1ft)

        return i2
Exemple #9
0
    def fresnelSingleTransformVW(self, d):
        # compute new window
        x2 = self.nx * pl.absolute(d) * self.wl / (self.endx - self.startx)
        y2 = self.ny * pl.absolute(d) * self.wl / (self.endy - self.starty)

        # create new intensity object
        i2 = Intensity2D(self.nx, -x2 / 2, x2 / 2, self.ny, -y2 / 2, y2 / 2,
                         self.wl)

        # compute intensity
        u1p = self.i * pl.exp(-1j * pl.pi / (d * self.wl) *
                              (self.xgrid**2 + self.ygrid**2))
        ftu1p = pl.fftshift(pl.fft2(pl.fftshift(u1p)))
        i2.i = ftu1p * 1j / (d * i2.wl) * pl.exp(-1j * pl.pi / (d * i2.wl) *
                                                 (i2.xgrid**2 + i2.ygrid**2))
        return i2
Exemple #10
0
def Fraunhofer(i, z):
    print "Propagation:Fraunhofer"
    ft = pl.fftshift(pl.fftn(pl.fftshift(i.i)))
    dx = i.wl * z / (i.nx * i.dx)
    dy = i.wl * z / (i.ny * i.dy)
    po = pl.exp(1j * 2 * pl.pi / i.wl * i.dx * i.dx) / (1j * i.wl * z)
    p = pl.arange(0, i.nx) - (i.nx + 0.5) / 2.0
    q = pl.arange(0, i.ny) - (i.ny + 0.5) / 2.0
    [pp, qq] = pl.meshgrid(p, q)
    pm = pl.exp(1j * pl.pi / (i.wl * z) * ((pp * dx)**2 + (qq * dy)**2))
    i2 = Intensity.Intensity2D(i.nx, -i.nx * dx / 2, i.nx * dy / 2, i.ny,
                               -i.ny * dy / 2, i.ny * dy / 2)
    i2.i = po * pm * ft
    return i2

    print "Propagation:Fraunhofer>", dx, dy, i.nx * dx, i.ny * dy
Exemple #11
0
    def fresnelConvolutionTransform(self,d) :
        # make intensity distribution
        i2 = Intensity2D(self.nx,self.startx,self.endx,
                         self.ny,self.starty,self.endy,
                         self.wl)       

        # FT on inital distribution 
        u1ft = pl.fft2(self.i)

        # 2d convolution kernel
        k = 2*pl.pi/i2.wl
        
        # make spatial frequency matrix
        maxsfx = 2*pl.pi/self.dx
        maxsfy = 2*pl.pi/self.dy
        
        dsfx = 2*maxsfx/(self.nx)
        dsfy = 2*maxsfy/(self.ny)
        
        self.sfx = pl.arange(-maxsfx/2,maxsfx/2+1e-15,dsfx/2)
        self.sfy = pl.arange(-maxsfy/2,maxsfy/2+1e-15,dsfy/2)

        [self.sfxgrid, self.sfygrid] = pl.fftshift(pl.meshgrid(self.sfx,self.sfy))
                
        # make convolution kernel 
        kern = pl.exp(1j*d*(self.sfxgrid**2+self.sfygrid**2)/(2*k))
        
        # apply convolution kernel and invert
        i2.i = pl.ifft2(kern*u1ft) 

        return i2
Exemple #12
0
def _gen_bead_pupil(X, Y, beadsize):
    r2 = X*X + Y*Y

    dx = X[1, 0] - X[0, 0]
    
    bead_proj = np.sqrt(np.maximum(beadsize*beadsize - (r2 - dx*dx), 0))

    return abs(fftshift(fftn(bead_proj)))
Exemple #13
0
    def angularSpectrum(self, d):
        # make intensity distribution
        i2 = Intensity2D(self.nx, self.startx, self.endx, self.ny, self.starty,
                         self.endy, self.wl)

        # Angular spectrum (FT of input wavefield)
        a = pl.fft2(pl.fftshift(self.i))

        print a

        # 2d convolution kernel
        k = 2 * pl.pi / self.wl

        print k

        # make spatial frequency matrix
        maxsfx = 2 * pl.pi / self.dx
        maxsfy = 2 * pl.pi / self.dy

        print maxsfx, maxsfy

        dsfx = 2 * maxsfx / (self.nx)
        dsfy = 2 * maxsfy / (self.ny)

        self.sfx = pl.arange(-maxsfx / 2, maxsfx / 2 + 1e-15, dsfx / 2)
        self.sfy = pl.arange(-maxsfy / 2, maxsfy / 2 + 1e-15, dsfy / 2)

        print self.sfx
        print self.sfy

        [self.sfxgrid, self.sfygrid] = pl.meshgrid(self.sfx, self.sfy)

        # angular spectrum propagation kernel
        aspk = pl.fftshift(
            pl.exp(1j * d * pl.sqrt(k**2 -
                                    (self.sfxgrid**2 + self.sfygrid**2))))

        print "Angular spectrum propagation kernel"
        print aspk

        # apply angular spectrum propagation kernel and inverse Fourier transform
        i2.i = pl.fftshift(pl.ifft2(aspk * a))

        print i2.i
        return i2
Exemple #14
0
    def angularSpectrum(self,d) :
        # make intensity distribution
        i2 = Intensity2D(self.nx,self.startx,self.endx,
                         self.ny,self.starty,self.endy,
                         self.wl)       

        # Angular spectrum (FT of input wavefield)
        a = pl.fft2(pl.fftshift(self.i))
        
        print a

        # 2d convolution kernel
        k = 2*pl.pi/self.wl

        print k

        # make spatial frequency matrix
        maxsfx = 2*pl.pi/self.dx
        maxsfy = 2*pl.pi/self.dy

        print maxsfx,maxsfy
        
        dsfx = 2*maxsfx/(self.nx)
        dsfy = 2*maxsfy/(self.ny)
        
        self.sfx = pl.arange(-maxsfx/2,maxsfx/2+1e-15,dsfx/2)
        self.sfy = pl.arange(-maxsfy/2,maxsfy/2+1e-15,dsfy/2)

        print self.sfx
        print self.sfy

        [self.sfxgrid, self.sfygrid] = pl.meshgrid(self.sfx,self.sfy)

        # angular spectrum propagation kernel 
        aspk = pl.fftshift(pl.exp(1j*d*pl.sqrt(k**2 -(self.sfxgrid**2 + self.sfygrid**2))))

        print "Angular spectrum propagation kernel"
        print aspk

        # apply angular spectrum propagation kernel and inverse Fourier transform
        i2.i = pl.fftshift(pl.ifft2(aspk*a))
        
        print i2.i
        return i2
    def OnColoc(self, event):
        from PYME.Analysis import binAvg        
        voxelsize = self.image.voxelsize

        #assume we have exactly 2 channels #FIXME - add a selector
        #grab image data
        imA = self.image.data[:,:,:,0].squeeze()
        imB = self.image.data[:,:,:,1].squeeze()
        
        X, Y = np.mgrid[0:float(imA.shape[0]), 0:float(imA.shape[1])]
        X = X/X.shape[0]
        Y = Y/X.shape[1]
        X = X - .5
        Y = Y - .5
        R = np.sqrt(X**2 + Y**2)

        H1 = pylab.fftn(imA)
        H2 = pylab.fftn(imB)
        
        rB = np.linspace(0,R.max())
        
        bn, bm, bs = binAvg.binAvg(R, pylab.fftshift(abs(H1*H2)), rB)
        
        bn1, bm1, bs1 = binAvg.binAvg(R, pylab.fftshift(abs(H1*H1)), rB)
        bn2, bm2, bs2 = binAvg.binAvg(R, pylab.fftshift(abs(H2*H2)), rB)
       
       
        

        pylab.figure()
        
        ax = pylab.gca()
        
        ax.plot(rB[:-1], bm/np.sqrt(bm1*bm2))
        ax.plot(rB[:-1], 2./np.sqrt(bn/2))
        
        xt = np.array([10., 15, 20, 30, 50, 80, 100, 150])
        rt = voxelsize[0]/xt
        
        pylab.xticks(rt[::-1],['%d' % xi for xi in xt[::-1]])
        
        
        pylab.show()
Exemple #16
0
def abscorrel(a, b):
    from scipy.fftpack import fftn, ifftn
    from pylab import fftshift, ifftshift
    import numpy as np

    F0 = fftn(a)
    Fi = ifftn(b)
    corr = abs(fftshift(ifftn(F0 * Fi)))

    return corr
def plot_image(in_file, function, plot_mask, plot_log, plot_shifted):
    
    # try:
    #     #img = spimage.sp_image_read(in_file,0)
    image, mask = sphelper.import_spimage(in_file, ['image', 'mask'])
    # except:
    #     raise TypeError("Error: %s is not a readable .h5 file\n" % in_file)

    plot_flags = ['abs','mask','phase','real','imag']
    shift_flags = ['shift']
    log_flags = ['log']

    plot_flag = 0
    shift_flag = 0
    log_flag = 0

    colormap = "jet"
    if function == "phase":
        colormap = "hsv"

    if plot_shifted:
        #img = spimage.sp_image_shift(img)
        image = pylab.fftshift(image)
        mask = pylab.fftshift(mask)

    def no_log(x):
        return x

    if plot_log:
        log_function = pylab.log
    else:
        log_function = no_log

    if plot_mask:
        plot_input = mask
    else:
        plot_input = image
        
    function_dict = {"abs" : abs, "phase" : pylab.angle, "real" : pylab.real, "imag" : pylab.imag}
    
    pylab.imshow(log_function(function_dict[function](plot_input)), cmap=colormap, origin="lower", interpolation="nearest")
    pylab.show()
def FourierDerivative(f):
    """
    this derivatie just works for periodic 2*pi multiple series
    have to figure out how to make that work for any function
    """
    N = np.size(f)
    n = np.arange(0,N)
    # df discrete differential operator
    df = np.complex(0,1)*py.fftshift(n-N/2)
    dfdt = py.ifft( df*py.fft(f) )  
    return py.real(dfdt)
Exemple #19
0
def FourierDerivative(f):
    """
    this derivatie just works for periodic 2*pi multiple series
    have to figure out how to make that work for any function
    """
    N = np.size(f)
    n = np.arange(0, N)
    # df discrete differential operator
    df = np.complex(0, 1) * py.fftshift(n - N / 2)
    dfdt = py.ifft(df * py.fft(f))
    return py.real(dfdt)
Exemple #20
0
def test_plot(fpgaclient, bandwidth, snap_depth, dec_rate, n_inputs, signal_input, lof):
    """
	fpgaclient: 
	bandwidth: ADC working badnwidth
	snap_depth: depth of the snap blocks
	dec_rate: decimation rate
	n_inputs: number of simutaneous inputs (2^n)
	signal_input: known frequency of the test tone
	lof: lo frequency
    """
    data_dict = read_snaps(fpgaclient, snap_depth)

    pol1_re = data_dict['cic1_re']
    pol1_re = pol1_re[0::(dec_rate/(2**n_inputs))]
    x = []
    a = -bandwidth*1.0/dec_rate
    for i in range(size(pol1_re)):
        x.append(a)
        a = a + 2.0*(bandwidth/dec_rate)/size(pol1_re)
    pylab.ion()
    pylab.figure()

    pylab.subplot(231)
    pylab.title('ADC data')
    pylab.xlabel('N')
    pylab.plot(data_dict['adc1'][100:500], '-o')
    pylab.hold(False)
	
    pylab.subplot(232)
    pylab.title('mixer_data')
    pylab.plot(data_dict['s1_mixer'][100:200], '-o')
    pylab.hold(False)
        
    pylab.subplot(233)
    pylab.title('cic data')
    pylab.plot(pol1_re[100:200], '-o')
    pylab.hold(False)

    pol1_re_fft = fft(pol1_re)
    pylab.subplot(234)
    pylab.title('Mixed FFT,  Signal: '+str(signal_input)+'MHz,  LO: '+str(lof)+'MHz')
    pylab.xlabel('Frequency: MHz')
    pylab.semilogy(x,abs(pylab.fftshift((pol1_re_fft))))

    pylab.subplot(235)
    pylab.title('first cic data')
    pylab.plot(data_dict['s1_firstcic'][100:200], '-o')
    pylab.hold(False)

    pylab.subplot(236)
    pylab.title('halfband data')
    pylab.plot(data_dict['s1_halfband'][100:200], '-o')
    return pol1_re, x
    def handler(self, msg):
        # get input
        x = pmt.to_python(pmt.cdr(msg))
        meta = pmt.car(msg)
        samples = pmt.cdr(msg)

        # pass data
        self.curve_data[0] = (
            numpy.linspace(1, len(x), len(x)),
            10 * numpy.log10(numpy.abs(pylab.fftshift(numpy.fft.fft(x)))))

        # trigger update
        self.emit(QtCore.SIGNAL("updatePlot(int)"), 0)
Exemple #22
0
    def OnColoc(self, event):
        from PYME.Analysis import binAvg
        voxelsize = self.image.voxelsize

        #assume we have exactly 2 channels #FIXME - add a selector
        #grab image data
        imA = self.image.data[:, :, :, 0].squeeze()
        imB = self.image.data[:, :, :, 1].squeeze()

        X, Y = np.mgrid[0:float(imA.shape[0]), 0:float(imA.shape[1])]
        X = X / X.shape[0]
        Y = Y / X.shape[1]
        X = X - .5
        Y = Y - .5
        R = np.sqrt(X**2 + Y**2)

        H1 = pylab.fftn(imA)
        H2 = pylab.fftn(imB)

        rB = np.linspace(0, R.max())

        bn, bm, bs = binAvg.binAvg(R, pylab.fftshift(abs(H1 * H2)), rB)

        bn1, bm1, bs1 = binAvg.binAvg(R, pylab.fftshift(abs(H1 * H1)), rB)
        bn2, bm2, bs2 = binAvg.binAvg(R, pylab.fftshift(abs(H2 * H2)), rB)

        pylab.figure()

        ax = pylab.gca()

        ax.plot(rB[:-1], bm / np.sqrt(bm1 * bm2))
        ax.plot(rB[:-1], 2. / np.sqrt(bn / 2))

        xt = np.array([10., 15, 20, 30, 50, 80, 100, 150])
        rt = voxelsize[0] / xt

        pylab.xticks(rt[::-1], ['%d' % xi for xi in xt[::-1]])

        pylab.show()
Exemple #23
0
    def OnCheckSpacing(self, event):
        voxx = 0.07
        voxy = 0.07

        im = self.scope.frameWrangler.currentFrame
        F = (abs(pylab.fftshift(pylab.fftn(im - im.mean()))) + 1e-2).squeeze()

        currVoxelSizeID = self.scope.settingsDB.execute(
            "SELECT sizeID FROM VoxelSizeHistory ORDER BY time DESC").fetchone(
            )
        if not currVoxelSizeID is None:
            voxx, voxy = self.scope.settingsDB.execute(
                "SELECT x,y FROM VoxelSizes WHERE ID=?",
                currVoxelSizeID).fetchone()

        pylab.figure(2)
        pylab.clf()

        xd = F.shape[0] / 2.
        yd = F.shape[1] / 2.

        cd = xd * 2 * voxx / 5
        #kill central spike
        F[(xd - cd):(xd + cd), (yd - cd):(yd + cd)] = F.mean()
        pylab.imshow(F.T, interpolation='nearest', cmap=cm.hot)

        xd = F.shape[0] / 2.
        yd = F.shape[1] / 2.

        pylab.plot(
            xd + (xd * 2 * voxx / 1.8) * np.cos(np.arange(0, 2.1 * np.pi, .1)),
            yd + (xd * 2 * voxx / 1.8) * np.sin(np.arange(0, 2.1 * np.pi, .1)),
            lw=2,
            label='$1.8 {\mu}m$')
        pylab.plot(
            xd + (xd * 2 * voxx / 2.) * np.cos(np.arange(0, 2.1 * np.pi, .1)),
            yd + (xd * 2 * voxx / 2.) * np.sin(np.arange(0, 2.1 * np.pi, .1)),
            lw=1,
            label='$2 {\mu}m$')
        pylab.plot(
            xd + (xd * 2 * voxx / 1.6) * np.cos(np.arange(0, 2.1 * np.pi, .1)),
            yd + (xd * 2 * voxx / 1.6) * np.sin(np.arange(0, 2.1 * np.pi, .1)),
            lw=1,
            label='$1.6 {\mu}m$')

        pylab.xlim(xd - xd * 2 * voxx / 1, xd + xd * 2 * voxx / 1)
        pylab.ylim(yd - xd * 2 * voxx / 1, yd + xd * 2 * voxx / 1)
        pylab.legend()

        self.F = F
Exemple #24
0
    def OnCorrelate(self, event):
        from scipy.fftpack import fftn, ifftn
        from pylab import fftshift, ifftshift
        import numpy as np
        #ch0 = self.image.data[:,:,:,0]
        chanList = self.image.data.dataList

        for i in range(len(self.rbs)):
            if self.rbs[i].GetValue():
                ch0 = self.image.data[:, :, :, i]

        ch0 = np.maximum(ch0 - ch0.mean(), 0)

        F0 = fftn(ch0)

        for i in range(self.image.data.shape[3]):
            if not self.rbs[i].GetValue():
                ch0 = self.image.data[:, :, :, i]
                ch0 = np.maximum(ch0 - ch0.mean(), 0)
                Fi = ifftn(ch0)

                corr = abs(fftshift(ifftn(F0 * Fi)))

                corr -= corr.min()

                corr = np.maximum(corr - corr.max() * .75, 0)

                xi, yi, zi = np.where(corr)

                corr_s = corr[corr > 0]
                corr_s /= corr_s.sum()

                dxi = ((xi * corr_s).sum() -
                       corr.shape[0] / 2.) * chanList[i].voxelsize[0]
                dyi = ((yi * corr_s).sum() -
                       corr.shape[1] / 2.) * chanList[i].voxelsize[1]
                dzi = ((zi * corr_s).sum() -
                       corr.shape[2] / 2.) * chanList[i].voxelsize[2]

                self.xctls[i].SetValue(str(int(dxi)))
                self.yctls[i].SetValue(str(int(dyi)))
                self.zctls[i].SetValue(str(int(dzi)))

        self.OnApply(None)
Exemple #25
0
    def propagate(self, F, z):
        """ Propagate a complex pupil, F,  a distance z from the nominal focus and return the electric field amplitude
        
        Parameters
        ==========
        
        F : 2D array
            complex pupil
            
        z : float
            distance in nm to propagate
        
        """
        pf = self.propFac*float(z)
        fs = F*self.pfm*(np.cos(pf) + j*np.sin(pf))
        self._F[:] = ifftshift(fs)

        self._plan_F_f()
        return fftshift(self._f/np.sqrt(self._f.size))
Exemple #26
0
    def OnCorrelate(self, event):
        from scipy.fftpack import fftn, ifftn
        from pylab import fftshift, ifftshift
        import numpy as np

        # ch0 = self.image.data[:,:,:,0]
        chanList = self.image.data.dataList

        for i in range(len(self.rbs)):
            if self.rbs[i].GetValue():
                ch0 = self.image.data[:, :, :, i]

        ch0 = np.maximum(ch0 - ch0.mean(), 0)

        F0 = fftn(ch0)

        for i in range(self.image.data.shape[3]):
            if not self.rbs[i].GetValue():
                ch0 = self.image.data[:, :, :, i]
                ch0 = np.maximum(ch0 - ch0.mean(), 0)
                Fi = ifftn(ch0)

                corr = abs(fftshift(ifftn(F0 * Fi)))

                corr -= corr.min()

                corr = np.maximum(corr - corr.max() * 0.75, 0)

                xi, yi, zi = np.where(corr)

                corr_s = corr[corr > 0]
                corr_s /= corr_s.sum()

                dxi = ((xi * corr_s).sum() - corr.shape[0] / 2.0) * chanList[i].voxelsize[0]
                dyi = ((yi * corr_s).sum() - corr.shape[1] / 2.0) * chanList[i].voxelsize[1]
                dzi = ((zi * corr_s).sum() - corr.shape[2] / 2.0) * chanList[i].voxelsize[2]

                self.xctls[i].SetValue(str(int(dxi)))
                self.yctls[i].SetValue(str(int(dyi)))
                self.zctls[i].SetValue(str(int(dzi)))

        self.OnApply(None)
Exemple #27
0
    def propagate_r(self, f, z):
        """
        Backpropagate an electric field distribution, f, at defocus z to the nominal focus and return the complex pupil
        
        Parameters
        ----------
        f : 2D array
            complex electric field amplitude
        z : float
            nominal distance of plane from focus in nm

        Returns
        -------

        """
        self._f[:] = fftshift(f)
        self._plan_f_F()
        
        pf = -self.propFac*float(z)
        return (ifftshift(self._F)*(np.cos(pf)+j*np.sin(pf)))/np.sqrt(self._f.size)
Exemple #28
0
    def propagate(self, F, z):
        """
        Propagate a complex pupil, F,  a distance z from the nominal focus and return the electric field amplitude

        Parameters
        ==========

        F : 2D array
            complex pupil

        z : float
            distance in nm to propagate

        """
        pf = self.propFac*float(z)
        r = max(self.appR*(1 -self.apertureZGrad*z), 0)
        
        M = (self.x*self.x + self.y*self.y) < (r*r)
        fs = F*M*self.pfm*(np.cos(pf) + j*np.sin(pf))
        self._F[:] = fftshift(fs)

        self._plan_F_f()
        
        return ifftshift(self._f/np.sqrt(self._f.size))
T     = arange(0.0,float(N),1.0)
MyPi  = 3.1416

xReal    = cos(2.0*MyPi*f0MHz*T/fsMHz);
xRealmul = cos(2.0*MyPi*f0MHz*T/fsMHz)*cos(2.0*MyPi*f0MHzmul*T/fsMHz)
xComplex = exp(1j*2.0*MyPi*f0MHz*T/fsMHz);
xComplexneg = exp(-1j*2.0*MyPi*f0MHz*T/fsMHz);

xRealF   = (1.0/N)*fft(xReal,N); 
xRealFmul= (1.0/N)*fft(xRealmul,N);
xComplexF = (1.0/N)*fft(xComplex,N); 
xComplexFneg = (1.0/N)*fft(xComplexneg,N); 

Tplot = arange(-N/2.0,N/2.0,1)
subplot(5,1,1)
plot(Tplot*fsMHz/N,(fftshift(abs(xRealF))));
subplot(5,1,2)
plot(Tplot*fsMHz/N,(fftshift(abs(xComplexF))));
subplot(5,1,3)
plot(Tplot*fsMHz/N,(fftshift(abs(xComplexFneg))));
subplot(5,1,4)
plot(Tplot*fsMHz/N,(fftshift(abs(xRealFmul))));
show()

f=open('output.txt','w')
file_output.comple_w(f, xReal, 'xReal')
file_output.comple_w(f, xComplex, 'xComplex')
file_output.comple_w(f, xRealF, 'xRealF')
file_output.comple_w(f, xComplexF, 'xComplexF')
f.close()
Exemple #30
0
#get the gaussian kernel
w = 100
h = 100

in_mask = np.zeros((h, w), dtype=np.float32)
in_mask[int(h / 2), int(w / 2)] = 1
img_kernel = ndimage.gaussian_laplace(in_mask, sigma=2)
#
kernel = img_kernel[50 - 10:50 + 10, 50 - 10:50 + 10]
kernel_ft = fftpack.fft2(kernel, shape=img.shape[:2], axes=(0, 1))

#manual pad zeros, same results.
kernel_pad = np.zeros_like(img, dtype='float')
kh, kw = kernel.shape[:2]
kernel_pad[:kh, :kw] = kernel
kernel_pad_ft = fftpack.fft2(kernel_pad, axes=(0, 1))
fig1, axs = plt.subplots(1, 3)
axs[0].imshow(np.abs(pylab.fftshift(kernel_ft)))
axs[1].imshow(np.abs(pylab.fftshift(kernel_pad_ft)))
axs[2].imshow(np.abs(kernel_pad_ft - kernel_ft))

# convolve
img_ft = fftpack.fft2(img, axes=(0, 1))
img2_ft = kernel_ft * img_ft
img2 = fftpack.ifft2(img2_ft, axes=(0, 1)).real
img2 = (img2 - np.min(img2)) / (np.max(img2) - np.min(img2))

axes[2].imshow(img2, cmap='gray')
axes[2].set_title('blur via Gaussian filter')
plt.show()
Exemple #31
0
MyPi  = pi
ModRatio = 0.5

xInput = cos(2.0*MyPi*finput*T/fsmod)
xCarrier = cos(2.0*MyPi*fcarr*T/fsmod)
xMod = (xInput * ModRatio + 1) * xCarrier

xInputF = (1.0/N)*fft(xInput,N); 
xCarrierF = (1.0/N)*fft(xCarrier,N);
xModF = (1.0/N)*fft(xMod,N); 
#xComplexFneg = (1.0/N)*fft(xComplexneg,N); 

Tplot = arange(-N/2.0,N/2.0,1)
pic_n=5
subplot(pic_n,1,1)
plot(Tplot*fsmod/N,(fftshift(abs(xModF))));
subplot(pic_n,1,2)
plot(Tplot*fsmod/N,(fftshift(abs(xCarrierF))));
subplot(pic_n,1,3)
plot(T,xInput);
subplot(pic_n,1,4)
plot(T,xMod);
subplot(pic_n,1,5)
plot(T,xCarrier);
#subplot(5,1,4)
#plot(Tplot*fsMHz/N,(fftshift(abs(xRealFmul))));
show()

#f=open('output.txt','w')
#file_output.comple_w(f, xReal, 'xReal')
#file_output.comple_w(f, xComplex, 'xComplex')
Exemple #32
0
            measureData[i, :] = analyzeSignal1
        T1 = T1 / M
        print('T1 = ', T1)
        Vres = c0 / (2 * f0 * T1 * M * Mpad)

        for ii in range(M):
            sigRWin[ii, :] = measureData[ii, :] * windowFunction1

        for ii in range(M):
            sigRfft[ii, :] = fft(sigRWin[ii, :], N * Npad)

        for ii in range(N * Npad):
            sigDWin[:, ii] = sigRfft[:, ii] * windowFunction2

        for ii in range(N * Npad):
            sigDfft[:, ii] = fftshift(fft(sigDWin[:, ii], M * Mpad))
        '''
        plt.figure(1)
        plt.contourf(Rres*np.arange(1,N*Npad+1),Vres*(np.arange(1,M*Mpad+1) - M*Mpad/2),np.abs(sigDfft))
        plt.xlabel('Range/m')
        plt.ylabel('Velocity/mps')
        plt.pause(0.000001)
        plt.cla()
        '''
        '''
        np.savetxt('./Rres/Rres'+str(j)+'.txt',Rres*np.arange(1,N*Npad+1))
        np.savetxt('./Vres/Vres'+str(j)+'.txt',Vres*(np.arange(1,M*Mpad+1) - M*Mpad/2))
        np.savetxt('./sigDfft/sigDfft'+str(j)+'.txt',np.abs(sigDfft))
        '''

        plt.figure(1)
Exemple #33
0
sigReceive = S1 + S2 + S3
sigRWin = np.zeros((L, N), dtype=complex)
sigDWin = np.zeros((L, N * Npad), dtype=complex)
sigRfft = np.zeros((L, N * Npad), dtype=complex)
sigDfft = np.zeros((L * Lpad, N * Npad), dtype=complex)

windowFunction1 = np.hanning(N)  # windowFunction
windowFunction2 = np.hanning(L)  # windowFunction

for ii in range(L):
    sigRWin[ii, :] = sigReceive[ii, :] * windowFunction1

for ii in range(L):
    sigRfft[ii, :] = fft(sigRWin[ii, :], N * Npad)

for ii in range(N * Npad):
    sigDWin[:, ii] = sigRfft[:, ii] * windowFunction2

for ii in range(N * Npad):
    sigDfft[:, ii] = fftshift(fft(sigDWin[:, ii], L * Lpad))

Rres = c / (2 * B * Npad)
Vres = c / (2 * 24.25 * 10**9 * T * L * Lpad)
plt.contourf(Rres * np.arange(1, N * Npad + 1),
             Vres * (np.arange(1, L * Lpad + 1) - L * Lpad / 2),
             np.abs(sigDfft))
plt.xlabel('Range/m')
plt.ylabel('Velocity/mps')
plt.title('Range-Doppler Map')
plt.minorticks_on()
plt.show()
Exemple #34
0
MyPi = pi
ModRatio = 0.5

xInput = cos(2.0 * MyPi * finput * T / fsmod)
xCarrier = cos(2.0 * MyPi * fcarr * T / fsmod)
xMod = (xInput * ModRatio + 1) * xCarrier

xInputF = (1.0 / N) * fft(xInput, N)
xCarrierF = (1.0 / N) * fft(xCarrier, N)
xModF = (1.0 / N) * fft(xMod, N)
#xComplexFneg = (1.0/N)*fft(xComplexneg,N);

Tplot = arange(-N / 2.0, N / 2.0, 1)
pic_n = 5
subplot(pic_n, 1, 1)
plot(Tplot * fsmod / N, (fftshift(abs(xModF))))
subplot(pic_n, 1, 2)
plot(Tplot * fsmod / N, (fftshift(abs(xCarrierF))))
subplot(pic_n, 1, 3)
plot(T, xInput)
subplot(pic_n, 1, 4)
plot(T, xMod)
subplot(pic_n, 1, 5)
plot(T, xCarrier)
#subplot(5,1,4)
#plot(Tplot*fsMHz/N,(fftshift(abs(xRealFmul))));
show()

#f=open('output.txt','w')
#file_output.comple_w(f, xReal, 'xReal')
#file_output.comple_w(f, xComplex, 'xComplex')
Exemple #35
0
        pylab.plot(mixer_data[100:200], '-o')
	#pylab.semilogy(abs(fft(mixer_data)))
	pylab.hold(False)

        pylab.subplot(223)
        pylab.title('Available LO frequencies')
        pylab.ylabel('MHz')
        #pylab.plot(lof_avail,'-o')
	pylab.plot(pol1_re[100:200], '-o')
        pylab.hold(False)

        pol1_re_fft = fft(pol1_re)
        pylab.subplot(224)
        pylab.title('Mixed FFT,  Signal: '+str(signal_input)+'MHz,  LO: '+str(lof_output)+'MHz')
        pylab.xlabel('Frequency: MHz')
        pylab.semilogy(x,abs(pylab.fftshift((pol1_re_fft))))

        pylab.hold(False)
        pylab.draw()

        pol1_re = read_snaps(snap_depth)
	pol1_re = pol1_re[0::(dec_rate/8)]

        time.sleep(2)

    #cic1_data, hb_data, cic2_data = read_cic_snaps(fpga, dec_rate, snap_depth)
    #pylab.figure()
    #pylab.subplot(221)
    #pylab.semilogy(abs(pylab.fftshift(fft(cic1_data[0:1024]))))
    #pylab.title('FFT of the output of CIC_1')
    #pylab.subplot(222)
Exemple #36
0
def correction_light(I, method, show_light, mask=None):
    """Corrige la derive eclairement

    :I: array_like ou iplimage
    :method: 'polynomial' or 'frequency'
    :show_light: option affiche correction (true|false)
    :mask: array de zone non interet
    :returns: iplimage 32bit

    """
    from progress import *
    import Tkinter
    if type(I) == cv.iplimage:
        if I.nChannels == 3:
            if method == 'None':
                I = RGB2L(I)
                I = cv2array(I)[:, :, 0]
                I = pymorph.hmin(I, 15, pymorph.sedisk(3))
                I = array2cv(I)
                cv.EqualizeHist(I, I)
                return I
            I = RGB2L(I)
            I_32bit = cv.CreateImage(cv.GetSize(I), cv.IPL_DEPTH_32F, 1)
            cv.ConvertScale(I, I_32bit, 3000.0, 0.0)
            I = cv.CloneImage(I_32bit)
        I = cv2array(I)[:, :, 0]
    elif len(I.shape) == 3:
        I = (I[:, :, 0] + I[:, :, 0] + I[:, :, 0])\
            / 3.0  # A modifier: non utiliser dans notre cas
    elif method == 'None':
        I = array2cv(I)
        cv.EqualizeHist(I, I)
        return I

    I = np.log(I + 10 ** (-6))
    (H, W) = np.shape(I)
    I_out = I * 0 + 10 ** (-6)
    if method == 'polynomial':
        ## I = M.A avec A coeff. du polynome
        I_flat = I.flatten()
        degree = 3
        print("modification degree 3")
        #degree du polynome
        nb_coeff = (degree + 1) * (degree + 2) / 2  # nombre coefficient
        [yy, xx] = np.meshgrid(np.arange(W, dtype=np.float64),
                               np.arange(H, dtype=np.float64))
        if mask is not None:
            xx[mask] = 0
            yy[mask] = 0
        # Creation de M
        try:
            M = np.zeros((H * W, nb_coeff), dtype=np.float64)
        except MemoryError:
            print MemoryError
            return MemoryError
        i, j = 0, 0  # i,j degree de x,y
        #Bar progression
        bar = Tkinter.Tk(className='Correcting Light...')
        m = Meter(bar, relief='ridge', bd=3)
        m.pack(fill='x')
        m.set(0.0, 'Starting correction...')
        for col in np.arange(nb_coeff):
            M[:, col] = (xx.flatten() ** i) * (yy.flatten() ** j)
            i += 1
            m.set(0.5 * float(col) / (nb_coeff - 1))
            if i + j == degree + 1:
                i = 0
                j += 1

        # Resolution au sens des moindres carree: pseudo-inverse
        try:
            M = pl.pinv(M)
            A = np.dot(M, I_flat)
        except ValueError:
            return ValueError
        # Calcul de la surface
        i, j = 0, 0
        surface = np.zeros((H, W), dtype=np.float64)
        for cmpt in np.arange(nb_coeff):
            surface += A[cmpt] * (xx ** i) * (yy ** j)  # forme quadratique
            i += 1
            m.set(0.5 + 0.5 * float(cmpt) / (nb_coeff - 1))
            if i + j == degree + 1:
                i = 0
                j += 1
        bar.destroy()
        I_out = np.exp(I / surface)
        light = surface
    elif method == 'frequency':
        Rx, Ry = 2, 2
        # zero padding
        N = [H, W]
        filtre = np.zeros((N[1], N[0]))
        centre_x = round(N[0] / 2)
        centre_y = round(N[1] / 2)
        print("FFT2D...")
        I_fourier = pl.fftshift(pl.fft2(I, N))

        # Gaussian filter
        [xx, yy] = np.meshgrid(np.arange(N[0], dtype=np.float),
                               np.arange(N[1], dtype=np.float))
        filtre = np.exp(-2 * ((xx - centre_x) ** 2 + (yy - centre_y) ** 2) /
                        (Rx ** 2 + Ry ** 2))
        filtre = pl.transpose(filtre)
        I_fourier = I_fourier * filtre
        print("IFFT2D...")
        I_out = (np.abs(pl.ifft2(pl.ifftshift(I_fourier), N)))[0:H, 0:W]
        light = I_out
        I_out = np.exp(I / I_out)
    else:
        light = I * 0
        I_out = I
    # Display Light
    if show_light:
        light = ((light - light.min()) * 3000.0 /
                 light.max()).astype('float32')
        light = array2cv(light)
        fig = pl.figure()
        pl.imshow(light)
        fig.show()

    I_out = (I_out - I_out.min()) * 3000.0 / I_out.max()
    I_out = I_out.astype('uint8')

    #chapeau haut de forme
    I_out = pymorph.hmin(I_out, 25, pymorph.sedisk(3))
    #Conversion en iplimage et ajustement contraste
    gr = array2cv(I_out)
    cv.EqualizeHist(gr, gr)
    return gr
MyPi = 3.1416

xReal = cos(2.0 * MyPi * f0MHz * T / fsMHz)
xRealmul = cos(2.0 * MyPi * f0MHz * T / fsMHz) * cos(
    2.0 * MyPi * f0MHzmul * T / fsMHz)
xComplex = exp(1j * 2.0 * MyPi * f0MHz * T / fsMHz)
xComplexneg = exp(-1j * 2.0 * MyPi * f0MHz * T / fsMHz)

xRealF = (1.0 / N) * fft(xReal, N)
xRealFmul = (1.0 / N) * fft(xRealmul, N)
xComplexF = (1.0 / N) * fft(xComplex, N)
xComplexFneg = (1.0 / N) * fft(xComplexneg, N)

Tplot = arange(-N / 2.0, N / 2.0, 1)
subplot(5, 1, 1)
plot(Tplot * fsMHz / N, (fftshift(abs(xRealF))))
subplot(5, 1, 2)
plot(Tplot * fsMHz / N, (fftshift(abs(xComplexF))))
subplot(5, 1, 3)
plot(Tplot * fsMHz / N, (fftshift(abs(xComplexFneg))))
subplot(5, 1, 4)
plot(Tplot * fsMHz / N, (fftshift(abs(xRealFmul))))
show()

f = open('output.txt', 'w')
file_output.comple_w(f, xReal, 'xReal')
file_output.comple_w(f, xComplex, 'xComplex')
file_output.comple_w(f, xRealF, 'xRealF')
file_output.comple_w(f, xComplexF, 'xComplexF')
f.close()
Exemple #38
0
    def handler(self, msg):
        # get input
        x = pmt.to_python(pmt.cdr(msg))
        meta = pmt.car(msg);
        samples = pmt.cdr(msg);
        
        # pass data
        self.curve_data[0] = (numpy.linspace(1,len(x),len(x)), 10*numpy.log10(numpy.abs(pylab.fftshift(numpy.fft.fft(x)))));

        # trigger update
        self.emit(QtCore.SIGNAL("updatePlot(int)"), 0)