basegfx/source/color/bcolormodifier.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 #include <sal/config.h>
  21
  22 #include <algorithm>
  23
  24 #include <basegfx/color/bcolormodifier.hxx>
  25
  26 namespace basegfx
  27 {
  28     BColorModifier::~BColorModifier()
  29     {
  30     }
  31
  32     BColorModifier_gray::~BColorModifier_gray()
  33     {
  34     }
  35
  36     bool BColorModifier_gray::operator==(const BColorModifier& rCompare) const
  37     {
  38         return dynamic_cast< const BColorModifier_gray* >(&rCompare) != nullptr;
  39     }
  40
  41     ::basegfx::BColor BColorModifier_gray::getModifiedColor(const ::basegfx::BColor& aSourceColor) const
  42     {
  43         const double fLuminance(aSourceColor.luminance());
  44
  45         return ::basegfx::BColor(fLuminance, fLuminance, fLuminance);
  46     }
  47
  48     BColorModifier_invert::~BColorModifier_invert()
  49     {
  50     }
  51
  52     bool BColorModifier_invert::operator==(const BColorModifier& rCompare) const
  53     {
  54         return dynamic_cast< const BColorModifier_invert* >(&rCompare) != nullptr;
  55     }
  56
  57     ::basegfx::BColor BColorModifier_invert::getModifiedColor(const ::basegfx::BColor& aSourceColor) const
  58     {
  59         return ::basegfx::BColor(1.0 - aSourceColor.getRed(), 1.0 - aSourceColor.getGreen(), 1.0 - aSourceColor.getBlue());
  60     }
  61
  62     BColorModifier_luminance_to_alpha::~BColorModifier_luminance_to_alpha()
  63     {
  64     }
  65
  66     bool BColorModifier_luminance_to_alpha::operator==(const BColorModifier& rCompare) const
  67     {
  68         return dynamic_cast< const BColorModifier_luminance_to_alpha* >(&rCompare) != nullptr;
  69     }
  70
  71     ::basegfx::BColor BColorModifier_luminance_to_alpha::getModifiedColor(const ::basegfx::BColor& aSourceColor) const
  72     {
  73         const double fAlpha(1.0 - ((aSourceColor.getRed() * 0.2125) + (aSourceColor.getGreen() * 0.7154) + (aSourceColor.getBlue() * 0.0721)));
  74
  75         return ::basegfx::BColor(fAlpha, fAlpha, fAlpha);
  76     }
  77
  78     BColorModifier_replace::~BColorModifier_replace()
  79     {
  80     }
  81
  82     bool BColorModifier_replace::operator==(const BColorModifier& rCompare) const
  83     {
  84         const BColorModifier_replace* pCompare = dynamic_cast< const BColorModifier_replace* >(&rCompare);
  85
  86         if(!pCompare)
  87         {
  88             return false;
  89         }
  90
  91         return getBColor() == pCompare->getBColor();
  92     }
  93
  94     ::basegfx::BColor BColorModifier_replace::getModifiedColor(const ::basegfx::BColor& /*aSourceColor*/) const
  95     {
  96         return maBColor;
  97     }
  98
  99     BColorModifier_interpolate::~BColorModifier_interpolate()
 100     {
 101     }
 102
 103     bool BColorModifier_interpolate::operator==(const BColorModifier& rCompare) const
 104     {
 105         const BColorModifier_interpolate* pCompare = dynamic_cast< const BColorModifier_interpolate* >(&rCompare);
 106
 107         if(!pCompare)
 108         {
 109             return false;
 110         }
 111
 112         return maBColor == pCompare->maBColor && mfValue == pCompare->mfValue;
 113     }
 114
 115     ::basegfx::BColor BColorModifier_interpolate::getModifiedColor(const ::basegfx::BColor& aSourceColor) const
 116     {
 117         return interpolate(maBColor, aSourceColor, mfValue);
 118     }
 119
 120     BColorModifier_black_and_white::~BColorModifier_black_and_white()
 121     {
 122     }
 123
 124     bool BColorModifier_black_and_white::operator==(const BColorModifier& rCompare) const
 125     {
 126         const BColorModifier_black_and_white* pCompare = dynamic_cast< const BColorModifier_black_and_white* >(&rCompare);
 127
 128         if(!pCompare)
 129         {
 130             return false;
 131         }
 132
 133         return mfValue == pCompare->mfValue;
 134     }
 135
 136     ::basegfx::BColor BColorModifier_black_and_white::getModifiedColor(const ::basegfx::BColor& aSourceColor) const
 137     {
 138         const double fLuminance(aSourceColor.luminance());
 139
 140         if(fLuminance < mfValue)
 141         {
 142             return ::basegfx::BColor::getEmptyBColor();
 143         }
 144         else
 145         {
 146             return ::basegfx::BColor(1.0, 1.0, 1.0);
 147         }
 148     }
 149
 150     BColorModifier_gamma::BColorModifier_gamma(double fValue)
 151     :   BColorModifier(),
 152         mfValue(fValue),
 153         mfInvValue(fValue),
 154         mbUseIt(!basegfx::fTools::equal(fValue, 1.0) && basegfx::fTools::more(fValue, 0.0) && basegfx::fTools::lessOrEqual(fValue, 10.0))
 155     {
 156         if(mbUseIt)
 157         {
 158             mfInvValue = 1.0 / mfValue;
 159         }
 160     }
 161
 162     BColorModifier_gamma::~BColorModifier_gamma()
 163     {
 164     }
 165
 166     bool BColorModifier_gamma::operator==(const BColorModifier& rCompare) const
 167     {
 168         const BColorModifier_gamma* pCompare = dynamic_cast< const BColorModifier_gamma* >(&rCompare);
 169
 170         if(!pCompare)
 171         {
 172             return false;
 173         }
 174
 175         // getValue is sufficient, mfInvValue and mbUseIt are only helper values
 176         return mfValue == pCompare->mfValue;
 177     }
 178
 179     ::basegfx::BColor BColorModifier_gamma::getModifiedColor(const ::basegfx::BColor& aSourceColor) const
 180     {
 181         if(mbUseIt)
 182         {
 183             ::basegfx::BColor aRetval(
 184                 pow(aSourceColor.getRed(), mfInvValue),
 185                 pow(aSourceColor.getGreen(), mfInvValue),
 186                 pow(aSourceColor.getBlue(), mfInvValue));
 187
 188             aRetval.clamp();
 189             return aRetval;
 190         }
 191         else
 192         {
 193             return aSourceColor;
 194         }
 195     }
 196
 197     BColorModifier_RGBLuminanceContrast::BColorModifier_RGBLuminanceContrast(double fRed, double fGreen, double fBlue, double fLuminance, double fContrast)
 198     :   BColorModifier(),
 199         mfRed(std::clamp(fRed, -1.0, 1.0)),
 200         mfGreen(std::clamp(fGreen, -1.0, 1.0)),
 201         mfBlue(std::clamp(fBlue, -1.0, 1.0)),
 202         mfLuminance(std::clamp(fLuminance, -1.0, 1.0)),
 203         mfContrast(std::clamp(fContrast, -1.0, 1.0)),
 204         mfContrastOff(1.0),
 205         mfRedOff(0.0),
 206         mfGreenOff(0.0),
 207         mfBlueOff(0.0),
 208         mbUseIt(false)
 209     {
 210         if(basegfx::fTools::equalZero(mfRed)
 211             && basegfx::fTools::equalZero(mfGreen)
 212             && basegfx::fTools::equalZero(mfBlue)
 213             && basegfx::fTools::equalZero(mfLuminance)
 214             && basegfx::fTools::equalZero(mfContrast))
 215             return;
 216
 217         // calculate slope
 218         if(mfContrast >= 0.0)
 219         {
 220             mfContrastOff = 128.0 / (128.0 - (mfContrast * 127.0));
 221         }
 222         else
 223         {
 224             mfContrastOff = ( 128.0 + (mfContrast * 127.0)) / 128.0;
 225         }
 226
 227         // calculate unified contrast offset
 228         const double fPreparedContrastOff((128.0 - mfContrastOff * 128.0) / 255.0);
 229         const double fCombinedOffset(mfLuminance + fPreparedContrastOff);
 230
 231         // set full offsets
 232         mfRedOff = mfRed + fCombinedOffset;
 233         mfGreenOff = mfGreen + fCombinedOffset;
 234         mfBlueOff = mfBlue + fCombinedOffset;
 235
 236         mbUseIt = true;
 237     }
 238
 239     BColorModifier_RGBLuminanceContrast::~BColorModifier_RGBLuminanceContrast()
 240     {
 241     }
 242
 243     bool BColorModifier_RGBLuminanceContrast::operator==(const BColorModifier& rCompare) const
 244     {
 245         const BColorModifier_RGBLuminanceContrast* pCompare = dynamic_cast< const BColorModifier_RGBLuminanceContrast* >(&rCompare);
 246
 247         if(!pCompare)
 248         {
 249             return false;
 250         }
 251
 252         // no need to compare other values, these are just helpers
 253         return mfRed == pCompare->mfRed
 254             && mfGreen == pCompare->mfGreen
 255             && mfBlue == pCompare->mfBlue
 256             && mfLuminance == pCompare->mfLuminance
 257             && mfContrast == pCompare->mfContrast;
 258     }
 259
 260     ::basegfx::BColor BColorModifier_RGBLuminanceContrast::getModifiedColor(const ::basegfx::BColor& aSourceColor) const
 261     {
 262         if(mbUseIt)
 263         {
 264             return basegfx::BColor(
 265                 std::clamp(aSourceColor.getRed() * mfContrastOff + mfRedOff, 0.0, 1.0),
 266                 std::clamp(aSourceColor.getGreen() * mfContrastOff + mfGreenOff, 0.0, 1.0),
 267                 std::clamp(aSourceColor.getBlue() * mfContrastOff + mfBlueOff, 0.0, 1.0));
 268         }
 269         else
 270         {
 271             return aSourceColor;
 272         }
 273     }
 274
 275     ::basegfx::BColor BColorModifierStack::getModifiedColor(const ::basegfx::BColor& rSource) const
 276     {
 277         if(maBColorModifiers.empty())
 278         {
 279             return rSource;
 280         }
 281
 282         ::basegfx::BColor aRetval(rSource);
 283
 284         for(sal_uInt32 a(maBColorModifiers.size()); a;)
 285         {
 286             a--;
 287             aRetval = maBColorModifiers[a]->getModifiedColor(aRetval);
 288         }
 289
 290         return aRetval;
 291     }
 292 } // end of namespace basegfx
 293
 294 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */