# Farbverlauf in for-Schleife berechnen



## Soahc (24. Jul 2011)

Hallo,

mit

```
for (int i = 0; i< 255; i++){
  Color color = new Color(255,i,i);	               
}
```

kann ich mir alle Farben für einen Farbverlauf von rot nach weiß in 255 Schritten berechnen lassen. Ich hätte aber gern einen Verlauf über alle Farben, also von rot, über grün nach blau (auch wieder in 255 Schritten). Ich probiere schon eine Weile hin, aber bekomme es nicht hin. Hat da jemand einen Tip?

gruß, Soahc


----------



## Marcinek (24. Jul 2011)

Du möchstest 255 * 255 farben in 255 schritten darstellen??

mach doch erstmal zwei schleifen und dann kannst du den schritt größer machen und gucken, wie es sich verhält.


----------



## Marco13 (24. Jul 2011)

Klassisch  "Alle" Farben sind schon verdammt viele  

Hatte da mal was gebastelt, wovon ich mal einen Schnipsel posten kann

```
// Irgendwie erstellen:
    List<Color> list = Arrays.asList(Color.RED, Color.GREEN, Color.BLUE);

...

    private int[] buildRGB(int size)
    {
        int rgbColors[] = new int[size];
        float stepSize = (float)size / (list.size()-1);
        for (int i=0; i<size; i++)
        {
            float a = (float)i / size;
            int ci0 = (int)(a * (list.size()-1));
            int ci1 = ci0 + 1;
            
            Color c0 = list.get(ci0);
            int r0 = c0.getRed();
            int g0 = c0.getGreen();
            int b0 = c0.getBlue();

            Color c1 = list.get(ci1);
            int r1 = c1.getRed();
            int g1 = c1.getGreen();
            int b1 = c1.getBlue();
            
            int dr = r1-r0;
            int dg = g1-g0;
            int db = b1-b0;

            float alpha = (i-(ci0*stepSize)) / stepSize;
            
            int r = (int)(r0 + alpha * dr);
            int g = (int)(g0 + alpha * dg);
            int b = (int)(b0 + alpha * db);
            int rgb = 
                (r << 16) |
                (g <<  8) |
                (b <<  0);

            System.out.println("at "+i+" a "+a+" ci0 "+ci0+" alpha "+alpha+" rgb "+r+" "+g+" "+b);
            
            rgbColors[i] = rgb;
        }
        return rgbColors;
    }
    
    private Color[] buildColors(int size)
    {
        int rgbColors[] = buildRGB(size); 
        Color colors[] = new Color[size];
        for (int i=0; i<size; i++)
        {
            colors[i] = new Color(rgbColors[i]);
        }
        return colors;
    }
```

Das sollte "flüssig" über die Farben in der "list" rüberinterpolieren, mit der angegeben anzahl schritt (bei dir wäre 'size' also 255 oder 256)


----------



## Landei (24. Jul 2011)

Ich denke, du solltest dir mal das HSB-Modell anschauen, das ebenfalls in Java verfügbar ist.

Dabei lässt du Sättigung (s) und Helligkeit (b) fest, und änderst den Farbton (h). Die Farbe kannst du dann mit [c]Color color = new Color(Color.HSBtoRGB(h, s, b));[c]  generieren. Allerdings sind die HSB-Werte floats von 0..1, du müsstest also z.B. [c]float h = i / 255F;[/c] rechnen.


----------



## Soahc (26. Jul 2011)

Wow cool.


```
for (int i = 1; i < 255; i++) {
  float h = i / 255F;
  Color color = new Color(Color.HSBtoRGB(h, 1f, 1f));
  ...
}
```

macht es genauso, wie ich es haben will. Super, vielen Dank!


----------

