def edge_mean(self, im): m1 = arraystats.mean(im[0]) m2 = arraystats.mean(im[-1]) m3 = arraystats.mean(im[:,0]) m4 = arraystats.mean(im[:,-1]) m = (m1+m2+m3+m4) / 4.0 return m
def bringHome(self): # start with a spread beam self.instrument.tem.Intensity = 0.8 imdata0 = self.acquire() mean0 = arraystats.mean(imdata0['image']) # test if we can even see the beam self.instrument.tem.Intensity = 0.7 imdata1 = self.acquire() mean1 = arraystats.mean(imdata1['image']) print 'mean0,mean1', mean0, mean1
def calc_norm(self, corimagedata, ccdcameraname, scopedata): corstate = corimagedata['camstate'] channel = corimagedata['channel'] if isinstance(corimagedata, leginondata.DarkImageData): dark = corimagedata['image'] bright = self.corclient.retrieveRef(corstate, 'bright', ccdcameraname, scopedata, channel) if bright is None: self.logger.warning('No bright reference image for normalization calculations') return if isinstance(corimagedata, leginondata.BrightImageData): bright = corimagedata['image'] dark = self.corclient.retrieveRef(corstate, 'dark', ccdcameraname, scopedata, channel) if dark is None: self.logger.warning('No dark reference image for normalization calculations') return norm = bright - dark norm = numpy.asarray(norm, numpy.float32) ## there may be a better normavg than this normavg = arraystats.mean(norm) # division may result infinity or zero division # so make sure there are no zeros in norm norm = numpy.clip(norm, 0.001, sys.maxint) norm = normavg / norm self.corclient.storeRef('flat', norm, corstate, scopedata, channel)
def autoAcquireReferences(self, binning, targetmean, initial_exp): ''' for a given binning, figure out the proper exposure time which gives the desired mean pixel value ''' config = { 'dimension':{'x':256, 'y':256}, 'binning':{'x':binning, 'y':binning}, 'auto offset': True, 'exposure time': 0, } raise NotImplementedError('need to work out the details of configuring the camera here') im = self.instrument.ccdcamera.Image mean = darkmean = arraystats.mean(im) self.displayImage(im) self.logger.info('Dark reference mean: %s' % str(darkmean)) target_exp = 0 trial_exp = initial_exp tolerance = 100 minmean = targetmean - tolerance maxmean = targetmean + tolerance tries = 5 for i in range(tries): config = { 'exposure time': trial_exp } raise NotImplementedError('need to work out the details of configuring the camera here') im = self.instrument.ccdcamera.Image mean = arraystats.mean(im) self.displayImage(im) self.logger.info('Image mean: %s' % str(mean)) if minmean <= mean <= maxmean: i = -1 break else: slope = (mean - darkmean) / trial_exp trial_exp = (targetmean - darkmean) / slope if i == tries-1: self.logger.info('Failed to find target mean after %s tries' % (tries,))
def setStatistics(self, array=None, statistics={}): try: mean = statistics['mean'] except KeyError: if array is None: mean = None else: mean = arraystats.mean(array) try: min = statistics['min'] except KeyError: if array is None: min = None else: min = arraystats.min(array) try: max = statistics['max'] except KeyError: if array is None: max = None else: max = arraystats.max(array) try: sd = statistics['stdev'] except KeyError: if array is None: sd = None else: sd = arraystats.std(array) if mean is None: meanstr = '' else: meanstr = '%g' % mean if min is None: minstr = '' else: minstr = '%g' % min if max is None: maxstr = '' else: maxstr = '%g' % max if sd is None: sdstr = '' else: sdstr = '%g' % sd self.meanlabel.SetLabel(meanstr) self.minlabel.SetLabel(minstr) self.maxlabel.SetLabel(maxstr) self.sdlabel.SetLabel(sdstr) self.sizer.Layout()
def evaluateStats(self, imagearray): mean = arraystats.mean(imagearray) if mean > self.settings['high mean']: try: self.emailBadImageStats(mean) except: self.logger.info('could not email') self.respondBadImageStats('high') if mean < self.settings['low mean']: try: self.emailBadImageStats(mean) except: self.logger.info('could not email') self.respondBadImageStats('low')
def threshold_correlation(self, threshold=None): ''' Threshold the correlation image. ''' if self.__results['correlation'] is None: raise RuntimeError('need correlation image to threshold') self.configure_threshold(threshold) cc = self.__results['correlation'] mean = arraystats.mean(cc) std = arraystats.std(cc) thresh = mean + self.threshold * std t = imagefun.threshold(cc, thresh) self.__update_result('threshold', t) if self.save_mrc: mrc.write(t, 'threshold.mrc')
def recheckEvaluateStats(self,imagearray): ''' Stats evaluation in recheck. This is mainly based on the slope. ''' mean = arraystats.mean(imagearray) if self.settings['bad stats type'] is None or self.settings['bad stats type'] == 'Mean': return self.evaluateStats(imagearray) # Evaluate with slope. Always rejects None (no slope calculated) slope = self.runningSlope(time.time() - self.time0,mean) self.logger.info('current slope %s' % (slope,)) if slope is not None and mean > self.recover_mean and slope <= self.settings['high mean'] and slope >=self.settings['low mean']: return else: self.respondBadImageStats('low')
def calc_norm(self, refdata): scopedata = refdata['scope'] cameradata = refdata['camera'] channel = refdata['channel'] if isinstance(refdata, leginondata.DarkImageData): dark = refdata bright = self.retrieveCorrectorImageData('bright', scopedata, cameradata, channel) if bright is None: self.logger.warning('No bright reference image for normalization calculations') return if isinstance(refdata, leginondata.BrightImageData): bright = refdata dark = self.retrieveCorrectorImageData('dark', scopedata, cameradata, channel) if dark is None: self.logger.warning('No dark reference image for normalization calculations') return try: darkarray = self.prepareDark(dark, bright) except: self.logger.warning('Unable to load dark image from %s' % dark['session']['image path']) return try: brightarray = bright['image'] except: self.logger.warning('Unable to load bright image from %s' % bright['session']['image path']) return try: normarray = brightarray - darkarray except: self.logger.error('dark subtraction failed.') return normarray = numpy.asarray(normarray, numpy.float32) normavg = arraystats.mean(normarray) # division may result infinity or zero division # so make sure there are no zeros in norm normarray = numpy.clip(normarray, 0.001, sys.maxint) normarray = normavg / normarray # Avoid over correcting dead pixels normarray = numpy.ma.masked_greater(normarray,20).filled(1) # Saving normdata normdata = leginondata.CameraImageData(initializer=refdata) normdata['image'] = normarray normdata['dark'] = dark normdata['bright'] = bright self.storeCorrectorImageData(normdata, 'norm', channel)
def acquire(self, presetdata, emtarget=None, attempt=None, target=None): ''' this replaces Acquisition.acquire() ''' # If first attempt at metering on this target, record original exposure # time. Use target list and number as the "key" to the target. targetkey = (target['list'], target['number']) if targetkey != self.aetarget: self.aetarget = targetkey self.original_exptime = presetdata['exposure time'] self.ae_attempt = 1 else: self.ae_attempt += 1 status = acquisition.Acquisition.acquire(self, presetdata, emtarget, attempt=attempt, target=target) ## check settings for what we want intensity to be mean_target = self.settings['mean intensity'] tolerance = self.settings['mean intensity tolerance'] mean_min = mean_target - tolerance mean_max = mean_target + tolerance ## check if image is close enough to target mean value mean_acquired = arraystats.mean(self.imagedata['image']) self.logger.info('Target Mean: %.1f += %s%%, Acquired Mean: %.1f' % ( mean_target, tolerance, mean_acquired, )) scale = float(mean_target) / mean_acquired percent_error = abs(scale - 1.0) * 100 self.logger.info('Error relative to target: %.1f%%' % (percent_error, )) if percent_error > tolerance: status = self.adjustExposureTime(self.imagedata, scale) else: status = 'ok' return status
def get_box_stats(self, image, coord, boxsize): ## select the region of interest b2 = boxsize / 2 rmin = int(coord[1] - b2) rmax = int(coord[1] + b2) cmin = int(coord[0] - b2) cmax = int(coord[0] + b2) ## beware of boundaries if rmin < 0: rmin = 0 if rmax >= image.shape[0]: rmax = image.shape[0] - 1 if cmin < 0: cmin = 0 if cmax >= image.shape[1]: cmax = image.shape[1] - 1 subimage = image[rmin:rmax + 1, cmin:cmax + 1] roi = numpy.ravel(subimage) mean = arraystats.mean(roi) std = arraystats.std(roi) n = len(roi) stats = {'mean': mean, 'std': std, 'n': n} return stats
def get_box_stats(self, image, coord, boxsize): ## select the region of interest b2 = boxsize / 2 rmin = int(coord[1]-b2) rmax = int(coord[1]+b2) cmin = int(coord[0]-b2) cmax = int(coord[0]+b2) ## beware of boundaries if rmin < 0: rmin = 0 if rmax >= image.shape[0]: rmax = image.shape[0]-1 if cmin < 0: cmin = 0 if cmax >= image.shape[1]: cmax = image.shape[1]-1 subimage = image[rmin:rmax+1, cmin:cmax+1] roi = numpy.ravel(subimage) mean = arraystats.mean(roi) std = arraystats.std(roi) n = len(roi) stats = {'mean':mean, 'std': std, 'n':n} return stats
def evaluateStats(self, imagearray): mean = arraystats.mean(imagearray) if self.settings['bad stats type'] == 'Slope': mean = self.runningSlope(time.time() - self.time0,mean) self.logger.info('current slope %s' % (mean,)) if mean is None: return if mean > self.settings['high mean']: try: self.emailBadImageStats(mean) except: self.logger.info('could not email') self.respondBadImageStats('high') if mean < self.settings['low mean']: try: self.emailBadImageStats(mean) except: self.logger.info('could not email') if mean is not None: self.logger.info('mean lower than settings %6.0f' % (mean)) self.respondBadImageStats('low')
def get_hole_stats(self, image, coord, radius): ## select the region of interest rmin = int(coord[0]-radius) rmax = int(coord[0]+radius) cmin = int(coord[1]-radius) cmax = int(coord[1]+radius) ## beware of boundaries if rmin < 0 or rmax >= image.shape[0] or cmin < 0 or cmax > image.shape[1]: return None subimage = image[rmin:rmax+1, cmin:cmax+1] save_mrc(subimage, 'hole.mrc') center = subimage.shape[0]/2.0, subimage.shape[1]/2.0 mask = self.circle.get(subimage.shape, center, 0, radius) save_mrc(mask, 'holemask.mrc') im = Numeric.ravel(subimage) mask = Numeric.ravel(mask) roi = Numeric.compress(mask, im) mean = arraystats.mean(roi) std = arraystats.std(roi) n = len(roi) return {'mean':mean, 'std': std, 'n':n}
def getAdjustment(self): # get current beam shift original_beamshift = self.instrument.tem.BeamShift bestbeamshift = original_beamshift maxvalue = 0 step = self.getBeamShiftStep() for beamx in (-step, 0, step): newbeamx = original_beamshift['x'] + beamx for beamy in (-step, 0, step): newbeamy = original_beamshift['y'] + beamy # set scope parameters newbeamshift = {'x': newbeamx, 'y': newbeamy} self.instrument.tem.BeamShift = newbeamshift self.logger.info('change beam shift to: %s' % (newbeamshift)) # acquire image imagedata = self.acquire() if imagedata is None: self.logger.error('Failed to Fix Beam Shift') return # check image image = imagedata['image'] self.setImage(image, 'Image') meanvalue = arraystats.mean(image) if meanvalue > maxvalue: maxvalue = meanvalue bestbeamshift = newbeamshift state = self.player.state() if state == 'stop': self.instrument.tem.BeamShift = original_beamshift return {} # set to the best beam shift self.instrument.tem.BeamShift = bestbeamshift self.logger.info('Best Beam Shift: %s' % (bestbeamshift, )) return {'beam shift': bestbeamshift}
def getAdjustment(self): # get current beam shift original_beamshift = self.instrument.tem.BeamShift bestbeamshift = original_beamshift maxvalue = 0 step = self.getBeamShiftStep() for beamx in (-step, 0,step): newbeamx = original_beamshift['x'] + beamx for beamy in (-step, 0,step): newbeamy = original_beamshift['y'] + beamy # set scope parameters newbeamshift = {'x': newbeamx, 'y': newbeamy} self.instrument.tem.BeamShift = newbeamshift self.logger.info('change beam shift to: %s' %(newbeamshift)) # acquire image imagedata = self.acquire() if imagedata is None: self.logger.error('Failed to Fix Beam Shift') return # check image image = imagedata['image'] self.setImage(image, 'Image') meanvalue = arraystats.mean(image) if meanvalue > maxvalue: maxvalue = meanvalue bestbeamshift = newbeamshift state = self.player.state() if state == 'stop': self.instrument.tem.BeamShift = original_beamshift return {} # set to the best beam shift self.instrument.tem.BeamShift = bestbeamshift self.logger.info('Best Beam Shift: %s' % (bestbeamshift,)) return {'beam shift':bestbeamshift}
def acquire(self, presetdata, emtarget=None, attempt=None, target=None): ''' this replaces Acquisition.acquire() ''' # If first attempt at metering on this target, record original exposure # time. Use target list and number as the "key" to the target. targetkey = (target['list'], target['number']) if targetkey != self.aetarget: self.aetarget = targetkey self.original_exptime = presetdata['exposure time'] self.ae_attempt = 1 else: self.ae_attempt += 1 status = acquisition.Acquisition.acquire(self, presetdata, emtarget, attempt=attempt, target=target) ## check settings for what we want intensity to be mean_target = self.settings['mean intensity'] tolerance = self.settings['mean intensity tolerance'] mean_min = mean_target - tolerance mean_max = mean_target + tolerance ## check if image is close enough to target mean value mean_acquired = arraystats.mean(self.imagedata['image']) self.logger.info('Target Mean: %.1f += %s%%, Acquired Mean: %.1f' % (mean_target, tolerance, mean_acquired,)) scale = float(mean_target) / mean_acquired percent_error = abs(scale - 1.0) * 100 self.logger.info('Error relative to target: %.1f%%' % (percent_error,)) if percent_error > tolerance: status = self.adjustExposureTime(self.imagedata, scale) else: status = 'ok' return status
def calcStats(self, imdata): stats = {} stats['mean'] = arraystats.mean(imdata['image']) stats['stdev'] = arraystats.std(imdata['image']) return stats