/** Creates a new instance of IDEJRManFramebufferImpl */
public IDEJRManFramebufferImpl(String name, BufferedImage image) {
super("JRMan rendered: " + name, true, true, true, true);
this.name = name;
save.setEnabled(false);
imagePanel.setImage(image);
imagePanel.addToolbarAction(save);
if (image.getType() == BufferedImage.TYPE_INT_ARGB
|| image.getType() == BufferedImage.TYPE_INT_ARGB_PRE) {
imagePanel.setShowTransparencyPattern(true);
}
getRootPane().setDoubleBuffered(false);
getContentPane().add(imagePanel);
pack();
ImageResource images = ImageResource.getInstance();
// set the frame icon
setFrameIcon(images.getJrMan());
// add this to the IDE desktop
MainMenuEventHandlers.getInstance(null)
.getIdeInstance()
.getWorkspaceDesktop()
.addInternalFrame(this, true);
}
/**
* Converts <code>BufferedImage</code> to <code>ByteBuffer</code>.
*
* @param bi Input image
* @return
*/
public static ByteBuffer convertImageData(BufferedImage bi) {
byte[] pixelData = ((DataBufferByte) bi.getRaster().getDataBuffer()).getData();
// return ByteBuffer.wrap(pixelData);
ByteBuffer buf = ByteBuffer.allocateDirect(pixelData.length);
buf.order(ByteOrder.nativeOrder());
buf.put(pixelData);
buf.flip();
return buf;
}
private void writeToFile(File selectedFile, ImageWriterSpiFileFilter ff) {
try {
ImageOutputStream ios = ImageIO.createImageOutputStream(selectedFile);
ImageWriter iw = ff.getImageWriterSpi().createWriterInstance();
iw.setOutput(ios);
ImageWriteParam iwp = iw.getDefaultWriteParam();
if (iwp.canWriteCompressed()) {
iwp.setCompressionMode(ImageWriteParam.MODE_EXPLICIT);
// set maximum image quality
iwp.setCompressionQuality(1.f);
}
Image image = viewerPanel.getImage();
BufferedImage bufferedImage;
if (viewerPanel.getImage() instanceof BufferedImage)
bufferedImage = (BufferedImage) viewerPanel.getImage();
else {
bufferedImage =
new BufferedImage(
image.getWidth(null), image.getHeight(null), BufferedImage.TYPE_INT_RGB);
bufferedImage.createGraphics().drawImage(image, 0, 0, null);
}
iw.write(null, new IIOImage(bufferedImage, null, null), iwp);
iw.dispose();
ios.close();
} catch (IOException ioe) {
JOptionPane.showMessageDialog(
viewerPanel,
messagesBundle.getString(
"ImageViewerPanelSaveAction." + "Error_during_image_saving_message_7"),
//$NON-NLS-1$
messagesBundle.getString("ImageViewerPanelSaveAction." + "Error_dialog_title_8"),
//$NON-NLS-1$
JOptionPane.ERROR_MESSAGE);
ioe.printStackTrace();
}
}
/**
* Returns a ByteBuffer of BufferedImage data. Ensure BufferedImage is of 4BYTE_ABGR type. If
* imageFormat is set to GL_RGBA, byte stream will be converted.
*/
private ByteBuffer getByteBuffer(final BufferedImage _image) {
final DataBuffer buffer = _image.getRaster().getDataBuffer();
final int type = buffer.getDataType();
if (type == DataBuffer.TYPE_BYTE) {
final byte[] data = ((DataBufferByte) buffer).getData();
if (imageFormat == GL3.GL_RGBA) {
convertABGRtoRGBA(data);
}
return ByteBuffer.wrap(data);
}
System.out.println("Failed to determine DataBuffer type.");
return null;
}
private BufferedImage convert(BufferedImage image, int imageType) {
if (image.getType() == imageType) {
return image;
}
int w = image.getWidth();
int h = image.getHeight();
BufferedImage newImg = new BufferedImage(w, h, imageType);
ColorSpace srcSpace = image.getColorModel().getColorSpace();
ColorSpace newSpace = newImg.getColorModel().getColorSpace();
ColorConvertOp convert = new ColorConvertOp(srcSpace, newSpace, null);
convert.filter(image, newImg);
return newImg;
}
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();
}
}
/**
* Binds the BufferedImage byte-stream into video memory. BufferedImage must be in 4BYTE_ABGR.
* 4BYTE_ABGR removes endinese problems.
*/
public Texture bind(final BufferedImage _image, final InternalFormat _format) {
final GL3 gl = GLRenderer.getCanvas().getContext().getCurrentGL().getGL3();
if (gl == null) {
System.out.println("GL context doesn't exist");
return null;
}
gl.glEnable(GL.GL_TEXTURE_2D);
final int textureID = glGenTextures(gl);
gl.glBindTexture(GL3.GL_TEXTURE_2D, textureID);
gl.glTexParameteri(GL3.GL_TEXTURE_2D, GL3.GL_TEXTURE_WRAP_S, GL3.GL_REPEAT);
gl.glTexParameteri(GL3.GL_TEXTURE_2D, GL3.GL_TEXTURE_WRAP_T, GL3.GL_REPEAT);
gl.glTexParameteri(GL3.GL_TEXTURE_2D, GL3.GL_TEXTURE_MAG_FILTER, GL3.GL_LINEAR);
gl.glTexParameteri(GL3.GL_TEXTURE_2D, GL3.GL_TEXTURE_MIN_FILTER, GL3.GL_LINEAR_MIPMAP_LINEAR);
final int width = _image.getWidth();
final int height = _image.getHeight();
final int channels = _image.getSampleModel().getNumBands();
int internalFormat = GL3.GL_RGB;
if (gl.isExtensionAvailable("GL_EXT_abgr") == true) {
switch (channels) {
case 4:
imageFormat = GL2.GL_ABGR_EXT;
break;
case 3:
imageFormat = GL3.GL_BGR;
break;
case 1:
imageFormat = GL3.GL_RED;
break;
}
} else {
switch (channels) {
case 4:
imageFormat = GL3.GL_RGBA;
break;
case 3:
imageFormat = GL3.GL_RGB;
break;
case 1:
imageFormat = GL3.GL_RED;
break;
}
}
gl.glPixelStorei(GL3.GL_UNPACK_ALIGNMENT, 1);
gl.glTexImage2D(
GL3.GL_TEXTURE_2D,
0,
getGLInternalFormat(channels, _format),
width,
height,
0,
imageFormat,
GL3.GL_UNSIGNED_BYTE,
getByteBuffer(_image));
gl.glGenerateMipmap(GL3.GL_TEXTURE_2D);
gl.glBindTexture(GL.GL_TEXTURE_2D, 0); // Reset to default texture
return new Texture(new GLImage(textureID, width, height));
}
private IFD writeYCbCrImage(
ImageOutputStream out, BufferedImage image, int comp, TIFFImageWriteParam param)
throws IOException {
image = convert(image, BufferedImage.TYPE_INT_RGB);
try {
int width = image.getWidth();
int height = image.getHeight();
IFD ifd = new IFD(); // entries need to be in tag order !
int ss = (param == null) ? 0x22 : param.getSubSampling();
int ssh = (ss >> 4) & 0x0F;
int ssv = ss & 0x0F;
if (ssh
< ssv) { // YCbCrSubsampleVert shall always be less than or equal to YCbCrSubsampleHoriz.
throw new IOException(
"Internal error: YCbCrSubsampleVert is not less than YCbCrSubsampleHoriz.");
}
// int ww=((width +ssh-1)/ssh)*ssh; // [1] p.92
// int hh=((height+ssv-1)/ssv)*ssv;
int ww = width;
int hh = height;
ifd.add(new DEFactory.NewSubfileTypeDE(2)); // 254 single page of multipage file
ifd.add(new DEFactory.ImageWidthDE(ww)); // 256
ifd.add(new DEFactory.ImageLengthDE(hh)); // 257
DEFactory.BitsPerSampleDE bpss = new DEFactory.BitsPerSampleDE(3);
bpss.setBitsPerSample(0, 8); // Y
bpss.setBitsPerSample(1, 8); // Cb
bpss.setBitsPerSample(2, 8); // Cr
ifd.add(bpss); // 258
ifd.add(new DEFactory.CompressionDE(comp)); // 259
ifd.add(new DEFactory.PhotometricInterpretationDE(YCbCr)); // 262
int maxrps, maxstripes; // max RowsPerStrip
if ((1 << 13) <= width) {
maxrps = 1;
maxstripes = height; // one row per strip
} else {
maxrps = (1 << 13) / width;
maxstripes = (height + maxrps - 1) / maxrps;
}
if (comp == JPEG) {
maxrps = ((maxrps + 8 * ssv - 1) / (8 * ssv)) * (8 * ssv);
maxstripes = (height + maxrps - 1) / maxrps;
}
DEFactory.StripOffsetsDE offsets = new DEFactory.StripOffsetsDE(maxstripes);
ifd.add(offsets); // 273
ifd.add(new DEFactory.SamplesPerPixelDE(3)); // 277
ifd.add(new DEFactory.RowsPerStripDE(maxrps)); // 278
DEFactory.StripByteCountsDE counts = new DEFactory.StripByteCountsDE(maxstripes);
ifd.add(counts); // 279
if (param == null) {
ifd.add(new DEFactory.XResolutionDE(72.0)); // 282
ifd.add(new DEFactory.YResolutionDE(72.0)); // 283
} else {
ifd.add(new DEFactory.XResolutionDE(param.getXResolution())); // 282
ifd.add(new DEFactory.YResolutionDE(param.getYResolution())); // 283
}
ifd.add(new DEFactory.ResolutionUnitDE(Inch)); // 296
ByteArrayOutputStream baos = new ByteArrayOutputStream();
OutputStream os = baos;
JPEGOutputStream jpegos = null;
if (comp == JPEG) {
jpegos = new JPEGOutputStream(baos);
int quality = (param == null) ? 50 : (int) (param.getCompressionQuality() * 100);
jpegos.setZZQuantizationTable(0, JPEGConstants.LQT, quality);
jpegos.setZZQuantizationTable(1, JPEGConstants.CQT, quality);
jpegos.setRawDCHuffmanTable(0, JPEGConstants.HLDCTable);
jpegos.setRawACHuffmanTable(0, JPEGConstants.HLACTable);
jpegos.setRawDCHuffmanTable(1, JPEGConstants.HCDCTable);
jpegos.setRawACHuffmanTable(1, JPEGConstants.HCACTable);
jpegos.defineQuantizationTables();
jpegos.defineHuffmanTables();
jpegos.close();
DEFactory.JPEGTablesDE jpegtables = new DEFactory.JPEGTablesDE(baos.toByteArray());
ifd.add(jpegtables); // 347
baos.reset();
os = jpegos;
}
// CCIR Recommendation 601-1 LumaRed=299/1000 LumaGreen=587/1000 LumeBlue=114/1000
// Y = ( LumaRed * R + LumaGreen * G + LumaBlue * B )
// Cb = ( B - Y ) / ( 2 - 2 * LumaBlue )
// Cr = ( R - Y ) / ( 2 - 2 * LumaRed )
double LumaRed = 299.0 / 1000.0;
double LumaGreen = 587.0 / 1000.0;
double LumaBlue = 114.0 / 1000.0;
DEFactory.YCbCrCoefficientsDE YCbCrCoeff = new DEFactory.YCbCrCoefficientsDE();
YCbCrCoeff.setLumaRed(LumaRed); // Y
YCbCrCoeff.setLumaGreen(LumaGreen); // Cb
YCbCrCoeff.setLumaBlue(LumaBlue); // Cr
ifd.add(YCbCrCoeff); // 529
DEFactory.YCbCrSubSamplingDE YCbCrSubSampling = new DEFactory.YCbCrSubSamplingDE();
YCbCrSubSampling.setHoriz(ssh);
YCbCrSubSampling.setVert(ssv);
ifd.add(YCbCrSubSampling); // 530
double RfBY = 0;
double RfWY = 255;
double RfBCb = 128;
double RfWCb = 255;
double RfBCr = 128;
double RfWCr = 255;
DEFactory.ReferenceBlackWhiteDE ReferenceBlackWhite = new DEFactory.ReferenceBlackWhiteDE();
ReferenceBlackWhite.setY(RfBY, RfWY);
ReferenceBlackWhite.setCb(RfBCb, RfWCb);
ReferenceBlackWhite.setCr(RfBCr, RfWCr);
ifd.add(ReferenceBlackWhite); // 532
TIFFYCbCrOutputStream ycbcros;
if (jpegos == null) {
ycbcros = new TIFFYCbCrOutputStream(os, width, ssv, ssh);
os = new TIFFSubSamplingOutputStream(ycbcros, width, ssv, ssh);
} else {
ycbcros = new TIFFYCbCrOutputStream(os, width, 1, 1); // jpeg does own subsampling
os = ycbcros;
}
ycbcros.setPositioning(1);
ycbcros.setColourCoefficients(LumaRed, LumaGreen, LumaBlue);
ycbcros.setRfBWY(RfBY, RfWY);
ycbcros.setRfBWCb(RfBCb, RfWCb);
ycbcros.setRfBWCr(RfBCr, RfWCr);
WritableRaster raster = image.getRaster();
DataBufferInt buffer = (DataBufferInt) raster.getDataBuffer();
int[] imgdata = (int[]) buffer.getData();
int c = 0, index = 0;
for (int y = 0; y < height; y += maxrps) {
if ((height - y) < maxrps) {
maxrps = height - y;
}
if (jpegos != null) {
jpegos.startOfImage();
int[] hv = {(ssh << 4) | ssv, 0x11, 0x11}; // (Hi<<4)|Vi
int[] q = {0, 1, 1}; // quantization table Y=0, Cb=Cr=1
// jpegos.startOfFrame(((maxrps+ssv-1)/ssv)*ssv,ww,hv,q);
jpegos.startOfFrame(maxrps, ww, hv, q);
int[] sel = {0, 1, 1}; // DC,AC code table Y=0, Cb=Cr=1
jpegos.startOfScan(sel);
}
for (int i = 0; i < maxrps; i++) {
int x = 0;
while (x < width) {
c = imgdata[x + (y + i) * width];
// c = image.getRGB(x,y+i);
os.write((c >> 16) & 0x000000FF);
os.write((c >> 8) & 0x000000FF);
os.write(c & 0x000000FF);
x++;
}
while (x < ww) {
os.write((c >> 16) & 0x000000FF);
os.write((c >> 8) & 0x000000FF);
os.write(c & 0x000000FF);
x++;
}
}
os.close();
byte[] data = baos.toByteArray();
counts.setCount(index, data.length); // update ifd strip counter array
offsets.setOffset(index, out.getStreamPosition()); // update ifd image data offset array
out.write(data); // write to image stream
baos.reset();
index++;
}
return ifd;
} catch (Exception e) {
e.printStackTrace();
throw new IOException(getClass().getName() + ".writeYCbCrImage:\n\t" + e.getMessage());
}
}
private IFD writeCMYKImage(ImageOutputStream out, BufferedImage image, TIFFImageWriteParam param)
throws IOException {
try {
int width = image.getWidth();
int height = image.getHeight();
IFD ifd = new IFD(); // entries need to be in tag order !
ifd.add(new DEFactory.NewSubfileTypeDE(2)); // 254 single page of multipage file
ifd.add(new DEFactory.ImageWidthDE(width)); // 256
ifd.add(new DEFactory.ImageLengthDE(height)); // 257
DEFactory.BitsPerSampleDE bpss = new DEFactory.BitsPerSampleDE(4);
bpss.setBitsPerSample(0, 8); // cyan
bpss.setBitsPerSample(1, 8); // magneta
bpss.setBitsPerSample(2, 8); // yellow
bpss.setBitsPerSample(3, 8); // key (black)
ifd.add(bpss); // 258
ifd.add(new DEFactory.CompressionDE(NOCOMPRESSION)); // 259
ifd.add(new DEFactory.PhotometricInterpretationDE(CMYK)); // 262
int maxrps, maxstripes; // max RowsPerStrip
if ((1 << 13) <= width) {
maxrps = 1;
maxstripes = height; // one row per strip
} else {
maxrps = (1 << 13) / width;
maxstripes = (height + maxrps - 1) / maxrps;
}
DEFactory.StripOffsetsDE offsets = new DEFactory.StripOffsetsDE(maxstripes);
ifd.add(offsets); // 273
ifd.add(new DEFactory.SamplesPerPixelDE(4)); // 277
ifd.add(new DEFactory.RowsPerStripDE(maxrps)); // 278
DEFactory.StripByteCountsDE counts = new DEFactory.StripByteCountsDE(maxstripes);
ifd.add(counts); // 279
if (param == null) {
ifd.add(new DEFactory.XResolutionDE(72.0)); // 282
ifd.add(new DEFactory.YResolutionDE(72.0)); // 283
} else {
ifd.add(new DEFactory.XResolutionDE(param.getXResolution())); // 282
ifd.add(new DEFactory.YResolutionDE(param.getYResolution())); // 283
}
ifd.add(new DEFactory.ResolutionUnitDE(Inch)); // 296
int index = 0;
for (int y = 0; y < height; y += maxrps) {
/*
Assume rgb image.
Each strip: evaluate c m y k colour
save in byte array
write to image file
*/
ByteArrayOutputStream baos = new ByteArrayOutputStream();
for (int i = 0; i < maxrps; i++) {
if ((y + i) == height) {
break;
} // last strip might have less rows
for (int x = 0; x < width; x++) {
int c = image.getRGB(x, y + i);
int R = (c >> 16) & 0x00FF;
int G = (c >> 8) & 0x00FF;
int B = (c) & 0x00FF;
if ((R == 255) && (G == 255) && (B == 255)) {
baos.write(0);
baos.write(0);
baos.write(0);
baos.write(0);
} else {
double C = 1.0 - R / 255.0;
double M = 1.0 - G / 255.0;
double Y = 1.0 - B / 255.0;
double K = C;
if (M < K) {
K = M;
}
if (Y < K) {
K = Y;
}
C = ((C - K) / (1.0 - K)) * 255.0;
M = ((M - K) / (1.0 - K)) * 255.0;
Y = ((Y - K) / (1.0 - K)) * 255.0;
K *= 255.0;
baos.write((int) C);
baos.write((int) M);
baos.write((int) Y);
baos.write((int) K);
}
}
}
baos.close();
byte[] data = baos.toByteArray();
counts.setCount(index, data.length); // update ifd strip counter array
offsets.setOffset(index, out.getStreamPosition()); // update ifd image data offset array
out.write(data); // write to image stream
index++;
}
return ifd;
} catch (Exception e) {
e.printStackTrace();
throw new IOException(getClass().getName() + ".writeCMYKImage:\n\t" + e.getMessage());
}
}
private IFD writeRGBImage(
ImageOutputStream out, BufferedImage image, int comp, TIFFImageWriteParam param)
throws IOException {
image = convert(image, BufferedImage.TYPE_INT_RGB);
try {
int width = image.getWidth();
int height = image.getHeight();
IFD ifd = new IFD(); // entries need to be in tag order !
ifd.add(new DEFactory.NewSubfileTypeDE(2)); // 254 single page of multipage file
ifd.add(new DEFactory.ImageWidthDE(width)); // 256
ifd.add(new DEFactory.ImageLengthDE(height)); // 257
DEFactory.BitsPerSampleDE bpss = new DEFactory.BitsPerSampleDE(3);
bpss.setBitsPerSample(0, 8); // red
bpss.setBitsPerSample(1, 8); // green
bpss.setBitsPerSample(2, 8); // blue
ifd.add(bpss); // 258
ifd.add(new DEFactory.CompressionDE(comp)); // 259
ifd.add(new DEFactory.PhotometricInterpretationDE(RGB)); // 262
int maxrps, maxstripes; // max RowsPerStrip
if ((1 << 13) <= width) {
maxrps = 1;
maxstripes = height; // one row per strip
} else {
maxrps = (1 << 13) / width;
maxstripes = (height + maxrps - 1) / maxrps;
}
if (comp == JPEG) {
maxrps = ((maxrps + 8 - 1) / 8) * 8;
maxstripes = (height + maxrps - 1) / maxrps;
}
DEFactory.StripOffsetsDE offsets = new DEFactory.StripOffsetsDE(maxstripes);
ifd.add(offsets); // 273
ifd.add(new DEFactory.SamplesPerPixelDE(3)); // 277
ifd.add(new DEFactory.RowsPerStripDE(maxrps)); // 278
DEFactory.StripByteCountsDE counts = new DEFactory.StripByteCountsDE(maxstripes);
ifd.add(counts); // 279
if (param == null) {
ifd.add(new DEFactory.XResolutionDE(72.0)); // 282
ifd.add(new DEFactory.YResolutionDE(72.0)); // 283
} else {
ifd.add(new DEFactory.XResolutionDE(param.getXResolution())); // 282
ifd.add(new DEFactory.YResolutionDE(param.getYResolution())); // 283
}
ifd.add(new DEFactory.ResolutionUnitDE(Inch)); // 296
ByteArrayOutputStream baos = new ByteArrayOutputStream();
OutputStream os = baos;
JPEGOutputStream jpegos = null;
if (comp == JPEG) { // add JPEGTables tag
jpegos = new JPEGOutputStream(baos);
int quality = (param == null) ? 50 : (int) (param.getCompressionQuality() * 100);
jpegos.setZZQuantizationTable(0, JPEGConstants.LQT, quality);
jpegos.setRawDCHuffmanTable(0, JPEGConstants.HLDCTable);
jpegos.setRawACHuffmanTable(0, JPEGConstants.HLACTable);
jpegos.defineQuantizationTables();
jpegos.defineHuffmanTables();
jpegos.close();
DEFactory.JPEGTablesDE jpegtables = new DEFactory.JPEGTablesDE(baos.toByteArray());
ifd.add(jpegtables); // 347
baos.reset();
os = jpegos;
}
WritableRaster raster = image.getRaster();
DataBufferInt buffer = (DataBufferInt) raster.getDataBuffer();
int[] imgdata = (int[]) buffer.getData();
int index = 0;
for (int y = 0; y < height; y += maxrps) {
/*
Assume rgb image.
Each strip: evaluate r g b colour
save in byte array
write to image file
*/
if ((height - y) < maxrps) {
maxrps = height - y;
}
if (jpegos != null) { // jpeg: SOI,SOF,SOS marker
jpegos.startOfImage();
int[] hv = {0x11, 0x11, 0x11}; // (Hi<<4)|Vi
int[] q = {0, 0, 0}; // quantization table 0
jpegos.startOfFrame(maxrps, width, hv, q);
int[] sel = {0, 0, 0}; // DC,AC code table 0
jpegos.startOfScan(sel);
}
for (int i = 0; i < maxrps; i++) { // write RGB data
for (int x = 0; x < width; x++) {
int c = imgdata[x + (y + i) * width];
os.write((c >> 16) & 0x000000FF);
os.write((c >> 8) & 0x000000FF);
os.write(c & 0x000000FF);
}
}
os.close(); // jpeg: EOI marker
byte[] data = baos.toByteArray();
counts.setCount(index, data.length); // update ifd strip counter array
offsets.setOffset(index, out.getStreamPosition()); // update ifd image data offset array
out.write(data); // write to image stream
baos.reset();
index++;
}
return ifd;
} catch (Exception e) {
e.printStackTrace();
throw new IOException(getClass().getName() + ".writeRGBImage:\n\t" + e.getMessage());
}
}
private IFD writeBModHufImage(
ImageOutputStream out, BufferedImage image, TIFFImageWriteParam param) throws IOException {
try {
int width = image.getWidth();
int height = image.getHeight();
IFD ifd = new IFD(); // entries need to be in tag order !
ifd.add(new DEFactory.NewSubfileTypeDE(2)); // 254 single page of multipage file
ifd.add(new DEFactory.ImageWidthDE(width)); // 256
ifd.add(new DEFactory.ImageLengthDE(height)); // 257
ifd.add(new DEFactory.CompressionDE(CCITTGROUP3MODHUFFMAN)); // 259
ifd.add(new DEFactory.PhotometricInterpretationDE(WhiteIsZero)); // 262
int maxrps, maxstripes; // max RowsPerStrip
if ((1 << 13) <= width) {
maxrps = 1;
maxstripes = height; // one row per stripe
} else {
maxrps = (1 << 13) / width;
maxstripes = (height + maxrps - 1) / maxrps;
}
DEFactory.StripOffsetsDE offsets = new DEFactory.StripOffsetsDE(maxstripes);
ifd.add(offsets); // 273
ifd.add(new DEFactory.RowsPerStripDE(maxrps)); // 278
DEFactory.StripByteCountsDE counts = new DEFactory.StripByteCountsDE(maxstripes);
ifd.add(counts); // 279
if (param == null) {
ifd.add(new DEFactory.XResolutionDE(72.0)); // 282
ifd.add(new DEFactory.YResolutionDE(72.0)); // 283
} else {
ifd.add(new DEFactory.XResolutionDE(param.getXResolution())); // 282
ifd.add(new DEFactory.YResolutionDE(param.getYResolution())); // 283
}
ifd.add(new DEFactory.ResolutionUnitDE(Inch)); // 296
int index = 0;
for (int y = 0; y < height; y += maxrps) {
/*
Assume bilevel image (black/white[=-1])
Each strip: count run length
encode into modified hufman codes
swap bits
save in byte array
write to image file
*/
ByteArrayOutputStream baos = new ByteArrayOutputStream();
BitSwapOutputStream bsos = new BitSwapOutputStream(baos);
ModHuffmanOutputStream mhos = new ModHuffmanOutputStream(bsos);
RLEOutputStream rlos =
new RLEOutputStream(mhos, 3); // rgb = 3 bytes per sample code word (not needed here)
for (int i = 0; i < maxrps; i++) {
if ((y + i) == height) {
break;
} // last strip might have less rows
rlos.setStartCodeWord(-1); // white run first
for (int x = 0; x < width; x++) {
rlos.write(image.getRGB(x, y + i));
}
rlos.flush(); // write padding after ever image row
}
rlos.close();
byte[] data = baos.toByteArray();
counts.setCount(index, data.length); // update ifd strip counter array
offsets.setOffset(index, out.getStreamPosition()); // update ifd image data offset array
out.write(data); // write to image stream
index++;
}
return ifd;
} catch (Exception e) {
e.printStackTrace();
throw new IOException(getClass().getName() + ".writeBModHufImage:\n\t" + e.getMessage());
}
}
public static BufferedImage getImageFromArray(int[] pixels, int width, int height) {
BufferedImage imageBI = new BufferedImage(width, height, BufferedImage.TYPE_INT_ARGB);
WritableRaster raster = (WritableRaster) imageBI.getData();
raster.setPixels(0, 0, width, height, pixels);
return imageBI;
}
