private ImagePlus duplicateImage(ImageProcessor iProcessor) {
int w = iProcessor.getWidth();
int h = iProcessor.getHeight();
ImagePlus iPlus = NewImage.createByteImage("Image", w, h, 1, NewImage.FILL_BLACK);
ImageProcessor imageProcessor = iPlus.getProcessor();
imageProcessor.copyBits(iProcessor, 0, 0, Blitter.COPY);
return iPlus;
}
ImageProcessor shrink(ImageProcessor ip, ImageProcessor ip2, boolean hasEdgePixels) {
if (hasEdgePixels) {
int width = ip.getWidth();
int height = ip.getHeight();
for (int y = 0; y < height; y++)
for (int x = 0; x < width; x++) ip.putPixel(x, y, ip2.getPixel(x + 1, y + 1));
}
return ip;
}
/** Constructs a Wand object from an ImageProcessor. */
public Wand(ImageProcessor ip) {
this.ip = ip;
if (ip instanceof ByteProcessor) bpixels = (byte[]) ip.getPixels();
else if (ip instanceof ColorProcessor) cpixels = (int[]) ip.getPixels();
else if (ip instanceof ShortProcessor) spixels = (short[]) ip.getPixels();
else if (ip instanceof FloatProcessor) fpixels = (float[]) ip.getPixels();
width = ip.getWidth();
height = ip.getHeight();
}
/** Adds the image in 'ip' to the end of the stack. */
public void addSlice(String sliceLabel, ImageProcessor ip) {
if (ip.getWidth() != width || ip.getHeight() != height)
throw new IllegalArgumentException("Dimensions do not match");
if (nSlices == 0) {
cm = ip.getColorModel();
min = ip.getMin();
max = ip.getMax();
}
addSlice(sliceLabel, ip.getPixels());
}
ImageProcessor expand(ImageProcessor ip, boolean hasEdgePixels) {
if (hasEdgePixels) {
ImageProcessor ip2 = ip.createProcessor(ip.getWidth() + 2, ip.getHeight() + 2);
if (foreground == 0) {
ip2.setColor(255);
ip2.fill();
}
ip2.insert(ip, 1, 1);
// new ImagePlus("ip2", ip2).show();
return ip2;
} else return ip;
}
/*------------------------------------------------------------------*/
void putRow(ImageProcessor ip, int y, double[] row) {
int rowLength = ip.getWidth();
if (rowLength != row.length) {
throw new IndexOutOfBoundsException("Incoherent array sizes");
}
y *= rowLength;
if (ip.getPixels() instanceof float[]) {
float[] floatPixels = (float[]) ip.getPixels();
for (int i = 0; (i < rowLength); i++) {
floatPixels[y++] = (float) row[i];
}
} else {
throw new IllegalArgumentException("Float image required");
}
} /* end putRow */
/*------------------------------------------------------------------*/
void putColumn(ImageProcessor ip, int x, double[] column) {
int width = ip.getWidth();
if (ip.getHeight() != column.length) {
throw new IndexOutOfBoundsException("Incoherent array sizes");
}
if (ip.getPixels() instanceof float[]) {
float[] floatPixels = (float[]) ip.getPixels();
for (int i = 0; (i < column.length); i++) {
floatPixels[x] = (float) column[i];
x += width;
}
} else {
throw new IllegalArgumentException("Float image required");
}
} /* end putColumn */
/**
* Execute the plugin functionality: duplicate and scale the given image.
*
* @return an Object[] array with the name and the scaled ImagePlus. Does NOT show the new, image;
* just returns it.
*/
public Object[] exec(
ImagePlus imp, String myMethod, int radius, double par1, double par2, boolean doIwhite) {
// 0 - Check validity of parameters
if (null == imp) return null;
ImageProcessor ip = imp.getProcessor();
int xe = ip.getWidth();
int ye = ip.getHeight();
// int [] data = (ip.getHistogram());
IJ.showStatus("Thresholding...");
long startTime = System.currentTimeMillis();
// 1 Do it
if (imp.getStackSize() == 1) {
ip.snapshot();
Undo.setup(Undo.FILTER, imp);
}
// Apply the selected algorithm
if (myMethod.equals("Bernsen")) {
Bernsen(imp, radius, par1, par2, doIwhite);
} else if (myMethod.equals("Contrast")) {
Contrast(imp, radius, par1, par2, doIwhite);
} else if (myMethod.equals("Mean")) {
Mean(imp, radius, par1, par2, doIwhite);
} else if (myMethod.equals("Median")) {
Median(imp, radius, par1, par2, doIwhite);
} else if (myMethod.equals("MidGrey")) {
MidGrey(imp, radius, par1, par2, doIwhite);
} else if (myMethod.equals("Niblack")) {
Niblack(imp, radius, par1, par2, doIwhite);
} else if (myMethod.equals("Otsu")) {
Otsu(imp, radius, par1, par2, doIwhite);
} else if (myMethod.equals("Phansalkar")) {
Phansalkar(imp, radius, par1, par2, doIwhite);
} else if (myMethod.equals("Sauvola")) {
Sauvola(imp, radius, par1, par2, doIwhite);
}
// IJ.showProgress((double)(255-i)/255);
imp.updateAndDraw();
imp.getProcessor().setThreshold(255, 255, ImageProcessor.NO_LUT_UPDATE);
// 2 - Return the threshold and the image
IJ.showStatus("\nDone " + (System.currentTimeMillis() - startTime) / 1000.0);
return new Object[] {imp};
}
public void run(String arg) {
imp = IJ.getImage();
Roi roi = imp.getRoi();
if (roi != null && !roi.isArea()) imp.killRoi(); // ignore any line selection
ImageProcessor ip = imp.getProcessor();
if (!showDialog(ip)) return;
if (ip.getWidth() > 1 && ip.getHeight() > 1) ip.setInterpolate(interpolate);
else ip.setInterpolate(false);
ip.setBackgroundValue(bgValue);
imp.startTiming();
try {
if (newWindow && imp.getStackSize() > 1 && processStack) createNewStack(imp, ip);
else scale(ip);
} catch (OutOfMemoryError o) {
IJ.outOfMemory("Scale");
}
IJ.showProgress(1.0);
}
/*------------------------------------------------------------------*/
public void getHorizontalGradient(ImageProcessor ip, double tolerance) {
if (!(ip.getPixels() instanceof float[])) {
throw new IllegalArgumentException("Float image required");
}
float[] floatPixels = (float[]) ip.getPixels();
int width = ip.getWidth();
int height = ip.getHeight();
double line[] = new double[width];
for (int y = 0; (y < height); y++) {
getRow(ip, y, line);
getSplineInterpolationCoefficients(line, tolerance);
getGradient(line);
putRow(ip, y, line);
stepProgressBar();
}
} /* end getHorizontalGradient */
/*------------------------------------------------------------------*/
public void getVerticalHessian(ImageProcessor ip, double tolerance) {
if (!(ip.getPixels() instanceof float[])) {
throw new IllegalArgumentException("Float image required");
}
float[] floatPixels = (float[]) ip.getPixels();
int width = ip.getWidth();
int height = ip.getHeight();
double line[] = new double[height];
for (int x = 0; (x < width); x++) {
getColumn(ip, x, line);
getSplineInterpolationCoefficients(line, tolerance);
getHessian(line);
putColumn(ip, x, line);
stepProgressBar();
}
} /* end getVerticalHessian */
boolean hasEdgePixels(ImageProcessor ip) {
int width = ip.getWidth();
int height = ip.getHeight();
boolean edgePixels = false;
for (int x = 0; x < width; x++) { // top edge
if (ip.getPixel(x, 0) == foreground) edgePixels = true;
}
for (int x = 0; x < width; x++) { // bottom edge
if (ip.getPixel(x, height - 1) == foreground) edgePixels = true;
}
for (int y = 0; y < height; y++) { // left edge
if (ip.getPixel(0, y) == foreground) edgePixels = true;
}
for (int y = 0; y < height; y++) { // right edge
if (ip.getPixel(width - 1, y) == foreground) edgePixels = true;
}
return edgePixels;
}
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;
}
private String addMean(int column, String line, int start) {
if (start == -1) {
line += "\tNaN";
summaryHdr += "\t" + ResultsTable.getDefaultHeading(column);
} else {
float[] c = column >= 0 ? rt.getColumn(column) : null;
if (c != null) {
ImageProcessor ip = new FloatProcessor(c.length, 1, c, null);
if (ip == null) return line;
ip.setRoi(start, 0, ip.getWidth() - start, 1);
ip = ip.crop();
ImageStatistics stats = new FloatStatistics(ip);
if (stats == null) return line;
line += n(stats.mean);
} else line += "\tNaN";
summaryHdr += "\t" + rt.getColumnHeading(column);
}
return line;
}
// Binary fill by Gabriel Landini, G.Landini at bham.ac.uk
// 21/May/2008
void fill(ImageProcessor ip, int foreground, int background) {
int width = ip.getWidth();
int height = ip.getHeight();
FloodFiller ff = new FloodFiller(ip);
ip.setColor(127);
for (int y = 0; y < height; y++) {
if (ip.getPixel(0, y) == background) ff.fill(0, y);
if (ip.getPixel(width - 1, y) == background) ff.fill(width - 1, y);
}
for (int x = 0; x < width; x++) {
if (ip.getPixel(x, 0) == background) ff.fill(x, 0);
if (ip.getPixel(x, height - 1) == background) ff.fill(x, height - 1);
}
byte[] pixels = (byte[]) ip.getPixels();
int n = width * height;
for (int i = 0; i < n; i++) {
if (pixels[i] == 127) pixels[i] = (byte) background;
else pixels[i] = (byte) foreground;
}
}
ImagePlus doMedianProjection() {
IJ.showStatus("Calculating median...");
ImageStack stack = imp.getStack();
ImageProcessor[] slices = new ImageProcessor[sliceCount];
int index = 0;
for (int slice = startSlice; slice <= stopSlice; slice += increment)
slices[index++] = stack.getProcessor(slice);
ImageProcessor ip2 = slices[0].duplicate();
ip2 = ip2.convertToFloat();
float[] values = new float[sliceCount];
int width = ip2.getWidth();
int height = ip2.getHeight();
int inc = Math.max(height / 30, 1);
for (int y = 0; y < height; y++) {
if (y % inc == 0) IJ.showProgress(y, height - 1);
for (int x = 0; x < width; x++) {
for (int i = 0; i < sliceCount; i++) values[i] = slices[i].getPixelValue(x, y);
ip2.putPixelValue(x, y, median(values));
}
}
if (imp.getBitDepth() == 8) ip2 = ip2.convertToByte(false);
IJ.showProgress(1, 1);
return new ImagePlus(makeTitle(), ip2);
}
/*------------------------------------------------------------------*/
void doIt(ImageProcessor ip) {
int width = ip.getWidth();
int height = ip.getHeight();
double hLine[] = new double[width];
double vLine[] = new double[height];
if (!(ip.getPixels() instanceof float[])) {
throw new IllegalArgumentException("Float image required");
}
switch (operation) {
case GRADIENT_MAGNITUDE:
{
ImageProcessor h = ip.duplicate();
ImageProcessor v = ip.duplicate();
float[] floatPixels = (float[]) ip.getPixels();
float[] floatPixelsH = (float[]) h.getPixels();
float[] floatPixelsV = (float[]) v.getPixels();
getHorizontalGradient(h, FLT_EPSILON);
getVerticalGradient(v, FLT_EPSILON);
for (int y = 0, k = 0; (y < height); y++) {
for (int x = 0; (x < width); x++, k++) {
floatPixels[k] =
(float)
Math.sqrt(
floatPixelsH[k] * floatPixelsH[k] + floatPixelsV[k] * floatPixelsV[k]);
}
stepProgressBar();
}
}
break;
case GRADIENT_DIRECTION:
{
ImageProcessor h = ip.duplicate();
ImageProcessor v = ip.duplicate();
float[] floatPixels = (float[]) ip.getPixels();
float[] floatPixelsH = (float[]) h.getPixels();
float[] floatPixelsV = (float[]) v.getPixels();
getHorizontalGradient(h, FLT_EPSILON);
getVerticalGradient(v, FLT_EPSILON);
for (int y = 0, k = 0; (y < height); y++) {
for (int x = 0; (x < width); x++, k++) {
floatPixels[k] = (float) Math.atan2(floatPixelsH[k], floatPixelsV[k]);
}
stepProgressBar();
}
}
break;
case LAPLACIAN:
{
ImageProcessor hh = ip.duplicate();
ImageProcessor vv = ip.duplicate();
float[] floatPixels = (float[]) ip.getPixels();
float[] floatPixelsHH = (float[]) hh.getPixels();
float[] floatPixelsVV = (float[]) vv.getPixels();
getHorizontalHessian(hh, FLT_EPSILON);
getVerticalHessian(vv, FLT_EPSILON);
for (int y = 0, k = 0; (y < height); y++) {
for (int x = 0; (x < width); x++, k++) {
floatPixels[k] = (float) (floatPixelsHH[k] + floatPixelsVV[k]);
}
stepProgressBar();
}
}
break;
case LARGEST_HESSIAN:
{
ImageProcessor hh = ip.duplicate();
ImageProcessor vv = ip.duplicate();
ImageProcessor hv = ip.duplicate();
float[] floatPixels = (float[]) ip.getPixels();
float[] floatPixelsHH = (float[]) hh.getPixels();
float[] floatPixelsVV = (float[]) vv.getPixels();
float[] floatPixelsHV = (float[]) hv.getPixels();
getHorizontalHessian(hh, FLT_EPSILON);
getVerticalHessian(vv, FLT_EPSILON);
getCrossHessian(hv, FLT_EPSILON);
for (int y = 0, k = 0; (y < height); y++) {
for (int x = 0; (x < width); x++, k++) {
floatPixels[k] =
(float)
(0.5
* (floatPixelsHH[k]
+ floatPixelsVV[k]
+ Math.sqrt(
4.0 * floatPixelsHV[k] * floatPixelsHV[k]
+ (floatPixelsHH[k] - floatPixelsVV[k])
* (floatPixelsHH[k] - floatPixelsVV[k]))));
}
stepProgressBar();
}
}
break;
case SMALLEST_HESSIAN:
{
ImageProcessor hh = ip.duplicate();
ImageProcessor vv = ip.duplicate();
ImageProcessor hv = ip.duplicate();
float[] floatPixels = (float[]) ip.getPixels();
float[] floatPixelsHH = (float[]) hh.getPixels();
float[] floatPixelsVV = (float[]) vv.getPixels();
float[] floatPixelsHV = (float[]) hv.getPixels();
getHorizontalHessian(hh, FLT_EPSILON);
getVerticalHessian(vv, FLT_EPSILON);
getCrossHessian(hv, FLT_EPSILON);
for (int y = 0, k = 0; (y < height); y++) {
for (int x = 0; (x < width); x++, k++) {
floatPixels[k] =
(float)
(0.5
* (floatPixelsHH[k]
+ floatPixelsVV[k]
- Math.sqrt(
4.0 * floatPixelsHV[k] * floatPixelsHV[k]
+ (floatPixelsHH[k] - floatPixelsVV[k])
* (floatPixelsHH[k] - floatPixelsVV[k]))));
}
stepProgressBar();
}
}
break;
case HESSIAN_ORIENTATION:
{
ImageProcessor hh = ip.duplicate();
ImageProcessor vv = ip.duplicate();
ImageProcessor hv = ip.duplicate();
float[] floatPixels = (float[]) ip.getPixels();
float[] floatPixelsHH = (float[]) hh.getPixels();
float[] floatPixelsVV = (float[]) vv.getPixels();
float[] floatPixelsHV = (float[]) hv.getPixels();
getHorizontalHessian(hh, FLT_EPSILON);
getVerticalHessian(vv, FLT_EPSILON);
getCrossHessian(hv, FLT_EPSILON);
for (int y = 0, k = 0; (y < height); y++) {
for (int x = 0; (x < width); x++, k++) {
if (floatPixelsHV[k] < 0.0) {
floatPixels[k] =
(float)
(-0.5
* Math.acos(
(floatPixelsHH[k] - floatPixelsVV[k])
/ Math.sqrt(
4.0 * floatPixelsHV[k] * floatPixelsHV[k]
+ (floatPixelsHH[k] - floatPixelsVV[k])
* (floatPixelsHH[k] - floatPixelsVV[k]))));
} else {
floatPixels[k] =
(float)
(0.5
* Math.acos(
(floatPixelsHH[k] - floatPixelsVV[k])
/ Math.sqrt(
4.0 * floatPixelsHV[k] * floatPixelsHV[k]
+ (floatPixelsHH[k] - floatPixelsVV[k])
* (floatPixelsHH[k] - floatPixelsVV[k]))));
}
}
stepProgressBar();
}
}
break;
default:
throw new IllegalArgumentException("Invalid operation");
}
ip.resetMinAndMax();
imp.updateAndDraw();
} /* end doIt */
/**
* 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;
}
private boolean isThresholdedRGB(ImagePlus imp) {
Object obj = imp.getProperty("Mask");
if (obj == null || !(obj instanceof ImageProcessor)) return false;
ImageProcessor mask = (ImageProcessor) obj;
return mask.getWidth() == imp.getWidth() && mask.getHeight() == imp.getHeight();
}
/** Ask for parameters and then execute. */
public void run(String arg) {
// 1 - Obtain the currently active image:
ImagePlus imp = IJ.getImage();
if (null == imp) {
IJ.showMessage("There must be at least one image open");
return;
}
if (imp.getBitDepth() != 8) {
IJ.showMessage("Error", "Only 8-bit images are supported");
return;
}
// 2 - Ask for parameters:
GenericDialog gd = new GenericDialog("Auto Local Threshold");
String[] methods = {
"Try all",
"Bernsen",
"Contrast",
"Mean",
"Median",
"MidGrey",
"Niblack",
"Otsu",
"Phansalkar",
"Sauvola"
};
gd.addMessage("Auto Local Threshold v1.5");
gd.addChoice("Method", methods, methods[0]);
gd.addNumericField("Radius", 15, 0);
gd.addMessage("Special paramters (if different from default)");
gd.addNumericField("Parameter_1", 0, 0);
gd.addNumericField("Parameter_2", 0, 0);
gd.addCheckbox("White objects on black background", true);
if (imp.getStackSize() > 1) {
gd.addCheckbox("Stack", false);
}
gd.addMessage("Thresholded result is always shown in white [255].");
gd.showDialog();
if (gd.wasCanceled()) return;
// 3 - Retrieve parameters from the dialog
String myMethod = gd.getNextChoice();
int radius = (int) gd.getNextNumber();
double par1 = (double) gd.getNextNumber();
double par2 = (double) gd.getNextNumber();
boolean doIwhite = gd.getNextBoolean();
boolean doIstack = false;
int stackSize = imp.getStackSize();
if (stackSize > 1) doIstack = gd.getNextBoolean();
// 4 - Execute!
// long start = System.currentTimeMillis();
if (myMethod.equals("Try all")) {
ImageProcessor ip = imp.getProcessor();
int xe = ip.getWidth();
int ye = ip.getHeight();
int ml = methods.length;
ImagePlus imp2, imp3;
ImageStack tstack = null, stackNew;
if (stackSize > 1 && doIstack) {
boolean doItAnyway = true;
if (stackSize > 25) {
YesNoCancelDialog d =
new YesNoCancelDialog(
IJ.getInstance(),
"Auto Local Threshold",
"You might run out of memory.\n \nDisplay "
+ stackSize
+ " slices?\n \n \'No\' will process without display and\noutput results to the log window.");
if (!d.yesPressed()) {
// doIlog=true; //will show in the log window
doItAnyway = false;
}
if (d.cancelPressed()) return;
}
for (int j = 1; j <= stackSize; j++) {
imp.setSlice(j);
ip = imp.getProcessor();
tstack = new ImageStack(xe, ye);
for (int k = 1; k < ml; k++) tstack.addSlice(methods[k], ip.duplicate());
imp2 = new ImagePlus("Auto Threshold", tstack);
imp2.updateAndDraw();
for (int k = 1; k < ml; k++) {
imp2.setSlice(k);
Object[] result = exec(imp2, methods[k], radius, par1, par2, doIwhite);
}
// if (doItAnyway){
CanvasResizer cr = new CanvasResizer();
stackNew = cr.expandStack(tstack, (xe + 2), (ye + 18), 1, 1);
imp3 = new ImagePlus("Auto Threshold", stackNew);
imp3.updateAndDraw();
MontageMaker mm = new MontageMaker();
mm.makeMontage(imp3, 3, 3, 1.0, 1, (ml - 1), 1, 0, true); // 3 columns and 3 rows
}
imp.setSlice(1);
// if (doItAnyway)
IJ.run("Images to Stack", "method=[Copy (center)] title=Montage");
return;
} else { // single image try all
tstack = new ImageStack(xe, ye);
for (int k = 1; k < ml; k++) tstack.addSlice(methods[k], ip.duplicate());
imp2 = new ImagePlus("Auto Threshold", tstack);
imp2.updateAndDraw();
for (int k = 1; k < ml; k++) {
imp2.setSlice(k);
// IJ.log("analyzing slice with "+methods[k]);
Object[] result = exec(imp2, methods[k], radius, par1, par2, doIwhite);
}
// imp2.setSlice(1);
CanvasResizer cr = new CanvasResizer();
stackNew = cr.expandStack(tstack, (xe + 2), (ye + 18), 1, 1);
imp3 = new ImagePlus("Auto Threshold", stackNew);
imp3.updateAndDraw();
MontageMaker mm = new MontageMaker();
mm.makeMontage(imp3, 3, 3, 1.0, 1, (ml - 1), 1, 0, true);
return;
}
} else { // selected a method
if (stackSize > 1 && doIstack) { // whole stack
// if (doIstackHistogram) {// one global histogram
// Object[] result = exec(imp, myMethod, noWhite, noBlack, doIwhite, doIset, doIlog,
// doIstackHistogram );
// }
// else{ // slice by slice
for (int k = 1; k <= stackSize; k++) {
imp.setSlice(k);
Object[] result = exec(imp, myMethod, radius, par1, par2, doIwhite);
}
// }
imp.setSlice(1);
} else { // just one slice
Object[] result = exec(imp, myMethod, radius, par1, par2, doIwhite);
}
// 5 - If all went well, show the image:
// not needed here as the source image is binarised
}
}