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

 // SPDX-FileCopyrightText: Lukas Sommer <sommerluk@gmail.com>
 // SPDX-License-Identifier: BSD-2-Clause OR MIT
 
 // Own header
 #include "helpermath.h"
 
 #include <optional>
 #include <qgenericmatrix.h>
 #include <qmath.h>
 
 namespace PerceptualColor
 {
 
 /** @internal
  *
  * @brief Convenience constructor for @ref SquareMatrix3.
  *
  * @param r0c0 row 0, column 0
  * @param r0c1 row 0, column 1
  * @param r0c2 row 0, column 2
  * @param r1c0 row 1, column 0
  * @param r1c1 row 1, column 1
  * @param r1c2 row 1, column 2
  * @param r2c0 row 2, column 0
  * @param r2c1 row 2, column 1
  * @param r2c2 row 2, column 2
  *
  * @returns The corresponding @ref SquareMatrix3. */
 SquareMatrix3 createSquareMatrix3(double r0c0, double r0c1, double r0c2, double r1c0, double r1c1, double r1c2, double r2c0, double r2c1, double r2c2)
 {
     // clang-format off
     const double valueArray[] = {r0c0, r0c1, r0c2,
                                  r1c0, r1c1, r1c2,
                                  r2c0, r2c1, r2c2};
     // clang-format on
     return SquareMatrix3(valueArray);
 }
 
 /** @internal
  *
  * @brief Convenience constructor for @ref Trio.
  *
  * @param first first value
  * @param second second value
  * @param third third value
  *
  * @returns The corresponding @ref Trio. */
 Trio createTrio(double first, double second, double third)
 {
     const double valueArray[] = {first, second, third};
     return Trio(valueArray);
 }
 
 /** @internal
  *
  * @brief Try to find the inverse matrix.
  *
  * @param matrix The original matrix.
  *
  * @returns If the original matrix is invertible, its inverse matrix.
  * An empty value otherwise. */
 std::optional<SquareMatrix3> inverseMatrix(const SquareMatrix3 &matrix)
 {
     const double &a = matrix(0, 0);
     const double &b = matrix(0, 1);
     const double &c = matrix(0, 2);
     const double &d = matrix(1, 0);
     const double &e = matrix(1, 1);
     const double &f = matrix(1, 2);
     const double &g = matrix(2, 0);
     const double &h = matrix(2, 1);
     const double &i = matrix(2, 2);
     const auto determinant = a * e * i //
         + b * f * g //
         + c * d * h //
         - c * e * g //
         - b * d * i //
         - a * f * h;
     if (determinant == 0) {
         return std::nullopt;
     }
     // clang-format off
     const auto temp = createSquareMatrix3(
         e * i - f * h, c * h - b * i, b * f - c * e,
         f * g - d * i, a * i - c * g, c * d - a * f,
         d * h - e * g, b * g - a * h, a * e - b * d);
     // clang-format on
     return temp / determinant;
 }
 
 /** @brief Calculates the required number of decimals to achieve the requested
  * number of significant figures within the given range.
  *
  * @param rangeMax The maximum value of the range [0, rangeMax].
  * @param significantFigures The requested number of significant figures.
  *
  * | maxRange | decimalPlaces(maxRange, 2) | decimalPlaces(maxRange, 3) | decimalPlaces(maxRange, 4) |
  * | -------: | -------------------------: | -------------------------: | -------------------------: |
  * |        1 |                          1 |                          2 |                          3 |
  * |        2 |                          1 |                          2 |                          3 |
  * |      100 |                          0 |                          0 |                          1 |
  * |      255 |                          0 |                          0 |                          1 |
  * |      360 |                          0 |                          0 |                          1 |
  *
  * @returns The number of decimal places after the decimal point (in addition
  * to the whole number part) required to achieve the requested
  * number of significant figures within the given range. */
 int decimalPlaces(const int rangeMax, const int significantFigures)
 {
     const auto myLog10Value = std::log10(qAbs(rangeMax));
     const int wholeNumberDigits = (rangeMax == 0) //
         ? 1 // special case
         : qFloor(myLog10Value) + 1;
     return qMax(0, significantFigures - wholeNumberDigits);
 }
 
 } // namespace PerceptualColor