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

 // SPDX-FileCopyrightText: Lukas Sommer <sommerluk@gmail.com>
 // SPDX-License-Identifier: BSD-2-Clause OR MIT
 
 // Own headers
 // First the interface, which forces the header to be self-contained.
 #include "chromahueimageparameters.h"
 
 #include "asyncimagerendercallback.h"
 #include "cielchd50values.h"
 #include "helperconstants.h"
 #include "helpermath.h"
 #include "interlacingpass.h"
 #include "rgbcolorspace.h"
 #include <lcms2.h>
 #include <qcolor.h>
 #include <qimage.h>
 #include <qmath.h>
 #include <qnamespace.h>
 #include <qpainter.h>
 #include <qrgb.h>
 #include <qsharedpointer.h>
 #include <qsize.h>
 #include <type_traits>
 
 namespace PerceptualColor
 {
 /** @brief Equal operator
  *
  * @param other The object to compare with.
  *
  * @returns <tt>true</tt> if equal, <tt>false</tt> otherwise. */
 bool ChromaHueImageParameters::operator==(const ChromaHueImageParameters &other) const
 {
     return ( //
         (borderPhysical == other.borderPhysical) //
         && (devicePixelRatioF == other.devicePixelRatioF) //
         && (imageSizePhysical == other.imageSizePhysical) //
         && (lightness == other.lightness) //
         && (rgbColorSpace == other.rgbColorSpace) //
     );
 }
 
 /** @brief Unequal operator
  *
  * @param other The object to compare with.
  *
  * @returns <tt>true</tt> if unequal, <tt>false</tt> otherwise. */
 bool ChromaHueImageParameters::operator!=(const ChromaHueImageParameters &other) const
 {
     return !(*this == other);
 }
 
 /** @brief Render an image.
  *
  * The function will render the image with the given parameters,
  * and deliver the result of each interlacing pass and also the final
  * result by means of <tt>callbackObject</tt>.
  *
  * This function is thread-safe as long as each call of this function
  * uses different <tt>variantParameters</tt> and <tt>callbackObject</tt>.
  *
  * @param variantParameters A <tt>QVariant</tt> that contains the
  *        image parameters.
  * @param callbackObject Pointer to the object for the callbacks.
  *
  * @todo Could we get better performance? Even online tools like
  * https://bottosson.github.io/misc/colorpicker/#ff2a00 or
  * https://oklch.evilmartians.io/#65.4,0.136,146.7,100 get quite good
  * performance. How do they do that? */
 void ChromaHueImageParameters::render(const QVariant &variantParameters, AsyncImageRenderCallback &callbackObject)
 {
     if (!variantParameters.canConvert<ChromaHueImageParameters>()) {
         return;
     }
     const ChromaHueImageParameters parameters = //
         variantParameters.value<ChromaHueImageParameters>();
 
     // From Qt Example’s documentation:
     //
     //     “If we discover […] that restart has been set
     //      to true (by render()), we break out […] immediately […].
     //      Similarly, if we discover that abort has been set
     //      to true (by the […] destructor), we return from the
     //      function immediately […].”
     if (callbackObject.shouldAbort()) {
         return;
     }
     // Create a new QImage with correct image size.
     QImage myImage(
         // size:
         QSize(parameters.imageSizePhysical, parameters.imageSizePhysical),
         // format:
         QImage::Format_ARGB32_Premultiplied);
     // Calculate the radius of the circle we want to paint (and which will
     // finally have the background color, while everything around will be
     // transparent).
     const qreal circleRadius = //
         (parameters.imageSizePhysical - 2 * parameters.borderPhysical) / 2.;
     if ((circleRadius <= 0) || parameters.rgbColorSpace.isNull()) {
         // The border is too big the and image size too small: The size
         // of the circle is zero. Or: There is no color space with which
         // we can work (and dereferencing parameters.rgbColorSpace will
         // crash).
         // In either case: The image will therefore be transparent.
         // Initialize the image as completely transparent and return.
         myImage.fill(Qt::transparent);
         // Set the correct scaling information for the image and return
         myImage.setDevicePixelRatio(parameters.devicePixelRatioF);
         callbackObject.deliverInterlacingPass( //
             myImage, //
             variantParameters, //
             AsyncImageRenderCallback::InterlacingState::Final);
         return;
     }
 
     // If we continue, the circle will at least be visible.
 
     const QColor myNeutralGray = //
         parameters.rgbColorSpace->fromCielchD50ToQRgbBound(CielchD50Values::neutralGray);
 
     // Initialize the hole image background to the background color
     // of the circle:
     myImage.fill(myNeutralGray);
 
     // Prepare for gamut painting
     cmsCIELab cielabD50;
     cielabD50.L = parameters.lightness;
     int x;
     int y;
     QRgb tempColor;
     const auto chromaRange = parameters.rgbColorSpace->profileMaximumCielchD50Chroma();
     const qreal scaleFactor = static_cast<qreal>(2 * chromaRange)
         // The following line will never be 0 because we have have
         // tested above that circleRadius is > 0, so this line will
         // we > 0 also.
         / (parameters.imageSizePhysical - 2 * parameters.borderPhysical);
 
     // Paint the gamut.
     // The pixel at position QPoint(x, y) is the square with the top-left
     // edge at coordinate point QPoint(x, y) and the bottom-right edge at
     // coordinate point QPoint(x+1, y+1). This pixel is supposed to have
     // the color from coordinate point QPoint(x+0.5, y+0.5), which is
     // the middle of this pixel. Therefore, with an offset of 0.5 we
     // can convert from the pixel position to the point in the middle of
     // the pixel.
     constexpr qreal pixelOffset = 0.5;
     // TODO Could this be further optimized? For example not go from zero
     // up to imageSizePhysical, but exclude the border (and add the
     // tolerance)? Thought anyway the color transform (which is the heavy
     // work) is only done when within a given diameter, reducing loop runs
     // itself might also increase performance at least a little bit…
     constexpr auto numberOfPasses = 11;
     static_assert(isOdd(numberOfPasses));
     InterlacingPass currentPass = InterlacingPass::make<numberOfPasses>();
     QPainter myPainter(&myImage);
     myPainter.setRenderHint(QPainter::Antialiasing, false);
     while (true) {
         for (y = currentPass.lineOffset; //
              y < parameters.imageSizePhysical; //
              y += currentPass.lineFrequency) //
         {
             if (callbackObject.shouldAbort()) {
                 return;
             }
             cielabD50.b = chromaRange //
                 - (y + pixelOffset - parameters.borderPhysical) * scaleFactor;
             for (x = currentPass.columnOffset; //
                  x < parameters.imageSizePhysical; //
                  x += currentPass.columnFrequency //
             ) {
                 cielabD50.a = //
                     (x + pixelOffset - parameters.borderPhysical) * scaleFactor //
                     - chromaRange;
                 if ( //
                     (qPow(cielabD50.a, 2) + qPow(cielabD50.b, 2)) //
                     <= (qPow(chromaRange + overlap, 2)) //
                 ) {
                     tempColor = parameters //
                                     .rgbColorSpace //
                                     ->fromCielabD50ToQRgbOrTransparent(cielabD50);
                     if (qAlpha(tempColor) != 0) {
                         // The pixel is within the gamut!
                         myPainter.fillRect(
                             //
                             x, //
                             y, //
                             currentPass.rectangleSize.width(), //
                             currentPass.rectangleSize.height(), //
                             QColor(tempColor));
                     } else {
                         myPainter.fillRect(
                             //
                             x, //
                             y, //
                             currentPass.rectangleSize.width(), //
                             currentPass.rectangleSize.height(), //
                             myNeutralGray);
                     }
                 }
             }
         }
 
         const AsyncImageRenderCallback::InterlacingState state = //
             (currentPass.countdown > 1) //
             ? AsyncImageRenderCallback::InterlacingState::Intermediate //
             : AsyncImageRenderCallback::InterlacingState::Final;
 
         myImage.setDevicePixelRatio(parameters.devicePixelRatioF);
         callbackObject.deliverInterlacingPass(myImage, variantParameters, state);
         myImage.setDevicePixelRatio(1);
 
         if (state == AsyncImageRenderCallback::InterlacingState::Intermediate) {
             currentPass.switchToNextPass();
         } else {
             return;
         }
     }
 }
 
 static_assert(std::is_standard_layout_v<ChromaHueImageParameters>);
 
 } // namespace PerceptualColor