hsv nach rgb für 12Bit

[Frank L. (franklink)]

Hallo zusammen,
bei der Entwicklung eines Weihnachtsgeschenkes ist eine 12Bit HSV nach 
RGB Routine abgefallen, die ich hier gerne veröffentlichen möchte.

Die Werte für H, S und V können zwischen 0 und 4095 liegen.

Gruß
Frank

[Frank L. (franklink)]

Hallo zusammen,
leider hat sich ein kleiner Fehler in die Routine eingeschlichen.

In der Berechnung für die Variablen q fehlt ein Typecast.

Die korrekte Zeile lautet:

q = (uint16_t)( ( value->V * ( ( 2796885 - ( value->S * (uint32_t)f ) ) / 683 ) ) / 4096 );

Im Anhang mal ein vollständiger Plot aller RGB-Werte für den kompletten 
HSV-Farbraum berechnet über die Funktion.

Der Plot legt die Werte H = {0..4095}; S = 4095 und V = 4095 zu Grunde.

Gruß
Frank

[Micha K. (Gast)]

Anbei der Code etwas abgeändert damit er ohne den struct funktioniert.

  uint16_t q = 0;
  uint16_t p = 0;
  uint16_t t = 0;
  
  uint8_t i = 0;
  uint16_t f = 0;
  
  if (s == 0) {
    
    *red = *green = *blue = v;
    
  } else {
    
    i = h / 683;
    f = h % 683;
    p = (uint16_t)( ( v * ( 4095 - s ) ) / 4096 );
    q = (uint16_t)( ( v * ( ( 2796885 - ( s * (uint32_t)f ) ) / 683 ) ) / 4096 );
    t = (uint16_t)( ( ( v * ( ( 2796885 - ( s * ( 683 - ( (uint32_t)f ) ) ) ) / 683 ) ) ) / 4096 );
  
    switch(i) {
    case 0:
      *red = v;
      *green = t;
      *blue = p;
      break;
    
    case 1:
      *red = q;
      *green = v;
      *blue = p;
      break;
    
    case 2:
      *red = p;
      *green = v;
      *blue = t;
      break;
    
    case 3:
      *red = p;
      *green = q;
      *blue = v;
      break;
    
    case 4:
      *red = t;
      *green = p;
      *blue = v;
      break;
    
    default:
      *red = v;
      *green = p;
      *blue = q;
      break;
    }
    
  }

[devmo (Gast)]

@ Micha,
vielleicht kannst du deine Änderung komplettieren? Zumindest die 
Var.deklaration red, green, blue, fehlt hier, nur damit für andere keine 
Verwirrung entsteht

[Moritz E. (devmo)]

Ich habe die halbe Nacht damit verbracht, den Code etwas anzupassen, 
vielleicht ist er für andere nützlich. Ursprünglich habe ich vorallem 
die Divisionen durch skalierte Multiplikationen ersetzt, nach debuggen 
habe ich die Formeln nochmal umgebaut, insbesondere die switch-case 
Fallunterscheidung stimmte nicht mit dem Artikel von Wikipedia überein. 
Nach weiterem Test tut diese Version das was sie soll.

Im Prinzip ist alles auf 12bit skaliert, also alles was nach 
Wikipediaartikel auf [0..1) definiert ist, ist hier auf [0..4095] 
skaliert.

Als verbliebene Ungenauigkeit kommen t und evtl. weitere teilweise nicht 
ganz an 4095 heran (z.B. Maxwert 4088, wenn Hue als Mischfarbe).

/********header************************************************************************************  
 *  
 *   pwm_hsv.c      pwm_hsv.h
 *
 *********************************************************************************************/

#ifndef pwm_hsv_h
  #define pwm_hsv_h


typedef uint16_t ( *rgb_triplet_ptr_t)[3];

typedef uint16_t rgb_triplet_t[3];

  rgb_triplet_t * hsv2rgb12(uint16_t h, uint16_t s, uint16_t v);

  void Unittest_pwm_hsv(void);

#endif

/********************************************************************************************  
 *  
 *   pwm_hsv.c      pwm_hsv.h    03.04.2012
 *  
 *      Author: Devmo
 ********************************************************************************************/
#include <util/atomic.h>
#include <avr/cpufunc.h>
#include <avr/pgmspace.h>

#include "pwm_hsv.h"
#include "../mod_math/mod_math.h"



rgb_triplet_t rgb;

#define TOP12        4095
#define TOP12ceil      4096

#define TOP12_12      16769025    //4095*4095
#define MUL_COEF_i_6_4096  6

  rgb_triplet_t (* rgb_ptr) = &rgb;
  uint16_t q;
  uint16_t p;
  uint16_t t;
  uint8_t i;
  uint32_t tmp32;
  uint16_t f, tmp16, i16;

rgb_triplet_t * hsv2rgb12(uint16_t h, uint16_t s, uint16_t v)  //256clk ... 1223clk
{

//      folgendes auskommentiert und oben deklariert für debugging:
//  rgb_triplet_t (* rgb_ptr) = &rgb;

//  uint16_t q;
//  uint16_t p;
//  uint16_t t;

//  uint8_t i;
//  uint32_t tmp32;
//  uint16_t f, tmp16;

  if( s == 0 )
   {
      rgb[0] = v;
    rgb[1] = v;
    rgb[2] = v;
  }
  else
  {  

//--------------------------------------------------------------------------
//  i = h / (top12/6)
//--------------------------------------------------------------------------

    tmp32 = MAT_MULU32(h, (uint16_t)MUL_COEF_i_6_4096);      //skaliert i: scaledres = wert i * 2^12    top max = 15bit
    i16 = (uint16_t)tmp32;                    //zwischenergebnis: scaledres = ungerundeter wert i * 2^12 + (6)
    i = (uint8_t)(tmp32 >> 12);                  //rückskalieren: scaledres/2^12 = wert,     top max = 3bit (5) 

    tmp16 = ((uint16_t)i << 12);                //zwischenergebnis: scaledres = gerundeter wert i * 2^12 + (5)

//--------------------------------------------------------------------------
//  F = h - h_floor +, F = [0..1)
//--------------------------------------------------------------------------

      f = i16 - tmp16;                      //f [0..1) skaliert : scaledres = wert f * 2^12



//--------------------------------------------------------------------------
//  p = v * (1 - s), mit p,s,v = [0..1)    ->    P_12 = ((V_12 * (top12 - S_12)_12)_24)>>12, mit scaled P,S,V = wert p,s,v * 2^12
//--------------------------------------------------------------------------

    // TOP12 - s
    tmp16 = ((uint16_t)TOP12 - s);

    // v * ans
      tmp32 = MAT_MULU32(v, tmp16);              //scaledres = wert p * 2^24      //127clk    //172clk

      // von 24 auf 12bit skalieren  
      p = (uint16_t)(tmp32>>12);                //rückskalieren: scaledres = wert p * 2^12


//--------------------------------------------------------------------------
//  q = v * ( 1 - (s * f)), mit q,s,v, f = [0..1)  ->  Q_12 = ((V_12 * ((top24 - (S_12*F_12)_24)>>12)_12)_24)>>12
//--------------------------------------------------------------------------

    
      // s * f       
      tmp32 = MAT_MULU32(s, f);   //top max = 24bit         

      // TOP12_12 - ans      
      tmp32 = ((uint32_t)TOP12_12 - tmp32 );  //top max = 24 bit,   

        // von 24 auf 12bit skalieren  
        tmp16 = (uint16_t)(tmp32 >> 12);                   

      // v * ans
      tmp32 = MAT_MULU32(v, tmp16);                       

        //von 24 auf 12 bit skalieren)
        q = (uint16_t)(tmp32 >> 12);                


//--------------------------------------------------------------------------
//  t = v * (1 - s * (1 - f)), mit t,s,v, f = [0..1)  ->    T_12 = ((V_12 * (( TOP24 - (S_12 * (TOP12 - F_12)_12 )_24 )>>12)_12)_24)>>12 
//--------------------------------------------------------------------------

    //TOP12 - F_12
    tmp16 = (uint16_t)TOP12 - f;  


    // S_12 * ans_12
    tmp32 = MAT_MULU32(s, tmp16);          //top max = 24bit

    // TOP24 - ans_24
    tmp32 = ((uint32_t)TOP12_12 - tmp32 );      //top max = 24 bit,

        // von 24 auf 12bit skalieren  
        tmp16 = (uint16_t)(tmp32 >> 12);  
      

    // V_12 * ans_12
    tmp32 = MAT_MULU32(v, tmp16);

        //von 24 auf 12 bit skalieren)
        t = (uint16_t)(tmp32 >> 12);      //top max = 12 bit

  
      switch(i) 
    {
        case 0:
      case 6:
            rgb[0] = v;
            rgb[1] = t;
            rgb[2] = p;
            break;
    
        case 1:
            rgb[0] = q;
            rgb[1] = v;
            rgb[2] = p;
            break;
    
        case 2:
            rgb[0] = p;
            rgb[1] = v;
            rgb[2] = t;
            break;
    
        case 3:
            rgb[0] = p;
            rgb[1] = q;
            rgb[2] = v;
            break;
    
        case 4:
            rgb[0] = t;
            rgb[1] = p;
            rgb[2] = v;
            break;
    
        case 5:
            rgb[0] = v;
            rgb[1] = p;
            rgb[2] = q;
            break;
      default:
        _NOP();
    }
  }

  return rgb_ptr;
}



//--------------------------------------------------------------------------
//  Unit Test
//--------------------------------------------------------------------------
#include <avr/pgmspace.h>




uint16_t th, ts, tv;

const uint16_t hsv_input_h[6];
const uint16_t hsv_input_s[3];
const uint16_t hsv_input_v[8];

typedef struct 
{
  volatile rgb_triplet_t input;
  volatile rgb_triplet_t output;
}
struct_hsv_in_out_t;

struct_hsv_in_out_t volatile hsv_res_vekt[8];

rgb_triplet_t * tmp_rgb_ptr;

void Unittest_pwm_hsv(void)
{
  for (uint8_t l = 0; l <6; l++)
  {
    for (uint8_t m = 0; m <3; m++)
    {
      for (uint16_t n = 0; n<8; n++)
      {
        th = (uint16_t) pgm_read_word(hsv_input_h + l);
        ts = (uint16_t) pgm_read_word(hsv_input_s + m);
        tv = (uint16_t) pgm_read_word(hsv_input_v + n);

        hsv_res_vekt[n].input[0] = th;
        hsv_res_vekt[n].input[1] = ts;
        hsv_res_vekt[n].input[2] = tv;
        
        tmp_rgb_ptr = hsv2rgb12(th, ts, tv);

        hsv_res_vekt[n].output[0] = (*tmp_rgb_ptr)[0];
        hsv_res_vekt[n].output[1] = (*tmp_rgb_ptr)[1];
        hsv_res_vekt[n].output[2] = (*tmp_rgb_ptr)[2];

        _NOP();
      }
      _NOP();
    }
    _NOP();
  }
}  

const uint16_t hsv_input_h[6] PROGMEM =
{//  rot    grün  blau  gr-bl bl-rt rt-gr
  4095, 1365, 2730, 2047, 3412, 680
};

const uint16_t hsv_input_s[3] PROGMEM =
{
  0, 1023, 4095
};

const uint16_t hsv_input_v[8] PROGMEM = 
{
  1, 3, 11, 35, 116, 380, 1248, 4095
};

[Joe D. (Gast)]

Woher kommt im Code die Zahl "2796885" ?

Und wie sind die Formeln aus Franks Code mit der Grundlage des 
Wikipedia-Artikels zur Konvertierung HSV nach RGB vergleichbar?

Ich sehe hier keinerlei Zusammenhang bezüglich der Berechnung der 
Variablen i, f, p, q, t.


Vielen Dank für jeden Hinweis!

[Frank L. (frank_l)]

Hallo,

die Berechnung erfolgt wie folgt für 12 Bit:

60° -> 683 -> (4096 / 360°) * 60° -> 683,5
 1 -> 682 * 4095

Gruß
Frank

[Joe D. (Gast)]

Hallo Frank, vielen Dank für Deine Antwort.


Frank L. schrieb:
> Hallo,
>
> die Berechnung erfolgt wie folgt für 12 Bit:
>
> 60° -> 683 -> (4096 / 360°) * 60° -> 683,5
>  1 -> 682 * 4095

Mit anderen Worten: 360° für den Hue-Wert entsprechen in 12 Bit dann der 
2796885?
Während dann für Hue = 1° gilt:

1° -> 2796885 / 360° = 62153/8


Danke!

Gruß