WCudaMSE/BilatTools_CPP/src/core/tools/cpp/namespace_cpu/ColorTools_CPU.cpp

   1 /*
   2  * The two methode HSB_TO_RGB and RGB_TO_HSB are from http://www.easyrgb.com/index.php?X=MATH&H=21#text21
   3  */
   4 #include "ColorTools_CPU.h"
   5
   6 #define max(a,b) (a>=b?a:b)
   7 #define min(a,b) (a<=b?a:b)
   8
   9 namespace cpu
  10     {
  11
  12 //#define RED_MASK      0x000000FF
  13 //#define GREEN_MASK    0x0000FF00
  14 //#define BLUE_MASK     0x00FF0000
  15 //#define ALPHA_MASK    0xFF000000;
  16
  17     /*--------------------------------------*\
  18 |*               HSB_TO_RVB             *|
  19      \*-------------------------------------*/
  20
  21     void ColorTools::HSB_TO_RVB(const float3& hsb, uchar4* ptrRVBA)
  22         {
  23         ColorTools::HSB_TO_RVB(hsb.x, hsb.y, hsb.z, &ptrRVBA->x, &ptrRVBA->y, &ptrRVBA->z);
  24         }
  25
  26     void ColorTools::HSB_TO_RVB(float h01, uchar4* ptrRVBA)
  27         {
  28         ColorTools::HSB_TO_RVB(h01, 1.0f, 1.0f, &ptrRVBA->x, &ptrRVBA->y, &ptrRVBA->z);
  29         }
  30
  31     void ColorTools::HSB_TO_RVB(float h01, float s01, float b01, uchar4* ptrRVBA)
  32         {
  33         ColorTools::HSB_TO_RVB(h01, s01, b01, &ptrRVBA->x, &ptrRVBA->y, &ptrRVBA->z);
  34         }
  35
  36     /**
  37      * Inputs :
  38      *  H,S,B valeur comprise entre [0,1]
  39      *
  40      * Outpus :
  41      *  R,G,B le resultat compris dans les valeurs [0-255]
  42      */
  43     void ColorTools::HSB_TO_RVB(const float H, const float S, const float V, unsigned char *ptrR, unsigned char *ptrG, unsigned char *ptrB)
  44         {
  45         if (S == 0) //HSV from 0 to 1
  46             {
  47             *ptrR = V * 255;
  48             *ptrG = V * 255;
  49             *ptrB = V * 255;
  50             }
  51         else
  52             {
  53             float var_h = H * 6;
  54             if (var_h == 6)
  55                 {
  56                 var_h = 0;
  57                 } //H must be < 1
  58
  59             unsigned char var_i = (unsigned char) var_h; //Or ... var_i = floor( var_h )
  60             float var_1 = V * (1 - S);
  61             float var_2 = V * (1 - S * (var_h - var_i));
  62             float var_3 = V * (1 - S * (1 - (var_h - var_i)));
  63
  64             float var_r, var_g, var_b;
  65             if (var_i == 0)
  66                 {
  67                 var_r = V;
  68                 var_g = var_3;
  69                 var_b = var_1;
  70                 }
  71             else if (var_i == 1)
  72                 {
  73                 var_r = var_2;
  74                 var_g = V;
  75                 var_b = var_1;
  76                 }
  77             else if (var_i == 2)
  78                 {
  79                 var_r = var_1;
  80                 var_g = V;
  81                 var_b = var_3;
  82                 }
  83             else if (var_i == 3)
  84                 {
  85                 var_r = var_1;
  86                 var_g = var_2;
  87                 var_b = V;
  88                 }
  89             else if (var_i == 4)
  90                 {
  91                 var_r = var_3;
  92                 var_g = var_1;
  93                 var_b = V;
  94                 }
  95             else
  96                 {
  97                 var_r = V;
  98                 var_g = var_1;
  99                 var_b = var_2;
 100                 }
 101
 102             //RGB results from 0 to 255
 103             *ptrR = (unsigned char) (var_r * 255);
 104             *ptrG = (unsigned char) (var_g * 255);
 105             *ptrB = (unsigned char) (var_b * 255);
 106             }
 107         }
 108
 109     /*--------------------------------------*\
 110     |*           RGB_TO_HSV             *|
 111      \*-------------------------------------*/
 112
 113     void ColorTools::RGB_TO_HSB(const unsigned char R, const unsigned char G, const unsigned char B, float &H, float &S, float &V)
 114         {
 115         //RGB from 0 to 255
 116         float var_R = (R / (float) 255);
 117         float var_G = (G / (float) 255);
 118         float var_B = (B / (float) 255);
 119
 120         float var_Min = min(var_R, min(var_G, var_B)); //Min. value of RGB
 121         float var_Max = max(var_R, max(var_G, var_B)); //Max. value of RGB
 122         float del_Max = var_Max - var_Min; //Delta RGB value
 123
 124         V = var_Max;
 125
 126         if (del_Max == 0) //This is a gray, no chroma...
 127             {
 128             H = 0; //HSV results from 0 to 1
 129             S = 0;
 130             }
 131         else //Chromatic data...
 132             {
 133             S = del_Max / var_Max;
 134
 135             float del_R, del_G, del_B;
 136             del_R = (((var_Max - var_R) / 6) + (del_Max / 2)) / del_Max;
 137             del_G = (((var_Max - var_G) / 6) + (del_Max / 2)) / del_Max;
 138             del_B = (((var_Max - var_B) / 6) + (del_Max / 2)) / del_Max;
 139
 140             if (var_R == var_Max)
 141                 H = del_B - del_G;
 142             else if (var_G == var_Max)
 143                 H = (1 / 3) + del_R - del_B;
 144             else if (var_B == var_Max)
 145                 H = (2 / 3) + del_G - del_R;
 146
 147             if (H < 0)
 148                 H += 1;
 149             if (H > 1)
 150                 H -= 1;
 151             }
 152         }
 153
 154     /*--------------------------------------*\
 155     |*           int                       *|
 156      \*-------------------------------------*/
 157
 158     int ColorTools::toIntRGBA(unsigned char r, unsigned char g, unsigned char b, unsigned char a)
 159         {
 160         int var_a = a << 24;
 161         int var_b = b << 16;
 162         int var_g = g << 8;
 163         int rgb = var_b ^ var_g ^ ((int) r) ^ var_a;
 164
 165         return rgb;
 166         }
 167
 168     int ColorTools::toIntRGBA(float r, float g, float b, float a)
 169         {
 170         return toIntRGBA((unsigned char) (r * 255.0), (unsigned char) (g * 255.0), (unsigned char) (b * 255.0), (unsigned char) (a * 255.0));
 171         }
 172
 173     int ColorTools::HSB_TO_IntRGBA(float h01, float s01, float b01, float a01)
 174         {
 175         unsigned char result_r, result_v, result_b;
 176         ColorTools::HSB_TO_RVB(h01, s01, b01, &result_r, &result_v, &result_b);
 177
 178         return toIntRGBA(result_r, result_v, result_b, (int) (a01 * 255.0));
 179         }
 180
 181     void ColorTools::fromIntRGBA(const int rgba, unsigned char &r, unsigned char &g, unsigned char &b, unsigned char &a)
 182         {
 183         r = (unsigned char) rgba;
 184         g = (unsigned char) (rgba >> 8);
 185         b = (unsigned char) (rgba >> 16);
 186         a = (unsigned char) (rgba >> 24);
 187         }
 188
 189     }
 190
 191 /*----------------------------------------------------------------------*\
 192  |*                     End                                             *|
 193  \*---------------------------------------------------------------------*/
 194