public void reduceHyperstack(ImagePlus imp, int factor, boolean reduceSlices) {
int channels = imp.getNChannels();
int slices = imp.getNSlices();
int frames = imp.getNFrames();
int zfactor = reduceSlices ? factor : 1;
int tfactor = reduceSlices ? 1 : factor;
ImageStack stack = imp.getStack();
ImageStack stack2 = new ImageStack(imp.getWidth(), imp.getHeight());
boolean virtual = stack.isVirtual();
int slices2 = slices / zfactor + ((slices % zfactor) != 0 ? 1 : 0);
int frames2 = frames / tfactor + ((frames % tfactor) != 0 ? 1 : 0);
int n = channels * slices2 * frames2;
int count = 1;
for (int t = 1; t <= frames; t += tfactor) {
for (int z = 1; z <= slices; z += zfactor) {
for (int c = 1; c <= channels; c++) {
int i = imp.getStackIndex(c, z, t);
IJ.showProgress(i, n);
ImageProcessor ip = stack.getProcessor(imp.getStackIndex(c, z, t));
// IJ.log(count++ +" "+i+" "+c+" "+z+" "+t);
stack2.addSlice(stack.getSliceLabel(i), ip);
}
}
}
imp.setStack(stack2, channels, slices2, frames2);
Calibration cal = imp.getCalibration();
if (cal.scaled()) cal.pixelDepth *= zfactor;
if (virtual) imp.setTitle(imp.getTitle());
IJ.showProgress(1.0);
}
byte[] getJar(String address) {
// System.out.println("getJar: "+address);
byte[] data;
try {
URL url = new URL(address);
IJ.showStatus("Connecting to " + IJ.URL);
URLConnection uc = url.openConnection();
int len = uc.getContentLength();
if (IJ.debugMode) IJ.log("Updater (url): " + address + " " + len);
if (len <= 0) return null;
String name = address.contains("wsr") ? "daily build (" : "ij.jar (";
IJ.showStatus("Downloading " + name + IJ.d2s((double) len / 1048576, 1) + "MB)");
InputStream in = uc.getInputStream();
data = new byte[len];
int n = 0;
while (n < len) {
int count = in.read(data, n, len - n);
if (count < 0) throw new EOFException();
n += count;
IJ.showProgress(n, len);
}
in.close();
} catch (IOException e) {
if (IJ.debugMode) IJ.log("" + e);
return null;
}
if (IJ.debugMode) IJ.wait(6000);
return data;
}
/** Opens a stack of images. */
ImagePlus openStack(ColorModel cm, boolean show) {
ImageStack stack = new ImageStack(fi.width, fi.height, cm);
long skip = fi.getOffset();
Object pixels;
try {
ImageReader reader = new ImageReader(fi);
InputStream is = createInputStream(fi);
if (is == null) return null;
IJ.resetEscape();
for (int i = 1; i <= fi.nImages; i++) {
if (!silentMode) IJ.showStatus("Reading: " + i + "/" + fi.nImages);
if (IJ.escapePressed()) {
IJ.beep();
IJ.showProgress(1.0);
silentMode = false;
return null;
}
pixels = reader.readPixels(is, skip);
if (pixels == null) break;
stack.addSlice(null, pixels);
skip = fi.gapBetweenImages;
if (!silentMode) IJ.showProgress(i, fi.nImages);
}
is.close();
} catch (Exception e) {
IJ.log("" + e);
} catch (OutOfMemoryError e) {
IJ.outOfMemory(fi.fileName);
stack.trim();
}
if (!silentMode) IJ.showProgress(1.0);
if (stack.getSize() == 0) return null;
if (fi.sliceLabels != null && fi.sliceLabels.length <= stack.getSize()) {
for (int i = 0; i < fi.sliceLabels.length; i++) stack.setSliceLabel(fi.sliceLabels[i], i + 1);
}
ImagePlus imp = new ImagePlus(fi.fileName, stack);
if (fi.info != null) imp.setProperty("Info", fi.info);
if (show) imp.show();
imp.setFileInfo(fi);
setCalibration(imp);
ImageProcessor ip = imp.getProcessor();
if (ip.getMin() == ip.getMax()) // find stack min and max if first slice is blank
setStackDisplayRange(imp);
if (!silentMode) IJ.showProgress(1.0);
silentMode = false;
return imp;
}
public void reduceStack(ImagePlus imp, int factor) {
ImageStack stack = imp.getStack();
boolean virtual = stack.isVirtual();
int n = stack.getSize();
ImageStack stack2 = new ImageStack(stack.getWidth(), stack.getHeight());
for (int i = 1; i <= n; i += factor) {
if (virtual) IJ.showProgress(i, n);
stack2.addSlice(stack.getSliceLabel(i), stack.getProcessor(i));
}
imp.setStack(null, stack2);
if (virtual) {
IJ.showProgress(1.0);
imp.setTitle(imp.getTitle());
}
Calibration cal = imp.getCalibration();
if (cal.scaled()) cal.pixelDepth *= factor;
}
void createNewStack(ImagePlus imp, ImageProcessor ip) {
int nSlices = imp.getStackSize();
int w = imp.getWidth(), h = imp.getHeight();
ImagePlus imp2 = imp.createImagePlus();
Rectangle r = ip.getRoi();
boolean crop = r.width != imp.getWidth() || r.height != imp.getHeight();
ImageStack stack1 = imp.getStack();
ImageStack stack2 = new ImageStack(newWidth, newHeight);
ImageProcessor ip1, ip2;
int method = interpolationMethod;
if (w == 1 || h == 1) method = ImageProcessor.NONE;
for (int i = 1; i <= nSlices; i++) {
IJ.showStatus("Scale: " + i + "/" + nSlices);
ip1 = stack1.getProcessor(i);
String label = stack1.getSliceLabel(i);
if (crop) {
ip1.setRoi(r);
ip1 = ip1.crop();
}
ip1.setInterpolationMethod(method);
ip2 = ip1.resize(newWidth, newHeight, averageWhenDownsizing);
if (ip2 != null) stack2.addSlice(label, ip2);
IJ.showProgress(i, nSlices);
}
imp2.setStack(title, stack2);
Calibration cal = imp2.getCalibration();
if (cal.scaled()) {
cal.pixelWidth *= 1.0 / xscale;
cal.pixelHeight *= 1.0 / yscale;
}
IJ.showProgress(1.0);
int[] dim = imp.getDimensions();
imp2.setDimensions(dim[2], dim[3], dim[4]);
if (imp.isComposite()) {
imp2 = new CompositeImage(imp2, ((CompositeImage) imp).getMode());
((CompositeImage) imp2).copyLuts(imp);
}
if (imp.isHyperStack()) imp2.setOpenAsHyperStack(true);
if (newDepth > 0 && newDepth != oldDepth)
imp2 = (new Resizer()).zScale(imp2, newDepth, interpolationMethod);
if (imp2 != null) {
imp2.show();
imp2.changes = true;
}
}
public static byte[] download(String urlString, String name) {
int maxLength = 52428800; // 50MB
URL url = null;
boolean unknownLength = false;
byte[] data = null;
;
int n = 0;
try {
url = new URL(urlString);
if (IJ.debugMode) IJ.log("PluginInstaller: " + urlString + " " + url);
if (url == null) return null;
URLConnection uc = url.openConnection();
int len = uc.getContentLength();
unknownLength = len < 0;
if (unknownLength) len = maxLength;
if (name != null) IJ.showStatus("Downloading " + url.getFile());
InputStream in = uc.getInputStream();
data = new byte[len];
int lenk = len / 1024;
while (n < len) {
int count = in.read(data, n, len - n);
if (count < 0) break;
n += count;
if (name != null)
IJ.showStatus("Downloading " + name + " (" + (n / 1024) + "/" + lenk + "k)");
IJ.showProgress(n, len);
}
in.close();
} catch (Exception e) {
String msg = "" + e;
if (!msg.contains("://")) msg += "\n " + urlString;
IJ.error("Plugin Installer", msg);
return null;
} finally {
IJ.showProgress(1.0);
}
if (name != null) IJ.showStatus("");
if (unknownLength) {
byte[] data2 = data;
data = new byte[n];
for (int i = 0; i < n; i++) data[i] = data2[i];
}
return data;
}
public void run(String arg) {
int[] wList = WindowManager.getIDList();
if (wList == null) {
IJ.error("No images are open.");
return;
}
double thalf = 0.5;
boolean keep;
GenericDialog gd = new GenericDialog("Bleach correction");
gd.addNumericField("t½:", thalf, 1);
gd.addCheckbox("Keep source stack:", true);
gd.showDialog();
if (gd.wasCanceled()) return;
long start = System.currentTimeMillis();
thalf = gd.getNextNumber();
keep = gd.getNextBoolean();
if (keep) IJ.run("Duplicate...", "title='Bleach corrected' duplicate");
ImagePlus imp1 = WindowManager.getCurrentImage();
int d1 = imp1.getStackSize();
double v1, v2;
int width = imp1.getWidth();
int height = imp1.getHeight();
ImageProcessor ip1, ip2, ip3;
int slices = imp1.getStackSize();
ImageStack stack1 = imp1.getStack();
ImageStack stack2 = imp1.getStack();
int currentSlice = imp1.getCurrentSlice();
for (int n = 1; n <= slices; n++) {
ip1 = stack1.getProcessor(n);
ip3 = stack1.getProcessor(1);
ip2 = stack2.getProcessor(n);
for (int x = 0; x < width; x++) {
for (int y = 0; y < height; y++) {
v1 = ip1.getPixelValue(x, y);
v2 = ip3.getPixelValue(x, y);
// =B8/(EXP(-C$7*A8))
v1 = (v1 / Math.exp(-n * thalf));
ip2.putPixelValue(x, y, v1);
}
}
IJ.showProgress((double) n / slices);
IJ.showStatus(n + "/" + slices);
}
// stack2.show();
imp1.updateAndDraw();
}
/** 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.");
}
void createNewStack(ImagePlus imp, ImageProcessor ip) {
Rectangle r = ip.getRoi();
boolean crop = r.width != imp.getWidth() || r.height != imp.getHeight();
int nSlices = imp.getStackSize();
ImageStack stack1 = imp.getStack();
ImageStack stack2 = new ImageStack(newWidth, newHeight);
ImageProcessor ip1, ip2;
boolean interp = interpolate;
if (imp.getWidth() == 1 || imp.getHeight() == 1) interp = false;
for (int i = 1; i <= nSlices; i++) {
IJ.showStatus("Scale: " + i + "/" + nSlices);
ip1 = stack1.getProcessor(i);
String label = stack1.getSliceLabel(i);
if (crop) {
ip1.setRoi(r);
ip1 = ip1.crop();
}
ip1.setInterpolate(interp);
ip2 = ip1.resize(newWidth, newHeight);
if (ip2 != null) stack2.addSlice(label, ip2);
IJ.showProgress(i, nSlices);
}
ImagePlus imp2 = imp.createImagePlus();
imp2.setStack(title, stack2);
Calibration cal = imp2.getCalibration();
if (cal.scaled()) {
cal.pixelWidth *= 1.0 / xscale;
cal.pixelHeight *= 1.0 / yscale;
}
int[] dim = imp.getDimensions();
imp2.setDimensions(dim[2], dim[3], dim[4]);
IJ.showProgress(1.0);
if (imp.isComposite()) {
imp2 = new CompositeImage(imp2, 0);
((CompositeImage) imp2).copyLuts(imp);
}
if (imp.isHyperStack()) imp2.setOpenAsHyperStack(true);
imp2.show();
imp2.changes = true;
}
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);
}
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 doHyperStackProjection(boolean allTimeFrames) {
int start = startSlice;
int stop = stopSlice;
int firstFrame = 1;
int lastFrame = imp.getNFrames();
if (!allTimeFrames) firstFrame = lastFrame = imp.getFrame();
ImageStack stack = new ImageStack(imp.getWidth(), imp.getHeight());
int channels = imp.getNChannels();
int slices = imp.getNSlices();
if (slices == 1) {
slices = imp.getNFrames();
firstFrame = lastFrame = 1;
}
int frames = lastFrame - firstFrame + 1;
increment = channels;
boolean rgb = imp.getBitDepth() == 24;
for (int frame = firstFrame; frame <= lastFrame; frame++) {
for (int channel = 1; channel <= channels; channel++) {
startSlice = (frame - 1) * channels * slices + (start - 1) * channels + channel;
stopSlice = (frame - 1) * channels * slices + (stop - 1) * channels + channel;
if (rgb) doHSRGBProjection(imp);
else doProjection();
stack.addSlice(null, projImage.getProcessor());
}
}
projImage = new ImagePlus(makeTitle(), stack);
projImage.setDimensions(channels, 1, frames);
if (channels > 1) {
projImage = new CompositeImage(projImage, 0);
((CompositeImage) projImage).copyLuts(imp);
if (method == SUM_METHOD || method == SD_METHOD)
((CompositeImage) projImage).resetDisplayRanges();
}
if (frames > 1) projImage.setOpenAsHyperStack(true);
Overlay overlay = imp.getOverlay();
if (overlay != null) {
startSlice = start;
stopSlice = stop;
if (imp.getType() == ImagePlus.COLOR_RGB)
projImage.setOverlay(projectRGBHyperStackRois(overlay));
else projImage.setOverlay(projectHyperStackRois(overlay));
}
IJ.showProgress(1, 1);
}
public ImageStack expandStack(ImageStack stackOld, int wNew, int hNew, int xOff, int yOff) {
int nFrames = stackOld.getSize();
ImageProcessor ipOld = stackOld.getProcessor(1);
java.awt.Color colorBack = Toolbar.getBackgroundColor();
ImageStack stackNew = new ImageStack(wNew, hNew, stackOld.getColorModel());
ImageProcessor ipNew;
for (int i = 1; i <= nFrames; i++) {
IJ.showProgress((double) i / nFrames);
ipNew = ipOld.createProcessor(wNew, hNew);
if (zeroFill) ipNew.setValue(0.0);
else ipNew.setColor(colorBack);
ipNew.fill();
ipNew.insert(stackOld.getProcessor(i), xOff, yOff);
stackNew.addSlice(stackOld.getSliceLabel(i), ipNew);
}
return stackNew;
}
byte[] getJar(String address) {
byte[] data;
boolean gte133 = version().compareTo("1.33u") >= 0;
try {
URL url = new URL(address);
URLConnection uc = url.openConnection();
int len = uc.getContentLength();
String name = address.endsWith("ij/ij.jar") ? "daily build" : "ij.jar";
IJ.showStatus("Downloading ij.jar (" + IJ.d2s((double) len / 1048576, 1) + "MB)");
InputStream in = uc.getInputStream();
data = new byte[len];
int n = 0;
while (n < len) {
int count = in.read(data, n, len - n);
if (count < 0) throw new EOFException();
n += count;
if (gte133) IJ.showProgress(n, len);
}
in.close();
} catch (IOException e) {
return null;
}
return data;
}
public void build_bricks() {
ImagePlus imp;
ImagePlus orgimp;
ImageStack stack;
FileInfo finfo;
if (lvImgTitle.isEmpty()) return;
orgimp = WindowManager.getImage(lvImgTitle.get(0));
imp = orgimp;
finfo = imp.getFileInfo();
if (finfo == null) return;
int[] dims = imp.getDimensions();
int imageW = dims[0];
int imageH = dims[1];
int nCh = dims[2];
int imageD = dims[3];
int nFrame = dims[4];
int bdepth = imp.getBitDepth();
double xspc = finfo.pixelWidth;
double yspc = finfo.pixelHeight;
double zspc = finfo.pixelDepth;
double z_aspect = Math.max(xspc, yspc) / zspc;
int orgW = imageW;
int orgH = imageH;
int orgD = imageD;
double orgxspc = xspc;
double orgyspc = yspc;
double orgzspc = zspc;
lv = lvImgTitle.size();
if (filetype == "JPEG") {
for (int l = 0; l < lv; l++) {
if (WindowManager.getImage(lvImgTitle.get(l)).getBitDepth() != 8) {
IJ.error("A SOURCE IMAGE MUST BE 8BIT GLAYSCALE");
return;
}
}
}
// calculate levels
/* int baseXY = 256;
int baseZ = 256;
if (z_aspect < 0.5) baseZ = 128;
if (z_aspect > 2.0) baseXY = 128;
if (z_aspect >= 0.5 && z_aspect < 1.0) baseZ = (int)(baseZ*z_aspect);
if (z_aspect > 1.0 && z_aspect <= 2.0) baseXY = (int)(baseXY/z_aspect);
IJ.log("Z_aspect: " + z_aspect);
IJ.log("BaseXY: " + baseXY);
IJ.log("BaseZ: " + baseZ);
*/
int baseXY = 256;
int baseZ = 128;
int dbXY = Math.max(orgW, orgH) / baseXY;
if (Math.max(orgW, orgH) % baseXY > 0) dbXY *= 2;
int dbZ = orgD / baseZ;
if (orgD % baseZ > 0) dbZ *= 2;
lv = Math.max(log2(dbXY), log2(dbZ)) + 1;
int ww = orgW;
int hh = orgH;
int dd = orgD;
for (int l = 0; l < lv; l++) {
int bwnum = ww / baseXY;
if (ww % baseXY > 0) bwnum++;
int bhnum = hh / baseXY;
if (hh % baseXY > 0) bhnum++;
int bdnum = dd / baseZ;
if (dd % baseZ > 0) bdnum++;
if (bwnum % 2 == 0) bwnum++;
if (bhnum % 2 == 0) bhnum++;
if (bdnum % 2 == 0) bdnum++;
int bw = (bwnum <= 1) ? ww : ww / bwnum + 1 + (ww % bwnum > 0 ? 1 : 0);
int bh = (bhnum <= 1) ? hh : hh / bhnum + 1 + (hh % bhnum > 0 ? 1 : 0);
int bd = (bdnum <= 1) ? dd : dd / bdnum + 1 + (dd % bdnum > 0 ? 1 : 0);
bwlist.add(bw);
bhlist.add(bh);
bdlist.add(bd);
IJ.log("LEVEL: " + l);
IJ.log(" width: " + ww);
IJ.log(" hight: " + hh);
IJ.log(" depth: " + dd);
IJ.log(" bw: " + bw);
IJ.log(" bh: " + bh);
IJ.log(" bd: " + bd);
int xyl2 = Math.max(ww, hh) / baseXY;
if (Math.max(ww, hh) % baseXY > 0) xyl2 *= 2;
if (lv - 1 - log2(xyl2) <= l) {
ww /= 2;
hh /= 2;
}
IJ.log(" xyl2: " + (lv - 1 - log2(xyl2)));
int zl2 = dd / baseZ;
if (dd % baseZ > 0) zl2 *= 2;
if (lv - 1 - log2(zl2) <= l) dd /= 2;
IJ.log(" zl2: " + (lv - 1 - log2(zl2)));
if (l < lv - 1) {
lvImgTitle.add(lvImgTitle.get(0) + "_level" + (l + 1));
IJ.selectWindow(lvImgTitle.get(0));
IJ.run(
"Scale...",
"x=- y=- z=- width="
+ ww
+ " height="
+ hh
+ " depth="
+ dd
+ " interpolation=Bicubic average process create title="
+ lvImgTitle.get(l + 1));
}
}
for (int l = 0; l < lv; l++) {
IJ.log(lvImgTitle.get(l));
}
Document doc = newXMLDocument();
Element root = doc.createElement("BRK");
root.setAttribute("version", "1.0");
root.setAttribute("nLevel", String.valueOf(lv));
root.setAttribute("nChannel", String.valueOf(nCh));
root.setAttribute("nFrame", String.valueOf(nFrame));
doc.appendChild(root);
for (int l = 0; l < lv; l++) {
IJ.showProgress(0.0);
int[] dims2 = imp.getDimensions();
IJ.log(
"W: "
+ String.valueOf(dims2[0])
+ " H: "
+ String.valueOf(dims2[1])
+ " C: "
+ String.valueOf(dims2[2])
+ " D: "
+ String.valueOf(dims2[3])
+ " T: "
+ String.valueOf(dims2[4])
+ " b: "
+ String.valueOf(bdepth));
bw = bwlist.get(l).intValue();
bh = bhlist.get(l).intValue();
bd = bdlist.get(l).intValue();
boolean force_pow2 = false;
/* if(IsPowerOf2(bw) && IsPowerOf2(bh) && IsPowerOf2(bd)) force_pow2 = true;
if(force_pow2){
//force pow2
if(Pow2(bw) > bw) bw = Pow2(bw)/2;
if(Pow2(bh) > bh) bh = Pow2(bh)/2;
if(Pow2(bd) > bd) bd = Pow2(bd)/2;
}
if(bw > imageW) bw = (Pow2(imageW) == imageW) ? imageW : Pow2(imageW)/2;
if(bh > imageH) bh = (Pow2(imageH) == imageH) ? imageH : Pow2(imageH)/2;
if(bd > imageD) bd = (Pow2(imageD) == imageD) ? imageD : Pow2(imageD)/2;
*/
if (bw > imageW) bw = imageW;
if (bh > imageH) bh = imageH;
if (bd > imageD) bd = imageD;
if (bw <= 1 || bh <= 1 || bd <= 1) break;
if (filetype == "JPEG" && (bw < 8 || bh < 8)) break;
Element lvnode = doc.createElement("Level");
lvnode.setAttribute("lv", String.valueOf(l));
lvnode.setAttribute("imageW", String.valueOf(imageW));
lvnode.setAttribute("imageH", String.valueOf(imageH));
lvnode.setAttribute("imageD", String.valueOf(imageD));
lvnode.setAttribute("xspc", String.valueOf(xspc));
lvnode.setAttribute("yspc", String.valueOf(yspc));
lvnode.setAttribute("zspc", String.valueOf(zspc));
lvnode.setAttribute("bitDepth", String.valueOf(bdepth));
root.appendChild(lvnode);
Element brksnode = doc.createElement("Bricks");
brksnode.setAttribute("brick_baseW", String.valueOf(bw));
brksnode.setAttribute("brick_baseH", String.valueOf(bh));
brksnode.setAttribute("brick_baseD", String.valueOf(bd));
lvnode.appendChild(brksnode);
ArrayList<Brick> bricks = new ArrayList<Brick>();
int mw, mh, md, mw2, mh2, md2;
double tx0, ty0, tz0, tx1, ty1, tz1;
double bx0, by0, bz0, bx1, by1, bz1;
for (int k = 0; k < imageD; k += bd) {
if (k > 0) k--;
for (int j = 0; j < imageH; j += bh) {
if (j > 0) j--;
for (int i = 0; i < imageW; i += bw) {
if (i > 0) i--;
mw = Math.min(bw, imageW - i);
mh = Math.min(bh, imageH - j);
md = Math.min(bd, imageD - k);
if (force_pow2) {
mw2 = Pow2(mw);
mh2 = Pow2(mh);
md2 = Pow2(md);
} else {
mw2 = mw;
mh2 = mh;
md2 = md;
}
if (filetype == "JPEG") {
if (mw2 < 8) mw2 = 8;
if (mh2 < 8) mh2 = 8;
}
tx0 = i == 0 ? 0.0d : ((mw2 - mw + 0.5d) / mw2);
ty0 = j == 0 ? 0.0d : ((mh2 - mh + 0.5d) / mh2);
tz0 = k == 0 ? 0.0d : ((md2 - md + 0.5d) / md2);
tx1 = 1.0d - 0.5d / mw2;
if (mw < bw) tx1 = 1.0d;
if (imageW - i == bw) tx1 = 1.0d;
ty1 = 1.0d - 0.5d / mh2;
if (mh < bh) ty1 = 1.0d;
if (imageH - j == bh) ty1 = 1.0d;
tz1 = 1.0d - 0.5d / md2;
if (md < bd) tz1 = 1.0d;
if (imageD - k == bd) tz1 = 1.0d;
bx0 = i == 0 ? 0.0d : (i + 0.5d) / (double) imageW;
by0 = j == 0 ? 0.0d : (j + 0.5d) / (double) imageH;
bz0 = k == 0 ? 0.0d : (k + 0.5d) / (double) imageD;
bx1 = Math.min((i + bw - 0.5d) / (double) imageW, 1.0d);
if (imageW - i == bw) bx1 = 1.0d;
by1 = Math.min((j + bh - 0.5d) / (double) imageH, 1.0d);
if (imageH - j == bh) by1 = 1.0d;
bz1 = Math.min((k + bd - 0.5d) / (double) imageD, 1.0d);
if (imageD - k == bd) bz1 = 1.0d;
int x, y, z;
x = i - (mw2 - mw);
y = j - (mh2 - mh);
z = k - (md2 - md);
bricks.add(
new Brick(
x, y, z, mw2, mh2, md2, 0, 0, tx0, ty0, tz0, tx1, ty1, tz1, bx0, by0, bz0, bx1,
by1, bz1));
}
}
}
Element fsnode = doc.createElement("Files");
lvnode.appendChild(fsnode);
stack = imp.getStack();
int totalbricknum = nFrame * nCh * bricks.size();
int curbricknum = 0;
for (int f = 0; f < nFrame; f++) {
for (int ch = 0; ch < nCh; ch++) {
int sizelimit = bdsizelimit * 1024 * 1024;
int bytecount = 0;
int filecount = 0;
int pd_bufsize = Math.max(sizelimit, bw * bh * bd * bdepth / 8);
byte[] packed_data = new byte[pd_bufsize];
String base_dataname =
basename
+ "_Lv"
+ String.valueOf(l)
+ "_Ch"
+ String.valueOf(ch)
+ "_Fr"
+ String.valueOf(f);
String current_dataname = base_dataname + "_data" + filecount;
Brick b_first = bricks.get(0);
if (b_first.z_ != 0) IJ.log("warning");
int st_z = b_first.z_;
int ed_z = b_first.z_ + b_first.d_;
LinkedList<ImageProcessor> iplist = new LinkedList<ImageProcessor>();
for (int s = st_z; s < ed_z; s++)
iplist.add(stack.getProcessor(imp.getStackIndex(ch + 1, s + 1, f + 1)));
// ImagePlus test;
// ImageStack tsst;
// test = NewImage.createByteImage("test", imageW, imageH, imageD,
// NewImage.FILL_BLACK);
// tsst = test.getStack();
for (int i = 0; i < bricks.size(); i++) {
Brick b = bricks.get(i);
if (ed_z > b.z_ || st_z < b.z_ + b.d_) {
if (b.z_ > st_z) {
for (int s = 0; s < b.z_ - st_z; s++) iplist.pollFirst();
st_z = b.z_;
} else if (b.z_ < st_z) {
IJ.log("warning");
for (int s = st_z - 1; s > b.z_; s--)
iplist.addFirst(stack.getProcessor(imp.getStackIndex(ch + 1, s + 1, f + 1)));
st_z = b.z_;
}
if (b.z_ + b.d_ > ed_z) {
for (int s = ed_z; s < b.z_ + b.d_; s++)
iplist.add(stack.getProcessor(imp.getStackIndex(ch + 1, s + 1, f + 1)));
ed_z = b.z_ + b.d_;
} else if (b.z_ + b.d_ < ed_z) {
IJ.log("warning");
for (int s = 0; s < ed_z - (b.z_ + b.d_); s++) iplist.pollLast();
ed_z = b.z_ + b.d_;
}
} else {
IJ.log("warning");
iplist.clear();
st_z = b.z_;
ed_z = b.z_ + b.d_;
for (int s = st_z; s < ed_z; s++)
iplist.add(stack.getProcessor(imp.getStackIndex(ch + 1, s + 1, f + 1)));
}
if (iplist.size() != b.d_) {
IJ.log("Stack Error");
return;
}
// int zz = st_z;
int bsize = 0;
byte[] bdata = new byte[b.w_ * b.h_ * b.d_ * bdepth / 8];
Iterator<ImageProcessor> ipite = iplist.iterator();
while (ipite.hasNext()) {
// ImageProcessor tsip = tsst.getProcessor(zz+1);
ImageProcessor ip = ipite.next();
ip.setRoi(b.x_, b.y_, b.w_, b.h_);
if (bdepth == 8) {
byte[] data = (byte[]) ip.crop().getPixels();
System.arraycopy(data, 0, bdata, bsize, data.length);
bsize += data.length;
} else if (bdepth == 16) {
ByteBuffer buffer = ByteBuffer.allocate(b.w_ * b.h_ * bdepth / 8);
buffer.order(ByteOrder.LITTLE_ENDIAN);
short[] data = (short[]) ip.crop().getPixels();
for (short e : data) buffer.putShort(e);
System.arraycopy(buffer.array(), 0, bdata, bsize, buffer.array().length);
bsize += buffer.array().length;
} else if (bdepth == 32) {
ByteBuffer buffer = ByteBuffer.allocate(b.w_ * b.h_ * bdepth / 8);
buffer.order(ByteOrder.LITTLE_ENDIAN);
float[] data = (float[]) ip.crop().getPixels();
for (float e : data) buffer.putFloat(e);
System.arraycopy(buffer.array(), 0, bdata, bsize, buffer.array().length);
bsize += buffer.array().length;
}
}
String filename =
basename
+ "_Lv"
+ String.valueOf(l)
+ "_Ch"
+ String.valueOf(ch)
+ "_Fr"
+ String.valueOf(f)
+ "_ID"
+ String.valueOf(i);
int offset = bytecount;
int datasize = bdata.length;
if (filetype == "RAW") {
int dummy = -1;
// do nothing
}
if (filetype == "JPEG" && bdepth == 8) {
try {
DataBufferByte db = new DataBufferByte(bdata, datasize);
Raster raster = Raster.createPackedRaster(db, b.w_, b.h_ * b.d_, 8, null);
BufferedImage img =
new BufferedImage(b.w_, b.h_ * b.d_, BufferedImage.TYPE_BYTE_GRAY);
img.setData(raster);
ByteArrayOutputStream baos = new ByteArrayOutputStream();
ImageOutputStream ios = ImageIO.createImageOutputStream(baos);
String format = "jpg";
Iterator<javax.imageio.ImageWriter> iter =
ImageIO.getImageWritersByFormatName("jpeg");
javax.imageio.ImageWriter writer = iter.next();
ImageWriteParam iwp = writer.getDefaultWriteParam();
iwp.setCompressionMode(ImageWriteParam.MODE_EXPLICIT);
iwp.setCompressionQuality((float) jpeg_quality * 0.01f);
writer.setOutput(ios);
writer.write(null, new IIOImage(img, null, null), iwp);
// ImageIO.write(img, format, baos);
bdata = baos.toByteArray();
datasize = bdata.length;
} catch (IOException e) {
e.printStackTrace();
return;
}
}
if (filetype == "ZLIB") {
byte[] tmpdata = new byte[b.w_ * b.h_ * b.d_ * bdepth / 8];
Deflater compresser = new Deflater();
compresser.setInput(bdata);
compresser.setLevel(Deflater.DEFAULT_COMPRESSION);
compresser.setStrategy(Deflater.DEFAULT_STRATEGY);
compresser.finish();
datasize = compresser.deflate(tmpdata);
bdata = tmpdata;
compresser.end();
}
if (bytecount + datasize > sizelimit && bytecount > 0) {
BufferedOutputStream fis = null;
try {
File file = new File(directory + current_dataname);
fis = new BufferedOutputStream(new FileOutputStream(file));
fis.write(packed_data, 0, bytecount);
} catch (IOException e) {
e.printStackTrace();
return;
} finally {
try {
if (fis != null) fis.close();
} catch (IOException e) {
e.printStackTrace();
return;
}
}
filecount++;
current_dataname = base_dataname + "_data" + filecount;
bytecount = 0;
offset = 0;
System.arraycopy(bdata, 0, packed_data, bytecount, datasize);
bytecount += datasize;
} else {
System.arraycopy(bdata, 0, packed_data, bytecount, datasize);
bytecount += datasize;
}
Element filenode = doc.createElement("File");
filenode.setAttribute("filename", current_dataname);
filenode.setAttribute("channel", String.valueOf(ch));
filenode.setAttribute("frame", String.valueOf(f));
filenode.setAttribute("brickID", String.valueOf(i));
filenode.setAttribute("offset", String.valueOf(offset));
filenode.setAttribute("datasize", String.valueOf(datasize));
filenode.setAttribute("filetype", String.valueOf(filetype));
fsnode.appendChild(filenode);
curbricknum++;
IJ.showProgress((double) (curbricknum) / (double) (totalbricknum));
}
if (bytecount > 0) {
BufferedOutputStream fis = null;
try {
File file = new File(directory + current_dataname);
fis = new BufferedOutputStream(new FileOutputStream(file));
fis.write(packed_data, 0, bytecount);
} catch (IOException e) {
e.printStackTrace();
return;
} finally {
try {
if (fis != null) fis.close();
} catch (IOException e) {
e.printStackTrace();
return;
}
}
}
}
}
for (int i = 0; i < bricks.size(); i++) {
Brick b = bricks.get(i);
Element bricknode = doc.createElement("Brick");
bricknode.setAttribute("id", String.valueOf(i));
bricknode.setAttribute("st_x", String.valueOf(b.x_));
bricknode.setAttribute("st_y", String.valueOf(b.y_));
bricknode.setAttribute("st_z", String.valueOf(b.z_));
bricknode.setAttribute("width", String.valueOf(b.w_));
bricknode.setAttribute("height", String.valueOf(b.h_));
bricknode.setAttribute("depth", String.valueOf(b.d_));
brksnode.appendChild(bricknode);
Element tboxnode = doc.createElement("tbox");
tboxnode.setAttribute("x0", String.valueOf(b.tx0_));
tboxnode.setAttribute("y0", String.valueOf(b.ty0_));
tboxnode.setAttribute("z0", String.valueOf(b.tz0_));
tboxnode.setAttribute("x1", String.valueOf(b.tx1_));
tboxnode.setAttribute("y1", String.valueOf(b.ty1_));
tboxnode.setAttribute("z1", String.valueOf(b.tz1_));
bricknode.appendChild(tboxnode);
Element bboxnode = doc.createElement("bbox");
bboxnode.setAttribute("x0", String.valueOf(b.bx0_));
bboxnode.setAttribute("y0", String.valueOf(b.by0_));
bboxnode.setAttribute("z0", String.valueOf(b.bz0_));
bboxnode.setAttribute("x1", String.valueOf(b.bx1_));
bboxnode.setAttribute("y1", String.valueOf(b.by1_));
bboxnode.setAttribute("z1", String.valueOf(b.bz1_));
bricknode.appendChild(bboxnode);
}
if (l < lv - 1) {
imp = WindowManager.getImage(lvImgTitle.get(l + 1));
int[] newdims = imp.getDimensions();
imageW = newdims[0];
imageH = newdims[1];
imageD = newdims[3];
xspc = orgxspc * ((double) orgW / (double) imageW);
yspc = orgyspc * ((double) orgH / (double) imageH);
zspc = orgzspc * ((double) orgD / (double) imageD);
bdepth = imp.getBitDepth();
}
}
File newXMLfile = new File(directory + basename + ".vvd");
writeXML(newXMLfile, doc);
for (int l = 1; l < lv; l++) {
imp = WindowManager.getImage(lvImgTitle.get(l));
imp.changes = false;
imp.close();
}
}
/**
* 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;
}
void Otsu(ImagePlus imp, int radius, double par1, double par2, boolean doIwhite) {
// Otsu's threshold algorithm
// C++ code by Jordan Bevik <*****@*****.**>
// ported to ImageJ plugin by G.Landini. Same algorithm as in Auto_Threshold, this time on local
// circular regions
int[] data;
int w = imp.getWidth();
int h = imp.getHeight();
int position;
int radiusx2 = radius * 2;
ImageProcessor ip = imp.getProcessor();
byte[] pixels = (byte[]) ip.getPixels();
byte[] pixelsOut =
new byte
[pixels.length]; // need this to avoid changing the image data (and further histograms)
byte object;
byte backg;
if (doIwhite) {
object = (byte) 0xff;
backg = (byte) 0;
} else {
object = (byte) 0;
backg = (byte) 0xff;
}
int k, kStar; // k = the current threshold; kStar = optimal threshold
int N1, N; // N1 = # points with intensity <=k; N = total number of points
double BCV, BCVmax; // The current Between Class Variance and maximum BCV
double num, denom; // temporary bookeeping
int Sk; // The total intensity for all histogram points <=k
int S,
L =
256; // The total intensity of the image. Need to hange here if modifying for >8 bits
// images
int roiy;
Roi roi = new OvalRoi(0, 0, radiusx2, radiusx2);
// ip.setRoi(roi);
for (int y = 0; y < h; y++) {
IJ.showProgress(
(double) (y) / (h - 1)); // this method is slow, so let's show the progress bar
roiy = y - radius;
for (int x = 0; x < w; x++) {
roi.setLocation(x - radius, roiy);
ip.setRoi(roi);
// ip.setRoi(new OvalRoi(x-radius, roiy, radiusx2, radiusx2));
position = x + y * w;
data = ip.getHistogram();
// Initialize values:
S = N = 0;
for (k = 0; k < L; k++) {
S += k * data[k]; // Total histogram intensity
N += data[k]; // Total number of data points
}
Sk = 0;
N1 = data[0]; // The entry for zero intensity
BCV = 0;
BCVmax = 0;
kStar = 0;
// Look at each possible threshold value,
// calculate the between-class variance, and decide if it's a max
for (k = 1; k < L - 1; k++) { // No need to check endpoints k = 0 or k = L-1
Sk += k * data[k];
N1 += data[k];
// The float casting here is to avoid compiler warning about loss of precision and
// will prevent overflow in the case of large saturated images
denom = (double) (N1) * (N - N1); // Maximum value of denom is (N^2)/4 = approx. 3E10
if (denom != 0) {
// Float here is to avoid loss of precision when dividing
num = ((double) N1 / N) * S - Sk; // Maximum value of num = 255*N = approx 8E7
BCV = (num * num) / denom;
} else BCV = 0;
if (BCV >= BCVmax) { // Assign the best threshold found so far
BCVmax = BCV;
kStar = k;
}
}
// kStar += 1; // Use QTI convention that intensity -> 1 if intensity >= k
// (the algorithm was developed for I-> 1 if I <= k.)
// return kStar;
pixelsOut[position] = ((int) (pixels[position] & 0xff) > kStar) ? object : backg;
}
}
for (position = 0; position < w * h; position++)
pixels[position] = pixelsOut[position]; // update with thresholded pixels
}
/** add work done in the meanwhile and show progress */
private void addProgress(double deltaProgress) {
if (nPasses == 0) return;
progressDone += deltaProgress;
IJ.showProgress(progressDone / nPasses);
}