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 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 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 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
def calcStats(self, imdata):
stats = {}
stats['mean'] = arraystats.mean(imdata['image'])
stats['stdev'] = arraystats.std(imdata['image'])
return stats
