如何仅使用 java.io.* 在 java 中将颜色转换为灰度；图书馆？

Question

嗯，我得到了这个.. 因为在我的地方他们这样要求它.. 嗯，我有这个： //一些变量和注释是可能的代码..但我的意思是我不知道该怎么做，我在互联网上发现转换R是字节在* 0.21中，G是* 0.71，我猜是蓝色是 * 0.07。我只能使用那个库 java.io.*;我正在使用 1024 x 768 的 BMP 格式图像，如果你能帮助我，或者你想让我更具体，请告诉我。我不知道我是否必须添加其他变量或取出一些变量或修改，请帮助我。我对这门语言不是很陌生，但我不是专家。代码就在这里：

导入 java.io.*;

公共类灰度{

FileInputStream image;
FileOutputStream img;
byte[] datos;
int i;
int cont;

public Grayscale(String nombre)throws Exception{

    this.image = new FileInputStream(nombre);
    this.img = img;
    this.datos = new byte[image.available()];
    this.i = 54;
    this.cont = 1;
}

public void gray()throws Exception{

    image.read(datos);
    img = new FileOutputStream("grayscale.bmp");

    while(i<datos.length){
        if(cont == 1){
            datos[i] = datos[i] ;//* 0.21;
            cont++;
        } else if(cont == 2){
            datos[i] = datos [i] ;//* 0.71;
            cont++;
        } else if(cont == 3){
            datos[i] = datos[i] ;//* 0.07;
            cont++;
        }else{
            cont = 1;
        }
        i++;
    }
    img.write(datos);
}

}

Answer 1

大多数图像格式在像素数据之前都有标题信息，所以当您阅读这些类型的文件时，您需要考虑到这一点...

坦率地说，尽可能依赖预先存在的库要容易得多。

ImageIO 允许您读写多种不同的文件格式，包括 BMP。

看看

• Reading/Loading an Image
• Writing/Saving an Image

下一个决定是 - 您自己转换图像还是使用预先存在的过滤器。你必须做一些你自己的指标，但在过去，我发现图像的像素处理很慢，至少比内置过滤器慢......

原始、手动灰度、自动/过滤灰度

import java.awt.Color;
import java.awt.Dimension;
import java.awt.EventQueue;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.GridLayout;
import java.awt.color.ColorSpace;
import java.awt.image.BufferedImage;
import java.awt.image.ColorConvertOp;
import java.io.File;
import java.io.IOException;
import java.util.logging.Level;
import java.util.logging.Logger;
import javax.imageio.ImageIO;
import javax.swing.ImageIcon;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JPanel;
import javax.swing.UIManager;
import javax.swing.UnsupportedLookAndFeelException;

public class GrayScaleImage {

    public static void main(String[] args) {
        new GrayScaleImage();
    }

    public GrayScaleImage() {
        EventQueue.invokeLater(new Runnable() {
            @Override
            public void run() {
                try {
                    UIManager.setLookAndFeel(UIManager.getSystemLookAndFeelClassName());
                } catch (ClassNotFoundException | InstantiationException | IllegalAccessException | UnsupportedLookAndFeelException ex) {
                    ex.printStackTrace();
                }

                JFrame frame = new JFrame("Testing");
                frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
                frame.add(new TestPane());
                frame.pack();
                frame.setLocationRelativeTo(null);
                frame.setVisible(true);
            }
        });
    }

    public class TestPane extends JPanel {

        public TestPane() {
            setLayout(new GridLayout(0, 3));
            try {
                BufferedImage master = ImageIO.read(new File("/path/to/file.bmp"));
                BufferedImage gray = ImageIO.read(new File("/path/to/file.bmp"));

                // Manual manipulation...
                for (int x = 0; x < gray.getWidth(); x++) {
                    for (int y = 0; y < gray.getHeight(); y++) {
                        Color color = new Color(gray.getRGB(x, y));
                        int red = color.getRed();
                        int green = color.getGreen();
                        int blue = color.getBlue();

                        red = green = blue = (int)(red * 0.299 + green * 0.587 + blue * 0.114);
                        color = new Color(red, green, blue);
                        int rgb = color.getRGB();
                        gray.setRGB(x, y, rgb);
                    }
                }

                BufferedImage grayScale = ImageIO.read(new File("/path/to/file.bmp"));

                // Automatic converstion....
                ColorConvertOp op = new ColorConvertOp(ColorSpace.getInstance(ColorSpace.CS_GRAY), null);
                op.filter(grayScale, grayScale);

                add(new JLabel(new ImageIcon(master)));
                add(new JLabel(new ImageIcon(gray)));
                add(new JLabel(new ImageIcon(grayScale)));
            } catch (IOException ex) {
                Logger.getLogger(GrayScaleImage.class.getName()).log(Level.SEVERE, null, ex);
            }
        }
    }        
}

现在，编写图像（上面没有演示）就像......

ImageIO.write(grayScale, "BMP", new File("/path/to/grayscale file.bmp"));

Answer 2

// constant factors
            final double GS_RED   = 0.299;
            final double GS_GREEN = 0.587;
            final double GS_BLUE  = 0.114;

现在检索每个并获取它的红色、蓝色、绿色分量和 alpha（如果存在）并将它们乘以它们对应的因子。

R = G = B = (int)(GS_RED * R + GS_GREEN * G + GS_BLUE * B);

Answer 3

对于每个具有 RGB 值的像素，只取 R 值并将其复制到 G 和 B。这样每个像素将包含 3 RGB 中的红色值，这将导致图像变灰。 例子。 数据 [0]=123 //红色 data [1]=43 //绿色 数据[2]=78 //蓝色 然后 数据 [0]=123 数据 [1]=123 数据[2]=123