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);
}
void hide() {
ImagePlus imp = IJ.getImage();
Overlay overlay = imp.getOverlay();
if (overlay != null) {
overlay2 = overlay;
imp.setOverlay(null);
}
RoiManager rm = RoiManager.getInstance();
if (rm != null) rm.runCommand("show none");
}
public void doHyperStackProjection(boolean allTimeFrames) {
int start = startSlice;
int stop = stopSlice;
int firstFrame = 1;
int lastFrame = imp.getNFrames();
if (!allTimeFrames) firstFrame = lastFrame = imp.getFrame();
ImageStack stack = new ImageStack(imp.getWidth(), imp.getHeight());
int channels = imp.getNChannels();
int slices = imp.getNSlices();
if (slices == 1) {
slices = imp.getNFrames();
firstFrame = lastFrame = 1;
}
int frames = lastFrame - firstFrame + 1;
increment = channels;
boolean rgb = imp.getBitDepth() == 24;
for (int frame = firstFrame; frame <= lastFrame; frame++) {
for (int channel = 1; channel <= channels; channel++) {
startSlice = (frame - 1) * channels * slices + (start - 1) * channels + channel;
stopSlice = (frame - 1) * channels * slices + (stop - 1) * channels + channel;
if (rgb) doHSRGBProjection(imp);
else doProjection();
stack.addSlice(null, projImage.getProcessor());
}
}
projImage = new ImagePlus(makeTitle(), stack);
projImage.setDimensions(channels, 1, frames);
if (channels > 1) {
projImage = new CompositeImage(projImage, 0);
((CompositeImage) projImage).copyLuts(imp);
if (method == SUM_METHOD || method == SD_METHOD)
((CompositeImage) projImage).resetDisplayRanges();
}
if (frames > 1) projImage.setOpenAsHyperStack(true);
Overlay overlay = imp.getOverlay();
if (overlay != null) {
startSlice = start;
stopSlice = stop;
if (imp.getType() == ImagePlus.COLOR_RGB)
projImage.setOverlay(projectRGBHyperStackRois(overlay));
else projImage.setOverlay(projectHyperStackRois(overlay));
}
IJ.showProgress(1, 1);
}
private boolean deleteOverlayRoi(ImagePlus imp) {
if (imp == null) return false;
Overlay overlay = null;
ImageCanvas ic = imp.getCanvas();
if (ic != null) overlay = ic.getShowAllList();
if (overlay == null) overlay = imp.getOverlay();
if (overlay == null) return false;
Roi roi = imp.getRoi();
for (int i = 0; i < overlay.size(); i++) {
Roi roi2 = overlay.get(i);
if (roi2 == roi) {
overlay.remove(i);
imp.deleteRoi();
ic = imp.getCanvas();
if (ic != null) ic.roiManagerSelect(roi, true);
return true;
}
}
return false;
}
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);
}
void addImage() {
ImagePlus imp = IJ.getImage();
int[] wList = WindowManager.getIDList();
if (wList == null || wList.length < 2) {
IJ.error("Add Image...", "The command requires at least two open images.");
return;
}
String[] titles = new String[wList.length];
for (int i = 0; i < wList.length; i++) {
ImagePlus imp2 = WindowManager.getImage(wList[i]);
titles[i] = imp2 != null ? imp2.getTitle() : "";
}
int x = 0, y = 0;
Roi roi = imp.getRoi();
if (roi != null && roi.isArea()) {
Rectangle r = roi.getBounds();
x = r.x;
y = r.y;
}
int index = 0;
if (wList.length == 2) {
ImagePlus i1 = WindowManager.getImage(wList[0]);
ImagePlus i2 = WindowManager.getImage(wList[1]);
if (i2.getWidth() < i1.getWidth() && i2.getHeight() < i1.getHeight()) index = 1;
} else if (imp.getID() == wList[0]) index = 1;
GenericDialog gd = new GenericDialog("Add Image...");
gd.addChoice("Image to add:", titles, titles[index]);
gd.addNumericField("X location:", x, 0);
gd.addNumericField("Y location:", y, 0);
gd.addNumericField("Opacity (0-100%):", 100, 0);
gd.addCheckbox("Create image selection", createImageRoi);
gd.showDialog();
if (gd.wasCanceled()) return;
index = gd.getNextChoiceIndex();
x = (int) gd.getNextNumber();
y = (int) gd.getNextNumber();
double opacity = gd.getNextNumber() / 100.0;
createImageRoi = gd.getNextBoolean();
ImagePlus overlay = WindowManager.getImage(wList[index]);
if (wList.length == 2) {
ImagePlus i1 = WindowManager.getImage(wList[0]);
ImagePlus i2 = WindowManager.getImage(wList[1]);
if (i2.getWidth() < i1.getWidth() && i2.getHeight() < i1.getHeight()) {
imp = i1;
overlay = i2;
}
}
if (overlay == imp) {
IJ.error(
"Add Image...", "Image to be added cannot be the same as\n\"" + imp.getTitle() + "\".");
return;
}
if (overlay.getWidth() > imp.getWidth() && overlay.getHeight() > imp.getHeight()) {
IJ.error(
"Add Image...", "Image to be added cannnot be larger than\n\"" + imp.getTitle() + "\".");
return;
}
if (createImageRoi && x == 0 && y == 0) {
x = imp.getWidth() / 2 - overlay.getWidth() / 2;
y = imp.getHeight() / 2 - overlay.getHeight() / 2;
}
roi = new ImageRoi(x, y, overlay.getProcessor());
roi.setName(overlay.getShortTitle());
if (opacity != 1.0) ((ImageRoi) roi).setOpacity(opacity);
if (createImageRoi) imp.setRoi(roi);
else {
Overlay overlayList = imp.getOverlay();
if (overlayList == null) overlayList = new Overlay();
overlayList.add(roi);
imp.setOverlay(overlayList);
overlay2 = overlayList;
Undo.setup(Undo.OVERLAY_ADDITION, imp);
}
}
String getInfo(ImagePlus imp, ImageProcessor ip) {
String s = new String("\n");
s += "Title: " + imp.getTitle() + "\n";
Calibration cal = imp.getCalibration();
int stackSize = imp.getStackSize();
int channels = imp.getNChannels();
int slices = imp.getNSlices();
int frames = imp.getNFrames();
int digits = imp.getBitDepth() == 32 ? 4 : 0;
if (cal.scaled()) {
String unit = cal.getUnit();
String units = cal.getUnits();
s +=
"Width: "
+ IJ.d2s(imp.getWidth() * cal.pixelWidth, 2)
+ " "
+ units
+ " ("
+ imp.getWidth()
+ ")\n";
s +=
"Height: "
+ IJ.d2s(imp.getHeight() * cal.pixelHeight, 2)
+ " "
+ units
+ " ("
+ imp.getHeight()
+ ")\n";
if (slices > 1)
s += "Depth: " + IJ.d2s(slices * cal.pixelDepth, 2) + " " + units + " (" + slices + ")\n";
double xResolution = 1.0 / cal.pixelWidth;
double yResolution = 1.0 / cal.pixelHeight;
int places = Tools.getDecimalPlaces(xResolution, yResolution);
if (xResolution == yResolution)
s += "Resolution: " + IJ.d2s(xResolution, places) + " pixels per " + unit + "\n";
else {
s += "X Resolution: " + IJ.d2s(xResolution, places) + " pixels per " + unit + "\n";
s += "Y Resolution: " + IJ.d2s(yResolution, places) + " pixels per " + unit + "\n";
}
} else {
s += "Width: " + imp.getWidth() + " pixels\n";
s += "Height: " + imp.getHeight() + " pixels\n";
if (stackSize > 1) s += "Depth: " + slices + " pixels\n";
}
if (stackSize > 1)
s +=
"Voxel size: "
+ d2s(cal.pixelWidth)
+ "x"
+ d2s(cal.pixelHeight)
+ "x"
+ d2s(cal.pixelDepth)
+ " "
+ cal.getUnit()
+ "\n";
else
s +=
"Pixel size: "
+ d2s(cal.pixelWidth)
+ "x"
+ d2s(cal.pixelHeight)
+ " "
+ cal.getUnit()
+ "\n";
s += "ID: " + imp.getID() + "\n";
String zOrigin = stackSize > 1 || cal.zOrigin != 0.0 ? "," + d2s(cal.zOrigin) : "";
s += "Coordinate origin: " + d2s(cal.xOrigin) + "," + d2s(cal.yOrigin) + zOrigin + "\n";
int type = imp.getType();
switch (type) {
case ImagePlus.GRAY8:
s += "Bits per pixel: 8 ";
String lut = "LUT";
if (imp.getProcessor().isColorLut()) lut = "color " + lut;
else lut = "grayscale " + lut;
if (imp.isInvertedLut()) lut = "inverting " + lut;
s += "(" + lut + ")\n";
if (imp.getNChannels() > 1) s += displayRanges(imp);
else s += "Display range: " + (int) ip.getMin() + "-" + (int) ip.getMax() + "\n";
break;
case ImagePlus.GRAY16:
case ImagePlus.GRAY32:
if (type == ImagePlus.GRAY16) {
String sign = cal.isSigned16Bit() ? "signed" : "unsigned";
s += "Bits per pixel: 16 (" + sign + ")\n";
} else s += "Bits per pixel: 32 (float)\n";
if (imp.getNChannels() > 1) s += displayRanges(imp);
else {
s += "Display range: ";
double min = ip.getMin();
double max = ip.getMax();
if (cal.calibrated()) {
min = cal.getCValue((int) min);
max = cal.getCValue((int) max);
}
s += IJ.d2s(min, digits) + " - " + IJ.d2s(max, digits) + "\n";
}
break;
case ImagePlus.COLOR_256:
s += "Bits per pixel: 8 (color LUT)\n";
break;
case ImagePlus.COLOR_RGB:
s += "Bits per pixel: 32 (RGB)\n";
break;
}
double interval = cal.frameInterval;
double fps = cal.fps;
if (stackSize > 1) {
ImageStack stack = imp.getStack();
int slice = imp.getCurrentSlice();
String number = slice + "/" + stackSize;
String label = stack.getShortSliceLabel(slice);
if (label != null && label.length() > 0) label = " (" + label + ")";
else label = "";
if (interval > 0.0 || fps != 0.0) {
s += "Frame: " + number + label + "\n";
if (fps != 0.0) {
String sRate =
Math.abs(fps - Math.round(fps)) < 0.00001 ? IJ.d2s(fps, 0) : IJ.d2s(fps, 5);
s += "Frame rate: " + sRate + " fps\n";
}
if (interval != 0.0)
s +=
"Frame interval: "
+ ((int) interval == interval ? IJ.d2s(interval, 0) : IJ.d2s(interval, 5))
+ " "
+ cal.getTimeUnit()
+ "\n";
} else s += "Image: " + number + label + "\n";
if (imp.isHyperStack()) {
if (channels > 1) s += " Channel: " + imp.getChannel() + "/" + channels + "\n";
if (slices > 1) s += " Slice: " + imp.getSlice() + "/" + slices + "\n";
if (frames > 1) s += " Frame: " + imp.getFrame() + "/" + frames + "\n";
}
if (imp.isComposite()) {
if (!imp.isHyperStack() && channels > 1) s += " Channels: " + channels + "\n";
String mode = ((CompositeImage) imp).getModeAsString();
s += " Composite mode: \"" + mode + "\"\n";
}
}
if (ip.getMinThreshold() == ImageProcessor.NO_THRESHOLD) s += "No Threshold\n";
else {
double lower = ip.getMinThreshold();
double upper = ip.getMaxThreshold();
int dp = digits;
if (cal.calibrated()) {
lower = cal.getCValue((int) lower);
upper = cal.getCValue((int) upper);
dp = cal.isSigned16Bit() ? 0 : 4;
}
s += "Threshold: " + IJ.d2s(lower, dp) + "-" + IJ.d2s(upper, dp) + "\n";
}
ImageCanvas ic = imp.getCanvas();
double mag = ic != null ? ic.getMagnification() : 1.0;
if (mag != 1.0) s += "Magnification: " + IJ.d2s(mag, 2) + "\n";
if (cal.calibrated()) {
s += " \n";
int curveFit = cal.getFunction();
s += "Calibration Function: ";
if (curveFit == Calibration.UNCALIBRATED_OD) s += "Uncalibrated OD\n";
else if (curveFit == Calibration.CUSTOM) s += "Custom lookup table\n";
else s += CurveFitter.fList[curveFit] + "\n";
double[] c = cal.getCoefficients();
if (c != null) {
s += " a: " + IJ.d2s(c[0], 6) + "\n";
s += " b: " + IJ.d2s(c[1], 6) + "\n";
if (c.length >= 3) s += " c: " + IJ.d2s(c[2], 6) + "\n";
if (c.length >= 4) s += " c: " + IJ.d2s(c[3], 6) + "\n";
if (c.length >= 5) s += " c: " + IJ.d2s(c[4], 6) + "\n";
}
s += " Unit: \"" + cal.getValueUnit() + "\"\n";
} else s += "Uncalibrated\n";
FileInfo fi = imp.getOriginalFileInfo();
if (fi != null) {
if (fi.url != null && !fi.url.equals("")) s += "URL: " + fi.url + "\n";
else if (fi.directory != null && fi.fileName != null)
s += "Path: " + fi.directory + fi.fileName + "\n";
}
ImageWindow win = imp.getWindow();
if (win != null) {
Point loc = win.getLocation();
Dimension screen = IJ.getScreenSize();
s +=
"Screen location: "
+ loc.x
+ ","
+ loc.y
+ " ("
+ screen.width
+ "x"
+ screen.height
+ ")\n";
}
Overlay overlay = imp.getOverlay();
if (overlay != null) {
String hidden = imp.getHideOverlay() ? " (hidden)" : " ";
int n = overlay.size();
String elements = n == 1 ? " element" : " elements";
s += "Overlay: " + n + elements + (imp.getHideOverlay() ? " (hidden)" : "") + "\n";
} else s += "No Overlay\n";
Roi roi = imp.getRoi();
if (roi == null) {
if (cal.calibrated()) s += " \n";
s += "No Selection\n";
} else if (roi instanceof EllipseRoi) {
s += "\nElliptical Selection\n";
double[] p = ((EllipseRoi) roi).getParams();
double dx = p[2] - p[0];
double dy = p[3] - p[1];
double major = Math.sqrt(dx * dx + dy * dy);
s += " Major: " + IJ.d2s(major, 2) + "\n";
s += " Minor: " + IJ.d2s(major * p[4], 2) + "\n";
s += " X1: " + IJ.d2s(p[0], 2) + "\n";
s += " Y1: " + IJ.d2s(p[1], 2) + "\n";
s += " X2: " + IJ.d2s(p[2], 2) + "\n";
s += " Y2: " + IJ.d2s(p[3], 2) + "\n";
s += " Aspect ratio: " + IJ.d2s(p[4], 2) + "\n";
} else {
s += " \n";
s += roi.getTypeAsString() + " Selection";
String points = null;
if (roi instanceof PointRoi) {
int npoints = ((PolygonRoi) roi).getNCoordinates();
String suffix = npoints > 1 ? "s)" : ")";
points = " (" + npoints + " point" + suffix;
}
String name = roi.getName();
if (name != null) {
s += " (\"" + name + "\")";
if (points != null) s += "\n " + points;
} else if (points != null) s += points;
s += "\n";
Rectangle r = roi.getBounds();
if (roi instanceof Line) {
Line line = (Line) roi;
s += " X1: " + IJ.d2s(line.x1d * cal.pixelWidth) + "\n";
s += " Y1: " + IJ.d2s(yy(line.y1d, imp) * cal.pixelHeight) + "\n";
s += " X2: " + IJ.d2s(line.x2d * cal.pixelWidth) + "\n";
s += " Y2: " + IJ.d2s(yy(line.y2d, imp) * cal.pixelHeight) + "\n";
} else if (cal.scaled()) {
s += " X: " + IJ.d2s(cal.getX(r.x)) + " (" + r.x + ")\n";
s += " Y: " + IJ.d2s(cal.getY(r.y, imp.getHeight())) + " (" + r.y + ")\n";
s += " Width: " + IJ.d2s(r.width * cal.pixelWidth) + " (" + r.width + ")\n";
s += " Height: " + IJ.d2s(r.height * cal.pixelHeight) + " (" + r.height + ")\n";
} else {
s += " X: " + r.x + "\n";
s += " Y: " + yy(r.y, imp) + "\n";
s += " Width: " + r.width + "\n";
s += " Height: " + r.height + "\n";
}
}
return s;
}
public void run(String arg) {
int wOld, hOld, wNew, hNew;
boolean fIsStack = false;
ImagePlus imp = IJ.getImage();
wOld = imp.getWidth();
hOld = imp.getHeight();
ImageStack stackOld = imp.getStack();
if ((stackOld != null) && (stackOld.getSize() > 1)) fIsStack = true;
String[] sPositions = {
"Top-Left", "Top-Center", "Top-Right",
"Center-Left", "Center", "Center-Right",
"Bottom-Left", "Bottom-Center", "Bottom-Right"
};
String strTitle = fIsStack ? "Resize Stack Canvas" : "Resize Image Canvas";
GenericDialog gd = new GenericDialog(strTitle);
gd.addNumericField("Width:", wOld, 0, 5, "pixels");
gd.addNumericField("Height:", hOld, 0, 5, "pixels");
gd.addChoice("Position:", sPositions, sPositions[4]);
gd.addCheckbox("Zero Fill", zeroFill);
gd.showDialog();
if (gd.wasCanceled()) return;
wNew = (int) gd.getNextNumber();
hNew = (int) gd.getNextNumber();
int iPos = gd.getNextChoiceIndex();
zeroFill = gd.getNextBoolean();
Prefs.set("resizer.zero", zeroFill);
int xOff, yOff;
int xC = (wNew - wOld) / 2; // offset for centered
int xR = (wNew - wOld); // offset for right
int yC = (hNew - hOld) / 2; // offset for centered
int yB = (hNew - hOld); // offset for bottom
switch (iPos) {
case 0: // TL
xOff = 0;
yOff = 0;
break;
case 1: // TC
xOff = xC;
yOff = 0;
break;
case 2: // TR
xOff = xR;
yOff = 0;
break;
case 3: // CL
xOff = 0;
yOff = yC;
break;
case 4: // C
xOff = xC;
yOff = yC;
break;
case 5: // CR
xOff = xR;
yOff = yC;
break;
case 6: // BL
xOff = 0;
yOff = yB;
break;
case 7: // BC
xOff = xC;
yOff = yB;
break;
case 8: // BR
xOff = xR;
yOff = yB;
break;
default: // center
xOff = xC;
yOff = yC;
break;
}
if (fIsStack) {
ImageStack stackNew = expandStack(stackOld, wNew, hNew, xOff, yOff);
imp.setStack(null, stackNew);
} else {
if (!IJ.macroRunning()) Undo.setup(Undo.COMPOUND_FILTER, imp);
ImageWindow win = imp.getWindow();
if (win != null && (win instanceof PlotWindow)) ((PlotWindow) win).getPlot().setFrozen(true);
ImageProcessor newIP = expandImage(imp.getProcessor(), wNew, hNew, xOff, yOff);
imp.setProcessor(null, newIP);
if (!IJ.macroRunning()) Undo.setup(Undo.COMPOUND_FILTER_DONE, imp);
}
Overlay overlay = imp.getOverlay();
if (overlay != null) overlay.translate(xOff, yOff);
}
/**
* Performs actual projection using specified method. If handleOverlay, adds stack overlay
* elements from startSlice to stopSlice to projection
*/
public void doProjection(boolean handleOverlay) {
doProjection();
Overlay overlay = imp.getOverlay();
if (handleOverlay && overlay != null) projImage.setOverlay(projectStackRois(overlay));
}