void scale(ImageProcessor ip) {
if (newWindow) {
Rectangle r = ip.getRoi();
ImagePlus imp2 = imp.createImagePlus();
imp2.setProcessor(title, ip.resize(newWidth, newHeight));
Calibration cal = imp2.getCalibration();
if (cal.scaled()) {
cal.pixelWidth *= 1.0 / xscale;
cal.pixelHeight *= 1.0 / yscale;
}
imp2.show();
imp.trimProcessor();
imp2.trimProcessor();
imp2.changes = true;
} else {
if (processStack && imp.getStackSize() > 1) {
Undo.reset();
StackProcessor sp = new StackProcessor(imp.getStack(), ip);
sp.scale(xscale, yscale, bgValue);
} else {
ip.snapshot();
Undo.setup(Undo.FILTER, imp);
ip.setSnapshotCopyMode(true);
ip.scale(xscale, yscale);
ip.setSnapshotCopyMode(false);
}
imp.killRoi();
imp.updateAndDraw();
imp.changes = true;
}
}
public void refreshForeground() {
// Boundary for Foreground Selection
setColor(0x444444);
drawRect(8, 266, (w * 2) + 4, (h * 2) + 4);
setColor(0x999999);
drawRect(9, 267, (w * 2) + 2, (h * 2) + 2);
setRoi(10, 268, w * 2, h * 2); // Paints the Foreground Color
setColor(Toolbar.getForegroundColor());
fill();
imp.updateAndDraw();
}
public void refreshBackground() {
// Boundary for Background Selection
setColor(0x444444);
drawRect((w * 2) - 12, 276, (w * 2) + 4, (h * 2) + 4);
setColor(0x999999);
drawRect((w * 2) - 11, 277, (w * 2) + 2, (h * 2) + 2);
setRoi((w * 2) - 10, 278, w * 2, h * 2); // Paints the Background Color
setColor(Toolbar.getBackgroundColor());
fill();
imp.updateAndDraw();
}
public void run() {
while (!done) {
synchronized (this) {
try {
wait();
} catch (InterruptedException e) {
}
reset(imp, ip); // GL
apply(imp, ip); // GL
imp.updateAndDraw(); // GL
}
}
}
public void actionPerformed(ActionEvent e) {
Button b = (Button) e.getSource();
if (b == null) return;
boolean imageThere = checkImage();
if (imageThere) {
if (b == originalB) {
reset(imp, ip);
filteredB.setEnabled(true);
} else if (b == filteredB) {
apply(imp, ip);
} else if (b == sampleB) {
reset(imp, ip);
sample();
apply(imp, ip);
} else if (b == stackB) {
applyStack();
} else if (b == helpB) {
IJ.showMessage(
"Help",
"Threshold Colour v1.0\n \n"
+ "Modification of Bob Dougherty's BandPass2 plugin by G.Landini to\n"
+ "threshold 24 bit RGB images based on Hue, Saturation and Brightness\n"
+ "or Red, Green and Blue components.\n \n"
+ "Pass: Band-pass filter (anything within range is displayed).\n \n"
+ "Stop: Band-reject filter (anything within range is NOT displayed).\n \n"
+ "Original: Shows the original image and updates the buffer when\n"
+ " switching to another image.\n \n"
+ "Filtered: Shows the filtered image.\n \n"
+ "Stack: Processes the rest of the slices in the stack (if any)\n"
+ " using the current settings.\n \n"
+ "Threshold: Shows the object/background in the foreground and\n"
+ " background colours selected in the ImageJ toolbar.\n \n"
+ "Invert: Swaps the fore/background colours.\n \n"
+ "Sample: (experimental) Sets the ranges of the filters based on the\n"
+ " pixel value componentd in a rectangular, user-defined, ROI.\n \n"
+ "HSB RGB: Selects HSB or RGB space and resets all the filters.\n \n"
+ "Note that the \'thresholded\' image is RGB, not 8 bit grey.");
}
updatePlot();
updateLabels();
imp.updateAndDraw();
} else {
IJ.beep();
IJ.showStatus("No Image");
}
notify();
}
ImageProcessor setup(ImagePlus imp) {
ImageProcessor ip;
int type = imp.getType();
if (type != ImagePlus.COLOR_RGB) return null;
ip = imp.getProcessor();
int id = imp.getID();
int slice = imp.getCurrentSlice();
if ((id != previousImageID) | (slice != previousSlice) | (flag)) {
flag = false; // if true, flags a change from HSB to RGB or viceversa
numSlices = imp.getStackSize();
stack = imp.getStack();
width = stack.getWidth();
height = stack.getHeight();
numPixels = width * height;
hSource = new byte[numPixels];
sSource = new byte[numPixels];
bSource = new byte[numPixels];
// restore = (int[])ip.getPixelsCopy(); //This runs into trouble sometimes, so do it the
// long way:
int[] temp = (int[]) ip.getPixels();
restore = new int[numPixels];
for (int i = 0; i < numPixels; i++) restore[i] = temp[i];
fillMask = new int[numPixels];
// Get hsb or rgb from image.
ColorProcessor cp = (ColorProcessor) ip;
IJ.showStatus("Gathering data");
if (isRGB) cp.getRGB(hSource, sSource, bSource);
else cp.getHSB(hSource, sSource, bSource);
IJ.showStatus("done");
// Create a spectrum ColorModel for the Hue histogram plot.
Color c;
byte[] reds = new byte[256];
byte[] greens = new byte[256];
byte[] blues = new byte[256];
for (int i = 0; i < 256; i++) {
c = Color.getHSBColor(i / 255f, 1f, 1f);
reds[i] = (byte) c.getRed();
greens[i] = (byte) c.getGreen();
blues[i] = (byte) c.getBlue();
}
ColorModel cm = new IndexColorModel(8, 256, reds, greens, blues);
// Make an image with just the hue from the RGB image and the spectrum LUT.
// This is just for a hue histogram for the plot. Do not show it.
// ByteProcessor bpHue = new ByteProcessor(width,height,h,cm);
ByteProcessor bpHue = new ByteProcessor(width, height, hSource, cm);
ImagePlus impHue = new ImagePlus("Hue", bpHue);
// impHue.show();
ByteProcessor bpSat = new ByteProcessor(width, height, sSource, cm);
ImagePlus impSat = new ImagePlus("Sat", bpSat);
// impSat.show();
ByteProcessor bpBri = new ByteProcessor(width, height, bSource, cm);
ImagePlus impBri = new ImagePlus("Bri", bpBri);
// impBri.show();
plot.setHistogram(impHue, 0);
splot.setHistogram(impSat, 1);
bplot.setHistogram(impBri, 2);
updateLabels();
updatePlot();
updateScrollBars();
imp.updateAndDraw();
}
previousImageID = id;
previousSlice = slice;
return ip;
}
/*------------------------------------------------------------------*/
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 */