/**
* 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 lineToArea(ImagePlus imp) {
Roi roi = imp.getRoi();
if (roi == null || !roi.isLine()) {
IJ.error("Line to Area", "Line selection required");
return;
}
if (roi.getType() == Roi.LINE && roi.getStrokeWidth() == 1) {
IJ.error("Line to Area", "Straight line width must be > 1");
return;
}
ImageProcessor ip2 = new ByteProcessor(imp.getWidth(), imp.getHeight());
ip2.setColor(255);
if (roi.getType() == Roi.LINE) ip2.fillPolygon(roi.getPolygon());
else {
roi.drawPixels(ip2);
// BufferedImage bi = new BufferedImage(imp.getWidth(), imp.getHeight(),
// BufferedImage.TYPE_BYTE_GRAY);
// Graphics g = bi.getGraphics();
// Roi roi2 = (Roi)roi.clone();
// roi2.setStrokeColor(Color.white);
// roi2.drawOverlay(g);
// ip2 = new ByteProcessor(bi);
}
// new ImagePlus("ip2", ip2.duplicate()).show();
ip2.setThreshold(255, 255, ImageProcessor.NO_LUT_UPDATE);
ThresholdToSelection tts = new ThresholdToSelection();
Roi roi2 = tts.convert(ip2);
imp.setRoi(roi2);
Roi.previousRoi = (Roi) roi.clone();
}
private String getExifData(ImagePlus imp) {
FileInfo fi = imp.getOriginalFileInfo();
if (fi == null) return null;
String directory = fi.directory;
String name = fi.fileName;
if (directory == null) return null;
if ((name == null || name.equals("")) && imp.getStack().isVirtual())
name = imp.getStack().getSliceLabel(imp.getCurrentSlice());
if (name == null || !(name.endsWith("jpg") || name.endsWith("JPG"))) return null;
String path = directory + name;
String metadata = null;
try {
Class c = IJ.getClassLoader().loadClass("Exif_Reader");
if (c == null) return null;
String methodName = "getMetadata";
Class[] argClasses = new Class[1];
argClasses[0] = methodName.getClass();
Method m = c.getMethod("getMetadata", argClasses);
Object[] args = new Object[1];
args[0] = path;
Object obj = m.invoke(null, args);
metadata = obj != null ? obj.toString() : null;
} catch (Exception e) {
return null;
}
if (metadata != null && !metadata.startsWith("Error:")) return metadata;
else return null;
}
public void mouseMoved(MouseEvent e) {
// if (ij==null) return;
int sx = e.getX();
int sy = e.getY();
int ox = offScreenX(sx);
int oy = offScreenY(sy);
flags = e.getModifiers();
setCursor(sx, sy, ox, oy);
IJ.setInputEvent(e);
Roi roi = imp.getRoi();
if (roi != null
&& (roi.getType() == Roi.POLYGON
|| roi.getType() == Roi.POLYLINE
|| roi.getType() == Roi.ANGLE)
&& roi.getState() == roi.CONSTRUCTING) {
PolygonRoi pRoi = (PolygonRoi) roi;
pRoi.handleMouseMove(ox, oy);
} else {
if (ox < imageWidth && oy < imageHeight) {
ImageWindow win = imp.getWindow();
// Cursor must move at least 12 pixels before text
// displayed using IJ.showStatus() is overwritten.
if ((sx - sx2) * (sx - sx2) + (sy - sy2) * (sy - sy2) > 144) showCursorStatus = true;
if (win != null && showCursorStatus) win.mouseMoved(ox, oy);
} else IJ.showStatus("");
}
}
public int setup(String arg, ImagePlus imp) {
this.arg = arg;
this.imp = imp;
IJ.register(ParticleAnalyzer.class);
if (imp == null) {
IJ.noImage();
return DONE;
}
if (imp.getBitDepth() == 24 && !isThresholdedRGB(imp)) {
IJ.error(
"Particle Analyzer",
"RGB images must be thresholded using\n" + "Image>Adjust>Color Threshold.");
return DONE;
}
if (!showDialog()) return DONE;
int baseFlags = DOES_ALL + NO_CHANGES + NO_UNDO;
int flags = IJ.setupDialog(imp, baseFlags);
processStack = (flags & DOES_STACKS) != 0;
slice = 0;
saveRoi = imp.getRoi();
if (saveRoi != null && saveRoi.getType() != Roi.RECTANGLE && saveRoi.isArea())
polygon = saveRoi.getPolygon();
imp.startTiming();
nextFontSize = defaultFontSize;
nextLineWidth = 1;
return flags;
}
void createEllipse(ImagePlus imp) {
IJ.showStatus("Fitting ellipse");
Roi roi = imp.getRoi();
if (roi == null) {
noRoi("Fit Ellipse");
return;
}
if (roi.isLine()) {
IJ.error("Fit Ellipse", "\"Fit Ellipse\" does not work with line selections");
return;
}
ImageProcessor ip = imp.getProcessor();
ip.setRoi(roi);
int options = Measurements.CENTROID + Measurements.ELLIPSE;
ImageStatistics stats = ImageStatistics.getStatistics(ip, options, null);
double dx = stats.major * Math.cos(stats.angle / 180.0 * Math.PI) / 2.0;
double dy = -stats.major * Math.sin(stats.angle / 180.0 * Math.PI) / 2.0;
double x1 = stats.xCentroid - dx;
double x2 = stats.xCentroid + dx;
double y1 = stats.yCentroid - dy;
double y2 = stats.yCentroid + dy;
double aspectRatio = stats.minor / stats.major;
imp.killRoi();
imp.setRoi(new EllipseRoi(x1, y1, x2, y2, aspectRatio));
}
void lineToArea(ImagePlus imp) {
Roi roi = imp.getRoi();
if (roi == null || !roi.isLine()) {
IJ.error("Line to Area", "Line selection required");
return;
}
Undo.setup(Undo.ROI, imp);
Roi roi2 = null;
if (roi.getType() == Roi.LINE) {
double width = roi.getStrokeWidth();
if (width <= 1.0) roi.setStrokeWidth(1.0000001);
FloatPolygon p = roi.getFloatPolygon();
roi.setStrokeWidth(width);
roi2 = new PolygonRoi(p, Roi.POLYGON);
roi2.setDrawOffset(roi.getDrawOffset());
} else {
ImageProcessor ip2 = new ByteProcessor(imp.getWidth(), imp.getHeight());
ip2.setColor(255);
roi.drawPixels(ip2);
// new ImagePlus("ip2", ip2.duplicate()).show();
ip2.setThreshold(255, 255, ImageProcessor.NO_LUT_UPDATE);
ThresholdToSelection tts = new ThresholdToSelection();
roi2 = tts.convert(ip2);
}
transferProperties(roi, roi2);
roi2.setStrokeWidth(0);
Color c = roi2.getStrokeColor();
if (c != null) // remove any transparency
roi2.setStrokeColor(new Color(c.getRed(), c.getGreen(), c.getBlue()));
imp.setRoi(roi2);
Roi.previousRoi = (Roi) roi.clone();
}
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();
}
void showDialog() {
int width = imp.getWidth();
int height = imp.getHeight();
Calibration cal = imp.getCalibration();
int places;
if (cal.scaled()) {
pixelWidth = cal.pixelWidth;
pixelHeight = cal.pixelHeight;
units = cal.getUnits();
places = 2;
} else {
pixelWidth = 1.0;
pixelHeight = 1.0;
units = "pixels";
places = 0;
}
if (areaPerPoint == 0.0)
areaPerPoint =
(width * cal.pixelWidth * height * cal.pixelHeight) / 81.0; // default to 9x9 grid
ImageWindow win = imp.getWindow();
GenericDialog gd = new GenericDialog("Grid...");
gd.addChoice("Grid Type:", types, type);
gd.addNumericField("Area per Point:", areaPerPoint, places, 6, units + "^2");
gd.addChoice("Color:", colors, color);
gd.addCheckbox("Random Offset", randomOffset);
gd.addDialogListener(this);
gd.showDialog();
if (gd.wasCanceled()) showGrid(null);
}
/** Sets the cursor based on the current tool and cursor location. */
public void setCursor(int sx, int sy, int ox, int oy) {
xMouse = ox;
yMouse = oy;
mouseExited = false;
Roi roi = imp.getRoi();
ImageWindow win = imp.getWindow();
if (win == null) return;
if (IJ.spaceBarDown()) {
setCursor(handCursor);
return;
}
int id = Toolbar.getToolId();
switch (Toolbar.getToolId()) {
case Toolbar.MAGNIFIER:
setCursor(moveCursor);
break;
case Toolbar.HAND:
setCursor(handCursor);
break;
default: // selection tool
if (id == Toolbar.SPARE1 || id >= Toolbar.SPARE2) {
if (Prefs.usePointerCursor) setCursor(defaultCursor);
else setCursor(crosshairCursor);
} else if (roi != null && roi.getState() != roi.CONSTRUCTING && roi.isHandle(sx, sy) >= 0)
setCursor(handCursor);
else if (Prefs.usePointerCursor
|| (roi != null && roi.getState() != roi.CONSTRUCTING && roi.contains(ox, oy)))
setCursor(defaultCursor);
else setCursor(crosshairCursor);
}
}
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);
}
void updateSliceSummary() {
int slices = imp.getStackSize();
float[] areas = rt.getColumn(ResultsTable.AREA);
if (areas == null) areas = new float[0];
String label = imp.getTitle();
if (slices > 1) {
label = imp.getStack().getShortSliceLabel(slice);
label = label != null && !label.equals("") ? label : "" + slice;
}
String aLine = null;
double sum = 0.0;
int start = areas.length - particleCount;
if (start < 0) return;
for (int i = start; i < areas.length; i++) sum += areas[i];
int places = Analyzer.getPrecision();
Calibration cal = imp.getCalibration();
String total = "\t" + ResultsTable.d2s(sum, places);
String average = "\t" + ResultsTable.d2s(sum / particleCount, places);
String fraction = "\t" + ResultsTable.d2s(sum * 100.0 / totalArea, 1);
aLine = label + "\t" + particleCount + total + average + fraction;
aLine = addMeans(aLine, areas.length > 0 ? start : -1);
if (slices == 1) {
Frame frame = WindowManager.getFrame("Summary");
if (frame != null && (frame instanceof TextWindow) && summaryHdr.equals(prevHdr))
tw = (TextWindow) frame;
}
if (tw == null) {
String title = slices == 1 ? "Summary" : "Summary of " + imp.getTitle();
tw = new TextWindow(title, summaryHdr, aLine, 450, 300);
prevHdr = summaryHdr;
} else tw.append(aLine);
}
/**
* Zooms out by making the source rectangle (srcRect) larger and centering it on (x,y). If we
* can't make it larger, then make the window smaller.
*/
public void zoomOut(int x, int y) {
if (magnification <= 0.03125) return;
double oldMag = magnification;
double newMag = getLowerZoomLevel(magnification);
double srcRatio = (double) srcRect.width / srcRect.height;
double imageRatio = (double) imageWidth / imageHeight;
double initialMag = imp.getWindow().getInitialMagnification();
if (Math.abs(srcRatio - imageRatio) > 0.05) {
double scale = oldMag / newMag;
int newSrcWidth = (int) Math.round(srcRect.width * scale);
int newSrcHeight = (int) Math.round(srcRect.height * scale);
if (newSrcWidth > imageWidth) newSrcWidth = imageWidth;
if (newSrcHeight > imageHeight) newSrcHeight = imageHeight;
int newSrcX = srcRect.x - (newSrcWidth - srcRect.width) / 2;
int newSrcY = srcRect.y - (newSrcHeight - srcRect.height) / 2;
if (newSrcX < 0) newSrcX = 0;
if (newSrcY < 0) newSrcY = 0;
srcRect = new Rectangle(newSrcX, newSrcY, newSrcWidth, newSrcHeight);
// IJ.log(newMag+" "+srcRect+" "+dstWidth+" "+dstHeight);
int newDstWidth = (int) (srcRect.width * newMag);
int newDstHeight = (int) (srcRect.height * newMag);
setMagnification(newMag);
setMaxBounds();
// IJ.log(newDstWidth+" "+dstWidth+" "+newDstHeight+" "+dstHeight);
if (newDstWidth < dstWidth || newDstHeight < dstHeight) {
// IJ.log("pack");
setDrawingSize(newDstWidth, newDstHeight);
imp.getWindow().pack();
} else repaint();
return;
}
if (imageWidth * newMag > dstWidth) {
int w = (int) Math.round(dstWidth / newMag);
if (w * newMag < dstWidth) w++;
int h = (int) Math.round(dstHeight / newMag);
if (h * newMag < dstHeight) h++;
x = offScreenX(x);
y = offScreenY(y);
Rectangle r = new Rectangle(x - w / 2, y - h / 2, w, h);
if (r.x < 0) r.x = 0;
if (r.y < 0) r.y = 0;
if (r.x + w > imageWidth) r.x = imageWidth - w;
if (r.y + h > imageHeight) r.y = imageHeight - h;
srcRect = r;
} else {
srcRect = new Rectangle(0, 0, imageWidth, imageHeight);
setDrawingSize((int) (imageWidth * newMag), (int) (imageHeight * newMag));
// setDrawingSize(dstWidth/2, dstHeight/2);
imp.getWindow().pack();
}
// IJ.write(newMag + " " + srcRect.x+" "+srcRect.y+" "+srcRect.width+" "+srcRect.height+"
// "+dstWidth + " " + dstHeight);
setMagnification(newMag);
// IJ.write(srcRect.x + " " + srcRect.width + " " + dstWidth);
setMaxBounds();
repaint();
}
void toBoundingBox(ImagePlus imp) {
Roi roi = imp.getRoi();
if (roi == null) {
noRoi("To Bounding Box");
return;
}
Rectangle r = roi.getBounds();
imp.killRoi();
imp.setRoi(new Roi(r.x, r.y, r.width, r.height));
}
void updateImage(ImagePlus imp) {
this.imp = imp;
int width = imp.getWidth();
int height = imp.getHeight();
imageWidth = width;
imageHeight = height;
srcRect = new Rectangle(0, 0, imageWidth, imageHeight);
setDrawingSize(imageWidth, (int) imageHeight);
magnification = 1.0;
}
/** Sets the color used used for the ROI Manager "Show All" mode. */
public static void setShowAllColor(Color c) {
if (c == null) return;
showAllColor = c;
labelColor = null;
ImagePlus img = WindowManager.getCurrentImage();
if (img != null) {
ImageCanvas ic = img.getCanvas();
if (ic != null && ic.getShowAllROIs()) img.draw();
}
}
void invert(ImagePlus imp) {
Roi roi = imp.getRoi();
if (roi == null || !roi.isArea()) {
IJ.error("Inverse", "Area selection required");
return;
}
ShapeRoi s1, s2;
if (roi instanceof ShapeRoi) s1 = (ShapeRoi) roi;
else s1 = new ShapeRoi(roi);
s2 = new ShapeRoi(new Roi(0, 0, imp.getWidth(), imp.getHeight()));
imp.setRoi(s1.xor(s2));
}
/** Implements the Image/Zoom/Original Scale command. */
public void unzoom() {
double imag = imp.getWindow().getInitialMagnification();
if (magnification == imag) return;
srcRect = new Rectangle(0, 0, imageWidth, imageHeight);
ImageWindow win = imp.getWindow();
setDrawingSize((int) (imageWidth * imag), (int) (imageHeight * imag));
setMagnification(imag);
setMaxBounds();
win.pack();
setMaxBounds();
repaint();
}
void toBoundingBox(ImagePlus imp) {
Roi roi = imp.getRoi();
if (roi == null) {
noRoi("To Bounding Box");
return;
}
Undo.setup(Undo.ROI, imp);
Rectangle r = roi.getBounds();
imp.deleteRoi();
Roi roi2 = new Roi(r.x, r.y, r.width, r.height);
transferProperties(roi, roi2);
imp.setRoi(roi2);
}
boolean setThresholdLevels(ImagePlus imp, ImageProcessor ip) {
double t1 = ip.getMinThreshold();
double t2 = ip.getMaxThreshold();
boolean invertedLut = imp.isInvertedLut();
boolean byteImage = ip instanceof ByteProcessor;
if (ip instanceof ShortProcessor) imageType = SHORT;
else if (ip instanceof FloatProcessor) imageType = FLOAT;
else imageType = BYTE;
if (t1 == ImageProcessor.NO_THRESHOLD) {
ImageStatistics stats = imp.getStatistics();
if (imageType != BYTE || (stats.histogram[0] + stats.histogram[255] != stats.pixelCount)) {
IJ.error(
"Particle Analyzer",
"A thresholded image or 8-bit binary image is\n"
+ "required. Threshold levels can be set using\n"
+ "the Image->Adjust->Threshold tool.");
canceled = true;
return false;
}
boolean threshold255 = invertedLut;
if (Prefs.blackBackground) threshold255 = !threshold255;
if (threshold255) {
level1 = 255;
level2 = 255;
fillColor = 64;
} else {
level1 = 0;
level2 = 0;
fillColor = 192;
}
} else {
level1 = t1;
level2 = t2;
if (imageType == BYTE) {
if (level1 > 0) fillColor = 0;
else if (level2 < 255) fillColor = 255;
} else if (imageType == SHORT) {
if (level1 > 0) fillColor = 0;
else if (level2 < 65535) fillColor = 65535;
} else if (imageType == FLOAT) fillColor = -Float.MAX_VALUE;
else return false;
}
imageType2 = imageType;
if (redirectIP != null) {
if (redirectIP instanceof ShortProcessor) imageType2 = SHORT;
else if (redirectIP instanceof FloatProcessor) imageType2 = FLOAT;
else if (redirectIP instanceof ColorProcessor) imageType2 = RGB;
else imageType2 = BYTE;
}
return true;
}
void createMaskFromThreshold(ImagePlus imp) {
ImageProcessor ip = imp.getProcessor();
if (ip.getMinThreshold() == ImageProcessor.NO_THRESHOLD) {
IJ.error("Create Mask", "Area selection or thresholded image required");
return;
}
double t1 = ip.getMinThreshold();
double t2 = ip.getMaxThreshold();
IJ.run("Duplicate...", "title=mask");
ImagePlus imp2 = WindowManager.getCurrentImage();
ImageProcessor ip2 = imp2.getProcessor();
ip2.setThreshold(t1, t2, ImageProcessor.NO_LUT_UPDATE);
IJ.run("Convert to Mask");
}
void convexHull(ImagePlus imp) {
Roi roi = imp.getRoi();
int type = roi != null ? roi.getType() : -1;
if (!(type == Roi.FREEROI
|| type == Roi.TRACED_ROI
|| type == Roi.POLYGON
|| type == Roi.POINT)) {
IJ.error("Convex Hull", "Polygonal or point selection required");
return;
}
if (roi instanceof EllipseRoi) return;
Polygon p = roi.getConvexHull();
if (p != null) imp.setRoi(new PolygonRoi(p.xpoints, p.ypoints, p.npoints, roi.POLYGON));
}
public ImageCanvas(ImagePlus imp) {
this.imp = imp;
ij = IJ.getInstance();
int width = imp.getWidth();
int height = imp.getHeight();
imageWidth = width;
imageHeight = height;
srcRect = new Rectangle(0, 0, imageWidth, imageHeight);
setDrawingSize(imageWidth, (int) (imageHeight));
magnification = 1.0;
addMouseListener(this);
addMouseMotionListener(this);
addKeyListener(ij); // ImageJ handles keyboard shortcuts
setFocusTraversalKeysEnabled(false);
}
public String getImageInfo(ImagePlus imp, ImageProcessor ip) {
String infoProperty = null;
if (imp.getStackSize() > 1) {
ImageStack stack = imp.getStack();
String label = stack.getSliceLabel(imp.getCurrentSlice());
if (label != null && label.indexOf('\n') > 0) infoProperty = label;
}
if (infoProperty == null) {
infoProperty = (String) imp.getProperty("Info");
if (infoProperty == null) infoProperty = getExifData(imp);
}
String info = getInfo(imp, ip);
if (infoProperty != null) return infoProperty + "\n------------------------\n" + info;
else return info;
}
void setStackDisplayRange(ImagePlus imp) {
ImageStack stack = imp.getStack();
double min = Double.MAX_VALUE;
double max = -Double.MAX_VALUE;
int n = stack.getSize();
for (int i = 1; i <= n; i++) {
if (!silentMode) IJ.showStatus("Calculating stack min and max: " + i + "/" + n);
ImageProcessor ip = stack.getProcessor(i);
ip.resetMinAndMax();
if (ip.getMin() < min) min = ip.getMin();
if (ip.getMax() > max) max = ip.getMax();
}
imp.getProcessor().setMinAndMax(min, max);
imp.updateAndDraw();
}
public String[] getOpenImageNames() {
int[] imageIDList = WindowManager.getIDList();
String[] imageNames = new String[imageIDList.length];
// imageNames[0] = "None";
if (!imageIDList.equals(null) && imageIDList.length > 1) {
for (int i = 0; i < imageIDList.length; i++) {
ImagePlus tempIMP = WindowManager.getImage(imageIDList[i]);
imageNames[i] = tempIMP.getTitle();
}
return imageNames;
} else {
imageNames[0] = "None";
return imageNames;
}
}
void resetMaxBounds() {
ImageWindow win = imp.getWindow();
if (win != null && (System.currentTimeMillis() - win.setMaxBoundsTime) > 500L) {
win.setMaximizedBounds(win.maxWindowBounds);
maxBoundsReset = true;
}
}
void addToRoiManager(ImagePlus imp) {
if (IJ.macroRunning() && Interpreter.isBatchModeRoiManager())
IJ.error("run(\"Add to Manager\") may not work in batch mode macros");
Frame frame = WindowManager.getFrame("ROI Manager");
if (frame == null) IJ.run("ROI Manager...");
if (imp == null) return;
Roi roi = imp.getRoi();
if (roi == null) return;
frame = WindowManager.getFrame("ROI Manager");
if (frame == null || !(frame instanceof RoiManager)) IJ.error("ROI Manager not found");
RoiManager rm = (RoiManager) frame;
boolean altDown = IJ.altKeyDown();
IJ.setKeyUp(IJ.ALL_KEYS);
if (altDown && !IJ.macroRunning()) IJ.setKeyDown(KeyEvent.VK_SHIFT);
if (roi.getState() == Roi.CONSTRUCTING) { // wait (up to 2 sec.) until ROI finished
long start = System.currentTimeMillis();
while (true) {
IJ.wait(10);
if (roi.getState() != Roi.CONSTRUCTING) break;
if ((System.currentTimeMillis() - start) > 2000) {
IJ.beep();
IJ.error("Add to Manager", "Selection is not complete");
return;
}
}
}
rm.runCommand("add");
IJ.setKeyUp(IJ.ALL_KEYS);
}
void drawLines() {
GeneralPath path = new GeneralPath();
int width = imp.getWidth();
int height = imp.getHeight();
for (int i = 0; i < linesV; i++) {
float xoff = (float) (xstart + i * tileWidth);
path.moveTo(xoff, 0f);
path.lineTo(xoff, height);
}
for (int i = 0; i < linesH; i++) {
float yoff = (float) (ystart + i * tileHeight);
path.moveTo(0f, yoff);
path.lineTo(width, yoff);
}
showGrid(path);
}
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;
}
}