Ejemplo n.º 1
0
    def processImage(self, imgdata, filtarray):
        #Ignore array filter
        array = imgdata['image']
        imgmax = self.params['max']
        imgmin = self.params['min']

        outfile = os.path.join(self.params['rundir'], imgdata['filename'])
        if self.params['fft'] is True:
            outfile += ".fft"
        outfile += ".jpg"
        if imgmin > imgmax:
            imgmax = array.max()
            imgmin = array.min()
        shape = array.shape
        maxdim = max(shape)
        if self.params['fft'] is True:
            ## fft's are binned by 2
            array = imagefun.bin(array, 2)
            array = imagefun.power(array)
            maxdim /= 2
        bin = int(math.ceil(float(maxdim / self.params['imgsize'])))
        array = imagefun.bin(array, bin)
        jpg.write(array,
                  outfile,
                  min=imgmin,
                  max=imgmax,
                  quality=self.params['quality'],
                  stdval=self.params['stdval'])
        def manualCheckLoop(self, presetname=None, emtarget=None):
                ## copied and simplified from focuser.py
                ## go to preset and target
                self.logger.info('Starting manual focus loop, please confirm defocus...')
                self.beep()
                camdata1 = {}

                # configure camera using settings, but only 512x512 to save time
                origcam = self.settings['camera settings']
                camdata1 = self.makeCenterImageCamSettings(origcam)
                camdata1['exposure time']=self.focexptime
                self.instrument.ccdcamera.Settings = camdata1
                pixelsize,center = self.getReciprocalPixelSizeFromInstrument()
                self.ht = self.instrument.tem.HighTension
                self.panel.onNewPixelSize(pixelsize,center,self.ht)
                self.manualplayer.play()
                self.onManualCheck()
                while True:
                        t0 = time.time()
                        state = self.manualplayer.state()
                        if state == 'stop':
                                break
                        elif state == 'pause':
                                if self.manualplayer.wait() == 'stop':
                                        break
                        # acquire image, show image and power spectrum
                        # allow user to adjust defocus and stig
                        correction = self.settings['correct image']
                        camdata1['exposure time'] = self.focexptime
                        
                        self.manualchecklock.acquire()
                        self.instrument.ccdcamera.Settings = camdata1
                        try:
                                if correction:
                                        imagedata = self.acquireCorrectedCameraImageData()
                                else:
                                        imagedata = self.acquireCameraImageData()
                                imarray = imagedata['image']
                        except:
                                raise
                                self.manualchecklock.release()
                                self.manualplayer.pause()
                                self.logger.error('Failed to acquire image, pausing...')
                                continue
                        
                        self.manualchecklock.release()
                        pow = imagefun.power(imarray, self.maskradius)
                        man_power = pow.astype(numpy.float32)
                        self.man_power = numpy.clip(man_power,self.powmin,self.powmax)
                        self.man_image = imarray.astype(numpy.float32)
                        self.panel.setManualImage(self.man_image, 'Image')
                        self.panel.setManualImage(self.man_power, 'Power')

                        #sleep if too fast in simulation
                        t1 = time.time()
                        if t1-t0 < 0.5:
                                time.sleep(0.5-(t1-t0))
                                
                self.onManualCheckDone()
                self.logger.info('Manual focus check completed')
    def processImage(self, imgdata):
        stackedname = os.path.join(self.params['rundir'],
                                   imgdata['filename'] + "power.jpg")

        if os.path.isfile(stackedname) and apFile.fileSize(stackedname) > 100:
            return

        ### make the power spectra
        powerspectra = imagefun.power(imgdata['image'],
                                      mask_radius=1.0,
                                      thresh=4)
        binpowerspectra = imagefun.bin2(powerspectra, self.params['bin'])
        del powerspectra
        if self.params['hp'] is True:
            binpowerspectra = apImage.fermiHighPassFilter(binpowerspectra,
                                                          apix=4.0,
                                                          radius=2000.0)
        binpowerspectra = apImage.normStdevMed(binpowerspectra, size=5)
        binpowerspectra = apImage.pixelLimitFilter(binpowerspectra, pixlimit=4)
        binpowerspectra = apImage.normRange(binpowerspectra)

        ### filter the image
        imagedata = imagefun.bin2(imgdata['image'], self.params['bin'])
        del imgdata['image']
        imagedata = apImage.normStdevMed(imagedata, size=5)
        imagedata = apImage.pixelLimitFilter(imagedata, pixlimit=2)
        imagedata = apImage.normRange(imagedata)

        ### write to file
        stacked = numpy.hstack([imagedata, binpowerspectra])
        del imagedata, binpowerspectra
        apImage.arrayToJpeg(stacked, stackedname)
 def binAndAddCTFlabel(self, image, ht, rpixelsize, binning=1, defocus=None):
         pow = imagefun.power(image)
         binned = imagefun.bin(pow, binning)
         # No ctf estimation until it works better so that this node does not
         # depend on coma beam-tilt calibration
         s = None
         ctfdata = None
         '''
         try:
                 ctfdata = fftfun.fitFirstCTFNode(pow,rpixelsize['x'], defocus, ht)
         except Exception, e:
                 self.logger.error("ctf fitting failed: %s" % e)
                 ctfdata = None
         if ctfdata:
                 self.logger.info('z0 %.3f um, zast %.3f um (%.0f ), angle= %.1f deg' % (ctfdata[0]*1e6,ctfdata[1]*1e6,ctfdata[2]*100, ctfdata[3]*180.0/math.pi))
                 s = '%d' % int(ctfdata[0]*1e9)
         #elif self.ace2exe:
         elif False:
                 ctfdata = self.estimateCTF(imagedata)
                 z0 = (ctfdata['defocus1'] + ctfdata['defocus2']) / 2
                 s = '%d' % (int(z0*1e9),)
         '''
         if s:
                 t = numpil.textArray(s)
                 t = ndimage.zoom(t, (min(binned.shape)-40.0)*0.08/(t.shape)[0])
                 minvalue = arraystats.min(binned)
                 maxvalue = arraystats.max(binned)
                 t = minvalue + t * (maxvalue-minvalue)
                 imagefun.pasteInto(t, binned, (20,20))
         return binned, ctfdata
	def processImage(self, imgdata):
		stackedname = os.path.join(self.params['rundir'], imgdata['filename']+"power.jpg")

		if os.path.isfile(stackedname) and apFile.fileSize(stackedname) > 100:
			return

		### make the power spectra
		powerspectra = imagefun.power(imgdata['image'], mask_radius=1.0, thresh=4)
		binpowerspectra = imagefun.bin2(powerspectra, self.params['bin'])
		del powerspectra
		if self.params['hp'] is True:
			binpowerspectra = apImage.fermiHighPassFilter(binpowerspectra, apix=4.0, radius=2000.0)
		binpowerspectra = apImage.normStdevMed(binpowerspectra, size=5) 
		binpowerspectra = apImage.pixelLimitFilter(binpowerspectra, pixlimit=4)
		binpowerspectra = apImage.normRange(binpowerspectra)

		### filter the image
		imagedata = imagefun.bin2(imgdata['image'], self.params['bin'])
		del imgdata['image']
		imagedata = apImage.normStdevMed(imagedata, size=5) 
		imagedata = apImage.pixelLimitFilter(imagedata, pixlimit=2)
		imagedata = apImage.normRange(imagedata)

		### write to file
		stacked = numpy.hstack([imagedata, binpowerspectra])
		del imagedata, binpowerspectra
		apImage.arrayToJpeg(stacked, stackedname)
Ejemplo n.º 6
0
	def addCTFlabel(self, image, ht, rpixelsize, binning=1, defocus=None):
		pow = imagefun.power(image)
		binned = imagefun.bin(pow, binning)
		s = None
		try:
			ctfdata = fftfun.fitFirstCTFNode(pow,rpixelsize['x'], defocus, ht)
		except Exception, e:
			self.logger.error("ctf fitting failed: %s" % e)
			ctfdata = None
Ejemplo n.º 7
0
def splitTableau(image, split):
	tabimage = numpy.zeros(image.shape, image.dtype)
	splitsize = int(math.floor(image.shape[0]*0.5/int(split)))*2, int(math.floor(image.shape[1]*0.5/int(split)))*2
	for row in range(0,image.shape[0],splitsize[0]):
		rowslice = slice(row,row+splitsize[0])
		for col in range(0,image.shape[1],splitsize[1]):
			colslice = slice(col,col+splitsize[1])
			if col+splitsize[1] <= image.shape[1] and row+splitsize[0] <= image.shape[0]:
				tabimage[rowslice,colslice] = imagefun.power(image[rowslice,colslice])
			else:
				tabimage[rowslice,colslice] = tabimage[max(0,row-1),max(0,col-1)]
	return tabimage
def splitTableau(image, split):
        tabimage = numpy.zeros(image.shape, image.dtype)
        splitsize = int(math.floor(image.shape[0]*0.5/int(split)))*2, int(math.floor(image.shape[1]*0.5/int(split)))*2
        for row in range(0,image.shape[0],splitsize[0]):
                rowslice = slice(row,row+splitsize[0])
                for col in range(0,image.shape[1],splitsize[1]):
                        colslice = slice(col,col+splitsize[1])
                        if col+splitsize[1] <= image.shape[1] and row+splitsize[0] <= image.shape[0]:
                                tabimage[rowslice,colslice] = imagefun.power(image[rowslice,colslice])
                        else:
                                tabimage[rowslice,colslice] = tabimage[max(0,row-1),max(0,col-1)]
        return tabimage
Ejemplo n.º 9
0
 def calculatePowerImage(self, imagedata):
     imarray = imagedata["image"]
     imageshape = imarray.shape
     if imageshape[0] != imageshape[1]:
         new_dim = min(imageshape)
         imarray = imagefun.crop_at(imarray, (imageshape[0] / 2, imageshape[1] / 2), (new_dim, new_dim))
         imageshape = imarray.shape
     if self.settings["reduced"]:
         size = max(imageshape)
         if size > 1024:
             imarray = scipy.ndimage.zoom(imarray, 1024.0 / imageshape[0])
     self.logger.info("Calculating power spectrum for image")
     pow = imagefun.power(imarray, self.settings["mask radius"])
     self.setImage(numpy.asarray(pow, numpy.float32), "Power")
     self.imageshape = imageshape
     return pow
Ejemplo n.º 10
0
 def calculatePowerImage(self, imagedata):
     imarray = imagedata['image']
     imageshape = imarray.shape
     if imageshape[0] != imageshape[1]:
         new_dim = min(imageshape)
         imarray = imagefun.crop_at(imarray,
                                    (imageshape[0] / 2, imageshape[1] / 2),
                                    (new_dim, new_dim))
         imageshape = imarray.shape
     if self.settings['reduced']:
         size = max(imageshape)
         if size > 1024:
             imarray = scipy.ndimage.zoom(imarray, 1024.0 / imageshape[0])
     self.logger.info('Calculating power spectrum for image')
     pow = imagefun.power(imarray, self.settings['mask radius'])
     self.setImage(numpy.asarray(pow, numpy.float32), 'Power')
     self.imageshape = imageshape
     return pow
Ejemplo n.º 11
0
def padpower(image, pixelsize, fieldsize=None, mask_radius=0.5):
	"""
	computes power spectra of image using padding
	"""
	t0 = time.time()
	if fieldsize is None:
		fieldsize = getFieldSize(image.shape)	
	maxDim = max(image.shape)
	powerTwo = math.ceil(math.log(maxDim)/math.log(2.0))
	powerTwoDim = int(2**(powerTwo))
	squareImage = imagefilter.frame_constant(image, (powerTwoDim,powerTwoDim))
	envelop = twodHann(powerTwoDim)
	poweravg = imagefun.power(squareImage*envelop, mask_radius)
	binning = int(powerTwoDim/fieldsize)
	imagefun.bin2(poweravg, binning)	
	freq = 1.0/(poweravg.shape[0]*pixelsize)
	apDisplay.printMsg("Fast compute PSD with size %d -> %d complete in %s"
		%(powerTwoDim, fieldsize, apDisplay.timeString(time.time()-t0)))
	return poweravg, freq
 def acquireManualFocusImage(self):
         t0 = time.time()
         correction = self.settings['correct image']
         self.manualchecklock.acquire()
         if correction:
                 imdata = self.acquireCorrectedCameraImageData()
         else:
                 imdata = self.acquireCameraImageData()
         imarray = imdata['image']
         self.manualchecklock.release()
         pow = imagefun.power(imarray, self.maskradius)
         self.man_power = pow.astype(numpy.float32)
         self.man_image = imarray.astype(numpy.float32)
         self.panel.setManualImage(self.man_image, 'Image')
         self.panel.setManualImage(self.man_power, 'Power')
         #sleep if too fast in simulation
         safetime = 1.0
         t1 = time.time()
         if t1-t0 < safetime:
                 time.sleep(safetime-(t1-t0))
 def acquireImage(self):
     imagedata = calibrator.Calibrator.acquireImage(self)
     # fake acquire image for testing
     #imagedata = self.fakeImage()
     if imagedata is None:
         return
     scope = imagedata['scope']
     camera = imagedata['camera']
     self.mag = scope['magnification']
     self.bin = camera['binning']['x']
     newimage = imagedata['image']
     self.shape = newimage.shape
     self.imagepixelsize = self.getImagePixelSize()
     size = max(self.shape)
     #if size > 2048:
     #	newimage = scipy.ndimage.zoom(newimage, 2048.0/max(self.shape))
     pow = imagefun.power(newimage, 1, 10)
     pow[(0, 0)] = pow.max() * 2
     self.setImage(pow, 'Power')
     self.panel.acquisitionDone()
	def acquireManualFocusImage(self):
		t0 = time.time()
		correction = self.settings['correct image']
		self.manualchecklock.acquire()
		if correction:
			imdata = self.acquireCorrectedCameraImageData()
		else:
			imdata = self.acquireCameraImageData()
		imarray = imdata['image']
		self.manualchecklock.release()
		pow = imagefun.power(imarray, self.maskradius)
		self.man_power = pow.astype(numpy.float32)
		self.man_image = imarray.astype(numpy.float32)
		self.panel.setManualImage(self.man_image, 'Image')
		self.panel.setManualImage(self.man_power, 'Power')
		#sleep if too fast in simulation
		safetime = 1.0
		t1 = time.time()
		if t1-t0 < safetime:
			time.sleep(safetime-(t1-t0))
 def acquireImage(self):
         imagedata = calibrator.Calibrator.acquireImage(self)
         # fake acquire image for testing
         #imagedata = self.fakeImage()
         if imagedata is None:
                 return
         scope = imagedata['scope']
         camera = imagedata['camera']
         self.mag = scope['magnification']
         self.bin = camera['binning']['x']
         newimage = imagedata['image']
         self.shape = newimage.shape
         self.imagepixelsize = self.getImagePixelSize()
         size = max(self.shape)
         if size > 2048:
                 newimage = scipy.ndimage.zoom(newimage, 2048.0/max(self.shape))
         pow = imagefun.power(newimage, 1,10)
         pow[(0,0)] =  pow.max()*2
         self.setImage(pow, 'Power')
         self.panel.acquisitionDone()
Ejemplo n.º 16
0
	def processImage(self, imgdata, filtarray):			
		#Ignore array filter
		array = imgdata['image']
		imgmax = self.params['max']
		imgmin = self.params['min']

		outfile = os.path.join(self.params['rundir'], imgdata['filename'])
		if self.params['fft'] is True:
			outfile+=".fft"
		outfile+=".jpg"
		if imgmin > imgmax:
			imgmax = array.max()
			imgmin = array.min()
		shape = array.shape
		maxdim = max(shape)
		if self.params['fft'] is True:
			## fft's are binned by 2
			array = imagefun.bin(array,2)
			array = imagefun.power(array)
			maxdim/=2
		bin = int(math.ceil(float(maxdim/self.params['imgsize'])))	
		array = imagefun.bin(array,bin)
		jpg.write(array, outfile, min=imgmin, max=imgmax, quality=self.params['quality'], stdval=self.params['stdval'])
Ejemplo n.º 17
0
    def binAndAddCTFlabel(self,
                          image,
                          ht,
                          cs,
                          rpixelsize,
                          binning=1,
                          defocus=None):
        pow = imagefun.power(image)
        binned = imagefun.bin(pow, binning)
        # No ctf estimation until it works better so that this node does not
        # depend on coma beam-tilt calibration
        s = None
        ctfdata = None
        '''
		try:
			ctfdata = fftfun.fitFirstCTFNode(pow,rpixelsize['x'], defocus, ht, cs)
		except Exception, e:
			self.logger.error("ctf fitting failed: %s" % e)
			ctfdata = None
		if ctfdata:
			self.logger.info('z0 %.3f um, zast %.3f um (%.0f ), angle= %.1f deg' % (ctfdata[0]*1e6,ctfdata[1]*1e6,ctfdata[2]*100, ctfdata[3]*180.0/math.pi))
			s = '%d' % int(ctfdata[0]*1e9)
		#elif self.ace2exe:
		elif False:
			ctfdata = self.estimateCTF(imagedata)
			z0 = (ctfdata['defocus1'] + ctfdata['defocus2']) / 2
			s = '%d' % (int(z0*1e9),)
		'''
        if s:
            t = numpil.textArray(s)
            t = ndimage.zoom(t,
                             (min(binned.shape) - 40.0) * 0.08 / (t.shape)[0])
            minvalue = arraystats.min(binned)
            maxvalue = arraystats.max(binned)
            t = minvalue + t * (maxvalue - minvalue)
            imagefun.pasteInto(t, binned, (20, 20))
        return binned, ctfdata
                        x = args[0]
                        y = args[1]
                fig = self.get_figure()
                axes = fig.gca()
                axes.plot(x,y)

        def clear(self):
                fig = self.get_figure()
                axes = fig.gca()
                axes.cla()
                

if __name__ == '__main__':
        import wx

        import numextension
        from pyami import mrc
        from pyami import imagefun
        import sys
        im = mrc.read(sys.argv[1])
        pow = imagefun.power(im)
        b = numextension.radialPower(pow, 5, 20)

        app = wx.PySimpleApp()
        frame = wx.Frame(None, -1, title='My Plot')
        plotpanel = PlotPanel(frame, -1)
        #b = [2,3,5,4,3]
        plotpanel.plot(b)
        frame.Show()
        app.MainLoop()
Ejemplo n.º 19
0
		#print phaseshift[c[0],:] * 180.0 / math.pi
		correction = numpy.cos(phaseshift)+numpy.sin(phaseshift)*complex(0,1)
		return correction

def correctBeamTiltPhaseShift(imgarray,pixelsize,beamtilt,Cs,ht):
		fft = fftpack.fft2(imgarray)
		beamtilt = (0.0,1e-4)
		Cs = 2e-3
		pixelsize = 1e-10
		ht = 120000
		wavelength = getElectronWavelength(ht)
		correction = getBeamTiltPhaseShiftCorrection(fft.shape,beamtilt,Cs,wavelength,pixelsize)
		cfft = fft * correction
		corrected_image = fftpack.ifft2(cfft)
		return corrected_image

if __name__ == '__main__':
	a = mrc.read('test.mrc')
	# pixel size in meters
	pixelsize = 6e-10
	Cs=2e-3
	ht=300000
	pow = imagefun.power(a)
	mrc.write(pow,'pow.mrc')
	dimension = {'x':a.shape[1],'y':a.shape[0]}
	imagepixelsize = {'x':pixelsize,'y':pixelsize}
	rpixelsize = {'x':1.0/(imagepixelsize['x']*dimension['x']),'y':1.0/(imagepixelsize['y']*dimension['y'])}
	
	ctfdata = fitFirstCTFNode(pow,rpixelsize['x'], None, ht)
	print ctfdata
                #print phaseshift[c[0],:] * 180.0 / math.pi
                correction = numpy.cos(phaseshift)+numpy.sin(phaseshift)*complex(0,1)
                return correction

def correctBeamTiltPhaseShift(imgarray,pixelsize,beamtilt,Cs,ht):
                fft = fftpack.fft2(imgarray)
                beamtilt = (0.0,1e-4)
                Cs = 2e-3
                pixelsize = 1e-10
                ht = 120000
                wavelength = getElectronWavelength(ht)
                correction = getBeamTiltPhaseShiftCorrection(fft.shape,beamtilt,Cs,wavelength,pixelsize)
                cfft = fft * correction
                corrected_image = fftpack.ifft2(cfft)
                return corrected_image

if __name__ == '__main__':
        a = mrc.read('test.mrc')
        # pixel size in meters
        pixelsize = 6e-10
        Cs=2e-3
        ht=300000
        pow = imagefun.power(a)
        mrc.write(pow,'pow.mrc')
        dimension = {'x':a.shape[1],'y':a.shape[0]}
        imagepixelsize = {'x':pixelsize,'y':pixelsize}
        rpixelsize = {'x':1.0/(imagepixelsize['x']*dimension['x']),'y':1.0/(imagepixelsize['y']*dimension['y'])}
        
        ctfdata = fitFirstCTFNode(pow,rpixelsize['x'], None, ht)
        print ctfdata
Ejemplo n.º 21
0
def power(image, pixelsize, fieldsize=None, mask_radius=0.5, msg=True):
	"""
	computes power spectra of image using sub-field averaging

	image - (2d numpy float array) image to compute power spectra
	pixelsize - (float) used to compute frequency, freq. 
		can be either Angstroms or meters, but freq will have same inverse units
	fieldsize - (integer) size of box
	mask_radius - (float) passed to imagefun.power(), 
		creates a mask of size mask_radius in the center

	TODO: add median flag, requires saving individual power spectra rather than summing
	"""
	if fieldsize is None:
		fieldsize = getFieldSize(image.shape)

	t0 = time.time()
	xsize, ysize = image.shape
	xnumstep = int(math.floor(xsize/float(fieldsize)))*2-1
	ynumstep = int(math.floor(ysize/float(fieldsize)))*2-1
	f = fieldsize
	#powersum = numpy.zeros((fieldsize,fieldsize))
	#envelop = numpy.ones((fieldsize,fieldsize)) 
	envelop = twodHann(fieldsize)
	count = 0
	psdlist = []
	if msg is True:
		sys.stderr.write("Computing power spectra in %dx%d blocks"%(fieldsize,fieldsize))
	for i in range(xnumstep):
		for j in range(ynumstep):
			count += 1
			x1 = f*i/2
			x2 = x1 + f
			y1 = f*j/2
			y2 = y1 + f
			if debug is True:
				print "%03d: %d:%d, %d:%d"%(count, x1, x2, y1, y2)
			elif msg is True:
				sys.stderr.write(".")
			cutout = image[x1:x2, y1:y2]
			powerspec = imagefun.power(cutout*envelop, mask_radius)
			psdlist.append(powerspec)
	if xsize%fieldsize > fieldsize*0.1:
		for j in range(ynumstep):
			count += 1
			x1 = xsize-f
			x2 = xsize
			y1 = f*j/2
			y2 = y1 + f
			if debug is True:
				print "%03d: %d:%d, %d:%d"%(count, x1, x2, y1, y2)
			elif msg is True:
				sys.stderr.write(".")
			cutout = image[x1:x2, y1:y2]
			powerspec = imagefun.power(cutout*envelop, mask_radius)
			psdlist.append(powerspec)
	if ysize%fieldsize > fieldsize*0.1:
		for i in range(xnumstep):
			count += 1
			x1 = f*i/2
			x2 = x1 + f
			y1 = ysize-f
			y2 = ysize
			if debug is True:
				print "%03d: %d:%d, %d:%d"%(count, x1, x2, y1, y2)
			elif msg is True:
				sys.stderr.write(".")
			cutout = image[x1:x2, y1:y2]
			powerspec = imagefun.power(cutout*envelop, mask_radius)
			psdlist.append(powerspec)
	sys.stderr.write("\n")
	freq = 1.0/(powerspec.shape[0]*pixelsize)

	#poweravg = numpy.array(psdlist).mean(0)
	apDisplay.printMsg("Computing median of power spectra series")
	poweravg = numpy.median(psdlist, axis=0)
	if msg is True:
		apDisplay.printMsg("Compute PSD with fieldsize %d and %d images complete in %s"
			%(fieldsize, count, apDisplay.timeString(time.time()-t0)))
	return poweravg, freq
            x = args[0]
            y = args[1]
        fig = self.get_figure()
        axes = fig.gca()
        axes.plot(x, y)

    def clear(self):
        fig = self.get_figure()
        axes = fig.gca()
        axes.cla()


if __name__ == '__main__':
    import wx

    import numextension
    from pyami import mrc
    from pyami import imagefun
    import sys
    im = mrc.read(sys.argv[1])
    pow = imagefun.power(im)
    b = numextension.radialPower(pow, 5, 20)

    app = wx.PySimpleApp()
    frame = wx.Frame(None, -1, title='My Plot')
    plotpanel = PlotPanel(frame, -1)
    #b = [2,3,5,4,3]
    plotpanel.plot(b)
    frame.Show()
    app.MainLoop()
Ejemplo n.º 23
0
	#poweravg = numpy.array(psdlist).mean(0)
	apDisplay.printMsg("Computing median of power spectra series")
	poweravg = numpy.median(psdlist, axis=0)
	if msg is True:
		apDisplay.printMsg("Compute PSD with fieldsize %d and %d images complete in %s"
			%(fieldsize, count, apDisplay.timeString(time.time()-t0)))
	return poweravg, freq

#===================
#===================
#===================
if __name__ == "__main__":
	a = mrc.read("/home/vosslab/test.mrc")
	a = imagefilter.planeRegression(a)
	fullpower = imagefun.power(a)
	#imagestat.printImageInfo(a)
	t0 = time.time()
	x = numpy.arange(6, 13)
	N = 2**x
	print N
	for n in N:
		print "====================================="
		b = power(a, n)
		b = imagefilter.frame_cut(b, numpy.array(b.shape)/2)
		imagefile.arrayToPng(b, "%04d-field.png"%(n))
		imagestat.printImageInfo(b)

		bin = int(round(2**12/n))
		b = imagefun.bin2(fullpower, bin)
		b = imagefilter.frame_cut(b, numpy.array(b.shape)/2)
    def manualCheckLoop(self, presetname=None, emtarget=None):
        ## copied and simplified from focuser.py
        ## go to preset and target
        self.logger.info(
            'Starting manual focus loop, please confirm defocus...')
        self.beep()
        camdata1 = {}

        # configure camera using settings, but only 512x512 to save time
        origcam = self.settings['camera settings']
        camdata1 = self.makeCenterImageCamSettings(origcam)
        camdata1['exposure time'] = self.focexptime
        self.instrument.ccdcamera.Settings = camdata1
        pixelsize, center = self.getReciprocalPixelSizeFromInstrument()
        self.ht = self.instrument.tem.HighTension
        self.cs = self.getTEMCsValue()
        self.panel.onNewPixelSize(pixelsize, center, self.ht, self.cs)
        self.manualplayer.play()
        self.onManualCheck()
        while True:
            t0 = time.time()
            state = self.manualplayer.state()
            if state == 'stop':
                break
            elif state == 'pause':
                if self.manualplayer.wait() == 'stop':
                    break
            # acquire image, show image and power spectrum
            # allow user to adjust defocus and stig
            correction = self.settings['correct image']
            camdata1['exposure time'] = self.focexptime

            self.manualchecklock.acquire()
            self.instrument.ccdcamera.Settings = camdata1
            try:
                if correction:
                    imagedata = self.acquireCorrectedCameraImageData()
                else:
                    imagedata = self.acquireCameraImageData()
                imarray = imagedata['image']
            except:
                raise
                self.manualchecklock.release()
                self.manualplayer.pause()
                self.logger.error('Failed to acquire image, pausing...')
                continue

            self.manualchecklock.release()
            pow = imagefun.power(imarray, self.maskradius)
            man_power = pow.astype(numpy.float32)
            self.man_power = numpy.clip(man_power, self.powmin, self.powmax)
            self.man_image = imarray.astype(numpy.float32)
            self.panel.setManualImage(self.man_image, 'Image')
            self.panel.setManualImage(self.man_power, 'Power')

            #sleep if too fast in simulation
            t1 = time.time()
            if t1 - t0 < 0.5:
                time.sleep(0.5 - (t1 - t0))

        self.onManualCheckDone()
        self.logger.info('Manual focus check completed')