/** * replaces the current output image by the top of the image stack and removes the top of the * stack */ public void pop() { try { content.setData(imageStack.pop()); } catch (EmptyStackException e) { clear(); } }
private BufferedImage toImage(byte[][] bands, int xSize, int ySize) { int numberOfBands = bands.length; int numBytes = xSize * ySize * numberOfBands; DataBuffer imgBuffer = new DataBufferByte(bands, numBytes); SampleModel sampleModel = new BandedSampleModel(TYPE_BYTE, xSize, ySize, numberOfBands); WritableRaster raster = Raster.createWritableRaster(sampleModel, imgBuffer, null); if (numberOfBands == 1) { Band band = dataset.GetRasterBand(1); int bufType = band.getDataType(); int dataType = detectDataType(band, bufType); BufferedImage img; if (BufferedImage.TYPE_BYTE_INDEXED == dataType) { ColorTable ct = band.GetRasterColorTable(); IndexColorModel cm = ct.getIndexColorModel(gdal.GetDataTypeSize(bufType)); img = new BufferedImage(xSize, ySize, dataType, cm); } else { img = new BufferedImage(xSize, ySize, dataType); } img.setData(raster); return img; } ColorSpace cs = ColorSpace.getInstance(CS_sRGB); ColorModel cm; if (numberOfBands == 3) { cm = new ComponentColorModel(cs, false, false, ColorModel.OPAQUE, TYPE_BYTE); } else if (numberOfBands == 4) { cm = new ComponentColorModel(cs, true, false, ColorModel.TRANSLUCENT, TYPE_BYTE); } else { throw new IllegalArgumentException("Unsupported number of bands: " + numberOfBands); } return new BufferedImage(cm, raster, false, null); }
/** * _more_ * * @param image_data _more_ */ private void createBufferedImage(float image_data[][]) { WritableRaster raster = null; int num_bands = 0; if (null != preview_image) { preview_image.getSampleModel().getNumBands(); } if ((null == preview_image) || (image_data.length != num_bands)) { if (image_data.length == 1) { preview_image = new BufferedImage(subSampledPixels, subSampledScans, BufferedImage.TYPE_BYTE_GRAY); } else { preview_image = new BufferedImage(subSampledPixels, subSampledScans, BufferedImage.TYPE_3BYTE_BGR); } DataBufferFloat dbuf = new DataBufferFloat(image_data, subSampledPixels * subSampledScans * image_data.length); SampleModel sampleModel = new BandedSampleModel(0, subSampledPixels, subSampledScans, image_data.length); raster = Raster.createWritableRaster(sampleModel, dbuf, new Point(0, 0)); preview_image.setData(raster); } else if (1 == num_bands) { preview_image .getRaster() .setDataElements( 0, 0, preview_image.getWidth(), preview_image.getHeight(), image_data[0]); } else if (3 == num_bands) { preview_image .getRaster() .setDataElements(0, 0, preview_image.getWidth(), preview_image.getHeight(), image_data); } }
/** * We need to figure out how to get more than just vis images :/ * * @param args * @throws IOException * @throws ZipException */ public static void dumb(String[] args) throws IOException, ZipException { /** * Things to try, only look at first 14 bits (???) only look at last 14 bits (???) extrapolate * 14 bits into 16 bit space */ // old stuff String filename = "/data/pgftp/LemnaTest/2013-11-06/blob212853"; int width = 1388; int height = 1038; // some shit i copied on the internet byte[] spot = IOUtils.toByteArray( new FileInputStream("/Users/shill/Documents/JSEE_workspace/PhenoFront/lib/data")); short[] pixelArray = toShorts(spot); // foreach short, value of Point origin = new Point(); DataBufferUShort dataBuffer = new DataBufferUShort(pixelArray, (width * height), 0); int[] bandOffets = {0}; ComponentSampleModel sampleModel = new ComponentSampleModel(DataBuffer.TYPE_USHORT, width, height, 1, width, bandOffets); WritableRaster raster = Raster.createWritableRaster(sampleModel, dataBuffer, origin); BufferedImage buffImg = new BufferedImage(width, height, BufferedImage.TYPE_USHORT_GRAY); buffImg.setData(raster); ImageIO.write( buffImg, "tiff", new File("/Users/shill/Documents/JSEE_workspace/PhenoFront/lib/b.tiff")); }
/** * @param page * @return */ public BufferedImage getPageAsBufferedImage(int page) { page++; JBIG2Bitmap pageBitmap = streamDecoder.findPageSegement(page).getPageBitmap(); byte[] bytes = pageBitmap.getData(true); if (bytes == null) return null; // make a a DEEP copy so we cant alter int len = bytes.length; byte[] copy = new byte[len]; System.arraycopy(bytes, 0, copy, 0, len); // byte[] data = pageBitmap.getData(true).clone(); int width = pageBitmap.getWidth(); int height = pageBitmap.getHeight(); /** create an image from the raw data */ DataBuffer db = new DataBufferByte(copy, copy.length); WritableRaster raster = Raster.createPackedRaster(db, width, height, 1, null); BufferedImage image = new BufferedImage(width, height, BufferedImage.TYPE_BYTE_BINARY); image.setData(raster); return image; }
/** * replaces the current output image by the top of the image stack without removing the top of the * stack */ public void peek() { try { content.setData(imageStack.peek()); } catch (EmptyStackException e) { clear(); } repaint(); }
/** * Gets the current frame as a BufferedImage the same size as the logical screen. Graphic Control * Extension and Image Descriptor parameters are taken into account When creating the frame. The * resulting frame is actually a "composite" one or a snapshot as seen in an animated GIF. Such * frames may not be the same as the frames created by {@link * #getFrameAsBufferedImage(InputStream) getFrameAsBufferedImage} which could be of different * sizes and may also have to rely on the previous frames to look the same as the frames created * here. * * <p>Note: do not mix this method with {@link #read(InputStream) read} or {@link * #getFrameAsBufferedImage(InputStream) getFrameAsBufferedImage}. Use them separately. * * @param is input stream for the image - single frame or multiple frame animated GIF * @return java BufferedImage or null if there is no more frames * @throws Exception */ protected BufferedImage getFrameAsBufferedImageEx(InputStream is) throws Exception { // This single call will trigger the reading of the global scope data BufferedImage bi = getFrameAsBufferedImage(is); if (bi == null) return null; int maxWidth = (width < logicalScreenWidth) ? width : logicalScreenWidth; int maxHeight = (height < logicalScreenHeight) ? height : logicalScreenHeight; if (baseImage == null) baseImage = new BufferedImage(logicalScreenWidth, logicalScreenHeight, BufferedImage.TYPE_INT_ARGB); Rectangle area = new Rectangle(image_x, image_y, maxWidth, maxHeight); // Create a backup bufferedImage from the base image for the area of the current frame BufferedImage backup = new BufferedImage(maxWidth, maxHeight, BufferedImage.TYPE_INT_ARGB); backup.setData(baseImage.getData(area)); /* End of backup */ Graphics2D g = baseImage.createGraphics(); // Draw this frame to the base g.drawImage(bi, image_x, image_y, null); // We need to clone the base image since we are going to dispose it later according to the // disposal method BufferedImage clone = new BufferedImage(logicalScreenWidth, logicalScreenHeight, BufferedImage.TYPE_INT_ARGB); clone.setData(baseImage.getData()); // Check about disposal method to take action accordingly if (disposalMethod == 1 || disposalMethod == 0) // Leave in place or unspecified ; // No action needed else if (disposalMethod == 2) { // Restore to background Composite oldComposite = g.getComposite(); g.setComposite(AlphaComposite.Clear); g.fillRect(image_x, image_y, width, height); g.setComposite(oldComposite); } else if (disposalMethod == 3) { // Restore to previous Composite oldComposite = g.getComposite(); g.setComposite(AlphaComposite.Src); g.drawImage(backup, image_x, image_y, null); g.setComposite(oldComposite); } else { // To be defined - should never come here baseImage = new BufferedImage(logicalScreenWidth, logicalScreenHeight, BufferedImage.TYPE_INT_ARGB); g = baseImage.createGraphics(); } return clone; }
public static BufferedImage bufferedImageFromByteArrayJpeg( ColorModel colorModel, byte[] payload, int width, int height) { BufferedImage ret = new BufferedImage(width, height, BufferedImage.TYPE_3BYTE_BGR); DataBuffer dataBuffer = new DataBufferByte(payload, payload.length, 0); SampleModel sampleModel = colorModel.createCompatibleSampleModel(width, height); WritableRaster raster = Raster.createWritableRaster(sampleModel, dataBuffer, null); ret.setData(raster); return ret; }
@Override protected BufferedImage loadImage(int imageIndex) throws IOException { checkImageIndex(imageIndex); ensureMetadataIsLoaded(imageIndex); final WritableRaster raster = loadRAWRaster(); final int width = raster.getWidth(); final int height = raster.getHeight(); BufferedImage bufferedImage = new BufferedImage(width, height, BufferedImage.TYPE_USHORT_GRAY); bufferedImage.setData(raster); return bufferedImage; }
@Test public void test4BitPNG() throws Exception { // create test image IndexColorModel icm = new IndexColorModel( 4, 16, new byte[] {(byte) 255, 0, 0, 0, 16, 32, 64, (byte) 128, 1, 2, 3, 4, 5, 6, 7, 8}, new byte[] {0, (byte) 255, 0, 0, 16, 32, 64, (byte) 128, 1, 2, 3, 4, 5, 6, 7, 8}, new byte[] {0, 0, (byte) 255, 0, 16, 32, 64, (byte) 128, 1, 2, 3, 4, 5, 6, 7, 8}); assertEquals(16, icm.getMapSize()); // create random data WritableRaster data = com.sun.media.jai.codecimpl.util.RasterFactory.createWritableRaster( icm.createCompatibleSampleModel(32, 32), new Point(0, 0)); for (int x = data.getMinX(); x < data.getMinX() + data.getWidth(); x++) { for (int y = data.getMinY(); y < data.getMinY() + data.getHeight(); y++) { data.setSample(x, y, 0, (x + y) % 8); } } final BufferedImage bi = new BufferedImage(icm, data, false, null); assertEquals(16, ((IndexColorModel) bi.getColorModel()).getMapSize()); assertEquals(4, bi.getSampleModel().getSampleSize(0)); bi.setData(data); if (TestData.isInteractiveTest()) { ImageIOUtilities.visualize(bi, "before"); } // encode as png ImageWorker worker = new ImageWorker(bi); final File outFile = TestData.temp(this, "temp4.png"); worker.writePNG(outFile, "FILTERED", 0.75f, true, false); worker.dispose(); // make sure we can read it BufferedImage back = ImageIO.read(outFile); // we expect an IndexColorMolde one matching the old one IndexColorModel ccm = (IndexColorModel) back.getColorModel(); assertEquals(3, ccm.getNumColorComponents()); assertEquals(16, ccm.getMapSize()); assertEquals(4, ccm.getPixelSize()); if (TestData.isInteractiveTest()) { ImageIOUtilities.visualize(back, "after"); } }
public static BufferedImage bufferedImageFromRosMessageRaw( ColorModel colorModel, sensor_msgs.Image imageMessage) { int width = imageMessage.getWidth(); int height = imageMessage.getHeight(); byte[] payload = imageMessage.getData().array(); BufferedImage ret = new BufferedImage(width, height, BufferedImage.TYPE_3BYTE_BGR); DataBuffer dataBuffer = new DataBufferByte(payload, payload.length, imageMessage.getData().arrayOffset()); SampleModel sampleModel = colorModel.createCompatibleSampleModel(width, height); WritableRaster raster = Raster.createWritableRaster(sampleModel, dataBuffer, null); ret.setData(raster); return ret; }
public static BufferedImage make( int w, int h, byte[] data, final GenericColorSpace decodeColorData, int d) { final BufferedImage image = new BufferedImage(w, h, BufferedImage.TYPE_BYTE_BINARY); final DataBuffer db = new DataBufferByte(data, data.length); // needs to be inverted in this case (ie 12dec/mariners_annual_2012.pdf) if (decodeColorData.getID() == ColorSpaces.Separation) { final int count = data.length; for (int aa = 0; aa < count; aa++) { data[aa] = (byte) (data[aa] ^ 255); } } final WritableRaster raster = Raster.createPackedRaster(db, w, h, d, null); image.setData(raster); return image; }
@Override protected BufferedImage doInBackground() { int x, y, b; int[] A = null; int[] sum = new int[bands], sum_x = new int[bands], sum_y = new int[bands]; WritableRaster raster = image.getRaster(); for (x = 0; x < size.getWidth(); x++) { for (y = 0; y < size.getHeight(); y++) { if (y == 0 || y == size.getHeight() - 1 || x == 0 || x == size.getWidth() - 1) { for (b = 0; b < bands; b++) { sum[b] = 0; } } else { for (b = 0; b < bands; b++) { A = input.getSamples( x - 1, y - 1, CSobelOperator.matrix_size, CSobelOperator.matrix_size, b, A); sum_x[b] = CSobelOperator.getGx(A); sum_y[b] = CSobelOperator.getGy(A); } for (b = 0; b < bands; b++) { sum[b] = Math.abs(sum_x[b]) + Math.abs(sum_y[b]); } } raster.setPixel(x, y, sum); setProgress( 100 * (x * ((int) size.getHeight()) + y) / ((int) (size.getWidth() * size.getHeight()))); } } image.setData(raster); return image; }
public void updateImage(BufferedImage rImage) { bImage.setData(rImage.getRaster()); repaint(); }
private static BufferedImage scaleImage(Raster ras, int pX, int pY, int comp, int d) { int w = ras.getWidth(); int h = ras.getHeight(); byte[] data = ((DataBufferByte) ras.getDataBuffer()).getData(); // see what we could reduce to and still be big enough for page int newW = w, newH = h; int sampling = 1; int smallestH = pY << 2; // double so comparison works int smallestW = pX << 2; // cannot be smaller than page while (newW > smallestW && newH > smallestH) { sampling = sampling << 1; newW = newW >> 1; newH = newH >> 1; } int scaleX = w / pX; if (scaleX < 1) scaleX = 1; int scaleY = h / pY; if (scaleY < 1) scaleY = 1; // choose smaller value so at least size of page sampling = scaleX; if (sampling > scaleY) sampling = scaleY; // switch to 8 bit and reduce bw image size by averaging if (sampling > 1) { newW = w / sampling; newH = h / sampling; if (d == 1) { int size = newW * newH; byte[] newData = new byte[size]; final int[] flag = {1, 2, 4, 8, 16, 32, 64, 128}; int origLineLength = (w + 7) >> 3; int bit; byte currentByte; // scan all pixels and down-sample for (int y = 0; y < newH; y++) { for (int x = 0; x < newW; x++) { int bytes = 0, count = 0; // allow for edges in number of pixels left int wCount = sampling, hCount = sampling; int wGapLeft = w - x; int hGapLeft = h - y; if (wCount > wGapLeft) wCount = wGapLeft; if (hCount > hGapLeft) hCount = hGapLeft; // count pixels in sample we will make into a pixel (ie // 2x2 is 4 pixels , 4x4 is 16 pixels) for (int yy = 0; yy < hCount; yy++) { for (int xx = 0; xx < wCount; xx++) { currentByte = data[((yy + (y * sampling)) * origLineLength) + (((x * sampling) + xx) >> 3)]; bit = currentByte & flag[7 - (((x * sampling) + xx) & 7)]; if (bit != 0) bytes++; count++; } } // set value as white or average of pixels int offset = x + (newW * y); if (count > 0) { newData[offset] = (byte) ((255 * bytes) / count); } else { newData[offset] = (byte) 255; } } } data = newData; h = newH; w = newW; d = 8; // imageMask=false; } else if (d == 8) { int x = 0, y = 0, xx = 0, yy = 0, jj = 0, origLineLength = 0; try { // black and white if (w * h == data.length) comp = 1; byte[] newData = new byte[newW * newH * comp]; // System.err.println(w+" "+h+" "+data.length+" // comp="+comp+" scaling="+sampling+" "+decodeColorData); origLineLength = w * comp; // System.err.println("size="+w*h*comp+" filter"+filter+" // scaling="+sampling+" comp="+comp); // System.err.println("w="+w+" h="+h+" data="+data.length+" // origLineLength="+origLineLength+" sampling="+sampling); // scan all pixels and down-sample for (y = 0; y < newH; y++) { for (x = 0; x < newW; x++) { // allow for edges in number of pixels left int wCount = sampling, hCount = sampling; int wGapLeft = w - x; int hGapLeft = h - y; if (wCount > wGapLeft) wCount = wGapLeft; if (hCount > hGapLeft) hCount = hGapLeft; for (jj = 0; jj < comp; jj++) { int byteTotal = 0, count = 0; // count pixels in sample we will make into a // pixel (ie 2x2 is 4 pixels , 4x4 is 16 pixels) for (yy = 0; yy < hCount; yy++) { for (xx = 0; xx < wCount; xx++) { byteTotal = byteTotal + (data[ ((yy + (y * sampling)) * origLineLength) + (((x * sampling * comp) + (xx * comp) + jj))] & 255); count++; } } // set value as white or average of pixels if (count > 0) // if(index==null) newData[jj + (x * comp) + (newW * y * comp)] = (byte) ((byteTotal) / count); // else // newData[x+(newW*y)]=(byte)(((index[1] & // 255)*byteTotal)/count); else { // if(index==null) // newData[jj+x+(newW*y*comp)]=(byte) 255; // else // newData[x+(newW*y)]=index[0]; } } } } data = newData; h = newH; w = newW; } catch (Exception e) { // <start-full><start-demo> System.err.println( "xx=" + xx + " yy=" + yy + " jj=" + jj + " ptr=" + ((yy + (y * sampling)) * origLineLength) + (((x * sampling) + (xx * comp) + jj)) + '/' + data.length); // System.err.println("index="+index); System.err.println( ((yy + (y * sampling)) * origLineLength) + " " + (((x * sampling) + (xx * comp) + jj))); System.err.println( "w=" + w + " h=" + h + " sampling=" + sampling + " x=" + x + " y=" + y); // System.out.println("xx="+xx+" yy="+yy); e.printStackTrace(); // <end-demo><end-full> } } } if (sampling > 1) { final int[] bands = {0}; // System.out.println("w=" + w + " h=" + h + " size=" + // data.length); // WritableRaster raster =Raster.createPackedRaster(new // DataBufferByte(newData, newData.length), newW, newH, 1, null); Raster raster = Raster.createInterleavedRaster( new DataBufferByte(data, data.length), w, h, w, 1, bands, null); BufferedImage image = new BufferedImage(w, h, BufferedImage.TYPE_BYTE_GRAY); image.setData(raster); return image; } else { return null; } }
public void setData(Raster r) { _i.setData(r); }
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(); } }
@Override protected boolean loadTexture(TextureTile tile, URL textureURL) { if (!(tile instanceof MinMaxTextureTile)) { Logging.logger().severe("Tile is not instance of " + MinMaxTextureTile.class); getLevels().markResourceAbsent(tile); return false; } synchronized (fileLock) { InputStream is = null; try { is = textureURL.openStream(); DataInputStream dis = new DataInputStream(is); int width = dis.readInt(); int height = dis.readInt(); int bands = dis.readInt(); double minElevation = dis.readDouble(); double maxElevation = dis.readDouble(); byte[][] bytes = new byte[bands][]; for (int i = 0; i < bands; i++) { bytes[i] = new byte[width * height]; is.read(bytes[i]); } DataBuffer db = new DataBufferByte(bytes, width * height); SampleModel sm = new BandedSampleModel(DataBuffer.TYPE_BYTE, width, height, bands); Raster raster = Raster.createRaster(sm, db, null); BufferedImage image = new BufferedImage(width, height, BufferedImage.TYPE_INT_ARGB_PRE); image.setData(raster); TextureData textureData = TextureIO.newTextureData(image, isUseMipMaps()); if (textureData == null) { throw new Exception("Could not create texture data for " + textureURL); } ((MinMaxTextureTile) tile).setMinElevation(minElevation); ((MinMaxTextureTile) tile).setMaxElevation(maxElevation); tile.setTextureData(textureData); // if (tile.getLevelNumber() != 0 || !this.isRetainLevelZeroTiles()) addTileToCache(tile); getLevels().unmarkResourceAbsent(tile); firePropertyChange(AVKey.LAYER, null, this); return true; } catch (Exception e) { // Assume that something's wrong with the file and delete it. gov.nasa.worldwind.WorldWind.getDataFileStore().removeFile(textureURL); getLevels().markResourceAbsent(tile); String message = Logging.getMessage("generic.DeletedCorruptDataFile", textureURL); Logging.logger().info(message + ":" + e.getLocalizedMessage()); return false; } finally { if (is != null) { try { is.close(); } catch (IOException e) { } } } } }
/** * Parse the image stream into a buffered image. Note that this is guaranteed to be called after * all the other setXXX methods have been called. * * <p>NOTE: the color convolving is extremely slow on large images. It would be good to see if it * could be moved out into the rendering phases, where we might be able to scale the image down * first.</p */ protected BufferedImage parseData(byte[] data) { // create the data buffer DataBuffer db = new DataBufferByte(data, data.length); // pick a color model, based on the number of components and // bits per component ColorModel cm = getColorModel(); // create a compatible raster SampleModel sm = cm.createCompatibleSampleModel(getWidth(), getHeight()); WritableRaster raster; try { raster = Raster.createWritableRaster(sm, db, new Point(0, 0)); } catch (RasterFormatException e) { int tempExpectedSize = getWidth() * getHeight() * getColorSpace().getNumComponents() * Math.max(8, getBitsPerComponent()) / 8; if (tempExpectedSize < 3) { tempExpectedSize = 3; } if (tempExpectedSize > data.length) { byte[] tempLargerData = new byte[tempExpectedSize]; System.arraycopy(data, 0, tempLargerData, 0, data.length); db = new DataBufferByte(tempLargerData, tempExpectedSize); raster = Raster.createWritableRaster(sm, db, new Point(0, 0)); } else { throw e; } } /* * Workaround for a bug on the Mac -- a class cast exception in * drawImage() due to the wrong data buffer type (?) */ BufferedImage bi = null; if (cm instanceof IndexColorModel) { IndexColorModel icm = (IndexColorModel) cm; // choose the image type based on the size int type = BufferedImage.TYPE_BYTE_BINARY; if (getBitsPerComponent() == 8) { type = BufferedImage.TYPE_BYTE_INDEXED; } // create the image with an explicit indexed color model. bi = new BufferedImage(getWidth(), getHeight(), type, icm); // set the data explicitly as well bi.setData(raster); } else { // Raster is already in a format which is supported by Java2D, // such as RGB or Gray. bi = new BufferedImage(cm, raster, true, null); } // hack to avoid *very* slow conversion ColorSpace cs = cm.getColorSpace(); ColorSpace rgbCS = ColorSpace.getInstance(ColorSpace.CS_sRGB); if (!isImageMask() && cs instanceof ICC_ColorSpace && !cs.equals(rgbCS)) { ColorConvertOp op = new ColorConvertOp(cs, rgbCS, null); BufferedImage converted = new BufferedImage(getWidth(), getHeight(), BufferedImage.TYPE_INT_ARGB); bi = op.filter(bi, converted); } // add in the alpha data supplied by the SMask, if any PDFImage sMaskImage = getSMask(); if (sMaskImage != null) { BufferedImage si = sMaskImage.getImage(); BufferedImage outImage = new BufferedImage(getWidth(), getHeight(), BufferedImage.TYPE_INT_ARGB); int[] srcArray = new int[this.width]; int[] maskArray = new int[this.width]; for (int i = 0; i < this.height; i++) { bi.getRGB(0, i, this.width, 1, srcArray, 0, this.width); si.getRGB(0, i, this.width, 1, maskArray, 0, this.width); for (int j = 0; j < this.width; j++) { int ac = 0xff000000; maskArray[j] = ((maskArray[j] & 0xff) << 24) | (srcArray[j] & ~ac); } outImage.setRGB(0, i, this.width, 1, maskArray, 0, this.width); } bi = outImage; } return (bi); }