def __init__(self, pth, mode='r'):
if mode in ['w', 'a', 'r+'] and os.path.exists(pth):
raise RuntimeError('Cannot open existing file in write mode')
self.h5f = tables.openFile(pth, mode)
self.mode = mode
self.complevel = 6
self.complib = 'zlib'
self.mdh = MetaDataHandler.CachingMDHandler(
MetaDataHandler.HDFMDHandler(self.h5f))
if 'ImageData' in dir(self.h5f.root):
self.dshape = [
self.h5f.root.ImageData.shape[1],
self.h5f.root.ImageData.shape[2],
self.h5f.root.ImageData.shape[0]
]
else:
self.dshape = [0, 0, 0]
if 'Events' in dir(self.h5f.root):
self.nEvents = self.h5f.root.Events.shape[0]
else:
self.nEvents = 0
if mode == 'w':
self._checkCreateEventsTable()
def __init__(self,
name,
resultsFilename,
initialTasks=[],
onEmpty=doNix,
fTaskToPop=popZero):
if resultsFilename is None:
resultsFilename = genResultFileName(name)
if os.path.exists(
resultsFilename): #bail if output file already exists
raise RuntimeError('Output file already exists: ' +
resultsFilename)
TaskQueue.__init__(self, name, initialTasks, onEmpty, fTaskToPop)
self.resultsFilename = resultsFilename
self.numClosedTasks = 0
logging.info('Creating results file')
self.h5ResultsFile = tables.openFile(self.resultsFilename, 'w')
self.prepResultsFile() # pass
#self.fileResultsLock = threading.Lock()
self.fileResultsLock = tablesLock
logging.info('Creating results metadata')
self.resultsMDH = MetaDataHandler.HDFMDHandler(self.h5ResultsFile)
self.metaData = MetaDataHandler.NestedClassMDHandler()
#self.metaData = None #MetaDataHandler.NestedClassMDHandler(self.resultsMDH)
self.metaDataStale = True
self.MDHCache = []
logging.info('Creating results events table')
with self.fileResultsLock.wlock:
self.resultsEvents = self.h5ResultsFile.createTable(
self.h5ResultsFile.root,
'Events',
SpoolEvent,
filters=tables.Filters(complevel=5, shuffle=True))
logging.info('Events table created')
self.haveResultsTable = False
self.resultsQueue = [] #Queue.Queue()
self.resultsQueueLock = threading.Lock()
self.lastResultsQueuePurge = time.time()
logging.info('Results file initialised')
def Loadh5(self, filename):
'''Load PYMEs semi-custom HDF5 image data format. Offloads all the
hard work to the HDFDataSource class'''
import tables
from PYME.Analysis.DataSources import HDFDataSource, BGSDataSource
from PYME.Analysis.LMVis import inpFilt
#open hdf5 file
self.dataSource = HDFDataSource.DataSource(filename, None)
#chain on a background subtraction data source, so we can easily do
#background subtraction in the GUI the same way as in the analysis
self.data = BGSDataSource.DataSource(
self.dataSource) #this will get replaced with a wrapped version
if 'MetaData' in self.dataSource.h5File.root: #should be true the whole time
self.mdh = MetaData.TIRFDefault
self.mdh.copyEntriesFrom(
MetaDataHandler.HDFMDHandler(self.dataSource.h5File))
else:
self.mdh = MetaData.TIRFDefault
wx.MessageBox(
"Carrying on with defaults - no gaurantees it'll work well",
'ERROR: No metadata found in file ...', wx.OK)
print(
"ERROR: No metadata fond in file ... Carrying on with defaults - no gaurantees it'll work well"
)
#attempt to estimate any missing parameters from the data itself
MetaData.fillInBlanks(self.mdh, self.dataSource)
#calculate the name to use when we do batch analysis on this
from PYME.ParallelTasks.relativeFiles import getRelFilename
self.seriesName = getRelFilename(filename)
#try and find a previously performed analysis
fns = filename.split(os.path.sep)
cand = os.path.sep.join(fns[:-2] + [
'analysis',
] + fns[-2:]) + 'r'
print(cand)
if False: #os.path.exists(cand):
h5Results = tables.openFile(cand)
if 'FitResults' in dir(h5Results.root):
self.fitResults = h5Results.root.FitResults[:]
self.resultsSource = inpFilt.h5rSource(h5Results)
self.resultsMdh = MetaData.TIRFDefault
self.resultsMdh.copyEntriesFrom(
MetaDataHandler.HDFMDHandler(h5Results))
self.events = self.dataSource.getEvents()
def OnMAquireOnePic(self, event):
import numpy as np
self.scope.pa.stop()
ds2 = np.atleast_3d(
self.scope.pa.dsa.reshape(self.scope.cam.GetPicWidth(),
self.scope.cam.GetPicHeight()).copy())
#metadata handling
mdh = MetaDataHandler.NestedClassMDHandler()
mdh.setEntry('StartTime', time.time())
mdh.setEntry('AcquisitionType', 'SingleImage')
#loop over all providers of metadata
for mdgen in MetaDataHandler.provideStartMetadata:
mdgen(mdh)
im = dsviewer.ImageStack(data=ds2, mdh=mdh, titleStub='Unsaved Image')
if not im.mode == 'graph':
im.mode = 'lite'
#print im.mode
dvf = dsviewer.DSViewFrame(im, mode=im.mode, size=(500, 500))
dvf.SetSize((500, 500))
dvf.Show()
self.snapNum += 1
self.scope.pa.Prepare(True)
self.scope.pa.start()
def LoadQueue(self, filename):
'''Load data from a remote PYME.ParallelTasks.HDFTaskQueue queue using
Pyro.
Parameters:
filename the name of the queue
'''
import Pyro.core
from PYME.Analysis.DataSources import TQDataSource
from PYME.misc.computerName import GetComputerName
compName = GetComputerName()
if self.queueURI == None:
#do a lookup
taskQueueName = 'TaskQueues.%s' % compName
self.tq = Pyro.core.getProxyForURI('PYRONAME://' + taskQueueName)
else:
self.tq = Pyro.core.getProxyForURI(self.queueURI)
self.seriesName = filename[len('QUEUE://'):]
self.dataSource = TQDataSource.DataSource(self.seriesName, self.tq)
self.data = self.dataSource #this will get replaced with a wrapped version
self.mdh = MetaDataHandler.QueueMDHandler(self.tq, self.seriesName)
MetaData.fillInBlanks(self.mdh, self.dataSource)
#self.timer.WantNotification.append(self.dsRefresh)
self.events = self.dataSource.getEvents()
def getImageTags(filename):
ext = os.path.splitext(filename)[1]
#print ext
tags = []
try:
if ext in ['.h5', '.h5r']:
h5f = tables.openFile(filename)
if 'Events' in dir(h5f.root):
events = h5f.root.Events[:]
evKeyNames = set()
for e in events:
evKeyNames.add(e['EventName'])
if 'ProtocolFocus' in evKeyNames:
tags.append('Z-Stack')
md = MetaDataHandler.HDFMDHandler(h5f)
if 'Protocol.Filename' in md.getEntryNames():
tags.append('Protocol_%s' % md.getEntry('Protocol.Filename'))
h5f.close()
except:
pass
return tags
def Export(self,
data,
outFile,
xslice,
yslice,
zslice,
metadata=None,
events=None,
origName=None):
#nframes = (zslice.stop - zslice.start)/zslice.step
outDir = os.path.splitext(outFile)[0]
os.mkdir(outDir)
i = 0
for frameN in range(zslice.start, zslice.stop, zslice.step):
im = data[xslice, yslice, frameN].squeeze()[None, :, :]
for fN in range(frameN + 1, frameN + zslice.step):
im += data[xslice, yslice, fN].squeeze()[None, :, :]
Image.fromarray(im.squeeze().astype('uint16'), 'I;16').save(
os.path.join(outDir, 'frame_%03d.tif' % i))
i += 1
if not metadata == None:
xmd = MetaDataHandler.XMLMDHandler(mdToCopy=metadata)
if not origName == None:
xmd.setEntry('cropping.originalFile', origName)
xmd.setEntry('cropping.xslice', xslice.indices(data.shape[0]))
xmd.setEntry('cropping.yslice', yslice.indices(data.shape[1]))
xmd.setEntry('cropping.zslice', zslice.indices(data.shape[2]))
xmlFile = os.path.splitext(outFile)[0] + '.xml'
xmd.writeXML(xmlFile)
def genImageID(filename, guess=False):
ext = os.path.splitext(filename)[1]
#print ext
try:
if ext == '.h5':
return genDataFileID(filename)
elif ext == '.h5r':
h5f = tables.openFile(filename)
md = MetaDataHandler.HDFMDHandler(h5f)
if 'Analysis.DataFileID' in md.getEntryNames():
ret = md.getEntry('Analysis.DataFileID')
elif guess:
ret = guessH5RImageID(filename)
#print ret
else:
ret = None
#print guess, ret
h5f.close()
return ret
else:
return hashString32(filename)
except:
return hashString32(filename)
def Generate(self, event=None):
dlg = genImageDialog.GenImageDialog(self.mainWind, mode=self.mode)
ret = dlg.ShowModal()
bCurr = wx.BusyCursor()
if ret == wx.ID_OK:
mdh = MetaDataHandler.NestedClassMDHandler()
mdh['Rendering.Method'] = self.name
if 'imageID' in self.pipeline.mdh.getEntryNames():
mdh['Rendering.SourceImageID'] = self.pipeline.mdh['imageID']
mdh['Rendering.SourceFilename'] = self.pipeline.filename
for cb in renderMetadataProviders:
cb(mdh)
pixelSize = dlg.getPixelSize()
imb = self._getImBounds()
im = self.genIm(dlg, imb, mdh)
img = GeneratedImage(im,imb, pixelSize, 0, ['Image'] , mdh = mdh)
imf = ViewIm3D(img, mode='visGUI', title='Generated %s - %3.1fnm bins' % (self.name, pixelSize), glCanvas=self.visFr.glCanvas, parent=self.mainWind)
#imf = imageView.ImageViewFrame(self.visFr,img, self.visFr.glCanvas)
#imageView.MultiChannelImageViewFrame(self.visFr, self.visFr.glCanvas, img, title='Generated %s - %3.1fnm bins' % (self.name, pixelSize))
#self.visFr.generatedImages.append(imf)
#imf.Show()
self.visFr.RefreshView()
dlg.Destroy()
return imf
def OnDeconvWiener(self, event):
#from PYME.Deconv import weiner
decMDH = MetaDataHandler.NestedClassMDHandler(self.image.mdh)
decMDH['Deconvolution.OriginalFile'] = self.image.filename
decMDH['Deconvolution.Method'] = 'Wiener'
im = numpy.zeros(self.image.data.shape, 'f4')
decView = View3D(im,
'Deconvolution Result',
mdh=decMDH,
parent=self.dsviewer)
decView.wienerPanel = WienerDeconvolver(decView, self.image,
decView.image)
self.pinfo1 = aui.AuiPaneInfo().Name("wienerPanel").Left(
).Caption('Wiener Filter').DestroyOnClose(True).CloseButton(
False
) #.MinimizeButton(True).MinimizeMode(aui.AUI_MINIMIZE_CAPT_SMART|aui.AUI_MINIMIZE_POS_RIGHT)#.CaptionVisible(False)
decView._mgr.AddPane(decView.wienerPanel, self.pinfo1)
decView._mgr.Update()
self.dsviewer.decView = decView
def generateThumbnail(inputFile, thumbSize):
global size
#logging.debug('Input File: %s\n' % inputFile)
#logging.debug('Ouput File: %s\n' % outputFile)
#logging.debug('Thumb Size: %s\n' % thumbSize)
h5f = tables.openFile(inputFile)
dataSource = HDFDataSource.DataSource(inputFile, None)
md = MetaData.genMetaDataFromSourceAndMDH(
dataSource, MetaDataHandler.HDFMDHandler(h5f))
xsize = h5f.root.ImageData.shape[1]
ysize = h5f.root.ImageData.shape[2]
if xsize > ysize:
zoom = float(thumbSize) / xsize
else:
zoom = float(thumbSize) / ysize
size = (int(xsize * zoom), int(ysize * zoom))
im = h5f.root.ImageData[min(md.EstimatedLaserOnFrameNo + 10,
(h5f.root.ImageData.shape[0] -
1)), :, :].astype('f')
im = im.T - min(md.Camera.ADOffset, im.min())
h5f.close()
im = maximum(minimum(1 * (255 * im) / im.max(), 255), 0)
return im.astype('uint8')
def Export(self,
data,
outFile,
xslice,
yslice,
zslice,
metadata=None,
events=None,
origName=None):
#xmd = None
if not metadata == None:
xmd = MetaDataHandler.XMLMDHandler(mdToCopy=metadata)
if data.shape[3] > 1: #have multiple colour channels
if data.shape[2] == 1: #2d image -> stack with chans
#d = numpy.concatenate([numpy.atleast_3d(data[xslice, yslice, 0, i].squeeze()) for i in range(data.shape[3])],2)
#saveTiffStack.saveTiffMultipage(d, outFile)
mpt = saveTiffStack.TiffMP(outFile)
for i in range(data.shape[3]):
mpt.AddSlice(data[xslice, yslice, 0, i].squeeze())
mpt.close()
else: #save each channel as it's own stack
if not metadata == None and 'ChannelNames' in metadata.getEntryNames(
):
chanNames = metadata['ChannelNames']
else:
chanNames = range(data.shape[3])
chanFiles = [
os.path.splitext(os.path.split(outFile)[1])[0] +
'__%s.tif' % chanNames[i] for i in range(data.shape[3])
]
if not metadata == None:
xmd['ChannelFiles'] = chanFiles
for i in range(data.shape[3]):
saveTiffStack.saveTiffMultipage(
data[xslice, yslice, zslice, i].squeeze(),
os.path.splitext(outFile)[0] +
'__%s.tif' % chanNames[i])
else:
saveTiffStack.saveTiffMultipage(data[xslice, yslice, zslice],
outFile)
if not metadata == None:
#xmd = MetaDataHandler.XMLMDHandler(mdToCopy=metadata)
if not origName == None:
xmd.setEntry('cropping.originalFile', origName)
xmd.setEntry('cropping.xslice', xslice.indices(data.shape[0]))
xmd.setEntry('cropping.yslice', yslice.indices(data.shape[1]))
xmd.setEntry('cropping.zslice', zslice.indices(data.shape[2]))
print((xslice.indices(data.shape[0])))
xmlFile = os.path.splitext(outFile)[0] + '.xml'
xmd.writeXML(xmlFile)
def extractFramesF(inFile, outFile, start, end, complib='zlib', complevel=9):
h5in = HDFDataSource(inFile)
md = MetaDataHandler.HDFMDHandler(h5in.h5File)
extractFrames(h5in, md, h5in.h5File.filename, outFile, start, end, complib,
complevel)
h5in.release()
def getFileMetadata(filename):
ext = os.path.splitext(filename)[1]
#print ext
mdh = MetaDataHandler.NestedClassMDHandler()
try:
if ext in ['.h5', '.h5r']:
h5f = tables.openFile(filename)
md = MetaDataHandler.HDFMDHandler(h5f)
mdh = MetaDataHandler.NestedClassMDHandler(md)
#print guess, ret
h5f.close()
except:
pass
return mdh
def __init__(self, scope, filename, acquisator, protocol = p.NullProtocol, parent=None, complevel=6, complib='zlib'):
self.h5File = tables.openFile(filename, 'w')
filt = tables.Filters(complevel, complib, shuffle=True)
self.imageData = self.h5File.createEArray(self.h5File.root, 'ImageData', tables.UInt16Atom(), (0,scope.cam.GetPicWidth(),scope.cam.GetPicHeight()), filters=filt)
self.md = MetaDataHandler.HDFMDHandler(self.h5File)
self.evtLogger = EventLogger(self, scope, self.h5File)
sp.Spooler.__init__(self, scope, filename, acquisator, protocol, parent)
def extractFrames(dataSource,
metadata,
origName,
outFile,
start,
end,
subsamp=1,
complib='zlib',
complevel=5):
h5out = tables.openFile(outFile, 'w')
filters = tables.Filters(complevel, complib, shuffle=True)
nframes = end - start
xSize, ySize = dataSource.getSliceShape()
ims = h5out.createEArray(h5out.root,
'ImageData',
tables.UInt16Atom(), (0, xSize, ySize),
filters=filters,
expectedrows=nframes)
for frameN in range(start, end, subsamp):
im = dataSource.getSlice(frameN)[None, :, :]
for fN in range(frameN + 1, frameN + subsamp):
im += dataSource.getSlice(fN)[None, :, :]
ims.append(im)
ims.flush()
outMDH = MetaDataHandler.HDFMDHandler(h5out)
outMDH.copyEntriesFrom(metadata)
outMDH.setEntry('cropping.originalFile', origName)
outMDH.setEntry('cropping.start', start)
outMDH.setEntry('cropping.end', end)
outMDH.setEntry('cropping.averaging', subsamp)
if 'Camera.ADOffset' in metadata.getEntryNames():
outMDH.setEntry('Camera.ADOffset',
subsamp * metadata.getEntry('Camera.ADOffset'))
outEvents = h5out.createTable(h5out.root,
'Events',
SpoolEvent,
filters=tables.Filters(complevel=5,
shuffle=True))
#copy events to results file
evts = dataSource.getEvents()
if len(evts) > 0:
outEvents.append(evts)
h5out.flush()
h5out.close()
def OnSplitChannels(self, event):
try:
names = self.image.mdh.getEntry('ChannelNames')
except:
names = ['%d' % d for d in range(self.image.data.shape[3])]
for i in range(self.image.data.shape[3]):
mdh = MetaDataHandler.NestedClassMDHandler(self.image.mdh)
mdh.setEntry('ChannelNames', [names[i]])
View3D(self.image.data[:, :, :, i],
'%s - %s' % (self.image.filename, names[i]),
mdh=mdh,
parent=wx.GetTopLevelParent(self.dsviewer))
def __init__(self, chans, cam, shutters, _piezos, _log={}):
PreviewAquisator.__init__(self, chans, cam, shutters, None)
self.piezos = _piezos
self.log = _log
self.mdh = MetaDataHandler.NestedClassMDHandler()
#register as a provider of metadata
MetaDataHandler.provideStartMetadata.append(self.ProvideStackMetadata)
self.ScanChan = 0
self.StartMode = self.CENTRE_AND_LENGTH
self.SeqLength = 100
self.StepSize = 0.2
self.startPos = 0
self.endPos = 0
self.direction = self.FORWARDS
def pushImagesHDF(self,
startingAt=0,
detThresh=.9,
fitFcn='LatGaussFitFR'):
#global seriesName
dataFilename = self.image.seriesName
resultsFilename = genResultFileName(self.image.seriesName)
if os.path.exists(resultsFilename):
di, fn = os.path.split(resultsFilename)
i = 1
stub = os.path.splitext(fn)[0]
while os.path.exists(os.path.join(di, stub + '_%d.h5r' % i)):
i += 1
fdialog = wx.FileDialog(
None,
'Analysis file already exists, please select a new filename',
wildcard='H5R files|*.h5r',
defaultDir=di,
defaultFile=stub + '_%d.h5r' % i,
style=wx.SAVE)
succ = fdialog.ShowModal()
if (succ == wx.ID_OK):
resultsFilename = fdialog.GetPath().encode()
else:
raise RuntimeError('Invalid results file - not running')
self.image.seriesName = resultsFilename
self.tq.createQueue('HDFTaskQueue',
self.image.seriesName,
dataFilename=dataFilename,
resultsFilename=resultsFilename,
startAt='notYet')
mdhQ = MetaDataHandler.QueueMDHandler(self.tq, self.image.seriesName,
self.image.mdh)
mdhQ.setEntry('Analysis.DetectionThreshold', detThresh)
mdhQ.setEntry('Analysis.FitModule', fitFcn)
mdhQ.setEntry('Analysis.DataFileID',
fileID.genDataSourceID(self.image.dataSource))
evts = self.image.dataSource.getEvents()
if len(evts) > 0:
self.tq.addQueueEvents(self.image.seriesName, evts)
self.tq.releaseTasks(self.image.seriesName, startingAt)
def genImageTime(filename):
ext = os.path.splitext(filename)[1]
#print ext
try:
if ext in ['.h5', '.h5r']:
h5f = tables.openFile(filename)
md = MetaDataHandler.HDFMDHandler(h5f)
ret = md.getEntry('StartTime')
#print guess, ret
h5f.close()
return ret
else:
return 0
except:
return 0
def OnFitObjects(self, event):
import PYME.Analysis.FitFactories.Gauss3DFitR as fitMod
from PYME.Acquire import MetaDataHandler
chnum = self.chChannel.GetSelection()
mdh = MetaDataHandler.NestedClassMDHandler(self.image.mdh)
mdh['tIndex'] = 0
self.objFitRes = {}
for chnum in range(self.image.data.shape[3]):
data = self.image.data[:, :, :, chnum]
if not 'Camera.ADOffset' in mdh.getEntryNames():
mdh['Camera.ADOffset'] = data.min()
fitFac = fitMod.FitFactory(data, mdh)
self.objFitRes[chnum] = numpy.empty(len(self.ofd),
fitMod.FitResultsDType)
for i in range(len(self.ofd)):
p = self.ofd[i]
#try:
self.objFitRes[chnum][i] = fitFac.FromPoint(
round(p.x), round(p.y), round(p.z), 8)
#except:
# pass
#if self.nObjFit == None:
vObjFit = recArrayView.recArrayPanel(
self.dsviewer, self.objFitRes[chnum]['fitResults'])
self.dsviewer.AddPage(vObjFit,
caption='Fitted Positions %d - %d' %
(chnum, self.nObjFit))
self.nObjFit += 1
#else:
# self.vObjFit.grid.SetData(self.objFitRes['fitResults'])
self.dsviewer.update()
def __init__(self,
scope,
filename,
acquisator,
protocol=p.NullProtocol,
parent=None,
complevel=2,
complib='zlib'):
# if 'PYME_TASKQUEUENAME' in os.environ.keys():
# taskQueueName = os.environ['PYME_TASKQUEUENAME']
# else:
# taskQueueName = 'taskQueue'
from PYME.misc.computerName import GetComputerName
compName = GetComputerName()
taskQueueName = 'TaskQueues.%s' % compName
self.tq = Pyro.core.getProxyForURI('PYRONAME://' + taskQueueName)
self.tq._setOneway([
'postTask', 'postTasks', 'addQueueEvents', 'setQueueMetaData',
'logQueueEvent'
])
self.seriesName = filename
self.buffer = []
self.buflen = 30
self.tq.createQueue('HDFTaskQueue',
self.seriesName,
filename,
frameSize=(scope.cam.GetPicWidth(),
scope.cam.GetPicHeight()),
complevel=complevel,
complib=complib)
self.md = MetaDataHandler.QueueMDHandler(self.tq, self.seriesName)
self.evtLogger = EventLogger(self, scope, self.tq, self.seriesName)
sp.Spooler.__init__(self, scope, filename, acquisator, protocol,
parent)
def Export(self,
data,
outFile,
xslice,
yslice,
zslice,
metadata=None,
events=None,
origName=None):
numpy.save(outFile, data[xslice, yslice, zslice])
if not metadata == None:
xmd = MetaDataHandler.XMLMDHandler(mdToCopy=metadata)
if not origName == None:
xmd.setEntry('cropping.originalFile', origName)
xmd.setEntry('cropping.xslice', xslice.indices(data.shape[0]))
xmd.setEntry('cropping.yslice', yslice.indices(data.shape[1]))
xmd.setEntry('cropping.zslice', zslice.indices(data.shape[2]))
xmlFile = os.path.splitext(outFile)[0] + '.xml'
xmd.writeXML(xmlFile)
def __init__(self):
#list of tuples of form (class, chan, name) describing the instaled piezo channels
self.piezos = []
self.hardwareChecks = []
#entries should be of the form: "x" : (piezo, channel, multiplier)
# where multiplyier is what to multiply by to get the usints to um
self.positioning = {}
self.joystick = None
self.cameras = {}
self.camControls = {}
self.stackNum = 0
#self.WantEventNotification = []
self.StatusCallbacks = [
] #list of functions which provide status information
self.CleanupFunctions = [] #list of functions to be called at exit
self.PACallbacks = [
] #list of functions to be called when a new aquisator is created
#preview
self.saturationThreshold = 16383 #14 bit
self.lastFrameSaturated = False
#self.cam.saturationIntervened = False
self.saturatedMessage = ''
protocol.scope = self
ccdCalibrator.setScope(self)
self.initDone = False
self._OpenSettingsDB()
MetaDataHandler.provideStartMetadata.append(self.GenStartMetadata)
#provision to set global metadata values in startup script
self.mdh = MetaDataHandler.NestedClassMDHandler()
def OnAlignChannels(self, event):
#try:
# names = self.image.mdh.getEntry('ChannelNames')
#except:
# names = ['%d' % d for d in range(self.image.data.shape[3])]
from PYME.Analysis.DataSources import AlignDataSource
import PYME.DSView.dataWrap
if isinstance(self.image.data, PYME.DSView.dataWrap.ListWrap):
nd = [
AlignDataSource.DataSource(ds)
for ds in self.image.data.wrapList
]
else:
nd = [
AlignDataSource.DataSource(
dataWrap.Wrap(self.image.data[:, :, :, i]))
for i in range(self.image.data.shape[3])
]
mdh = MetaDataHandler.NestedClassMDHandler(self.image.mdh)
res = View3D(nd,
'%s - %s' % (self.image.filename, 'align'),
mdh=mdh,
parent=wx.GetTopLevelParent(self.dsviewer))
res.panAlign = ShiftPanel(res)
pinfo1 = aui.AuiPaneInfo().Name("shiftPanel").Right(
).Caption('Alignment').DestroyOnClose(
True
).CloseButton(False).MinimizeButton(True).MinimizeMode(
aui.AUI_MINIMIZE_CAPT_SMART | aui.AUI_MINIMIZE_POS_RIGHT
) #.MinimizeButton(True).MinimizeMode(aui.AUI_MINIMIZE_CAPT_SMART|aui.AUI_MINIMIZE_POS_RIGHT)#.CaptionVisible(False)
#pinfo2 = aui.AuiPaneInfo().Name("overlayPanel").Right().Caption('Overlays').CloseButton(False).MinimizeButton(True).MinimizeMode(aui.AUI_MINIMIZE_CAPT_SMART|aui.AUI_MINIMIZE_POS_RIGHT)#.CaptionVisible(False)
res._mgr.AddPane(res.panAlign, pinfo1)
res._mgr.Update()
def OnMakeComposites(self, event):
import numpy as np
dlg = CompositeDialog(self.dsviewer, self.dsviewer.image)
imageNames = dlg.imageNames
#dispNames = dlg.dispNames
if dlg.ShowModal() == wx.ID_OK:
#others = [dispNames[n] for n in dlg.GetSelections()]
others = dlg.GetSelections()
#master, mchan = _getImage(dlg.GetMaster())
ignoreZ = dlg.GetIgnoreZ()
interp = dlg.GetInterp()
if interp:
order = 3
else:
order = 0
shape, origin, voxelsize = dlg.shape, dlg.origin, dlg.voxelsize
print((shape, origin, voxelsize))
if len(others) > 0:
newNames = []
newData = []
for otherN in others:
other, chan = _getImage(otherN)
try:
cn = other.mdh.getEntry('ChannelNames')[chan]
otherName = '%s - %s' % (os.path.split(
other.filename)[1], cn)
except:
if other.data.shape[3] == 1:
otherName = os.path.split(other.filename)[1]
else:
otherName = '%s - %d' % (os.path.split(
other.filename)[1], chan)
newNames.append(otherName)
if isinstance(other.data, dataWrap.ListWrap):
od = other.data.dataList[chan]
else:
od = other.data
if ignoreZ:
originsEqual = np.allclose(other.origin[:2],
origin[:2],
atol=1)
else:
originsEqual = np.allclose(other.origin,
origin,
atol=1)
shiftField = dlg.GetShiftmap(otherN)
print shape[:3], other.data.shape[:3]
if (not np.allclose(
other.pixelSize, voxelsize[0], rtol=.001)) or (
not (other.data.shape[:3] == shape[:3])) or (
not originsEqual) or shiftField:
#need to rescale ...
print(('Remapping ', otherN, originsEqual,
other.origin,
np.allclose(other.pixelSize,
voxelsize[0],
rtol=.001),
(not (other.data.shape[:3] == shape[:3])),
shiftField, other.pixelSize, ignoreZ))
#print origin, voxelsize
od = self.RemapData(other,
chan,
shape,
voxelsize,
origin,
shiftField=shiftField,
ignoreZ=ignoreZ,
order=order)
newData += [od]
pre = common_prefix(newNames)
print(pre)
lPre = len(pre)
newNames = [n[lPre:] for n in newNames]
mdh = MetaDataHandler.NestedClassMDHandler(self.image.mdh)
mdh.setEntry('ChannelNames', newNames)
mdh['voxelsize.x'] = voxelsize[0] / 1e3
mdh['voxelsize.y'] = voxelsize[1] / 1e3
mdh['voxelsize.z'] = voxelsize[2] / 1e3
mdh['Origin.x'] = origin[0]
mdh['Origin.y'] = origin[1]
mdh['Origin.z'] = origin[2]
View3D(dataWrap.ListWrap(newData, 3),
'Composite',
mdh=mdh,
mode=self.dsviewer.mode,
parent=wx.GetTopLevelParent(self.dsviewer),
glCanvas=self.dsviewer.glCanvas)
dlg.Destroy()
def Generate(self, event=None):
jitVars = ['1.0']
jitVars += self.pipeline.colourFilter.keys()
self.genMeas = self.pipeline.GeneratedMeasures.keys()
if not 'neighbourDistances' in self.genMeas:
self.genMeas.append('neighbourDistances')
if not 'neighbourErrorMin' in self.genMeas:
self.genMeas.append('neighbourErrorMin')
jitVars += self.genMeas
if 'z' in self.pipeline.mapping.keys():
zvals = self.pipeline.mapping['z']
else:
zvals = None
dlg = genImageDialog.GenImageDialog(self.mainWind, mode=self.mode, defaultPixelSize=self._defaultPixelSize, colours=self.pipeline.colourFilter.getColourChans(), zvals = zvals, jitterVariables = jitVars, jitterVarDefault=self._getDefaultJitVar(jitVars), jitterVarDefaultZ=self._getDefaultZJitVar(jitVars))
ret = dlg.ShowModal()
bCurr = wx.BusyCursor()
if ret == wx.ID_OK:
mdh = MetaDataHandler.NestedClassMDHandler()
mdh['Rendering.Method'] = self.name
if 'imageID' in self.pipeline.mdh.getEntryNames():
mdh['Rendering.SourceImageID'] = self.pipeline.mdh['imageID']
mdh['Rendering.SourceFilename'] = self.pipeline.filename
mdh.Source = MetaDataHandler.NestedClassMDHandler(self.pipeline.mdh)
for cb in renderMetadataProviders:
cb(mdh)
pixelSize = dlg.getPixelSize()
status = statusLog.StatusLogger('Generating %s Image ...' % self.name)
imb = self._getImBounds()
#record the pixel origin in nm from the corner of the camera for futrue overlays
if 'Source.Camera.ROIPosX' in mdh.getEntryNames():
#a rendered image with information about the source ROI
voxx, voxy = 1e3*mdh['Source.voxelsize.x'], 1e3*mdh['Source.voxelsize.y']
ox = (mdh['Source.Camera.ROIPosX'] - 1)*voxx + imb.x0
oy = (mdh['Source.Camera.ROIPosY'] - 1)*voxy + imb.y0
if 'Source.Positioning.PIFoc' in mdh.getEntryNames():
oz = mdh['Source.Positioning.PIFoc']*1e3
else:
oz = 0
else:
ox = imb.x0
oy = imb.y0
oz = 0
mdh['Origin.x'] = ox
mdh['Origin.y'] = oy
mdh['Origin.z'] = oz
colours = dlg.getColour()
oldC = self.pipeline.colourFilter.currentColour
ims = []
for c in colours:
self.pipeline.colourFilter.setColour(c)
ims.append(np.atleast_3d(self.genIm(dlg, imb, mdh)))
im = GeneratedImage(ims,imb, pixelSize, dlg.getZSliceThickness(), colours, mdh = mdh)
imfc = ViewIm3D(im, mode='visGUI', title='Generated %s - %3.1fnm bins' % (self.name, pixelSize), glCanvas=self.visFr.glCanvas, parent=self.mainWind)
#imfc = imageView.MultiChannelImageViewFrame(self.visFr, self.visFr.glCanvas, im, title='Generated %s - %3.1fnm bins' % (self.name, pixelSize))
#self.visFr.generatedImages.append(imfc)
#imfc.Show()
self.pipeline.colourFilter.setColour(oldC)
else:
imfc = None
dlg.Destroy()
return imfc
def __init__(self,
name,
dataFilename=None,
resultsFilename=None,
onEmpty=doNix,
fTaskToPop=popZero,
startAt='guestimate',
frameSize=(-1, -1),
complevel=6,
complib='zlib'):
if dataFilename is None:
self.dataFilename = genDataFilename(name)
else:
self.dataFilename = dataFilename
if resultsFilename is None:
resultsFilename = genResultFileName(self.dataFilename)
else:
resultsFilename = resultsFilename
ffn = getFullFilename(self.dataFilename)
self.acceptNewTasks = False
self.releaseNewTasks = False
self.postTaskBuffer = []
initialTasks = []
if os.path.exists(ffn): #file already exists - read from it
self.h5DataFile = tables.openFile(ffn, 'r')
#self.metaData = MetaData.genMetaDataFromHDF(self.h5DataFile)
self.dataMDH = MetaDataHandler.NestedClassMDHandler(
MetaDataHandler.HDFMDHandler(self.h5DataFile))
#self.dataMDH.mergeEntriesFrom(MetaData.TIRFDefault)
self.imageData = self.h5DataFile.root.ImageData
if startAt == 'guestimate': #calculate a suitable starting value
tLon = self.dataMDH.EstimatedLaserOnFrameNo
if tLon == 0:
startAt = 0
else:
startAt = tLon + 10
if startAt == 'notYet':
initialTasks = []
else:
initialTasks = list(
range(startAt, self.h5DataFile.root.ImageData.shape[0]))
self.imNum = len(self.imageData)
self.dataRW = False
else: #make ourselves a new file
self.h5DataFile = tables.openFile(ffn, 'w')
filt = tables.Filters(complevel, complib, shuffle=True)
self.imageData = self.h5DataFile.createEArray(
self.h5DataFile.root,
'ImageData',
tables.UInt16Atom(), (0, ) + tuple(frameSize),
filters=filt,
chunkshape=(1, ) + tuple(frameSize))
self.events = self.h5DataFile.createTable(self.h5DataFile.root,
'Events',
SpoolEvent,
filters=filt)
self.imNum = 0
self.acceptNewTasks = True
self.dataMDH = MetaDataHandler.HDFMDHandler(self.h5DataFile)
self.dataMDH.mergeEntriesFrom(MetaData.TIRFDefault)
self.dataRW = True
HDFResultsTaskQueue.__init__(self, name, resultsFilename, initialTasks,
onEmpty, fTaskToPop)
self.resultsMDH.copyEntriesFrom(self.dataMDH)
self.metaData.copyEntriesFrom(self.resultsMDH)
#copy events to results file
if len(self.h5DataFile.root.Events) > 0:
self.resultsEvents.append(self.h5DataFile.root.Events[:])
self.queueID = name
self.numSlices = self.imageData.shape[0]
#self.dataFileLock = threading.Lock()
self.dataFileLock = tablesLock
#self.getTaskLock = threading.Lock()
self.lastTaskTime = 0
def getMetadata(self):
return pickle.dumps(MetaDataHandler.NestedClassMDHandler(self.mdh))
def Export(self,
data,
outFile,
xslice,
yslice,
zslice,
metadata=None,
events=None,
origName=None):
h5out = tables.openFile(outFile, 'w')
filters = tables.Filters(self.complevel, self.complib, shuffle=True)
nframes = (zslice.stop - zslice.start) / zslice.step
xSize, ySize = data[xslice, yslice, 0].shape[:2]
print((xSize, ySize))
#atm = tables.UInt16Atom()
atm = tables.Atom.from_dtype(data[xslice, yslice, 0].dtype)
ims = h5out.createEArray(
h5out.root,
'ImageData',
atm, (0, xSize, ySize),
filters=filters,
expectedrows=nframes) #, chunkshape=(1,xSize,ySize))
for frameN in range(zslice.start, zslice.stop, zslice.step):
im = data[xslice, yslice, frameN].squeeze()
for fN in range(frameN + 1, frameN + zslice.step):
im += data[xslice, yslice, fN].squeeze()
if im.ndim == 1:
im = im.reshape((-1, 1))[None, :, :]
else:
im = im[None, :, :]
#print im.shape
ims.append(im)
#ims.flush()
ims.flush()
outMDH = MetaDataHandler.HDFMDHandler(h5out)
if not metadata == None:
outMDH.copyEntriesFrom(metadata)
if 'Camera.ADOffset' in metadata.getEntryNames():
outMDH.setEntry(
'Camera.ADOffset',
zslice.step * metadata.getEntry('Camera.ADOffset'))
if not origName == None:
outMDH.setEntry('cropping.originalFile', origName)
outMDH.setEntry('cropping.xslice', xslice.indices(data.shape[0]))
outMDH.setEntry('cropping.yslice', yslice.indices(data.shape[1]))
outMDH.setEntry('cropping.zslice', zslice.indices(data.shape[2]))
outEvents = h5out.createTable(h5out.root,
'Events',
SpoolEvent,
filters=tables.Filters(complevel=5,
shuffle=True))
if not events == None:
#copy events to results file
if len(events) > 0:
outEvents.append(events)
h5out.flush()
h5out.close()