def researchCorrectorImageData(self, type, scopedata, cameradata, channel):
if type == 'dark':
imagetemp = leginondata.DarkImageData()
elif type == 'bright':
imagetemp = leginondata.BrightImageData()
elif type == 'norm':
imagetemp = leginondata.NormImageData()
else:
return None
## query only based on certain camera parameters, not all
imagetemp['camera'] = leginondata.CameraEMData()
for key in ('ccdcamera', 'dimension', 'binning', 'offset',
'gain index'):
imagetemp['camera'][key] = cameradata[key]
# query only based on certain scope parameters, not all
imagetemp['scope'] = leginondata.ScopeEMData()
for key in ('tem', 'high tension'):
imagetemp['scope'][key] = scopedata[key]
imagetemp['channel'] = channel
try:
ref = imagetemp.query(results=1)
except Exception, e:
self.logger.warning('Reference image query failed: %s' % e)
ref = None
def calculateTiles(self, tilesize):
## figure out the final shape of global space
rowsize = int(numpy.ceil(float(self.shape[0]) / tilesize) * tilesize)
colsize = int(numpy.ceil(float(self.shape[1]) / tilesize) * tilesize)
## make list of stage center for each tile
print 'calculating tile positions...'
centerpixel = rowsize / 2.0 - 0.5, colsize / 2.0 - 0.5
firstpixel = tilesize / 2.0 - 0.5
rowi = 0
tiles = ordereddict.OrderedDict()
for row in numpy.arange(firstpixel, rowsize, tilesize):
coli = 0
for col in numpy.arange(firstpixel, colsize, tilesize):
pixel = {
'row': row - centerpixel[0],
'col': col - centerpixel[1]
}
newstage = self.trans.transform(pixel, self.stage, self.bin)
tilescope = leginondata.ScopeEMData(initializer=self.scope)
tilescope['stage position'] = newstage
tilecamera = leginondata.CameraEMData(initializer=self.camera)
tilecamera['dimension'] = {'x': tilesize, 'y': tilesize}
args = tilescope, tilecamera, self.timestamp
kwargs = {'rotation': self.rotation}
tiles[(rowi, coli)] = {'args': args, 'kwargs': kwargs}
coli += 1
rowi += 1
print 'Calculated %d tiles, %d rows, %d cols' % (len(tiles), rowi,
coli)
return tiles
def upgradeLeginonDB(self):
if not self.leginon_dbupgrade.tableExists('SessionData'):
return
while True:
while True:
sessionname = raw_input('Enter the name of the first session of which\n frames are saved with Gatan K2 Summit under DM 2.31\n (Press RETURN if none): ')
if not sessionname:
return
results = leginondata.SessionData(name=sessionname).query()
if not results:
print '\033[31mSession not found, Try again.\033[0m'
continue
self.sessiondata = results[0]
q = leginondata.CameraEMData(session=self.sessiondata)
q['save frames'] = True
results = q.query(results=1)
if not results:
print '\033[31mNo image with saved frame found in Session. Try again.\033[0m'
continue
camdata = results[0]
if not camdata['ccdcamera']['name'] in VALID_CAMERA_NAMES:
print '\033[31mThis is not a camera that needs changing. Try again.\033[0m'
continue
first_image = self. getFirstImageInSession()
if not first_image:
print '\033[31mThis session has no image saved. Try agin.\033[0m'
continue
k2cameras = self.getRelatedFrameCameras(camdata)
self.saveFrameOrientation(k2cameras,first_image)
break
answer = raw_input('Another K2 camera ? (Y/N)')
if answer.upper() =='N':
return
def findBrightImageFromNorm(self, normdata):
'''
Find BrighetImageData based on imported NormImageData.
This is needed for older data since BrightImageData was
not linked to AcquisitionImages previously.
'''
if normdata['bright']:
return normdata['bright']
timestamp = normdata.timestamp
normcam = normdata['camera']
qcam = leginondata.CameraEMData(dimension=normcam['dimension'],
offset=normcam['offset'],
binning=normcam['binning'],
ccdcamera=normcam['ccdcamera'])
qcam['exposure type'] = 'normal'
qcam['energy filtered'] = normcam['energy filtered']
normscope = normdata['scope']
qscope = leginondata.ScopeEMData(tem=normscope['tem'])
qscope['high tension'] = normscope['high tension']
q = leginondata.BrightImageData(camera=qcam,
scope=qscope,
channel=normdata['channel'])
brightlist = q.query()
for brightdata in brightlist:
if brightdata.timestamp < timestamp:
break
return brightdata
def alreadyAcquired(self, targetdata, presetname):
'''
determines if image already acquired using targetdata and presetname
'''
## if image exists with targetdata and presetdata, no acquire
## we expect target to be exact, however, presetdata may have
## changed so we only query on preset name
# seems to have trouple with using original targetdata as
# a query, so use a copy with only some of the fields
presetquery = leginondata.PresetData(name=presetname)
targetquery = leginondata.AcquisitionImageTargetData(initializer=targetdata)
## don't care if drift correction was done on target after image was
## acquired, so ignore version, delta row/col, parentimage, and fromtarget
targetquery['version'] = None
targetquery['delta row'] = None
targetquery['delta column'] = None
targetquery['image'] = None
targetquery['fromtarget'] = None
imagequery = leginondata.AcquisitionImageData(target=targetquery, preset=presetquery)
## other things to fill in
imagequery['scope'] = leginondata.ScopeEMData()
imagequery['camera'] = leginondata.CameraEMData()
imagequery['session'] = leginondata.SessionData()
datalist = self.research(datainstance=imagequery)
if datalist:
## no need to acquire again, but need to republish
self.reportStatus('output', 'Image was acquired previously, republishing')
imagedata = datalist[0]
self.publishDisplayWait(imagedata)
return True
else:
return False
def saveSessionDDinfoToDatabase(sessiondata):
qcam = leginondata.CameraEMData(session=sessiondata)
qcam['save frames'] = True
acqimages = leginondata.AcquisitionImageData(camera=qcam).query()
for imagedata in acqimages:
infopath = os.path.join(sessiondata['image path'],
imagedata['filename'] + '.frames', 'info.path')
saveImageDDinfoToDatabase(imagedata, infopath)
def upgradeLeginonDB(self):
if not self.leginon_dbupgrade.columnExists(
'AcquisitionImageData',
'REF|CorrectorPlanData|corrector plan'):
self.leginon_dbupgrade.addColumn(
'AcquisitionImageData', 'REF|CorrectorPlanData|corrector plan',
self.leginon_dbupgrade.int)
results = leginondata.InstrumentData(name='DE12').query(results=1)
if not results:
return
decameradata = results[0]
dim = {'x': 4096, 'y': 3072}
camq = leginondata.CameraEMData(ccdcamera=decameradata, dimension=dim)
plans = leginondata.CorrectorPlanData(camera=camq).query()
pairs = {}
ordered_keys = []
for i, plan in enumerate(plans):
if i == 0:
ordered_keys.append(i)
pairs[i] = (plan.timestamp.now(), plan.timestamp)
else:
ordered_keys.append(i)
pairs[i] = (plans[i - 1].timestamp, plan.timestamp)
camq = leginondata.CameraEMData(ccdcamera=decameradata, dimension=dim)
camq['save frames'] = True
imageq = leginondata.AcquisitionImageData(camera=camq)
print 'Query all DE12 images. This may take some time...'
images = imageq.query()
print 'Total of %d images' % (len(images), )
for image in images:
if image['corrector plan']:
continue
for key in ordered_keys:
if image.timestamp > pairs[key][1] and image.timestamp < pairs[
key][0]:
print key, image.dbid, image['filename'], image.timestamp
status = self.leginon_dbupgrade.updateColumn(
'AcquisitionImageData',
'REF|CorrectorPlanData|corrector plan',
'%d' % plans[key].dbid, '`DEF_id`=%d' % image.dbid,
True)
if not status:
print break_from_failed_update
def getPlan(self):
ccdcamera = self.instrument.getCCDCameraData()
newcam = leginondata.CameraEMData(ccdcamera=ccdcamera)
if self.settings['camera settings'] is None:
plan = None
else:
for i in ['dimension', 'offset', 'binning']:
newcam[i] = dict(self.settings['camera settings'][i])
plan = self.corclient.retrievePlan(newcam)
return plan
def getImageCameraEMData(self):
camdata = leginondata.CameraEMData(initializer=self.image['camera'])
# local change. Need to remove before release
if self.isOldNRAMMData() and self.image.dbid < 1989842:
# image dimension is not consistent with the frames
# Use the default camera dimension, binning, and offset of the frames
# (rotated and flipped full size)
defaultcamdata = self.getCorrectedImageData()['camera']
for key in ('dimension', 'binning', 'offset'):
camdata[key] = defaultcamdata[key]
return camdata
def createGlobalOutput(imdata, angle=0.0, bin=1):
sys.stderr.write('creating global image space\n')
timestamp = imdata.timestamp
scope = leginondata.ScopeEMData(initializer=imdata['scope'])
camera = leginondata.CameraEMData(initializer=imdata['camera'])
binning = {
'x': camera['binning']['x'] * bin,
'y': camera['binning']['y'] * bin
}
camera['binning'] = binning
globaloutput = MontageImage(scope, camera, timestamp, rotation=angle)
return globaloutput
def queryCorrectionImage(self, scopedata, camdata, type, channel):
# only query based on instrument and high tension
scope = leginondata.ScopeEMData()
scope['tem'] = scopedata['tem']
scope['high tension'] = scopedata['high tension']
# only query based on instrument, dimension, binning, offset
camera = leginondata.CameraEMData()
camera['ccdcamera'] = camdata['ccdcamera']
camera['dimension'] = camdata['dimenion']
camera['binning'] = camdata['binning']
camera['offset'] = camdata['offset']
## first try requested channel, then try any channel
corimg = None
for channel in (channel, None):
## try cache
try:
key = self.getkey(scopedata, camdata, type, channel)
return self.cache[key]
except KeyError:
pass
self.node.logger.info('Loading %s...' % self.formatKey(key))
qimage = leginondata.CorrectionImageData(scope=scope,
camera=camera,
type=type,
channel=channel)
try:
corimg = qimage.query(results=1)
corimg = corimg[0]
break
except:
pass
self.node.logger.warning(
'requested correction channel %s not available, using channel: %s'
% (channel, corimg['channel']))
else:
self.node.logger.error('No correction image in database')
corimg = None
if corimg is not None:
self.node.logger.info('Correction image loaded: %s' %
(corimg['filename'], ))
## make it float to do float math later
image = numpy.asarray(corimg['image'], numpy.float32)
key = self.getkey(corimg['scope'], corimg['camera'],
corimg['type'], corimg['channel'])
self.cache[key] = image
else:
image = None
return image
def __init__(self, scope, camera, timestamp, fileref=None, rotation=0.0):
self.scope = leginondata.ScopeEMData(initializer=scope)
self.camera = leginondata.CameraEMData(initializer=camera)
self.shape = self.camera['dimension']['y'], self.camera['dimension'][
'x']
self.fileref = fileref
self.timestamp = timestamp
self.trans = caltransformer.getTransformer(scope['tem'],
camera['ccdcamera'],
scope['high tension'],
scope['magnification'],
timestamp, rotation)
self.newStage(scope['stage position'])
def reseachCorrectorPlan(self, cameradata):
qcamera = leginondata.CameraEMData()
# Fix Me: Ignore gain index for now because camera setting does not have it when theplan is saved.
for key in ('ccdcamera','dimension','binning','offset'):
qcamera[key] = cameradata[key]
qplan = leginondata.CorrectorPlanData()
qplan['camera'] = qcamera
plandatalist = qplan.query()
if plandatalist:
return plandatalist[0]
else:
return None
def retrieveCorrectorPlanFromSettings(self):
ccdcameraname = self.settings['instruments']['ccdcamera']
camsettings = self.settings['camera settings']
if ccdcameraname is None or camsettings is None:
return None
cameradata = leginondata.CameraEMData()
try:
cameradata['ccdcamera'] = self.instrument.getCCDCameraData(
ccdcameraname)
except:
return None
cameradata.update(camsettings)
cdata = self.instrument.getData(leginondata.CameraEMData)
cameradata['gain index'] = cdata['gain index']
plan, plandata = self.retrieveCorrectorPlan(cameradata)
return plan
def storeCorrectorImageData(self, imagedata, type, channel):
# check for bad shape
imarray = imagedata['image']
shape = imarray.shape
cameradata = imagedata['camera']
dim = cameradata['dimension']
if dim['x'] != shape[1] or dim['y'] != shape[0]:
raise RuntimeError('%s: bad array shape: %s' % (
type,
shape,
))
if type == 'dark':
refclass = leginondata.DarkImageData
elif type == 'bright':
refclass = leginondata.BrightImageData
elif type == 'norm':
refclass = leginondata.NormImageData
refdata = refclass(initializer=imagedata)
refdata['filename'] = self.makeCorrectorImageFilename(
type, channel, imarray.shape)
## replace session of scope, camera, refdata with ref session
refsession = self.getReferenceSession()
scopedata = refdata['scope']
cameradata = refdata['camera']
newscope = leginondata.ScopeEMData(initializer=scopedata)
newscope['session'] = refsession
newcamera = leginondata.CameraEMData(initializer=cameradata)
newcamera['session'] = refsession
refdata['session'] = refsession
refdata['scope'] = newscope
refdata['camera'] = newcamera
refdata['channel'] = channel
self.logger.info('Saving new %s' % (type, ))
refdata.insert(force=True)
self.logger.info('Saved: %s' % (refdata['filename'], ))
## store in cache
key = self.makeCorrectorKey(type, scopedata, cameradata, channel)
ref_cache[key] = refdata
return refdata
def saveAllPreviousToDatabase():
qcam = leginondata.CameraEMData()
qcam['save frames'] = True
acqimages = leginondata.AcquisitionImageData(camera=qcam).query()
for imagedata in acqimages:
# check for frames dir
camdata = imagedata['camera']
session = imagedata['session']
impath = session['image path']
fname = imagedata['filename']
infoname = os.path.join(impath, fname + '.frames', 'info.txt')
if os.path.exists(infoname):
# check for existing ddinfo in db
info = leginondata.DDinfoValueData(camera=camdata).query()
if not info:
print 'saving:', infoname
saveImageDDinfoToDatabase(imagedata, infoname)
def retrieveCorrectorImageFromSettings(self, reftype, channel):
ccdcameraname = self.settings['instruments']['ccdcamera']
camsettings = self.settings['camera settings']
if ccdcameraname is None or camsettings is None:
return None
cameradata = leginondata.CameraEMData()
try:
cameradata['ccdcamera'] = self.instrument.getCCDCameraData(
ccdcameraname)
except:
return None
cameradata.update(camsettings)
cdata = self.instrument.getData(leginondata.CameraEMData)
cameradata['gain index'] = cdata['gain index']
scopedata = self.instrument.getData(leginondata.ScopeEMData)
imdata = self.retrieveCorrectorImageData(reftype, scopedata,
cameradata, channel)
return imdata
def getAlternativeChannelNorm(self, refdata):
'''
Get norm image data of the other channel closest in time
'''
if refdata is None:
return None
reftype = 'norm'
timestamp = refdata.timestamp
refcam = refdata['camera']
qcam = leginondata.CameraEMData(dimension=refcam['dimension'],
offset=refcam['offset'],
binning=refcam['binning'],
ccdcamera=refcam['ccdcamera'])
qcam['exposure time'] = refcam['exposure time']
qcam['energy filtered'] = refcam['energy filtered']
qcam['gain index'] = refcam['gain index']
refscope = refdata['scope']
qscope = leginondata.ScopeEMData(tem=refscope['tem'])
qscope['high tension'] = refscope['high tension']
altchannel = int(refdata['channel'] == 0)
q = self.createRefQuery(reftype, qcam, qscope, altchannel)
reflist = q.query()
if len(reflist) == 0:
# Not to query exposure time if none found
qcam['exposure time'] = None
q = self.createRefQuery(reftype, qcam, qscope, altchannel)
reflist = q.query()
if len(reflist) == 0:
#no switching, no alternative channel found
return refdata
for newrefdata in reflist:
if newrefdata.timestamp < timestamp:
break
before_ref = newrefdata
reflist.reverse()
for newrefdata in reflist:
if newrefdata.timestamp > timestamp:
break
after_ref = newrefdata
if after_ref.timestamp - timestamp > timestamp - before_ref.timestamp:
return before_ref
else:
return after_ref
def saveTableau(self, imagedata):
init = imagedata
tabim = self.tabimage
filename = init['filename'] + '_tableau'
cam = leginondata.CameraEMData(initializer=init['camera'])
tab_bin = self.settings['tableau binning']
new_bin = {
'x': tab_bin * cam['binning']['x'],
'y': tab_bin * cam['binning']['y']
}
cam['dimension'] = {'x': tabim.shape[1], 'y': tabim.shape[0]}
cam['binning'] = new_bin
tabimdata = leginondata.AcquisitionImageData(initializer=imagedata,
image=self.tabimage,
filename=filename,
camera=cam)
tabimdata.insert(force=True)
self.logger.info('Saved tableau.')
def storeCorrectorPlan(self, plan):
# import instrument here so that wx is not required unless Leginon is running
import instrument
camsettings = self.settings['camera settings']
ccdname = self.settings['instruments']['ccdcamera']
ccdcamera = self.instrument.getCCDCameraData(ccdname)
cameradata = leginondata.CameraEMData()
cameradata.update(self.settings['camera settings'])
cameradata['ccdcamera'] = ccdcamera
plandata = leginondata.CorrectorPlanData()
plandata['session'] = self.session
plandata['camera'] = cameradata
plandata['bad_rows'] = plan['rows']
plandata['bad_cols'] = plan['columns']
plandata['bad_pixels'] = plan['pixels']
plandata['despike'] = plan['despike']
plandata['despike size'] = plan['despike size']
plandata['despike threshold'] = plan['despike threshold']
plandata.insert(force=True)
def makeAlignedImageData(old_imagedata,
new_camdata,
new_array,
alignlabel='a'):
'''
Prepare ImageData to be uploaded after alignment
'''
label_string = '-%s' % (alignlabel)
camdata = leginondata.CameraEMData(
initializer=new_camdata) # new CameraEMData for the aligned image
align_presetdata = leginondata.PresetData(
initializer=old_imagedata['preset'])
if old_imagedata['preset'] is None:
old_name = 'ma'
align_presetdata = leginondata.PresetData(
name='ma-%s' % (label_string),
magnification=old_imagedata['scope']['magnification'],
defocus=old_imagedata['scope']['defocus'],
tem=old_imagedata['scope']['tem'],
ccdcamera=camdata['ccdcamera'],
session=old_imagedata['session'],
)
else:
old_name = align_presetdata['name']
align_presetdata['name'] = old_name + label_string
align_presetdata['dimension'] = camdata['dimension']
align_presetdata['binning'] = camdata['binning']
align_presetdata['offset'] = camdata['offset']
align_presetdata['exposure time'] = camdata['exposure time']
# make new imagedata with the align_preset amd aligned CameraEMData
imagedata = leginondata.AcquisitionImageData(initializer=old_imagedata)
imagedata['preset'] = align_presetdata
imagefilename = imagedata['filename']
bits = imagefilename.split(old_name)
before_string = old_name.join(bits[:-1])
newfilename = align_presetdata['name'].join((before_string, bits[-1]))
imagedata['camera'] = camdata
imagedata['camera']['align frames'] = True
imagedata['image'] = new_array
imagedata['filename'] = makeUniqueImageFilename(imagedata, old_name,
align_presetdata['name'])
return imagedata
def retrievePlan(self, camdata):
qcam = leginondata.CameraEMData()
qcam['ccdcamera'] = camdata['ccdcamera']
qcam['dimension'] = camdata['dimension']
qcam['offset'] = camdata['offset']
qcam['binning'] = camdata['binning']
qplan = leginondata.CorrectionPlanData(camera=qcam)
plandatalist = qplan.query(results=1)
if plandatalist:
plandata = plandatalist[0]
result = {}
result['rows'] = list(plandata['bad_rows'])
result['columns'] = list(plandata['bad_cols'])
if plandata['bad_pixels'] is None:
result['pixels'] = []
else:
result['pixels'] = list(plandata['bad_pixels'])
return result
else:
return {'rows': [], 'columns': [], 'pixels': []}
def getBrightImageFromNorm(self, normdata):
'''
Get bright image used to produce the norm image
This is made to be back compatible to early leginondata that
has no bright image association but would be the closest in time before
the norm was calculated
'''
if normdata is None:
return None
# newer leginon data will have bright image associated with norm image
if 'bright' in normdata.keys() and normdata['bright'] is not None:
return normdata['bright']
# bright image may have the same CameraEMData
q = leginondata.BrightImageData(camera=normdata['camera'])
brightresults = q.query(results=1)
if brightresults:
return brightresults[0]
# otherwise need to look up timestamp
timestamp = normdata.timestamp
normcam = normdata['camera']
qcam = leginondata.CameraEMData(dimension=normcam['dimension'],
offset=normcam['offset'],
binning=normcam['binning'],
ccdcamera=normcam['ccdcamera'])
qcam['exposure type'] = 'normal'
qcam['energy filtered'] = normcam['energy filtered']
qcam['gain index'] = normcam['gain index']
normscope = normdata['scope']
qscope = leginondata.ScopeEMData(tem=normscope['tem'])
qscope['high tension'] = normscope['high tension']
q = leginondata.BrightImageData(camera=qcam,
scope=qscope,
channel=normdata['channel'])
brightlist = q.query()
for brightdata in brightlist:
if brightdata.timestamp < timestamp:
break
return brightdata
gaindict['meanlst'] = meanlst
gaindict['stdlst'] = stdlst
gaindict['timelst'] = timelst
gaindict['templst'] = templst
return gaindict
if __name__ == '__main__':
args = parseArguments()
totalimages = args.n
sinedon.setConfig('leginondata')
darkq = leginondata.DarkImageData()
camq = leginondata.CameraEMData()
camq['binning'] = {'y': long(args.b), 'x': long(args.b)}
camq['dimension'] = {'y': long(args.y), 'x': long(args.x)}
darkq['camera'] = camq
print "querying dark images"
darkdata = darkq.query(results=totalimages)
darkdata.reverse()
darkd = getGainInfo(darkdata, totalimages)
brightq = leginondata.BrightImageData()
brightq['camera'] = camq
print "querying bright images"
brightdata = brightq.query(results=totalimages)
brightdata.reverse()
brightd = getGainInfo(brightdata, totalimages)
def getImageCameraEMData(self): camdata = leginondata.CameraEMData(initializer=self.image['camera']) return camdata
def calculateMosaicImage(self):
'''
calculates (but does not generate) an unscaled mosaic image
'''
if not self.tiles:
return
param = self.calibrationclient.parameter()
## calculate parameter center of final mosaic image
center = {'x': 0.0, 'y': 0.0}
for tile in self.tiles:
tileparam = tile.imagedata['scope'][param]
center['x'] += tileparam['x']
center['y'] += tileparam['y']
n = len(self.tiles)
center['x'] /= n
center['y'] /= n
self.center = center
## Calculate pixel vector on final image to center of
## each tile.
## To use calibrationclient's itransform method, we need
## a fake image from which to calculate a pixel vector
## Maybe could use an actual final image leginondata.
someimage = self.tiles[0].imagedata
self.fakescope = leginondata.ScopeEMData(initializer=someimage['scope'])
self.fakescope[param] = dict(someimage['scope'][param])
self.fakescope[param].update(center)
## assume the final fake image has same binning as first tile
self.fakecamera = leginondata.CameraEMData(initializer=someimage['camera'])
tile0 = self.tiles[0]
mosaic0 = mosaic1 = None
for tile in self.tiles:
tileparam = {}
## calculate the parameter shift from center of
## mosaic image to center of tile
for axis in ('x','y'):
tileparam[axis] = tile.imagedata['scope'][param][axis]
## calculate corresponding pixel shift (float)
center2center = self.positionByCalibration(tileparam)
## for targeting, until it's fixed
tile.position = center2center
## pixel shift mosaic center to tile center (int)
center2center = self.round(center2center)
tile.center_vect = center2center
## pixel shift from center of mosaic to corners of tile
shape = tile.image.shape
corner_vect = center2center[0]-shape[0]/2, center2center[1]-shape[1]/2
corner1_vect = corner_vect[0]+shape[0], corner_vect[1]+shape[1]
tile.corner_vect = corner_vect
## check if this is a min or max in the mosaic
if mosaic0 is None:
mosaic0 = [corner_vect[0], corner_vect[1]]
mosaic1 = [corner1_vect[0], corner1_vect[1]]
for axis in (0,1):
if corner_vect[axis] < mosaic0[axis]:
mosaic0[axis] = corner_vect[axis]
if corner1_vect[axis] > mosaic1[axis]:
mosaic1[axis] = corner1_vect[axis]
## mosaic shape at full scale
self.mosaicshape = mosaic1[0]-mosaic0[0], mosaic1[1]-mosaic0[1]
## center of mosaic image
mosaic_center = self.mosaicshape[0]/2, self.mosaicshape[1]/2
## position of corner and center
for tile in self.tiles:
corner_pos = tile.corner_vect[0]-mosaic0[0], tile.corner_vect[1]-mosaic0[1]
center_pos = tile.center_vect[0]-mosaic0[0], tile.center_vect[1]-mosaic0[1]
tile.corner_pos = corner_pos
tile.center_pos = center_pos
mod['encore'] = 'asdf'
md['other'] = mod
scopedata = leginondata.ScopeEMData(('scopeasdf', ),
initializer={
'magnification': 1501,
'beam tilt': {
'x': 1.1,
'y': 2.2
}
})
cameradata = leginondata.CameraEMData(('camasdf', ),
initializer={
'exposure time': 510,
'binning': {
'x': 1,
'y': 1
}
})
## PresetData
pdata = leginondata.NewPresetData(('pdata', 1))
pdata['name'] = 'hole3'
pdata['magnification'] = 1900
pdata['spot size'] = 4
pdata['beam shift'] = {'x': 5.5, 'y': 9.3}
pdata['exposure time'] = 500
pdata['binning'] = {'x': 8, 'y': 8}
## PresetImageData: contains PresetData
mydata = leginondata.NewPresetImageData(('pidata', 1))
mydata['preset'] = pdata
## beam tilt correction induced by image shift
beamtiltclient = self.calclients['beam tilt']
tem = self.instrument.getTEMData()
cam = self.instrument.getCCDCameraData()
ht = self.instrument.tem.HighTension
mag = self.instrument.tem.Magnification
imageshift = self.instrument.tem.getImageShift()
self.beamtilt0 = self.instrument.tem.getBeamTilt()
try:
beamtilt = beamtiltclient.transformImageShiftToBeamTilt(imageshift, tem, cam, ht, self.beamtilt0, mag)
self.instrument.tem.BeamTilt = beamtilt
self.logger.info("beam tilt for image acquired (%.4f,%.4f)" % (self.instrument.tem.BeamTilt['x'],self.instrument.tem.BeamTilt['y']))
except Exception, e:
raise NoMoveCalibration(e)
if self.settings['adjust time by tilt'] and abs(stagea) > 10 * 3.14159 / 180:
camdata = leginondata.CameraEMData()
camdata.friendly_update(presetdata)
old_time = camdata['exposure time']
new_time = old_time / math.cos(stagea)
if new_time > 5000 or new_time <= 1:
self.logger.warning('Ignore unreasonable exposure time at %d ms' % new_time)
new_time = old_time
camdata['exposure time'] = new_time
self.logger.info('scale exposure time from %d to %d by cos(%d)' % (old_time,new_time,int(stagea*180/3.14159)))
self.instrument.setData(camdata)
self.onTarget = True
self.setStatus('processing')
return status
def acquireCCD(self, presetdata, emtarget=None,channel=None):
targetdata = emtarget['target']
