Examples with ExtendedGenericDialog ij.gui.ExtendedGenericDialog used on opensource projects

Example 1 with ExtendedGenericDialog

use of ij.gui.ExtendedGenericDialog in project GDSC-SMLM by aherbert.

the class ResultsManager method showDialog.

private boolean showDialog() {
    ExtendedGenericDialog gd = new ExtendedGenericDialog(TITLE);
    gd.addHelp(About.HELP_URL);
    // Build a list of all images with a region ROI
    List<String> titles = new LinkedList<String>();
    if (WindowManager.getWindowCount() > 0) {
        for (int imageID : WindowManager.getIDList()) {
            ImagePlus imp = WindowManager.getImage(imageID);
            if (imp != null && imp.getRoi() != null && imp.getRoi().isArea())
                titles.add(imp.getTitle());
        }
    }
    GlobalSettings settings = SettingsManager.loadSettings();
    resultsSettings = settings.getResultsSettings();
    gd.addMessage("Read the Peak Results and output to a new format");
    gd.addMessage("Select the Peak Results");
    addInput(gd, inputOption, InputSource.MEMORY, InputSource.FILE);
    if (!titles.isEmpty())
        gd.addCheckbox((titles.size() == 1) ? "Use_ROI" : "Choose_ROI", chooseRoi);
    gd.addMessage("--- Table output ---");
    String[] tableNames = SettingsManager.getNames((Object[]) ResultsTable.values());
    gd.addChoice("Results_table", tableNames, tableNames[resultsSettings.getResultsTable().ordinal()], new OptionListener<Choice>() {

        @Override
        public void collectOptions(Choice field) {
            ExtendedGenericDialog egd = new ExtendedGenericDialog(TITLE, null);
            egd.addCheckbox("Show_deviations", resultsSettings.showDeviations);
            egd.showDialog(true);
            if (egd.wasCanceled())
                return;
            resultsSettings.showDeviations = egd.getNextBoolean();
        }

        @Override
        public void collectOptions() {
            collectOptions(null);
        }
    });
    gd.addMessage("--- Image output ---");
    String[] imageNames = SettingsManager.getNames((Object[]) ResultsImage.values());
    gd.addChoice("Image", imageNames, imageNames[resultsSettings.getResultsImage().ordinal()]);
    // TODO - move these to an options pop-uo
    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);
    gd.addNumericField("Image_Window", resultsSettings.imageRollingWindow, 0);
    gd.addMessage("--- File output ---");
    // Do not add a results file to prevent constant overwrite messages
    gd.addFilenameField("Results_file", "");
    // TODO - move these to an options pop-uo
    String[] formatNames = SettingsManager.getNames((Object[]) ResultsFileFormat.values());
    gd.addChoice("Results_format", formatNames, formatNames[resultsSettings.getResultsFileFormat().ordinal()]);
    gd.addMessage(" ");
    gd.addCheckbox("Results_in_memory (file input only)", resultsSettings.resultsInMemory);
    gd.showDialog();
    if (gd.wasCanceled())
        return false;
    inputOption = ResultsManager.getInputSource(gd);
    inputFilename = gd.getNextString();
    if (!titles.isEmpty())
        chooseRoi = gd.getNextBoolean();
    resultsSettings.setResultsTable(gd.getNextChoiceIndex());
    resultsSettings.showDeviations = gd.getNextBoolean();
    resultsSettings.setResultsImage(gd.getNextChoiceIndex());
    resultsSettings.weightedImage = gd.getNextBoolean();
    resultsSettings.equalisedImage = gd.getNextBoolean();
    resultsSettings.precision = gd.getNextNumber();
    resultsSettings.imageScale = gd.getNextNumber();
    resultsSettings.imageRollingWindow = (int) gd.getNextNumber();
    resultsSettings.resultsFilename = gd.getNextString();
    resultsSettings.setResultsFileFormat(gd.getNextChoiceIndex());
    resultsSettings.resultsInMemory = gd.getNextBoolean();
    // Check arguments
    try {
        if (resultsSettings.getResultsImage() == ResultsImage.SIGNAL_AV_PRECISION || resultsSettings.getResultsImage() == ResultsImage.LOCALISATIONS_AV_PRECISION) {
            Parameters.isAboveZero("Image precision", resultsSettings.precision);
        }
        Parameters.isAboveZero("Image scale", resultsSettings.imageScale);
        Parameters.isPositive("Image rolling window", resultsSettings.imageRollingWindow);
    } catch (IllegalArgumentException e) {
        IJ.error(TITLE, e.getMessage());
        return false;
    }
    Prefs.set(Constants.inputFilename, inputFilename);
    if (!titles.isEmpty() && chooseRoi) {
        if (titles.size() == 1) {
            roiImage = titles.get(0);
            Recorder.recordOption("Image", roiImage);
        } else {
            String[] items = titles.toArray(new String[titles.size()]);
            gd = new ExtendedGenericDialog(TITLE);
            gd.addMessage("Select the source image for the ROI");
            gd.addChoice("Image", items, roiImage);
            gd.showDialog();
            if (gd.wasCanceled())
                return false;
            roiImage = gd.getNextChoice();
        }
        ImagePlus imp = WindowManager.getImage(roiImage);
        roiBounds = imp.getRoi().getBounds();
        roiImageWidth = imp.getWidth();
        roiImageHeight = imp.getHeight();
    } else {
        roiBounds = null;
    }
    SettingsManager.saveSettings(settings);
    return true;
}

Example 2 with ExtendedGenericDialog

use of ij.gui.ExtendedGenericDialog in project GDSC-SMLM by aherbert.

the class PeakFit method newWizardDialog.

private ExtendedGenericDialog newWizardDialog(String... messages) {
    ExtendedGenericDialog gd = new ExtendedGenericDialog(TITLE);
    gd.addHelp(About.HELP_URL);
    final String header = "-=-";
    gd.addMessage(header + " " + TITLE + " Configuration Wizard " + header);
    for (String message : messages) gd.addMessage(TextUtils.wrap(message, 80));
    return gd;
}

Example 3 with ExtendedGenericDialog

use of ij.gui.ExtendedGenericDialog 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 4 with ExtendedGenericDialog

use of ij.gui.ExtendedGenericDialog in project GDSC-SMLM by aherbert.

the class PeakFit method getExposureTime.

private boolean getExposureTime() {
    ExtendedGenericDialog gd = newWizardDialog("Enter the exposure time. Calibration of the exposure time allows correct reporting of on and off times.", "This is the length of time for each frame in the image.");
    gd.addNumericField("Exposure_time (ms)", calibration.getExposureTime(), 2);
    gd.showDialog();
    if (gd.wasCanceled())
        return false;
    calibration.setExposureTime(Math.abs(gd.getNextNumber()));
    return true;
}

Example 5 with ExtendedGenericDialog

use of ij.gui.ExtendedGenericDialog in project GDSC-SMLM by aherbert.

the class PeakFit method showMaximaDialog.

private boolean showMaximaDialog() {
    int size = MemoryPeakResults.countMemorySize();
    if (size == 0) {
        IJ.error(TITLE, "There are no fitting results in memory");
        return false;
    }
    ExtendedGenericDialog gd = new ExtendedGenericDialog(TITLE);
    gd.addHelp(About.HELP_URL);
    gd.addMessage("Select identified maxima for fitting");
    ResultsManager.addInput(gd, inputOption, InputSource.MEMORY);
    gd.showDialog();
    if (gd.wasCanceled())
        return false;
    inputOption = ResultsManager.getInputSource(gd);
    return true;
}