# Class RGB Farbe



## Seelenschnitter (6. Nov 2009)

Hallo zusammen, ich habe ein kleines Problemchen:

Ich muss eine Klasse Farbe realisieren, das erst aus einer Farbtupel eine rrrgggbbb (z.B. 255255255) Zahl macht.
Eine Methode soll invertieren (hab ich fertig)
eine soll 2 Farben addieren (aber nicht über 255 kommen, habe ich auch fertig)
und eine Methode die zu einer Farbe eine „beliebige“ andere Farbe liefert.(daran renne ich mich gerade tot und komme nicht weiter)

Der Sinn dieser Methode ist, durch wiederholte Anwendung alle RGB-Farben zu generieren.
Betrachten Sie dazu folgenden Java-Code (c enthalte irgendeine Farbe im Format rrrgggbbb,
n sei die Anzahl der möglichen Farben):

d=gibNaechsteFarbe(c) // 1. Aufruf
d=gibNaechsteFarbe(d) // 2. Aufruf
d=gibNaechsteFarbe(d) // 3. Aufruf
...
d=gibNaechsteFarbe(d) // n-ter Aufruf

Alle Farben, die beim 1. bis zum vorletzten Aufruf erzeugt werden, sollen untereinander und
von der Anfangsfarbe c verschieden sein. Die Farbe, die beim letzten Aufruf erzeugt wird, soll
mit der Anfangsfarbe gleich sein, d. h. c und d sind nach Ausführung des Codes gleich

Das Programm mit Schiebereglern etc haben wir vorgegeben bekommen aber ich weiss einfach nicht, was ich falsch mache.


```
/**
 * Diese Klasse berechnet RGB Farben.
 */
public class Farbe {

    /**
    * RGB Farben im Format rrrgggbbb werden addiert,invertiert und die
    * fortlaufende Farbe wird ausgegeben.Dies l�sst sich dann mit
    * der Farbdarstellung GUI darstellen.
    *
    * @param args wird nicht verwendet
    */
    public static void main(String args[]) {

    /*
    * Wertuebergabe an die Methoden gibNaechsteFarbe,
    * addiere und invertieren.
    */

    System.out.println(gibNaechsteFarbe(255200200));
    System.out.println(addiere(250250250 , 100100100));
    System.out.println(invertiere(10128255));
    }

    /*
    * Die Methode berechneRot berechnet den Rot-Anteil aus einer
    * Farbzahl im Format rrrgggbbb, indem die Variable "farbe" durch
    * 1000000 dividiert wird.Der ausgegebene Wert wird an die Variable
    * "rot" uebergeben. Der Wert fuer "farbe" wird von den
    * spaeteren Methoden "invertiere und addiere" uebergeben.
    * Die Nachkommastelle wird dadurch entfernt,
    * dass die Zahl ein "int" Wert ist.
    */

    public static int berechneRot(int farbe) {

        int rot = (farbe / 1000000);

        return rot;
    }

    /*
    * Die Methode fuer den gruenen Farbanteil des rrrgggbbb Wertes.
    * Hier wird nochmals der rot Anteil erechnet.Der Wert gruen
    * wird errechnet, indem die Farbe Rot mit 1000000 multipliziert
    * wird und von der Variablen "farbe" subtrahiert wird. Der naechste Schritt
    * ist die Dividierung durch 1000 ,um den Gruenanteil zu erhalten.
    * Die Nachkommastelle wird auf dieselbe Weise entnfert, wie bei
    * der Errechnung des  Farbanteils "rot".
    */

    public static int berechneGruen(int farbe) {

        int rot = (farbe / 1000000);
        int gruen = ((farbe - rot * 1000000) / 1000);

        return gruen;
    }

    /*
    * Methode fuer den blauen Farbanteil. Rot und Gruen werden erneut
    * errechnet, dann erfolgt die Errechnung fuer den blauen Farbanteil.
    * Rot wird mit 1000000 multipliziert und dann von der Variablen "farbe"
    * subtrahiert.Dann folgt die multiplikation mit 1000
    * mit dem Farbanteil gruen. Dieser Wert wird nochmals von der Variablen
    * "farbe" subtrahiert. Was bleibt, ist der blaue Farbanteil.
    */

    public static int berechneBlau(int farbe) {

        int rot = (farbe / 1000000);
        int gruen = ((farbe - rot * 1000000) / 1000);
        int blau = ((farbe - rot * 1000000) - gruen * 1000);

        return blau;
    }

    /*
    * Methode um eine Zahl zu invertieren. Zuerst holst sich die Methode
    * ihren Wert �ber die Variablendeklaration "int farbe" von oben aus
    * "System.out.println(invertiere(10128255))". Um eine Invertierung zu
    * erreichen, wird der maximale Farbanteilswert "255" subtrahiert mit
    * dem rot Anteil. Als letzter Schritt werden die einzelnen Werte
    * die in Rot,Gruen und Blauf aufgeteilt sind zu einem rrrgggbbb Wert
    * zusammen gesetzt. Das errechnete Rot wird mit 1000000 multipliziert,
    * dann wird das Gruen mit 1000 multipliziert und zum rot Wert addiert
    * und zuletzt wird noch der blau Anteil hinzu addiert.
    */

    public static int invertiere(int farbe) {


        int rot = 255 - berechneRot(farbe);
        int gruen = 255 - berechneGruen(farbe);
        int blau = 255 - berechneBlau(farbe);
        int farbeZahl = (((rot * 1000000) + gruen * 1000) + blau);


    return farbeZahl;

    }

    /*
    * Methode fuer den blauen Farbanteil. Rot und Gruen werden erneut
    * errechnet, dann erfolgt die Errechnung fuer den blauen Farbanteil.
    * Rot wird mit 1000000 multipliziert und dann von der Variablen "farbe"
    * subtrahiert.Dann folgt die multiplikation mit 1000
    * mit dem Farbanteil gruen. Dieser Wert wird nochmals von der Variablen
    * "farbe" subtrahiert. Was bleibt, ist der blaue Farbanteil.
    */

    public static int addiere(int farbe1 , int farbe2) {



        int rot = ((berechneRot(farbe1) + berechneRot(farbe2)) > 255)
                  ? (rot = 0)
                  : (berechneRot(farbe1)) + (berechneRot(farbe2));
        int gruen = ((berechneGruen(farbe1) + berechneGruen(farbe2)) > 255)
                  ? (gruen = 0)
                  : (berechneGruen(farbe1)) + (berechneGruen(farbe2));
        int blau = ((berechneBlau(farbe1) + berechneBlau(farbe2)) > 255)
                  ? (rot = 0)
                  : (berechneBlau(farbe1)) + (berechneBlau(farbe2));
        int farbeZahl = (((rot * 1000000) + gruen * 1000) + blau);

    return farbeZahl;


    }

    /*
    * Methode fuer den blauen Farbanteil. Rot und Gruen werden erneut
    * errechnet, dann erfolgt die Errechnung fuer den blauen Farbanteil.
    * Rot wird mit 1000000 multipliziert und dann von der Variablen "farbe"
    * subtrahiert.Dann folgt die multiplikation mit 1000 
    * mit dem Farbanteil gruen. Dieser Wert wird nochmals von der Variablen
    * "farbe" subtrahiert. Was bleibt, ist der blaue Farbanteil.
    */

    public static int gibNaechsteFarbe(int farbe) {

        int rot = (berechneRot(farbe));
        int gruen = (berechneGruen(farbe));
        int blau = (berechneBlau(farbe));

        blau = (blau > 255) ? (blau + 1) : (blau);
        gruen = (blau == 255) & (blau == 255) ? (gruen + 1) : (gruen);
        rot = (blau == 255) & (gruen == 255) ? (rot + 1) : (rot);
        rot = (blau == 255) & (gruen == 255) & (rot == 255) ? (rot = 0) : (rot);
        int wert = (((rot * 1000000) + gruen * 1000) + blau);

    return wert;

    }


}
```


Ich bedanke mich schonmal im vorraus, mir rennt nur leider die Zeit davon


----------



## Seelenschnitter (6. Nov 2009)

Zur weiteren Erklärung:

Klicke ich auf Clean & Build Project kommt erstmal:
...\src\FarbdarstellungGUI.java:277: warning: [deprecation] setLabel(java.lang.String) in javax.swing.AbstractButton has been deprecated
        jButton1.setLabel("Naechste Farbe");
1 warning


Das Reglermenu öffnet sich zwar aber leider macht er nicht das, was er soll, wenn ich auf Naechste Farbe klicke. Normal soll er dann Blau von 0 - 255 durchgehen. Dort angekommen den Grünen Schieberegler um 1 erhöhen und bei Blau wieder von 0 beginnen. Ist dann auch Gruen bei 255 angelangt soll natürlich Rot um eins erhöht werden. Sind alle auf 255 soll danach alles wieder genullt werden und der heitere Spass geht von vorne los.

Sollte ich mich im Board allerdings vertan haben, dann Entschuldigung.


----------



## madboy (7. Nov 2009)

Lass am besten den ternären Operator weg (ich denke, du hast den noch nicht richtig verstanden) und verwende normale if-Abfragen. Beispiel für blau, analog dann rot und grün:

```
public static int gibNaechsteFarbe(int farbe) {

        int rot = (berechneRot(farbe));
        int gruen = (berechneGruen(farbe));
        int blau = (berechneBlau(farbe));

        if(blau > 255) {
            blau = 0;
            //hier noch die nächste Farbe erhöhen.
        } else
            blau = blau + 1;
        }
...
    }
```

Außerdem verwende für logisches UND nicht 
	
	
	
	





```
&
```
 sondern 
	
	
	
	





```
&&
```
. Ersteres ist ein binärer Operator und eben nicht das logische UND 

EDIT:
Das ganze ist das gleiche Prinzip wie beim "normalen" Zählen zur Basis 10, nur hast du nun die Basis 255. 
0,1,2,3,4,5,6,7,8,9,?
Bei ? gehen mir die Zahlen aus, daher setze ich die erste Stelle wieder auf 0 und die zweite Stelle wird auf 1 erhöht, dann geht's wieder von vorne los.


----------

