Examples with Checkbox java.awt.Checkbox used on opensource projects

Example 6 with Checkbox

use of java.awt.Checkbox in project GDSC-SMLM by aherbert.

the class CreateFilters method showDialog.

private boolean showDialog() {
    GenericDialog gd = new GenericDialog(TITLE);
    gd.addHelp(About.HELP_URL);
    gd.addMessage("Create a set of filters for use in the Filter Analysis plugin.\nAttributes will be enumerated if they are of the form 'min:max:increment'");
    gs = SettingsManager.loadSettings();
    filterSettings = gs.getFilterSettings();
    gd.addTextAreas(filterSettings.filterTemplate, null, 20, 80);
    gd.addCheckbox("Enumerate_early attributes first", enumerateEarly);
    gd.addCheckbox("Show_demo_filters", false);
    if (Utils.isShowGenericDialog()) {
        Checkbox cb = (Checkbox) gd.getCheckboxes().get(1);
        cb.addItemListener(this);
    }
    gd.showDialog();
    if (gd.wasCanceled())
        return false;
    filterSettings.filterTemplate = gd.getNextText();
    enumerateEarly = gd.getNextBoolean();
    boolean demoFilters = gd.getNextBoolean();
    if (demoFilters) {
        logDemoFilters();
        return false;
    }
    return SettingsManager.saveSettings(gs);
}

Example 7 with Checkbox

use of java.awt.Checkbox 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;
}

Example 8 with Checkbox

use of java.awt.Checkbox in project GDSC-SMLM by aherbert.

the class PeakFit method itemStateChanged.

public void itemStateChanged(ItemEvent e) {
    if (e.getSource() instanceof Choice) {
        // Update the settings from the template
        Choice choice = (Choice) e.getSource();
        String templateName = choice.getSelectedItem();
        //System.out.println("Update to " + templateName);
        // Get the configuration template
        GlobalSettings template = ConfigurationTemplate.getTemplate(templateName);
        if (template != null) {
            String notes = template.getNotes();
            IJ.log("Applying template: " + templateName);
            if (!Utils.isNullOrEmpty(notes))
                IJ.log(notes);
            boolean custom = ConfigurationTemplate.isCustomTemplate(templateName);
            if (template.isFitEngineConfiguration()) {
                refreshSettings(template.getFitEngineConfiguration().clone(), custom);
            }
            if (template.isCalibration()) {
                refreshSettings(template.getCalibration().clone());
            }
            if (template.isResultsSettings()) {
                refreshSettings(template.getResultsSettings().clone());
            }
        }
    } else if (e.getSource() instanceof Checkbox) {
        if (e.getSource() == textSmartFilter) {
            // Prevent both filters being enabled
            textDisableSimpleFilter.setState(textSmartFilter.getState());
            updateFilterInput();
        } else if (e.getSource() == textDisableSimpleFilter) {
            updateFilterInput();
        } else {
            // Run the PSF Calculator
            Checkbox cb = (Checkbox) e.getSource();
            if (cb.getState()) {
                cb.setState(false);
                PSFCalculator calculator = new PSFCalculator();
                calculatorSettings.pixelPitch = calibration.getNmPerPixel() / 1000.0;
                calculatorSettings.magnification = 1;
                calculatorSettings.beamExpander = 1;
                double sd = calculator.calculate(calculatorSettings, true);
                if (sd > 0)
                    textInitialPeakStdDev0.setText(Double.toString(sd));
            }
        }
    }
}

Example 9 with Checkbox

use of java.awt.Checkbox in project GDSC-SMLM by aherbert.

the class PeakFit method getPeakWidth.

private boolean getPeakWidth() {
    ExtendedGenericDialog gd = newWizardDialog("Enter the expected peak width in pixels.", "A point source of light will not be focussed perfectly by the microscope but will appear as a spread out peak. This Point Spread Function (PSF) can be modelled using a 2D Gaussian curve.", "An optimised optical system (lens and camera sensor) should have a peak standard deviation of approximately 1 pixel when in focus. This allows the fitting routine to have enough data to identify the centre of the peak without spreading the light over too many pixels (which increases noise).", "The peak width can be estimated using the wavelength of light emitted by the single molecules and the parameters of the microscope. Use a PSF calculator by clicking the checkbox below:");
    // Add ability to run the PSF Calculator to get the width
    gd.addCheckbox("Run_PSF_calculator", false);
    gd.addNumericField("Gaussian_SD", fitConfig.getInitialPeakStdDev0(), 3);
    if (Utils.isShowGenericDialog()) {
        Checkbox cb = (Checkbox) gd.getCheckboxes().get(0);
        cb.addItemListener(this);
        textInitialPeakStdDev0 = (TextField) gd.getNumericFields().get(0);
    }
    gd.showDialog();
    if (gd.wasCanceled())
        return false;
    fitConfig.setInitialPeakStdDev(Math.abs(gd.getNextNumber()));
    return true;
}

Example 10 with Checkbox

use of java.awt.Checkbox in project GDSC-SMLM by aherbert.

the class BenchmarkSpotFit method showDialog.

@SuppressWarnings("unchecked")
private boolean showDialog() {
    GenericDialog gd = new GenericDialog(TITLE);
    gd.addHelp(About.HELP_URL);
    gd.addMessage(String.format("Fit candidate spots in the benchmark image created by " + CreateData.TITLE + " plugin\nand identified by the " + BenchmarkSpotFilter.TITLE + " plugin.\nPSF width = %s nm (Square pixel adjustment = %s nm)\n \nConfigure the fitting:", Utils.rounded(simulationParameters.s), Utils.rounded(getSa())));
    gd.addSlider("Fraction_positives", 50, 100, fractionPositives);
    gd.addSlider("Fraction_negatives_after_positives", 0, 100, fractionNegativesAfterAllPositives);
    gd.addSlider("Min_negatives_after_positives", 0, 10, negativesAfterAllPositives);
    gd.addSlider("Match_distance", 0.5, 3.5, distance);
    gd.addSlider("Lower_distance", 0, 3.5, lowerDistance);
    gd.addSlider("Match_signal", 0, 3.5, signalFactor);
    gd.addSlider("Lower_signal", 0, 3.5, lowerSignalFactor);
    // Collect options for fitting
    final double sa = getSa();
    gd.addNumericField("Initial_StdDev", Maths.round(sa / simulationParameters.a), 3);
    gd.addSlider("Fitting_width", 2, 4.5, config.getFitting());
    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()]);
    gd.addMessage("Multi-path filter (used to pick optimum results during fitting)");
    // Allow loading the best filter fot these results
    boolean benchmarkSettingsCheckbox = fitResultsId == BenchmarkFilterAnalysis.lastId;
    // This should always be an opt-in decision. Otherwise the user cannot use the previous settings
    useBenchmarkSettings = false;
    if (benchmarkSettingsCheckbox)
        gd.addCheckbox("Benchmark_settings", useBenchmarkSettings);
    gd.addTextAreas(XmlUtils.convertQuotes(multiFilter.toXML()), null, 6, 60);
    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.addCheckbox("Compute_doublets", computeDoublets);
    gd.addNumericField("Duplicate_distance", fitConfig.getDuplicateDistance(), 2);
    gd.addCheckbox("Show_score_histograms", showFilterScoreHistograms);
    gd.addCheckbox("Show_correlation", showCorrelation);
    gd.addCheckbox("Plot_rank_by_intensity", rankByIntensity);
    gd.addCheckbox("Save_filter_range", saveFilterRange);
    if (extraOptions) {
    }
    // Add a mouse listener to the config file field
    if (benchmarkSettingsCheckbox && Utils.isShowGenericDialog()) {
        Vector<TextField> numerics = (Vector<TextField>) gd.getNumericFields();
        Vector<Checkbox> checkboxes = (Vector<Checkbox>) gd.getCheckboxes();
        taFilterXml = gd.getTextArea1();
        Checkbox b = checkboxes.get(0);
        b.addItemListener(this);
        textFailLimit = numerics.get(9);
        cbIncludeNeighbours = checkboxes.get(1);
        textNeighbourHeight = numerics.get(10);
        cbComputeDoublets = checkboxes.get(2);
        if (useBenchmarkSettings) {
            FitConfiguration tmpFitConfig = new FitConfiguration();
            FitEngineConfiguration tmp = new FitEngineConfiguration(tmpFitConfig);
            // Collect the residuals threshold
            tmpFitConfig.setComputeResiduals(true);
            if (BenchmarkFilterAnalysis.updateConfiguration(tmp, false)) {
                textFailLimit.setText("" + tmp.getFailuresLimit());
                cbIncludeNeighbours.setState(tmp.isIncludeNeighbours());
                textNeighbourHeight.setText(Utils.rounded(tmp.getNeighbourHeightThreshold()));
                cbComputeDoublets.setState(tmp.getResidualsThreshold() < 1);
                final DirectFilter primaryFilter = tmpFitConfig.getSmartFilter();
                final double residualsThreshold = tmp.getResidualsThreshold();
                taFilterXml.setText(new MultiPathFilter(primaryFilter, minimalFilter, residualsThreshold).toXML());
            }
        }
    }
    gd.showDialog();
    if (gd.wasCanceled())
        return false;
    fractionPositives = Math.abs(gd.getNextNumber());
    fractionNegativesAfterAllPositives = Math.abs(gd.getNextNumber());
    negativesAfterAllPositives = (int) Math.abs(gd.getNextNumber());
    distance = Math.abs(gd.getNextNumber());
    lowerDistance = Math.abs(gd.getNextNumber());
    signalFactor = Math.abs(gd.getNextNumber());
    lowerSignalFactor = Math.abs(gd.getNextNumber());
    fitConfig.setInitialPeakStdDev(gd.getNextNumber());
    config.setFitting(gd.getNextNumber());
    fitConfig.setFitSolver(gd.getNextChoiceIndex());
    fitConfig.setFitFunction(gd.getNextChoiceIndex());
    boolean myUseBenchmarkSettings = false;
    if (benchmarkSettingsCheckbox)
        //useBenchmarkSettings = 
        myUseBenchmarkSettings = gd.getNextBoolean();
    // Read dialog settings
    String xml = gd.getNextText();
    int failLimit = (int) gd.getNextNumber();
    boolean includeNeighbours = gd.getNextBoolean();
    double neighbourHeightThreshold = gd.getNextNumber();
    boolean myComputeDoublets = gd.getNextBoolean();
    double myDuplicateDistance = gd.getNextNumber();
    MultiPathFilter myMultiFilter = null;
    if (myUseBenchmarkSettings && !Utils.isShowGenericDialog()) {
        // Only copy the benchmark settings if not interactive
        FitConfiguration tmpFitConfig = new FitConfiguration();
        FitEngineConfiguration tmp = new FitEngineConfiguration(tmpFitConfig);
        // Collect the residuals threshold
        tmpFitConfig.setComputeResiduals(true);
        if (BenchmarkFilterAnalysis.updateConfiguration(tmp, false)) {
            config.setFailuresLimit(tmp.getFailuresLimit());
            config.setIncludeNeighbours(tmp.isIncludeNeighbours());
            config.setNeighbourHeightThreshold(tmp.getNeighbourHeightThreshold());
            computeDoublets = (tmp.getResidualsThreshold() < 1);
            fitConfig.setDuplicateDistance(tmpFitConfig.getDuplicateDistance());
            final DirectFilter primaryFilter = tmpFitConfig.getSmartFilter();
            final double residualsThreshold = tmp.getResidualsThreshold();
            myMultiFilter = new MultiPathFilter(primaryFilter, minimalFilter, residualsThreshold);
        }
    } else {
        myMultiFilter = MultiPathFilter.fromXML(xml);
        config.setFailuresLimit(failLimit);
        config.setIncludeNeighbours(includeNeighbours);
        config.setNeighbourHeightThreshold(neighbourHeightThreshold);
        computeDoublets = myComputeDoublets;
        fitConfig.setDuplicateDistance(myDuplicateDistance);
    }
    if (myMultiFilter == null) {
        gd = new GenericDialog(TITLE);
        gd.addMessage("The multi-path filter was invalid.\n \nContinue with a default filter?");
        gd.enableYesNoCancel();
        gd.hideCancelButton();
        gd.showDialog();
        if (!gd.wasOKed())
            return false;
    } else {
        multiFilter = myMultiFilter;
    }
    if (computeDoublets) {
        //config.setComputeResiduals(true);
        config.setResidualsThreshold(0);
        fitConfig.setComputeResiduals(true);
    } else {
        config.setResidualsThreshold(1);
        fitConfig.setComputeResiduals(false);
    }
    showFilterScoreHistograms = gd.getNextBoolean();
    showCorrelation = gd.getNextBoolean();
    rankByIntensity = gd.getNextBoolean();
    saveFilterRange = gd.getNextBoolean();
    // Avoid stupidness, i.e. things that move outside the fit window and are bad widths
    // TODO - Fix this for simple or smart filter...
    fitConfig.setDisableSimpleFilter(false);
    // Realistically we cannot fit lower than this
    fitConfig.setMinPhotons(15);
    // Disable shift as candidates may be re-mapped to alternative candidates so the initial position is wrong.
    fitConfig.setCoordinateShiftFactor(0);
    fitConfig.setMinWidthFactor(1.0 / 5);
    fitConfig.setWidthFactor(5);
    // Disable the direct filter
    fitConfig.setDirectFilter(null);
    if (extraOptions) {
    }
    if (gd.invalidNumber())
        return false;
    if (lowerDistance > distance)
        lowerDistance = distance;
    if (lowerSignalFactor > signalFactor)
        lowerSignalFactor = signalFactor;
    // Distances relative to sa (not s) as this is the same as the BenchmarkSpotFilter plugin 
    distanceInPixels = distance * sa / simulationParameters.a;
    lowerDistanceInPixels = lowerDistance * sa / simulationParameters.a;
    GlobalSettings settings = new GlobalSettings();
    settings.setFitEngineConfiguration(config);
    settings.setCalibration(cal);
    // Copy simulation defaults if a new simulation
    if (lastId != simulationParameters.id) {
        cal.setNmPerPixel(simulationParameters.a);
        cal.setGain(simulationParameters.gain);
        cal.setAmplification(simulationParameters.amplification);
        cal.setExposureTime(100);
        cal.setReadNoise(simulationParameters.readNoise);
        cal.setBias(simulationParameters.bias);
        cal.setEmCCD(simulationParameters.emCCD);
        // This is needed to configure the fit solver
        fitConfig.setNmPerPixel(Maths.round(cal.getNmPerPixel()));
        fitConfig.setGain(Maths.round(cal.getGain()));
        fitConfig.setBias(Maths.round(cal.getBias()));
        fitConfig.setReadNoise(Maths.round(cal.getReadNoise()));
        fitConfig.setAmplification(Maths.round(cal.getAmplification()));
        fitConfig.setEmCCD(cal.isEmCCD());
    }
    if (!PeakFit.configureFitSolver(settings, null, extraOptions))
        return false;
    return true;
}