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()