private static BufferedImage rgbaToIndexedBufferedImage(final BufferedImage sourceBufferedImage) { final BufferedImage indexedImage = new BufferedImage( sourceBufferedImage.getWidth(), sourceBufferedImage.getHeight(), BufferedImage.TYPE_BYTE_INDEXED); final ColorModel cm = indexedImage.getColorModel(); final IndexColorModel icm = (IndexColorModel) cm; final int size = icm.getMapSize(); final byte[] reds = new byte[size]; final byte[] greens = new byte[size]; final byte[] blues = new byte[size]; icm.getReds(reds); icm.getGreens(greens); icm.getBlues(blues); final WritableRaster raster = indexedImage.getRaster(); final int pixel = raster.getSample(0, 0, 0); final IndexColorModel resultIcm = new IndexColorModel(8, size, reds, greens, blues, pixel); final BufferedImage resultIndexedImage = new BufferedImage(resultIcm, raster, sourceBufferedImage.isAlphaPremultiplied(), null); resultIndexedImage.getGraphics().drawImage(sourceBufferedImage, 0, 0, null); return resultIndexedImage; }
for ( int y = 0; y < data.height; y++ ) { for ( int x = 0; x < data.width; x++ ) { raster.getPixel( x, y, pixelArray ); int pixel = palette.getPixel( new RGB( pixelArray[0], pixelArray[1], pixelArray[2] ) ); data.setPixel( x, y, pixel ); int size = colorModel.getMapSize(); byte[] reds = new byte[size]; byte[] greens = new byte[size]; byte[] blues = new byte[size]; colorModel.getReds( reds ); colorModel.getGreens( greens ); colorModel.getBlues( blues ); RGB[] rgbs = new RGB[size]; for ( int i = 0; i < rgbs.length; i++ ) { new ImageData( bufferedImage.getWidth(), bufferedImage.getHeight(), colorModel.getPixelSize(), palette ); data.transparentPixel = colorModel.getTransparentPixel(); for ( int y = 0; y < data.height; y++ ) { for ( int x = 0; x < data.width; x++ ) { raster.getPixel( x, y, pixelArray ); data.setPixel( x, y, pixelArray[0] );
/** * Extract the palette from an {@link IndexColorModel}. * * @param indexColorModel * @return */ public static byte[][] extractPalette(IndexColorModel indexColorModel) { Utilities.ensureNonNull("indexColorModel", indexColorModel); byte[][] palette = new byte[3][indexColorModel.getMapSize()]; int numBands = indexColorModel.getNumColorComponents(); indexColorModel.getReds(palette[0]); indexColorModel.getGreens(palette[0]); indexColorModel.getBlues(palette[0]); if (numBands == 4) { indexColorModel.getAlphas(palette[0]); } return palette; }
private static IndexedSprite createIndexedSprite(final Client client, final BufferedImage bufferedImage) { final IndexColorModel indexedCM = (IndexColorModel) bufferedImage.getColorModel(); final int width = bufferedImage.getWidth(); final int height = bufferedImage.getHeight(); final byte[] pixels = ((DataBufferByte) bufferedImage.getRaster().getDataBuffer()).getData(); final int[] palette = new int[indexedCM.getMapSize()]; indexedCM.getRGBs(palette); final IndexedSprite newIndexedSprite = client.createIndexedSprite(); newIndexedSprite.setPixels(pixels); newIndexedSprite.setPalette(palette); newIndexedSprite.setWidth(width); newIndexedSprite.setHeight(height); newIndexedSprite.setOriginalWidth(width); newIndexedSprite.setOriginalHeight(height); newIndexedSprite.setOffsetX(0); newIndexedSprite.setOffsetY(0); return newIndexedSprite; }
void writeImageWithTransparency(ImagePlus imp, String path, int transparentIndex) throws Exception { int width = imp.getWidth(); int height = imp.getHeight(); ImageProcessor ip = imp.getProcessor(); IndexColorModel cm = (IndexColorModel)ip.getColorModel(); int size = cm.getMapSize(); byte[] reds = new byte[256]; byte[] greens = new byte[256]; byte[] blues = new byte[256]; cm.getReds(reds); cm.getGreens(greens); cm.getBlues(blues); cm = new IndexColorModel(8, 256, reds, greens, blues, transparentIndex); WritableRaster wr = cm.createCompatibleWritableRaster(width, height); DataBufferByte db = (DataBufferByte)wr.getDataBuffer(); byte[] biPixels = db.getData(); System.arraycopy(ip.getPixels(), 0, biPixels, 0, biPixels.length); BufferedImage bi = new BufferedImage(cm, wr, false, null); ImageIO.write(bi, "png", new File(path)); }
public BufferedImage filter(BufferedImage src, BufferedImage dest) { if (dest == null) dest = new BufferedImage( src.getWidth(), src.getHeight(), BufferedImage.TYPE_BYTE_INDEXED, icm); else { if (!(dest.getColorModel() instanceof IndexColorModel) || ((IndexColorModel) dest.getColorModel()).getTransparency() != this.transparencyIndex) throw new IllegalArgumentException(); if (((IndexColorModel) dest.getColorModel()).getTransparentPixel() != this.transparencyIndex) throw new IllegalArgumentException(); } final WritableRaster wr = dest.getRaster(); final Raster ir = src.getRaster(); this.rasterOp.filter(ir, wr); return dest; }
private void init( final int width, final int height, final int lineLength, final int bufferSize) { this.SCREEN_WIDTH = width; this.SCREEN_HEIGHT = height; this.LINE_LEN = lineLength; this.BUFFER_SIZE = bufferSize; if (Files.notExists(Paths.get(FB_PATH))) { throw new RuntimeException("Device path not found: " + FB_PATH); } byte[] data = new byte[bufferSize]; byte[] bwarr = {(byte) 0xff, (byte) 0x00}; IndexColorModel bwcm = new IndexColorModel(1, bwarr.length, bwarr, bwarr, bwarr); DataBuffer db = new DataBufferByte(data, data.length); WritableRaster wr = Raster.createPackedRaster(db, SCREEN_WIDTH, SCREEN_HEIGHT, 1, null); this.image = new BufferedImage(bwcm, wr, false, null); this.g2d = (Graphics2D) image.getGraphics(); g2d.setColor(Color.WHITE); g2d.fillRect(0, 0, image.getWidth(), image.getHeight()); this.refresh(); }
private static Paint create8x8Pattern(final byte[] pPattern, Color fg, Color bg) { switch (isSolid(pPattern)) { case 0: // 0x00 return bg; case -1: // 0xff return fg; default: // Fall through } WritableRaster raster = Raster.createPackedRaster(new DataBufferByte(pPattern, 8), 8, 8, 1, new Point()); IndexColorModel cm = new IndexColorModel(1, 2, new int[] {bg.getRGB(), fg.getRGB()}, 0, false, -1, DataBuffer.TYPE_BYTE); BufferedImage img = new BufferedImage(cm, raster, false, null); return new TexturePaint(img, new Rectangle(8, 8)); }
ImageTypeSpecifier rawType = getRawImageType(imageIndex); if (rawType.getColorModel() instanceof IndexColorModel && rawType.getBufferedImageType() != image.getType()) { checkReadParamBandSettings(param, 4, image.getSampleModel().getNumBands()); checkReadParamBandSettings(param, rawType.getNumBands(), image.getSampleModel().getNumBands()); DataBufferByte buffer = new DataBufferByte(data, data.length / 2, 0); WritableRaster raster = Raster.createPackedRaster(buffer, width, height, resource.depth(), null); if (image.getType() == rawType.getBufferedImageType() && ((IndexColorModel) image.getColorModel()).getMapSize() == 2) { image.setData(raster); DataBufferByte maskBuffer = new DataBufferByte(data, data.length / 2, data.length / 2); WritableRaster mask = Raster.createPackedRaster(maskBuffer, width, height, resource.depth(), null); Graphics2D graphics = image.createGraphics(); DataBufferByte buffer = new DataBufferByte(data, data.length); WritableRaster raster = Raster.createPackedRaster(buffer, width, height, resource.depth(), null); if (image.getType() == rawType.getBufferedImageType()) { image.getAlphaRaster().setRect(mask); image.getAlphaRaster().setRect(mask);
while ((colors.size() - 1) >> bitCount != 0) bitCount *= 2; IndexColorModel cm = new IndexColorModel(bitCount, colors.size(), cmap, 0, DataBuffer.TYPE_BYTE, null); BufferedImage dest = new BufferedImage(this.getWidth(), this.getHeight(), cm.getPixelSize() < 8 ? BufferedImage.TYPE_BYTE_BINARY : BufferedImage.TYPE_BYTE_INDEXED, cm); dest.createGraphics().drawImage(this.getImage(), 0, 0, null); return dest;
private void assertSimilarImageTransparent(final BufferedImage pExpected, final BufferedImage pActual, final float pArtifactThreshold) { IndexColorModel icm = pActual.getColorModel() instanceof IndexColorModel ? (IndexColorModel) pActual.getColorModel() : null; Object pixel = null; for (int y = 0; y < pExpected.getHeight(); y++) { for (int x = 0; x < pExpected.getWidth(); x++) { int expected = pExpected.getRGB(x, y); int expectedLookedUp = icm.getRGB(icm.getTransparentPixel()); assertRGBEquals(x, y, expectedLookedUp & 0xff000000, actual & 0xff000000, 0); pixel = icm.getDataElements(expected, pixel); int expectedLookedUp = icm.getRGB(pixel); assertRGBEquals(x, y, expectedLookedUp & 0xffffff, actual & 0xffffff, pArtifactThreshold);
mainRaster.setSamples(0, 0, origW, origH, 0, data); final ColorModel binaryCM = new IndexColorModel(1, 2, x00FF, x00FF, x00FF); BufferedImage mainBI = new BufferedImage(binaryCM, mainRaster, false, null); Graphics2D graphics = mainBI.createGraphics(); mainRaster.setDataElements(col * tileWidth, row * tileHeight, tileRaster); } else {
@Test public void testPng8Opaque() throws Exception { MockHttpServletResponse response = getAsServletResponse( "wms?bbox=" + bbox + "&styles=&layers=" + layers + "&Format=image/png8" + "&request=GetMap" + "&width=550" + "&height=250" + "&srs=EPSG:4326"); assertEquals("image/png; mode=8bit", response.getContentType()); InputStream is = getBinaryInputStream(response); BufferedImage bi = ImageIO.read(is); IndexColorModel cm = (IndexColorModel) bi.getColorModel(); assertEquals(Transparency.OPAQUE, cm.getTransparency()); assertEquals(-1, cm.getTransparentPixel()); }
private static IndexColorModel readPalette() { try { // Read the DK II palette image BufferedImage paletteImage = ImageIO.read(new File(ConversionUtils.getRealFileName(AssetsConverter.getAssetsFolder(), PALETTE_IMAGE))); // The palette image is generally an image where 1 column represents one color, column width is 1px // We know that is is 64x16, but just play along with "dynamic" (we'll fail if it is over 256) byte[] r = new byte[paletteImage.getWidth()]; byte[] g = new byte[paletteImage.getWidth()]; byte[] b = new byte[paletteImage.getWidth()]; for (int x = 0; x < paletteImage.getWidth(); x++) { int color = paletteImage.getRGB(x, 0); r[x] = (byte) ((color & 0xff0000) >> 16); g[x] = (byte) ((color & 0xff00) >> 8); b[x] = (byte) (color & 0xff); } // Create the actual palette return new IndexColorModel(8, paletteImage.getWidth(), r, g, b); } catch (Exception e) { logger.log(Level.WARNING, "Failed to create the map thumbnail palette!", e); // TODO: Create a random palette here? throw new RuntimeException("Failed to create the map thumbnail palette!", e); } }
BufferedImage createPaletteImage(final BMHDChunk header, boolean isEHB) throws IIOException { // Create a 1 x colors.length image IndexColorModel cm = getIndexColorModel(header, isEHB); WritableRaster raster = cm.createCompatibleWritableRaster(cm.getMapSize(), 1); byte[] pixel = null; for (int x = 0; x < cm.getMapSize(); x++) { pixel = (byte[]) cm.getDataElements(cm.getRGB(x), pixel); raster.setDataElements(x, 0, pixel); } return new BufferedImage(cm, raster, cm.isAlphaPremultiplied(), null); }
@Test public void testTranslatedImage() throws Exception { BufferedImage bi = new BufferedImage(256, 256, BufferedImage.TYPE_BYTE_GRAY); TiledImage image = new TiledImage(0, 0, 256, 256, 1, 1, bi.getSampleModel() .createCompatibleSampleModel(256, 256), bi.getColorModel()); Graphics g = image.createGraphics(); g.setColor(Color.WHITE); g.fillRect(0, 0, 20, 20); g.setColor(new Color(20, 20, 20)); // A dark gray g.fillRect(20, 20, 20, 20); g.setColor(new Color(200, 200, 200)); // A light gray g.fillRect(0, 20, 20, 20); g.dispose(); RenderedImage indexed = quantize(image); assertTrue(indexed.getColorModel() instanceof IndexColorModel); IndexColorModel icm = (IndexColorModel) indexed.getColorModel(); assertEquals(4, icm.getMapSize()); // Black background, white fill, // light gray fill, dark gray fill = // 4 colors }
public BufferedImage createImageIndexed() { // TODO: This is very stupid, maybe we need a TYPE_CUSTOM image, with separate alphaRaster?! // As ICO has a separate bitmask, not related to palette index (allows 256 colors + trans) :-P IndexColorModel icm = createColorModel(); // This is slightly obscure, and should probably be moved.. Hashtable<String, Object> properties = null; if (entry instanceof DirectoryEntry.CUREntry) { properties = new Hashtable<>(1); properties.put("cursor_hotspot", ((DirectoryEntry.CUREntry) this.entry).getHotspot()); } BufferedImage image = new BufferedImage( icm, icm.createCompatibleWritableRaster(getWidth(), getHeight()), icm.isAlphaPremultiplied(), properties ); WritableRaster raster = image.getRaster(); // Make pixels transparent according to mask final int trans = icm.getTransparentPixel(); for (int y = 0; y < getHeight(); y++) { for (int x = 0; x < getWidth(); x++) { if (mask.isTransparent(x, y)) { bits[x + getWidth() * y] = trans; } } } raster.setSamples(0, 0, getWidth(), getHeight(), 0, bits); return image; }
public TestImage(byte data[], int w, int h, int scanlineStride) { super("Demobild"); // Color-Model sagt: bit = 0 -> schwarz, bit = 1 -> weiss. Ggf. umdrehen. ColorModel colorModel = new IndexColorModel(1, 2, new byte[]{ (byte) 0xff, 0x00 }, new byte[]{ (byte) 0xff, 0x00 }, new byte[]{ (byte) 0xff, 0x00 }); DataBuffer dataBuffer = new DataBufferByte(data, data.length); SampleModel sampleModel = new MultiPixelPackedSampleModel(DataBuffer.TYPE_BYTE, w, h, 1, scanlineStride, 0); WritableRaster writableRaster = Raster.createWritableRaster(sampleModel, dataBuffer, new Point(0, 0)); BufferedImage image = new BufferedImage(colorModel, writableRaster, false, null); ImageComponent imageComponent = new ImageComponent(image); // imageComponent.setScale(4); JScrollPane sp = new JScrollPane(imageComponent); setContentPane(sp); pack(); setSize(new Dimension(1600, 900)); setVisible(true); try { System.in.read(); } catch (IOException e) { // TODO Auto-generated catch block e.printStackTrace(); } }
ColorModel colorModel = image.getColorModel(); byte[] reds = new byte[index.getMapSize()]; byte[] greens = new byte[index.getMapSize()]; byte[] blues = new byte[index.getMapSize()]; byte[] alphas = new byte[index.getMapSize()]; index.getReds(reds); index.getGreens(greens); index.getBlues(blues); index.getAlphas(alphas); final int transparentPixel = index.getTransparentPixel(); for (int i = 0; i < alphas.length; i++) { alphas[i] = (byte) Math.round((0xFF & alphas[i]) * opacity); new IndexColorModel( index.getPixelSize(), index.getMapSize(), reds, greens, blues, alphas); LookupTable table = buildOpacityLookupTable(0, 1, -1, image.getSampleModel().getDataType()); ImageLayout layout = new ImageLayout(image); layout.setColorModel(newColorModel); if (!expanded.getColorModel().hasAlpha()) { final int bands = expanded.getSampleModel().getNumBands(); int alphaBand = bands - 1;
private BufferedImage decodeSingleBitGrayscaleImage(DataBuffer buffer) { WritableRaster raster = Raster.createPackedRaster(buffer, width, height, 1, new Point(0, 0)); return new BufferedImage( new IndexColorModel( 1, 2, new byte[] {(byte) 0xff, 0}, new byte[] {(byte) 0xff, 0}, new byte[] {(byte) 0xff, 0}), raster, false, null); }