def initFindAndFit(parameters): """ Initialize and return a SplinerFinderFitter object. """ # Create spline object. spline_fn = splineToPSF.loadSpline(parameters.getAttr("spline")) # Create peak finder. finder = fitting.PeakFinderArbitraryPSF(parameters=parameters, psf_object=spline_fn) # Create cubicFitC.CSplineFit object. mfitter = initFitter(finder, parameters, spline_fn) # Create peak fitter. fitter = fitting.PeakFitterArbitraryPSF(mfitter=mfitter, parameters=parameters) # Specify which properties we want from the analysis. properties = [ "background", "error", "height", "iterations", "significance", "sum", "x", "y", "z" ] return fitting.PeakFinderFitter(peak_finder=finder, peak_fitter=fitter, properties=properties)
def __init__(self, parameters): fitting.PeakFinder.__init__(self, parameters) self.height_rescale = [] self.mfilter = [] self.mfilter_z = [] self.z_value = [] # Load the spline. self.s_to_psf = splineToPSF.loadSpline(parameters.getAttr("spline")) # Update margin based on the spline size. old_margin = self.margin self.margin = int((self.s_to_psf.getSize() + 1)/4 + 2) self.mfilter_z = parameters.getAttr("z_value", [0.0]) for zval in self.mfilter_z: self.z_value.append(self.s_to_psf.getScaledZ(zval)) if parameters.hasAttr("peak_locations"): # Correct for any difference in the margins. self.peak_locations[:,utilC.getXCenterIndex()] += self.margin - old_margin self.peak_locations[:,utilC.getYCenterIndex()] += self.margin - old_margin # Provide the "correct" starting z value. self.peak_locations[:,utilC.getZCenterIndex()] = self.z_value[0]
def __init__(self, parameters): self.fista_iterations = parameters.getAttr("fista_iterations") self.fista_lambda = parameters.getAttr("fista_lambda") self.fista_number_z = parameters.getAttr("fista_number_z") self.fista_threshold = parameters.getAttr("fista_threshold") self.fista_timestep = parameters.getAttr("fista_timestep") self.fista_upsample = parameters.getAttr("fista_upsample") self.spline_file = parameters.getAttr("spline") self.rball = None self.wbgr = None # Load spline to get size. self.spline_file = parameters.getAttr("spline") s_to_psf = splineToPSF.loadSpline(self.spline_file) # Update margin based on the spline size. self.margin = int((s_to_psf.getSize() + 1) / 4 + 2) if parameters.hasAttr("rb_radius"): self.rball = rollingBall.RollingBall( parameters.getAttr("rb_radius"), parameters.getAttr("rb_sigma")) else: self.wbgr_iterations = parameters.getAttr("wbgr_iterations") self.wbgr_threshold = parameters.getAttr("wbgr_threshold") self.wbgr_wavelet_level = parameters.getAttr("wbgr_wavelet_level") self.wbgr = waveletBGR.WaveletBGR() self.fdecon = None
def __init__(self, parameters): self.fista_iterations = parameters.getAttr("fista_iterations") self.fista_lambda = parameters.getAttr("fista_lambda") self.fista_number_z = parameters.getAttr("fista_number_z") self.fista_threshold = parameters.getAttr("fista_threshold") self.fista_timestep = parameters.getAttr("fista_timestep") self.fista_upsample = parameters.getAttr("fista_upsample") self.spline_file = parameters.getAttr("spline") self.rball = None self.wbgr = None # Load spline to get size. self.spline_file = parameters.getAttr("spline") s_to_psf = splineToPSF.loadSpline(self.spline_file) # Update margin based on the spline size. self.margin = int((s_to_psf.getSize() + 1)/4 + 2) if parameters.hasAttr("rb_radius"): self.rball = rollingBall.RollingBall(parameters.getAttr("rb_radius"), parameters.getAttr("rb_sigma")) else: self.wbgr_iterations = parameters.getAttr("wbgr_iterations") self.wbgr_threshold = parameters.getAttr("wbgr_threshold") self.wbgr_wavelet_level = parameters.getAttr("wbgr_wavelet_level") self.wbgr = waveletBGR.WaveletBGR() self.fdecon = None
def initFindAndFit(parameters): """ Initialize and return a SplinerFISTAFinderFitter object. """ # Create spline object. spline_fn = splineToPSF.loadSpline(parameters.getAttr("spline")) # Create peak finder. finder = SplinerFISTAPeakFinder(parameters = parameters, psf_object = spline_fn) # Create cubicFitC.CSplineFit object. mfitter = findPeaksStd.initFitter(finder, parameters, spline_fn) # Create peak fitter. fitter = fitting.PeakFitterArbitraryPSF(mfitter = mfitter, parameters = parameters) # Specify which properties we want from the analysis. properties = ["background", "error", "height", "sum", "x", "y", "z"] return fitting.PeakFinderFitter(peak_finder = finder, peak_fitter = fitter, properties = properties)
def __init__(self, image_size, spline_file, number_zvals, timestep, upsample=1, check_psf=True): """ Upsample is the multiplier to use for re-sizing the image, for example upsample = 2 means to enlarge by 2x. """ self.background = numpy.zeros(image_size) self.psf_heights = [] self.upsample = int(upsample) im_size_x, im_size_y = image_size size_x = im_size_x * self.upsample size_y = im_size_y * self.upsample # Load spline. s_to_psf = splineToPSF.loadSpline(spline_file) # Get size in X and Y. self.spline_size_x = self.spline_size_y = s_to_psf.getSize() # Calculate z values to use if 3D. if (s_to_psf.getType() == "3D"): self.z_min = s_to_psf.getZMin() self.z_max = s_to_psf.getZMax() z_step = (self.z_max - self.z_min) / float(number_zvals - 1.0) self.zvals = [] for i in range(number_zvals): self.zvals.append(self.z_min + float(i) * z_step) else: self.z_min = 0.0 self.z_max = 1.0 self.zvals = [0.0] psfs = numpy.zeros((size_x, size_y, len(self.zvals))) # Add PSFs. for i in range(len(self.zvals)): psfs[:, :, i] = s_to_psf.getPSF(self.zvals[i], shape=(im_size_x, im_size_y), up_sample=upsample, normalize=True) self.psf_heights.append(numpy.max(psfs[:, :, i])) #print "fista_decon", i, numpy.max(psfs[:,:,i]) # Check PSFs. if check_psf: import os import storm_analysis.sa_library.daxwriter as daxwriter psf_data = daxwriter.DaxWriter( os.path.join(os.path.dirname(spline_file), "fista_decon_psf.dax"), psfs.shape[0], psfs.shape[1]) for i in range(psfs.shape[2]): temp = psfs[:, :, i] psf_data.addFrame(1000.0 * temp / numpy.max(temp)) psf_data.close() if 0: # Python solver (useful for debugging). print("Using Python solver.") self.fsolver = fista_3d.FISTA(psfs, timestep) else: # C solver (about 4x faster). print("Using C solver.") self.fsolver = fistaFFTC.FISTA(psfs, timestep)
parser.add_argument('--output', dest='output', type=str, required=True, help = "The name of the .tif file to save the results in.") args = parser.parse_args() # Load parameters parameters = params.ParametersSplinerFISTA().initFromFile(args.settings) # Open movie and load the first frame. movie_data = datareader.inferReader(args.movie) [x_size, y_size, z_size] = movie_data.filmSize() image = (movie_data.loadAFrame(0) - parameters.getAttr("camera_offset"))/parameters.getAttr("camera_gain") image = image.astype(numpy.float) # Load spline. psf_object = splineToPSF.loadSpline(parameters.getAttr("spline")) # Do FISTA deconvolution. fdecon = FISTADecon(image.shape, psf_object, parameters.getAttr("fista_number_z"), parameters.getAttr("fista_timestep")) if False: # Wavelet background removal. wbgr = waveletBGR.WaveletBGR() background = wbgr.estimateBG(image, parameters.getAttr("wbgr_iterations"), parameters.getAttr("wbgr_threshold"), parameters.getAttr("wbgr_wavelet_level")) else:
def __init__(self, parameters): super(MPPeakFinder, self).__init__(parameters) self.atrans = [None] self.backgrounds = [] self.bg_filter = None self.bg_filter_sigma = parameters.getAttr("bg_filter_sigma") self.check_mode = False self.height_rescale = [] self.images = [] self.mapping_filename = None self.mfilters = [] self.mfilters_z = [] self.mpu = None self.n_channels = 0 self.s_to_psfs = [] self.variances = [] self.vfilters = [] self.xt = [] self.yt = [] self.z_values = [] # Print warning about check mode if self.check_mode: print("Warning: Running in check mode.") # Load the splines. for spline_attr in mpUtilC.getSplineAttrs(parameters): self.s_to_psfs.append( splineToPSF.loadSpline(parameters.getAttr(spline_attr))) self.n_channels += 1 # Assert that all the splines are the same size. for i in range(1, len(self.s_to_psfs)): assert (self.s_to_psfs[0].getSize() == self.s_to_psfs[i].getSize()) # # Update margin based on the spline size. Note the assumption # that all of the splines are the same size, or at least smaller # than the spline for plane 0. # old_margin = self.margin self.margin = int((self.s_to_psfs[0].getSize() + 1) / 4 + 2) # Load the plane to plane mapping data & create affine transform objects. mappings = {} if parameters.hasAttr("mapping"): if os.path.exists(parameters.getAttr("mapping")): self.mapping_filename = parameters.getAttr("mapping") with open(parameters.getAttr("mapping"), 'rb') as fp: mappings = pickle.load(fp) # Use self.margin - 1, because we added 1 to the x,y coordinates when we saved them. for i in range(self.n_channels - 1): self.xt.append( mpUtilC.marginCorrect(mappings["0_" + str(i + 1) + "_x"], self.margin - 1)) self.yt.append( mpUtilC.marginCorrect(mappings["0_" + str(i + 1) + "_y"], self.margin - 1)) self.atrans.append( affineTransformC.AffineTransform(xt=self.xt[i], yt=self.yt[i])) # # Note the assumption that the splines for each plane all use # the same z scale / have the same z range. # self.mfilters_z = parameters.getAttr("z_value", [0.0]) for zval in self.mfilters_z: self.z_values.append(self.s_to_psfs[0].getScaledZ(zval)) if parameters.hasAttr("peak_locations"): # Correct for any difference in the margins. self.peak_locations[:, utilC.getXCenterIndex( )] += self.margin - old_margin self.peak_locations[:, utilC.getYCenterIndex( )] += self.margin - old_margin # Provide the "correct" starting z value. # # FIXME: Should also allow the user to specify the peak z location # as any fixed value could be so far off for some of the # localizations that the fitting will fail. # self.peak_locations[:, utilC.getZCenterIndex()] = self.z_values[0]