void createMaskFromThreshold(ImagePlus imp) {
ImageProcessor ip = imp.getProcessor();
if (ip.getMinThreshold() == ImageProcessor.NO_THRESHOLD) {
IJ.error("Create Mask", "Area selection or thresholded image required");
return;
}
double t1 = ip.getMinThreshold();
double t2 = ip.getMaxThreshold();
IJ.run("Duplicate...", "title=mask");
ImagePlus imp2 = WindowManager.getCurrentImage();
ImageProcessor ip2 = imp2.getProcessor();
ip2.setThreshold(t1, t2, ImageProcessor.NO_LUT_UPDATE);
IJ.run("Convert to Mask");
}
void addToRoiManager(ImagePlus imp) {
if (IJ.macroRunning() && Interpreter.isBatchModeRoiManager())
IJ.error("run(\"Add to Manager\") may not work in batch mode macros");
Frame frame = WindowManager.getFrame("ROI Manager");
if (frame == null) IJ.run("ROI Manager...");
if (imp == null) return;
Roi roi = imp.getRoi();
if (roi == null) return;
frame = WindowManager.getFrame("ROI Manager");
if (frame == null || !(frame instanceof RoiManager)) IJ.error("ROI Manager not found");
RoiManager rm = (RoiManager) frame;
boolean altDown = IJ.altKeyDown();
IJ.setKeyUp(IJ.ALL_KEYS);
if (altDown && !IJ.macroRunning()) IJ.setKeyDown(KeyEvent.VK_SHIFT);
if (roi.getState() == Roi.CONSTRUCTING) { // wait (up to 2 sec.) until ROI finished
long start = System.currentTimeMillis();
while (true) {
IJ.wait(10);
if (roi.getState() != Roi.CONSTRUCTING) break;
if ((System.currentTimeMillis() - start) > 2000) {
IJ.beep();
IJ.error("Add to Manager", "Selection is not complete");
return;
}
}
}
rm.runCommand("add");
IJ.setKeyUp(IJ.ALL_KEYS);
}
void runMacro(String arg) {
Roi roi = imp.getRoi();
if (IJ.macroRunning()) {
String options = Macro.getOptions();
if (options != null
&& (options.indexOf("grid=") != -1 || options.indexOf("interpolat") != -1)) {
IJ.run("Rotate... ", options); // run Image>Transform>Rotate
return;
}
}
if (roi == null) {
noRoi("Rotate>Selection");
return;
}
roi = (Roi) roi.clone();
if (arg.equals("rotate")) {
double d = Tools.parseDouble(angle);
if (Double.isNaN(d)) angle = "15";
String value = IJ.runMacroFile("ij.jar:RotateSelection", angle);
if (value != null) angle = value;
} else if (arg.equals("enlarge")) {
String value = IJ.runMacroFile("ij.jar:EnlargeSelection", enlarge);
if (value != null) enlarge = value;
Roi.previousRoi = roi;
}
}
private void rotate(ImagePlus imp) {
Roi roi = imp.getRoi();
if (IJ.macroRunning()) {
String options = Macro.getOptions();
if (options != null
&& (options.indexOf("grid=") != -1 || options.indexOf("interpolat") != -1)) {
IJ.run("Rotate... ", options); // run Image>Transform>Rotate
return;
}
}
(new RoiRotator()).run("");
}
void runMacro(String arg, ImagePlus imp) {
boolean rotate = arg.equals("rotate");
Roi roi = imp.getRoi();
if (rotate && IJ.macroRunning()) {
String options = Macro.getOptions();
if (options != null
&& (options.indexOf("grid=") != -1 || options.indexOf("interpolat") != -1)) {
IJ.run("Rotate... ", options); // run Image>Transform>Rotate
return;
}
}
if (roi == null) {
noRoi(rotate ? "Rotate" : "Enlarge");
return;
}
double dangle = Tools.parseDouble(angle);
if (Double.isNaN(dangle)) {
dangle = 15;
angle = "" + dangle;
}
if (rotate && (roi instanceof ImageRoi)) {
dangle = IJ.getNumber("Angle (degrees):", dangle);
((ImageRoi) roi).rotate(dangle);
imp.draw();
angle = "" + dangle;
return;
}
Undo.setup(Undo.ROI, imp);
roi = (Roi) roi.clone();
if (rotate) {
String value = IJ.runMacroFile("ij.jar:RotateSelection", angle);
Roi roi2 = imp.getRoi();
transferProperties(roi, roi2);
imp.setRoi(roi2);
if (value != null) angle = value;
} else if (arg.equals("enlarge")) (new RoiEnlarger()).run("");
}
private void makeBand(ImagePlus imp) {
Roi roi = imp.getRoi();
if (roi == null) {
noRoi("Make Band");
return;
}
if (!roi.isArea()) {
IJ.error("Make Band", "Area selection required");
return;
}
Calibration cal = imp.getCalibration();
double pixels = bandSize;
double size = pixels * cal.pixelWidth;
int decimalPlaces = 0;
if ((int) size != size) decimalPlaces = 2;
GenericDialog gd = new GenericDialog("Make Band");
gd.addNumericField("Band Size:", size, decimalPlaces, 4, cal.getUnits());
gd.showDialog();
if (gd.wasCanceled()) return;
size = gd.getNextNumber();
if (Double.isNaN(size)) {
IJ.error("Make Band", "invalid number");
return;
}
int n = (int) Math.round(size / cal.pixelWidth);
if (n > 255) {
IJ.error("Make Band", "Cannot make bands wider that 255 pixels");
return;
}
int width = imp.getWidth();
int height = imp.getHeight();
Rectangle r = roi.getBounds();
ImageProcessor ip = roi.getMask();
if (ip == null) {
ip = new ByteProcessor(r.width, r.height);
ip.invert();
}
ImageProcessor mask = new ByteProcessor(width, height);
mask.insert(ip, r.x, r.y);
ImagePlus edm = new ImagePlus("mask", mask);
boolean saveBlackBackground = Prefs.blackBackground;
Prefs.blackBackground = false;
IJ.run(edm, "Distance Map", "");
Prefs.blackBackground = saveBlackBackground;
ip = edm.getProcessor();
ip.setThreshold(0, n, ImageProcessor.NO_LUT_UPDATE);
int xx = -1, yy = -1;
for (int x = r.x; x < r.x + r.width; x++) {
for (int y = r.y; y < r.y + r.height; y++) {
if (ip.getPixel(x, y) < n) {
xx = x;
yy = y;
break;
}
}
if (xx >= 0 || yy >= 0) break;
}
int count = IJ.doWand(edm, xx, yy, 0, null);
if (count <= 0) {
IJ.error("Make Band", "Unable to make band");
return;
}
ShapeRoi roi2 = new ShapeRoi(edm.getRoi());
if (!(roi instanceof ShapeRoi)) roi = new ShapeRoi(roi);
ShapeRoi roi1 = (ShapeRoi) roi;
roi2 = roi2.not(roi1);
imp.setRoi(roi2);
bandSize = n;
}
public static void main(String args[]) {
if (System.getProperty("java.version").substring(0, 3).compareTo("1.5") < 0) {
javax.swing.JOptionPane.showMessageDialog(
null, "ImageJ " + VERSION + " requires Java 1.5 or later.");
System.exit(0);
}
boolean noGUI = false;
int mode = STANDALONE;
arguments = args;
// System.setProperty("file.encoding", "UTF-8");
int nArgs = args != null ? args.length : 0;
boolean commandLine = false;
for (int i = 0; i < nArgs; i++) {
String arg = args[i];
if (arg == null) continue;
if (args[i].startsWith("-")) {
if (args[i].startsWith("-batch")) noGUI = true;
else if (args[i].startsWith("-debug")) IJ.setDebugMode(true);
else if (args[i].startsWith("-ijpath") && i + 1 < nArgs) {
if (IJ.debugMode) IJ.log("-ijpath: " + args[i + 1]);
Prefs.setHomeDir(args[i + 1]);
commandLine = true;
args[i + 1] = null;
} else if (args[i].startsWith("-port")) {
int delta = (int) Tools.parseDouble(args[i].substring(5, args[i].length()), 0.0);
commandLine = true;
if (delta == 0) mode = EMBEDDED;
else if (delta > 0 && DEFAULT_PORT + delta < 65536) port = DEFAULT_PORT + delta;
}
}
}
// If existing ImageJ instance, pass arguments to it and quit.
boolean passArgs = mode == STANDALONE && !noGUI;
if (IJ.isMacOSX() && !commandLine) passArgs = false;
if (passArgs && isRunning(args)) return;
ImageJ ij = IJ.getInstance();
if (!noGUI && (ij == null || (ij != null && !ij.isShowing()))) {
ij = new ImageJ(null, mode);
ij.exitWhenQuitting = true;
}
int macros = 0;
for (int i = 0; i < nArgs; i++) {
String arg = args[i];
if (arg == null) continue;
if (arg.startsWith("-")) {
if ((arg.startsWith("-macro") || arg.startsWith("-batch")) && i + 1 < nArgs) {
String arg2 = i + 2 < nArgs ? args[i + 2] : null;
Prefs.commandLineMacro = true;
if (noGUI && args[i + 1].endsWith(".js")) Interpreter.batchMode = true;
IJ.runMacroFile(args[i + 1], arg2);
break;
} else if (arg.startsWith("-eval") && i + 1 < nArgs) {
String rtn = IJ.runMacro(args[i + 1]);
if (rtn != null) System.out.print(rtn);
args[i + 1] = null;
} else if (arg.startsWith("-run") && i + 1 < nArgs) {
IJ.run(args[i + 1]);
args[i + 1] = null;
}
} else if (macros == 0 && (arg.endsWith(".ijm") || arg.endsWith(".txt"))) {
IJ.runMacroFile(arg);
macros++;
} else if (arg.length() > 0 && arg.indexOf("ij.ImageJ") == -1) {
File file = new File(arg);
IJ.open(file.getAbsolutePath());
}
}
if (IJ.debugMode && IJ.getInstance() == null) new JavaProperties().run("");
if (noGUI) System.exit(0);
}
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();
}
}
/** Ask for parameters and then execute. */
public void run(String arg) {
// 1 - Obtain the currently active image:
ImagePlus imp = IJ.getImage();
if (null == imp) {
IJ.showMessage("There must be at least one image open");
return;
}
if (imp.getBitDepth() != 8) {
IJ.showMessage("Error", "Only 8-bit images are supported");
return;
}
// 2 - Ask for parameters:
GenericDialog gd = new GenericDialog("Auto Local Threshold");
String[] methods = {
"Try all",
"Bernsen",
"Contrast",
"Mean",
"Median",
"MidGrey",
"Niblack",
"Otsu",
"Phansalkar",
"Sauvola"
};
gd.addMessage("Auto Local Threshold v1.5");
gd.addChoice("Method", methods, methods[0]);
gd.addNumericField("Radius", 15, 0);
gd.addMessage("Special paramters (if different from default)");
gd.addNumericField("Parameter_1", 0, 0);
gd.addNumericField("Parameter_2", 0, 0);
gd.addCheckbox("White objects on black background", true);
if (imp.getStackSize() > 1) {
gd.addCheckbox("Stack", false);
}
gd.addMessage("Thresholded result is always shown in white [255].");
gd.showDialog();
if (gd.wasCanceled()) return;
// 3 - Retrieve parameters from the dialog
String myMethod = gd.getNextChoice();
int radius = (int) gd.getNextNumber();
double par1 = (double) gd.getNextNumber();
double par2 = (double) gd.getNextNumber();
boolean doIwhite = gd.getNextBoolean();
boolean doIstack = false;
int stackSize = imp.getStackSize();
if (stackSize > 1) doIstack = gd.getNextBoolean();
// 4 - Execute!
// long start = System.currentTimeMillis();
if (myMethod.equals("Try all")) {
ImageProcessor ip = imp.getProcessor();
int xe = ip.getWidth();
int ye = ip.getHeight();
int ml = methods.length;
ImagePlus imp2, imp3;
ImageStack tstack = null, stackNew;
if (stackSize > 1 && doIstack) {
boolean doItAnyway = true;
if (stackSize > 25) {
YesNoCancelDialog d =
new YesNoCancelDialog(
IJ.getInstance(),
"Auto Local Threshold",
"You might run out of memory.\n \nDisplay "
+ stackSize
+ " slices?\n \n \'No\' will process without display and\noutput results to the log window.");
if (!d.yesPressed()) {
// doIlog=true; //will show in the log window
doItAnyway = false;
}
if (d.cancelPressed()) return;
}
for (int j = 1; j <= stackSize; j++) {
imp.setSlice(j);
ip = imp.getProcessor();
tstack = new ImageStack(xe, ye);
for (int k = 1; k < ml; k++) tstack.addSlice(methods[k], ip.duplicate());
imp2 = new ImagePlus("Auto Threshold", tstack);
imp2.updateAndDraw();
for (int k = 1; k < ml; k++) {
imp2.setSlice(k);
Object[] result = exec(imp2, methods[k], radius, par1, par2, doIwhite);
}
// if (doItAnyway){
CanvasResizer cr = new CanvasResizer();
stackNew = cr.expandStack(tstack, (xe + 2), (ye + 18), 1, 1);
imp3 = new ImagePlus("Auto Threshold", stackNew);
imp3.updateAndDraw();
MontageMaker mm = new MontageMaker();
mm.makeMontage(imp3, 3, 3, 1.0, 1, (ml - 1), 1, 0, true); // 3 columns and 3 rows
}
imp.setSlice(1);
// if (doItAnyway)
IJ.run("Images to Stack", "method=[Copy (center)] title=Montage");
return;
} else { // single image try all
tstack = new ImageStack(xe, ye);
for (int k = 1; k < ml; k++) tstack.addSlice(methods[k], ip.duplicate());
imp2 = new ImagePlus("Auto Threshold", tstack);
imp2.updateAndDraw();
for (int k = 1; k < ml; k++) {
imp2.setSlice(k);
// IJ.log("analyzing slice with "+methods[k]);
Object[] result = exec(imp2, methods[k], radius, par1, par2, doIwhite);
}
// imp2.setSlice(1);
CanvasResizer cr = new CanvasResizer();
stackNew = cr.expandStack(tstack, (xe + 2), (ye + 18), 1, 1);
imp3 = new ImagePlus("Auto Threshold", stackNew);
imp3.updateAndDraw();
MontageMaker mm = new MontageMaker();
mm.makeMontage(imp3, 3, 3, 1.0, 1, (ml - 1), 1, 0, true);
return;
}
} else { // selected a method
if (stackSize > 1 && doIstack) { // whole stack
// if (doIstackHistogram) {// one global histogram
// Object[] result = exec(imp, myMethod, noWhite, noBlack, doIwhite, doIset, doIlog,
// doIstackHistogram );
// }
// else{ // slice by slice
for (int k = 1; k <= stackSize; k++) {
imp.setSlice(k);
Object[] result = exec(imp, myMethod, radius, par1, par2, doIwhite);
}
// }
imp.setSlice(1);
} else { // just one slice
Object[] result = exec(imp, myMethod, radius, par1, par2, doIwhite);
}
// 5 - If all went well, show the image:
// not needed here as the source image is binarised
}
}
public void run(String arg) {
imp = IJ.getImage();
int stackSize = imp.getStackSize();
if (imp == null) {
IJ.noImage();
return;
}
// Make sure input image is a stack.
if (stackSize == 1) {
IJ.error("Z Project", "Stack required");
return;
}
// Check for inverting LUT.
if (imp.getProcessor().isInvertedLut()) {
if (!IJ.showMessageWithCancel("ZProjection", lutMessage)) return;
}
// Set default bounds.
int channels = imp.getNChannels();
int frames = imp.getNFrames();
int slices = imp.getNSlices();
isHyperstack =
imp.isHyperStack()
|| (ij.macro.Interpreter.isBatchMode()
&& ((frames > 1 && frames < stackSize) || (slices > 1 && slices < stackSize)));
boolean simpleComposite = channels == stackSize;
if (simpleComposite) isHyperstack = false;
startSlice = 1;
if (isHyperstack) {
int nSlices = imp.getNSlices();
if (nSlices > 1) stopSlice = nSlices;
else stopSlice = imp.getNFrames();
} else stopSlice = stackSize;
// Build control dialog
GenericDialog gd = buildControlDialog(startSlice, stopSlice);
gd.showDialog();
if (gd.wasCanceled()) return;
if (!imp.lock()) return; // exit if in use
long tstart = System.currentTimeMillis();
setStartSlice((int) gd.getNextNumber());
setStopSlice((int) gd.getNextNumber());
method = gd.getNextChoiceIndex();
Prefs.set(METHOD_KEY, method);
if (isHyperstack) {
allTimeFrames = imp.getNFrames() > 1 && imp.getNSlices() > 1 ? gd.getNextBoolean() : false;
doHyperStackProjection(allTimeFrames);
} else if (imp.getType() == ImagePlus.COLOR_RGB) doRGBProjection(true);
else doProjection(true);
if (arg.equals("") && projImage != null) {
long tstop = System.currentTimeMillis();
projImage.setCalibration(imp.getCalibration());
if (simpleComposite) IJ.run(projImage, "Grays", "");
projImage.show("ZProjector: " + IJ.d2s((tstop - tstart) / 1000.0, 2) + " seconds");
}
imp.unlock();
IJ.register(ZProjector.class);
return;
}
