/*------------------------------------------------------------------*/
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 */
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 */
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 */
