Examples with AggregatedImageSource gdsc.smlm.results.AggregatedImageSource used on opensource projects

Example 1 with AggregatedImageSource

use of gdsc.smlm.results.AggregatedImageSource in project GDSC-SMLM by aherbert.

the class PSFEstimator method calculateStatistics.

private boolean calculateStatistics(PeakFit fitter, double[] params, double[] params_dev) {
    debug("  Fitting PSF");
    swapStatistics();
    // Create the fit engine using the PeakFit plugin
    FitConfiguration fitConfig = config.getFitConfiguration();
    fitConfig.setInitialAngle((float) params[0]);
    fitConfig.setInitialPeakStdDev0((float) params[1]);
    fitConfig.setInitialPeakStdDev1((float) params[2]);
    ImageStack stack = imp.getImageStack();
    Rectangle roi = stack.getProcessor(1).getRoi();
    ImageSource source = new IJImageSource(imp);
    // Allow interlaced data by wrapping the image source
    if (interlacedData) {
        source = new InterlacedImageSource(source, dataStart, dataBlock, dataSkip);
    }
    // Allow frame aggregation by wrapping the image source
    if (integrateFrames > 1) {
        source = new AggregatedImageSource(source, integrateFrames);
    }
    fitter.initialiseImage(source, roi, true);
    fitter.addPeakResults(this);
    fitter.initialiseFitting();
    FitEngine engine = fitter.createFitEngine();
    // Use random slices
    int[] slices = new int[stack.getSize()];
    for (int i = 0; i < slices.length; i++) slices[i] = i + 1;
    Random rand = new Random();
    rand.shuffle(slices);
    IJ.showStatus("Fitting ...");
    // Use multi-threaded code for speed
    int i;
    for (i = 0; i < slices.length; i++) {
        int slice = slices[i];
        //debug("  Processing slice = %d\n", slice);
        IJ.showProgress(size(), settings.numberOfPeaks);
        ImageProcessor ip = stack.getProcessor(slice);
        // stack processor does not set the bounds required by ImageConverter
        ip.setRoi(roi);
        FitJob job = new FitJob(slice, ImageConverter.getData(ip), roi);
        engine.run(job);
        if (sampleSizeReached() || Utils.isInterrupted()) {
            break;
        }
    }
    if (Utils.isInterrupted()) {
        IJ.showProgress(1);
        engine.end(true);
        return false;
    }
    // Wait until we have enough results
    while (!sampleSizeReached() && !engine.isQueueEmpty()) {
        IJ.showProgress(size(), settings.numberOfPeaks);
        try {
            Thread.sleep(50);
        } catch (InterruptedException e) {
            break;
        }
    }
    // End now if we have enough samples
    engine.end(sampleSizeReached());
    IJ.showStatus("");
    IJ.showProgress(1);
    // This count will be an over-estimate given that the provider is ahead of the consumer
    // in this multi-threaded system
    debug("  Processed %d/%d slices (%d peaks)", i, slices.length, size());
    setParams(ANGLE, params, params_dev, sampleNew[ANGLE]);
    setParams(X, params, params_dev, sampleNew[X]);
    setParams(Y, params, params_dev, sampleNew[Y]);
    if (settings.showHistograms) {
        int[] idList = new int[NAMES.length];
        int count = 0;
        boolean requireRetile = false;
        for (int ii = 0; ii < 3; ii++) {
            if (sampleNew[ii].getN() == 0)
                continue;
            StoredDataStatistics stats = new StoredDataStatistics(sampleNew[ii].getValues());
            idList[count++] = Utils.showHistogram(TITLE, stats, NAMES[ii], 0, 0, settings.histogramBins, "Mean = " + Utils.rounded(stats.getMean()) + ". Median = " + Utils.rounded(sampleNew[ii].getPercentile(50)));
            requireRetile = requireRetile || Utils.isNewWindow();
        }
        if (requireRetile && count > 0) {
            new WindowOrganiser().tileWindows(Arrays.copyOf(idList, count));
        }
    }
    if (size() < 2) {
        log("ERROR: Insufficient number of fitted peaks, terminating ...");
        return false;
    }
    return true;
}

Example 2 with AggregatedImageSource

use of gdsc.smlm.results.AggregatedImageSource in project GDSC-SMLM by aherbert.

the class PeakFit method showDialog.

@SuppressWarnings("unchecked")
private int showDialog(ImagePlus imp) {
    // Executing as an ImageJ plugin.
    // Override the defaults with those in the configuration file
    final String filename = SettingsManager.getSettingsFilename();
    if (simpleFit) {
        return showSimpleDialog(filename);
    }
    GlobalSettings settings = SettingsManager.loadSettings(filename);
    calibration = settings.getCalibration();
    config = settings.getFitEngineConfiguration();
    fitConfig = config.getFitConfiguration();
    resultsSettings = settings.getResultsSettings();
    boolean isCrop = (bounds != null && imp != null && (bounds.width < imp.getWidth() || bounds.height < imp.getHeight()));
    if (!extraOptions) {
        integrateFrames = 1;
        resultsSettings.imageRollingWindow = 0;
        fitConfig.setBackgroundFitting(true);
        fitConfig.setMinIterations(0);
        fitConfig.setNoise(0);
        config.setNoiseMethod(Method.QUICK_RESIDUALS_LEAST_MEAN_OF_SQUARES);
        showProcessedFrames = false;
    }
    ExtendedGenericDialog gd = new ExtendedGenericDialog(TITLE);
    gd.addHelp(About.HELP_URL);
    gd.addMessage((maximaIdentification) ? "Identify candidate maxima" : "Fit 2D Gaussian to identified maxima");
    String[] templates = ConfigurationTemplate.getTemplateNames(true);
    gd.addChoice("Template", templates, templates[0]);
    gd.addStringField("Config_file", filename, 40);
    gd.addNumericField("Calibration (nm/px)", calibration.getNmPerPixel(), 2);
    gd.addNumericField("Gain (ADU/photon)", calibration.getGain(), 2);
    gd.addCheckbox("EM-CCD", calibration.isEmCCD());
    gd.addNumericField("Exposure_time (ms)", calibration.getExposureTime(), 2);
    if (isCrop)
        gd.addCheckbox("Ignore_bounds_for_noise", optionIgnoreBoundsForNoise);
    // This is already set to false before the dialog is displayed
    //else
    //	ignoreBoundsForNoise = false;
    gd.addNumericField("Initial_StdDev0", fitConfig.getInitialPeakStdDev0(), 3);
    if (!maximaIdentification) {
        gd.addNumericField("Initial_StdDev1", fitConfig.getInitialPeakStdDev1(), 3);
        gd.addNumericField("Initial_Angle", fitConfig.getInitialAngle(), 3);
    }
    String[] filterTypes = SettingsManager.getNames((Object[]) DataFilterType.values());
    gd.addChoice("Spot_filter_type", filterTypes, filterTypes[config.getDataFilterType().ordinal()]);
    String[] filterNames = SettingsManager.getNames((Object[]) DataFilter.values());
    gd.addChoice("Spot_filter", filterNames, filterNames[config.getDataFilter(0).ordinal()]);
    gd.addSlider("Smoothing", 0, 2.5, config.getSmooth(0));
    gd.addSlider("Search_width", 0.5, 2.5, config.getSearch());
    gd.addSlider("Border", 0.5, 2.5, config.getBorder());
    gd.addSlider("Fitting_width", 2, 4.5, config.getFitting());
    if (extraOptions && !fitMaxima) {
        gd.addCheckbox("Interlaced_data", optionInterlacedData);
        gd.addSlider("Integrate_frames", 1, 5, optionIntegrateFrames);
    }
    Component discardLabel = null;
    if (!maximaIdentification) {
        gd.addMessage("--- Gaussian fitting ---");
        String[] solverNames = SettingsManager.getNames((Object[]) FitSolver.values());
        gd.addChoice("Fit_solver", solverNames, solverNames[fitConfig.getFitSolver().ordinal()]);
        String[] functionNames = SettingsManager.getNames((Object[]) FitFunction.values());
        gd.addChoice("Fit_function", functionNames, functionNames[fitConfig.getFitFunction().ordinal()]);
        if (extraOptions)
            gd.addCheckbox("Fit_background", fitConfig.isBackgroundFitting());
        // Parameters specific to each Fit solver are collected in a second dialog 
        gd.addNumericField("Fail_limit", config.getFailuresLimit(), 0);
        gd.addCheckbox("Include_neighbours", config.isIncludeNeighbours());
        gd.addSlider("Neighbour_height", 0.01, 1, config.getNeighbourHeightThreshold());
        gd.addSlider("Residuals_threshold", 0.01, 1, config.getResidualsThreshold());
        gd.addSlider("Duplicate_distance", 0, 1.5, fitConfig.getDuplicateDistance());
        gd.addMessage("--- Peak filtering ---\nDiscard fits that shift; are too low; or expand/contract");
        discardLabel = gd.getMessage();
        gd.addCheckbox("Smart_filter", fitConfig.isSmartFilter());
        gd.addCheckbox("Disable_simple_filter", fitConfig.isDisableSimpleFilter());
        gd.addSlider("Shift_factor", 0.01, 2, fitConfig.getCoordinateShiftFactor());
        gd.addNumericField("Signal_strength", fitConfig.getSignalStrength(), 2);
        gd.addNumericField("Min_photons", fitConfig.getMinPhotons(), 0);
        if (extraOptions) {
            gd.addNumericField("Noise", fitConfig.getNoise(), 2);
            String[] noiseMethodNames = SettingsManager.getNames((Object[]) Method.values());
            gd.addChoice("Noise_method", noiseMethodNames, noiseMethodNames[config.getNoiseMethod().ordinal()]);
        }
        gd.addSlider("Min_width_factor", 0, 0.99, fitConfig.getMinWidthFactor());
        gd.addSlider("Width_factor", 1.01, 5, fitConfig.getWidthFactor());
        gd.addNumericField("Precision", fitConfig.getPrecisionThreshold(), 2);
    }
    gd.addMessage("--- Results ---");
    gd.addCheckbox("Log_progress", resultsSettings.logProgress);
    if (!maximaIdentification) {
        gd.addCheckbox("Show_deviations", resultsSettings.showDeviations);
    }
    String[] tableNames = SettingsManager.getNames((Object[]) ResultsTable.values());
    gd.addChoice("Results_table", tableNames, tableNames[resultsSettings.getResultsTable().ordinal()]);
    String[] imageNames = SettingsManager.getNames((Object[]) ResultsImage.values());
    gd.addMessage("--- Image output ---");
    gd.addChoice("Image", imageNames, imageNames[resultsSettings.getResultsImage().ordinal()]);
    gd.addCheckbox("Weighted", resultsSettings.weightedImage);
    gd.addCheckbox("Equalised", resultsSettings.equalisedImage);
    gd.addSlider("Image_Precision (nm)", 5, 30, resultsSettings.precision);
    gd.addSlider("Image_Scale", 1, 15, resultsSettings.imageScale);
    if (extraOptions) {
        gd.addNumericField("Image_window", resultsSettings.imageRollingWindow, 0);
        gd.addCheckbox("Show_processed_frames", optionShowProcessedFrames);
    }
    gd.addMessage("--- File output ---");
    gd.addStringField("Results_dir", resultsSettings.resultsDirectory);
    String[] formatNames = SettingsManager.getNames((Object[]) ResultsFileFormat.values());
    gd.addChoice("Results_format", formatNames, formatNames[resultsSettings.getResultsFileFormat().ordinal()]);
    gd.addMessage(" ");
    gd.addCheckbox("Results_in_memory", resultsSettings.resultsInMemory);
    if (extraOptions) {
        gd.addMessage("--- Misc ---");
        gd.addSlider("Fraction_of_threads", 0.1, 1, fractionOfThreads);
    }
    if (gd.getLayout() != null) {
        GridBagLayout grid = (GridBagLayout) gd.getLayout();
        int xOffset = 0, yOffset = 0;
        int lastY = -1, rowCount = 0;
        for (Component comp : gd.getComponents()) {
            // Check if this should be the second major column
            if (comp == discardLabel) {
                xOffset += 2;
                yOffset -= rowCount;
            }
            // Reposition the field
            GridBagConstraints c = grid.getConstraints(comp);
            if (lastY != c.gridy)
                rowCount++;
            lastY = c.gridy;
            c.gridx = c.gridx + xOffset;
            c.gridy = c.gridy + yOffset;
            c.insets.left = c.insets.left + 10 * xOffset;
            c.insets.top = 0;
            c.insets.bottom = 0;
            grid.setConstraints(comp, c);
        }
        if (IJ.isLinux())
            gd.setBackground(new Color(238, 238, 238));
    }
    // Add a mouse listener to the config file field
    if (Utils.isShowGenericDialog()) {
        Vector<TextField> texts = (Vector<TextField>) gd.getStringFields();
        Vector<TextField> numerics = (Vector<TextField>) gd.getNumericFields();
        Vector<Checkbox> checkboxes = (Vector<Checkbox>) gd.getCheckboxes();
        Vector<Choice> choices = (Vector<Choice>) gd.getChoices();
        int n = 0;
        int t = 0;
        int b = 0;
        int ch = 0;
        Choice textTemplate = choices.get(ch++);
        textTemplate.addItemListener(this);
        textConfigFile = texts.get(t++);
        textConfigFile.addMouseListener(this);
        textConfigFile.addTextListener(this);
        // TODO: add a value changed listener to detect when typing a new file
        textNmPerPixel = numerics.get(n++);
        textGain = numerics.get(n++);
        textEMCCD = checkboxes.get(b++);
        textExposure = numerics.get(n++);
        textInitialPeakStdDev0 = numerics.get(n++);
        if (!maximaIdentification) {
            textInitialPeakStdDev1 = numerics.get(n++);
            textInitialAngleD = numerics.get(n++);
        }
        textDataFilterType = choices.get(ch++);
        textDataFilter = choices.get(ch++);
        textSmooth = numerics.get(n++);
        textSearch = numerics.get(n++);
        textBorder = numerics.get(n++);
        textFitting = numerics.get(n++);
        if (extraOptions && !fitMaxima) {
            // Skip over the interlaced data option
            b++;
            // Skip over the integrate frames option
            n++;
        }
        if (!maximaIdentification) {
            textFitSolver = choices.get(ch++);
            textFitFunction = choices.get(ch++);
            if (extraOptions)
                textFitBackground = checkboxes.get(b++);
            textFailuresLimit = numerics.get(n++);
            textIncludeNeighbours = checkboxes.get(b++);
            textNeighbourHeightThreshold = numerics.get(n++);
            textResidualsThreshold = numerics.get(n++);
            textDuplicateDistance = numerics.get(n++);
            textSmartFilter = checkboxes.get(b++);
            textDisableSimpleFilter = checkboxes.get(b++);
            textCoordinateShiftFactor = numerics.get(n++);
            textSignalStrength = numerics.get(n++);
            textMinPhotons = numerics.get(n++);
            if (extraOptions) {
                textNoise = numerics.get(n++);
                textNoiseMethod = choices.get(ch++);
            }
            textMinWidthFactor = numerics.get(n++);
            textWidthFactor = numerics.get(n++);
            textPrecisionThreshold = numerics.get(n++);
            updateFilterInput();
            textSmartFilter.addItemListener(this);
            textDisableSimpleFilter.addItemListener(this);
        }
        textLogProgress = checkboxes.get(b++);
        if (!maximaIdentification)
            textShowDeviations = checkboxes.get(b++);
        textResultsTable = choices.get(ch++);
        textResultsImage = choices.get(ch++);
        textWeightedImage = checkboxes.get(b++);
        textEqualisedImage = checkboxes.get(b++);
        textPrecision = numerics.get(n++);
        textImageScale = numerics.get(n++);
        if (extraOptions) {
            textImageRollingWindow = numerics.get(n++);
            // Skip over show processed frames option
            b++;
        }
        textResultsDirectory = texts.get(t++);
        textResultsDirectory.addMouseListener(this);
        textBinaryResults = choices.get(ch++);
        textResultsInMemory = checkboxes.get(b++);
    }
    gd.showDialog();
    // The refreshSettings method can be called by the dialog listener.
    // This updates the Calibration, FitEngineConfiguration, and ResultsSettings so set these
    // back in the GlobalSettings object.
    settings.setCalibration(this.calibration);
    settings.setFitEngineConfiguration(this.config);
    settings.setResultsSettings(this.resultsSettings);
    if (gd.wasCanceled() || !readDialog(settings, gd, isCrop))
        return DONE;
    if (imp != null) {
        // Store whether the user selected to process all the images.
        int flags = IJ.setupDialog(imp, plugin_flags);
        // Check if cancelled
        if ((flags & DONE) != 0)
            return DONE;
        if ((flags & DOES_STACKS) == 0) {
            // Save the slice number for the overlay
            singleFrame = imp.getCurrentSlice();
            // Account for interlaced data
            if (interlacedData) {
                int start = singleFrame;
                // Calculate the first frame that is not skipped
                while (ignoreFrame(start) && start > dataStart) start--;
                if (start < dataStart) {
                    log("The current frame (%d) is before the start of the interlaced data", singleFrame);
                    return DONE;
                }
                if (start != singleFrame)
                    log("Updated the current frame (%d) to a valid interlaced data frame (%d)", singleFrame, start);
                singleFrame = start;
            }
            // Account for integrated frames
            int endFrame = singleFrame;
            if (integrateFrames > 1) {
                int totalFrames = 1;
                while (totalFrames < integrateFrames) {
                    endFrame++;
                    if (!ignoreFrame(endFrame))
                        totalFrames++;
                }
                log("Updated the image end frame (%d) to %d allow %d integrated frames", singleFrame, endFrame, integrateFrames);
            }
            // Create a new image source with the correct frames
            setSource(new IJImageSource(imp, singleFrame, endFrame - singleFrame));
            // Store the image so the results can be added as an overlay
            this.imp = imp;
            this.imp.setOverlay(null);
        }
    }
    // Allow interlaced data by wrapping the image source
    if (interlacedData) {
        setSource(new InterlacedImageSource(this.source, dataStart, dataBlock, dataSkip));
    }
    // Allow frame aggregation by wrapping the image source
    if (integrateFrames > 1) {
        setSource(new AggregatedImageSource(this.source, integrateFrames));
    }
    // Ask if the user wants to log progress on multiple frame images
    if (resultsSettings.logProgress && source.getFrames() > 1) {
        gd = new ExtendedGenericDialog(TITLE);
        gd.addMessage("Warning: Log progress on multiple-frame image will be slow");
        gd.addCheckbox("Log_progress", resultsSettings.logProgress);
        gd.showDialog();
        if (gd.wasCanceled())
            return DONE;
        resultsSettings.logProgress = gd.getNextBoolean();
        if (!resultsSettings.logProgress)
            SettingsManager.saveSettings(settings, filename);
    }
    // Get a bias if required
    if (resultsSettings.getResultsTable() == ResultsTable.CALIBRATED && calibration.getBias() == 0) {
        gd = new ExtendedGenericDialog(TITLE);
        gd.addMessage("Calibrated results requires a camera bias");
        gd.addNumericField("Camera_bias (ADUs)", calibration.getBias(), 2);
        gd.showDialog();
        if (!gd.wasCanceled()) {
            calibration.setBias(Math.abs(gd.getNextNumber()));
            if (calibration.getBias() > 0)
                SettingsManager.saveSettings(settings, filename);
        }
    }
    // single call to be made.
    return plugin_flags;
}