def _findFiducials(self, sfunc, debounce, fiducalSize): #################################################### # Find Fiducials self.mIm = numpy.ones(self.data.shape, 'f') mdnm = 1. / np.median((self.data / self.sigma).ravel()) for dri in self.driftEstInd: bs = cameraMaps.correctImage( self.md, bufferManager.dBuffer.getSlice(dri).squeeze()) bs = bs.reshape(self.data.shape) / self.sigma bs = bs * mdnm #multiply images together, thus favouring images which are on over multiple frames self.mIm = self.mIm * bs #self.mIm = numpy.absolute(self.mIm) #if not 'PSFFile' in self.md.getEntryNames(): fid_scale = max((fiducalSize / 100.) * 0.5, 0) self.ofdDr = ofind.ObjectIdentifier( self.mIm, filterRadiusLowpass=(1 + fid_scale), filterRadiusHighpass=(3 + fid_scale)) #else: # self.ofdDr = ofind_xcorr.ObjectIdentifier(self.mIm, self.md.getEntry('PSFFile'), 7, 3e-2) thres = self.calObjThresh**len(self.driftEstInd) self.ofdDr.FindObjects(thres, 0, splitter=sfunc, debounceRadius=debounce)
def fitDep(g, r, ofindThresh, dx, dy): rg = r + g #detect objects in sum image ofd = ofind.ObjectIdentifier(rg) ofd.FindObjects(ofindThresh, blurRadius=2) res_d = np.empty(len(ofd), FitResultsDType) class foo: pass md = MetaData.TIRFDefault md.chroma = foo() md.chroma.dx = dx md.chroma.dy = dy ff = FitFactory( np.concatenate((g.reshape(512, -1, 1), r.reshape(512, -1, 1)), 2), md) for i in range(len(ofd)): p = ofd[i] res_d[i] = ff.FromPoint(round(p.x), round(p.y)) return res_d
def fitIndep(g,r,ofindThresh): rg = r + g #detect objects in sum image ofd = ofind.ObjectIdentifier(rg) ofd.FindObjects(ofindThresh, blurRadius=2) res_g = np.empty(len(ofd), FitResultsDType) res_r = np.empty(len(ofd), FitResultsDType) ff_g = FitFactory(g.reshape(512,256,1), MetaData.TIRFDefault) ff_r = FitFactory(r.reshape(512,256,1), MetaData.TIRFDefault) for i in range(len(ofd)): p = ofd[i] res_g[i] = ff_g.FromPoint(round(p.x), round(p.y)) res_r[i] = ff_r.FromPoint(round(p.x), round(p.y)) return(res_g, res_r)
def __call__(self, gui=False, taskQueue=None): global dBuffer, bBuffer, dataSourceID # short-circuit if a task is generated for a frame pre-StartAt # FIXME - we should never generate tasks for these frames. if self.index < self.md.get('Analysis.StartAt', 0): logger.error( "Frame index is less than 'Analysis.StartAt', frame should not have been released for analysis. Skipping to avoid potential buffer errors." ) return fitResult(self, [], []) #create a local copy of the metadata md = copy.copy(self.md) md.tIndex = self.index md.taskQueue = taskQueue md.dataSourceID = self.dataSourceID self.roi_offset = [0, 0] #logging.debug('dataSourceID: %s, cachedDSID: %s', md.dataSourceID, bufferManager.dataSourceID) #make sure we're buffering the right data stream bufferManager.updateBuffers(md, self.dataSourceModule, self.bufferLen) self.data = bufferManager.dBuffer.getSlice(self.index) #if logger.isEnabledFor(logging.DEBUG): # logger.debug('data: min - %3.2f, max - %3.2f, mean - %3.2f' % (self.data.min(), self.data.max(), self.data.mean())) #print self.index #when camera buffer overflows, empty pictures are produced - deal with these here if self.data.max() == 0: return fitResult(self, [], []) # default background to zero self.bg = 0 if 'GPU_PREFIT' in dir(self.fitMod): if len(self.bgindices) != 0: if md.get('Analysis.GPUPCTBackground', False): # asynchronous background calc on the GPU bufferManager.bBuffer.calc_background(self.bgindices) self.bg = bufferManager.bBuffer else: # calculate now on the CPU self.bg = cameraMaps.correctImage( md, bufferManager.bBuffer.getBackground( self.bgindices)).reshape(self.data.shape) # fit module does its own prefit steps on the GPU self.data = self.data.squeeze() ff = self.fitMod.FitFactory(self.data, md, background=self.bg, noiseSigma=None) self.res = ff.FindAndFit(self.threshold, cameraMaps=cameraMaps, gui=gui) return fitResult(self, self.res, []) # squash 4th dimension # NOTE: correctImage now subtracts ADOffset self.data = cameraMaps.correctImage(md, self.data.squeeze()).reshape( (self.data.shape[0], self.data.shape[1], 1)) # calculate noise self.sigma = self.calcSigma(md, self.data) if len(self.bgindices) != 0: # calculate the background for this frame and correct this for camera characteristics self.bg = cameraMaps.correctImage( md, bufferManager.bBuffer.getBackground( self.bgindices)).reshape(self.data.shape) #if logger.isEnabledFor(logging.DEBUG): # logger.debug('data_mean: %3.2f, bg: %3.2f, sigma: %3.2f' % (self.data.mean(), self.sigma.mean(), self.bg.mean())) ############################################# # Special cases - defer object finding to fit module if self.fitModule == 'ConfocCOIR': #special case - no object finding self.res = self.fitMod.ConfocCOI(self.data, md, background=self.bg) return fitResult(self, self.res, []) if 'MULTIFIT' in dir(self.fitMod): #fit module does it's own object finding ff = self.fitMod.FitFactory(self.data, md, background=self.bg, noiseSigma=self.sigma) self.res = ff.FindAndFit(self.threshold, gui=gui, cameraMaps=cameraMaps) return fitResult(self, self.res, []) ############################################## # Find candidate molecule positions bgd = (self.data.astype('f') - self.bg) #print bgd.shape, self.calcThreshold().shape if 'Splitter.TransmittedChannel' in self.md.getEntryNames(): #don't find points in transmitted light channel transChan = md.getEntry('Splitter.TransmitedChannel') if transChan == 'Top': bgd[:, :(self.data.shape[1] / 2)] = 0 #set upper half of image to zero #define splitter mapping function (if appropriate) for use in object finding sfunc = None if self.is_splitter_fit: sfunc = self.__mapSplitterCoords #Choose which version of ofind to use if 'PRI.Axis' in self.md.getEntryNames( ) and not self.md['PRI.Axis'] == 'none': self.ofd = ofind_pri.ObjectIdentifier(bgd * (bgd > 0), md, axis=self.md['PRI.Axis']) else: # not 'PSFFile' in self.md.getEntryNames(): filtRadiusLowpass = md.getOrDefault( 'Analysis.DetectionRadiusLowpass', 1.0) filtRadiusHighpass = md.getOrDefault( 'Analysis.DetectionRadiusHighpass', 3.0) self.ofd = ofind.ObjectIdentifier( bgd * (bgd > 0), filterRadiusLowpass=filtRadiusLowpass, filterRadiusHighpass=filtRadiusHighpass) #else: #if we've got a PSF then use cross-correlation object identificatio # self.ofd = ofind_xcorr.ObjectIdentifier(bgd * (bgd > 0), md, 7, 5e-2) debounce = self.md.getOrDefault('Analysis.DebounceRadius', 5) discardClumpRadius = self.md.getOrDefault('Analysis.ClumpRejectRadius', 0) self.ofd.FindObjects(self.calcThreshold(), 0, splitter=sfunc, debounceRadius=debounce, discardClumpRadius=discardClumpRadius) #################################################### # Find Fiducials if self.driftEst: self.driftEstInd = self.index + self.md.getOrDefault( 'Analysis.DriftIndices', np.array([-10, 0, 10])) self.calObjThresh = self.md.getOrDefault( 'Analysis.FiducialThreshold', 6) fiducialROISize = self.md.getOrDefault('Analysis.FiducialROISize', 11) fiducialSize = self.md.getOrDefault('Analysis.FiducalSize', 1000.) self._findFiducials(sfunc, debounce, fiducialSize) ##################################################################### #If we are using a splitter, chop the largest common ROI out of the two channels if self.is_splitter_fit: self.data = self._splitImage(self.data) self.sigma = self._splitImage(self.sigma) if not len(self.bgindices) == 0: self.bg = self._splitImage(self.bg) #If we're running under a gui - display found objects if gui: self._displayFoundObjects() ######################################################### #Create a fit 'factory' fitFac = self.fitMod.FitFactory(self.data, md, background=self.bg, noiseSigma=self.sigma, roi_offset=self.roi_offset) if 'FitResultsDType' in dir(self.fitMod): self.res = numpy.empty(len(self.ofd), self.fitMod.FitResultsDType) if 'Analysis.ROISize' in md.getEntryNames(): rs = md.getEntry('Analysis.ROISize') for i in range(len(self.ofd)): p = self.ofd[i] self.res[i] = fitFac.FromPoint(p.x, p.y, roiHalfSize=rs) else: for i in range(len(self.ofd)): p = self.ofd[i] self.res[i] = fitFac.FromPoint(p.x, p.y) else: #legacy fit modules self.res = [fitFac.FromPoint(p.x, p.y) for p in self.ofd] #Fit Fiducials NOTE: This is potentially broken self.drRes = [] if self.driftEst: fitFac = self.fitMod.FitFactory(self.data, md, noiseSigma=self.sigma, roi_offset=self.roi_offset) nToFit = min(10, len( self.ofdDr)) #don't bother fitting lots of calibration objects if 'FitResultsDType' in dir(self.fitMod): self.drRes = numpy.empty(nToFit, self.fitMod.FitResultsDType) for i in range(nToFit): p = self.ofdDr[i] self.drRes[i] = fitFac.FromPoint( p.x, p.y, roiHalfSize=fiducialROISize) else: self.drRes = [ fitFac.FromPoint(p.x, p.y) for p in self.ofd[:nToFit] ] #print 'Fitted %d fiducials' % nToFit, len(self.drRes) return fitResult(self, self.res, self.drRes)