Question

文档说：

public void setPixel(int x,int y,int[] iArray)

如果我正在制作一个类型的缓冲图像：

BufferedImage(width, height, BufferedImage.TYPE_INT_RGB);

INT阵列的那4个字节的映射是什么？我尝试了0xff0000，0x00ff0000等所有组合，并且无法获得任何颜色。

是否存在所有其他类型的地图图表，例如INT_ARGB，BYTE_BINARY等等？

Answer 1

您的int[]应包含0xFF0000（红色），0x00FF00（绿色），0x0000FF（蓝色）等值...

这是一个可以生成各种颜色的3x3像素图像的例子。

您可能需要根据图像类型添加对波段蒙版的更多支持。

PixelWriterApp

import java.awt.Image;
import java.awt.image.*;
import java.io.*;
import java.nio.file.Paths;
import javax.imageio.ImageIO;

public class PixelWriterApp {
    public static int[] pixelData = {
        0xFF0000,  0xFF7F00,  0xFFFF00,
        0x00FF00,  0x00FF7F,  0x00FFFF,
        0x0000FF,  0x7F00FF,  0xFF00FF
    };

    public static void main(String[] args) {
        int cols = 3;
        int rows = pixelData.length / cols;
        int scaleX = 100;
        int scaleY = 100;
        int width = cols * scaleX;
        int height = rows * scaleY;
        int[] stretched = ArrayUtils.stretch(pixelData, cols, scaleX, scaleY);
        String directory = System.getProperty("user.home");
        String filename = "MyImage.png";
        String filepath = Paths.get(directory, filename).toString();
        int imageType = BufferedImage.TYPE_INT_RGB;
        Image image = PixelWriter.getImageFromArray(stretched, width, height, imageType);

        writeImage(image, filepath, "png");
    }

    public static void writeImage(Image image, String filename, String ext) {
        try {
            ImageIO.write((RenderedImage) image, ext, new File(filename));
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

PixelWriter

import java.awt.Image;
import java.awt.image.BufferedImage;
import java.awt.image.DataBufferInt;
import java.awt.image.Raster;
import java.awt.image.WritableRaster;
import java.util.Arrays;

public class PixelWriter {
    private static final int[] BAND_COUNT_3 = { 0xFF0000, 0xFF00, 0xFF };
    private static final int[] BAND_COUNT_4 = { 0xFF0000, 0xFF00, 0xFF, 0xFF000000 };

    // See note about ARGB bands http://stackoverflow.com/a/25184537
    protected static int[] lookupBandMask(int imageType) throws IllegalArgumentException {
        switch (imageType) {
            case BufferedImage.TYPE_INT_RGB:
            case BufferedImage.TYPE_INT_BGR:
                return Arrays.copyOf(BAND_COUNT_3, BAND_COUNT_3.length);
            case BufferedImage.TYPE_INT_ARGB:
                return Arrays.copyOf(BAND_COUNT_4, BAND_COUNT_4.length);
        }
        throw new IllegalArgumentException("Unsupported BufferedImage type");
    }

    public static Image getImageFromArray(int[] pixels, int width, int height, int imageType) {
        int[] bandMasks = lookupBandMask(imageType);
        BufferedImage image = new BufferedImage(width, height, imageType);
        DataBufferInt buffer = new DataBufferInt(pixels, pixels.length);
        WritableRaster raster = Raster.createPackedRaster(buffer, width, height, width, bandMasks, null);
        image.setData(raster);
        return image;
    }
}

ArrayUtils

public class ArrayUtils {
    // Source: http://stackoverflow.com/a/16556564
    public static int[][] stretch(int[][] arr, int cfactor, int rfactor) {
        int rows = arr.length * rfactor;
        int cols = arr[0].length * cfactor;
        int[][] result = new int[rows][cols];
        for (int r = 0; r < rows; r++) {
            for (int c = 0; c < cols; c++) {
                result[r][c] = arr[r / rfactor][c / cfactor];
            }
        }
        return result;
    }

    public static int[] stretch(int[] arr, int cols, int cfactor, int rfactor) {
        int rows = arr.length / cols;
        int width = cols * cfactor;
        int height = rows * rfactor;
        int[] result = new int[width * height];
        for (int y = 0; y < height; y++) {
            for (int x = 0; x < width; x++) {
                result[(y * height) + x] = arr[((y / rfactor) * rows) + (x / cfactor)];
            }
        }
        return result;
    }
}

结果

以下是文档中的所有缓冲图像类型。

TYPE_CUSTOM = 0;
TYPE_INT_RGB = 1;
TYPE_INT_ARGB = 2;
TYPE_INT_ARGB_PRE = 3;
TYPE_INT_BGR = 4;
TYPE_3BYTE_BGR = 5;
TYPE_4BYTE_ABGR = 6;
TYPE_4BYTE_ABGR_PRE = 7;
TYPE_USHORT_565_RGB = 8;
TYPE_USHORT_555_RGB = 9;
TYPE_BYTE_GRAY = 10;
TYPE_USHORT_GRAY = 11;
TYPE_BYTE_BINARY = 12;
TYPE_BYTE_INDEXED = 13;

通过GrepCode: JDK / jdk / openjdk / 8u40-b25 / java.awt.image.BufferedImage

// Image type is not recognized so it must be a customized image. This type is only used as a return value for the getType() method.
public static final int TYPE_CUSTOM = 0;

// Represents an image with 8-bit RGB color components packed into integer pixels. The image has a DirectColorModel without alpha. When data with non-opaque alpha is stored in an image of this type, the color data must be adjusted to a non-premultiplied form and the alpha discarded, as described in the java.awt.AlphaComposite documentation.
public static final int TYPE_INT_RGB = 1;

// Represents an image with 8-bit RGBA color components packed into integer pixels. The image has a DirectColorModel with alpha. The color data in this image is considered not to be premultiplied with alpha. When this type is used as the imageType argument to a BufferedImage constructor, the created image is consistent with images created in the JDK1.1 and earlier releases.
public static final int TYPE_INT_ARGB = 2;

// Represents an image with 8-bit RGBA color components packed into integer pixels. The image has a DirectColorModel with alpha. The color data in this image is considered to be premultiplied with alpha.
public static final int TYPE_INT_ARGB_PRE = 3;

// Represents an image with 8-bit RGB color components, corresponding to a Windows- or Solaris- style BGR color model, with the colors Blue, Green, and Red packed into integer pixels. There is no alpha. The image has a DirectColorModel. When data with non-opaque alpha is stored in an image of this type, the color data must be adjusted to a non-premultiplied form and the alpha discarded, as described in the java.awt.AlphaComposite documentation.
public static final int TYPE_INT_BGR = 4;

// Represents an image with 8-bit RGB color components, corresponding to a Windows-style BGR color model) with the colors Blue, Green, and Red stored in 3 bytes. There is no alpha. The image has a ComponentColorModel. When data with non-opaque alpha is stored in an image of this type, the color data must be adjusted to a non-premultiplied form and the alpha discarded, as described in the java.awt.AlphaComposite documentation.
public static final int TYPE_3BYTE_BGR = 5;

// Represents an image with 8-bit RGBA color components with the colors Blue, Green, and Red stored in 3 bytes and 1 byte of alpha. The image has a ComponentColorModel with alpha. The color data in this image is considered not to be premultiplied with alpha. The byte data is interleaved in a single byte array in the order A, B, G, R from lower to higher byte addresses within each pixel.
public static final int TYPE_4BYTE_ABGR = 6;

// Represents an image with 8-bit RGBA color components with the colors Blue, Green, and Red stored in 3 bytes and 1 byte of alpha. The image has a ComponentColorModel with alpha. The color data in this image is considered to be premultiplied with alpha. The byte data is interleaved in a single byte array in the order A, B, G, R from lower to higher byte addresses within each pixel.
public static final int TYPE_4BYTE_ABGR_PRE = 7;

// Represents an image with 5-6-5 RGB color components (5-bits red, 6-bits green, 5-bits blue) with no alpha. This image has a DirectColorModel. When data with non-opaque alpha is stored in an image of this type, the color data must be adjusted to a non-premultiplied form and the alpha discarded, as described in the java.awt.AlphaComposite documentation.
public static final int TYPE_USHORT_565_RGB = 8;

// Represents an image with 5-5-5 RGB color components (5-bits red, 5-bits green, 5-bits blue) with no alpha. This image has a DirectColorModel. When data with non-opaque alpha is stored in an image of this type, the color data must be adjusted to a non-premultiplied form and the alpha discarded, as described in the java.awt.AlphaComposite documentation.
public static final int TYPE_USHORT_555_RGB = 9;

// Represents a unsigned byte grayscale image, non-indexed. This image has a ComponentColorModel with a CS_GRAY java.awt.color.ColorSpace. When data with non-opaque alpha is stored in an image of this type, the color data must be adjusted to a non-premultiplied form and the alpha discarded, as described in the java.awt.AlphaComposite documentation.
public static final int TYPE_BYTE_GRAY = 10;

// Represents an unsigned short grayscale image, non-indexed). This image has a ComponentColorModel with a CS_GRAY ColorSpace. When data with non-opaque alpha is stored in an image of this type, the color data must be adjusted to a non-premultiplied form and the alpha discarded, as described in the java.awt.AlphaComposite documentation.
public static final int TYPE_USHORT_GRAY = 11;

// Represents an opaque byte-packed 1, 2, or 4 bit image. The image has an IndexColorModel without alpha. When this type is used as the imageType argument to the BufferedImage constructor that takes an imageType argument but no ColorModel argument, a 1-bit image is created with an IndexColorModel with two colors in the default sRGB ColorSpace: {0, 0, 0} and {255, 255, 255}. Images with 2 or 4 bits per pixel may be constructed via the BufferedImage constructor that takes a ColorModel argument by supplying a ColorModel with an appropriate map size. Images with 8 bits per pixel should use the image types TYPE_BYTE_INDEXED or TYPE_BYTE_GRAY depending on their ColorModel. When color data is stored in an image of this type, the closest color in the colormap is determined by the IndexColorModel and the resulting index is stored. Approximation and loss of alpha or color components can result, depending on the colors in the IndexColorModel colormap.
public static final int TYPE_BYTE_BINARY = 12;

// Represents an indexed byte image. When this type is used as the imageType argument to the BufferedImage constructor that takes an imageType argument but no ColorModel argument, an IndexColorModel is created with a 256-color 6/6/6 color cube palette with the rest of the colors from 216-255 populated by grayscale values in the default sRGB ColorSpace. When color data is stored in an image of this type, the closest color in the colormap is determined by the IndexColorModel and the resulting index is stored. Approximation and loss of alpha or color components can result, depending on the colors in the IndexColorModel colormap.
public static final int TYPE_BYTE_INDEXED = 13;

Answer 2

很奇怪，但这似乎是一个解决方案。

import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.image.BufferedImage;
import java.awt.image.WritableRaster;
import javax.swing.JFrame;
import javax.swing.JPanel;


public class ImageTesting2 extends JPanel{
    static  final int dim=20;
    static  int[] pixels = new int[dim*dim*4];
    BufferedImage image;

    public static void main(String[] args){

        ImageTesting2 tester = new ImageTesting2(); 
        tester.fillMatrix();
        JFrame frame = new JFrame();
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        frame.setBounds(100, 100, 500, 500);
        frame.setVisible(true);
        frame.add(tester);
    }

     public void fillMatrix(){
            for(int i =0 ; i <pixels.length ; i=i+4){
               pixels[i] =255;     // red component
               pixels[i+1] = 0;    // green component
               pixels[i+2] = 255;  // blue component
               pixels[i+3] = 70;   // alpha component
            }

        image = new BufferedImage(dim, dim, BufferedImage.TYPE_INT_ARGB);          
        WritableRaster raster =  image.getRaster();
        raster.setPixels(0,0,dim,dim,pixels);

   }     

    @Override
    public void paintComponent(Graphics g) {
           Graphics2D g2 = (Graphics2D) g;
           g2.drawImage(image, 50, 50, this);
    }  


}

如何为setPixels准备一个数组？

2 个答案:

PixelWriterApp

PixelWriter

ArrayUtils

结果