LcmsPredefinedPipelineFunctions.cpp File Reference

#include "LcmsPredefinedPipelineFunctions.h"
#include "kis_dom_utils.h"
#include <KoColorTransferFunctions.h>
#include <KoColorProfile.h>
#include <QMatrix4x4>
#include <QVector4D>

Go to the source code of this file.

Classes
struct	perceptualDummyHelper

Functions
static QMatrix4x4	bradfordMatrix (QVector4D src, QVector4D dst)
	bradfordMatrix From http://brucelindbloom.com/index.html?Eqn_ChromAdapt.html
static QMatrix4x4	rgbMatrix (ColorPrimaries primaries, double factor=1.0, double *luma=nullptr)
	rgbMatrix Generates a proper rgb matrix from a primaries type.
cmsInt32Number	samplePQDummyClut (const cmsUInt16Number In[], cmsUInt16Number Out[], void *Cargo)
	samplePQDummyClut In this sampler, we convert the PQ data to linear and then to HLG. The benefit of HLG is that it sort of allows for tonemapping.

Function Documentation

bradfordMatrix()

static QMatrix4x4 bradfordMatrix ( QVector4D src, QVector4D dst )

static

bradfordMatrix From http://brucelindbloom.com/index.html?Eqn_ChromAdapt.html

Parameters

src	– source white point XYZ
dst	– destionation white point XYZ

Returns

chromatic adaptation matrix.

Definition at line 20 of file LcmsPredefinedPipelineFunctions.cpp.

                                                               {
 
    QVector4D srcLMS(src[0], src[1], src[2], 0.0);
    QVector4D dstLMS(dst[0], dst[1], dst[2], 0.0);
 
    const QMatrix4x4 bradfordMatrix(
        0.8951000, 0.2664000, -0.1614000, 0.0,
        -0.7502000, 1.7135000, 0.0367000, 0.0,
        0.0389000, -0.0685000, 1.0296000, 0.0,
        0.0, 0.0, 0.0, 1.0
        );
    const QMatrix4x4 bradfordMatrixInverted (
        0.9869929, -0.1470543, 0.1599627, 0.0,
        0.4323053, 0.5183603, 0.0492912, 0.0,
        -0.0085287, 0.0400428, 0.9684867, 0.0,
        0.0, 0.0, 0.0, 1.0
    );
 
    srcLMS = bradfordMatrix * srcLMS;
    dstLMS = bradfordMatrix * dstLMS;
 
    const QMatrix4x4 adaptationMatrix (
        dstLMS.x()/srcLMS.x(), 0, 0, 0,
        0, dstLMS.y()/srcLMS.y(), 0, 0,
        0, 0, dstLMS.z()/srcLMS.z(), 0,
        0.0, 0.0, 0.0, 1.0
    );
 
 
    return bradfordMatrixInverted * adaptationMatrix * bradfordMatrix;
}

References bradfordMatrix().

rgbMatrix()

static QMatrix4x4 rgbMatrix ( ColorPrimaries primaries, double factor = 1.0, double * luma = nullptr )

static

rgbMatrix Generates a proper rgb matrix from a primaries type.

Parameters

primaries	– default primaries to use.
factor	– scaling factor.

Returns

transfrom representing a XYZ to RGB conversion.

Definition at line 58 of file LcmsPredefinedPipelineFunctions.cpp.

                                                                                                   {
    const double mul = 1.0/factor;
    // Calculation: http://brucelindbloom.com/index.html?Eqn_RGB_XYZ_Matrix.html
    // Calculates XYZ with Y = 1.0
    KoColorimetryUtils::xy wpXY;
    QList<KoColorimetryUtils::xy> col;
    KoColorProfile::colorantsForType(primaries, wpXY, col, true);
 
    QMatrix4x4 initialXYZMatrix(
        col[0].toXYZ().X, col[1].toXYZ().X, col[2].toXYZ().X, 0.0,
        1.0, 1.0, 1.0, 0.0,
        col[0].toXYZ().Z, col[1].toXYZ().Z, col[2].toXYZ().Z, 0.0,
        0.0, 0.0, 0.0, 1.0
        );
 
    // Calculate scaling factor with white point.
    QVector4D wp(wpXY.toXYZ().X, 1.0, wpXY.toXYZ().Z, 0.0);
 
    QVector4D S = initialXYZMatrix.inverted() * wp;
    if (luma) {
        luma[0] = S.x();
        luma[1] = S.y();
        luma[2] = S.z();
    }
 
    // Apply scaling factor to normalize the Y and get the matrix.
    QMatrix4x4 finalXYZMatrix(
        initialXYZMatrix(0, 0) * S.x(), initialXYZMatrix(0, 1) * S.y(), initialXYZMatrix(0, 2) * S.z(), 0.0,
        initialXYZMatrix(1, 0) * S.x(), initialXYZMatrix(1, 1) * S.y(), initialXYZMatrix(1, 2) * S.z(), 0.0,
        initialXYZMatrix(2, 0) * S.x(), initialXYZMatrix(2, 1) * S.y(), initialXYZMatrix(2, 2) * S.z(), 0.0,
        0.0, 0.0, 0.0, 1.0
        );
    // Apply bradford white point adaptation.
    QVector4D wpD50(0.9642, 1.0, 0.8249, 0.0);
    finalXYZMatrix = bradfordMatrix(wp, wpD50) * finalXYZMatrix;
 
    finalXYZMatrix.scale(mul);
    return finalXYZMatrix;
}

References bradfordMatrix(), KoColorProfile::colorantsForType(), S, KoColorimetryUtils::xy::toXYZ(), KoColorimetryUtils::XYZ::X, and KoColorimetryUtils::XYZ::Z.

samplePQDummyClut()

cmsInt32Number samplePQDummyClut	(	const cmsUInt16Number	In[],
		cmsUInt16Number	Out[],
		void *	Cargo )

samplePQDummyClut In this sampler, we convert the PQ data to linear and then to HLG. The benefit of HLG is that it sort of allows for tonemapping.

Important: this normalizes the pq signal.

scaling the nits value by the HLG scaling factor.

Definition at line 110 of file LcmsPredefinedPipelineFunctions.cpp.

                                                                                                 {
    struct perceptualDummyHelper *helper = (struct perceptualDummyHelper *) Cargo;
    const float pqScale = 125.0; 
    const float nominalPeak = 10000.0/(helper->diffuseWhiteNits * 3.7743);
 
    float lin[3];
    for (int i = 0; i < helper->channels; i++) {
        const float val = float(In[i])/65535.0;
        if (helper->toXYZ) {
            lin[i] = (removeSmpte2048Curve(val) / pqScale) * nominalPeak;
        } else {
            lin[i] = removeHLGCurve(val);
        }
    }
    for (int i = 0; i < helper->channels; i++) {
        cmsUInt16Number finalResult = In[i];
        if (helper->toXYZ) {
            finalResult = qBound(0, qRound( applyHLGCurve(lin[i]) * 65535 ), 65535);
        } else {
            finalResult = qBound(0, qRound( applySmpte2048Curve((lin[i] / nominalPeak) * pqScale) * 65535 ), 65535);
        }
        Out[i] = finalResult;
    }
    return true;
};

References applyHLGCurve(), applySmpte2048Curve(), perceptualDummyHelper::channels, perceptualDummyHelper::diffuseWhiteNits, removeHLGCurve(), removeSmpte2048Curve(), and perceptualDummyHelper::toXYZ.