boolean showDialog(ImageProcessor ip) {
int bitDepth = imp.getBitDepth();
boolean isStack = imp.getStackSize() > 1;
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);
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 (0.05-25):", xstr);
gd.addStringField("Y Scale (0.05-25):", ystr);
gd.setInsets(5, 0, 5);
gd.addStringField("Width (pixels):", "" + width);
gd.addStringField("Height (pixels):", "" + height);
fields = gd.getStringFields();
for (int i = 0; i < 3; i++) {
((TextField) fields.elementAt(i)).addTextListener(this);
((TextField) fields.elementAt(i)).addFocusListener(this);
}
xField = (TextField) fields.elementAt(0);
yField = (TextField) fields.elementAt(1);
widthField = (TextField) fields.elementAt(2);
heightField = (TextField) fields.elementAt(3);
fieldWithFocus = xField;
gd.addCheckbox("Interpolate", interpolate);
if (bitDepth == 8 || bitDepth == 24)
gd.addCheckbox("Fill with Background Color", fillWithBackground);
if (isStack) 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);
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("Invalid width or height entered");
return false;
}
if (xscale > 25.0) xscale = 25.0;
if (yscale > 25.0) yscale = 25.0;
if (xscale > 0.0 && yscale > 0.0) {
newWidth = (int) (r.width * xscale);
newHeight = (int) (r.height * yscale);
}
interpolate = gd.getNextBoolean();
if (bitDepth == 8 || bitDepth == 24) fillWithBackground = gd.getNextBoolean();
if (isStack) processStack = gd.getNextBoolean();
newWindow = gd.getNextBoolean();
if (!newWindow && 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 {
if (bitDepth == 8) bgValue = ip.isInvertedLut() ? 0.0 : 255.0; // white
else if (bitDepth == 24) bgValue = 0xffffffff; // white
}
return true;
}
public void run(ImageProcessor ip) {
String[] imageNames = getOpenImageNames();
if (imageNames[0] == "None") {
IJ.error("need at least 2 binary open images");
return;
}
double previousMinOverlap = Prefs.get("BVTB.BinaryFeatureExtractor.minOverlap", 0);
boolean previousCombine = Prefs.get("BVTB.BinaryFeatureExtractor.combine", false);
GenericDialog gd = new GenericDialog("Binary Feature Extractor");
gd.addChoice("Objects image", imageNames, imageNames[0]);
gd.addChoice("Selector image", imageNames, imageNames[1]);
gd.addNumericField("Object_overlap in % (0=off)", previousMinOverlap, 0, 9, "");
gd.addCheckbox("Combine objects and selectors", previousCombine);
gd.addCheckbox("Count output", true);
gd.addCheckbox("Analysis tables", false);
gd.showDialog();
if (gd.wasCanceled()) {
return;
}
String objectsImgTitle = gd.getNextChoice();
String selectorsImgTitle = gd.getNextChoice();
double minOverlap = gd.getNextNumber();
boolean combineImages = gd.getNextBoolean();
boolean showCountOutput = gd.getNextBoolean();
boolean showAnalysis = gd.getNextBoolean();
if (gd.invalidNumber() || minOverlap < 0 || minOverlap > 100) {
IJ.error("invalid number");
return;
}
Prefs.set("BVTB.BinaryFeatureExtractor.minOverlap", minOverlap);
Prefs.set("BVTB.BinaryFeatureExtractor.combine", combineImages);
if (objectsImgTitle.equals(selectorsImgTitle)) {
IJ.error("images need to be different");
return;
}
ImagePlus objectsImp = WindowManager.getImage(objectsImgTitle);
ImageProcessor objectsIP = objectsImp.getProcessor();
ImagePlus selectorsImp = WindowManager.getImage(selectorsImgTitle);
ImageProcessor selectorsIP = selectorsImp.getProcessor();
if (!objectsIP.isBinary() || !selectorsIP.isBinary()) {
IJ.error("works with 8-bit binary images only");
return;
}
if ((objectsImp.getWidth() != selectorsImp.getWidth())
|| objectsImp.getHeight() != selectorsImp.getHeight()) {
IJ.error("images need to be of the same size");
return;
}
// close any existing RoiManager before instantiating a new one for this analysis
RoiManager oldRM = RoiManager.getInstance2();
if (oldRM != null) {
oldRM.close();
}
RoiManager objectsRM = new RoiManager(true);
ResultsTable objectsRT = new ResultsTable();
ParticleAnalyzer analyzeObjects =
new ParticleAnalyzer(analyzerOptions, measurementFlags, objectsRT, 0.0, 999999999.9);
analyzeObjects.setRoiManager(objectsRM);
analyzeObjects.analyze(objectsImp);
objectsRM.runCommand("Show None");
int objectNumber = objectsRT.getCounter();
Roi[] objectRoi = objectsRM.getRoisAsArray();
ResultsTable measureSelectorsRT = new ResultsTable();
Analyzer overlapAnalyzer = new Analyzer(selectorsImp, measurementFlags, measureSelectorsRT);
ImagePlus outputImp =
IJ.createImage("output", "8-bit black", objectsImp.getWidth(), objectsImp.getHeight(), 1);
ImageProcessor outputIP = outputImp.getProcessor();
double[] measuredOverlap = new double[objectNumber];
outputIP.setValue(255.0);
for (int o = 0; o < objectNumber; o++) {
selectorsImp.killRoi();
selectorsImp.setRoi(objectRoi[o]);
overlapAnalyzer.measure();
measuredOverlap[o] = measureSelectorsRT.getValue("%Area", o);
if (minOverlap != 0.0 && measuredOverlap[o] >= minOverlap) {
outputIP.fill(objectRoi[o]);
finalCount++;
} else if (minOverlap == 0.0 && measuredOverlap[o] > 0.0) {
outputIP.fill(objectRoi[o]);
finalCount++;
}
}
// measureSelectorsRT.show("Objects");
selectorsImp.killRoi();
RoiManager selectorRM = new RoiManager(true);
ResultsTable selectorRT = new ResultsTable();
ParticleAnalyzer.setRoiManager(selectorRM);
ParticleAnalyzer analyzeSelectors =
new ParticleAnalyzer(analyzerOptions, measurementFlags, selectorRT, 0.0, 999999999.9);
analyzeSelectors.analyze(selectorsImp);
selectorRM.runCommand("Show None");
int selectorNumber = selectorRT.getCounter();
if (combineImages) {
outputImp.updateAndDraw();
Roi[] selectorRoi = selectorRM.getRoisAsArray();
ResultsTable measureObjectsRT = new ResultsTable();
Analyzer selectorAnalyzer = new Analyzer(outputImp, measurementFlags, measureObjectsRT);
double[] selectorOverlap = new double[selectorNumber];
outputIP.setValue(255.0);
for (int s = 0; s < selectorNumber; s++) {
outputImp.killRoi();
outputImp.setRoi(selectorRoi[s]);
selectorAnalyzer.measure();
selectorOverlap[s] = measureObjectsRT.getValue("%Area", s);
if (selectorOverlap[s] > 0.0d) {
outputIP.fill(selectorRoi[s]);
}
}
selectorRoi = null;
selectorAnalyzer = null;
measureObjectsRT = null;
}
// selectorRT.show("Selectors");
outputImp.killRoi();
String outputImageTitle = WindowManager.getUniqueName("Extracted_" + objectsImgTitle);
outputImp.setTitle(outputImageTitle);
outputImp.show();
outputImp.changes = true;
if (showCountOutput) {
String[] openTextWindows = WindowManager.getNonImageTitles();
boolean makeNewTable = true;
for (int w = 0; w < openTextWindows.length; w++) {
if (openTextWindows[w].equals("BFE_Results")) {
makeNewTable = false;
}
}
TextWindow existingCountTable = ResultsTable.getResultsWindow();
if (makeNewTable) {
countTable = new ResultsTable();
countTable.setPrecision(0);
countTable.setValue("Image", 0, outputImageTitle);
countTable.setValue("Objects", 0, objectNumber);
countTable.setValue("Selectors", 0, selectorNumber);
countTable.setValue("Extracted", 0, finalCount);
countTable.show("BFE_Results");
} else {
IJ.renameResults("BFE_Results", "Results");
countTable = ResultsTable.getResultsTable();
countTable.setPrecision(0);
countTable.incrementCounter();
countTable.addValue("Image", outputImageTitle);
countTable.addValue("Objects", objectNumber);
countTable.addValue("Selectors", selectorNumber);
countTable.addValue("Extracted", finalCount);
IJ.renameResults("Results", "BFE_Results");
countTable.show("BFE_Results");
}
}
if (showAnalysis) {
ResultsTable extractedRT = new ResultsTable();
ParticleAnalyzer analyzeExtracted =
new ParticleAnalyzer(
ParticleAnalyzer.CLEAR_WORKSHEET | ParticleAnalyzer.RECORD_STARTS,
measurementFlags,
extractedRT,
0.0,
999999999.9);
analyzeExtracted.analyze(outputImp);
objectsRT.show("Objects");
selectorRT.show("Selectors");
extractedRT.show("Extracted");
} else {
objectsRT = null;
selectorRT = null;
}
objectsRM = null;
measureSelectorsRT = null;
analyzeObjects = null;
overlapAnalyzer = null;
objectRoi = null;
selectorRM = null;
objectsImp.killRoi();
objectsImp.changes = false;
selectorsImp.changes = false;
}
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;
}