public int showDialog(ImagePlus imp, String command, PlugInFilterRunner pfr) {
this.pfr = pfr;
String macroOptions = Macro.getOptions();
if (macroOptions != null) {
if (macroOptions.indexOf(" interpolate") != -1)
macroOptions.replaceAll(" interpolate", " interpolation=Bilinear");
else if (macroOptions.indexOf(" interpolation=") == -1)
macroOptions = macroOptions + " interpolation=None";
Macro.setOptions(macroOptions);
}
gd = new GenericDialog("Rotate", IJ.getInstance());
gd.addNumericField("Angle (degrees):", angle, (int) angle == angle ? 1 : 2);
gd.addNumericField("Grid Lines:", gridLines, 0);
gd.addChoice("Interpolation:", methods, methods[interpolationMethod]);
if (bitDepth == 8 || bitDepth == 24)
gd.addCheckbox("Fill with Background Color", fillWithBackground);
if (canEnlarge) gd.addCheckbox("Enlarge Image to Fit Result", enlarge);
else enlarge = false;
gd.addPreviewCheckbox(pfr);
gd.addDialogListener(this);
gd.showDialog();
drawGridLines(0);
if (gd.wasCanceled()) {
return DONE;
}
if (!enlarge) flags |= KEEP_PREVIEW; // standard filter without enlarge
else if (imp.getStackSize() == 1) flags |= NO_CHANGES; // undoable as a "compound filter"
return IJ.setupDialog(imp, flags);
}
public void loadMacros() {
File f = new File(System.getProperty("user.dir"));
String[] files = f.list();
for (int i = 0; i < files.length; i++) {
try {
if (files[i].startsWith("macro_")
&& files[i].endsWith(".class")
&& files[i].indexOf('$') == -1) {
System.out.println(files[i]);
Class clazz = Class.forName(files[i].substring(0, files[i].length() - ".class".length()));
Macro macro =
(Macro)
clazz
.getConstructor(new Class[] {mudclient_Debug.class})
.newInstance(new Object[] {inner});
String[] commands = macro.getCommands();
for (int j = 0; j < commands.length; j++) {
System.out.println("command registered:" + commands[j]);
mudclient_Debug.macros.put(commands[j], macro);
}
}
} catch (Exception e) {
e.printStackTrace();
}
}
}
void interpolate() {
Roi roi = imp.getRoi();
if (roi == null) {
noRoi("Interpolate");
return;
}
if (roi.getType() == Roi.POINT) return;
if (IJ.isMacro() && Macro.getOptions() == null) Macro.setOptions("interval=1");
GenericDialog gd = new GenericDialog("Interpolate");
gd.addNumericField("Interval:", 1.0, 1, 4, "pixel");
gd.addCheckbox("Smooth", IJ.isMacro() ? false : smooth);
gd.showDialog();
if (gd.wasCanceled()) return;
double interval = gd.getNextNumber();
smooth = gd.getNextBoolean();
Undo.setup(Undo.ROI, imp);
FloatPolygon poly = roi.getInterpolatedPolygon(interval, smooth);
int t = roi.getType();
int type = roi.isLine() ? Roi.FREELINE : Roi.FREEROI;
if (t == Roi.POLYGON && interval > 1.0) type = Roi.POLYGON;
if ((t == Roi.RECTANGLE || t == Roi.OVAL || t == Roi.FREEROI) && interval >= 5.0)
type = Roi.POLYGON;
if ((t == Roi.LINE || t == Roi.FREELINE) && interval >= 5.0) type = Roi.POLYLINE;
if (t == Roi.POLYLINE && interval >= 1.0) type = Roi.POLYLINE;
ImageCanvas ic = imp.getCanvas();
if (poly.npoints <= 150 && ic != null && ic.getMagnification() >= 12.0)
type = roi.isLine() ? Roi.POLYLINE : Roi.POLYGON;
Roi p = new PolygonRoi(poly, type);
if (roi.getStroke() != null) p.setStrokeWidth(roi.getStrokeWidth());
p.setStrokeColor(roi.getStrokeColor());
p.setName(roi.getName());
transferProperties(roi, p);
imp.setRoi(p);
}
/** Returns the contents of the next textarea. */
public String getNextText() {
String text;
if (textAreaIndex == 0 && textArea1 != null) {
// textArea1.selectAll();
text = textArea1.getText();
textAreaIndex++;
if (macro) text = Macro.getValue(macroOptions, "text1", text);
if (recorderOn) {
String text2 = text;
String cmd = Recorder.getCommand();
if (cmd != null && cmd.equals("Convolve...")) {
text2 = text.replaceAll("\n", "\\\\n");
if (!text.endsWith("\n")) text2 = text2 + "\\n";
} else text2 = text.replace('\n', ' ');
Recorder.recordOption("text1", text2);
}
} else if (textAreaIndex == 1 && textArea2 != null) {
textArea2.selectAll();
text = textArea2.getText();
textAreaIndex++;
if (macro) text = Macro.getValue(macroOptions, "text2", text);
if (recorderOn) Recorder.recordOption("text2", text.replace('\n', ' '));
} else text = null;
return text;
}
boolean updateMacroOptions() {
String options = Macro.getOptions();
int index = options.indexOf("maximum=");
if (index == -1) return false;
index += 8;
int len = options.length();
while (index < len - 1 && options.charAt(index) != ' ') index++;
if (index == len - 1) return false;
int min = (int) Tools.parseDouble(Macro.getValue(options, "minimum", "1"));
int max = (int) Tools.parseDouble(Macro.getValue(options, "maximum", "999999"));
options = "size=" + min + "-" + max + options.substring(index, len);
Macro.setOptions(options);
return true;
}
/** Returns the index of the selected item in the next popup menu. */
public int getNextChoiceIndex() {
if (choice == null) return -1;
Choice thisChoice = (Choice) (choice.elementAt(choiceIndex));
int index = thisChoice.getSelectedIndex();
if (macro) {
String label = (String) labels.get((Object) thisChoice);
String oldItem = thisChoice.getSelectedItem();
int oldIndex = thisChoice.getSelectedIndex();
String item = Macro.getValue(macroOptions, label, oldItem);
if (item != null && item.startsWith("&")) // value is macro variable
item = getChoiceVariable(item);
thisChoice.select(item);
index = thisChoice.getSelectedIndex();
if (index == oldIndex && !item.equals(oldItem)) {
// is value a macro variable?
Interpreter interp = Interpreter.getInstance();
String s = interp != null ? interp.getStringVariable(item) : null;
if (s == null)
IJ.error(getTitle(), "\"" + item + "\" is not a valid choice for \"" + label + "\"");
else item = s;
}
}
if (recorderOn) {
int defaultIndex = ((Integer) (defaultChoiceIndexes.elementAt(choiceIndex))).intValue();
if (!(smartRecording && index == defaultIndex)) {
String item = thisChoice.getSelectedItem();
if (!(item.equals("*None*") && getTitle().equals("Merge Channels")))
recordOption(thisChoice, thisChoice.getSelectedItem());
}
}
choiceIndex++;
return index;
}
void fitSpline() {
Roi roi = imp.getRoi();
if (roi == null) {
noRoi("Spline");
return;
}
int type = roi.getType();
boolean segmentedSelection = type == Roi.POLYGON || type == Roi.POLYLINE;
if (!(segmentedSelection
|| type == Roi.FREEROI
|| type == Roi.TRACED_ROI
|| type == Roi.FREELINE)) {
IJ.error("Spline", "Polygon or polyline selection required");
return;
}
if (roi instanceof EllipseRoi) return;
PolygonRoi p = (PolygonRoi) roi;
if (!segmentedSelection) {
if (p.subPixelResolution()) p = trimFloatPolygon(p, p.getUncalibratedLength());
else p = trimPolygon(p, p.getUncalibratedLength());
}
String options = Macro.getOptions();
if (options != null && options.indexOf("straighten") != -1) p.fitSplineForStraightening();
else if (options != null && options.indexOf("remove") != -1) p.removeSplineFit();
else p.fitSpline();
imp.draw();
LineWidthAdjuster.update();
}
/** Returns the contents of the next text field. */
public String getNextString() {
String theText;
if (stringField == null) return "";
TextField tf = (TextField) (stringField.elementAt(sfIndex));
theText = tf.getText();
if (macro) {
String label = (String) labels.get((Object) tf);
theText = Macro.getValue(macroOptions, label, theText);
if (theText != null
&& (theText.startsWith("&") || label.toLowerCase(Locale.US).startsWith(theText))) {
// Is the value a macro variable?
if (theText.startsWith("&")) theText = theText.substring(1);
Interpreter interp = Interpreter.getInstance();
String s = interp != null ? interp.getVariableAsString(theText) : null;
if (s != null) theText = s;
}
}
if (recorderOn) {
String s = theText;
if (s != null
&& s.length() >= 3
&& Character.isLetter(s.charAt(0))
&& s.charAt(1) == ':'
&& s.charAt(2) == '\\')
s = s.replaceAll("\\\\", "\\\\\\\\"); // replace "\" with "\\" in Windows file paths
if (!smartRecording || !s.equals((String) defaultStrings.elementAt(sfIndex)))
recordOption(tf, s);
else if (Recorder.getCommandOptions() == null) Recorder.recordOption(" ");
}
sfIndex++;
return theText;
}
/**
* Saves statistics for one particle in a results table. This is a method subclasses may want to
* override.
*/
protected void saveResults(ImageStatistics stats, Roi roi) {
analyzer.saveResults(stats, roi);
if (recordStarts) {
rt.addValue("XStart", stats.xstart);
rt.addValue("YStart", stats.ystart);
}
if (addToManager) {
if (roiManager == null) {
if (Macro.getOptions() != null && Interpreter.isBatchMode())
roiManager = Interpreter.getBatchModeRoiManager();
if (roiManager == null) {
Frame frame = WindowManager.getFrame("ROI Manager");
if (frame == null) IJ.run("ROI Manager...");
frame = WindowManager.getFrame("ROI Manager");
if (frame == null || !(frame instanceof RoiManager)) {
addToManager = false;
return;
}
roiManager = (RoiManager) frame;
}
if (resetCounter) roiManager.runCommand("reset");
}
if (imp.getStackSize() > 1) roi.setPosition(imp.getCurrentSlice());
if (lineWidth != 1) roi.setStrokeWidth(lineWidth);
roiManager.add(imp, roi, rt.getCounter());
}
if (showResults) rt.addResults();
}
void runMacro(String arg) {
Roi roi = imp.getRoi();
if (IJ.macroRunning()) {
String options = Macro.getOptions();
if (options != null
&& (options.indexOf("grid=") != -1 || options.indexOf("interpolat") != -1)) {
IJ.run("Rotate... ", options); // run Image>Transform>Rotate
return;
}
}
if (roi == null) {
noRoi("Rotate>Selection");
return;
}
roi = (Roi) roi.clone();
if (arg.equals("rotate")) {
double d = Tools.parseDouble(angle);
if (Double.isNaN(d)) angle = "15";
String value = IJ.runMacroFile("ij.jar:RotateSelection", angle);
if (value != null) angle = value;
} else if (arg.equals("enlarge")) {
String value = IJ.runMacroFile("ij.jar:EnlargeSelection", enlarge);
if (value != null) enlarge = value;
Roi.previousRoi = roi;
}
}
void abortPluginOrMacro(ImagePlus imp) {
if (imp != null) {
ImageWindow win = imp.getWindow();
if (win != null) {
win.running = false;
win.running2 = false;
}
}
Macro.abort();
Interpreter.abort();
if (Interpreter.getInstance() != null) IJ.beep();
}
private void rotate(ImagePlus imp) {
Roi roi = imp.getRoi();
if (IJ.macroRunning()) {
String options = Macro.getOptions();
if (options != null
&& (options.indexOf("grid=") != -1 || options.indexOf("interpolat") != -1)) {
IJ.run("Rotate... ", options); // run Image>Transform>Rotate
return;
}
}
(new RoiRotator()).run("");
}
/**
* Returns the contents of the next numeric field, or NaN if the field does not contain a number.
*/
public double getNextNumber() {
if (numberField == null) return -1.0;
TextField tf = (TextField) numberField.elementAt(nfIndex);
String theText = tf.getText();
String label = null;
if (macro) {
label = (String) labels.get((Object) tf);
theText = Macro.getValue(macroOptions, label, theText);
// IJ.write("getNextNumber: "+label+" "+theText);
}
String originalText = (String) defaultText.elementAt(nfIndex);
double defaultValue = ((Double) (defaultValues.elementAt(nfIndex))).doubleValue();
double value;
boolean skipRecording = false;
if (theText.equals(originalText)) {
value = defaultValue;
if (smartRecording) skipRecording = true;
} else {
Double d = getValue(theText);
if (d != null) value = d.doubleValue();
else {
// Is the value a macro variable?
if (theText.startsWith("&")) theText = theText.substring(1);
Interpreter interp = Interpreter.getInstance();
value = interp != null ? interp.getVariable2(theText) : Double.NaN;
if (Double.isNaN(value)) {
invalidNumber = true;
errorMessage = "\"" + theText + "\" is an invalid number";
value = Double.NaN;
if (macro) {
IJ.error(
"Macro Error",
"Numeric value expected in run() function\n \n"
+ " Dialog box title: \""
+ getTitle()
+ "\"\n"
+ " Key: \""
+ label.toLowerCase(Locale.US)
+ "\"\n"
+ " Value or variable name: \""
+ theText
+ "\"");
}
}
}
}
if (recorderOn && !skipRecording) {
recordOption(tf, trim(theText));
}
nfIndex++;
return value;
}
/** Returns the state of the next checkbox. */
public boolean getNextBoolean() {
if (checkbox == null) return false;
Checkbox cb = (Checkbox) (checkbox.elementAt(cbIndex));
if (recorderOn) recordCheckboxOption(cb);
boolean state = cb.getState();
if (macro) {
String label = (String) labels.get((Object) cb);
String key = Macro.trimKey(label);
state = isMatch(macroOptions, key + " ");
}
cbIndex++;
return state;
}
/** Returns the selected item in the next popup menu. */
public String getNextChoice() {
if (choice == null) return "";
Choice thisChoice = (Choice) (choice.elementAt(choiceIndex));
String item = thisChoice.getSelectedItem();
if (macro) {
String label = (String) labels.get((Object) thisChoice);
item = Macro.getValue(macroOptions, label, item);
if (item != null && item.startsWith("&")) // value is macro variable
item = getChoiceVariable(item);
}
if (recorderOn) recordOption(thisChoice, item);
choiceIndex++;
return item;
}
/** Returns the selected item in the next radio button group. */
public String getNextRadioButton() {
if (radioButtonGroups == null) return null;
CheckboxGroup cg = (CheckboxGroup) (radioButtonGroups.elementAt(radioButtonIndex));
radioButtonIndex++;
Checkbox checkbox = cg.getSelectedCheckbox();
String item = "null";
if (checkbox != null) item = checkbox.getLabel();
if (macro) {
String label = (String) labels.get((Object) cg);
item = Macro.getValue(macroOptions, label, item);
}
if (recorderOn) recordOption(cg, item);
return item;
}
void addSelection() {
ImagePlus imp = IJ.getImage();
String macroOptions = Macro.getOptions();
if (macroOptions != null && IJ.macroRunning() && macroOptions.indexOf("remove") != -1) {
imp.setOverlay(null);
return;
}
Roi roi = imp.getRoi();
if (roi == null && imp.getOverlay() != null) {
GenericDialog gd = new GenericDialog("No Selection");
gd.addMessage("\"Overlay>Add\" requires a selection.");
gd.setInsets(15, 40, 0);
gd.addCheckbox("Remove existing overlay", false);
gd.showDialog();
if (gd.wasCanceled()) return;
if (gd.getNextBoolean()) imp.setOverlay(null);
return;
}
if (roi == null) {
IJ.error("This command requires a selection.");
return;
}
roi = (Roi) roi.clone();
if (roi.getStrokeColor() == null) roi.setStrokeColor(Toolbar.getForegroundColor());
int width = Line.getWidth();
Rectangle bounds = roi.getBounds();
boolean tooWide = width > Math.max(bounds.width, bounds.height) / 3.0;
if (roi.getStroke() == null && width > 1 && !tooWide) roi.setStrokeWidth(Line.getWidth());
Overlay overlay = imp.getOverlay();
if (overlay != null && overlay.size() > 0 && !roi.isDrawingTool()) {
Roi roi2 = overlay.get(overlay.size() - 1);
if (roi.getStroke() == null) roi.setStrokeWidth(roi2.getStrokeWidth());
if (roi.getFillColor() == null) roi.setFillColor(roi2.getFillColor());
}
boolean points = roi instanceof PointRoi && ((PolygonRoi) roi).getNCoordinates() > 1;
if (points) roi.setStrokeColor(Color.red);
if (!IJ.altKeyDown() && !(roi instanceof Arrow)) {
RoiProperties rp = new RoiProperties("Add to Overlay", roi);
if (!rp.showDialog()) return;
}
String name = roi.getName();
boolean newOverlay = name != null && name.equals("new-overlay");
if (overlay == null || newOverlay) overlay = new Overlay();
overlay.add(roi);
imp.setOverlay(overlay);
overlay2 = overlay;
if (points || (roi instanceof ImageRoi) || (roi instanceof Arrow)) imp.killRoi();
Undo.setup(Undo.OVERLAY_ADDITION, imp);
}
/** Creates a new GenericDialog using the specified title and parent frame. */
public GenericDialog(String title, Frame parent) {
super(parent == null ? new Frame() : parent, title, true);
if (Prefs.blackCanvas) {
setForeground(SystemColor.controlText);
setBackground(SystemColor.control);
}
// if (IJ.isLinux())
// setBackground(new Color(238, 238, 238));
grid = new GridBagLayout();
c = new GridBagConstraints();
setLayout(grid);
macroOptions = Macro.getOptions();
macro = macroOptions != null;
addKeyListener(this);
addWindowListener(this);
}
void runMacro(String arg, ImagePlus imp) {
boolean rotate = arg.equals("rotate");
Roi roi = imp.getRoi();
if (rotate && IJ.macroRunning()) {
String options = Macro.getOptions();
if (options != null
&& (options.indexOf("grid=") != -1 || options.indexOf("interpolat") != -1)) {
IJ.run("Rotate... ", options); // run Image>Transform>Rotate
return;
}
}
if (roi == null) {
noRoi(rotate ? "Rotate" : "Enlarge");
return;
}
double dangle = Tools.parseDouble(angle);
if (Double.isNaN(dangle)) {
dangle = 15;
angle = "" + dangle;
}
if (rotate && (roi instanceof ImageRoi)) {
dangle = IJ.getNumber("Angle (degrees):", dangle);
((ImageRoi) roi).rotate(dangle);
imp.draw();
angle = "" + dangle;
return;
}
Undo.setup(Undo.ROI, imp);
roi = (Roi) roi.clone();
if (rotate) {
String value = IJ.runMacroFile("ij.jar:RotateSelection", angle);
Roi roi2 = imp.getRoi();
transferProperties(roi, roi2);
imp.setRoi(roi2);
if (value != null) angle = value;
} else if (arg.equals("enlarge")) (new RoiEnlarger()).run("");
}
void toRoiManager() {
ImagePlus imp = IJ.getImage();
Overlay overlay = imp.getOverlay();
if (overlay == null) {
IJ.error("Overlay required");
return;
}
RoiManager rm = RoiManager.getInstance();
if (rm == null) {
if (Macro.getOptions() != null && Interpreter.isBatchMode())
rm = Interpreter.getBatchModeRoiManager();
if (rm == null) {
Frame frame = WindowManager.getFrame("ROI Manager");
if (frame == null) IJ.run("ROI Manager...");
frame = WindowManager.getFrame("ROI Manager");
if (frame == null || !(frame instanceof RoiManager)) return;
rm = (RoiManager) frame;
}
}
rm.runCommand("reset");
for (int i = 0; i < overlay.size(); i++) rm.add(imp, overlay.get(i), i);
rm.setEditMode(imp, true);
if (rm.getCount() == overlay.size()) imp.setOverlay(null);
}
public String toString() {
return myMacro.getName() + " - " + myMacro.getDescription();
}
/**
* Performs particle analysis on the specified ImagePlus and ImageProcessor. Returns false if
* there is an error.
*/
public boolean analyze(ImagePlus imp, ImageProcessor ip) {
if (this.imp == null) this.imp = imp;
showResults = (options & SHOW_RESULTS) != 0;
excludeEdgeParticles = (options & EXCLUDE_EDGE_PARTICLES) != 0;
resetCounter = (options & CLEAR_WORKSHEET) != 0;
showProgress = (options & SHOW_PROGRESS) != 0;
floodFill = (options & INCLUDE_HOLES) == 0;
recordStarts = (options & RECORD_STARTS) != 0;
addToManager = (options & ADD_TO_MANAGER) != 0;
displaySummary = (options & DISPLAY_SUMMARY) != 0;
inSituShow = (options & IN_SITU_SHOW) != 0;
outputImage = null;
ip.snapshot();
ip.setProgressBar(null);
if (Analyzer.isRedirectImage()) {
redirectImp = Analyzer.getRedirectImage(imp);
if (redirectImp == null) return false;
int depth = redirectImp.getStackSize();
if (depth > 1 && depth == imp.getStackSize()) {
ImageStack redirectStack = redirectImp.getStack();
redirectIP = redirectStack.getProcessor(imp.getCurrentSlice());
} else redirectIP = redirectImp.getProcessor();
} else if (imp.getType() == ImagePlus.COLOR_RGB) {
ImagePlus original = (ImagePlus) imp.getProperty("OriginalImage");
if (original != null
&& original.getWidth() == imp.getWidth()
&& original.getHeight() == imp.getHeight()) {
redirectImp = original;
redirectIP = original.getProcessor();
}
}
if (!setThresholdLevels(imp, ip)) return false;
width = ip.getWidth();
height = ip.getHeight();
if (!(showChoice == NOTHING || showChoice == OVERLAY_OUTLINES || showChoice == OVERLAY_MASKS)) {
blackBackground = Prefs.blackBackground && inSituShow;
if (slice == 1) outlines = new ImageStack(width, height);
if (showChoice == ROI_MASKS) drawIP = new ShortProcessor(width, height);
else drawIP = new ByteProcessor(width, height);
drawIP.setLineWidth(lineWidth);
if (showChoice == ROI_MASKS) {
} // Place holder for now...
else if (showChoice == MASKS && !blackBackground) drawIP.invertLut();
else if (showChoice == OUTLINES) {
if (!inSituShow) {
if (customLut == null) makeCustomLut();
drawIP.setColorModel(customLut);
}
drawIP.setFont(new Font("SansSerif", Font.PLAIN, fontSize));
if (fontSize > 12 && inSituShow) drawIP.setAntialiasedText(true);
}
outlines.addSlice(null, drawIP);
if (showChoice == ROI_MASKS || blackBackground) {
drawIP.setColor(Color.black);
drawIP.fill();
drawIP.setColor(Color.white);
} else {
drawIP.setColor(Color.white);
drawIP.fill();
drawIP.setColor(Color.black);
}
}
calibration = redirectImp != null ? redirectImp.getCalibration() : imp.getCalibration();
if (rt == null) {
rt = Analyzer.getResultsTable();
analyzer = new Analyzer(imp);
} else analyzer = new Analyzer(imp, measurements, rt);
if (resetCounter && slice == 1) {
if (!Analyzer.resetCounter()) return false;
}
beginningCount = Analyzer.getCounter();
byte[] pixels = null;
if (ip instanceof ByteProcessor) pixels = (byte[]) ip.getPixels();
if (r == null) {
r = ip.getRoi();
mask = ip.getMask();
if (displaySummary) {
if (mask != null) totalArea = ImageStatistics.getStatistics(ip, AREA, calibration).area;
else totalArea = r.width * calibration.pixelWidth * r.height * calibration.pixelHeight;
}
}
minX = r.x;
maxX = r.x + r.width;
minY = r.y;
maxY = r.y + r.height;
if (r.width < width || r.height < height || mask != null) {
if (!eraseOutsideRoi(ip, r, mask)) return false;
}
int offset;
double value;
int inc = Math.max(r.height / 25, 1);
int mi = 0;
ImageWindow win = imp.getWindow();
if (win != null) win.running = true;
if (measurements == 0) measurements = Analyzer.getMeasurements();
if (showChoice == ELLIPSES) measurements |= ELLIPSE;
measurements &= ~LIMIT; // ignore "Limit to Threshold"
roiNeedsImage =
(measurements & PERIMETER) != 0
|| (measurements & SHAPE_DESCRIPTORS) != 0
|| (measurements & FERET) != 0;
particleCount = 0;
wand = new Wand(ip);
pf = new PolygonFiller();
if (floodFill) {
ImageProcessor ipf = ip.duplicate();
ipf.setValue(fillColor);
ff = new FloodFiller(ipf);
}
roiType = Wand.allPoints() ? Roi.FREEROI : Roi.TRACED_ROI;
for (int y = r.y; y < (r.y + r.height); y++) {
offset = y * width;
for (int x = r.x; x < (r.x + r.width); x++) {
if (pixels != null) value = pixels[offset + x] & 255;
else if (imageType == SHORT) value = ip.getPixel(x, y);
else value = ip.getPixelValue(x, y);
if (value >= level1 && value <= level2) analyzeParticle(x, y, imp, ip);
}
if (showProgress && ((y % inc) == 0)) IJ.showProgress((double) (y - r.y) / r.height);
if (win != null) canceled = !win.running;
if (canceled) {
Macro.abort();
break;
}
}
if (showProgress) IJ.showProgress(1.0);
if (showResults) rt.updateResults();
imp.killRoi();
ip.resetRoi();
ip.reset();
if (displaySummary && IJ.getInstance() != null) updateSliceSummary();
if (addToManager && roiManager != null) roiManager.setEditMode(imp, true);
maxParticleCount = (particleCount > maxParticleCount) ? particleCount : maxParticleCount;
totalCount += particleCount;
if (!canceled) showResults();
return true;
}
/** Returns true if the user clicked on "Cancel". */
public boolean wasCanceled() {
if (wasCanceled) Macro.abort();
return wasCanceled;
}
/** Displays a modal options dialog. */
public boolean showDialog() {
Calibration cal = imp != null ? imp.getCalibration() : (new Calibration());
double unitSquared = cal.pixelWidth * cal.pixelHeight;
if (pixelUnits) unitSquared = 1.0;
if (Macro.getOptions() != null) {
boolean oldMacro = updateMacroOptions();
if (oldMacro) unitSquared = 1.0;
staticMinSize = 0.0;
staticMaxSize = DEFAULT_MAX_SIZE;
staticMinCircularity = 0.0;
staticMaxCircularity = 1.0;
staticShowChoice = NOTHING;
}
GenericDialog gd = new GenericDialog("Analyze Particles");
minSize = staticMinSize;
maxSize = staticMaxSize;
minCircularity = staticMinCircularity;
maxCircularity = staticMaxCircularity;
showChoice = staticShowChoice;
if (maxSize == 999999) maxSize = DEFAULT_MAX_SIZE;
options = staticOptions;
String unit = cal.getUnit();
boolean scaled = cal.scaled();
if (unit.equals("inch")) {
unit = "pixel";
unitSquared = 1.0;
scaled = false;
pixelUnits = true;
}
String units = unit + "^2";
int places = 0;
double cmin = minSize * unitSquared;
if ((int) cmin != cmin) places = 2;
double cmax = maxSize * unitSquared;
if ((int) cmax != cmax && cmax != DEFAULT_MAX_SIZE) places = 2;
String minStr = ResultsTable.d2s(cmin, places);
if (minStr.indexOf("-") != -1) {
for (int i = places; i <= 6; i++) {
minStr = ResultsTable.d2s(cmin, i);
if (minStr.indexOf("-") == -1) break;
}
}
String maxStr = ResultsTable.d2s(cmax, places);
if (maxStr.indexOf("-") != -1) {
for (int i = places; i <= 6; i++) {
maxStr = ResultsTable.d2s(cmax, i);
if (maxStr.indexOf("-") == -1) break;
}
}
if (scaled) gd.setInsets(5, 0, 0);
gd.addStringField("Size (" + units + "):", minStr + "-" + maxStr, 12);
if (scaled) {
gd.setInsets(0, 40, 5);
gd.addCheckbox("Pixel units", pixelUnits);
}
gd.addStringField("Circularity:", IJ.d2s(minCircularity) + "-" + IJ.d2s(maxCircularity), 12);
gd.addChoice("Show:", showStrings, showStrings[showChoice]);
String[] labels = new String[8];
boolean[] states = new boolean[8];
labels[0] = "Display results";
states[0] = (options & SHOW_RESULTS) != 0;
labels[1] = "Exclude on edges";
states[1] = (options & EXCLUDE_EDGE_PARTICLES) != 0;
labels[2] = "Clear results";
states[2] = (options & CLEAR_WORKSHEET) != 0;
labels[3] = "Include holes";
states[3] = (options & INCLUDE_HOLES) != 0;
labels[4] = "Summarize";
states[4] = (options & DISPLAY_SUMMARY) != 0;
labels[5] = "Record starts";
states[5] = (options & RECORD_STARTS) != 0;
labels[6] = "Add to Manager";
states[6] = (options & ADD_TO_MANAGER) != 0;
labels[7] = "In_situ Show";
states[7] = (options & IN_SITU_SHOW) != 0;
gd.addCheckboxGroup(4, 2, labels, states);
gd.addHelp(IJ.URL + "/docs/menus/analyze.html#ap");
gd.showDialog();
if (gd.wasCanceled()) return false;
String size = gd.getNextString(); // min-max size
if (scaled) pixelUnits = gd.getNextBoolean();
if (pixelUnits) unitSquared = 1.0;
else unitSquared = cal.pixelWidth * cal.pixelHeight;
String[] minAndMax = Tools.split(size, " -");
double mins = gd.parseDouble(minAndMax[0]);
double maxs = minAndMax.length == 2 ? gd.parseDouble(minAndMax[1]) : Double.NaN;
minSize = Double.isNaN(mins) ? DEFAULT_MIN_SIZE : mins / unitSquared;
maxSize = Double.isNaN(maxs) ? DEFAULT_MAX_SIZE : maxs / unitSquared;
if (minSize < DEFAULT_MIN_SIZE) minSize = DEFAULT_MIN_SIZE;
if (maxSize < minSize) maxSize = DEFAULT_MAX_SIZE;
staticMinSize = minSize;
staticMaxSize = maxSize;
minAndMax = Tools.split(gd.getNextString(), " -"); // min-max circularity
double minc = gd.parseDouble(minAndMax[0]);
double maxc = minAndMax.length == 2 ? gd.parseDouble(minAndMax[1]) : Double.NaN;
minCircularity = Double.isNaN(minc) ? 0.0 : minc;
maxCircularity = Double.isNaN(maxc) ? 1.0 : maxc;
if (minCircularity < 0.0 || minCircularity > 1.0) minCircularity = 0.0;
if (maxCircularity < minCircularity || maxCircularity > 1.0) maxCircularity = 1.0;
if (minCircularity == 1.0 && maxCircularity == 1.0) minCircularity = 0.0;
staticMinCircularity = minCircularity;
staticMaxCircularity = maxCircularity;
if (gd.invalidNumber()) {
IJ.error("Bins invalid.");
canceled = true;
return false;
}
showChoice = gd.getNextChoiceIndex();
staticShowChoice = showChoice;
if (gd.getNextBoolean()) options |= SHOW_RESULTS;
else options &= ~SHOW_RESULTS;
if (gd.getNextBoolean()) options |= EXCLUDE_EDGE_PARTICLES;
else options &= ~EXCLUDE_EDGE_PARTICLES;
if (gd.getNextBoolean()) options |= CLEAR_WORKSHEET;
else options &= ~CLEAR_WORKSHEET;
if (gd.getNextBoolean()) options |= INCLUDE_HOLES;
else options &= ~INCLUDE_HOLES;
if (gd.getNextBoolean()) options |= DISPLAY_SUMMARY;
else options &= ~DISPLAY_SUMMARY;
if (gd.getNextBoolean()) options |= RECORD_STARTS;
else options &= ~RECORD_STARTS;
if (gd.getNextBoolean()) options |= ADD_TO_MANAGER;
else options &= ~ADD_TO_MANAGER;
if (gd.getNextBoolean()) options |= IN_SITU_SHOW;
else options &= ~IN_SITU_SHOW;
staticOptions = options;
options |= SHOW_PROGRESS;
if ((options & DISPLAY_SUMMARY) != 0)
Analyzer.setMeasurements(Analyzer.getMeasurements() | AREA);
return true;
}
boolean showDialog(ImageProcessor ip) {
String macroOptions = Macro.getOptions();
if (macroOptions != null) {
if (macroOptions.indexOf(" interpolate") != -1)
macroOptions.replaceAll(" interpolate", " interpolation=Bilinear");
else if (macroOptions.indexOf(" interpolation=") == -1)
macroOptions = macroOptions + " interpolation=None";
Macro.setOptions(macroOptions);
}
int bitDepth = imp.getBitDepth();
int stackSize = imp.getStackSize();
boolean isStack = stackSize > 1;
oldDepth = stackSize;
if (isStack) {
xstr = "1.0";
ystr = "1.0";
zstr = "1.0";
}
r = ip.getRoi();
int width = newWidth;
if (width == 0) width = r.width;
int height = (int) ((double) width * r.height / r.width);
xscale = Tools.parseDouble(xstr, 0.0);
yscale = Tools.parseDouble(ystr, 0.0);
zscale = 1.0;
if (xscale != 0.0 && yscale != 0.0) {
width = (int) (r.width * xscale);
height = (int) (r.height * yscale);
} else {
xstr = "-";
ystr = "-";
}
GenericDialog gd = new GenericDialog("Scale");
gd.addStringField("X Scale:", xstr);
gd.addStringField("Y Scale:", ystr);
if (isStack) gd.addStringField("Z Scale:", zstr);
gd.setInsets(5, 0, 5);
gd.addStringField("Width (pixels):", "" + width);
gd.addStringField("Height (pixels):", "" + height);
if (isStack) {
String label = "Depth (images):";
if (imp.isHyperStack()) {
int slices = imp.getNSlices();
int frames = imp.getNFrames();
if (slices == 1 && frames > 1) {
label = "Depth (frames):";
oldDepth = frames;
} else {
label = "Depth (slices):";
oldDepth = slices;
}
}
gd.addStringField(label, "" + oldDepth);
}
fields = gd.getStringFields();
for (int i = 0; i < fields.size(); i++) {
((TextField) fields.elementAt(i)).addTextListener(this);
((TextField) fields.elementAt(i)).addFocusListener(this);
}
xField = (TextField) fields.elementAt(0);
yField = (TextField) fields.elementAt(1);
if (isStack) {
zField = (TextField) fields.elementAt(2);
widthField = (TextField) fields.elementAt(3);
heightField = (TextField) fields.elementAt(4);
depthField = (TextField) fields.elementAt(5);
} else {
widthField = (TextField) fields.elementAt(2);
heightField = (TextField) fields.elementAt(3);
}
fieldWithFocus = xField;
gd.addChoice("Interpolation:", methods, methods[interpolationMethod]);
if (bitDepth == 8 || bitDepth == 24)
gd.addCheckbox("Fill with background color", fillWithBackground);
gd.addCheckbox("Average when downsizing", averageWhenDownsizing);
boolean hyperstack = imp.isHyperStack() || imp.isComposite();
if (isStack && !hyperstack) gd.addCheckbox("Process entire stack", processStack);
gd.addCheckbox("Create new window", newWindow);
title = WindowManager.getUniqueName(imp.getTitle());
gd.setInsets(10, 0, 0);
gd.addStringField("Title:", title, 12);
gd.showDialog();
if (gd.wasCanceled()) return false;
xstr = gd.getNextString();
ystr = gd.getNextString();
xscale = Tools.parseDouble(xstr, 0.0);
yscale = Tools.parseDouble(ystr, 0.0);
if (isStack) {
zstr = gd.getNextString();
zscale = Tools.parseDouble(ystr, 0.0);
}
String wstr = gd.getNextString();
newWidth = (int) Tools.parseDouble(wstr, 0);
newHeight = (int) Tools.parseDouble(gd.getNextString(), 0);
if (newHeight != 0 && (wstr.equals("-") || wstr.equals("0")))
newWidth = (int) (newHeight * (double) r.width / r.height);
if (newWidth == 0 || newHeight == 0) {
IJ.error("Scaler", "Width or height is 0");
return false;
}
if (xscale > 0.0 && yscale > 0.0) {
newWidth = (int) (r.width * xscale);
newHeight = (int) (r.height * yscale);
}
if (isStack) newDepth = (int) Tools.parseDouble(gd.getNextString(), 0);
interpolationMethod = gd.getNextChoiceIndex();
if (bitDepth == 8 || bitDepth == 24) fillWithBackground = gd.getNextBoolean();
averageWhenDownsizing = gd.getNextBoolean();
if (isStack && !hyperstack) processStack = gd.getNextBoolean();
if (hyperstack) processStack = true;
newWindow = gd.getNextBoolean();
if (xscale == 0.0) {
xscale = (double) newWidth / r.width;
yscale = (double) newHeight / r.height;
}
title = gd.getNextString();
if (fillWithBackground) {
Color bgc = Toolbar.getBackgroundColor();
if (bitDepth == 8) bgValue = ip.getBestIndex(bgc);
else if (bitDepth == 24) bgValue = bgc.getRGB();
} else bgValue = 0.0;
return true;
}
