void drawAllROIs(Graphics g) {
RoiManager rm = RoiManager.getInstance();
if (rm == null) {
rm = Interpreter.getBatchModeRoiManager();
if (rm != null && rm.getList().getItemCount() == 0) rm = null;
}
if (rm == null) {
// if (showAllList!=null)
// overlay = showAllList;
showAllROIs = false;
repaint();
return;
}
initGraphics(g, null, showAllColor);
Hashtable rois = rm.getROIs();
java.awt.List list = rm.getList();
boolean drawLabels = rm.getDrawLabels();
currentRoi = null;
int n = list.getItemCount();
if (IJ.debugMode) IJ.log("paint: drawing " + n + " \"Show All\" ROIs");
if (labelRects == null || labelRects.length != n) labelRects = new Rectangle[n];
if (!drawLabels) showAllList = new Overlay();
else showAllList = null;
if (imp == null) return;
int currentImage = imp.getCurrentSlice();
int channel = 0, slice = 0, frame = 0;
boolean hyperstack = imp.isHyperStack();
if (hyperstack) {
channel = imp.getChannel();
slice = imp.getSlice();
frame = imp.getFrame();
}
drawNames = Prefs.useNamesAsLabels;
for (int i = 0; i < n; i++) {
String label = list.getItem(i);
Roi roi = (Roi) rois.get(label);
if (roi == null) continue;
if (showAllList != null) showAllList.add(roi);
if (i < 200 && drawLabels && roi == imp.getRoi()) currentRoi = roi;
if (Prefs.showAllSliceOnly && imp.getStackSize() > 1) {
if (hyperstack && roi.getPosition() == 0) {
int c = roi.getCPosition();
int z = roi.getZPosition();
int t = roi.getTPosition();
if ((c == 0 || c == channel) && (z == 0 || z == slice) && (t == 0 || t == frame))
drawRoi(g, roi, drawLabels ? i : -1);
} else {
int position = roi.getPosition();
if (position == 0) position = getSliceNumber(roi.getName());
if (position == 0 || position == currentImage) drawRoi(g, roi, drawLabels ? i : -1);
}
} else drawRoi(g, roi, drawLabels ? i : -1);
}
((Graphics2D) g).setStroke(Roi.onePixelWide);
drawNames = false;
}
public boolean showDialog(ImageStack stack) {
hyperstack = imp.isHyperStack();
boolean showCheckbox = false;
if (hyperstack && imp.getNSlices() > 1 && imp.getNFrames() > 1) showCheckbox = true;
else if (hyperstack && imp.getNSlices() > 1) reduceSlices = true;
int n = stack.getSize();
GenericDialog gd = new GenericDialog("Reduce Size");
gd.addNumericField("Reduction Factor:", factor, 0);
if (showCheckbox) gd.addCheckbox("Reduce in Z-Dimension", false);
gd.showDialog();
if (gd.wasCanceled()) return false;
factor = (int) gd.getNextNumber();
if (showCheckbox) reduceSlices = gd.getNextBoolean();
return true;
}
void createNewStack(ImagePlus imp, ImageProcessor ip) {
int nSlices = imp.getStackSize();
int w = imp.getWidth(), h = imp.getHeight();
ImagePlus imp2 = imp.createImagePlus();
Rectangle r = ip.getRoi();
boolean crop = r.width != imp.getWidth() || r.height != imp.getHeight();
ImageStack stack1 = imp.getStack();
ImageStack stack2 = new ImageStack(newWidth, newHeight);
ImageProcessor ip1, ip2;
int method = interpolationMethod;
if (w == 1 || h == 1) method = ImageProcessor.NONE;
for (int i = 1; i <= nSlices; i++) {
IJ.showStatus("Scale: " + i + "/" + nSlices);
ip1 = stack1.getProcessor(i);
String label = stack1.getSliceLabel(i);
if (crop) {
ip1.setRoi(r);
ip1 = ip1.crop();
}
ip1.setInterpolationMethod(method);
ip2 = ip1.resize(newWidth, newHeight, averageWhenDownsizing);
if (ip2 != null) stack2.addSlice(label, ip2);
IJ.showProgress(i, nSlices);
}
imp2.setStack(title, stack2);
Calibration cal = imp2.getCalibration();
if (cal.scaled()) {
cal.pixelWidth *= 1.0 / xscale;
cal.pixelHeight *= 1.0 / yscale;
}
IJ.showProgress(1.0);
int[] dim = imp.getDimensions();
imp2.setDimensions(dim[2], dim[3], dim[4]);
if (imp.isComposite()) {
imp2 = new CompositeImage(imp2, ((CompositeImage) imp).getMode());
((CompositeImage) imp2).copyLuts(imp);
}
if (imp.isHyperStack()) imp2.setOpenAsHyperStack(true);
if (newDepth > 0 && newDepth != oldDepth)
imp2 = (new Resizer()).zScale(imp2, newDepth, interpolationMethod);
if (imp2 != null) {
imp2.show();
imp2.changes = true;
}
}
void createNewStack(ImagePlus imp, ImageProcessor ip) {
Rectangle r = ip.getRoi();
boolean crop = r.width != imp.getWidth() || r.height != imp.getHeight();
int nSlices = imp.getStackSize();
ImageStack stack1 = imp.getStack();
ImageStack stack2 = new ImageStack(newWidth, newHeight);
ImageProcessor ip1, ip2;
boolean interp = interpolate;
if (imp.getWidth() == 1 || imp.getHeight() == 1) interp = false;
for (int i = 1; i <= nSlices; i++) {
IJ.showStatus("Scale: " + i + "/" + nSlices);
ip1 = stack1.getProcessor(i);
String label = stack1.getSliceLabel(i);
if (crop) {
ip1.setRoi(r);
ip1 = ip1.crop();
}
ip1.setInterpolate(interp);
ip2 = ip1.resize(newWidth, newHeight);
if (ip2 != null) stack2.addSlice(label, ip2);
IJ.showProgress(i, nSlices);
}
ImagePlus imp2 = imp.createImagePlus();
imp2.setStack(title, stack2);
Calibration cal = imp2.getCalibration();
if (cal.scaled()) {
cal.pixelWidth *= 1.0 / xscale;
cal.pixelHeight *= 1.0 / yscale;
}
int[] dim = imp.getDimensions();
imp2.setDimensions(dim[2], dim[3], dim[4]);
IJ.showProgress(1.0);
if (imp.isComposite()) {
imp2 = new CompositeImage(imp2, 0);
((CompositeImage) imp2).copyLuts(imp);
}
if (imp.isHyperStack()) imp2.setOpenAsHyperStack(true);
imp2.show();
imp2.changes = true;
}
void drawOverlay(Graphics g) {
if (imp != null && imp.getHideOverlay()) return;
Color labelColor = overlay.getLabelColor();
if (labelColor == null) labelColor = Color.white;
initGraphics(g, labelColor, Roi.getColor());
int n = overlay.size();
if (IJ.debugMode) IJ.log("paint: drawing " + n + " ROI display list");
int currentImage = imp != null ? imp.getCurrentSlice() : -1;
if (imp.getStackSize() == 1) currentImage = -1;
int channel = 0, slice = 0, frame = 0;
boolean hyperstack = imp.isHyperStack();
if (hyperstack) {
channel = imp.getChannel();
slice = imp.getSlice();
frame = imp.getFrame();
}
drawNames = overlay.getDrawNames();
boolean drawLabels = drawNames || overlay.getDrawLabels();
for (int i = 0; i < n; i++) {
if (overlay == null) break;
Roi roi = overlay.get(i);
if (hyperstack && roi.getPosition() == 0) {
int c = roi.getCPosition();
int z = roi.getZPosition();
int t = roi.getTPosition();
if ((c == 0 || c == channel) && (z == 0 || z == slice) && (t == 0 || t == frame))
drawRoi(g, roi, drawLabels ? i + LIST_OFFSET : -1);
} else {
int position = roi.getPosition();
if (position == 0 || position == currentImage)
drawRoi(g, roi, drawLabels ? i + LIST_OFFSET : -1);
}
}
((Graphics2D) g).setStroke(Roi.onePixelWide);
drawNames = false;
}
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 textValueChanged(TextEvent e) {
Object source = e.getSource();
double newXScale = xscale;
double newYScale = yscale;
double newZScale = zscale;
if (source == xField && fieldWithFocus == xField) {
String newXText = xField.getText();
newXScale = Tools.parseDouble(newXText, 0);
if (newXScale == 0) return;
if (newXScale != xscale) {
int newWidth = (int) (newXScale * r.width);
widthField.setText("" + newWidth);
if (constainAspectRatio) {
yField.setText(newXText);
int newHeight = (int) (newXScale * r.height);
heightField.setText("" + newHeight);
}
}
} else if (source == yField && fieldWithFocus == yField) {
String newYText = yField.getText();
newYScale = Tools.parseDouble(newYText, 0);
if (newYScale == 0) return;
if (newYScale != yscale) {
int newHeight = (int) (newYScale * r.height);
heightField.setText("" + newHeight);
}
} else if (source == zField && fieldWithFocus == zField) {
String newZText = zField.getText();
newZScale = Tools.parseDouble(newZText, 0);
if (newZScale == 0) return;
if (newZScale != zscale) {
int nSlices = imp.getStackSize();
if (imp.isHyperStack()) {
int slices = imp.getNSlices();
int frames = imp.getNFrames();
if (slices == 1 && frames > 1) nSlices = frames;
else nSlices = slices;
}
int newDepth = (int) (newZScale * nSlices);
depthField.setText("" + newDepth);
}
} else if (source == widthField && fieldWithFocus == widthField) {
int newWidth = (int) Tools.parseDouble(widthField.getText(), 0.0);
if (newWidth != 0) {
int newHeight = (int) (newWidth * (double) r.height / r.width);
heightField.setText("" + newHeight);
xField.setText("-");
yField.setText("-");
newXScale = 0.0;
newYScale = 0.0;
}
} else if (source == depthField && fieldWithFocus == depthField) {
int newDepth = (int) Tools.parseDouble(depthField.getText(), 0.0);
if (newDepth != 0) {
zField.setText("-");
newZScale = 0.0;
}
}
xscale = newXScale;
yscale = newYScale;
zscale = newZScale;
}
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;
}
public void run(String arg) {
imp = IJ.getImage();
int stackSize = imp.getStackSize();
if (imp == null) {
IJ.noImage();
return;
}
// Make sure input image is a stack.
if (stackSize == 1) {
IJ.error("Z Project", "Stack required");
return;
}
// Check for inverting LUT.
if (imp.getProcessor().isInvertedLut()) {
if (!IJ.showMessageWithCancel("ZProjection", lutMessage)) return;
}
// Set default bounds.
int channels = imp.getNChannels();
int frames = imp.getNFrames();
int slices = imp.getNSlices();
isHyperstack =
imp.isHyperStack()
|| (ij.macro.Interpreter.isBatchMode()
&& ((frames > 1 && frames < stackSize) || (slices > 1 && slices < stackSize)));
boolean simpleComposite = channels == stackSize;
if (simpleComposite) isHyperstack = false;
startSlice = 1;
if (isHyperstack) {
int nSlices = imp.getNSlices();
if (nSlices > 1) stopSlice = nSlices;
else stopSlice = imp.getNFrames();
} else stopSlice = stackSize;
// Build control dialog
GenericDialog gd = buildControlDialog(startSlice, stopSlice);
gd.showDialog();
if (gd.wasCanceled()) return;
if (!imp.lock()) return; // exit if in use
long tstart = System.currentTimeMillis();
setStartSlice((int) gd.getNextNumber());
setStopSlice((int) gd.getNextNumber());
method = gd.getNextChoiceIndex();
Prefs.set(METHOD_KEY, method);
if (isHyperstack) {
allTimeFrames = imp.getNFrames() > 1 && imp.getNSlices() > 1 ? gd.getNextBoolean() : false;
doHyperStackProjection(allTimeFrames);
} else if (imp.getType() == ImagePlus.COLOR_RGB) doRGBProjection(true);
else doProjection(true);
if (arg.equals("") && projImage != null) {
long tstop = System.currentTimeMillis();
projImage.setCalibration(imp.getCalibration());
if (simpleComposite) IJ.run(projImage, "Grays", "");
projImage.show("ZProjector: " + IJ.d2s((tstop - tstart) / 1000.0, 2) + " seconds");
}
imp.unlock();
IJ.register(ZProjector.class);
return;
}