slideshow/source/engine/color.cxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*
   3  * This file is part of the LibreOffice project.
   4  *
   5  * This Source Code Form is subject to the terms of the Mozilla Public
   6  * License, v. 2.0. If a copy of the MPL was not distributed with this
   7  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   8  *
   9  * This file incorporates work covered by the following license notice:
  10  *
  11  *   Licensed to the Apache Software Foundation (ASF) under one or more
  12  *   contributor license agreements. See the NOTICE file distributed
  13  *   with this work for additional information regarding copyright
  14  *   ownership. The ASF licenses this file to you under the Apache
  15  *   License, Version 2.0 (the "License"); you may not use this file
  16  *   except in compliance with the License. You may obtain a copy of
  17  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
  18  */
  19
  20
  21 #include <hslcolor.hxx>
  22 #include <rgbcolor.hxx>
  23
  24 #include <basegfx/numeric/ftools.hxx>
  25
  26 #include <cmath>
  27 #include <algorithm>
  28
  29
  30 namespace slideshow
  31 {
  32     namespace internal
  33     {
  34         namespace
  35         {
  36             // helper functions
  37             // ================
  38
  39             double getMagic( double nLuminance, double nSaturation )
  40             {
  41                 if( nLuminance <= 0.5 )
  42                     return nLuminance*(1.0 + nSaturation);
  43                 else
  44                     return nLuminance + nSaturation - nLuminance*nSaturation;
  45             }
  46
  47             HSLColor::HSLTriple rgb2hsl( double nRed, double nGreen, double nBlue )
  48             {
  49                 // r,g,b in [0,1], h in [0,360] and s,l in [0,1]
  50                 HSLColor::HSLTriple aRes;
  51
  52                 const double nMax( ::std::max(nRed,::std::max(nGreen, nBlue)) );
  53                 const double nMin( ::std::min(nRed,::std::min(nGreen, nBlue)) );
  54
  55                 const double nDelta( nMax - nMin );
  56
  57                 aRes.mnLuminance = (nMax + nMin) / 2.0;
  58
  59                 if( ::basegfx::fTools::equalZero( nDelta ) )
  60                 {
  61                     aRes.mnSaturation = 0.0;
  62
  63                     // hue undefined (achromatic case)
  64                     aRes.mnHue = 0.0;
  65                 }
  66                 else
  67                 {
  68                     aRes.mnSaturation = aRes.mnLuminance > 0.5 ?
  69                         nDelta/(2.0-nMax-nMin) :
  70                         nDelta/(nMax + nMin);
  71
  72                     if( nRed == nMax )
  73                         aRes.mnHue = (nGreen - nBlue)/nDelta;
  74                     else if( nGreen == nMax )
  75                         aRes.mnHue = 2.0 + (nBlue - nRed)/nDelta;
  76                     else if( nBlue == nMax )
  77                         aRes.mnHue = 4.0 + (nRed - nGreen)/nDelta;
  78
  79                     aRes.mnHue *= 60.0;
  80
  81                     if( aRes.mnHue < 0.0 )
  82                         aRes.mnHue += 360.0;
  83                 }
  84
  85                 return aRes;
  86             }
  87
  88             double hsl2rgbHelper( double nValue1, double nValue2, double nHue )
  89             {
  90                 // clamp hue to [0,360]
  91                 nHue = fmod( nHue, 360.0 );
  92
  93                 // cope with wrap-arounds
  94                 if( nHue < 0.0 )
  95                     nHue += 360.0;
  96
  97                 if( nHue < 60.0 )
  98                     return nValue1 + (nValue2 - nValue1)*nHue/60.0;
  99                 else if( nHue < 180.0 )
 100                     return nValue2;
 101                 else if( nHue < 240.0 )
 102                     return nValue1 + (nValue2 - nValue1)*(240.0 - nHue)/60.0;
 103                 else
 104                     return nValue1;
 105             }
 106
 107             RGBColor::RGBTriple hsl2rgb( double nHue, double nSaturation, double nLuminance )
 108             {
 109                 if( ::basegfx::fTools::equalZero( nSaturation ) )
 110                     return RGBColor::RGBTriple(0.0, 0.0, nLuminance );
 111
 112                 const double nVal1( getMagic(nLuminance, nSaturation) );
 113                 const double nVal2( 2.0*nLuminance - nVal1 );
 114
 115                 RGBColor::RGBTriple aRes;
 116
 117                 aRes.mnRed = hsl2rgbHelper( nVal2,
 118                                             nVal1,
 119                                             nHue + 120.0 );
 120                 aRes.mnGreen = hsl2rgbHelper( nVal2,
 121                                               nVal1,
 122                                               nHue );
 123                 aRes.mnBlue = hsl2rgbHelper( nVal2,
 124                                              nVal1,
 125                                              nHue - 120.0 );
 126
 127                 return aRes;
 128             }
 129
 130             /// Truncate range of value to [0,1]
 131             double truncateRangeStd( double nVal )
 132             {
 133                 return ::std::max( 0.0,
 134                                    ::std::min( 1.0,
 135                                                nVal ) );
 136             }
 137
 138             /// Truncate range of value to [0,360]
 139             double truncateRangeHue( double nVal )
 140             {
 141                 return ::std::max( 0.0,
 142                                    ::std::min( 360.0,
 143                                                nVal ) );
 144             }
 145
 146             /// convert RGB color to sal_uInt8, truncate range appropriately before
 147             sal_uInt8 colorToInt( double nCol )
 148             {
 149                 return static_cast< sal_uInt8 >(
 150                     ::basegfx::fround( truncateRangeStd( nCol ) * 255.0 ) );
 151             }
 152         }
 153
 154
 155
 156         // HSLColor
 157
 158
 159         HSLColor::HSLTriple::HSLTriple() :
 160             mnHue(),
 161             mnSaturation(),
 162             mnLuminance()
 163         {
 164         }
 165
 166         HSLColor::HSLTriple::HSLTriple( double nHue, double nSaturation, double nLuminance ) :
 167             mnHue( nHue ),
 168             mnSaturation( nSaturation ),
 169             mnLuminance( nLuminance )
 170         {
 171         }
 172
 173         HSLColor::HSLColor() :
 174             maHSLTriple( 0.0, 0.0, 0.0 ),
 175             mnMagicValue( getMagic( maHSLTriple.mnLuminance,
 176                                     maHSLTriple.mnSaturation ) )
 177         {
 178         }
 179
 180         HSLColor::HSLColor( double nHue, double nSaturation, double nLuminance ) :
 181             maHSLTriple( nHue, nSaturation, nLuminance ),
 182             mnMagicValue( getMagic( maHSLTriple.mnLuminance,
 183                                     maHSLTriple.mnSaturation ) )
 184         {
 185         }
 186
 187         HSLColor::HSLColor( const RGBColor& rColor ) :
 188             maHSLTriple( rgb2hsl( truncateRangeStd( rColor.getRed() ),
 189                                   truncateRangeStd( rColor.getGreen() ),
 190                                   truncateRangeStd( rColor.getBlue() ) ) ),
 191             mnMagicValue( getMagic( maHSLTriple.mnLuminance,
 192                                     maHSLTriple.mnSaturation ) )
 193         {
 194         }
 195
 196
 197
 198
 199
 200         bool operator==( const HSLColor& rLHS, const HSLColor& rRHS )
 201         {
 202             return ( rLHS.getHue() == rRHS.getHue() &&
 203                      rLHS.getSaturation() == rRHS.getSaturation() &&
 204                      rLHS.getLuminance() == rRHS.getLuminance() );
 205         }
 206
 207         bool operator!=( const HSLColor& rLHS, const HSLColor& rRHS )
 208         {
 209             return !( rLHS == rRHS );
 210         }
 211
 212         HSLColor operator+( const HSLColor& rLHS, const HSLColor& rRHS )
 213         {
 214             return HSLColor( rLHS.getHue() + rRHS.getHue(),
 215                              rLHS.getSaturation() + rRHS.getSaturation(),
 216                              rLHS.getLuminance() + rRHS.getLuminance() );
 217         }
 218
 219         HSLColor operator*( const HSLColor& rLHS, const HSLColor& rRHS )
 220         {
 221             return HSLColor( rLHS.getHue() * rRHS.getHue(),
 222                              rLHS.getSaturation() * rRHS.getSaturation(),
 223                              rLHS.getLuminance() * rRHS.getLuminance() );
 224         }
 225
 226         HSLColor operator*( double nFactor, const HSLColor& rRHS )
 227         {
 228             return HSLColor( nFactor * rRHS.getHue(),
 229                              nFactor * rRHS.getSaturation(),
 230                              nFactor * rRHS.getLuminance() );
 231         }
 232
 233         HSLColor interpolate( const HSLColor& rFrom, const HSLColor& rTo, double t, bool bCCW )
 234         {
 235             const double nFromHue( rFrom.getHue() );
 236             const double nToHue  ( rTo.getHue()   );
 237
 238             double nHue=0.0;
 239
 240             if( nFromHue <= nToHue && !bCCW )
 241             {
 242                 // interpolate hue clockwise. That is, hue starts at
 243                 // high values and ends at low ones. Therefore, we
 244                 // must 'cross' the 360 degrees and start at low
 245                 // values again (imagine the hues to lie on the
 246                 // circle, where values above 360 degrees are mapped
 247                 // back to [0,360)).
 248                 nHue = (1.0-t)*(nFromHue + 360.0) + t*nToHue;
 249             }
 250             else if( nFromHue > nToHue && bCCW )
 251             {
 252                 // interpolate hue counter-clockwise. That is, hue
 253                 // starts at high values and ends at low
 254                 // ones. Therefore, we must 'cross' the 360 degrees
 255                 // and start at low values again (imagine the hues to
 256                 // lie on the circle, where values above 360 degrees
 257                 // are mapped back to [0,360)).
 258                 nHue = (1.0-t)*nFromHue + t*(nToHue + 360.0);
 259             }
 260             else
 261             {
 262                 // interpolate hue counter-clockwise. That is, hue
 263                 // starts at low values and ends at high ones (imagine
 264                 // the hue value as degrees on a circle, with
 265                 // increasing values going counter-clockwise)
 266                 nHue = (1.0-t)*nFromHue + t*nToHue;
 267             }
 268
 269             return HSLColor( nHue,
 270                              (1.0-t)*rFrom.getSaturation() + t*rTo.getSaturation(),
 271                              (1.0-t)*rFrom.getLuminance() + t*rTo.getLuminance() );
 272         }
 273
 274
 275
 276         // RGBColor
 277
 278
 279
 280         RGBColor::RGBTriple::RGBTriple() :
 281             mnRed(),
 282             mnGreen(),
 283             mnBlue()
 284         {
 285         }
 286
 287         RGBColor::RGBTriple::RGBTriple( double nRed, double nGreen, double nBlue ) :
 288             mnRed( nRed ),
 289             mnGreen( nGreen ),
 290             mnBlue( nBlue )
 291         {
 292         }
 293
 294         RGBColor::RGBColor() :
 295             maRGBTriple( 0.0, 0.0, 0.0 )
 296         {
 297         }
 298
 299         RGBColor::RGBColor( ::cppcanvas::Color::IntSRGBA nRGBColor ) :
 300             maRGBTriple( ::cppcanvas::getRed( nRGBColor ) / 255.0,
 301                          ::cppcanvas::getGreen( nRGBColor ) / 255.0,
 302                          ::cppcanvas::getBlue( nRGBColor ) / 255.0 )
 303         {
 304         }
 305
 306         RGBColor::RGBColor( double nRed, double nGreen, double nBlue ) :
 307             maRGBTriple( nRed, nGreen, nBlue )
 308         {
 309         }
 310
 311         RGBColor::RGBColor( const HSLColor& rColor ) :
 312             maRGBTriple( hsl2rgb( truncateRangeHue( rColor.getHue() ),
 313                                   truncateRangeStd( rColor.getSaturation() ),
 314                                   truncateRangeStd( rColor.getLuminance() ) ) )
 315         {
 316         }
 317
 318
 319
 320
 321         ::cppcanvas::Color::IntSRGBA RGBColor::getIntegerColor() const
 322         {
 323             return ::cppcanvas::makeColor( colorToInt( getRed() ),
 324                                            colorToInt( getGreen() ),
 325                                            colorToInt( getBlue() ),
 326                                            255 );
 327         }
 328
 329         bool operator==( const RGBColor& rLHS, const RGBColor& rRHS )
 330         {
 331             return ( rLHS.getRed() == rRHS.getRed() &&
 332                      rLHS.getGreen() == rRHS.getGreen() &&
 333                      rLHS.getBlue() == rRHS.getBlue() );
 334         }
 335
 336         bool operator!=( const RGBColor& rLHS, const RGBColor& rRHS )
 337         {
 338             return !( rLHS == rRHS );
 339         }
 340
 341         RGBColor operator+( const RGBColor& rLHS, const RGBColor& rRHS )
 342         {
 343             return RGBColor( rLHS.getRed() + rRHS.getRed(),
 344                              rLHS.getGreen() + rRHS.getGreen(),
 345                              rLHS.getBlue() + rRHS.getBlue() );
 346         }
 347
 348         RGBColor operator*( const RGBColor& rLHS, const RGBColor& rRHS )
 349         {
 350             return RGBColor( rLHS.getRed() * rRHS.getRed(),
 351                              rLHS.getGreen() * rRHS.getGreen(),
 352                              rLHS.getBlue() * rRHS.getBlue() );
 353         }
 354
 355         RGBColor operator*( double nFactor, const RGBColor& rRHS )
 356         {
 357             return RGBColor( nFactor * rRHS.getRed(),
 358                              nFactor * rRHS.getGreen(),
 359                              nFactor * rRHS.getBlue() );
 360         }
 361
 362         RGBColor interpolate( const RGBColor& rFrom, const RGBColor& rTo, double t )
 363         {
 364             return RGBColor( (1.0-t)*rFrom.getRed() + t*rTo.getRed(),
 365                              (1.0-t)*rFrom.getGreen() + t*rTo.getGreen(),
 366                              (1.0-t)*rFrom.getBlue() + t*rTo.getBlue() );
 367         }
 368     }
 369 }
 370
 371 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */