我正在研究一些代码来用Java着色图像。 基本上我想做的是GIMP的colorize命令,所以如果我有一个BufferedImage和Color,我可以用给定的颜色着色Image。 有人有任何想法吗? 我目前做这样的事情的最佳猜测是获取BufferedImage中每个像素的rgb值,并使用一些缩放因子将Color的RGB值添加到其中。

===============>>#1 票数:7

对图像中的每个像素设Y = 0.3*R + 0.59*G + 0.11*B ,然后将它们设置为

((R1+Y)/2,(G1+Y)/2,(B1+Y)/2)

if (R1,G1,B1)是你要着色的。

===============>>#2 票数:3 已采纳

我从未使用过GIMP的colorize命令。 但是,如果您获得每个像素的RGB值并向其添加RGB值,您应该使用LookupOp 下面是我编写的一些代码,用于将BufferedImageOp应用于BufferedImage。

使用上面的尼克斯示例继承人我将如何做到这一点。

对于每个像素,设Y = 0.3 * R + 0.59 * G + 0.11 * B.

(R1,G1,B1)是您着色的地方

protected LookupOp createColorizeOp(short R1, short G1, short B1) {
    short[] alpha = new short[256];
    short[] red = new short[256];
    short[] green = new short[256];
    short[] blue = new short[256];

    int Y = 0.3*R + 0.59*G + 0.11*B

    for (short i = 0; i < 256; i++) {
        alpha[i] = i;
        red[i] = (R1 + i*.3)/2;
        green[i] = (G1 + i*.59)/2;
        blue[i] = (B1 + i*.11)/2;
    }

    short[][] data = new short[][] {
            red, green, blue, alpha
    };

    LookupTable lookupTable = new ShortLookupTable(0, data);
    return new LookupOp(lookupTable, null);
}

它创建了一个BufferedImageOp ,如果mask boolean为true,它将屏蔽掉每种颜色。

它也很简单。

BufferedImageOp colorizeFilter = createColorizeOp(R1, G1, B1);
BufferedImage targetImage = colorizeFilter.filter(sourceImage, null);

如果这不是你想要的,我建议你多看看BufferedImageOp。

这也会更有效,因为您不需要在不同的图像上多次进行计算。 或者,只要R1,G1,B1值不变,就可以在不同的BufferedImages上再次进行计算。

===============>>#3 票数:2

这与GIMP中的Colorize函数完全相同,它保留了透明度。 我还添加了一些东西,如对比度和亮度,色相,星期六和亮度 - 0circle0 Google Me - >'Sprite Creator 3'

import java.awt.Color;
import java.awt.image.BufferedImage;

public class Colorizer
{
    public static final int MAX_COLOR = 256;

    public static final float LUMINANCE_RED = 0.2126f;
    public static final float LUMINANCE_GREEN = 0.7152f;
    public static final float LUMINANCE_BLUE = 0.0722f;

    double hue = 180;
    double saturation = 50;
    double lightness = 0;

    int[] lum_red_lookup;
    int[] lum_green_lookup;
    int[] lum_blue_lookup;

    int[] final_red_lookup;
    int[] final_green_lookup;
    int[] final_blue_lookup;

    public Colorizer()
    {
        doInit();
    }

    public void doHSB(double t_hue, double t_sat, double t_bri, BufferedImage image)
    {
        hue = t_hue;
        saturation = t_sat;
        lightness = t_bri;
        doInit();
        doColorize(image);
    }

    private void doInit()
    {
        lum_red_lookup = new int[MAX_COLOR];
        lum_green_lookup = new int[MAX_COLOR];
        lum_blue_lookup = new int[MAX_COLOR];

        double temp_hue = hue / 360f;
        double temp_sat = saturation / 100f;

        final_red_lookup = new int[MAX_COLOR];
        final_green_lookup = new int[MAX_COLOR];
        final_blue_lookup = new int[MAX_COLOR];

        for (int i = 0; i < MAX_COLOR; ++i)
        {
            lum_red_lookup[i] = (int) (i * LUMINANCE_RED);
            lum_green_lookup[i] = (int) (i * LUMINANCE_GREEN);
            lum_blue_lookup[i] = (int) (i * LUMINANCE_BLUE);

            double temp_light = (double) i / 255f;

            Color color = new Color(Color.HSBtoRGB((float) temp_hue, (float) temp_sat, (float) temp_light));

            final_red_lookup[i] = (int) (color.getRed());
            final_green_lookup[i] = (int) (color.getGreen());
            final_blue_lookup[i] = (int) (color.getBlue());
        }
    }

    public void doColorize(BufferedImage image)
    {
        int height = image.getHeight();
        int width;

        while (height-- != 0)
        {
            width = image.getWidth();

            while (width-- != 0)
            {
                Color color = new Color(image.getRGB(width, height), true);

                int lum = lum_red_lookup[color.getRed()] + lum_green_lookup[color.getGreen()] + lum_blue_lookup[color.getBlue()];

                if (lightness > 0)
                {
                    lum = (int) ((double) lum * (100f - lightness) / 100f);
                    lum += 255f - (100f - lightness) * 255f / 100f;
                }
                else if (lightness < 0)
                {
                    lum = (int) (((double) lum * (lightness + 100f)) / 100f);
                }
                Color final_color = new Color(final_red_lookup[lum], final_green_lookup[lum], final_blue_lookup[lum], color.getAlpha());
                image.setRGB(width, height, final_color.getRGB());
            }
        }
    }

    public BufferedImage changeContrast(BufferedImage inImage, float increasingFactor)
    {
        int w = inImage.getWidth();
        int h = inImage.getHeight();

        BufferedImage outImage = new BufferedImage(w, h, BufferedImage.TYPE_INT_ARGB);
        for (int i = 0; i < w; i++)
        {
            for (int j = 0; j < h; j++)
            {
                Color color = new Color(inImage.getRGB(i, j), true);
                int r, g, b, a;
                float fr, fg, fb;

                r = color.getRed();
                fr = (r - 128) * increasingFactor + 128;
                r = (int) fr;
                r = keep256(r);

                g = color.getGreen();
                fg = (g - 128) * increasingFactor + 128;
                g = (int) fg;
                g = keep256(g);

                b = color.getBlue();
                fb = (b - 128) * increasingFactor + 128;
                b = (int) fb;
                b = keep256(b);

                a = color.getAlpha();

                outImage.setRGB(i, j, new Color(r, g, b, a).getRGB());
            }
        }
        return outImage;
    }

    public BufferedImage changeGreen(BufferedImage inImage, int increasingFactor)
    {
        int w = inImage.getWidth();
        int h = inImage.getHeight();

        BufferedImage outImage = new BufferedImage(w, h, BufferedImage.TYPE_INT_ARGB);

        for (int i = 0; i < w; i++)
        {
            for (int j = 0; j < h; j++)
            {
                Color color = new Color(inImage.getRGB(i, j), true);
                int r, g, b, a;
                r = color.getRed();
                g = keep256(color.getGreen() + increasingFactor);
                b = color.getBlue();
                a = color.getAlpha();

                outImage.setRGB(i, j, new Color(r, g, b, a).getRGB());
            }
        }
        return outImage;
    }

    public BufferedImage changeBlue(BufferedImage inImage, int increasingFactor)
    {
        int w = inImage.getWidth();
        int h = inImage.getHeight();

        BufferedImage outImage = new BufferedImage(w, h, BufferedImage.TYPE_INT_ARGB);

        for (int i = 0; i < w; i++)
        {
            for (int j = 0; j < h; j++)
            {
                Color color = new Color(inImage.getRGB(i, j), true);
                int r, g, b, a;
                r = color.getRed();
                g = color.getGreen();
                b = keep256(color.getBlue() + increasingFactor);
                a = color.getAlpha();

                outImage.setRGB(i, j, new Color(r, g, b, a).getRGB());
            }
        }
        return outImage;
    }

    public BufferedImage changeRed(BufferedImage inImage, int increasingFactor)
    {
        int w = inImage.getWidth();
        int h = inImage.getHeight();

        BufferedImage outImage = new BufferedImage(w, h, BufferedImage.TYPE_INT_ARGB);

        for (int i = 0; i < w; i++)
        {
            for (int j = 0; j < h; j++)
            {
                Color color = new Color(inImage.getRGB(i, j), true);
                int r, g, b, a;
                r = keep256(color.getRed() + increasingFactor);
                g = color.getGreen();
                b = color.getBlue();
                a = color.getAlpha();

                outImage.setRGB(i, j, new Color(r, g, b, a).getRGB());
            }
        }
        return outImage;
    }

    public BufferedImage changeBrightness(BufferedImage inImage, int increasingFactor)
    {
        int w = inImage.getWidth();
        int h = inImage.getHeight();

        BufferedImage outImage = new BufferedImage(w, h, BufferedImage.TYPE_INT_ARGB);

        for (int i = 0; i < w; i++)
        {
            for (int j = 0; j < h; j++)
            {
                Color color = new Color(inImage.getRGB(i, j), true);

                int r, g, b, a;

                r = keep256(color.getRed() + increasingFactor);
                g = keep256(color.getGreen() + increasingFactor);
                b = keep256(color.getBlue() + increasingFactor);
                a = color.getAlpha();

                outImage.setRGB(i, j, new Color(r, g, b, a).getRGB());
            }
        }
        return outImage;
    }

    public int keep256(int i)
    {
        if (i <= 255 && i >= 0)
            return i;
        if (i > 255)
            return 255;
        return 0;
    }
}

===============>>#4 票数:1

我想做与问题海报想要做的完全相同的事情但是上面的转换没有像GIMP那样去除颜色(即带有红色覆盖的绿色使得令人不快的棕色等)。 所以我下载了GIMP的源代码并将c代码转换为Java。

在这个帖子中发布它以防万一其他人想要做同样的事情(因为它是谷歌中出现的第一个线程)。 当它不应该转换时仍会改变白色,这可能是从double到int的转换问题。 该类就地转换BufferedImage。

public class Colorize {

public static final int MAX_COLOR = 256;

public static final float LUMINANCE_RED   = 0.2126f;
public static final float LUMINANCE_GREEN = 0.7152f;
public static final float LUMINANCE_BLUE  = 0.0722f;

double hue        = 180;
double saturation =  50;
double lightness  =   0;

int [] lum_red_lookup;
int [] lum_green_lookup;
int [] lum_blue_lookup;

int [] final_red_lookup;
int [] final_green_lookup;
int [] final_blue_lookup;

public Colorize( int red, int green, int blue )
{
   doInit();
}

public Colorize( double t_hue, double t_sat, double t_bri )
{
   hue = t_hue;
   saturation = t_sat;
   lightness = t_bri;
   doInit();
}

public Colorize( double t_hue, double t_sat )
{
   hue = t_hue;
   saturation = t_sat;
   doInit();
}

public Colorize( double t_hue )
{
   hue = t_hue;
   doInit();
}

public Colorize()
{
   doInit();
}

private void doInit()
{
   lum_red_lookup   = new int [MAX_COLOR];
   lum_green_lookup = new int [MAX_COLOR];
   lum_blue_lookup  = new int [MAX_COLOR];

   double temp_hue = hue / 360f;
   double temp_sat = saturation / 100f;

   final_red_lookup   = new int [MAX_COLOR];
   final_green_lookup = new int [MAX_COLOR];
   final_blue_lookup  = new int [MAX_COLOR];

   for( int i = 0; i < MAX_COLOR; ++i )
   {
      lum_red_lookup  [i] = ( int )( i * LUMINANCE_RED );
      lum_green_lookup[i] = ( int )( i * LUMINANCE_GREEN );
      lum_blue_lookup [i] = ( int )( i * LUMINANCE_BLUE );

      double temp_light = (double)i / 255f;

      Color color = new Color( Color.HSBtoRGB( (float)temp_hue, 
                                               (float)temp_sat, 
                                               (float)temp_light ) );

      final_red_lookup  [i] = ( int )( color.getRed() );
      final_green_lookup[i] = ( int )( color.getGreen() );
      final_blue_lookup [i] = ( int )( color.getBlue() );
   }
}

public void doColorize( BufferedImage image )
{
   int height = image.getHeight();
   int width;

   while( height-- != 0 )
   {
      width = image.getWidth();

      while( width-- != 0 )
      {
         Color color = new Color( image.getRGB( width, height ) );

         int lum = lum_red_lookup  [color.getRed  ()] +
                   lum_green_lookup[color.getGreen()] +
                   lum_blue_lookup [color.getBlue ()];

         if( lightness > 0 )
         {
            lum = (int)((double)lum * (100f - lightness) / 100f);
            lum += 255f - (100f - lightness) * 255f / 100f;
         }
         else if( lightness < 0 )
         {
            lum = (int)(((double)lum * lightness + 100f) / 100f);
         }

         Color final_color = new Color( final_red_lookup[lum],
                                        final_green_lookup[lum],
                                        final_blue_lookup[lum],
                                        color.getAlpha() );

         image.setRGB( width, height, final_color.getRGB() );

      }
   }
}

  ask by Paul Wicks translate from so

未解决问题?本站智能推荐:

2回复

Java-着色图像

我试图用给定的颜色创建彩色的灰色图像,但是我总是失败。 我知道我必须使用BufferedImage并将源图像的所有像素加载到数组中,但是我不知道如何使用颜色值,因此在将源颜色和给定颜色相乘后,总会有一些奇怪的颜色(对于记录我我已经获得了获取颜色int的代码)。 谢谢你的帮助。 例如
1回复

使用Java着色的黑白缓冲图像

我一直在用Java从头开始制作游戏,最近在尝试为黑白BuffereImages上色时出现问题。 我想保持像素的暗淡(如果有任何意义)。 例如,《我的世界》中的草是灰色图像,但是当在游戏中看到时,它以不同的绿色阴影出现,但保持其价值。 我没有任何代码可显示,因为我不知道从哪里开始。 我只有
1回复

Java缓冲的具有不同RGB值的图像颜色op

我有一个以灰度绘制的缓冲图像,我想将其转换为颜色,其中颜色映射到灰色的某些范围。 例如,0-100之间的所有灰色均映射为红色,100-255之间的所有灰度均映射为绿色。 看起来缓冲的图像查找操作是执行此操作的方法,但是我不确定如何执行此操作。 例如,如果灰度图像的RGB是(50,50,50
1回复

在Java中将透明度应用于具有透明性的灰度png图像

我需要在不影响透明度本身的情况下对具有透明度的灰度BufferedImage施加色调,这是我使用的方法,但是当我尝试将其绘制在画布内的另一个图像之上时,原始图像的透明度消失了,留下原始所选颜色的正方形... 有什么提示吗?
1回复

Java颜色检测

我希望在Java中实现一个读取图像的功能,并能够检测出红色,蓝色,绿色,黄色等阴影,作为卫星图像分析程序的一部分。 因此,例如在标准卫星图像中,蓝色将是水,因此我希望程序读取多少像素是蓝色,然后它可以说x%的图像是水。 我知道通过读取每个像素的RGB值可以使用整个逻辑语句,但有更简单的方
1回复

Java颜色量较低

我目前在BufferedImage上有256种颜色,但我需要将其设置为200种颜色。 有谁知道将图像设置为200色而不是256色的Java代码?
1回复

JAVA Color []到BufferedImage到Color []的漂白输出

我正在处理从Color []数组生成输出图像的图像渲染器的代码,而我的代码只是在保存之前(即实际准备好原始图像时(所有像素位置都准备好用RGB填充))用其他内容更新它。在该Color []数组中准备好进行最终保存)。 我这样做的原因是能够插入描述我的渲染的文本,而无需另一个外部图形程序来执
1回复

在Java中将灰度BufferedImage与自定义颜色相乘

在到处搜寻时,发现了许多方法。 但是,在按像素的方法上(从Raster提取byte数据,对ARGB结果进行位移/乘数值),我有点费解地想出如何将我的Color应用于该像素。 这是图片: 这是我当前的方法和代码,但是被一个错误掩盖了,该错误将在后续的JRE / JDK版本中修复
2回复

使用rmagick为照片中的图像着色

所以我有这个基本形象: 在photoshop中,我使用rgb颜色进行基本的图层颜色叠加: r:244,g:93,b:0 这给了我惊人的活力: 我想要做的是在rmagick中着色相同的图像,所以如果我做以下着色: 它给了我这个真正褪色的橙色图像: 我的问
1回复

获取缓冲图像的透明度

我想更改图像的所有蓝色。 我使用此代码进行修改。 问题在于它也会改变所有透明区域的颜色,而不仅仅是蓝色区域。 我该如何解决?