Farben nach R,G,B umwandeln in 4-stell. hex-code?

[Moppi]

Demnach müsste es so sein, von R,G,B Einzelwerten zu 16Bit-Werten:

rgb =  ((rot/8)*2048) | ((grün/4)*32) | (blau/8);

und zurück müsste dann so sein:

rot = (rgb/2048)*8; 
grün = (rgb&2016)/8;
blau = (rgb&31)*8;

[HaWe]

hast du das mal selber getestet? Ich hatte doch den Arduino Code gepostet...

uint16_t ColorRGB216bit(uint16_t R, uint16_t G, uint16_t B) {

   return  ((R/8)*2048) | ((G/4)*32) | (B/8);
}


void Color16bit2colorRGB(uint16_t color16, uint16_t &R, uint16_t &G, uint16_t &B) {

   R = (uint8_t)(color16 / 2048)*8;
   G = (uint8_t)(color16 & 2016)/8;
   B = (uint8_t)(color16 &31)*8;
   Serial.println("");
   Serial.println("Unterprogramm color16 zu RGB:");
   Serial.println( (String)"color16="+(String)color16);
   Serial.println( (String)"R="+(String)R);
   Serial.println( (String)"G="+(String)G);
   Serial.println( (String)"B="+(String)B); 
}

void setup() {
  // put your setup code here, to run once:

   uint16_t r=255, g=102, b=78, 
            col16=0;               // 0xFF66B2;  // Dark Pink (255,102,78)


   Serial.begin(115200);
   delay(3000);
   
   Serial.println("Hauptprogramm vor Aufruf:");
   Serial.println( (String)"col16="+(String)col16);
   Serial.println( (String)"r="+(String)r);
   Serial.println( (String)"g="+(String)g);
   Serial.println( (String)"b="+(String)b);
   Serial.println("");
   
   col16=ColorRGB216bit(r,g,b);
   r=g=b=0; // Rücksetzen!

   Serial.println("Hauptprogramm nach rgb zu col16-Berechnung (rgb gelöscht):");
   Serial.println( (String)"col16="+(String)col16);
   Serial.println( (String)"r="+(String)r);
   Serial.println( (String)"g="+(String)g);
   Serial.println( (String)"b="+(String)b);
   
   Color16bit2colorRGB(col16, r, g, b);
   Serial.println("");
   Serial.println("Hauptprogramm nach col16 zu rgb:");
   Serial.println( (String)"col16="+(String)col16);
   Serial.println( (String)"r="+(String)r);
   Serial.println( (String)"g="+(String)g);
   Serial.println( (String)"b="+(String)b);   
    
}

void loop() {
  // put your main code here, to run repeatedly:

}

ergibt:

Hauptprogramm vor Aufruf:
col16=0
r=255
g=102
b=78

Hauptprogramm nach rgb zu col16-Berechnung (rgb gelöscht):
col16=64297
r=0
g=0
b=0

Unterprogramm color16 zu RGB:
color16=64297
R=248
G=4
B=72

Hauptprogramm nach col16 zu rgb:
col16=64297
r=248
g=4
b=72

Teste doch bitte mal selber, sei so nett...

[Moppi]

Ich guck mal, ob noch ein Fehler drin ist.

Hier mal die Hin-Rechnung:

r=255, g=102, b=78

r=11111111, g=01100110, b=01001110

muss ergeben: 11111 011001 01001 = 64297

rgb =  ((rot/8)*2048) | ((grün/4)*32) | (blau/8);

rgb     = 11111 000000 00000 
        | 00000 011001 00000 
        | 00000 000000 01001
        --------------------
          11111 011001 01001

        = 64297

und das Ganze zurück:

rgb = 64297;

rot = (rgb/2048)*8;     =>      11111000   => 248
grün = (rgb&2016)/8;    =>      01100100   => 100
blau = (rgb&31)*8;      =>      01001000   => 72

So weit ich das sehe, ist das richtig so, wenn ich die Bitmuster vergleiche.

Mit den Werten Rot=248, Grün=100 und Blau=72 müsste das Hin und Zurück dann stimmen.
Auf die Originalwerte kann man nicht kommen, weil man 24Bit-Farbe auf 16Bit-Farbe komprimiert, das ist verlustbehaftet - die unteren Bits gehen hier verloren und können nicht rekonstruiert werden. 16Bit-Farben haben einen kleineren Farbraum als 24Bit-Farben.

Allerdings benötigt man für diese Berechnungen:

rot = (rgb/2048)*8; ... etc.

16 Bit. Die Berechnung muss mit 16 Bit stattfinden und dann am Ende könnte man auf 8 Bit umwandeln, weil im Ergebnis nur noch die unteren 8 Bit der Berechnung belegt sind.

Ich denke Dein Problem liegt hier:

R = (uint8_t)(color16 / 2048)*8;

sieht für mich so aus, als ob die gesamte Berechnung mit 8 Bit durchgeführt werden soll(!?).

Eventuell so besser (ohne jede Gewähr):

(uint8_t) R = (color16 / 2048)*8;

Weiß ich aber nicht, weil ich diese sprachspezifischen Sachen hier nicht gut so kenne. Aber ich denke, Du weißt, was ich meine.

Oder mach es so:

int R = (color16 / 2048)*8;

Die obersten 8 Bit sind nach erfolgter Berechnung sowieso nicht belegt. Normalerweise switcht man auch zwischen den Datentypen nicht so oft hin und her. Das dürfte Zeit kosten, wenn aus 16 Bit-Operanden 8 Bit-Operanden gemacht werden und umgekehrt. Da sind bestimmt unnütze Operationen, die der Compiler für Dich einbaut. Ich würde es bei den Datentypen für die Farben immer bei 16 Bit belassen. Vielleicht kann man das später aus Platzgründen optimieren, aber erst mal sollte man schauen, dass es funktioniert.

[HaWe]

...danke für die Idee..und, schon getested...?

[Moppi]

Nein, ich habe das von Hand gerechnet. Du hattest ja nur auf dem Rückweg Probleme, mit den Berechnungen, daher denke ich, dass es was mit dem 8 Bit-Gedöhns zu tun hat. Ich habe die Rechnung genau aufgeschlüsselt. Kann man nachvollziehen und überprüfen.

[Ceos]

Ich habe die Berechnung gerade einmal in einem Excel Blatt angelegt um es verständlich zu machen

https://puu.sh/BsLSg/6fe9cf4a10.png

ich liefere später noch etwas code nach, wenn mein kopf sich von dem krampf auf arbeit erholt hat XD

ich sehe im moment nur miraculi vor augen

man kann den leichten farbunterschied durch die skallierung von 5 bzw. 6 bit doch besser erkennen als mir lieb ist XD

[Moppi]

HaWe, soll das auf Arduino laufen?

Nächstes mal komme ich vorbei und haue Dich! Schreibt der Kerl "...bevor du einen falschen Lösungsweg postest". Tse, tse, tse!

Was hältst Du denn von dieser Ausgabe mit Deinem Programm? Sieht das besser aus? :

Hauptprogramm vor Aufruf:
col16=0
r=255
g=102
b=78

Hauptprogramm nach rgb zu col16-Berechnung (rgb gelöscht):
col16=64297
r=0
g=0
b=0

Unterprogramm color16 zu RGB:
color16=64297
R=248
G=100
B=72

Hauptprogramm nach col16 zu rgb:
col16=64297
r=248
g=100
b=72

[HaWe]

da bin ich jetzt gespantn (ich habs noch nicht hingekriegt, evtl was falsch verstanden)

[HaWe]

leider nein, stimmt immer noch nicht.

Bitte teste es doch vorher selber, bevor du einen falschen Lösungsweg postest.

uint16_t ColorRGB216bit(uint16_t R, uint16_t G, uint16_t B) {

   return  (uint16_t)((R/8)*2048) | (uint16_t)((G/4)*32) | (uint16_t)(B/8);
}


void Color16bit2colorRGB(uint16_t color16, uint16_t &R, uint16_t &G, uint16_t &B) {

   R = (uint8_t)(color16 / 2048)*8; ;
   G = (uint8_t)(color16 & 2016)/8;;
   B = (uint8_t)(color16 & 31)*8;
   Serial.println("");
   Serial.println("Unterprogramm color16 zu RGB:");
   Serial.println( (String)"color16="+(String)color16);
   Serial.println( (String)"R="+(String)R);
   Serial.println( (String)"G="+(String)G);
   Serial.println( (String)"B="+(String)B); 
}

void setup() {
  // put your setup code here, to run once:

   uint16_t r=255, g=102, b=78, 
            col16=0;               // 0xFF66B2;  // Dark Pink (255,102,78)


   Serial.begin(115200);
   delay(3000);
   
   Serial.println("Hauptprogramm vor Aufruf:");
   Serial.println( (String)"col16="+(String)col16);
   Serial.println( (String)"r="+(String)r);
   Serial.println( (String)"g="+(String)g);
   Serial.println( (String)"b="+(String)b);
   Serial.println("");
   
   col16=ColorRGB216bit(r,g,b);
   r=g=b=0; // Rücksetzen!

   Serial.println("Hauptprogramm nach rgb zu col16-Berechnung (rgb gelöscht):");
   Serial.println( (String)"col16="+(String)col16);
   Serial.println( (String)"r="+(String)r);
   Serial.println( (String)"g="+(String)g);
   Serial.println( (String)"b="+(String)b);
   
   Color16bit2colorRGB(col16, r, g, b);
   Serial.println("");
   Serial.println("Hauptprogramm nach col16 zu rgb:");
   Serial.println( (String)"col16="+(String)col16);
   Serial.println( (String)"r="+(String)r);
   Serial.println( (String)"g="+(String)g);
   Serial.println( (String)"b="+(String)b);   
    
}

void loop() {
  // put your main code here, to run repeatedly:

}

Hauptprogramm vor Aufruf:
col16=0
r=255
g=102
b=78

Hauptprogramm nach rgb zu col16-Berechnung (rgb gel⸮scht):
col16=64297
r=0
g=0
b=0

Unterprogramm color16 zu RGB:
color16=64297
R=248
G=4
B=72

Hauptprogramm nach col16 zu rgb:
col16=64297
r=248
g=4
b=72