plugins/colors/plugincolors.C

   1 #include "plugincolors.h"
   2
   3 #include <stdio.h>
   4
   5 HSV::HSV()
   6 {
   7 }
   8
   9
  10 HSV::~HSV()
  11 {
  12 }
  13
  14 YUV HSV::yuv_static;
  15
  16 int HSV::rgb_to_hsv(float r, float g, float b, float &h, float &s, float &v)
  17 {
  18     int i;
  19         float min, max, delta;
  20         float f, p, q, t;
  21         min = ((r < g) ? r : g) < b ? ((r < g) ? r : g) : b;
  22         max = ((r > g) ? r : g) > b ? ((r > g) ? r : g) : b;
  23         v = max;
  24
  25         delta = max - min;
  26
  27         if(max != 0 && delta != 0)
  28     {
  29             s = delta / max;               // s
  30
  31                 if(r == max)
  32                 h = (g - b) / delta;         // between yellow & magenta
  33                 else
  34                 if(g == max)
  35                 h = 2 + (b - r) / delta;     // between cyan & yellow
  36                 else
  37                 h = 4 + (r - g) / delta;     // between magenta & cyan
  38
  39                 h *= 60;                               // degrees
  40                 if(h < 0)
  41                 h += 360;
  42         }
  43         else
  44         {
  45         // r = g = b = 0                // s = 0, v is undefined
  46         s = 0;
  47         h = -1;
  48         }
  49
  50         return 0;
  51 }
  52
  53 int HSV::hsv_to_rgb(float &r, float &g, float &b, float h, float s, float v)
  54 {
  55     int i;
  56         float min, max, delta;
  57         float f, p, q, t;
  58     if(s == 0)
  59         {
  60         // achromatic (grey)
  61         r = g = b = v;
  62         return 0;
  63     }
  64
  65     h /= 60;                        // sector 0 to 5
  66     i = (int)h;
  67     f = h - i;                      // factorial part of h
  68     p = v * (1 - s);
  69     q = v * (1 - s * f);
  70     t = v * (1 - s * (1 - f));
  71
  72     switch(i)
  73         {
  74         case 0:
  75             r = v;
  76             g = t;
  77             b = p;
  78             break;
  79         case 1:
  80             r = q;
  81             g = v;
  82             b = p;
  83             break;
  84         case 2:
  85             r = p;
  86             g = v;
  87             b = t;
  88             break;
  89         case 3:
  90             r = p;
  91             g = q;
  92             b = v;
  93             break;
  94         case 4:
  95             r = t;
  96             g = p;
  97             b = v;
  98             break;
  99         default:                // case 5:
 100             r = v;
 101             g = p;
 102             b = q;
 103             break;
 104     }
 105         return 0;
 106 }
 107
 108 int HSV::yuv_to_hsv(int y, int u, int v, float &h, float &s, float &va, int max)
 109 {
 110         float r, g, b;
 111         int r_i, g_i, b_i;
 112
 113         if(max == 0xffff)
 114         {
 115                 yuv_static.yuv_to_rgb_16(r_i, g_i, b_i, y, u, v);
 116         }
 117         else
 118         {
 119                 yuv_static.yuv_to_rgb_8(r_i, g_i, b_i, y, u, v);
 120         }
 121         r = (float)r_i / max;
 122         g = (float)g_i / max;
 123         b = (float)b_i / max;
 124
 125         float h2, s2, v2;
 126         HSV::rgb_to_hsv(r, g, b, h2, s2, v2);
 127         h = h2;
 128         s = s2;
 129         va = v2;
 130
 131         return 0;
 132 }
 133
 134 int HSV::hsv_to_yuv(int &y, int &u, int &v, float h, float s, float va, int max)
 135 {
 136         float r, g, b;
 137         int r_i, g_i, b_i;
 138         HSV::hsv_to_rgb(r, g, b, h, s, va);
 139         r = r * max + 0.5;
 140         g = g * max + 0.5;
 141         b = b * max + 0.5;
 142         r_i = (int)CLIP(r, 0, max);
 143         g_i = (int)CLIP(g, 0, max);
 144         b_i = (int)CLIP(b, 0, max);
 145
 146         int y2, u2, v2;
 147         if(max == 0xffff)
 148                 yuv_static.rgb_to_yuv_16(r_i, g_i, b_i, y2, u2, v2);
 149         else
 150                 yuv_static.rgb_to_yuv_8(r_i, g_i, b_i, y2, u2, v2);
 151         y = y2;
 152         u = u2;
 153         v = v2;
 154
 155         return 0;
 156 }
 157
 158
 159
 160
 161
 162
 163
 164
 165
 166
 167
 168
 169
 170
 171
 172
 173
 174
 175
 176
 177
 178
 179
 180
 181 YUV::YUV()
 182 {
 183         for(int i = 0; i < 0x100; i++)
 184         {
 185 // compression
 186                 rtoy_tab_8[i] = (int)(R_TO_Y * 0x100 * i);
 187                 rtou_tab_8[i] = (int)(R_TO_U * 0x100 * i);
 188                 rtov_tab_8[i] = (int)(R_TO_V * 0x100 * i);
 189
 190                 gtoy_tab_8[i] = (int)(G_TO_Y * 0x100 * i);
 191                 gtou_tab_8[i] = (int)(G_TO_U * 0x100 * i);
 192                 gtov_tab_8[i] = (int)(G_TO_V * 0x100 * i);
 193
 194                 btoy_tab_8[i] = (int)(B_TO_Y * 0x100 * i);
 195                 btou_tab_8[i] = (int)(B_TO_U * 0x100 * i) + 0x8000;
 196                 btov_tab_8[i] = (int)(B_TO_V * 0x100 * i) + 0x8000;
 197         }
 198
 199         vtor_8 = &(vtor_tab_8[(0x100) / 2]);
 200         vtog_8 = &(vtog_tab_8[(0x100) / 2]);
 201         utog_8 = &(utog_tab_8[(0x100) / 2]);
 202         utob_8 = &(utob_tab_8[(0x100) / 2]);
 203
 204         for(int i = (-0x100) / 2; i < (0x100) / 2; i++)
 205         {
 206 // decompression
 207                 vtor_8[i] = (int)(V_TO_R * 0x100 * i);
 208                 vtog_8[i] = (int)(V_TO_G * 0x100 * i);
 209
 210                 utog_8[i] = (int)(U_TO_G * 0x100 * i);
 211                 utob_8[i] = (int)(U_TO_B * 0x100 * i);
 212         }
 213
 214         for(int i = 0; i < 0x10000; i++)
 215         {
 216 // compression
 217                 rtoy_tab_16[i] = (int)(R_TO_Y * 0x100 * i);
 218                 rtou_tab_16[i] = (int)(R_TO_U * 0x100 * i);
 219                 rtov_tab_16[i] = (int)(R_TO_V * 0x100 * i);
 220
 221                 gtoy_tab_16[i] = (int)(G_TO_Y * 0x100 * i);
 222                 gtou_tab_16[i] = (int)(G_TO_U * 0x100 * i);
 223                 gtov_tab_16[i] = (int)(G_TO_V * 0x100 * i);
 224
 225                 btoy_tab_16[i] = (int)(B_TO_Y * 0x100 * i);
 226                 btou_tab_16[i] = (int)(B_TO_U * 0x100 * i) + 0x800000;
 227                 btov_tab_16[i] = (int)(B_TO_V * 0x100 * i) + 0x800000;
 228         }
 229
 230         vtor_16 = &(vtor_tab_16[(0x10000) / 2]);
 231         vtog_16 = &(vtog_tab_16[(0x10000) / 2]);
 232         utog_16 = &(utog_tab_16[(0x10000) / 2]);
 233         utob_16 = &(utob_tab_16[(0x10000) / 2]);
 234
 235         for(int i = (-0x10000) / 2; i < (0x10000) / 2; i++)
 236         {
 237 // decompression
 238                 vtor_16[i] = (int)(V_TO_R * 0x100 * i);
 239                 vtog_16[i] = (int)(V_TO_G * 0x100 * i);
 240
 241                 utog_16[i] = (int)(U_TO_G * 0x100 * i);
 242                 utob_16[i] = (int)(U_TO_B * 0x100 * i);
 243         }
 244 }
 245
 246 YUV::~YUV()
 247 {
 248 }