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