/** Refine segmentation with ADD/SUB regions of interests */
private synchronized void refine() {
if (controlPanel.status != ControlJPanel.SEGMENTATED_STATUS) return;
if (controlPanel.addJRadioButton.isSelected()) addRoi = imp.getRoi();
else subRoi = imp.getRoi();
if (null != addRoi) {
final float alpha = controlPanel.addThreshold.getValue() / 100.0f;
final Shape shape = ShapeRoiHelper.getShape(new ShapeRoi(addRoi));
final AffineTransform trans = new AffineTransform();
trans.translate(addRoi.getBounds().getX(), addRoi.getBounds().getY());
final Area area = new Area(shape);
area.transform(trans);
siox.subpixelRefine(area, SioxSegmentator.ADD_EDGE, alpha, (float[]) confMatrix.getPixels());
}
if (null != subRoi) {
final float alpha = controlPanel.subThreshold.getValue() / 100.0f;
final Shape shape = ShapeRoiHelper.getShape(new ShapeRoi(subRoi));
final AffineTransform trans = new AffineTransform();
trans.translate(subRoi.getBounds().getX(), subRoi.getBounds().getY());
final Area area = new Area(shape);
area.transform(trans);
siox.subpixelRefine(area, SioxSegmentator.SUB_EDGE, alpha, (float[]) confMatrix.getPixels());
}
updateResult();
}
void drawOutline(ImageProcessor ip, Roi roi, int count) {
if (showChoice == OVERLAY_OUTLINES || showChoice == OVERLAY_MASKS) {
if (overlay == null) {
overlay = new Overlay();
overlay.drawLabels(true);
overlay.setLabelFont(new Font("SansSerif", Font.PLAIN, fontSize));
}
Roi roi2 = (Roi) roi.clone();
roi2.setStrokeColor(Color.cyan);
if (lineWidth != 1) roi2.setStrokeWidth(lineWidth);
if (showChoice == OVERLAY_MASKS) roi2.setFillColor(Color.cyan);
overlay.add(roi2);
} else {
Rectangle r = roi.getBounds();
int nPoints = ((PolygonRoi) roi).getNCoordinates();
int[] xp = ((PolygonRoi) roi).getXCoordinates();
int[] yp = ((PolygonRoi) roi).getYCoordinates();
int x = r.x, y = r.y;
if (!inSituShow) ip.setValue(0.0);
ip.moveTo(x + xp[0], y + yp[0]);
for (int i = 1; i < nPoints; i++) ip.lineTo(x + xp[i], y + yp[i]);
ip.lineTo(x + xp[0], y + yp[0]);
if (showChoice != BARE_OUTLINES) {
String s = ResultsTable.d2s(count, 0);
ip.moveTo(r.x + r.width / 2 - ip.getStringWidth(s) / 2, r.y + r.height / 2 + fontSize / 2);
if (!inSituShow) ip.setValue(1.0);
ip.drawString(s);
}
}
}
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));
}
public int setup(String arg, ImagePlus imp) {
this.imp = imp;
if (imp != null) {
bitDepth = imp.getBitDepth();
Roi roi = imp.getRoi();
Rectangle r = roi != null ? roi.getBounds() : null;
canEnlarge =
r == null
|| (r.x == 0 && r.y == 0 && r.width == imp.getWidth() && r.height == imp.getHeight());
}
return flags;
}
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);
}
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);
}
public void run(String arg) {
imp = IJ.getImage();
if (imp == null) return;
stackSize = imp.getStackSize();
Roi roi = imp.getRoi();
Calibration cal = imp.getCalibration();
if (roi != null && roi.getBounds().equals(prevRoi) && cal.pixelWidth == prevPixelWidth)
roi = null;
if (roi != null) {
boolean rectOrOval =
roi != null && (roi.getType() == Roi.RECTANGLE || roi.getType() == Roi.OVAL);
oval = rectOrOval && (roi.getType() == Roi.OVAL); // Handle existing oval ROI
Rectangle r = roi.getBounds();
width = r.width;
height = r.height;
xRoi = r.x;
yRoi = r.y;
if (scaledUnits && cal.scaled()) {
xRoi = xRoi * cal.pixelWidth;
yRoi = yRoi * cal.pixelHeight;
width = width * cal.pixelWidth;
height = height * cal.pixelHeight;
}
if (centered) { // Make xRoi and yRoi consistent when centered mode is active
xRoi += width / 2.0;
yRoi += height / 2.0;
}
} else if (!validDialogValues()) {
width = imp.getWidth() / 2;
height = imp.getHeight() / 2;
xRoi = width / 2;
yRoi = height / 2;
}
iSlice = imp.getCurrentSlice();
showDialog();
}
/** Fill the text fields with parameters grabbed from specified ImagePlus. */
public void getFrom(ImagePlus imp) {
this.imp = imp;
if (null == imp) {
jLabelImageName.setText("No image selected.");
impValid = false;
return;
}
if (imp.getType() == ImagePlus.COLOR_RGB) {
// We do not know how to process RGB images
jLabelImageName.setText(imp.getShortTitle() + " is RGB: invalid.");
impValid = false;
return;
}
jLabelImageName.setText("Target: " + imp.getShortTitle());
jTextFieldPixelWidth.setText(String.format("%g", imp.getCalibration().pixelWidth));
jTextFieldPixelHeight.setText(String.format("%g", imp.getCalibration().pixelHeight));
jTextFieldVoxelDepth.setText(String.format("%g", imp.getCalibration().pixelDepth));
if (imp.getCalibration().frameInterval == 0) {
jTextFieldTimeInterval.setText("1");
jLabelUnits4.setText("frame");
} else {
jTextFieldTimeInterval.setText(String.format("%g", imp.getCalibration().frameInterval));
jLabelUnits4.setText(imp.getCalibration().getTimeUnit());
}
jLabelUnits1.setText(imp.getCalibration().getXUnit());
jLabelUnits2.setText(imp.getCalibration().getYUnit());
jLabelUnits3.setText(imp.getCalibration().getZUnit());
Roi roi = imp.getRoi();
if (null == roi) roi = new Roi(0, 0, imp.getWidth(), imp.getHeight());
Rectangle boundingRect = roi.getBounds();
jTextFieldXStart.setText("" + (boundingRect.x));
jTextFieldYStart.setText("" + (boundingRect.y));
jTextFieldXEnd.setText("" + (boundingRect.width + boundingRect.x - 1));
jTextFieldYEnd.setText("" + (boundingRect.height + boundingRect.y - 1));
jTextFieldZStart.setText("" + 0);
jTextFieldZEnd.setText("" + (imp.getNSlices() - 1));
jTextFieldTStart.setText("" + 0);
jTextFieldTEnd.setText("" + (imp.getNFrames() - 1));
impValid = true;
}
void enlargeCanvas() {
imp.unlock();
if (imp.getStackSize() == 1) Undo.setup(Undo.COMPOUND_FILTER, imp);
IJ.run("Select All");
IJ.run("Rotate...", "angle=" + angle);
Roi roi = imp.getRoi();
Rectangle r = roi.getBounds();
if (r.width < imp.getWidth()) r.width = imp.getWidth();
if (r.height < imp.getHeight()) r.height = imp.getHeight();
IJ.showStatus("Rotate: Enlarging...");
IJ.run(
"Canvas Size...",
"width="
+ r.width
+ " height="
+ r.height
+ " position=Center "
+ (fillWithBackground ? "" : "zero"));
IJ.showStatus("Rotating...");
}
void createMask(ImagePlus imp) {
Roi roi = imp.getRoi();
boolean useInvertingLut = Prefs.useInvertingLut;
Prefs.useInvertingLut = false;
boolean selectAll =
roi != null
&& roi.getType() == Roi.RECTANGLE
&& roi.getBounds().width == imp.getWidth()
&& roi.getBounds().height == imp.getHeight()
&& imp.isThreshold();
if (roi == null || !(roi.isArea() || roi.getType() == Roi.POINT) || selectAll) {
createMaskFromThreshold(imp);
Prefs.useInvertingLut = useInvertingLut;
return;
}
ImagePlus maskImp = null;
Frame frame = WindowManager.getFrame("Mask");
if (frame != null && (frame instanceof ImageWindow))
maskImp = ((ImageWindow) frame).getImagePlus();
if (maskImp == null) {
ImageProcessor ip = new ByteProcessor(imp.getWidth(), imp.getHeight());
if (!Prefs.blackBackground) ip.invertLut();
maskImp = new ImagePlus("Mask", ip);
maskImp.show();
}
ImageProcessor ip = maskImp.getProcessor();
ip.setRoi(roi);
ip.setValue(255);
ip.fill(ip.getMask());
Calibration cal = imp.getCalibration();
if (cal.scaled()) {
Calibration cal2 = maskImp.getCalibration();
cal2.pixelWidth = cal.pixelWidth;
cal2.pixelHeight = cal.pixelHeight;
cal2.setUnit(cal.getUnit());
}
maskImp.updateAndRepaintWindow();
Prefs.useInvertingLut = useInvertingLut;
}
void drawRoi() {
double xPxl = xRoi;
double yPxl = yRoi;
if (centered) {
xPxl -= width / 2;
yPxl -= height / 2;
}
double widthPxl = width;
double heightPxl = height;
Calibration cal = imp.getCalibration();
if (scaledUnits && cal.scaled()) {
xPxl /= cal.pixelWidth;
yPxl /= cal.pixelHeight;
widthPxl /= cal.pixelWidth;
heightPxl /= cal.pixelHeight;
prevPixelWidth = cal.pixelWidth;
}
Roi roi;
if (oval) roi = new OvalRoi(xPxl, yPxl, widthPxl, heightPxl);
else roi = new Roi(xPxl, yPxl, widthPxl, heightPxl);
imp.setRoi(roi);
prevRoi = roi.getBounds();
// prevPixelWidth = cal.pixelWidth;
}
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;
}
void drawRoiFilledParticle(ImageProcessor ip, Roi roi, ImageProcessor mask, int count) {
int grayLevel = (count < 65535) ? count : 65535;
ip.setValue((double) grayLevel);
ip.setRoi(roi.getBounds());
ip.fill(mask);
}
void drawFilledParticle(ImageProcessor ip, Roi roi, ImageProcessor mask) {
// IJ.write(roi.getBounds()+" "+mask.length);
ip.setRoi(roi.getBounds());
ip.fill(mask);
}
public void runStuff(
DimensionMap map,
TreeMap<DimensionMap, ROIPlus> maximaMap,
TreeMap<DimensionMap, String> segMap,
TreeMap<DimensionMap, String> maskMap,
TreeMap<DimensionMap, String> imageMap,
TreeMap<DimensionMap, Double> results,
Canceler canceler) {
// Get the Maxima
ROIPlus maxima = maximaMap.get(map);
// Make the mask image impMask
// ByteProcessor impMask = (ByteProcessor) (new
// ImagePlus(maskMap.get(map)).getProcessor().convertToByte(false));
// ByteProcessor impSeg = (ByteProcessor) (new
// ImagePlus(segMap.get(map)).getProcessor().convertToByte(false));
ByteProcessor impSeg = (ByteProcessor) (new ImagePlus(segMap.get(map))).getProcessor();
ByteProcessor impMask = (ByteProcessor) (new ImagePlus(maskMap.get(map))).getProcessor();
ByteBlitter blit = new ByteBlitter(impSeg);
blit.copyBits(impMask, 0, 0, Blitter.AND);
FloatProcessor impImage =
(FloatProcessor) (new ImagePlus(imageMap.get(map))).getProcessor().convertToFloat();
Wand wand = new Wand(impSeg);
Wand wand2 = new Wand(impMask);
Vector<Double> measurements;
for (IdPoint p : maxima.getPointList()) {
if (canceler.isCanceled()) {
return;
}
if (impSeg.getPixel(p.x, p.y)
== 255) // if we land on a cell that made it through thresholding
{
wand.autoOutline(p.x, p.y); // outline it
wand2.autoOutline(p.x, p.y);
boolean partOfCellClump =
!this.selectionsAreEqual(
wand,
wand2); // If the segmented and unsegmented masks do not agree on the roi, then this
// cell is part of a clump.
if (wand.npoints > 0) {
Roi roi =
new PolygonRoi(
wand.xpoints,
wand.ypoints,
wand.npoints,
Roi.POLYGON); // The roi helps for using getLength() (DON'T USE Roi.TRACED_ROI.,
// IT SCREWS UP THE Polygon OBJECTS!!!! Bug emailed to ImageJ
// folks)
Polygon poly =
new Polygon(
wand.xpoints,
wand.ypoints,
wand.npoints); // The polygon helps for using contains()
Rectangle r = roi.getBounds();
measurements = new Vector<Double>();
for (int i = r.x; i < r.x + r.width; i++) {
for (int j = r.y; j < r.y + r.height; j++) {
// innerBoundary
if (poly.contains(i, j) && impSeg.getPixelValue(i, j) == 255) {
measurements.add((double) impImage.getPixelValue(i, j));
// Logs.log("In - " + innerT, this);
}
}
}
impMask.setRoi(roi);
ImageStatistics stats =
ImageStatistics.getStatistics(
impMask,
ImageStatistics.AREA
& ImageStatistics.PERIMETER
& ImageStatistics.CIRCULARITY
& ImageStatistics.ELLIPSE,
null);
if (measurements.size() > 0) {
DimensionMap resultsMap = map.copy();
resultsMap.put("Id", "" + p.id);
resultsMap.put("Measurement", "X");
results.put(resultsMap.copy(), (double) p.x);
resultsMap.put("Measurement", "Y");
results.put(resultsMap.copy(), (double) p.y);
resultsMap.put("Measurement", "AREA");
results.put(resultsMap.copy(), stats.area);
resultsMap.put("Measurement", "PERIMETER");
results.put(resultsMap.copy(), roi.getLength());
resultsMap.put("Measurement", "CIRCULARITY");
results.put(
resultsMap.copy(), 4.0 * Math.PI * (stats.area / (Math.pow(roi.getLength(), 2))));
resultsMap.put("Measurement", "ELLIPSE MAJOR");
results.put(resultsMap.copy(), stats.major);
resultsMap.put("Measurement", "ELLIPSE MINOR");
results.put(resultsMap.copy(), stats.minor);
resultsMap.put("Measurement", "MEAN");
results.put(resultsMap.copy(), StatisticsUtility.mean(measurements));
resultsMap.put("Measurement", "MEDIAN");
results.put(resultsMap.copy(), StatisticsUtility.median(measurements));
resultsMap.put("Measurement", "SUM");
results.put(resultsMap.copy(), StatisticsUtility.sum(measurements));
resultsMap.put("Measurement", "MIN");
results.put(resultsMap.copy(), StatisticsUtility.min(measurements));
resultsMap.put("Measurement", "MAX");
results.put(resultsMap.copy(), StatisticsUtility.max(measurements));
resultsMap.put("Measurement", "STDDEV");
results.put(resultsMap.copy(), StatisticsUtility.stdDev(measurements));
resultsMap.put("Measurement", "VARIANCE");
results.put(resultsMap.copy(), StatisticsUtility.variance(measurements));
resultsMap.put("Measurement", "CLUMP");
results.put(resultsMap.copy(), (double) (partOfCellClump ? 1 : 0));
}
}
}
}
}
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);
}
}
void analyzeParticle(int x, int y, ImagePlus imp, ImageProcessor ip) {
// Wand wand = new Wand(ip);
ImageProcessor ip2 = redirectIP != null ? redirectIP : ip;
wand.autoOutline(x, y, level1, level2, wandMode);
if (wand.npoints == 0) {
IJ.log("wand error: " + x + " " + y);
return;
}
Roi roi = new PolygonRoi(wand.xpoints, wand.ypoints, wand.npoints, roiType);
Rectangle r = roi.getBounds();
if (r.width > 1 && r.height > 1) {
PolygonRoi proi = (PolygonRoi) roi;
pf.setPolygon(proi.getXCoordinates(), proi.getYCoordinates(), proi.getNCoordinates());
ip2.setMask(pf.getMask(r.width, r.height));
if (floodFill) ff.particleAnalyzerFill(x, y, level1, level2, ip2.getMask(), r);
}
ip2.setRoi(r);
ip.setValue(fillColor);
ImageStatistics stats = getStatistics(ip2, measurements, calibration);
boolean include = true;
if (excludeEdgeParticles) {
if (r.x == minX || r.y == minY || r.x + r.width == maxX || r.y + r.height == maxY)
include = false;
if (polygon != null) {
Rectangle bounds = roi.getBounds();
int x1 = bounds.x + wand.xpoints[wand.npoints - 1];
int y1 = bounds.y + wand.ypoints[wand.npoints - 1];
int x2, y2;
for (int i = 0; i < wand.npoints; i++) {
x2 = bounds.x + wand.xpoints[i];
y2 = bounds.y + wand.ypoints[i];
if (!polygon.contains(x2, y2)) {
include = false;
break;
}
if ((x1 == x2 && ip.getPixel(x1, y1 - 1) == fillColor)
|| (y1 == y2 && ip.getPixel(x1 - 1, y1) == fillColor)) {
include = false;
break;
}
x1 = x2;
y1 = y2;
}
}
}
ImageProcessor mask = ip2.getMask();
if (minCircularity > 0.0 || maxCircularity < 1.0) {
double perimeter = roi.getLength();
double circularity =
perimeter == 0.0 ? 0.0 : 4.0 * Math.PI * (stats.pixelCount / (perimeter * perimeter));
if (circularity > 1.0) circularity = 1.0;
// IJ.log(circularity+" "+perimeter+" "+stats.area);
if (circularity < minCircularity || circularity > maxCircularity) include = false;
}
if (stats.pixelCount >= minSize && stats.pixelCount <= maxSize && include) {
particleCount++;
if (roiNeedsImage) roi.setImage(imp);
stats.xstart = x;
stats.ystart = y;
saveResults(stats, roi);
if (showChoice != NOTHING) drawParticle(drawIP, roi, stats, mask);
}
if (redirectIP != null) ip.setRoi(r);
ip.fill(mask);
}
private void makeBand(ImagePlus imp) {
Roi roi = imp.getRoi();
if (roi == null) {
noRoi("Make Band");
return;
}
if (!roi.isArea()) {
IJ.error("Make Band", "Area selection required");
return;
}
Calibration cal = imp.getCalibration();
double pixels = bandSize;
double size = pixels * cal.pixelWidth;
int decimalPlaces = 0;
if ((int) size != size) decimalPlaces = 2;
GenericDialog gd = new GenericDialog("Make Band");
gd.addNumericField("Band Size:", size, decimalPlaces, 4, cal.getUnits());
gd.showDialog();
if (gd.wasCanceled()) return;
size = gd.getNextNumber();
if (Double.isNaN(size)) {
IJ.error("Make Band", "invalid number");
return;
}
int n = (int) Math.round(size / cal.pixelWidth);
if (n > 255) {
IJ.error("Make Band", "Cannot make bands wider that 255 pixels");
return;
}
int width = imp.getWidth();
int height = imp.getHeight();
Rectangle r = roi.getBounds();
ImageProcessor ip = roi.getMask();
if (ip == null) {
ip = new ByteProcessor(r.width, r.height);
ip.invert();
}
ImageProcessor mask = new ByteProcessor(width, height);
mask.insert(ip, r.x, r.y);
ImagePlus edm = new ImagePlus("mask", mask);
boolean saveBlackBackground = Prefs.blackBackground;
Prefs.blackBackground = false;
IJ.run(edm, "Distance Map", "");
Prefs.blackBackground = saveBlackBackground;
ip = edm.getProcessor();
ip.setThreshold(0, n, ImageProcessor.NO_LUT_UPDATE);
int xx = -1, yy = -1;
for (int x = r.x; x < r.x + r.width; x++) {
for (int y = r.y; y < r.y + r.height; y++) {
if (ip.getPixel(x, y) < n) {
xx = x;
yy = y;
break;
}
}
if (xx >= 0 || yy >= 0) break;
}
int count = IJ.doWand(edm, xx, yy, 0, null);
if (count <= 0) {
IJ.error("Make Band", "Unable to make band");
return;
}
ShapeRoi roi2 = new ShapeRoi(edm.getRoi());
if (!(roi instanceof ShapeRoi)) roi = new ShapeRoi(roi);
ShapeRoi roi1 = (ShapeRoi) roi;
roi2 = roi2.not(roi1);
imp.setRoi(roi2);
bandSize = n;
}
void toBoundingBox(ImagePlus imp) {
Roi roi = imp.getRoi();
Rectangle r = roi.getBounds();
imp.killRoi();
imp.setRoi(new Roi(r.x, r.y, r.width, r.height));
}
