/** Performs actual projection using specified method. */
public void doProjection() {
if (imp == null) return;
sliceCount = 0;
if (method < AVG_METHOD || method > MEDIAN_METHOD) method = AVG_METHOD;
for (int slice = startSlice; slice <= stopSlice; slice += increment) sliceCount++;
if (method == MEDIAN_METHOD) {
projImage = doMedianProjection();
return;
}
// Create new float processor for projected pixels.
FloatProcessor fp = new FloatProcessor(imp.getWidth(), imp.getHeight());
ImageStack stack = imp.getStack();
RayFunction rayFunc = getRayFunction(method, fp);
if (IJ.debugMode == true) {
IJ.log("\nProjecting stack from: " + startSlice + " to: " + stopSlice);
}
// Determine type of input image. Explicit determination of
// processor type is required for subsequent pixel
// manipulation. This approach is more efficient than the
// more general use of ImageProcessor's getPixelValue and
// putPixel methods.
int ptype;
if (stack.getProcessor(1) instanceof ByteProcessor) ptype = BYTE_TYPE;
else if (stack.getProcessor(1) instanceof ShortProcessor) ptype = SHORT_TYPE;
else if (stack.getProcessor(1) instanceof FloatProcessor) ptype = FLOAT_TYPE;
else {
IJ.error("Z Project", "Non-RGB stack required");
return;
}
// Do the projection.
for (int n = startSlice; n <= stopSlice; n += increment) {
IJ.showStatus("ZProjection " + color + ": " + n + "/" + stopSlice);
IJ.showProgress(n - startSlice, stopSlice - startSlice);
projectSlice(stack.getPixels(n), rayFunc, ptype);
}
// Finish up projection.
if (method == SUM_METHOD) {
fp.resetMinAndMax();
projImage = new ImagePlus(makeTitle(), fp);
} else if (method == SD_METHOD) {
rayFunc.postProcess();
fp.resetMinAndMax();
projImage = new ImagePlus(makeTitle(), fp);
} else {
rayFunc.postProcess();
projImage = makeOutputImage(imp, fp, ptype);
}
if (projImage == null) IJ.error("Z Project", "Error computing projection.");
}
public StandardDeviation(FloatProcessor fp, int num) {
result = (float[]) fp.getPixels();
len = result.length;
this.num = num;
sum = new double[len];
sum2 = new double[len];
}
/** Generate output image whose type is same as input image. */
private ImagePlus makeOutputImage(ImagePlus imp, FloatProcessor fp, int ptype) {
int width = imp.getWidth();
int height = imp.getHeight();
float[] pixels = (float[]) fp.getPixels();
ImageProcessor oip = null;
// Create output image consistent w/ type of input image.
int size = pixels.length;
switch (ptype) {
case BYTE_TYPE:
oip = imp.getProcessor().createProcessor(width, height);
byte[] pixels8 = (byte[]) oip.getPixels();
for (int i = 0; i < size; i++) pixels8[i] = (byte) pixels[i];
break;
case SHORT_TYPE:
oip = imp.getProcessor().createProcessor(width, height);
short[] pixels16 = (short[]) oip.getPixels();
for (int i = 0; i < size; i++) pixels16[i] = (short) pixels[i];
break;
case FLOAT_TYPE:
oip = new FloatProcessor(width, height, pixels, null);
break;
}
// Adjust for display.
// Calling this on non-ByteProcessors ensures image
// processor is set up to correctly display image.
oip.resetMinAndMax();
// Create new image plus object. Don't use
// ImagePlus.createImagePlus here because there may be
// attributes of input image that are not appropriate for
// projection.
return new ImagePlus(makeTitle(), oip);
}
/** Simple constructor since no preprocessing is necessary. */
public MinIntensity(FloatProcessor fp) {
fpixels = (float[]) fp.getPixels();
len = fpixels.length;
for (int i = 0; i < len; i++) fpixels[i] = Float.MAX_VALUE;
}
/**
* Constructor requires number of slices to be projected. This is used to determine average at
* each pixel.
*/
public AverageIntensity(FloatProcessor fp, int num) {
fpixels = (float[]) fp.getPixels();
len = fpixels.length;
this.num = num;
}