How to create X% percent gray in Java?

When converting RGB color to grayscale, the following weights are used:

0.2989, 0.5870, 0.1140

Source: Convert RGB to Grayscale / Intensity

And on Wikipedia: http://en.wikipedia.org/wiki/Grayscale

So formally:

gray = 0.2989*R + 0.5870*G + 0.1140*B

      

        
        
        
      

    

Basically you want the inverse function. You need to find the R, G and B values ​​that give the result gray

you are looking for. Since there are 3 parameters in the equation, in most cases there are many RGB values ​​that will result in the value gray

you are looking for.

Think about it: an RGB color with a high R component and none of G and B will be gray, there might be a different RGB color with some G component, and none of R and B will have the same gray, so represent several possible RGB solutions for the desired gray.

Algorithm

Here's one possible solution. What it does is try to establish that the first of the RGB components will be so large as to multiply its weight, will return a value gray

. If it "overflows" at 255, it is truncated, we decrease gray

with the amount that the maximum value of the component can "represent", and we try to do this for the next component with the remaining amount gray

.

Here I am using an input range gray

0..255

. If you want to specify it as a percentage, just convert it as gray = 255*percent/100

.

private static double[] WEIGHTS = { 0.2989, 0.5870, 0.1140 };

public static int[] getRGB(int gray) {
    int[] rgb = new int[3];

    for (int i = 0; i < 3; i++) {
        rgb[i] = (int) (gray / WEIGHTS[i]);
        if (rgb[i] < 256)
            return rgb; // Successfully "distributed" all of gray, return it

        // Not quite there, cut it...
        rgb[i] = 255;
        // And distribute the remaining on the rest of the RGB components:
        gray -= (int) (255 * WEIGHTS[i]);
    }

    return rgb;
}

      

        
        
        
      

    

To test it, use the following method:

public static int toGray(int[] rgb) {
    double gray = 0;
    for (int i = 0; i < 3; i++)
        gray += rgb[i] * WEIGHTS[i];
    return (int) gray;
}

      

        
        
        
      

    

Test:

for (int gray = 0; gray <= 255; gray += 50) {
    int[] rgb = getRGB(gray);
    System.out.printf("Input: %3d, Output: %3d,   RGB: %3d, %3d, %3d\n",
            gray, toGray(rgb), rgb[0], rgb[1], rgb[2]);
}

      

        
        
        
      

    

Test output:

Input:   0, Output:   0,   RGB:   0,   0,   0
Input:  50, Output:  49,   RGB: 167,   0,   0
Input: 100, Output:  99,   RGB: 255,  40,   0
Input: 150, Output: 150,   RGB: 255, 126,   0
Input: 200, Output: 200,   RGB: 255, 211,   0
Input: 250, Output: 250,   RGB: 255, 255, 219

      

        
        
        
      

    

The results show what we expected based on the algorithm: the R component is first filled, as soon as it reaches 255, the G component gets "filled" and the last G component is used.