int type = sampleModel.getTransferType(); long numBanks = 0; long size = 0; int dataTypeSize = DataBuffer.getDataTypeSize(type); size = mppsm.getScanlineStride() * mppsm.getHeight() + (mppsm.getDataBitOffset() + dataTypeSize - 1) / dataTypeSize; } else if (sampleModel instanceof SinglePixelPackedSampleModel) { SinglePixelPackedSampleModel sppsm = (SinglePixelPackedSampleModel) sampleModel; numBanks = 1; size = sppsm.getScanlineStride() * (sppsm.getHeight() - 1) + sppsm.getWidth(); Arrays.fill(bankData[i], (byte) 0); db = new DataBufferByte(bankData, (int) size); Arrays.fill(bankData[i], 0); db = new DataBufferInt(bankData, (int) size); db = sampleModel.createDataBuffer(); return Raster.createWritableRaster(sampleModel, db, location);
dest = dest.createWritableChild(cx, cy, cw, ch, 0, 0, null); src = same ? dest : src.createChild(cx, cy, cw, ch, 0, 0, null); final int width = src.getWidth(); final int height = src.getHeight(); int w = (width + pixelSizeX - 1) / pixelSizeX; int h = (height + pixelSizeY - 1) / pixelSizeY; SinglePixelPackedSampleModel sampleModel = (SinglePixelPackedSampleModel) src.getSampleModel(); bitMasks = sampleModel.getBitMasks(); bitOffsets = sampleModel.getBitOffsets(); dest.setDataElements(x * pixelSizeX, y * pixelSizeY, scanW, scanH, data);
protected IntegerSinglePixelPackedScanline(Raster src, WritableRaster dst, final int length) { super(length); srcRaster = src; dstRaster = dst; srcSM = (SinglePixelPackedSampleModel) srcRaster.getSampleModel(); bitMasks = srcSM.getBitMasks(); bitOffsets = srcSM.getBitOffsets(); componentCount = bitMasks.length; if (componentCount != bitOffsets.length || bitOffsets.length != srcSM.getNumBands()) throw new IllegalArgumentException("weird: getBitMasks().length != getBitOffsets().length"); tmp = new int[componentCount]; data = new int[componentCount * length]; }
srcSPPSM = (SinglePixelPackedSampleModel)src.getSampleModel(); final int srcScanStride = srcSPPSM.getScanlineStride(); DataBufferInt srcDB = (DataBufferInt)src.getDataBuffer(); final int [] srcPixels = srcDB.getBankData()[0]; final int srcBase = (srcDB.getOffset() + srcSPPSM.getOffset(x0-src.getSampleModelTranslateX(), y0-src.getSampleModelTranslateY())); dstInSPPSM = (SinglePixelPackedSampleModel)dstIn.getSampleModel(); final int dstInScanStride = dstInSPPSM.getScanlineStride(); DataBufferInt dstInDB = (DataBufferInt)dstIn.getDataBuffer(); final int [] dstInPixels = dstInDB.getBankData()[0]; final int dstInBase = (dstInDB.getOffset() + dstInSPPSM.getOffset(x0-dstIn.getSampleModelTranslateX(), y0-dstIn.getSampleModelTranslateY())); final int dstOutScanStride = dstOutSPPSM.getScanlineStride(); DataBufferInt dstOutDB = (DataBufferInt)dstOut.getDataBuffer(); final int [] dstOutPixels = dstOutDB.getBankData()[0]; final int dstOutBase = (dstOutDB.getOffset() + dstOutSPPSM.getOffset(x0-dstOut.getSampleModelTranslateX(), y0-dstOut.getSampleModelTranslateY()));
public ZeroRecter_INT_PACK(WritableRaster wr) { super(wr); SinglePixelPackedSampleModel sppsm; sppsm = (SinglePixelPackedSampleModel)wr.getSampleModel(); scanStride = sppsm.getScanlineStride(); DataBufferInt db = (DataBufferInt)wr.getDataBuffer(); x0 = wr.getMinY(); y0 = wr.getMinX(); base = (db.getOffset() + sppsm.getOffset(x0-wr.getSampleModelTranslateX(), y0-wr.getSampleModelTranslateY())); pixels = db.getBankData()[0]; if (wr.getWidth() > 10) zeros = new int[wr.getWidth()]; else zeros = null; }
private static void initImg(BufferedImage img, int pf, int flags) throws Exception { WritableRaster wr = img.getRaster(); int imgType = img.getType(); if(imgType == BufferedImage.TYPE_INT_RGB || imgType == BufferedImage.TYPE_INT_BGR || imgType == BufferedImage.TYPE_INT_ARGB || imgType == BufferedImage.TYPE_INT_ARGB_PRE) { SinglePixelPackedSampleModel sm = (SinglePixelPackedSampleModel)img.getSampleModel(); int pitch = sm.getScanlineStride(); DataBufferInt db = (DataBufferInt)wr.getDataBuffer(); int[] buf = db.getData(); initIntBuf(buf, img.getWidth(), pitch, img.getHeight(), pf, flags); } else { ComponentSampleModel sm = (ComponentSampleModel)img.getSampleModel(); int pitch = sm.getScanlineStride(); DataBufferByte db = (DataBufferByte)wr.getDataBuffer(); byte[] buf = db.getData(); initBuf(buf, img.getWidth(), pitch, img.getHeight(), pf, flags); } }
public static ByteBuffer createImageBuffer(BufferedImage image) { SampleModel model = image.getSampleModel(); Raster raster = image.getRaster(); DataBuffer inBuffer = raster.getDataBuffer(); ByteBuffer outBuffer = ByteBuffer.allocateDirect(image.getWidth() * image.getHeight() * model.getNumBands()); int x = -raster.getSampleModelTranslateX(); int y = -raster.getSampleModelTranslateY(); int step = model.getWidth() * model.getNumBands(); int channels = model.getNumBands(); step = compModel.getScanlineStride(); channels = ((ComponentSampleModel) model).getPixelStride(); step = singleModel.getScanlineStride(); channels = 1; step = multiModel.getScanlineStride(); channels = ((MultiPixelPackedSampleModel) model).getPixelBitStride() / 8; byte[] a = ((DataBufferByte) inBuffer).getData(); copy(ByteBuffer.wrap(a, start, a.length - start), step, outBuffer, step, false); int[] a = ((DataBufferInt) inBuffer).getData(); copy(IntBuffer.wrap(a, start, a.length - start), step, outBuffer.asIntBuffer(), step / 4);
Rectangle rgn = wr.getBounds(); rgn = rgn.intersection(alphaRed.getBounds()); csm = (ComponentSampleModel)r.getSampleModel(); final int alpScanStride = csm.getScanlineStride(); DataBufferByte alpDB = (DataBufferByte)r.getDataBuffer(); final int alpBase = (alpDB.getOffset() + csm.getOffset(rgn.x-r.getSampleModelTranslateX(), rgn.y-r.getSampleModelTranslateY())); final byte[] alpPixels = alpDB.getBankData()[0]; sppsm = (SinglePixelPackedSampleModel)wr.getSampleModel(); final int srcScanStride = sppsm.getScanlineStride(); DataBufferInt srcDB = (DataBufferInt)wr.getDataBuffer(); final int srcBase = (srcDB.getOffset() + sppsm.getOffset(rgn.x-wr.getSampleModelTranslateX(), rgn.y-wr.getSampleModelTranslateY())); final int[] srcPixels = srcDB.getBankData()[0];
Validate.isTrue(src.getTransferType() == DataBuffer.TYPE_BYTE, src, "only TYPE_BYTE rasters supported as src: %s"); Validate.isTrue(src.getNumDataElements() >= 4, src.getNumDataElements(), "CMYK raster must have at least 4 data elements: %s"); dest.getTransferType() == DataBuffer.TYPE_BYTE && dest.getNumDataElements() >= 3 || dest.getTransferType() == DataBuffer.TYPE_INT && dest.getNumDataElements() == 1, src, "only 3 or 4 byte TYPE_BYTE or 1 int TYPE_INT rasters supported as dest: %s" SampleModel sm = dest.getSampleModel(); if (sm instanceof SinglePixelPackedSampleModel) { bitOffsets = ((SinglePixelPackedSampleModel) sm).getBitOffsets();
Any2sRGBRed.is_INT_PACK_COMP(wr.getSampleModel())) { src.copyData(wr); if (srcCM.hasAlpha()) switch (srcSM.getNumBands()) { case 1: matrix = new float[1][3]; Raster srcRas = src.getData(wr.getBounds()); BandCombineOp op = new BandCombineOp(matrix, null); op.filter(srcRas, wr); (dstCM, wr.createWritableTranslatedChild(0,0), dstCM.isAlphaPremultiplied(), null); } else { int [] masks = dstSM.getBitMasks(); SampleModel dstSMNoA = new SinglePixelPackedSampleModel (dstSM.getDataType(), dstSM.getWidth(), dstSM.getHeight(), dstSM.getScanlineStride(), new int[] {masks[0], masks[1], masks[2]}); ColorModel dstCMNoA = GraphicsUtil.Linear_sRGB; dstWr = Raster.createWritableRaster(dstSMNoA, (wrR.width, wrR.height); copyBand(srcWr, srcSM.getNumBands()-1,
public static long getTileSize(SampleModel sm) { int elementSize = DataBuffer.getDataTypeSize(sm.getDataType()); return (mppsm.getScanlineStride() * mppsm.getHeight() + (mppsm.getDataBitOffset() + elementSize -1) / elementSize) * ((elementSize + 7) / 8); } else if (sm instanceof ComponentSampleModel) { ComponentSampleModel csm = (ComponentSampleModel)sm; int[] bandOffsets = csm.getBandOffsets(); int maxBandOff = bandOffsets[0]; for (int i=1; i<bandOffsets.length; i++) int pixelStride = csm.getPixelStride(); int scanlineStride = csm.getScanlineStride(); if (maxBandOff >= 0) size += maxBandOff + 1; if (pixelStride > 0) size += pixelStride * (sm.getWidth() - 1); if (scanlineStride > 0) size += scanlineStride * (sm.getHeight() - 1); int[] bankIndices = csm.getBankIndices(); SinglePixelPackedSampleModel sppsm = (SinglePixelPackedSampleModel)sm; long size = sppsm.getScanlineStride() * (sppsm.getHeight() - 1) + sppsm.getWidth(); return size * ((elementSize + 7) / 8);
alpha = cm.hasAlpha(); else { switch (sm.getNumBands()) { case 1: case 3: alpha = false; return new SinglePixelPackedSampleModel (DataBuffer.TYPE_INT, sm.getWidth(), sm.getHeight(), new int [] {0xFF0000, 0xFF00, 0xFF, 0xFF000000}); else return new SinglePixelPackedSampleModel (DataBuffer.TYPE_INT, sm.getWidth(),
size = new Dimension(defaultSampleModel.getWidth(), defaultSampleModel.getHeight()); dataType = defaultSampleModel.getDataType(); if (model instanceof ComponentSampleModel) { final ComponentSampleModel cast = (ComponentSampleModel) model; final int pixelStride = cast.getPixelStride(); final int scanlineStride = cast.getScanlineStride(); final int[] bankIndices = cast.getBankIndices(); final int[] bandOffsets = cast.getBandOffsets(); if (model instanceof BandedSampleModel) { final MultiPixelPackedSampleModel cast = (MultiPixelPackedSampleModel) model; final int numberOfBits = DataBuffer.getDataTypeSize(dataType); final int scanlineStride = cast.getScanlineStride(); final int dataBitOffset = cast.getDataBitOffset(); model = new MultiPixelPackedSampleModel(dataType, width, height, numberOfBits, scanlineStride, dataBitOffset); } else if (model instanceof SinglePixelPackedSampleModel) { final SinglePixelPackedSampleModel cast = (SinglePixelPackedSampleModel) model; final int scanlineStride = cast.getScanlineStride(); final int[] bitMasks = cast.getBitMasks(); model = new SinglePixelPackedSampleModel(dataType, width, height, scanlineStride, bitMasks); } else {
public RasterIntABGRProvider(Raster raster, boolean hasAlpha) { super(raster, 8, raster.getWidth() * (hasAlpha ? 4 : 3)); this.pixels = ((DataBufferInt) raster.getDataBuffer()).getData(); this.hasAlpha = hasAlpha; if (hasAlpha) { bgrOrder = false; } else { int[] offsets = ((SinglePixelPackedSampleModel) raster.getSampleModel()).getBitOffsets(); bgrOrder = offsets[0] != 0; } }
private void checkCompatible(SampleModel model){ // Check model is ok: should be SinglePixelPackedSampleModel if(!(model instanceof SinglePixelPackedSampleModel)) throw new IllegalArgumentException ("MorphologyOp only works with Rasters " + "using SinglePixelPackedSampleModels"); // Check number of bands int nBands = model.getNumBands(); if(nBands!=4) throw new IllegalArgumentException ("MorphologyOp only words with Rasters having 4 bands"); // Check that integer packed. if(model.getDataType()!=DataBuffer.TYPE_INT) throw new IllegalArgumentException ("MorphologyOp only works with Rasters using DataBufferInt"); // Check bit masks int[] bitOffsets=((SinglePixelPackedSampleModel)model).getBitOffsets(); for(int i=0; i<bitOffsets.length; i++){ if(bitOffsets[i]%8 != 0) throw new IllegalArgumentException ("MorphologyOp only works with Rasters using 8 bits " + "per band : " + i + " : " + bitOffsets[i]); } }
/** * Returns a width- and height-aligned image representation sharing data w/ {@link #image}. * @param width * @param height * @return * @throws IllegalArgumentException if requested size exceeds image size */ public BufferedImage getAlignedImage(final int width, final int height) throws IllegalArgumentException { if( width * height > image.getWidth() * image.getHeight() ) { throw new IllegalArgumentException("Requested size exceeds image size: "+width+"x"+height+" > "+image.getWidth()+"x"+image.getHeight()); } if( width == image.getWidth() && height == image.getHeight() ) { return image; } else { final ColorModel cm = image.getColorModel(); final WritableRaster raster0 = image.getRaster(); final DataBuffer dataBuffer = raster0.getDataBuffer(); final SinglePixelPackedSampleModel sppsm0 = (SinglePixelPackedSampleModel) raster0.getSampleModel(); final SinglePixelPackedSampleModel sppsm1 = new SinglePixelPackedSampleModel(dataBuffer.getDataType(), width, height, width /* scanLineStride */, sppsm0.getBitMasks()); final WritableRaster raster1 = Raster.createWritableRaster(sppsm1, dataBuffer, null); return new BufferedImage (cm, raster1, cm.isAlphaPremultiplied(), null); } }
int numBands = sampleModel.getNumBands(); int pixelSize = computePixelSize(sampleModel); int[] bitOffsets; if (sampleModel instanceof ComponentSampleModel) { bandOffsets = ((ComponentSampleModel) sampleModel).getBandOffsets(); bitOffsets = null; bitOffsets = ((SinglePixelPackedSampleModel) sampleModel).getBitOffsets(); bandOffsets = null; entries.put(TIFF.TAG_IMAGE_HEIGHT, new TIFFEntry(TIFF.TAG_IMAGE_HEIGHT, renderedImage.getHeight())); entries.put(TIFF.TAG_ORIENTATION, new TIFFEntry(TIFF.TAG_ORIENTATION, 1)); // (optional) entries.put(TIFF.TAG_BITS_PER_SAMPLE, new TIFFEntry(TIFF.TAG_BITS_PER_SAMPLE, asShortArray(sampleModel.getSampleSize()))); entries.put(TIFF.TAG_COLOR_MAP, new TIFFEntry(TIFF.TAG_COLOR_MAP, createColorMap((IndexColorModel) colorModel, sampleModel.getSampleSize(0)))); entries.put(TIFF.TAG_SAMPLES_PER_PIXEL, new TIFFEntry(TIFF.TAG_SAMPLES_PER_PIXEL, 1));
public static boolean is_INT_PACK_COMP(SampleModel sm) { if(!(sm instanceof SinglePixelPackedSampleModel)) return false; // Check transfer types if(sm.getDataType() != DataBuffer.TYPE_INT) return false; SinglePixelPackedSampleModel sppsm; sppsm = (SinglePixelPackedSampleModel)sm; int [] masks = sppsm.getBitMasks(); if ((masks.length != 3) && (masks.length != 4)) return false; if(masks[0] != 0x00ff0000) return false; if(masks[1] != 0x0000ff00) return false; if(masks[2] != 0x000000ff) return false; if ((masks.length == 4) && (masks[3] != 0xff000000)) return false; return true; }
bldr.setPixelStride(sm.getPixelStride()); bldr.setScanlineStride(sm.getScanlineStride()); if (sampleModelType != TYPE_PIXEL_INTERLEAVED) { bldr.addAllBankIndices(Ints.asList(sm.getBankIndices())); final SinglePixelPackedSampleModel sm = (SinglePixelPackedSampleModel) sampleModel; bldr.setModelType(TYPE_SINGLE_PIXEL_PACKED); bldr.setScanlineStride(sm.getScanlineStride()); bldr.addAllBitMasks(Ints.asList(sm.getBitMasks())); } else if (sampleModel instanceof MultiPixelPackedSampleModel) { final MultiPixelPackedSampleModel sm = (MultiPixelPackedSampleModel) sampleModel; bldr.setModelType(TYPE_MULTI_PIXEL_PACKED); bldr.setPixelBitStride(sm.getPixelBitStride()); bldr.setScanlineStride(sm.getScanlineStride()); bldr.setDataBitOffset(sm.getDataBitOffset()); } else { throw new RuntimeException("Unsupported SampleModel type for serialization " + sampleModel); bldr.setTransferType(sampleModel.getTransferType()); bldr.setWidth(sampleModel.getWidth()); bldr.setHeight(sampleModel.getHeight()); return bldr.build().toByteArray();
public boolean is_INT_PACK_BYTE_COMP(SampleModel srcSM, SampleModel alpSM) { // Check SampleModel types DirectColorModel if(!(srcSM instanceof SinglePixelPackedSampleModel)) return false; if(!(alpSM instanceof ComponentSampleModel)) return false; // Check transfer types if(srcSM.getDataType() != DataBuffer.TYPE_INT) return false; if(alpSM.getDataType() != DataBuffer.TYPE_BYTE) return false; SinglePixelPackedSampleModel sppsm; sppsm = (SinglePixelPackedSampleModel)srcSM; int [] masks = sppsm.getBitMasks(); if(masks.length != 4) return false; if(masks[0] != 0x00ff0000) return false; if(masks[1] != 0x0000ff00) return false; if(masks[2] != 0x000000ff) return false; if(masks[3] != 0xff000000) return false; ComponentSampleModel csm; csm = (ComponentSampleModel)alpSM; if (csm.getNumBands() != 1) return false; if (csm.getPixelStride() != 1) return false; return true; }