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

 // SPDX-FileCopyrightText: Lukas Sommer <sommerluk@gmail.com>
 // SPDX-License-Identifier: BSD-2-Clause OR MIT
 
 // Own header
 #include "absolutecolor.h"
 
 #include "helpermath.h"
 #include "helperposixmath.h"
 #include <cmath>
 #include <lcms2.h>
 #include <optional>
 #include <qgenericmatrix.h>
 #include <qglobal.h>
 #include <qmath.h>
 
 #if (QT_VERSION < QT_VERSION_CHECK(6, 0, 0))
 #include <qhashfunctions.h>
 #include <type_traits>
 #endif
 
 namespace PerceptualColor
 {
 
 // Doxygen doesn’t handle correctly the Q_GLOBAL_STATIC_WITH_ARGS macro, so
 // we instruct Doxygen with the @cond command to ignore  this part of the code.
 /// @cond
 
 // clang-format off
 
 // https://bottosson.github.io/posts/oklab/#converting-from-xyz-to-oklab
 Q_GLOBAL_STATIC_WITH_ARGS(
     const SquareMatrix3,
     m1,
     (std::array<double, 9>{{
         +0.8189330101, +0.3618667424, -0.1288597137,
         +0.0329845436, +0.9293118715, +0.0361456387,
         +0.0482003018, +0.2643662691, +0.6338517070}}.data()))
 
 // https://bottosson.github.io/posts/oklab/#converting-from-xyz-to-oklab
 Q_GLOBAL_STATIC_WITH_ARGS(
     const SquareMatrix3,
     m2,
     (std::array<double, 9>{{
         +0.2104542553, +0.7936177850, -0.0040720468,
         +1.9779984951, -2.4285922050, +0.4505937099,
         +0.0259040371, +0.7827717662, -0.8086757660}}.data()))
 
 // https://fujiwaratko.sakura.ne.jp/infosci/colorspace/bradford_e.html
 Q_GLOBAL_STATIC_WITH_ARGS(
     const SquareMatrix3,
     xyzD65ToXyzD50,
     (std::array<double, 9>{{
         +1.047886, +0.022919, -0.050216,
         +0.029582, +0.990484, -0.017079,
         -0.009252, +0.015073, +0.751678}}.data()))
 
 // clang-format on
 
 Q_GLOBAL_STATIC_WITH_ARGS( //
     const SquareMatrix3,
     m1inverse,
     (inverseMatrix(*m1).value_or(SquareMatrix3())))
 
 Q_GLOBAL_STATIC_WITH_ARGS( //
     const SquareMatrix3,
     m2inverse,
     (inverseMatrix(*m2).value_or(SquareMatrix3())))
 
 Q_GLOBAL_STATIC_WITH_ARGS( //
     const SquareMatrix3,
     xyzD50ToXyzD65,
     (inverseMatrix(*xyzD65ToXyzD50).value_or(SquareMatrix3())))
 
 /// @endcond
 
 /** @brief List of all available conversions from this color model.
  *
  * @param model The color model from which to convert.
  *
  * @returns List of all available conversions from this color model. */
 QList<AbsoluteColor::Conversion> AbsoluteColor::conversionsFrom(const ColorModel model)
 {
     QList<AbsoluteColor::Conversion> result;
     for (const auto &item : conversionList) {
         if (item.from == model) {
             result.append(item);
         }
     }
     return result;
 }
 
 /** @brief Adds some @ref GenericColor to an existing hash table.
  *
  * @param values A hash table with color values.
  * @param model The color model from which to perform conversions.
  *
  * @pre <em>values</em> contains the key <em>model</em>.
  *
  * @post For all available direct conversions from <em>model</em>, it is
  * checked whether a value for the destination color model is already
  * available in <em>values</em>. If not, this value is calculated and added
  * to <em>values</em>, and this function is called recursively again for this
  * destination color model. */
 void AbsoluteColor::addDirectConversionsRecursivly(QHash<ColorModel, GenericColor> *values, ColorModel model)
 {
     const auto availableConversions = conversionsFrom(model);
     const auto currentValue = values->value(model);
     for (const auto &conversion : availableConversions) {
         if (!values->contains(conversion.to)) {
             values->insert(conversion.to, conversion.conversionFunction(currentValue));
             addDirectConversionsRecursivly(values, conversion.to);
         }
     }
 }
 
 /** @brief Calculate conversions to all color models.
  *
  * @param model The original color model
  * @param value The original color value
  *
  * @returns A list containing the original value and containing conversions
  * to all other @ref ColorModel. */
 QHash<ColorModel, GenericColor> AbsoluteColor::allConversions(const ColorModel model, const GenericColor &value)
 {
     QHash<ColorModel, GenericColor> result;
     result.insert(model, value);
     addDirectConversionsRecursivly(&result, model);
     return result;
 }
 
 /** @internal
  *
  * @brief Conversion from <a href="https://bottosson.github.io/posts/oklab/">
  * Oklab color space</a> to
  * <a href="https://en.wikipedia.org/wiki/CIE_1931_color_space#Definition_of_the_CIE_XYZ_color_space">
  * CIE 1931 XYZ color space</a>.
  *
  * @param value The value to be converted
  *
  * @note <a href="https://bottosson.github.io/posts/oklab/">
  * Oklab</a> does not specify which
  * <a href="https://en.wikipedia.org/wiki/CIE_1931_color_space#CIE_standard_observer">
  * observer</a> the D65 whitepoint should use. But it states that
  * <em>“Oklab uses a D65 whitepoint, since this is what sRGB and other
  * common color spaces use.”</em>. As
  * <a href="https://en.wikipedia.org/wiki/SRGB">sRGB</a>
  * uses the <em>CIE 1931 2° Standard Observer</em>, this
  * might be a good choice.
  *
  * @returns the same color in
  * <a href="https://en.wikipedia.org/wiki/CIE_1931_color_space#Definition_of_the_CIE_XYZ_color_space">
  * CIE 1931 XYZ color space</a>. The XYZ value has
  * <a href="https://bottosson.github.io/posts/oklab/#converting-from-xyz-to-oklab">
  * “a D65 whitepoint and white as Y=1”</a>. */
 GenericColor AbsoluteColor::fromOklabToXyzD65(const GenericColor &value)
 {
     // The following algorithm is as described in
     // https://bottosson.github.io/posts/oklab/#converting-from-xyz-to-oklab
     //
     // Oklab: “The inverse operation, going from Oklab to XYZ is done with
     // the following steps:”
 
     auto lms = (*m2inverse) * value.toTrio(); // NOTE Entries might be negative.
     // LMS (long, medium, short) is the response of the three types of
     // cones of the human eye.
 
     lms(/*row*/ 0, /*column*/ 0) = std::pow(lms(/*row*/ 0, /*column*/ 0), 3);
     lms(/*row*/ 1, /*column*/ 0) = std::pow(lms(/*row*/ 1, /*column*/ 0), 3);
     lms(/*row*/ 2, /*column*/ 0) = std::pow(lms(/*row*/ 2, /*column*/ 0), 3);
 
     return GenericColor((*m1inverse) * lms);
 }
 
 /** @internal
  *
  * @brief Conversion from
  * <a href="https://en.wikipedia.org/wiki/CIE_1931_color_space#Definition_of_the_CIE_XYZ_color_space">
  * CIE 1931 XYZ color space</a> to
  * <a href="https://bottosson.github.io/posts/oklab/">
  * Oklab color space</a>.
  *
  * @param value The value to be converted
  *
  * @pre The XYZ value has
  * <a href="https://bottosson.github.io/posts/oklab/#converting-from-xyz-to-oklab">
  * “a D65 whitepoint and white as Y=1”</a>.
  *
  * @note <a href="https://bottosson.github.io/posts/oklab/">
  * Oklab</a> does not specify which
  * <a href="https://en.wikipedia.org/wiki/CIE_1931_color_space#CIE_standard_observer">
  * observer</a> the D65 whitepoint should use. But it states that
  * <em>“Oklab uses a D65 whitepoint, since this is what sRGB and other
  * common color spaces use.”</em>. As
  * <a href="https://en.wikipedia.org/wiki/SRGB">sRGB</a>
  * uses the <em>CIE 1931 2° Standard Observer</em>, this
  * might be a good choice.
  *
  * @returns the same color in
  * <a href="https://bottosson.github.io/posts/oklab/">
  * Oklab color space</a>. */
 GenericColor AbsoluteColor::fromXyzD65ToOklab(const GenericColor &value)
 {
     // The following algorithm is as described in
     // https://bottosson.github.io/posts/oklab/#converting-from-xyz-to-oklab
     //
     // Oklab: “First the XYZ coordinates are converted to an approximate
     // cone responses:”
     auto lms = (*m1) * value.toTrio(); // NOTE Entries might be negative.
     // LMS (long, medium, short) is the response of the three types of
     // cones of the human eye.
 
     // Oklab: “A non-linearity is applied:”
     // NOTE The original paper of Björn Ottosson, available at
     // https://bottosson.github.io/posts/oklab/#converting-from-xyz-to-oklab
     // proposes to calculate this: “x raised to the power of ⅓”. However,
     // x might be negative. The original paper does not explicitly explain
     // what the expected behaviour is, as “x raised to the power of ⅓”
     // is not universally defined for negative x values. Also,
     // std::pow(x, 1.0/3) would return “nan” for negative x. The
     // original paper does not provide a reference implementation for
     // the conversion between XYZ and Oklab. But it provides a reference
     // implementation for a direct (shortcut) conversion between sRGB
     // and Oklab, and this reference implementation uses std::cbrtf()
     // instead of std::pow(x, 1.0/3). And std::cbrtf() seems to allow
     // a negative radicand. This makes round-trip conversations possible,
     // because it gives unique results for each x value. Therefore, here
     // we do the same, but using std::cbrt() instead of std::cbrtf() to
     // allow double precision instead of float precision.
     lms(/*row*/ 0, /*column*/ 0) = std::cbrt(lms(/*row*/ 0, /*column*/ 0));
     lms(/*row*/ 1, /*column*/ 0) = std::cbrt(lms(/*row*/ 1, /*column*/ 0));
     lms(/*row*/ 2, /*column*/ 0) = std::cbrt(lms(/*row*/ 2, /*column*/ 0));
 
     // Oklab: “Finally, this is transformed into the Lab-coordinates:”
     return GenericColor((*m2) * lms);
 }
 
 /** @internal
  *
  * @brief Color conversion.
  *
  * @param value Color to be converted.
  *
  * @returns the converted color */
 GenericColor AbsoluteColor::fromXyzD65ToXyzD50(const GenericColor &value)
 {
     return GenericColor((*xyzD65ToXyzD50) * value.toTrio());
 }
 
 /** @internal
  *
  * @brief Color conversion.
  *
  * @param value Color to be converted.
  *
  * @returns the converted color */
 GenericColor AbsoluteColor::fromXyzD50ToXyzD65(const GenericColor &value)
 {
     return GenericColor((*xyzD50ToXyzD65) * value.toTrio());
 }
 
 /** @internal
  *
  * @brief Color conversion.
  *
  * @param value Color to be converted.
  *
  * @returns the converted color */
 GenericColor AbsoluteColor::fromXyzD50ToCielabD50(const GenericColor &value)
 {
     const cmsCIEXYZ cmsXyzD50 = value.reinterpretAsXyzToCmsciexyz();
     cmsCIELab result;
     cmsXYZ2Lab(cmsD50_XYZ(), // white point (for both, XYZ and also Cielab)
                &result, // output
                &cmsXyzD50); // input
     return GenericColor(result);
 }
 
 /** @internal
  *
  * @brief Color conversion.
  *
  * @param value Color to be converted.
  *
  * @returns the converted color */
 GenericColor AbsoluteColor::fromCielabD50ToXyzD50(const GenericColor &value)
 {
     const auto temp = value.reinterpretAsLabToCmscielab();
     cmsCIEXYZ xyzD50;
     cmsLab2XYZ(cmsD50_XYZ(), // white point (for both, XYZ and also Lab)
                &xyzD50, // output
                &temp); // input
     return GenericColor(xyzD50);
 }
 
 /** @internal
  *
  * @brief Color conversion.
  *
  * @param value Color to be converted.
  *
  * @returns the converted color
  *
  * This is a generic function converting between polar coordinates
  * (format: ignored, radius, angleDegree, ignored) and Cartesian coordinates
  * (format: ignored, x, y, ignored). */
 GenericColor AbsoluteColor::fromCartesianToPolar(const GenericColor &value)
 {
     GenericColor result = value;
     const auto &x = value.second;
     const auto &y = value.third;
     const auto radius = sqrt(pow(x, 2) + pow(y, 2));
     result.second = radius;
     if (radius == 0) {
         result.third = 0;
         return result;
     }
     if (y >= 0) {
         result.third = qRadiansToDegrees(acos(x / radius));
     } else {
         result.third = qRadiansToDegrees(2 * pi - acos(x / radius));
     }
     return result;
 }
 
 /** @internal
  *
  * @brief Color conversion.
  *
  * @param value Color to be converted.
  *
  * @returns the converted color
  *
  * This is a generic function converting between polar coordinates
  * (format: ignored, radius, angleDegree, ignored) and Cartesian coordinates
  * (format: ignored, x, y, ignored). */
 GenericColor AbsoluteColor::fromPolarToCartesian(const GenericColor &value)
 {
     const auto &radius = value.second;
     const auto &angleDegree = value.third;
     return GenericColor(value.first, //
                         radius * cos(qDegreesToRadians(angleDegree)),
                         radius * sin(qDegreesToRadians(angleDegree)),
                         value.fourth);
 }
 
 /** @brief Convert a color from one color model to another.
  *
  * @param from The color model from which the conversion is made.
  * @param value The value being converted.
  * @param to The color model to which the conversion is made.
  *
  * @returns The value converted into the new color model.
  *
  * @note This function is <em>not</em> speed-optimized. */
 std::optional<GenericColor> AbsoluteColor::convert(const ColorModel from, const GenericColor &value, const ColorModel to)
 {
     const auto temp = allConversions(from, value);
     if (temp.contains(to)) {
         return temp.value(to);
     }
     return std::nullopt;
 }
 
 } // namespace PerceptualColor