@Override ImageComponent2D createImageComponent(final byte[] pix, final int w, final int h) { final int[] bandOffset = { 0, 1, 2, 3 }; final DataBufferByte db = new DataBufferByte(pix, w * h * 4, 0); final WritableRaster raster = Raster.createInterleavedRaster(db, w, h, w * 4, 4, bandOffset, null); final BufferedImage bImage = new BufferedImage(rgbCM, raster, false, null); final ImageComponent2D bComp = new ImageComponent2D(ImageComponent.FORMAT_RGBA, w, h, true, true); bComp.setCapability(ImageComponent.ALLOW_IMAGE_WRITE); bComp.set(bImage); return bComp; } }
@Override public void writeConstructorParams( DataOutput out ) throws IOException { super.writeConstructorParams( out ); ImageComponent2D ic = ((ImageComponent2D)node); // If the BufferedImage is associated with the ImageComponent2D by // reference then we don't know much about it, so it'd be hard to // save. So we copy it into an ImageComponent2D and then copy it // out. It comes out in a known format so it's easier to save. if ( ic.isByReference() ) { ImageComponent2D noByRef = new ImageComponent2D( ic.getFormat(), ic.getRenderedImage(), false, ic.isYUp() ); bufferedImage = noByRef.getImage(); } else bufferedImage = ic.getImage(); writeBufferedImage( out, bufferedImage ); }
@Override public void imageUpdated(ImagePlus image) { if(image == imp) bComp.updateData(updater, 0, 0, w, h); }
/** * @deprecated replaced with cloneNodeComponent(boolean forceDuplicate) */ @Override public NodeComponent cloneNodeComponent() { ImageComponent2DRetained rt = (ImageComponent2DRetained) retained; ImageComponent2D img = new ImageComponent2D(rt.getFormat(), rt.width, rt.height, rt.byReference, rt.yUp); img.duplicateNodeComponent(this); return img; }
new ImageComponent2D(ImageComponent.FORMAT_RGBA, bImage); bImage = offCanvas.getOffScreenBuffer().getImage();
/** * Returns the associated ImageComponent2D object * * @return The associated ImageComponent2D object */ public ImageComponent2D getImage() { if (imageComponent == null) imageComponent = new ImageComponent2D(imageComponentFormat, bufferedImage, byRef, yUp); return imageComponent; }
/** * Creates an offscreen buffer to be attached to the heavyweight * buffer. Buffer is created 'byreference' * * @param width the width of the buffer. * @param height the height of the buffer. */ private void createOffScreenBuffer(int width, int height) { computePhysicalDimensions(); // this.canvas.setDoubleBufferEnable( false ); java.awt.image.BufferedImage bImage = new java.awt.image.BufferedImage(width, height, java.awt.image.BufferedImage.TYPE_INT_ARGB); org.scijava.java3d.ImageComponent2D image = new org.scijava.java3d.ImageComponent2D(org.scijava.java3d.ImageComponent2D.FORMAT_RGBA8, bImage, true, false ); image.setCapability(image.ALLOW_IMAGE_READ); image.setCapability(image.ALLOW_IMAGE_WRITE); this.canvas.stopRenderer(); // offscreenrendering might occur even if the renderer is stopped. For that reason, i'm waiting for an hypothetical offscreen render to finish before setting offscreen rendering. // Otherwise, rendering will stop with an exception. this.canvas.waitForOffScreenRendering(); this.canvas.setOffScreenBuffer(image); this.canvas.startRenderer(); }
if (image != null){ ImageComponent2DRetained imageRetained = (ImageComponent2DRetained)image.retained; if (image.getImageClass() != ImageComponent.ImageClass.BUFFERED_IMAGE) { throw new IllegalArgumentException(J3dI18N.getString("GraphicsContext3D33")); if (image.isByReference() && (image.getImage() == null)) { throw new IllegalArgumentException(J3dI18N.getString("GraphicsContext3D34")); throw new IllegalArgumentException(J3dI18N.getString("GraphicsContext3D35")); if (image.isLive()) { throw new IllegalSharingException(J3dI18N.getString("GraphicsContext3D36"));
private Texture2D getTexture(final CubeData cdata, final int index) { final Texture2D tex = new Texture2D(Texture.BASE_LEVEL, TEX_MODE, SIZE, SIZE); final ImageComponent2D pArray = new ImageComponent2D(COMP_TYPE, SIZE, SIZE, BY_REF, Y_UP); pArray.set(cdata.images[index]); tex.setImage(0, pArray); tex.setEnable(true); tex.setMinFilter(Texture.BASE_LEVEL_LINEAR); tex.setMagFilter(Texture.BASE_LEVEL_LINEAR); tex.setBoundaryModeS(Texture.CLAMP); tex.setBoundaryModeT(Texture.CLAMP); return tex; }
buffer.setCapability(ImageComponent2D.ALLOW_IMAGE_READ); canvas3D.setOffScreenBuffer(buffer); canvas3D.renderOffScreenBuffer();
/** * Retrieves the buffer from canvas, if possible, and * calls/notifies component to be repainted, if necessary. */ @Override synchronized public void postSwap() { if (true == isRendererRunning()) { // as weird as it can look, there can be postswaps without rendered running. (?!!) Anyway, in that case we should not refresh. bi = getOffScreenBuffer().getImage(); imageReadyBis = true; if (false == waitingForSwap) { // System.err.println("repaint " + System.currentTimeMillis()); this.lwCanvas.repaint(); } else { notify(); } } else { // System.err.println("SWAP WITHOUT RENDERER RUNNING"); } }
BufferedImage.TYPE_INT_ARGB); final ImageComponent2D buffer = new ImageComponent2D(ImageComponent.FORMAT_RGBA, bImage); offScreenCanvas3D.renderOffScreenBuffer(); offScreenCanvas3D.waitForOffScreenRendering(); bImage = offScreenCanvas3D.getOffScreenBuffer().getImage();
@Override protected org.scijava.java3d.SceneGraphObject createNode() { return new ImageComponent2D( format, bufferedImage, byReference, yUp ); } }
/** * Creates a heavyweight canvas and initializes it, or changes the * size of the current one if present. Current heavyweight canvas is * changed only if size is different from the actual one. No canvas is * created if this component has no parent, that is, was not added to a * container. * * @param width the width of the canvas to create. * @param height the height of the canvas to create. */ void createCanvas(int width, int height) { if (getParent() == null) { return; } if (null != canvas) { // i had a canvas, i need to check if i really need to change it if ((width != canvas.getWidth()) || (height != canvas.getHeight())) { if ((null != canvas.getOffScreenBuffer()) && (null != canvas.getOffScreenBuffer().getImage())) { canvas.getOffScreenBuffer().getImage().flush(); // flushing so that eventual resources are freed. } } else { return; } } else { // no canvas, i have to create it. canvas = new InternalCanvas3D(this.graphicsConfig, this); } createOffScreenBuffer(width, height); // whatever happened right above, i need to create the offscreen buffer. }
@Override ImageComponent2D createImageComponent(final byte[] pix, final int w, final int h) { final DataBufferByte db = new DataBufferByte(pix, w * h, 0); final SampleModel smod = greyCM.createCompatibleSampleModel(w, h); final WritableRaster raster = Raster.createWritableRaster(smod, db, null); final BufferedImage bImage = new BufferedImage(greyCM, raster, false, null); final ImageComponent2D bComp = new ImageComponent2D(ImageComponent.FORMAT_CHANNEL8, w, h, true, true); bComp.setCapability(ImageComponent.ALLOW_IMAGE_WRITE); bComp.set(bImage); return bComp; } }
/** * Returns the scaled ImageComponent2D object * * @param width The desired width * @param height The desired height * * @return The scaled ImageComponent2D object */ public ImageComponent2D getScaledImage(int width, int height) { if (bufferedImage.getWidth() == width && bufferedImage.getHeight() == height) return getImage(); else return(new ImageComponent2D(imageComponentFormat, getScaledImage(bufferedImage, width, height), byRef, yUp)); }
@Override public void setNoCheck(final int x, final int y, final int z, int v) { l.setNoCheck(x, y, z, v); v = l.loadWithLUT(x, y, z); xy[z][y * xTexSize + x] = (byte) v; xz[y][z * xTexSize + x] = (byte) v; yz[x][z * yTexSize + y] = (byte) v; xyComp[z].updateData(updater, x, y, 1, 1); xzComp[y].updateData(updater, x, z, 1, 1); yzComp[x].updateData(updater, y, z, 1, 1); }