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( rtl::math::approxEqual(nRed, nMax) )
  73                         aRes.mnHue = (nGreen - nBlue)/nDelta;
  74                     else if( rtl::math::approxEqual(nGreen, nMax) )
  75                         aRes.mnHue = 2.0 + (nBlue - nRed)/nDelta;
  76                     else if( rtl::math::approxEqual(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         // HSLColor
 156
 157
 158         HSLColor::HSLTriple::HSLTriple() :
 159             mnHue(),
 160             mnSaturation(),
 161             mnLuminance()
 162         {
 163         }
 164
 165         HSLColor::HSLTriple::HSLTriple( double nHue, double nSaturation, double nLuminance ) :
 166             mnHue( nHue ),
 167             mnSaturation( nSaturation ),
 168             mnLuminance( nLuminance )
 169         {
 170         }
 171
 172         HSLColor::HSLColor() :
 173             maHSLTriple( 0.0, 0.0, 0.0 )
 174         {
 175         }
 176
 177         HSLColor::HSLColor( double nHue, double nSaturation, double nLuminance ) :
 178             maHSLTriple( nHue, nSaturation, nLuminance )
 179         {
 180         }
 181
 182         HSLColor::HSLColor( const RGBColor& rColor ) :
 183             maHSLTriple( rgb2hsl( truncateRangeStd( rColor.getRed() ),
 184                                   truncateRangeStd( rColor.getGreen() ),
 185                                   truncateRangeStd( rColor.getBlue() ) ) )
 186         {
 187         }
 188
 189
 190         bool operator==( const HSLColor& rLHS, const HSLColor& rRHS )
 191         {
 192             return ( rLHS.getHue() == rRHS.getHue() &&
 193                      rLHS.getSaturation() == rRHS.getSaturation() &&
 194                      rLHS.getLuminance() == rRHS.getLuminance() );
 195         }
 196
 197         bool operator!=( const HSLColor& rLHS, const HSLColor& rRHS )
 198         {
 199             return !( rLHS == rRHS );
 200         }
 201
 202         HSLColor operator+( const HSLColor& rLHS, const HSLColor& rRHS )
 203         {
 204             return HSLColor( rLHS.getHue() + rRHS.getHue(),
 205                              rLHS.getSaturation() + rRHS.getSaturation(),
 206                              rLHS.getLuminance() + rRHS.getLuminance() );
 207         }
 208
 209         HSLColor operator*( double nFactor, const HSLColor& rRHS )
 210         {
 211             return HSLColor( nFactor * rRHS.getHue(),
 212                              nFactor * rRHS.getSaturation(),
 213                              nFactor * rRHS.getLuminance() );
 214         }
 215
 216         HSLColor interpolate( const HSLColor& rFrom, const HSLColor& rTo, double t, bool bCCW )
 217         {
 218             const double nFromHue( rFrom.getHue() );
 219             const double nToHue  ( rTo.getHue()   );
 220
 221             double nHue=0.0;
 222
 223             if( nFromHue <= nToHue && !bCCW )
 224             {
 225                 // interpolate hue clockwise. That is, hue starts at
 226                 // high values and ends at low ones. Therefore, we
 227                 // must 'cross' the 360 degrees and start at low
 228                 // values again (imagine the hues to lie on the
 229                 // circle, where values above 360 degrees are mapped
 230                 // back to [0,360)).
 231                 nHue = (1.0-t)*(nFromHue + 360.0) + t*nToHue;
 232             }
 233             else if( nFromHue > nToHue && bCCW )
 234             {
 235                 // interpolate hue counter-clockwise. That is, hue
 236                 // starts at high values and ends at low
 237                 // ones. Therefore, we must 'cross' the 360 degrees
 238                 // and start at low values again (imagine the hues to
 239                 // lie on the circle, where values above 360 degrees
 240                 // are mapped back to [0,360)).
 241                 nHue = (1.0-t)*nFromHue + t*(nToHue + 360.0);
 242             }
 243             else
 244             {
 245                 // interpolate hue counter-clockwise. That is, hue
 246                 // starts at low values and ends at high ones (imagine
 247                 // the hue value as degrees on a circle, with
 248                 // increasing values going counter-clockwise)
 249                 nHue = (1.0-t)*nFromHue + t*nToHue;
 250             }
 251
 252             return HSLColor( nHue,
 253                              (1.0-t)*rFrom.getSaturation() + t*rTo.getSaturation(),
 254                              (1.0-t)*rFrom.getLuminance() + t*rTo.getLuminance() );
 255         }
 256
 257
 258         // RGBColor
 259
 260
 261         RGBColor::RGBTriple::RGBTriple() :
 262             mnRed(),
 263             mnGreen(),
 264             mnBlue()
 265         {
 266         }
 267
 268         RGBColor::RGBTriple::RGBTriple( double nRed, double nGreen, double nBlue ) :
 269             mnRed( nRed ),
 270             mnGreen( nGreen ),
 271             mnBlue( nBlue )
 272         {
 273         }
 274
 275         RGBColor::RGBColor() :
 276             maRGBTriple( 0.0, 0.0, 0.0 )
 277         {
 278         }
 279
 280         RGBColor::RGBColor( ::cppcanvas::IntSRGBA nRGBColor ) :
 281             maRGBTriple( ::cppcanvas::getRed( nRGBColor ) / 255.0,
 282                          ::cppcanvas::getGreen( nRGBColor ) / 255.0,
 283                          ::cppcanvas::getBlue( nRGBColor ) / 255.0 )
 284         {
 285         }
 286
 287         RGBColor::RGBColor( double nRed, double nGreen, double nBlue ) :
 288             maRGBTriple( nRed, nGreen, nBlue )
 289         {
 290         }
 291
 292         RGBColor::RGBColor( const HSLColor& rColor ) :
 293             maRGBTriple( hsl2rgb( truncateRangeHue( rColor.getHue() ),
 294                                   truncateRangeStd( rColor.getSaturation() ),
 295                                   truncateRangeStd( rColor.getLuminance() ) ) )
 296         {
 297         }
 298
 299
 300         ::cppcanvas::IntSRGBA RGBColor::getIntegerColor() const
 301         {
 302             return ::cppcanvas::makeColor( colorToInt( getRed() ),
 303                                            colorToInt( getGreen() ),
 304                                            colorToInt( getBlue() ),
 305                                            255 );
 306         }
 307
 308         bool operator==( const RGBColor& rLHS, const RGBColor& rRHS )
 309         {
 310             return ( rLHS.getRed() == rRHS.getRed() &&
 311                      rLHS.getGreen() == rRHS.getGreen() &&
 312                      rLHS.getBlue() == rRHS.getBlue() );
 313         }
 314
 315         bool operator!=( const RGBColor& rLHS, const RGBColor& rRHS )
 316         {
 317             return !( rLHS == rRHS );
 318         }
 319
 320         RGBColor operator+( const RGBColor& rLHS, const RGBColor& rRHS )
 321         {
 322             return RGBColor( rLHS.getRed() + rRHS.getRed(),
 323                              rLHS.getGreen() + rRHS.getGreen(),
 324                              rLHS.getBlue() + rRHS.getBlue() );
 325         }
 326
 327         RGBColor operator*( const RGBColor& rLHS, const RGBColor& rRHS )
 328         {
 329             return RGBColor( rLHS.getRed() * rRHS.getRed(),
 330                              rLHS.getGreen() * rRHS.getGreen(),
 331                              rLHS.getBlue() * rRHS.getBlue() );
 332         }
 333
 334         RGBColor operator*( double nFactor, const RGBColor& rRHS )
 335         {
 336             return RGBColor( nFactor * rRHS.getRed(),
 337                              nFactor * rRHS.getGreen(),
 338                              nFactor * rRHS.getBlue() );
 339         }
 340
 341         RGBColor interpolate( const RGBColor& rFrom, const RGBColor& rTo, double t )
 342         {
 343             return RGBColor( (1.0-t)*rFrom.getRed() + t*rTo.getRed(),
 344                              (1.0-t)*rFrom.getGreen() + t*rTo.getGreen(),
 345                              (1.0-t)*rFrom.getBlue() + t*rTo.getBlue() );
 346         }
 347     }
 348 }
 349
 350 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */