在Java中分配32位浮点数到4个整数（RGBA）上

Question

1. Consider a 32bit java float sample in (0.0f .. 1.0f) and four 32bit java integers r, g, b, a each in (0 .. 255) in a vector called RGBA .

2. The sample variable contains normalized measurement data that I wish to present in an ImageIcon in the form of a heat map. The target for the final RGBA values is an integer vector that later is passed as pixel data to a java BufferdImage .

3. The constraints are that when sample==0.0f then RGBA==[0,0,0,255] with uniform distribution so that sample==1.0f represents RGBA==[255,0,0,255] and with sample==0.5f is represented by RGBA==[255,255,255,255] . The alpha channel is always 255.

4. So far I have used a static method by dividing the colors into three separate sections RGB while A remain static at 255. Like so

/* BLUE */
if ( sample <= 0.340000f ){
    localSample = (sample/(0.340000f/255.000000f));
    sourceLinearData[localIndex] = 0; // R
    sourceLinearData[localIndex+1] = 0; // G
    sourceLinearData[localIndex+2] = Math.round(localSample); // B
}

5. My questions: A) Are there any suitable java api's/libraries that would help me do this? B) If not then I ask for suggestions to a solution.

6. Thoughts: Since each of the R, G, B, A are in (0 .. 255) I assume I can use bytes instead of integers and then possibly shift these bytes into one variable and then extract the float that way. Though I have not had any success with this method so far.

7. EDIT: Adding example heat map

SOLVED: So, like many other things in software development, this question too holds more than a single answer. In my case I wanted the most direct route with the least amount of additional work. Because of that I decided to go with the answer given by @haraldK. This said though, if you are looking for a formal solution with more control, precision and flexibility, the answer provided by @SashaSalauyou is the more correct one.

Answer 1

To elaborate on my comment above. This doesn't give exactly the colors in the map above, but it is pretty close, and extremely simple:

float sample = ...; // [0...1]
float hue = (1 - sample) * .75f; // limit hue to [0...0.75] to avoid color "loop"
int rgb = Color.getHSBColor(hue, 1, 1).getRGB(); 

If you want darker tints in "edges" of the scale, you could use a sine function to compute the brightness, for example:

float hue = (1 - sample) * .75f;
float brightness = .5f + (float) Math.sin(Math.PI * sample) / 2;
int rgb = Color.getHSBColor(hue, 1, brightness).getRGB();

Answer 2

I suggest some kind of interpolation in a path that value from 0 to 1 performs in 3D color space:

// black: c = 0.0
// blue:  c = 0.3 
// white: c = 0.5
// red:   c = 1.0
// add more color mappings if needed, keeping c[] sorted

static float[] c = {0.0, 0.3, 0.5, 1.0};
static int[] r =   {  0,   0, 255, 255}; // red components
static int[] g =   {  0,   0, 255,   0}; // green components
static int[] b =   {  0, 255, 255,   0}; // blue components

public int[] getColor(float f) {
    int i = 0;
    while (c[i] < f) 
       i++;
    if (i == 0) 
       return new int[] {r[0], g[0], b[0]};

    // interpolate
    float k = (f - c[i-1]) / (c[i] - c[i-1]);
    return new int[] {
         Math.round((r[i] - r[i-1]) * k + r[i-1]),
         Math.round((g[i] - g[i-1]) * k + g[i-1]),
         Math.round((b[i] - b[i-1]) * k + b[i-1])
         }
    }

}

Answer 3

Lerp should do the trick:

public static void main(String[] args) {
    float value = 0.5f;

    float[] red = new float[] {1.0f, 0, 0};
    float[] white = new float[] {1.0f, 1.0f, 1.0f};
    float[] black = new float[] {0, 0, 0};

    if (value <= 0.5f) {
        float gradientValue = value * 2;
        int[] color = new int[] {(int) (lerp(white[0], black[0], gradientValue) * 255), (int) (lerp(white[1], black[1], gradientValue) * 255), 
                (int) (lerp(white[2], black[2], gradientValue) * 255), 255};
    } else if (value > 0.5f) {
        float gradientValue = (value + 1) / 2.0f;
        int[] color = new int[] {(int) (lerp(white[0], red[0], gradientValue) * 255), (int) (lerp(white[1], red[1], gradientValue) * 255), 
                (int) (lerp(white[2], red[2], gradientValue) * 255), 255};
    }
}

public static float lerp(float v0, float v1, float t) {
      return (1-t)*v0 + t*v1;
}

(the order of the lerp arguments might be different, I haven't tested)