/**
* Prepare for processing; also called at the very end with argument 'final' to show any newly
* created output image.
*/
public int setup(String arg, ImagePlus imp) {
if (arg.equals("final")) {
showOutput();
return DONE;
}
this.imp = imp;
// 'arg' is processing type; default is 'EDM' (0)
if (arg.equals("watershed")) {
processType = WATERSHED;
flags += KEEP_THRESHOLD;
} else if (arg.equals("points")) processType = UEP;
else if (arg.equals("voronoi")) processType = VORONOI;
// output type
if (processType != WATERSHED) // Watershed always has output BYTE_OVERWRITE=0
outImageType = outputType; // otherwise use the static variable from setOutputType
if (outImageType != BYTE_OVERWRITE) flags |= NO_CHANGES;
// check image and prepare
if (imp != null) {
ImageProcessor ip = imp.getProcessor();
if (!ip.isBinary()) {
IJ.error("8-bit binary image (0 and 255) required.");
return DONE;
}
ip.resetRoi();
// processing routines assume background=0; image may be otherwise
boolean invertedLut = imp.isInvertedLut();
background255 =
(invertedLut && Prefs.blackBackground) || (!invertedLut && !Prefs.blackBackground);
}
return flags;
} // public int setup
boolean eraseOutsideRoi(ImageProcessor ip, Rectangle r, ImageProcessor mask) {
int width = ip.getWidth();
int height = ip.getHeight();
ip.setRoi(r);
if (excludeEdgeParticles && polygon != null) {
ImageStatistics stats = ImageStatistics.getStatistics(ip, MIN_MAX, null);
if (fillColor >= stats.min && fillColor <= stats.max) {
double replaceColor = level1 - 1.0;
if (replaceColor < 0.0 || replaceColor == fillColor) {
replaceColor = level2 + 1.0;
int maxColor = imageType == BYTE ? 255 : 65535;
if (replaceColor > maxColor || replaceColor == fillColor) {
IJ.error("Particle Analyzer", "Unable to remove edge particles");
return false;
}
}
for (int y = minY; y < maxY; y++) {
for (int x = minX; x < maxX; x++) {
int v = ip.getPixel(x, y);
if (v == fillColor) ip.putPixel(x, y, (int) replaceColor);
}
}
}
}
ip.setValue(fillColor);
if (mask != null) {
mask = mask.duplicate();
mask.invert();
ip.fill(mask);
}
ip.setRoi(0, 0, r.x, height);
ip.fill();
ip.setRoi(r.x, 0, r.width, r.y);
ip.fill();
ip.setRoi(r.x, r.y + r.height, r.width, height - (r.y + r.height));
ip.fill();
ip.setRoi(r.x + r.width, 0, width - (r.x + r.width), height);
ip.fill();
ip.resetRoi();
// IJ.log("erase: "+fillColor+" "+level1+" "+level2+" "+excludeEdgeParticles);
// (new ImagePlus("ip2", ip.duplicate())).show();
return true;
}
ImagePlus duplicateStack(ImagePlus img1) {
ImageStack stack1 = img1.getStack();
int width = stack1.getWidth();
int height = stack1.getHeight();
int n = stack1.getSize();
ImageStack stack2 = img1.createEmptyStack();
try {
for (int i = 1; i <= n; i++) {
ImageProcessor ip1 = stack1.getProcessor(i);
ip1.resetRoi();
ImageProcessor ip2 = ip1.crop();
stack2.addSlice(stack1.getSliceLabel(i), ip2);
}
} catch (OutOfMemoryError e) {
stack2.trim();
stack2 = null;
return null;
}
return new ImagePlus("Duplicate", stack2);
}
public void run(ImageProcessor ip) {
int fg = Prefs.blackBackground ? 255 : 0;
foreground = ip.isInvertedLut() ? 255 - fg : fg;
background = 255 - foreground;
ip.setSnapshotCopyMode(true);
if (arg.equals("outline")) outline(ip);
else if (arg.startsWith("fill")) fill(ip, foreground, background);
else if (arg.startsWith("skel")) {
ip.resetRoi();
skeletonize(ip);
} else if (arg.equals("erode") || arg.equals("dilate")) doIterations((ByteProcessor) ip, arg);
else if (arg.equals("open")) {
doIterations(ip, "erode");
doIterations(ip, "dilate");
} else if (arg.equals("close")) {
doIterations(ip, "dilate");
doIterations(ip, "erode");
}
ip.setSnapshotCopyMode(false);
ip.setBinaryThreshold();
}
/* Method takes roi and substract its mean value from each frame in the image*/
public static ImagePlus DarkNoiseRemoval(ImagePlus imp_in, Roi noise_roi) {
ImagePlus imp_out = imp_in.duplicate();
int size = imp_in.getImageStackSize();
ImageProcessor ip = imp_out.getProcessor();
double minThreshold = ip.getMinThreshold();
double maxThreshold = ip.getMaxThreshold();
Calibration cal = imp_in.getCalibration();
int measurements = Analyzer.getMeasurements();
int current = imp_in.getCurrentSlice();
ImageStack stack = imp_in.getStack();
for (int i = 1; i <= size; i++) {
ip = stack.getProcessor(i);
if (minThreshold != ImageProcessor.NO_THRESHOLD)
ip.setThreshold(minThreshold, maxThreshold, ImageProcessor.NO_LUT_UPDATE);
ip.setRoi(noise_roi);
ImageStatistics stats = ImageStatistics.getStatistics(ip, measurements, cal);
ip.resetRoi();
ip.subtract(stats.mean);
stack.setProcessor(ip, i);
}
imp_out.setStack(stack);
return imp_out;
}
/**
* 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;
}
