basegfx/source/color/bcolortools.cxx

   1 /*************************************************************************
   2  *
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * Copyright 2000, 2010 Oracle and/or its affiliates.
   6  *
   7  * OpenOffice.org - a multi-platform office productivity suite
   8  *
   9  * This file is part of OpenOffice.org.
  10  *
  11  * OpenOffice.org is free software: you can redistribute it and/or modify
  12  * it under the terms of the GNU Lesser General Public License version 3
  13  * only, as published by the Free Software Foundation.
  14  *
  15  * OpenOffice.org is distributed in the hope that it will be useful,
  16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18  * GNU Lesser General Public License version 3 for more details
  19  * (a copy is included in the LICENSE file that accompanied this code).
  20  *
  21  * You should have received a copy of the GNU Lesser General Public License
  22  * version 3 along with OpenOffice.org.  If not, see
  23  * <http://www.openoffice.org/license.html>
  24  * for a copy of the LGPLv3 License.
  25  *
  26  ************************************************************************/
  27
  28 // MARKER(update_precomp.py): autogen include statement, do not remove
  29 #include "precompiled_basegfx.hxx"
  30
  31 #include <basegfx/numeric/ftools.hxx>
  32 #include <basegfx/color/bcolor.hxx>
  33 #include <basegfx/color/bcolortools.hxx>
  34
  35 //////////////////////////////////////////////////////////////////////////////
  36
  37 namespace basegfx { namespace tools
  38 {
  39     BColor rgb2hsl(const BColor& rRGBColor)
  40     {
  41         const double r=rRGBColor.getRed(), g=rRGBColor.getGreen(), b=rRGBColor.getBlue();
  42         const double minVal = ::std::min( ::std::min( r, g ), b );
  43         const double maxVal = ::std::max( ::std::max( r, g ), b );
  44         const double d = maxVal - minVal;
  45
  46         double h=0, s=0, l=0;
  47
  48         l = (maxVal + minVal) / 2.0;
  49
  50         if( ::basegfx::fTools::equalZero(d) )
  51         {
  52             s = h = 0; // hue undefined (achromatic case)
  53         }
  54         else
  55         {
  56             s = l > 0.5 ? d/(2.0-maxVal-minVal) :
  57                 d/(maxVal + minVal);
  58
  59             if( r == maxVal )
  60                 h = (g - b)/d;
  61             else if( g == maxVal )
  62                 h = 2.0 + (b - r)/d;
  63             else
  64                 h = 4.0 + (r - g)/d;
  65
  66             h *= 60.0;
  67
  68             if( h < 0.0 )
  69                 h += 360.0;
  70         }
  71
  72         return BColor(h,s,l);
  73     }
  74
  75     static inline double hsl2rgbHelper( double nValue1, double nValue2, double nHue )
  76     {
  77         // clamp hue to [0,360]
  78         nHue = fmod( nHue, 360.0 );
  79
  80         // cope with wrap-arounds
  81         if( nHue < 0.0 )
  82             nHue += 360.0;
  83
  84         if( nHue < 60.0 )
  85             return nValue1 + (nValue2 - nValue1)*nHue/60.0;
  86         else if( nHue < 180.0 )
  87             return nValue2;
  88         else if( nHue < 240.0 )
  89             return nValue1 + (nValue2 - nValue1)*(240.0 - nHue)/60.0;
  90         else
  91             return nValue1;
  92     }
  93
  94     BColor hsl2rgb(const BColor& rHSLColor)
  95     {
  96         const double h=rHSLColor.getRed(), s=rHSLColor.getGreen(), l=rHSLColor.getBlue();
  97
  98         if( fTools::equalZero(s) )
  99             return BColor(l, l, l ); // achromatic case
 100
 101         const double nVal1( l <= 0.5 ? l*(1.0 + s) : l + s - l*s );
 102         const double nVal2( 2.0*l - nVal1 );
 103
 104         return BColor(
 105             hsl2rgbHelper(nVal2,
 106                           nVal1,
 107                           h + 120.0),
 108             hsl2rgbHelper(nVal2,
 109                           nVal1,
 110                           h),
 111             hsl2rgbHelper(nVal2,
 112                           nVal1,
 113                           h - 120.0) );
 114     }
 115
 116     BColor rgb2hsv(const BColor& rRGBColor)
 117     {
 118         const double r=rRGBColor.getRed(), g=rRGBColor.getGreen(), b=rRGBColor.getBlue();
 119         const double maxVal = std::max(std::max(r,g),b);
 120         const double minVal = std::min(std::min(r,g),b);
 121         const double delta = maxVal-minVal;
 122
 123         double h=0, s=0, v=0;
 124
 125         v = maxVal;
 126         if( fTools::equalZero(v) )
 127             s = 0;
 128         else
 129             s = delta / v;
 130
 131         if( !fTools::equalZero(s) )
 132         {
 133             if( maxVal == r )
 134             {
 135                 h = (g - b) / delta;
 136             }
 137             else if( maxVal == g )
 138             {
 139                 h = 2.0 + (b - r) / delta;
 140             }
 141             else
 142             {
 143                 h = 4.0 + (r - g) / delta;
 144             }
 145
 146             h *= 60.0;
 147
 148             if( h < 0 )
 149                 h += 360;
 150         }
 151
 152         return BColor(h,s,v);
 153     }
 154
 155     BColor hsv2rgb(const BColor& rHSVColor)
 156     {
 157         double h=rHSVColor.getRed();
 158         const double s=rHSVColor.getGreen(), v=rHSVColor.getBlue();
 159
 160         if( fTools::equalZero(s) )
 161         {
 162             // achromatic case: no hue.
 163             return BColor(v,v,v);
 164         }
 165         else
 166         {
 167             if( fTools::equal(h,360) )
 168                 h = 0; // 360 degrees is equivalent to 0 degrees
 169
 170             h /= 60.0;
 171             const sal_Int32 intval = static_cast< sal_Int32 >( h );
 172             const double f = h - intval;
 173             const double p = v*(1.0-s);
 174             const double q = v*(1.0-(s*f));
 175             const double t = v*(1.0-(s*(1.0-f)));
 176
 177             /* which hue area? */
 178             switch( intval )
 179             {
 180                 case 0:
 181                     return BColor(v,t,p);
 182
 183                 case 1:
 184                     return BColor(q,v,p);
 185
 186                 case 2:
 187                     return BColor(p,v,t);
 188
 189                 case 3:
 190                     return BColor(p,q,v);
 191
 192                 case 4:
 193                     return BColor(t,p,v);
 194
 195                 case 5:
 196                     return BColor(v,p,q);
 197
 198                 default:
 199                     // hue overflow
 200                     return BColor();
 201             }
 202         }
 203     }
 204
 205     BColor rgb2yiq(const BColor& rRGBColor)
 206     {
 207         // from Foley, van Dam, Computer Graphics
 208         const double r=rRGBColor.getRed(), g=rRGBColor.getGreen(), b=rRGBColor.getBlue();
 209         return BColor(
 210             0.299*r + 0.587*g + 0.114*b,
 211             0.596*r - 0.274*g - 0.322*b,
 212             0.211*r - 0.522*g + 0.311*b);
 213     }
 214
 215     BColor yiq2rgb(const BColor& rYIQColor)
 216     {
 217         // from Foley, van Dam, Computer Graphics
 218         const double y=rYIQColor.getRed(), i=rYIQColor.getGreen(), q=rYIQColor.getBlue();
 219         return BColor(
 220             y + 0.956*i + 0.623*q,
 221             y - 0.272*i - 0.648*q,
 222             y - 1.105*i + 1.705*q );
 223     }
 224
 225     BColor ciexyz2rgb( const BColor& rXYZColor )
 226     {
 227         // from Poynton color faq, and SMPTE RP 177-1993, Derivation
 228         // of Basic Television Color Equations
 229         const double x=rXYZColor.getRed(), y=rXYZColor.getGreen(), z=rXYZColor.getBlue();
 230         return BColor(
 231             3.240479*x - 1.53715*y  - 0.498535*z,
 232             -0.969256*x + 1.875991*y + 0.041556*z,
 233             0.055648*x - 0.204043*y + 1.057311*z );
 234     }
 235
 236     BColor rgb2ciexyz( const BColor& rRGBColor )
 237     {
 238         // from Poynton color faq, and SMPTE RP 177-1993, Derivation
 239         // of Basic Television Color Equations
 240         const double r=rRGBColor.getRed(), g=rRGBColor.getGreen(), b=rRGBColor.getBlue();
 241         return BColor(
 242             0.412453*r + 0.35758*g  + 0.180423*b,
 243             0.212671*r + 0.71516*g  + 0.072169*b,
 244             0.019334*r + 0.119193*g + 0.950227*b);
 245     }
 246
 247     BColor rgb2ypbpr(const BColor& rRGBColor)
 248     {
 249         const double r=rRGBColor.getRed(), g=rRGBColor.getGreen(), b=rRGBColor.getBlue();
 250         return BColor(
 251              0.299*r    + 0.587*g    + 0.114*b,
 252             -0.168736*r - 0.331264*g + 0.5*b,
 253              0.5*r      - 0.418688*g - 0.081312*b);
 254     }
 255
 256     BColor ypbpr2rgb(const BColor& rYPbPrColor)
 257     {
 258         const double y=rYPbPrColor.getRed(), pb=rYPbPrColor.getGreen(), pr=rYPbPrColor.getBlue();
 259         return BColor(
 260             1.*y +       0.*pb +    1.402*pr,
 261             1.*y - 0.344136*pb - 0.714136*pr,
 262             1.*y +    1.772*pb +       0.*pr);
 263     }
 264
 265 } } // end of namespace basegfx
 266
 267 //////////////////////////////////////////////////////////////////////////////
 268 // eof