def filterTargets(self, targetlist):
self.logger.info('filtering target list: convolve targets with a raster')
newlist = []
angledeg = self.settings['raster angle']
anglerad = math.radians(angledeg)
# define goodindices for raster convolution
limitangledeg = self.settings['ellipse angle']
limitanglerad = math.radians(limitangledeg)
# use ellipse diameter to define raster limit
limita = self.settings['ellipse a'] / 2.0
limitb = self.settings['ellipse b'] / 2.0
# create raster
for target in targetlist:
tiltoffset = self.researchPattern(target)
self.goodindices = raster.createIndices2(limita,limitb,limitanglerad-anglerad,self.settings['limiting shape'],self.settings['raster offset'],self.is_odd,tiltoffset)
self.savePattern(target)
oldtarget = leginondata.AcquisitionImageTargetData(initializer=target)
self.targetdata = oldtarget
rasterpoints = self.makeRaster()
for rp in rasterpoints:
newtarget = leginondata.AcquisitionImageTargetData(initializer=target)
newtarget['delta row'] += rp[0]
newtarget['delta column'] += rp[1]
newtarget['fromtarget'] = target
newlist.append(newtarget)
if not self.test or len(targetlist) % 2:
self.is_odd = not self.is_odd
self.setOffsetToolBar()
self.donetargetids.append(target.dbid)
return newlist
def filterTargets(self, targetlist):
limit = self.settings['limit']
self.logger.info('filtering target list: use center %d targets' %
limit)
newlist = []
distlist = []
targetdistances = {}
for target in targetlist:
print target.dbid
oldtarget = leginondata.AcquisitionImageTargetData(
initializer=target)
dist = oldtarget['delta row']**2 + oldtarget['delta column']**2
while dist in distlist:
dist += 0.0001
targetdistances[dist] = target
distlist.append(dist)
distlist.sort()
targetnumber = len(distlist)
outputnumber = min([targetnumber, limit])
for i in range(0, outputnumber):
target = targetdistances[distlist[i]]
newtarget = leginondata.AcquisitionImageTargetData(
initializer=target)
newtarget['fromtarget'] = target
newlist.append(newtarget)
return newlist
def filterTargets(self, targetlist):
self.logger.info(
'filtering target list: sampling extreme and median intensity stats'
)
newlist = []
meanlist = []
targetmeans = {}
if not targetlist:
return []
if not targetlist[0]['image']:
return targetlist
imagearray = targetlist[0]['image']['image']
shape = imagearray.shape
half_length = self.settings['square length'] / 2
for target in targetlist:
oldtarget = leginondata.AcquisitionImageTargetData(
initializer=target)
row, col = oldtarget['delta row'] + shape[0] / 2, oldtarget[
'delta column'] + shape[1] / 2
rowrange = (max(0,
row - half_length), min(shape[0],
row + half_length))
colrange = (max(0,
col - half_length), min(shape[0],
col + half_length))
mean = imagearray[rowrange[0]:rowrange[1],
colrange[0]:colrange[1]].mean()
stdv = imagearray[rowrange[0]:rowrange[1],
colrange[0]:colrange[1]].std()
#make an unique key for the dictionary targetmeans
while mean in targetmeans.keys():
mean = mean + 0.0001
targetmeans[mean] = target
meanlist.append(mean)
meanlist.sort()
targetnumber = len(meanlist)
outputnumbers = []
outputnumbers.extend(range(0, self.settings['dark number']))
outputnumbers.extend(
range(targetnumber - self.settings['bright number'], targetnumber))
median_start = targetnumber / 2 - self.settings['median number'] / 2
outputnumbers.extend(
range(median_start, median_start + self.settings['median number']))
# get unique and sorted list
outputnumbers = list(set(outputnumbers))
# create a new target list with these filtered targets
for i in outputnumbers:
mean = meanlist[i]
target = targetmeans[mean]
newtarget = leginondata.AcquisitionImageTargetData(
initializer=target)
newtarget['fromtarget'] = target
newlist.append(newtarget)
return newlist
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 getSiblings(self): siblings = [] if self.imagedata: targetlistdata = self.imagedata['target']['list'] targetq = leginondata.AcquisitionImageTargetData(list=targetlistdata,type='acquisition') siblings = leginondata.AcquisitionImageData(target=targetq).query() return siblings
def copyTargetList(self, targetlistdata):
#make and publish new targetlist
alltargets = self.researchTargets(list=targetlistdata)
newtargetlistdata = self.newTargetList()
newtargetlistdata.update(targetlistdata)
self.publish(newtargetlistdata, database=True, dbforce=True)
#fill the list with targets
newtargets = []
newimages = {}
for target in alltargets:
if target['status'] not in ('done', 'aborted'):
parentimage = target.special_getitem('image',readimages=False,dereference=True)
parentid = parentimage.dbid
if parentid not in newimages.keys():
newimagedata = self.copyImage(parentimage)
newimages[parentid] = newimagedata
else:
newimagedata = newimages[parentid]
newtarget = leginondata.AcquisitionImageTargetData(initializer=target)
newtarget['fromtarget'] = target
newtarget['list'] = newtargetlistdata
newtarget['image'] = newimagedata
newtarget.insert(force=True)
newtargets.append(newtarget)
if newtargets:
return newtargetlistdata
else:
return None
def reacquire(self, targetdata, use_parent_mover=False):
'''
Reacquire parent image that created the targetdata but at current stage z.
'''
### get old image
oldimage = None
targetlist = targetdata['list']
# targetdata may be outdated due to other target adjustment
# This query gives the most recent target of the same specification
tquery = leginondata.AcquisitionImageTargetData(session=self.session, list=targetlist, number=targetdata['number'], type=targetdata['type'])
aquery = leginondata.AcquisitionImageData(target=tquery)
results = aquery.query(readimages=False, results=1)
if len(results) > 0:
oldimage = results[0]
if oldimage is None:
if targetlist:
self.logger.error('No image is acquired with target list %d' % targetlist.dbid)
return None
oldemtarget = oldimage['emtarget']
movetype = oldemtarget['movetype']
try:
emtarget = self.targetToEMTargetData(targetdata,movetype)
except InvalidStagePosition:
self.logger.error('Invalid new emtarget')
return None
oldpresetdata = oldimage['preset']
presetname = oldpresetdata['name']
channel = int(oldimage['correction channel']==0)
self._moveToLastFocusedStageZ()
self.imageMoveAndPreset(oldimage,emtarget,use_parent_mover)
targetdata = emtarget['target']
try:
imagedata = self.acquireCorrectedCameraImageData(channel)
except Exception, exc:
self.logger.error('Reacquire image failed: %s' % (exc,))
def reportTargetStatus(self, target, status):
# look up most recent version of this target
tquery = leginondata.AcquisitionImageTargetData()
tquery['session'] = target['session']
tquery['list'] = target['list']
tquery['number'] = target['number']
tquery['type'] = target['type']
mostrecent = tquery.query(results=1)
if mostrecent:
mostrecent = mostrecent[0]
else:
mostrecent = target
newtarget = leginondata.AcquisitionImageTargetData(initializer=mostrecent, status=status)
newtarget.insert(force=True)
self.logger.debug('target stored in DB: %s, %s' % (newtarget.dbid, status))
return newtarget
def makeTransformTarget(self, target, offset):
newtarget = leginondata.AcquisitionImageTargetData(initializer=target)
# Fix here about version
newtarget['delta row'] = target['delta row'] + offset['y']
newtarget['delta column'] = target['delta column'] + offset['x']
newtarget['fromtarget'] = target
newtarget.insert(force=True)
self.logger.info('target adjusted by (%.1f,%.1f) (column, row)' % (offset['x'],offset['y']))
return newtarget
def focusDone(self, targetlistdata):
self.logger.info(
'focus already done at previous tilt, forcing focus target status=done'
)
targetlist = self.getFocusTargets(targetlistdata)
for targetdata in targetlist:
donetarget = leginondata.AcquisitionImageTargetData(
initializer=targetdata, status='done')
self.publish(donetarget, database=True)
def lastTargetNumberOnMosaic(self, imagelist): qimagedata = leginondata.AcquisitionImageData() qimagedata['list'] = imagelist targetquery = leginondata.AcquisitionImageTargetData(image=qimagedata, status='new') targets = self.research(datainstance=targetquery, results=1) if targets: for target in targets: if target['number'] is not None: return target['number'] return 0
def appendOtherTargets(self, alltargets, newtargets):
filteredtype = self.settings['target type']
for target in alltargets:
if target['type'] != filteredtype and target['status'] not in (
'done', 'aborted'):
newtarget = leginondata.AcquisitionImageTargetData(
initializer=target)
newtarget['delta row'] = target['delta row']
newtarget['delta column'] = target['delta column']
if newtarget not in newtargets:
newtargets.append(newtarget)
return newtargets
def removeDeletedTransformedTargets(self):
deltapositions = []
donetargets = []
currenttargets = self.getTargets(self.childimagedata, 'transformed',
None)
for i, target in enumerate(currenttargets):
deltapositions.append(
(target['delta column'], target['delta row']))
for i, target in enumerate(self.childprevioustargets):
if (target['delta column'],
target['delta row']) not in deltapositions:
#find the ancestor target made from transformed target and remove it
targetq = leginondata.AcquisitionImageTargetData(
fromtarget=self.childprevioustargets[i])
donetargets = targetq.query()
for j in donetargets:
done_target = leginondata.AcquisitionImageTargetData(
initializer=donetargets[0], status='done')
self.publish(done_target, database=True)
#mark transformed target done, too
done_target = leginondata.AcquisitionImageTargetData(
initializer=self.childprevioustargets[i], status='done')
self.publish(done_target, database=True)
def getLastFocusedStageZ(self, targetdata):
if not targetdata or not targetdata['last_focused']:
return None
# FIX ME: This only works if images are taken with the last_focused
# ImageTargetListData. Not ideal. Can not rely on FocusResultData since
# manual z change is not recorded and it is not possible to distinguish
# true failuer from "fail" at eucentric focus as the contrast is lost.
qt = leginondata.AcquisitionImageTargetData(
list=targetdata['last_focused'])
images = leginondata.AcquisitionImageData(
target=qt, session=targetdata['session']).query(results=1)
if images:
z = images[0]['scope']['stage position']['z']
return z
def newTarget(self, drow, dcol, **kwargs): ''' create new AcquistionImageTargetData and fill in all fields ''' targetdata = leginondata.AcquisitionImageTargetData(initializer=kwargs) targetdata['delta row'] = drow targetdata['delta column'] = dcol if 'session' not in kwargs: targetdata['session'] = self.session if 'version' not in kwargs: targetdata['version'] = 0 if 'status' not in kwargs: targetdata['status'] = 'new' return targetdata
def reacquire(self, targetdata, use_parent_mover=False):
'''
Reacquire parent image that created the targetdata but at current stage z.
'''
### get old image
oldimage = None
targetlist = targetdata['list']
# targetdata may be outdated due to other target adjustment
# This query gives the most recent target of the same specification
tquery = leginondata.AcquisitionImageTargetData(
session=self.session,
list=targetlist,
number=targetdata['number'],
type=targetdata['type'])
aquery = leginondata.AcquisitionImageData(target=tquery)
results = aquery.query(readimages=False, results=1)
if len(results) > 0:
oldimage = results[0]
if oldimage is None:
if targetlist:
self.logger.error('No image is acquired with target list %d' %
targetlist.dbid)
return None
oldemtarget = oldimage['emtarget']
movetype = oldemtarget['movetype']
try:
emtarget = self.targetToEMTargetData(targetdata, movetype)
except InvalidStagePosition:
self.logger.error('Invalid new emtarget')
return None
oldpresetdata = oldimage['preset']
presetname = oldpresetdata['name']
channel = int(oldimage['correction channel'] == 0)
self._moveToLastFocusedStageZ()
stagenow = self.instrument.tem.StagePosition
msg = 'after moveToLastFocusedStageZ z %.6f' % stagenow['z']
self.logger.debug(msg)
# z is not changed within imageMoveAndPreset
status = self.imageMoveAndPreset(oldimage, emtarget, use_parent_mover)
targetdata = emtarget['target']
# extra wait for falcon protector or normalization
self.logger.info('Wait for %.1f second before reaquire' %
self.settings['pause time'])
time.sleep(self.settings['pause time'])
try:
imagedata = self.acquireCorrectedCameraImageData(channel)
except Exception, exc:
self.logger.error('Reacquire image failed: %s' % (exc, ))
def handleTargetListDone(self, evt):
if not self.settings['process']:
self.logger.info('processing turned off, ignoring event')
return
self.setStatus('processing')
targetlistdata = evt['targetlist']
# query images resulting from this targetlist
tquery = leginondata.AcquisitionImageTargetData(list=targetlistdata)
imquery = leginondata.AcquisitionImageData(target=tquery)
## query, but don't read image files yet, or else run out of memory
imagelist = imquery.query(readimages=False)
## list is reverse chronological, so reverse it
imagelist.reverse()
self.processImageList(imagelist)
self.setStatus('idle')
def matrixTransformOne(self, target, matrix,newimage=None):
row = target['delta row']
col = target['delta column']
rowcolmatrix = numpy.dot((row,col,1), matrix)
newtarget = leginondata.AcquisitionImageTargetData(initializer=target)
# Fix here about version
newtarget['image'] = newimage
newtarget['delta row'] = rowcolmatrix[0,0]
newtarget['delta column'] = rowcolmatrix[0,1]
newtarget['fromtarget'] = target
# newimagedata can be none if it is from a virtual grid for atlas
if newimage is not None:
newtarget['version'] = newimage['version']
newtarget['scope'] = newimage['scope']
newtarget['camera'] = newimage['camera']
newtarget['preset'] = newimage['preset']
newtarget.insert(force=True)
return newtarget
def reacquireImage(self,
imagedata,
test=False,
target=None,
griddata=None):
presetname = imagedata['preset']['name']
self.logger.debug('preset name: %s' % (presetname, ))
presetdata = self.presetsclient.getPresetFromDB(presetname)
try:
t = 'TEM'
self.instrument.setTEM(presetdata['tem']['name'])
t = 'CCD Camera'
self.instrument.setCCDCamera(presetdata['ccdcamera']['name'])
except (ValueError, TypeError, AttributeError, KeyError):
self.logger.error('Cannot access %s for preset' % t)
if test:
return False
else:
return None
targetdata = leginondata.AcquisitionImageTargetData(
initializer=imagedata['target'])
emtargetdata = leginondata.EMTargetData(
initializer=imagedata['emtarget'])
movetype = emtargetdata['movetype']
calclient = self.calibrationclients[movetype]
row = -targetdata['delta row']
column = -targetdata['delta column']
if target is not None:
row -= target[0]
column -= target[1]
target = {'row': row, 'col': column}
scope, camera = targetdata['scope'], targetdata['camera']
try:
scopedata = calclient.transform(target, scope, camera)
except calibrationclient.NoMatrixCalibrationError, e:
self.logger.error('No calibration for reacquisition: %s' % e)
if test:
return False
else:
return None
def researchTargets(self, **kwargs):
targetquery = leginondata.AcquisitionImageTargetData(**kwargs)
targets = targetquery.query()
# organize by list, number, version, status
organized = {}
for target in targets:
if target['list'] is None:
targetlist = None
else:
targetlist = target['list'].dbid
if targetlist not in organized:
organized[targetlist] = {}
number = target['number']
version = target['version']
status = target['status']
if number not in organized[targetlist]:
organized[targetlist][number] = {'version': 0, 'targets': {}}
recentversion = organized[targetlist][number]['version']
if version > recentversion:
organized[targetlist][number]['version'] = version
organized[targetlist][number]['targets'] = {status: target}
elif version == recentversion:
organized[targetlist][number]['targets'][status] = target
final = []
tls = organized.keys()
tls.sort()
for targetlist in tls:
numbers = organized[targetlist].keys()
numbers.sort()
for number in numbers:
statuses = organized[targetlist][number]['targets'].keys()
## take only most recent status in this order:
for status in ('done', 'aborted', 'processing', 'new'):
if status in organized[targetlist][number]['targets']:
final.append(
organized[targetlist][number]['targets'][status])
break
return final
def submitTargets(self):
targetlistdata = self.targetlistdata
alltargets = self.alltargets
newtargets = self.newtargets
totaloldtargetcount = self.getAllTargetCount(alltargets)
self.markTargetsDone(alltargets)
self.logger.info('Original targets marked done.')
newtargetlistdata = self.newTargetList()
newtargetlistdata.update(targetlistdata)
self.publish(newtargetlistdata, database=True, dbforce=True)
for i, filteredtarget in enumerate(newtargets):
## original targets are getting through the filter somehow.
## need to make sure we are publishing copies of them.
newtarget = leginondata.AcquisitionImageTargetData(
initializer=filteredtarget)
newtarget['list'] = newtargetlistdata
newtarget['number'] = i + 1 + totaloldtargetcount
self.publish(newtarget, database=True, dbforce=True)
return newtargetlistdata
def transformTargets(self, matrix, targets): points = targetPoints(targets) shape = targetShape(targets[0]) points = corners(points, shape) newpoints = self.transformPoints(matrix, points) centerpoints = centers(newpoints, shape) newtargets = [] for centerpoint,target in zip(centerpoints,targets): tiltedtarget = leginondata.AcquisitionImageTargetData(initializer=target) tiltedtarget['delta row'] = centerpoint[0] tiltedtarget['delta column'] = centerpoint[1] tiltedtarget['version'] = 0 newtargets.append(tiltedtarget) displaypoints = transposePoints(newpoints) self.setTargets(displaypoints, 'Peak') return newtargets
def getTiltSeries(self, targetdata, presetdata): ''' targetdata argument is target about to be acquired. Find the tilt series that this new image will belong to if it exists, otherwise create a new tilt series. ''' commontarget = targetdata['image']['target'] targetnumber = targetdata['number'] qimage1 = leginondata.AcquisitionImageData(target=commontarget) qtarget = leginondata.AcquisitionImageTargetData(image=qimage1, number=targetnumber) qpreset = leginondata.PresetData(name=presetdata['name'], session=presetdata['session']) qimage2 = leginondata.AcquisitionImageData(target=qtarget, preset=qpreset, session=presetdata['session']) images = self.research(qimage2, readimages=False) if images: tiltseries = images[0]['tilt series'] defocus = images[0]['scope']['defocus'] else: tiltseries = None defocus = None return tiltseries, defocus
def acquire(self, presetdata, emtarget=None, attempt=None, target=None):
'''
this replaces Acquisition.acquire()
Instead of acquiring an image, we acquire a series of beam tilt images
'''
if self.catchBadSettings(presetdata) == 'error':
return 'error'
self.rpixelsize = None
self.defocus = presetdata['defocus']
## sometimes have to apply or un-apply deltaz if image shifted on
## tilted specimen
if emtarget is None:
self.deltaz = 0
else:
self.deltaz = emtarget['delta z']
# aquire and save the focus image
oldbt = self.instrument.tem.BeamTilt
tiltlist, anglelist, radlist = self.getBeamTiltList()
## initialize a new tableau
self.initTableau()
## first target is the one given, the remaining are created now
emtargetlist = []
emtargetlist.append(emtarget)
for i in range(len(tiltlist) - 1):
## check if target is simulated or not
if target['type'] == 'simulated':
newtarget = self.newSimulatedTarget(preset=presetdata)
newemtarget = leginondata.EMTargetData(initializer=emtarget,
target=newtarget)
else:
lastnumber = self.lastTargetNumber(image=target['image'],
session=self.session)
newnumber = lastnumber + 1
newtarget = leginondata.AcquisitionImageTargetData(
initializer=target, number=newnumber)
newemtarget = leginondata.EMTargetData(initializer=emtarget,
target=newtarget)
newemtarget.insert(force=True)
emtargetlist.append(newemtarget)
displace = []
for i, bt in enumerate(tiltlist):
emtarget = emtargetlist[i]
if i == 0:
channel = 0
else:
channel = 1
self.logger.info('Old beam tilt: %.4f, %.4f' % (
oldbt['x'],
oldbt['y'],
))
newbt = {'x': oldbt['x'] + bt['x'], 'y': oldbt['y'] + bt['y']}
self.instrument.tem.BeamTilt = newbt
self.logger.info('New beam tilt: %.4f, %.4f' % (
newbt['x'],
newbt['y'],
))
status = manualfocuschecker.ManualFocusChecker.acquire(
self, presetdata, emtarget, channel=channel)
imagedata = self.imagedata
# get these values once
if not self.rpixelsize or not self.ht or not self.cs:
self.rpixelsize = self.btcalclient.getImageReciprocalPixelSize(
imagedata)
self.ht = imagedata['scope']['high tension']
self.cs = imagedata['scope']['tem']['cs']
self.setImage(imagedata['image'], 'Image')
self.instrument.tem.BeamTilt = oldbt
angle = anglelist[i]
rad = radlist[i]
if self.settings['tableau type'] == 'split image-power':
self.splitTableau(imagedata)
elif 'beam tilt series' in self.settings['tableau type']:
self.insertTableau(imagedata, angle, rad)
if self.settings['tableau type'] == 'beam tilt series-image':
try:
shiftinfo = self.correlateOriginal(i, imagedata)
except Exception, e:
self.logger.error('Failed correlation: %s' % e)
return 'error'
pixelshift = shiftinfo['pixel shift']
displace.append((pixelshift['row'], pixelshift['col']))
# prompt user to confirm session before modifying database
prompt = """Found the following session:
Name: %s
User: %s %s
Comment: %s
Type "ok" if this is the correct session: """ % (
sessiondata['name'], sessiondata['user']['firstname'],
sessiondata['user']['lastname'], sessiondata['comment'])
response = raw_input(prompt)
if response != 'ok':
print 'no change to database'
sys.exit(1)
# find targets in this session
targetq = leginondata.AcquisitionImageTargetData(session=sessiondata)
targets = targetq.query()
print 'Found %d target records. Searching for targets not done...' % (
len(targets), )
# for each target, insert new target with status = 'done'
targetdict = {}
targetdatadict = {}
for target in targets:
imref = target.special_getitem('image', dereference=False)
if imref is None:
filename = 'None'
else:
im = imref.dataclass.direct_query(imref.dbid, readimages=False)
filename = im['filename']
else:
return None
if test:
return True
# check stage position
if movetype == 'modeled stage position':
scopeparam = 'stage position'
else:
scopeparam = movetype
emtargetdata[scopeparam] = dict(scopedata[scopeparam])
emtargetdata['target'] = targetdata
#emtargetdata['preset'] = presetdata
query = leginondata.AcquisitionImageTargetData()
query['session'] = self.session
query['preset'] = leginondata.PresetData()
query['preset']['name'] = presetname
query['grid'] = griddata
try:
targetdata['number'] = max(
[r['number'] for r in self.research(query)]) + 1
except ValueError:
targetdata['number'] = 0
self.logger.debug('new number: %s' % (targetdata['number'], ))
targetdata['preset'] = presetdata
targetdata['grid'] = griddata
targetdata['version'] = 0
targetdata['status'] = 'done'
class Reference(watcher.Watcher, targethandler.TargetHandler):
panelclass = gui.wx.Reference.ReferencePanel
settingsclass = leginondata.ReferenceSettingsData
eventinputs = watcher.Watcher.eventinputs + \
presets.PresetsClient.eventinputs + \
[event.ReferenceTargetPublishEvent]
eventoutputs = watcher.Watcher.eventoutputs + \
presets.PresetsClient.eventoutputs
defaultsettings = {
'move type': 'stage position',
'pause time': 3.0,
'interval time': 0.0,
}
def __init__(self, *args, **kwargs):
try:
watch = kwargs['watchfor']
except KeyError:
watch = []
kwargs['watchfor'] = watch + [event.ReferenceTargetPublishEvent]
watcher.Watcher.__init__(self, *args, **kwargs)
targethandler.TargetHandler.__init__(self)
self.instrument = instrument.Proxy(self.objectservice, self.session)
self.calibration_clients = {
'image shift':
calibrationclient.ImageShiftCalibrationClient(self),
'stage position':
calibrationclient.StageCalibrationClient(self),
'modeled stage position':
calibrationclient.ModeledStageCalibrationClient(self),
'image beam shift':
calibrationclient.ImageBeamShiftCalibrationClient(self),
'beam shift':
calibrationclient.BeamShiftCalibrationClient(self),
}
self.presets_client = presets.PresetsClient(self)
self.player = player.Player(callback=self.onPlayer)
self.panel.playerEvent(self.player.state())
self.lock = threading.RLock()
self.reference_target = None
self.last_processed = None
if self.__class__ == Reference:
self.start()
def processData(self, incoming_data):
if isinstance(incoming_data, leginondata.ReferenceTargetData):
self.processReferenceTarget(incoming_data)
def processReferenceTarget(self, target_data):
self.lock.acquire()
self.reference_target = target_data
self.lock.release()
def getEMTargetData(self, check_preset_name=None):
target_data = self.reference_target
if target_data is None:
raise MoveError('no reference target available')
move_type = self.settings['move type']
calibration_client = self.calibration_clients[move_type]
target_delta_row = target_data['delta row']
target_delta_column = target_data['delta column']
pixel_shift = {'row': -target_delta_row, 'col': -target_delta_column}
target_scope = leginondata.ScopeEMData(
initializer=target_data['scope'])
for i in ['image shift', 'beam shift', 'stage position']:
target_scope[i] = dict(target_data['scope'][i])
target_camera = target_data['camera']
args = (pixel_shift, target_scope, target_camera)
try:
scope = calibration_client.transform(*args)
except calibrationclient.NoMatrixCalibrationError, e:
message = 'no %s calibration to move to reference target: %s'
raise MoveError(message % (move_type, e))
em_target_data = leginondata.EMTargetData()
if check_preset_name is None:
em_target_data['preset'] = target_data['preset']
else:
check_preset_data = self.presets_client.getPresetByName(
check_preset_name)
em_target_data['preset'] = check_preset_data
for i in ['image shift', 'beam shift']:
em_target_data[i] = em_target_data['preset'][i]
em_target_data['stage position'] = scope['stage position']
em_target_data['movetype'] = move_type
if move_type == 'modeled stage position':
scope_move_type = 'stage position'
else:
scope_move_type = move_type
em_target_data[scope_move_type] = scope[scope_move_type]
em_target_data['target'] = leginondata.AcquisitionImageTargetData(
initializer=target_data)
return em_target_data
