2D-Grafik wie funktioniert der RGB Farbcode als int?

[Dragnaros]

Hallo also ich habe eine grafik und lese diese pixel für pixel ein will prüfen welche farbe sie haben und sie nach
einer kurzen berechnung ändern um dan zum nächsten pixel zu kommen.

nun jedoch mein problem ich nutze BufferedImage.setRGB(x, y, RGB); ich weis aber nicht wie jave den
RGB Code in ein int umwandelt. ich hab es mit einfach mal als string ausgeben lassen und eine merkwüdige
- zahl bekommen scheinbar ohne sin nun möchte ich von euch erfahren wie ich zb. den
standart farbcode (255.000.255) in einen int umwandeln kann und andersrum.

zudem möchte ich wissen wie ich dem bild eine transparenz hinzufüge.

hier ein kleiner ausschnitt:

    public Player() {
        //load Player data from server or save.
        int replaceRedWidth = 0;
        int replaceBlueWidth = 0;

        try {
            skin = ImageIO.read(getClass().getResource("Skin.png"));
        } catch (IOException ex) {
            System.out.println("can not find Skin.png");
        }
        
        for (int y = 0; y < skin.getHeight(); y++) {
            for (int x = 0; x < skin.getWidth(); x++) {
                int color = skin.getRGB(x, y);
                skin.setRGB(x, y, Color.LIGHT_GRAY.getRGB());
            }
        }
    }

da steht zwar LIGHT_GRAY ist aber ein leicht dunkles Rot warum auch immer.

 

[HoaX]

int farbe = 0xRRGGBB; // Durch sinnvolle werte ersetzen.

int rot = (farbe >> 16) & 0xff;
int grün = (farbe >> 8) & 0xff;
int blau = farbe & 0xff;

Ich denke das sollte es erklären, je Farbe ein Byte.

 

[Marco13]

Tansparenz "hinzufügen" ist so eine Sache, da muss auch das Bildformat passen. Am besten ist es das Bild (wie z.B. in http://www.java-forum.org/spiele-mu...18-performance-bufferedimages.html#post803128 beschrieben) in ein INT_ARGB umzuwandeln (und wie dort auch steht; Dadurch könnte es schneller werden). Beschreib' aber mal, was du da mit dem Pixelsetzen vorhast. Klingt eher nach einer Aufgabe für Gimp

 

[HimBromBeere]

Bei Transparenz gibt´s hauptsächlich zwei Möglichkeiten:

1. Du hast ein schematisches Bild, bei dem genau ein Farbwert (von den 16,7Mrd Farben und einer Farbtiefe von 24bit) durch "Transparenz" ersetzt wird. Das geht ganz einfach, dabei wird die Farbe gewissermaßen aus dem Bild einfach gelöscht.
2. Du verwendest den Alpha-Kanal, der wie ein ganz normaler zusätzlicher Farbkanal gerechnet wird (auch mit 8bit Farbtiefe, also 256 Grauwerten). Dafür musst du eines der Farbformate ARGB oder RGBA (oder was es da nicht noch alles an Permutationen gibt, soweit ich weiß, heißen die je nach Umgebung auch mal XRGB, aber ich schweife ab) verwenden und dann natrülich noch aufpassen, welches Bildformat du verwendest, JPEG, GIF, PNG, TIFF (was Java aber wahrscheinlich nativ erstmal gar nicht unterstützt, nehm ich ma an)... einige davon unterstützen Transparenz, andere nicht...

 

[Spacerat]

Java unterstützt standardmässig GIF, JPEG und PNG, durch ImageIO kommen noch BMP und WBMP hinzu, andere Formate lassen sich aber noch hinzufügen. Transparenz wird dabei nur von PNG und GIF unterstützt.
Zum Thema Transparenz ist das aber längst nicht alles. So sollte man z.B. auch wissen, wie ColorModel, SampleModel und WritableRaster zusammen spielen (von wegen [c]isAlphaPreMultiplied()[/c] ;(). So kann man manchesmal schon arg verzweifeln, weil trotz gesetzter Transparenz (0 <= Alpha-Kanal < 255) der Pixel durch [c]setRGB()[/c] einfach nicht transparent werden will, sich schlimmstenfalls sogar nichts am Bild ändert (für diese Erkenntnis musste ich mir ein eigenes ColorModel entwickeln. :lol. Wenn man also einen Pixel in einem ARGB BufferedImage (DirectColorModel) unbedingt transparent haben will, fährt man mit [c]image.getRaster().setDataElements(x, y, new int[] {0})[/c] nach meiner Erfahrung noch am besten. In diesen ColorModellen sind dann auch immer die meist grundverschiedenen Farbwertmasken gespeichert. Für diesen Fall hier kann man es mal mit [c]image.getRaster().setDataElements(x, y, new int[] {Color.LIGHT_GRAY.getRGB()})[/c] versuchen.
[EDIT]Im übrigen finde ich nicht, dass dies ein Thema für den Anfängerbereich ist.[/EDIT]

 

[Dragnaros]

Im übrigen finde ich nicht, dass dies ein Thema für den Anfängerbereich ist.

nun ja ich fühle mich noch als anfänger und habe sonst kein passenden
ort gefunden daher dachte ich dies were die richtige entscheidung aber
nun gut nicht so schlimm ;-)

also was ich damit vorhabe ist relativ simpel ich nehme die pixel aus der
vorgefertigten grafik und mache alle rein grünen felder unsichtbar bei den roten/blauen feldern
errechne ich mir den schwarzanteil(grauwert) und ersetze die rote/blaue
durch eine vom user ausgewählte farbe und erhalte dadurch meine uhrsprüngliche
grafik mit realistischen oder zumindest mit farben die dem user
gefallen. im entgültigen programm soll dies für (haut, haar, kleidung, anderes)
möglisch seien und jeder spieler erhält einen individuellen charakter und es
müssen keine kompletten bilder geladen werden sondern nur 2 farbcodes wie
ihr euch vorstellen könnt habe ich so viel mehr möglichkeiten geschaffen
als mit festen grafiken und unmengen speicher gespart.

ich versuch mich mal ob ich mit eurer hilfe auch umgehen kann wenn
es klappt/nicht klappt melde ich mich.

herzlichen dank für die freundliche hilfe.

 

[Spacerat]

Ein Grauwert lässt sich aber auch über eine Wichtung aller 3 Komponenten errechnen, dazu musst nicht erst eine ausblenden.

int fadeToGrey(int color) { // not a Visage-Cover
  int alpha = color & 0xFF0000000; // nur filtern, verschiebung deswegen nicht nötig
  float red   = (float) ((color >> 16) & 0xFF);
  float green = (float) ((color >> 8) & 0xFF);
  float blue  = (float) (color & 0xFF);

  if(red == green && red == blue) {
    return color; // | 0xFF000000; für OPAQUE
  }

  // 0.2989 * R + 0.5870 * G + 0.1140 * B
  red   *= 0.2989;
  green *= 0.5870;
  blue  *= 0.1140;

  int grey = (int) (red + green + blue);
  color = grey;

  for(int n = 0; n < 2; n++) {
    color  = color << 8;
    color |= grey;
  }

  return color | alpha; // bzw. | 0xFF000000 für OPAQUE
}

 

[Marco13]

Suchst du sowas ähnliches wie http://www.java-forum.org/allgemeine-java-themen/118502-bild-einfaerben.html ?

 

[Dragnaros]

ok nun hab ich noch eine frage wie soll es möglichseien abzufragen ob die farbe des pixels
grün ist wen bei einer ausgabe der pixelfarbe(der pixel hat 00FF00) -16711936 kommt und
bei der ausgabe von 0x00FF00 oder 0x0000FF00 65280 raus kommt unterschiedlicher
könnten die zahlen ja kaum seien aber warum ist das so? was gibt mir getRBG den nun wirklich aus?

 

[bERt0r]

Also ich konnte mit dem int rgb Wert auch nie besonders viel anfangen. Die ganzen Bit shift Operationen sind mir einfach zu verkrampft. Marcos Link zeigt doch ganz schön, wie man ein Bild relativ schnell und unkompliziert färben kann.
Was ich noch anmerken wollte: In der Klasse Color gibts die Funktion int getRgb(). Es ist zwar sicher höchst unperformant für jeden Pixel ein eigenes Color Objekt zu erstellen, könnte dir aber beim herumprobieren helfen.

 

[Marco13]

Naja, das Hantieren mit RGB und Bit-Shifts wirkt zwar im ersten moment krampfig, ist aber das effizienteste, was man machen kann... Hast ja schon gesagt: Color-Objekte für jeden Pixel erstellen ist der Killer...

grün ist wen bei einer ausgabe der pixelfarbe(der pixel hat 00FF00) -16711936 kommt und
bei der ausgabe von 0x00FF00 oder 0x0000FF00 65280 raus kommt unterschiedlicher
könnten die zahlen ja kaum seien aber warum ist das so? was gibt mir getRBG den nun wirklich aus?

Die erste Ausgabe stammt nicht von 00FF00 sondern von FF00FF00 - also von Grün mit einem Alpha-Anteil von 255 (d.h. nicht-transparent).

Als allgemeiner Tipp: Für solche Ausgabe kann
System.out.println("0x"+Integer.toHexString(-16711936));
System.out.println("0x"+Integer.toHexString(65280));
sehr hilfreich sein (Ausgabe in diesem Fall: [c]0xff00ff00[/c] und [c]0xff00[/c]).

Nach dem, was du beschrieben hast, klingt es bisher (!) als wäre es am sinnvollsten:
- Das ganze Grün-Spezifische Zeug in Gimp oder Photoshop oder sonstwo zu machen
- Die Umwandlung von Rot/Blau in Graustufen AUCH in Gimp oder Photoshop oder sonstwo zu machen
- Das abschließende Einfärben zur Laufzeit des Programms so zu machen, wie in dem verlinkten Thread beschrieben

 

[Spacerat]

... Es ist zwar sicher höchst unperformant für jeden Pixel ein eigenes Color Objekt zu erstellen...

Die Klasse Color ist Teil eines zusammgepfuschten APIs, dem AWT (Die Seite, auf denen Sun zugibt, dass dem so ist, wurden beim Wechsel zum Oracle-Server entfernt). Color ist zudem wahrhaftig auch ein Unfall, weil Imutable.
Aber Color ist leider nicht die einzige Klasse im AWT dieser Art, BufferedImage nebst ColorModel, Raster und vor allem SampleModel gehören definitiv auch dazu, denn sie sorgen zunächst erstmal einschlägig für Verwirrung - wieso zum Henker tut [c]setRGB();[/c] nicht das was es soll, z.B. eine Farbe ebenso transparent oder anderweitig gefiltert schlicht zu setzen? Die Antwort findet man, wenn man sich diese Methode mal ansieht:

// BufferedImage - Auszug -
...
    public synchronized void setRGB(int x, int y, int rgb) {
        raster.setDataElements(x, y, colorModel.getDataElements(rgb, null));
    }
...

Daraus geht erstens hervor, dass die zu setzende Farbe noch auf Gültigkeit geprüft und ggf. durch eine gültige ersetzt wird, bevor das Raster aktualisiert wird.
Nun der Haken... sämtliche Farb-, Sample- und Rastermodelle, welche vom BufferedImage über den Konstruktor mit Breite, Höhe und Typ erzeugt werden, können vom Benutzer her nicht mehr verändert werden, bei ColorModels können z.B. keine Farben geändert, geschweige denn hinzugefügt werden - für den Erhalt des Bildformates ist daran auch nichts auszusetzen. Für Filterzwecke ist's deswegen also naheliegend, sich ein eigenes ColorModel zu schreiben (in diesem Falle eines, welches beim Aufruf von [c]getGreen(int pixel);[/c] stets 0 liefert) und eine Instanz davon an [c]new BufferedImage(myColorModel, oldImage.getRaster(), oldImage.isAlphaPremultiplied(), null)[/c] übergibt.

 

[HimBromBeere]

Die int-Rückgaben der RGB-Funktionen sind nichts weiter als die Integer-Entsprechungen der Hex-Darstellung (0x00FF00 z.B.). In dem Fall bedeutet das: 0 * 255 + (FF) * 255 + 0 * 255 = 256 * 255 = 65.280 oder so ähnlich

 

[HoaX]

Die int-Rückgaben der RGB-Funktionen sind nichts weiter als die Integer-Entsprechungen der Hex-Darstellung (0x00FF00 z.B.). In dem Fall bedeutet das: 0 * 255 + (FF) * 255 + 0 * 255 = 256 * 255 = 65.280 oder so ähnlich

Das einzig richtige hier ist definitiv das "so ähnlich" ... wie es richtig geht steht schon oben. Und wenn du selbst überlegst, solltest du merken, dass nach deiner Rechnung 0xFF das gleiche wäre wie 0xFF00 und 0xFF0000 und ...

 

[HimBromBeere]

dass nach deiner Rechnung 0xFF das gleiche wäre wie 0xFF00 und 0xFF0000 und ...

Äääääääähm, nein, da hast du mich missverstanden.

0xFF ist eine 1kanalige Darstellung (also ein Graustufenbild bzw. 8bit), 0xFF00 gibt´s gar nicht (schonmal ein Bild gesehen, das nur 2Farbkanäle besitzt, theoretisch zwar möglich, praktisch allerdings nicht existent) und 0xFF0000 ist das einzig sinnvolle in dem Zusammenhang (ein dreikanaliges (24bit) Bild)...

Das würde heißen, dass 1 genau das Gleiche ist wie 10 oder 1000... man muss schon aufpassen, für welche Potenzen die Zeichen stehen...

 

[Spacerat]

Äääääääähm, nein, da hast du mich missverstanden.

Leider hat HoaX nicht ganz unrecht. Zum Berechnen irgendwelcher RGB-Werte taugt deine Ausführung oben rein gar nicht.

brgb = b * 256^0 bzw b * 2^0  bzw b * 1
grgb = g * 256^1 bzw g * 2^8  bzw g * 256
rrgb = r * 256^2 bzw r * 2^16 bzw r * 65536
rgb = rrgb + grgb + brgb

Für einen Alphakanal käme dann noch [c]256^3 bzw 2^24 bzw 16777216[/c] hinzu. Nicht zu vergessen; Alle Werte (r, g, b und a) müssen zwischen 0 und 255 liegen, zumindest gilt das in 8-Bit-Farbsystemen. Es gibt aber auch Farbsysteme mit beliebiger Anzahl an Bits pro Farbe, gängig sind noch 1, 2 und 4, die restlichen 3, 5, 6, und 7 begegneten mir nur vor Urzeiten auf meinen Amigas.
Warum nun in Java (nicht blos dort ) Colorierung von Bildern so schwierig ist, erklärt sich halt durch die Existenz der verschiedendsten Farb- und Rastersysteme. Ehrlich... bei "hold and modify" kurz: HAM-Rastern würden einige das weite suchen, CMYK wäre da noch um einiges leichter zu verstehen. Soviel aber zum "...praktisch nicht existent...".
[EDIT]"mir nur" bedeutet natürlich nicht, dass ich der einzige bin, dem diese Systeme irgendwo begegneten... sonst stünde dort "nur mir" [/EDIT]

 

[HimBromBeere]

Ooooh, nach nochmaligem Durchlesen meines Beitrages ist mir der grawierende Fehler aufgefallen, ich hab die Potenzen natürlich vergessen, richtig wäre demnach

0 * 256^2 + (FF) * 256^1 + 0 * 256^0 = 255 * 256 = 65.280

Aber in dem Fall war´s tatsächlich Wurscht wegen der Nullen (darum ist es mir wohl auch nicht aufgefallen).
Entschuldigt vielmals die falsche Information, hoffe, das stimmt jetzt...

EDIT: Ich bin in der Komplexität diverser Farbsysteme durchaus geschult (HAM kenn ich zwar nicht, dafür aber andere Systeme und Räume wie (für jedes Gerät muss man ja ´ne eigene Farbumrechnung definieren, was dank Lab aber nicht mehr so umständlich ist)). Die Farbtiefe hat damit aber erstmal nix zu tun, ich kann auch ein einkanaliges Bild mit 16bit darstellen (oder ein dreikanaliges mit nur 1bit). Interessant wird´s bei einigen Bildformaten (wie GIF), wo es keine wirkliche Farbtiefe gibt (da dem Format eine Farbpalette zugrunde liegt), wodurch sich die Berechnung von Grauwerten natürlich auch etwas unterscheidet. Aber ich schweife ab...


Wie dem auch sei... die obige Berechnung ist hier zumindest das Themenführende

EDIT: So, nun aber wirklich Danke Spacerat

 

[Dragnaros]

Tja mein programm leuft so weit ich hab die schwierigen stellen umgangen indem ich eine grafik als
vorlage nutze wo nur bestimte farben ferwendedt werden diese filter ich in einer schleife mit if und
änder sie direkt transparenz bleibt erhalten und beim rendern der grafik lasse ich die graustufen aus
einer paralelen grafik einfach darüberrendern ist zwar nicht was ich wollte hat aber den gleichen effekt.

ich habe mir das problem aber notiert und werde mich damit nocheinmal befassen wen ich mit java
besser umgehen kann im moment ist das noch etwas zu hoch für mich und ich will ja auch mal
weiterkommen