File indexing completed on 2024-05-12 04:44:34

 // SPDX-FileCopyrightText: Lukas Sommer <sommerluk@gmail.com>
 // SPDX-License-Identifier: BSD-2-Clause OR MIT
 
 // Own header
 #include "rgbcolor.h"
 
 #include "helperqttypes.h"
 #include <qglobal.h>
 #include <type_traits>
 
 namespace PerceptualColor
 {
 
 // TODO xxx Decide on the commented-out static_assert statements. Ideally
 // get them working!
 
 // static_assert(std::is_trivially_copyable_v<RgbColor>);
 // static_assert(std::is_trivial_v<RgbColor>);
 
 static_assert(std::is_standard_layout_v<RgbColor>);
 
 static_assert(std::is_default_constructible_v<RgbColor>);
 // static_assert(std::is_trivially_default_constructible_v<RgbColor>);
 // static_assert(std::is_nothrow_default_constructible_v<RgbColor>);
 
 static_assert(std::is_copy_constructible_v<RgbColor>);
 // static_assert(std::is_trivially_copy_constructible_v<RgbColor>);
 // static_assert(std::is_nothrow_copy_constructible_v<RgbColor>);
 
 // static_assert(std::is_move_constructible_v<RgbColor>);
 // static_assert(std::is_trivially_move_constructible_v<RgbColor>);
 // static_assert(std::is_nothrow_move_constructible_v<RgbColor>);
 
 RgbColor::RgbColor()
 {
 }
 
 /** @brief Set all member variables.
  *
  * @param color The new color as <tt>QColor</tt> object. Might be of any
  * <tt>QColor::Spec</tt>.
  * @param hue When empty, the hue is calculated automatically. Otherwise,
  * this value is used instead. Valid range: [0, 360[
  *
  * @post @ref hsl, @ref hsv, @ref hwb, @ref rgb255 and @ref rgbQColor are
  * set. */
 void RgbColor::fillAll(QColor color, std::optional<double> hue)
 {
     rgb255 = GenericColor(static_cast<double>(color.redF() * 255), //
                           static_cast<double>(color.greenF() * 255), //
                           static_cast<double>(color.blueF() * 255));
 
     rgbQColor = color.toRgb();
 
     // The hue is identical for HSL, HSV and HWB.
     const double hueDegree = hue.value_or( //
         qBound(0., rgbQColor.hueF() * 360, 360.));
 
     // HSL
     const double hslSaturationPercentage = //
         qBound(0., static_cast<double>(color.hslSaturationF()) * 100, 100.);
     const double hslLightnessPercentage = //
         qBound(0., static_cast<double>(color.lightnessF()) * 100, 100.);
     hsl = GenericColor(hueDegree, //
                        hslSaturationPercentage, //
                        hslLightnessPercentage);
 
     // HSV
     const double hsvSaturationPercentage = //
         qBound(0.0, static_cast<double>(color.hsvSaturationF()) * 100, 100.0);
     const double hsvValuePercentage = //
         qBound<double>(0.0, static_cast<double>(color.valueF()) * 100, 100.0);
     hsv = GenericColor(hueDegree, //
                        hsvSaturationPercentage, //
                        hsvValuePercentage);
 
     const double hwbWhitenessPercentage = //
         qBound(0.0, (1 - color.hsvSaturationF()) * color.valueF() * 100, 100.0);
     const double hwbBlacknessPercentage = //
         qBound(0.0, (1 - color.valueF()) * 100, 100.0);
     hwb = GenericColor(hueDegree, //
                        hwbWhitenessPercentage, //
                        hwbBlacknessPercentage);
 }
 
 /** @brief Static convenience function that returns a @ref RgbColor
  * constructed from the given color.
  *
  * @param color Original color. Valid range: [0, 255]
  * @param hue If not empty, this value is used instead of the actually
  *            calculated hue value. Valid range: [0, 360[
  * @returns A @ref RgbColor object representing this color. */
 RgbColor RgbColor::fromRgb255(const GenericColor &color, std::optional<double> hue)
 {
     RgbColor result;
     const auto red = static_cast<QColorFloatType>(color.first / 255.0);
     const auto green = static_cast<QColorFloatType>(color.second / 255.0);
     const auto blue = static_cast<QColorFloatType>(color.third / 255.0);
     constexpr auto zero = static_cast<QColorFloatType>(0);
     constexpr auto one = static_cast<QColorFloatType>(1);
     const QColor newRgbQColor = QColor::fromRgbF(qBound(zero, red, one), //
                                                  qBound(zero, green, one), //
                                                  qBound(zero, blue, one));
     result.fillAll(newRgbQColor, hue);
     result.rgb255 = color;
 
     return result;
 }
 
 /** @brief Static convenience function that returns a @ref RgbColor
  * constructed from the given color.
  *
  * @param color Original color.
  * @returns A @ref RgbColor object representing this color. */
 RgbColor RgbColor::fromRgbQColor(const QColor &color)
 {
     RgbColor result;
     result.fillAll(color, std::optional<double>());
 
     return result;
 }
 
 /** @brief Static convenience function that returns a @ref RgbColor
  * constructed from the given color.
  *
  * @param color Original color.
  * @returns A @ref RgbColor object representing this color. */
 RgbColor RgbColor::fromHsl(const GenericColor &color)
 {
     RgbColor result;
 
     constexpr auto zero = static_cast<QColorFloatType>(0);
     constexpr auto one = static_cast<QColorFloatType>(1);
     const auto hslHue = //
         qBound(zero, static_cast<QColorFloatType>(color.first / 360.0), one);
     const auto hslSaturation = //
         qBound(zero, static_cast<QColorFloatType>(color.second / 100.0), one);
     const auto hslLightness = //
         qBound(zero, static_cast<QColorFloatType>(color.third / 100.0), one);
     const QColor newRgbQColor = //
         QColor::fromHslF(hslHue, hslSaturation, hslLightness).toRgb();
     result.fillAll(newRgbQColor, color.first);
     // Override again with the original value:
     result.hsl = color;
     if (result.hsl.third == 0) {
         // Color is black. So neither changing HSV-saturation or changing
         // HSL-saturation will change the color itself. To give a better
         // user experience, we synchronize both values.
         result.hsv.second = result.hsl.second;
     }
 
     return result;
 }
 
 /** @brief Static convenience function that returns a @ref RgbColor
  * constructed from the given color.
  *
  * @param color Original color.
  * @returns A @ref RgbColor object representing this color. */
 RgbColor RgbColor::fromHsv(const GenericColor &color)
 {
     RgbColor result;
     constexpr auto zero = static_cast<QColorFloatType>(0);
     constexpr auto one = static_cast<QColorFloatType>(1);
     const auto hsvHue = //
         qBound(zero, static_cast<QColorFloatType>(color.first / 360.0), one);
     const auto hsvSaturation = //
         qBound(zero, static_cast<QColorFloatType>(color.second / 100.0), one);
     const auto hsvValue = //
         qBound(zero, static_cast<QColorFloatType>(color.third / 100.0), one);
     const QColor newRgbQColor = //
         QColor::fromHsvF(hsvHue, hsvSaturation, hsvValue);
     result.fillAll(newRgbQColor, color.first);
     // Override again with the original value:
     result.hsv = color;
     if (result.hsv.third == 0) {
         // Color is black. So neither changing HSV-saturation or changing
         // HSL-saturation will change the color itself. To give a better
         // user experience, we synchronize both values.
         result.hsl.second = result.hsv.second;
     }
 
     return result;
 }
 
 /** @brief Static convenience function that returns a @ref RgbColor
  * constructed from the given color.
  *
  * @param color Original color.
  * @returns A @ref RgbColor object representing this color. */
 RgbColor RgbColor::fromHwb(const GenericColor &color)
 {
     RgbColor result;
     GenericColor normalizedHwb = color;
     const auto whitenessBlacknessSum = //
         normalizedHwb.second + normalizedHwb.third;
     if (whitenessBlacknessSum > 100) {
         normalizedHwb.second *= 100 / whitenessBlacknessSum;
         normalizedHwb.third *= 100 / whitenessBlacknessSum;
     }
 
     const double quotient = (100 - normalizedHwb.third);
     const auto newHsvSaturation = //
         (quotient == 0) // This is only the case for pure black.
         ? 0 // Avoid division by 0 in the formula below. Instead, set
             // an arbitrary (in-range) value, because the HSV saturation
             // is meaningless when value/brightness is 0, which is the case
             // for black.
         : qBound<double>(0, 100 - normalizedHwb.second / quotient * 100, 100);
     const auto newHsvValue = qBound<double>(0, 100 - normalizedHwb.third, 100);
     const GenericColor newHsv = GenericColor(normalizedHwb.first, //
                                              newHsvSaturation, //
                                              newHsvValue);
     const QColor newRgbQColor = //
         QColor::fromHsvF( //
             static_cast<QColorFloatType>(newHsv.first / 360), //
             static_cast<QColorFloatType>(newHsv.second / 100), //
             static_cast<QColorFloatType>(newHsv.third / 100));
     result.fillAll(newRgbQColor, normalizedHwb.first);
     // Override again with the original value:
     result.hsv = newHsv;
     result.hwb = color; // Intentionally not normalized, but original value.
 
     return result;
 }
 
 /** @brief Equal operator
  *
  * @param other The object to compare with.
  *
  * @returns <tt>true</tt> if all data members have exactly the same
  * coordinates. <tt>false</tt> otherwise. */
 bool RgbColor::operator==(const RgbColor &other) const
 {
     // Test equality for all data members
     return (hsl == other.hsl) //
         && (hsv == other.hsv) //
         && (hwb == other.hwb) //
         && (rgb255 == other.rgb255) //
         && (rgbQColor == other.rgbQColor);
 }
 
 /** @internal
  *
  * @brief Adds QDebug() support for data type
  * @ref PerceptualColor::RgbColor
  *
  * @param dbg Existing debug object
  * @param value Value to stream into the debug object
  * @returns Debug object with value streamed in */
 QDebug operator<<(QDebug dbg, const PerceptualColor::RgbColor &value)
 {
     dbg.nospace() //
         << "RgbColor(\n"
         << " - hsl: " << value.hsl << "\n"
         << " - hsv: " << value.hsv << "\n"
         << " - hwb: " << value.hwb << "\n"
         << " - rgb: " << value.rgb255 << "\n"
         << " - rgbQColor: " << value.rgbQColor << "\n"
         << ")";
     return dbg.maybeSpace();
 }
 
 static_assert(std::is_standard_layout_v<RgbColor>);
 
 } // namespace PerceptualColor