def findROI(self, image): """ Finds the ROI. """ assert (image.flags['C_CONTIGUOUS']), "Image is not C contiguous!" assert ( image.dtype == numpy.float64), "Images is not numpy.float64 type." self.mxf.resetTaken() # Create convolution object, if we have not already done this. if self.fg_filter is None: fg_psf = fitting.gaussianPSF(image.shape, self.sigma) self.fg_filter = matchedFilterC.MatchedFilter(fg_psf) # Find peaks. smoothed_image = self.fg_filter.convolve(image) [x, y, z, h] = self.mxf.findMaxima([smoothed_image], want_height=True) # No peaks found check if (x.size == 0): return [0, 0, False] # Slice out ROI. max_index = numpy.argmax(h) mx = int(round(x[max_index])) + 1 my = int(round(y[max_index])) + 1 rs = self.roi_size roi = image[my - rs:my + rs, mx - rs:mx + rs] roi -= numpy.min(roi) return [mx, my, roi]
def findFitPeak(self, image): """ Returns the 2D gaussian fit to the brightest peak in the image. """ # Convert image and add offset, this is to keep the MLE fitter from # overfitting the background and/or taking logs of zero. # image = numpy.ascontiguousarray(image, dtype = numpy.float64) image += self.offset self.mxf.resetTaken() # Create the peak fitter object, if we have not already done this. # if self.mfit is None: background = numpy.zeros(image.shape) # Create convolution filter. fg_psf = fitting.gaussianPSF(image.shape, self.sigma) self.fg_filter = matchedFilterC.MatchedFilter(fg_psf) # Create fitter. self.mfit = daoFitC.MultiFitter2DFixed(roi_size = self.roi_size) #self.mfit = daoFitC.MultiFitter2D() #self.mfit = daoFitC.MultiFitter3D() #self.mfit.default_tol = 1.0e-3 self.mfit.initializeC(image) self.mfit.newImage(image) self.mfit.newBackground(background) else: self.mfit.newImage(image) # Find peaks. smoothed_image = self.fg_filter.convolve(image) [x, y, z, h] = self.mxf.findMaxima([smoothed_image], want_height = True) # No peaks found check if(x.size == 0): return [0, 0, False] max_index = numpy.argmax(h) peaks = {"x" : numpy.array([x[max_index]]), "y" : numpy.array([y[max_index]]), "z" : numpy.array([z[max_index]]), "sigma" : numpy.array([self.sigma])} # Pass peaks to fitter & fit. self.mfit.newPeaks(peaks, "finder") self.mfit.doFit(max_iterations = 50) # Check for fit convergence. if (self.mfit.getUnconverged() == 0): # Return peak location. x = self.mfit.getPeakProperty("x") y = self.mfit.getPeakProperty("y") return [y[0], x[0], True] else: return [0, 0, False]
def setVariances(self, variances): """ setVariances() customized for gaussian PSFs. """ # Make sure that the number of (sCMOS) variance arrays # matches the number of image planes. # assert (len(variances) == self.n_channels) # Pad variances to correct size. # temp = [] for variance in variances: temp.append(fitting.padArray(variance, self.margin)) variances = temp # Create "foreground" and "variance" filters. There is # only one z value here. # # These are stored in a list indexed by z value, then by # channel / plane. So self.mfilters[1][2] is the filter # for z value 1, plane 2. # self.mfilters.append([]) self.vfilters.append([]) psf_norm = fitting.gaussianPSF( variances[0].shape, self.parameters.getAttr("foreground_sigma")) var_norm = psf_norm * psf_norm for i in range(self.n_channels): self.mfilters[0].append( matchedFilterC.MatchedFilter( psf_norm, fftw_estimate=self.parameters.getAttr("fftw_estimate"), memoize=True, max_diff=1.0e-3)) self.vfilters[0].append( matchedFilterC.MatchedFilter( var_norm, fftw_estimate=self.parameters.getAttr("fftw_estimate"), memoize=True, max_diff=1.0e-3)) # Save a pictures of the PSFs for debugging purposes. if self.check_mode: print("psf max", numpy.max(psf)) filename = "psf_z0.0_c{1:d}.tif".format(j) tifffile.imsave(filename, psf.astype(numpy.float32)) # This handles the rest of the initialization. # super(MPPeakFinderDao, self).setVariances(variances) return variances
def setVariances(self, variances): """ setVariances() customized for gaussian PSFs. """ # Make sure that the number of (sCMOS) variance arrays # matches the number of image planes. # assert(len(variances) == self.n_channels) # Pad variances to correct size. # temp = [] for variance in variances: temp.append(fitting.padArray(variance, self.margin)) variances = temp # Create "foreground" and "variance" filters. There is # only one z value here. # # These are stored in a list indexed by z value, then by # channel / plane. So self.mfilters[1][2] is the filter # for z value 1, plane 2. # self.mfilters.append([]) self.vfilters.append([]) psf_norm = fitting.gaussianPSF(variances[0].shape, self.parameters.getAttr("foreground_sigma")) var_norm = psf_norm * psf_norm for i in range(self.n_channels): self.mfilters[0].append(matchedFilterC.MatchedFilter(psf_norm, memoize = True, max_diff = 1.0e-3)) self.vfilters[0].append(matchedFilterC.MatchedFilter(var_norm, memoize = True, max_diff = 1.0e-3)) # Save a pictures of the PSFs for debugging purposes. if self.check_mode: print("psf max", numpy.max(psf)) filename = "psf_z0.0_c{1:d}.tif".format(j) tifffile.imsave(filename, psf.astype(numpy.float32)) # This handles the rest of the initialization. # super(MPPeakFinderDao, self).setVariances(variances) return variances
def findFitPeak(self, image): """ Returns the optimal alignment (based on the correlation score) between a Gaussian and the brightest peak in the image. """ image = numpy.ascontiguousarray(image, dtype=numpy.float64) self.mxf.resetTaken() # Create convolution object, if we have not already done this. if self.fg_filter is None: fg_psf = fitting.gaussianPSF(image.shape, self.sigma) self.fg_filter = matchedFilterC.MatchedFilter(fg_psf) # Find peaks. smoothed_image = self.fg_filter.convolve(image) [x, y, z, h] = self.mxf.findMaxima([smoothed_image], want_height=True) # No peaks found check if (x.size == 0): return [0, 0, False] # Slice out ROI. max_index = numpy.argmax(h) mx = int(round(x[max_index])) + 1 my = int(round(y[max_index])) + 1 rs = self.roi_size roi = image[my - rs:my + rs, mx - rs:mx + rs] roi -= numpy.min(roi) # Pass to aligner and find optimal offset. self.c2dg.setImage(roi) [disp, success, fun, status] = self.c2dg.maximize() if (success) or (status == 2): return [my + disp[0] - 0.5, mx + disp[1] - 0.5, True] else: return [0, 0, False]
def setVariances(self, variances): """ We initialize the following here because at __init__ we don't know how big the images are. This is called after the analysis specific version pads the variances and creates the mfilters[] and the vfilters[] class members. Note the assumption that every frame in all the movies is the same size. """ # Create mask to limit peak finding to a user defined sub-region of the image. # self.peak_mask = fitting.peakMask(variances[0].shape, self.parameters, self.margin) # Create matched filter for background. There is one of these for # each imaging plane for the benefit of memoization. # for i in range(self.n_channels): bg_psf = fitting.gaussianPSF( variances[0].shape, self.parameters.getAttr("background_sigma")) self.bg_filters.append( matchedFilterC.MatchedFilter(bg_psf, memoize=True, max_diff=1.0e-3)) # Process variance arrays now as they don't change from frame # to frame. # # This initializes the self.variances array with a list # of lists with the same organization as foreground and # psf / variance filters. # # Use variance filter. I now think this is correct as this is # also what we are doing with the image background term. In # the case of the image background we are estimating the # variance under the assumption that it is Poisson so the # mean of the background is the variance. With the cameras # we know what the variance is because we measured it. Now # we need to weight it properly given the PSF filter that # we are applying to the foreground. # # Iterate over z values. # for i in range(len(self.mfilters)): variance = numpy.zeros(variances[0].shape) # Iterate over channels / planes. for j in range(len(self.mfilters[i])): # Convolve variance with the appropriate variance filter. conv_var = self.vfilters[i][j].convolve(variances[j]) # Transform variance to the channel 0 frame. if self.atrans[j] is None: variance += conv_var else: variance += self.atrans[j].transform(conv_var) self.variances.append(variance) # Save results if needed for debugging purposes. if self.check_mode: with tifffile.TiffWriter("camera_variances.tif") as tf: for var in self.variances: tf.save(var.astype(numpy.float32))
def setVariances(self, variances): """ We initialize the following here because at __init__ we don't know how big the images are. This is called after the analysis specific version pads the variances and creates the mfilters[] and the vfilters[] class members. Note the assumption that every frame in all the movies is the same size. """ # Create mask to limit peak finding to a user defined sub-region of the image. # self.peak_mask = fitting.peakMask(variances[0].shape, self.parameters, self.margin) # Create matched filter for background. There is one of these for # each imaging plane for the benefit of memoization. # for i in range(self.n_channels): bg_psf = fitting.gaussianPSF(variances[0].shape, self.parameters.getAttr("background_sigma")) self.bg_filters.append(matchedFilterC.MatchedFilter(bg_psf, memoize = True, max_diff = 1.0e-3)) # Process variance arrays now as they don't change from frame # to frame. # # This initializes the self.variances array with a list # of lists with the same organization as foreground and # psf / variance filters. # # Use variance filter. I now think this is correct as this is # also what we are doing with the image background term. In # the case of the image background we are estimating the # variance under the assumption that it is Poisson so the # mean of the background is the variance. With the cameras # we know what the variance is because we measured it. Now # we need to weight it properly given the PSF filter that # we are applying to the foreground. # # Iterate over z values. # for i in range(len(self.mfilters)): variance = numpy.zeros(variances[0].shape) # Iterate over channels / planes. for j in range(len(self.mfilters[i])): # Convolve variance with the appropriate variance filter. conv_var = self.vfilters[i][j].convolve(variances[j]) # Transform variance to the channel 0 frame. if self.atrans[j] is None: variance += conv_var else: variance += self.atrans[j].transform(conv_var) self.variances.append(variance) # Save results if needed for debugging purposes. if self.check_mode: with tifffile.TiffWriter("camera_variances.tif") as tf: for var in self.variances: tf.save(var.astype(numpy.float32))