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

[Ceos]

Sorry dass ich nicht früher antworten konnte, hatte nicht viel gelegenheit überhaupt mal länger als 5 Minuten ins Forum zu schauen.

Mir ist da ein Denkfehler passiert, bei der Rückrechnung der einzelnen Komponenten stimmt zumindest schonmal deine Formel, bei der Umrechnung von Komponenten auf RGB16 allerdings ist rigendwas schief, da komme ich auf einen anderen Wert.

Der primäre Denkfehler liegt jedoch beim Rückrechnen von RGB16 auf R G B

G wird hier mit 6Bit aufgelöst, also müsste man streng genommen >> 6 statt >> 5 machen ... was allerdings der größte Denkfehler von mir war ... die Werte sind doch nur 5 bzw. 6Bit groß und müssten ja nochmal auf 8Bit aufgeblasen werden (inklusive eines Verlust der Auflösung selbsttverständlich)

Und ich glaube beim Maskieren und schieben ist auch noch ein dreher drinne ... ich habe immer die MSB ausmaskiert und da kann nur blödsinn bei rauskommen XD

Ich versuche heute Nachmittag mal eine Korrektur, da ich jetzt noch was wegschaffen muss bevor hier alles abbrennt

[HaWe]

besten Dank schon im vorraus - mach dir aber keinen Stress, es ist absolut nicht eilig, es hatte mich nur stutzig gemacht!

[Moppi]

Das mit dem Konvertieren der Farben ist so eine Sache, das kann man machen, es kommt aber nicht unbedingt das gewünschte Ergebnis heraus. Da die Farbgewichtung auch eine Rolle spielt. Ohne das weiter kompliziert zu machen, kommt es bei der einfachen Farbanpassung per Logikoperatoren teils zu falschen Farbdarstellungen beim Ziel. Das sollte man nur mal so im Hinterkopf haben. 
Ansonsten ist RGB-5-6-5, 5Bit für Rot, 6Bit für Grün und 5Bit für Blau. 
Bei RGB-8-8-8, jeweils 8Bit für eine Farbe. 

RGB 8-8-8: 11111111-11111111-11111111
RGB 5-6-5: xxx11111-xx111111-xxx11111

Schiebe die ersten 8 Bit nach rechts, um 3 Stellen.
Schiebe die zweiten 8 Bit nach rechts, um 2 Stellen.
Schiebe die dritten 8 Bit nach rechts, um 3 Stellen.

int rot1 = rot/8; int gruen1 = gruen/4; int blau1 = blau/8;

Das Problem dabei: Grün ist anders gewichtet, das kann sich in einem Grünstich des Bildes bemerkbar machen.

Rückwärts geht es genau andersrum:

Schiebe die ersten 5 Bit nach links, um 3 Stellen.
Schiebe die zweiten 6 Bit nach links, um 2 Stellen.
Schiebe die dritten 5 Bit nach links, um 3 Stellen.

int rot = rot1*8; int gruen = gruen1*4; int blau = blau1*8;

--------------------------

Die einzelnen Farben aus rgb-8-8-8 nach rgb-5-6-5:

r = rgb888/524288;
g = (rgb888/1024)&63;
b = (rgb888/8)&31;

Ganze RGB-Werte umrechnen:

rgb565 =  ((  ((rgb888/524288)*64) | ((rgb888/1024)&63)  )*32) | ((rgb888/8)&31);

10111000 10101100 10101000 =>  ((1472 | 43) * 32) | 21 => 1011110101110101

und zurück (als Probe):

rgb888 = ((rgb565 & 63488) * 256) | ((rgb565 & 2016) * 32) | ((rgb565 & 31) * 8)

1011110101110101 => (12058624 | 44032) | 168 => 10111000 10101100 10101000

[HaWe]

danke für den Post!
ich habe jetzt neu codiert:

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

   return  ((uint16_t)R << 11) | (((uint16_t)G << 5) & 0b0000011111100000) | ((uint16_t)B & 0b0000000000011111);
}


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

   R = (uint8_t)(color16/524288);
   G = (uint8_t)(color16/1024);
   B = (uint8_t)((color16/8)&31);
   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:

}

und bekomme jetzt den output:

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

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

Unterprogramm color16 zu RGB:
color16=64718
R=0
G=63
B=25

Hauptprogramm nach col16 zu rgb:
col16=64718
r=0
g=63
b=25

hmmmm...

[Moppi]

G = (uint8_t)(color16/1024);

muss, wenn dann so:

G = (uint8_t)(color16/1024)&63;

Allerdings schreibst Du "color16". sind das als Quelle 16Bit-Farben? RGB-8-8-8 sind 24Bit-Farben. RGB-5-6-5 sind 16Bit-Farben.

[HaWe]

ja, es handelt sich immer um die 16-bit Zahlen
r,g,b haben immer die volle range von 0-255, die dann nur anders in die 16- bzw. auch optional 24-bit oder 32-bit truecolor umkodiert werden sollen.

[Moppi]

Ich hatte gelesen, Du schriebst, dass nicht so einfach ist, wie in HTML - Farben für Webseiten. Die sind dort 8bit-8bit-8bit (style="color:#452f63"), 45h - 2fh - 63h. Macht 24Bit.

Von welchem Farbformat, nach welchem muss es denn?

"r,g,b haben immer die volle range von 0-255, die dann nur anders in die 16- bzw. auch optional 24-bit oder 32-bit truecolor umkodiert werden sollen."

Dann ist es 8-8-8 nach 5-6-5. Wo ist der Fehler?

sinngemäß wäre so richtig:

G = (uint8_t)(color24/1024)&63;

Allerdings kann man die 24Bit-Farbe natürlich nur in ein 32Bit-Register packen. Um in einem Stück zu rechnen.
Dumm gelaufen, wenn der Arduino nur 16Bit-Register hat Vor Jahren noch hätte ich das jetzt einfach auf 16Bit-Operationen aufgeteilt, als ich noch in Übung war. So muss ich nochmal drüber nachdenken.

Nachtrag:

Vorher war der ganze 24Bit-Farbwert: rgb888

Wenn die Farbwerte einzeln vorliegen, ist es so, wie ich Anfangs schrieb:

int rot1 = rot/8; int gruen1 = gruen/4; int blau1 = blau/8;

So wird aus Rot mit 8 Bit, Rot mit 5 Bit, aus Grün mit 8 Bit, wird Grün mit 6 Bit, aus Blau mit 8 Bit, wird Blau mit 5 Bit.

[HaWe]

ja, ich habe ja schon mal einen Benchmarktest für verschiedene MCUs geschrieben, könnte ich mal machen



- - - Aktualisiert - - -

edit: Code aktualisiert nach Ceos' Einwand (s.u.!)

#define TimerMS() millis()  //for  cross plattform compatib
uint32_t time0;

long test_Int_multdiv2() {
  uint32_t  x,y;
  volatile uint32_t  s;

  for(y=0;y<10000;y++) {
    s=11;
    for(x=1;x<=16;x++) { s*=2;}
    for(x=16; x>0;x--) { s/=2;}
    s=7;
    for(x=1;x<=8;x++) { s*=8;}
    for(x=8; x>0;x--) { s/=8;}
  }
  return s;
}


long test_Int_shl_shr() {
  uint32_t  x,y;
  volatile uint32_t  s;

  for(y=0;y<10000;y++) {
    s=11;
    for(x=1;x<=16;x++) { s=(s<<1);}
    for(x=16; x>0;x--) { s=(s>>1);}
    s=7;
    for(x=1;x<=8;x++) { s=(s<<3);}
    for(x=8; x>0;x--) { s=(s>>3);}
  }
  return s;
}


// *SNIP*


  time0=TimerMS();
  s=test_Int_multdiv2();
  runtime[0]=TimerMS()-time0;
  sprintf (buf, "%3d %9ld  Int_multdiv2",   0, runtime[0]); Serial.println( buf);


 time0=TimerMS();
  s=test_Int_shl_shr();
  runtime[1]=TimerMS()-time0;
  sprintf (buf, "%3d %9ld  Int_shl_shr",   1, runtime[1]); Serial.println( buf);

Ergebnis: doch identisch, anders als vermutet (Angaben in ms):


Plattform: AVR (Arduino Mega2560, 16 MHz)

start test
  0      1220  Int_multdiv2
  1      1220  Int_shl_shr

Plattform: ARM Cortex M0 (Adafruit Itsybitsy M0, 48 MHz)

start test
  0        93  Int_multdiv2
  1        93  Int_shl_shr

Plattform: ARM Cortex M3 (Arduino Due, 84MHz)

start test
  0        49  Int_multdiv2
  1        49  Int_shl_shr

Pattform: ESP8266 (nodeMCU, Xtensa LX106, 80 MHz)

start test
start test
  0        56  Int_multdiv2
  1        55  Int_shl_shr

edit:
gleiches Ergebnis auch für Zuweisung an 2. Variable:

long test_Int_multdiv2() {
  uint32_t  x,y;
  volatile uint32_t  s,t;

  for(y=0;y<10000;y++) {
    s=11;
    for(x=1;x<=16;x++) { t=s*2;}
    for(x=16; x>0;x--) { t=s/2;}
    s=7;
    for(x=1;x<=8;x++) { t=s*8;}
    for(x=8; x>0;x--) { t=s/8;}
  }
  return s;
}


long test_Int_shl_shr() {
  uint32_t  x,y;
  volatile uint32_t  s,t;

  for(y=0;y<10000;y++) {
    s=11;
    for(x=1;x<=16;x++) { t=(s<<1);}
    for(x=16; x>0;x--) { t=(s>>1);}
    s=7;
    for(x=1;x<=8;x++) { t=(s<<3);}
    for(x=8; x>0;x--) { t=(s>>3);}
  }
  return s;
}

[Ceos]

hey moment mal, du schummelst doch :P

mach mal aus (s << 1) ein s = (s << 1) bzw. 3 natürlich, du schiebst hier eine zahl aber sie wird nicht gespeichert, wenn dem so ist optimiert er den inhalt der schleife wahrscheinlich einfach weg und du hast nur eine leere schleife gemessen

bei der multiplikation und division machst du ja auch eine zuweisung

EDIT: by the way hab cih das mit dem barrel shifter wohl falsch verstanden, den gibt es wohl für links als auch für rechts, aber atmel benutzt beim rsr scheinbar nicht immer den barrel shifter, das warum hat sich mir aus den bisherigen topics nicht wirklich erscshlossen, aber es scheint wohl ein bekanntes phänomen zu sein (primär englische atmel foren die sich mit komplexerer verwendung beschäftigen und nciht mit so trivialen tests)

[HaWe]

hey moment mal, du schummelst doch :P

kleiner Aufmerksamkeitstest

ich korrigiere es sofort!

edit:
Korrektur, sind doch immer jeweils identisch, ist oben korrigiert!