use of gdsc.smlm.ij.IJImageSource 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;
}
use of gdsc.smlm.ij.IJImageSource in project GDSC-SMLM by aherbert.
the class PeakFit method setup.
/*
* (non-Javadoc)
*
* @see ij.plugin.filter.PlugInFilter#setup(java.lang.String, ij.ImagePlus)
*/
public int setup(String arg, ImagePlus imp) {
SMLMUsageTracker.recordPlugin(this.getClass(), arg);
plugin_flags = FLAGS;
extraOptions = Utils.isExtraOptions();
maximaIdentification = (arg != null && arg.contains("spot"));
fitMaxima = (arg != null && arg.contains("maxima"));
simpleFit = (arg != null && arg.contains("simple"));
boolean runSeries = (arg != null && arg.contains("series"));
ImageSource imageSource = null;
if (fitMaxima) {
imp = null;
// The image source will be found from the peak results.
if (!showMaximaDialog())
return DONE;
MemoryPeakResults results = ResultsManager.loadInputResults(inputOption, false);
if (results == null || results.size() == 0) {
IJ.error(TITLE, "No results could be loaded");
return DONE;
}
// Check for single frame
singleFrame = results.getHead().getFrame();
for (PeakResult result : results.getResults()) {
if (singleFrame != result.getFrame()) {
singleFrame = 0;
break;
}
}
imageSource = results.getSource();
plugin_flags |= NO_IMAGE_REQUIRED;
} else if (runSeries) {
imp = null;
// Select input folder
String inputDirectory;
inputDirectory = IJ.getDirectory("Select image series ...");
//inputDirectory = getInputDirectory("Select image series ...");
if (inputDirectory == null)
return DONE;
// Load input series ...
SeriesOpener series;
if (extraOptions)
series = new SeriesOpener(inputDirectory, true, numberOfThreads);
else
series = new SeriesOpener(inputDirectory);
if (series.getNumberOfImages() == 0) {
IJ.error(TITLE, "No images in the selected directory:\n" + inputDirectory);
return DONE;
}
SeriesImageSource seriesImageSource = new SeriesImageSource(getName(series.getImageList()), series);
seriesImageSource.setLogProgress(true);
if (extraOptions) {
numberOfThreads = Math.max(1, series.getNumberOfThreads());
seriesImageSource.setNumberOfThreads(numberOfThreads);
}
imageSource = seriesImageSource;
plugin_flags |= NO_IMAGE_REQUIRED;
} else {
if (imp == null) {
IJ.noImage();
return DONE;
}
// Check it is not a previous result
if (imp.getTitle().endsWith(IJImagePeakResults.IMAGE_SUFFIX)) {
IJImageSource tmpImageSource = null;
// Check the image to see if it has an image source XML structure in the info property
Object o = imp.getProperty("Info");
Pattern pattern = Pattern.compile("Source: (<.*IJImageSource>.*<.*IJImageSource>)", Pattern.DOTALL);
Matcher match = pattern.matcher((o == null) ? "" : o.toString());
if (match.find()) {
ImageSource source = ImageSource.fromXML(match.group(1));
if (source instanceof IJImageSource) {
tmpImageSource = (IJImageSource) source;
if (!tmpImageSource.open()) {
tmpImageSource = null;
} else {
imp = WindowManager.getImage(tmpImageSource.getName());
}
}
}
if (tmpImageSource == null) {
// Look for a parent using the title
String parentTitle = imp.getTitle().substring(0, imp.getTitle().length() - IJImagePeakResults.IMAGE_SUFFIX.length() - 1);
ImagePlus parentImp = WindowManager.getImage(parentTitle);
if (parentImp != null) {
tmpImageSource = new IJImageSource(parentImp);
imp = parentImp;
}
}
String message = "The selected image may be a previous fit result";
if (tmpImageSource != null) {
// are missing
if (!Utils.isNullOrEmpty(tmpImageSource.getName()))
message += " of: \n \n" + tmpImageSource.getName();
message += " \n \nFit the parent?";
} else
message += " \n \nDo you want to continue?";
YesNoCancelDialog d = new YesNoCancelDialog(null, TITLE, message);
if (tmpImageSource == null) {
if (!d.yesPressed())
return DONE;
} else {
if (d.yesPressed())
imageSource = tmpImageSource;
if (d.cancelPressed())
return DONE;
}
}
if (imageSource == null)
imageSource = new IJImageSource(imp);
}
time = -1;
if (!initialiseImage(imageSource, getBounds(imp), false)) {
IJ.error(TITLE, "Failed to initialise the source image: " + imageSource.getName());
return DONE;
}
int flags = showDialog(imp);
if ((flags & DONE) == 0) {
// Repeat so that we pass in the selected option for ignoring the bounds.
// This should not be necessary since it is set within the readDialog method.
//if (ignoreBoundsForNoise)
// initialiseImage(imageSource, bounds, ignoreBoundsForNoise);
initialiseFitting();
}
return flags;
}
use of gdsc.smlm.ij.IJImageSource in project GDSC-SMLM by aherbert.
the class CreateData method setNoise.
/**
* Sets the noise in the results if missing.
*
* @param results
* the results
*/
private void setNoise(MemoryPeakResults results, ImagePlus imp) {
// Loaded results do not have noise
for (PeakResult r : results.getResults()) if (r.noise != 0)
return;
// Compute noise per frame
ImageStack stack = imp.getImageStack();
final int width = stack.getWidth();
final int height = stack.getHeight();
final IJImageSource source = new IJImageSource(imp);
final float[] noise = new float[source.getFrames() + 1];
for (int slice = 1; slice < noise.length; slice++) {
stack.getPixels(slice);
float[] data = source.next();
// Use the trimmed method as there may be a lot of spots in the frame
noise[slice] = (float) FitWorker.estimateNoise(data, width, height, NoiseEstimator.Method.QUICK_RESIDUALS_LEAST_TRIMMED_OF_SQUARES);
}
Statistics stats = new Statistics(Arrays.copyOfRange(noise, 1, noise.length));
System.out.printf("Noise = %.3f +/- %.3f (%d)\n", stats.getMean(), stats.getStandardDeviation(), stats.getN());
for (PeakResult p : results.getResults()) {
if (p.getFrame() < noise.length)
p.noise = noise[p.getFrame()];
}
}
use of gdsc.smlm.ij.IJImageSource in project GDSC-SMLM by aherbert.
the class PeakFit method addSingleFrameOverlay.
private void addSingleFrameOverlay() {
// If a single frame was processed add the peaks as an overlay if they are in memory
ImagePlus imp = this.imp;
if (fitMaxima && singleFrame > 0) {
if (source instanceof IJImageSource) {
String title = source.getName();
imp = WindowManager.getImage(title);
}
}
if (singleFrame > 0 && imp != null) {
MemoryPeakResults results = null;
for (PeakResults r : this.results.toArray()) if (r instanceof MemoryPeakResults) {
results = (MemoryPeakResults) r;
break;
}
if (results == null || results.size() == 0)
return;
ExtendedGenericDialog gd = new ExtendedGenericDialog(TITLE);
gd.enableYesNoCancel();
gd.hideCancelButton();
gd.addMessage("Add the fitted localisations as an overlay?");
gd.showDialog();
if (!gd.wasOKed())
return;
LUT lut = LUTHelper.createLUT(LutColour.ICE);
Overlay o = new Overlay();
ArrayList<PeakResult> list = (ArrayList<PeakResult>) results.getResults();
for (int i = 0, j = results.size() - 1; i < results.size(); i++, j--) {
PeakResult r = list.get(i);
PointRoi roi = new PointRoi(r.getXPosition(), r.getYPosition());
Color c = LUTHelper.getColour(lut, j, results.size());
roi.setStrokeColor(c);
roi.setFillColor(c);
if (imp.getStackSize() > 1)
roi.setPosition(singleFrame);
o.add(roi);
}
imp.setOverlay(o);
imp.getWindow().toFront();
}
}
use of gdsc.smlm.ij.IJImageSource in project GDSC-SMLM by aherbert.
the class SpotAnalysis method extractSpotProfile.
private double[][] extractSpotProfile(ImagePlus imp, Rectangle bounds, ImageStack rawSpot) {
final int nSlices = imp.getStackSize();
IJImageSource rawSource = new IJImageSource(imp);
double[][] profile = new double[2][nSlices];
for (int n = 0; n < nSlices; n++) {
IJ.showProgress(n, nSlices);
float[] data = rawSource.next(bounds);
rawSpot.setPixels(data, n + 1);
Statistics stats = new Statistics(data);
profile[0][n] = stats.getMean() / gain;
profile[1][n] = stats.getStandardDeviation() / gain;
}
return profile;
}
Aggregations