workbench/classes/gadgets/colorwheel/convertrgbtohsb.c

   1 /*
   2     Copyright © 1995-2007, The AROS Development Team. All rights reserved.
   3     $Id$
   4
   5     Desc: ColorWheel function ConvertRGBToHSB()
   6     Lang: english
   7 */
   8 #include <gadgets/colorwheel.h>
   9 #include <math.h>
  10 #include "colorwheel_intern.h"
  11
  12 #undef MIN
  13 #define MIN(a, b) ((a) < (b) ? (a) : (b))
  14
  15 #undef MAX
  16 #define MAX(a, b) ((a) > (b) ? (a) : (b))
  17
  18 /*****************************************************************************
  19
  20     NAME */
  21 #include <proto/colorwheel.h>
  22
  23         AROS_LH2(void, ConvertRGBToHSB,
  24
  25 /*  SYNOPSIS */
  26         AROS_LHA(struct ColorWheelRGB *, rgb, A0),
  27         AROS_LHA(struct ColorWheelHSB *, hsb, A1),
  28
  29 /*  LOCATION */
  30         struct Library *, ColorWheelBase, 6, ColorWheel)
  31
  32 /*  FUNCTION
  33         Converts a color from an RGB representation to an
  34         HSB representation
  35
  36     INPUTS
  37         rgb - filled-in ColorWheelRGB structure containing
  38               the values to convert
  39         hsb - structure to recieive the converted values
  40
  41     RESULT
  42
  43     NOTES
  44
  45     EXAMPLE
  46
  47     BUGS
  48
  49     SEE ALSO
  50
  51     INTERNALS
  52
  53     HISTORY
  54         27-04-2000  lbischoff  implemented
  55
  56 ******************************************************************************/
  57 {
  58     AROS_LIBFUNC_INIT
  59
  60 #if FIXED_MATH
  61     Fixed32 R, G, B, H, S, I, max, min, delta;
  62
  63     R = rgb->cw_Red >> 16;
  64     G = rgb->cw_Green >> 16;
  65     B = rgb->cw_Blue >> 16;
  66
  67     max = MAX(MAX(R, G), B);
  68     min = MIN(MIN(R, G), B);
  69
  70     I = max;
  71
  72     S = (max != 0) ? ( (ULONG) ( ( max - min ) << 16 ) / (ULONG) max ) : 0;
  73     if( S >= (FIXED_ONE-1) ) S = FIXED_ONE-1;
  74
  75     if (S == 0)
  76     {
  77         H = 0; /* -1.0; */
  78     }
  79     else
  80     {
  81         delta = max - min;
  82
  83         if (R == max)
  84         {
  85             H = FixDiv( (G - B), delta );
  86         }
  87         else if (G == max)
  88         {
  89             H = INT_TO_FIXED( 2 ) + FixDiv( (B - R), delta );
  90         }
  91         else if (B == max)
  92         {
  93             H = INT_TO_FIXED( 4 ) + FixDiv( (R - G), delta );
  94         }
  95
  96         H *= 60;
  97
  98         if (H < 0 )
  99         {
 100             H += INT_TO_FIXED( 360 );
 101         }
 102
 103         H /= 360;
 104     }
 105
 106     hsb->cw_Hue         = H | ( H << 16 );
 107     hsb->cw_Saturation  = S | ( S << 16 );
 108     hsb->cw_Brightness  = I | ( I << 16 );
 109
 110 #else /* FIXED_MATH */
 111
 112 #if 1
 113
 114     DOUBLE R, G, B, H, S, I, max, min, delta;
 115
 116     R = (DOUBLE) rgb->cw_Red / (DOUBLE) 0xFFFFFFFF;
 117     G = (DOUBLE) rgb->cw_Green / (DOUBLE) 0xFFFFFFFF;
 118     B = (DOUBLE) rgb->cw_Blue / (DOUBLE) 0xFFFFFFFF;
 119
 120     max = MAX(MAX(R, G), B);
 121     min = MIN(MIN(R, G), B);
 122
 123     I = max;
 124
 125     if (max != 0.0)
 126     {
 127         S = (max - min) / max;
 128     }
 129     else
 130     {
 131         S = 0.0;
 132     }
 133
 134     if (S == 0.0)
 135     {
 136         H = 0.0; /* -1.0; */
 137     }
 138     else
 139     {
 140         delta = max - min;
 141
 142         if (R == max)
 143         {
 144             H = (G - B) / delta;
 145         }
 146         else if (G == max)
 147         {
 148             H = 2.0 + (B - R) / delta;
 149         }
 150         else if (B == max)
 151         {
 152             H = 4.0 + (R - G) / delta;
 153         }
 154
 155         H = H * 60.0;
 156
 157         if (H < 0.0)
 158         {
 159             H = H + 360;
 160         }
 161
 162         H = H / 360.0;
 163     }
 164
 165     hsb->cw_Hue         = (ULONG) rint (H * 0xFFFFFFFF);
 166     hsb->cw_Saturation  = (ULONG) rint (S * 0xFFFFFFFF);
 167     hsb->cw_Brightness  = (ULONG) rint (I * 0xFFFFFFFF);
 168
 169 #else
 170     DOUBLE R, G, B, H, S, I, a;
 171
 172     R = (DOUBLE) rgb->cw_Red / (DOUBLE) 0xFFFFFFFF;
 173     G = (DOUBLE) rgb->cw_Green / (DOUBLE) 0xFFFFFFFF;
 174     B = (DOUBLE) rgb->cw_Blue / (DOUBLE) 0xFFFFFFFF;
 175
 176     I = (R + G + B) / 3.0;
 177     a = MIN (MIN(R, G), B);
 178     S = 1.0 - (a/I);
 179     H = acos ((0.5*(R-G)+(R-B))/sqrt(pow(R-G, 2.0) + (R-B)*(G-B)));
 180     if (B/I > G/I)
 181         H = PI2 - H;
 182     H /= PI2;
 183
 184     hsb->cw_Hue = (ULONG) rint (H * 0xFFFFFFFF);
 185     hsb->cw_Saturation = (ULONG) rint (S * 0xFFFFFFFF);
 186     hsb->cw_Brightness = (ULONG) rint (I * 0xFFFFFFFF);
 187
 188 #endif
 189
 190 #endif /* FIXED_MATH */
 191
 192     AROS_LIBFUNC_EXIT
 193
 194 } /* ConvertRGBToHSB */