#include <LcmsColorSpace.h>

Inheritance diagram for LcmsColorSpace< _CSTraits >:

Classes
struct	KisLcmsLastTransformation

struct	KoLcmsColorTransformation

struct	Private

Public Member Functions
KoColorTransformation *	createBrightnessContrastAdjustment (const quint16 *transferValues) const override

KoColorTransformation *	createPerChannelAdjustment (const quint16 const transferValues) const override

quint8	difference (const quint8 src1, const quint8 src2) const override

quint8	differenceA (const quint8 src1, const quint8 src2) const override

void	fromQColor (const QColor &color, quint8 *dst) const override

bool	hasHighDynamicRange () const override

const KoColorProfile *	profile () const override

bool	profileIsCompatible (const KoColorProfile *profile) const override

void	toQColor (const quint8 src, QColor color) const override

void	toQColor16 (const quint8 src, QColor color) const override

Public Member Functions inherited from KoColorSpaceAbstract< _CSTraits >
quint32	alphaPos () const override

void	applyAlphaNormedFloatMask (quint8 pixels, const float alpha, qint32 nPixels) const override

void	applyAlphaU8Mask (quint8 pixels, const quint8 alpha, qint32 nPixels) const override

void	applyInverseAlphaU8Mask (quint8 pixels, const quint8 alpha, qint32 nPixels) const override

void	applyInverseNormedFloatMask (quint8 pixels, const float alpha, qint32 nPixels) const override

quint32	channelCount () const override

QString	channelValueText (const quint8 *pixel, quint32 channelIndex) const override

quint32	colorChannelCount () const override

void	convertChannelToVisualRepresentation (const quint8 src, quint8 dst, quint32 nPixels, const QBitArray selectedChannels) const override

void	convertChannelToVisualRepresentation (const quint8 src, quint8 dst, quint32 nPixels, const qint32 selectedChannelIndex) const override

void	copyOpacityU8 (quint8 src, quint8 dst, qint32 nPixels) const override

KoColorTransformation *	createDarkenAdjustment (qint32 shade, bool compensate, qreal compensation) const override

KoColorTransformation *	createInvertTransformation () const override

void	fillGrayBrushWithColor (quint8 dst, const QRgb brush, quint8 *brushColor, qint32 nPixels) const override

void	fillInverseAlphaNormedFloatMaskWithColor (quint8 pixels, const float alpha, const quint8 *brushColor, qint32 nPixels) const override

void	fromNormalisedChannelsValue (quint8 *pixel, const QVector< float > &values) const override

quint8	intensity8 (const quint8 *src) const override

qreal	intensityF (const quint8 *src) const override

	KoColorSpaceAbstract (const QString &id, const QString &name)

void	multiplyAlpha (quint8 *pixels, quint8 alpha, qint32 nPixels) const override

void	normalisedChannelsValue (const quint8 *pixel, QVector< float > &channels) const override

QString	normalisedChannelValueText (const quint8 *pixel, quint32 channelIndex) const override

qreal	opacityF (const quint8 *U8_pixel) const override

quint8	opacityU8 (const quint8 *U8_pixel) const override

quint32	pixelSize () const override

quint8	scaleToU8 (const quint8 *srcPixel, qint32 channelIndex) const override

void	setOpacity (quint8 *pixels, qreal alpha, qint32 nPixels) const override

void	setOpacity (quint8 *pixels, quint8 alpha, qint32 nPixels) const override

void	singleChannelPixel (quint8 dstPixel, const quint8 srcPixel, quint32 channelIndex) const override

Public Member Functions inherited from KoColorSpace
virtual void	addCompositeOp (const KoCompositeOp *op)

virtual void	addDitherOp (KisDitherOp *op)

virtual void	bitBlt (const KoColorSpace srcSpace, const KoCompositeOp::ParameterInfo &params, const KoCompositeOp op, KoColorConversionTransformation::Intent renderingIntent, KoColorConversionTransformation::ConversionFlags conversionFlags) const

QBitArray	channelFlags (bool color=true, bool alpha=false) const

QList< KoChannelInfo * >	channels () const

virtual KoID	colorDepthId () const =0

virtual void	colorFromXML (quint8 *pixel, const QDomElement &elt) const =0

virtual KoID	colorModelId () const =0

virtual void	colorToXML (const quint8 *pixel, QDomDocument &doc, QDomElement &colorElt) const =0

const KoCompositeOp *	compositeOp (const QString &id, const KoColorSpace *srcSpace=nullptr) const

virtual QList< KoCompositeOp * >	compositeOps () const

virtual bool	convertPixelsTo (const quint8 src, quint8 dst, const KoColorSpace *dstColorSpace, quint32 numPixels, KoColorConversionTransformation::Intent renderingIntent, KoColorConversionTransformation::ConversionFlags conversionFlags) const

virtual QImage	convertToQImage (const quint8 data, qint32 width, qint32 height, const KoColorProfile dstProfile, KoColorConversionTransformation::Intent renderingIntent, KoColorConversionTransformation::ConversionFlags conversionFlags) const

virtual KoConvolutionOp *	convolutionOp () const

virtual KoColorConversionTransformation *	createColorConverter (const KoColorSpace *dstColorSpace, KoColorConversionTransformation::Intent renderingIntent, KoColorConversionTransformation::ConversionFlags conversionFlags) const

KoColorTransformation *	createColorTransformation (const QString &id, const QHash< QString, QVariant > &parameters) const

virtual KoColorConversionTransformation *	createProofingTransform (const KoColorSpace dstColorSpace, const KoColorSpace proofingSpace, KoColorConversionTransformation::Intent renderingIntent, KoColorConversionTransformation::Intent proofingIntent, bool bpcFirstTransform, quint8 *gamutWarning, KoColorConversionTransformation::ConversionFlags displayConversionFlags) const
	createProofingTransform Create a proofing transform. This is a two part transform that can also do gamut checks. The first transform is from source -> proofing space. Here the gamut checks are performed. The second is the proofing to destination space.

virtual void	decreaseHue (quint8 *pixel, qreal step) const

virtual void	decreaseLuminosity (quint8 *pixel, qreal step) const

virtual void	decreaseSaturation (quint8 *pixel, qreal step) const

virtual const KisDitherOp *	ditherOp (const QString &depth, DitherType type) const

QPolygonF	estimatedTRCXYY () const

virtual void	fillGrayBrushWithColorAndLightnessOverlay (quint8 dst, const QRgb brush, quint8 *brushColor, qint32 nPixels) const

virtual void	fillGrayBrushWithColorAndLightnessWithStrength (quint8 dst, const QRgb brush, quint8 *brushColor, qreal strength, qint32 nPixels) const

virtual QVector< double >	fromHSY (qreal hue, qreal sat, qreal *luma) const =0

virtual void	fromLabA16 (const quint8 src, quint8 dst, quint32 nPixels) const

virtual void	fromRgbA16 (const quint8 src, quint8 dst, quint32 nPixels) const

virtual QVector< double >	fromYUV (qreal y, qreal u, qreal *v) const =0

QPolygonF	gamutXYY () const

virtual bool	hasCompositeOp (const QString &id, const KoColorSpace *srcSpace=nullptr) const

QString	id () const

virtual void	increaseBlue (quint8 *pixel, qreal step) const

virtual void	increaseGreen (quint8 *pixel, qreal step) const

virtual void	increaseHue (quint8 *pixel, qreal step) const

virtual void	increaseLuminosity (quint8 *pixel, qreal step) const

virtual void	increaseRed (quint8 *pixel, qreal step) const

virtual void	increaseSaturation (quint8 *pixel, qreal step) const

virtual void	increaseYellow (quint8 *pixel, qreal step) const

	KoColorSpace (const QString &id, const QString &name, KoMixColorsOp mixColorsOp, KoConvolutionOp convolutionOp)
	Should be called by real color spaces.

QVector< qreal >	lumaCoefficients () const

virtual KoMixColorsOp *	mixColorsOp () const

virtual void	modulateLightnessByGrayBrush (quint8 dst, const QRgb brush, qreal strength, qint32 nPixels) const

QString	name () const

virtual bool	operator== (const KoColorSpace &rhs) const

virtual bool	proofPixelsTo (const quint8 src, quint8 dst, quint32 numPixels, KoColorConversionTransformation *proofingTransform) const
	proofPixelsTo

virtual void	toHSY (const QVector< double > &channelValues, qreal hue, qreal sat, qreal *luma) const =0

virtual void	toLabA16 (const quint8 src, quint8 dst, quint32 nPixels) const

virtual void	toRgbA16 (const quint8 src, quint8 dst, quint32 nPixels) const

virtual void	toYUV (const QVector< double > &channelValues, qreal y, qreal u, qreal *v) const =0

virtual void	transparentColor (quint8 *dst, quint32 nPixels) const

virtual bool	willDegrade (ColorSpaceIndependence independence) const =0

Public Member Functions inherited from Private
	Private (KisCanvas2 *c)

Public Member Functions inherited from KoLcmsInfo
virtual cmsColorSpaceSignature	colorSpaceSignature () const

virtual quint32	colorSpaceType () const

	KoLcmsInfo (cmsUInt32Number cmType, cmsColorSpaceSignature colorSpaceSignature)

virtual	~KoLcmsInfo ()

Protected Member Functions
void	init ()

	LcmsColorSpace (const QString &id, const QString &name, cmsUInt32Number cmType, cmsColorSpaceSignature colorSpaceSignature, KoColorProfile *p)

	~LcmsColorSpace () override

Protected Member Functions inherited from KoColorSpace
virtual void	addChannel (KoChannelInfo *ci)

const KoColorConversionTransformation *	fromLabA16Converter () const

const KoColorConversionTransformation *	fromRgbA16Converter () const

	KoColorSpace ()
	Only for use by classes that serve as baseclass for real color spaces.

virtual bool	preferCompositionInSourceColorSpace () const

const KoColorConversionTransformation *	toLabA16Converter () const

const KoColorConversionTransformation *	toRgbA16Converter () const

virtual	~KoColorSpace ()

Private Types
typedef QSharedPointer< KisLcmsLastTransformation >	KisLcmsLastTransformationSP

typedef KisLocklessStack< KisLcmsLastTransformationSP >	KisLcmsTransformationStack

Private Member Functions
LcmsColorProfileContainer *	lcmsProfile () const

Static Private Member Functions
static LcmsColorProfileContainer *	asLcmsProfile (const KoColorProfile *p)

Private Attributes
Private *const	d

Additional Inherited Members
Public Types inherited from KoColorSpaceAbstract< _CSTraits >
typedef _CSTraits	ColorSpaceTraits

Public Attributes inherited from KoColorSpace
ThreadLocalCache	channelFlagsApplicationCache

QList< KoChannelInfo * >	channels

QVector< qreal >	colorants

QHash< QString, KoCompositeOp * >	compositeOps

ThreadLocalCache	conversionCache

KoConvolutionOp *	convolutionOp

Deletability	deletability

QHash< QString, QMap< DitherType, KisDitherOp * > >	ditherOps

QPolygonF	gamutXYY

KoColorSpaceEngine *	iccEngine

QString	id

quint32	idNumber

QVector< qreal >	lumaCoefficients

KoMixColorsOp *	mixColorsOp

QString	name

KoColorConversionTransformation *	transfoFromLABA16

KoColorConversionTransformation *	transfoFromRGBA16

KoColorConversionTransformation *	transfoToLABA16

KoColorConversionTransformation *	transfoToRGBA16

QPolygonF	TRCXYY

Public Attributes inherited from Private
KisCanvas2 *	canvas

int	displayedFrame

int	intendedFrame

Protected Attributes inherited from KoColorSpace
Private *const	d

Detailed Description

template<class _CSTraits>
class LcmsColorSpace< _CSTraits >

This is the base class for all colorspaces that are based on the lcms library, for instance RGB 8bits and 16bits, CMYK 8bits and 16bits, LAB...

Definition at line 71 of file LcmsColorSpace.h.

Member Typedef Documentation

◆ KisLcmsLastTransformationSP

template<class _CSTraits >

typedef QSharedPointer<KisLcmsLastTransformation> LcmsColorSpace< _CSTraits >::KisLcmsLastTransformationSP

private

Definition at line 159 of file LcmsColorSpace.h.

◆ KisLcmsTransformationStack

template<class _CSTraits >

typedef KisLocklessStack<KisLcmsLastTransformationSP> LcmsColorSpace< _CSTraits >::KisLcmsTransformationStack

private

Definition at line 161 of file LcmsColorSpace.h.

Constructor & Destructor Documentation

◆ LcmsColorSpace()

template<class _CSTraits >

LcmsColorSpace< _CSTraits >::LcmsColorSpace	(	const QString &	id,
		const QString &	name,
		cmsUInt32Number	cmType,
		cmsColorSpaceSignature	colorSpaceSignature,
		KoColorProfile *	p )

inlineprotected

Definition at line 176 of file LcmsColorSpace.h.

        : KoColorSpaceAbstract<_CSTraits>(id, name)
        , KoLcmsInfo(cmType, colorSpaceSignature)
        , d(new Private())
    {
        Q_ASSERT(p); // No profile means the lcms color space can't work
        Q_ASSERT(profileIsCompatible(p));
        d->profile = asLcmsProfile(p);
        Q_ASSERT(d->profile);
        d->colorProfile = p;
        d->defaultTransformations = 0;
    }

References LcmsColorSpace< _CSTraits >::asLcmsProfile(), LcmsColorSpace< _CSTraits >::Private::colorProfile, LcmsColorSpace< _CSTraits >::d, LcmsColorSpace< _CSTraits >::Private::defaultTransformations, p, LcmsColorSpace< _CSTraits >::Private::profile, and LcmsColorSpace< _CSTraits >::profileIsCompatible().

◆ ~LcmsColorSpace()

template<class _CSTraits >

LcmsColorSpace< _CSTraits >::~LcmsColorSpace ( )

inlineoverrideprotected

Definition at line 193 of file LcmsColorSpace.h.

    {
        delete d->colorProfile;
        delete d->defaultTransformations;
        delete d;
    }

References LcmsColorSpace< _CSTraits >::Private::colorProfile, LcmsColorSpace< _CSTraits >::d, and LcmsColorSpace< _CSTraits >::Private::defaultTransformations.

Member Function Documentation

◆ asLcmsProfile()

template<class _CSTraits >

static LcmsColorProfileContainer * LcmsColorSpace< _CSTraits >::asLcmsProfile ( const KoColorProfile * p )

inlinestaticprivate

Definition at line 436 of file LcmsColorSpace.h.

    {
        if (!p) {
            return 0;
        }
 
        const IccColorProfile *iccp = dynamic_cast<const IccColorProfile *>(p);
 
        if (!iccp) {
            return 0;
        }
 
        Q_ASSERT(iccp->asLcms());
 
        return iccp->asLcms();
    }

References IccColorProfile::asLcms(), and p.

◆ createBrightnessContrastAdjustment()

template<class _CSTraits >

KoColorTransformation * LcmsColorSpace< _CSTraits >::createBrightnessContrastAdjustment ( const quint16 * transferValues ) const

inlineoverridevirtual

Create an adjustment object for adjusting the brightness and contrast transferValues is a 256 bins array with values from 0 to 0xFFFF This function is thread-safe, but you need to create one KoColorTransformation per thread.

Implements KoColorSpace.

Definition at line 301 of file LcmsColorSpace.h.

    {
        if (!d->profile) {
            return 0;
        }
 
        cmsToneCurve *transferFunctions[3];
        transferFunctions[0] = cmsBuildTabulatedToneCurve16(0, 256, transferValues);
        transferFunctions[1] = cmsBuildGamma(0, 1.0);
        transferFunctions[2] = cmsBuildGamma(0, 1.0);
 
        KoLcmsColorTransformation *adj = new KoLcmsColorTransformation(this);
        adj->profiles[1] = cmsCreateLinearizationDeviceLink(cmsSigLabData, transferFunctions);
        cmsSetDeviceClass(adj->profiles[1], cmsSigAbstractClass);
 
        adj->profiles[0] = d->profile->lcmsProfile();
        adj->profiles[2] = d->profile->lcmsProfile();
        adj->cmstransform  = cmsCreateMultiprofileTransform(adj->profiles, 3, this->colorSpaceType(), this->colorSpaceType(),
                             KoColorConversionTransformation::adjustmentRenderingIntent(),
                             KoColorConversionTransformation::adjustmentConversionFlags());
        adj->csProfile = d->profile->lcmsProfile();
        return adj;
    }

References KoColorConversionTransformation::adjustmentConversionFlags(), KoColorConversionTransformation::adjustmentRenderingIntent(), LcmsColorSpace< _CSTraits >::KoLcmsColorTransformation::cmstransform, LcmsColorSpace< _CSTraits >::KoLcmsColorTransformation::csProfile, LcmsColorSpace< _CSTraits >::d, LcmsColorProfileContainer::lcmsProfile(), LcmsColorSpace< _CSTraits >::Private::profile, and LcmsColorSpace< _CSTraits >::KoLcmsColorTransformation::profiles.

◆ createPerChannelAdjustment()

template<class _CSTraits >

KoColorTransformation * LcmsColorSpace< _CSTraits >::createPerChannelAdjustment ( const quint16 *const * transferValues ) const

inlineoverridevirtual

Create an adjustment object for adjusting individual channels transferValues is an array of colorChannelCount number of 256 bins array with values from 0 to 0xFFFF This function is thread-safe, but you need to create one KoColorTransformation per thread.

The layout of the channels must be the following:

0..N-2 - color channels of the pixel; N-1 - alpha channel of the pixel (if exists)

Implements KoColorSpace.

Definition at line 325 of file LcmsColorSpace.h.

    {
        if (!d->profile) {
            return 0;
        }
 
        cmsToneCurve **transferFunctions = new cmsToneCurve*[ this->colorChannelCount()];
 
        for (uint ch = 0; ch < this->colorChannelCount(); ch++) {
            transferFunctions[ch] = transferValues[ch] ?
                                    cmsBuildTabulatedToneCurve16(0, 256, transferValues[ch]) :
                                    cmsBuildGamma(0, 1.0);
        }
 
        cmsToneCurve **alphaTransferFunctions = new cmsToneCurve*[1];
        alphaTransferFunctions[0] = transferValues[this->colorChannelCount()] ?
                                    cmsBuildTabulatedToneCurve16(0, 256, transferValues[this->colorChannelCount()]) :
                                    cmsBuildGamma(0, 1.0);
 
        KoLcmsColorTransformation *adj = new KoLcmsColorTransformation(this);
        adj->profiles[0] = cmsCreateLinearizationDeviceLink(this->colorSpaceSignature(), transferFunctions);
        adj->profiles[1] = cmsCreateLinearizationDeviceLink(cmsSigGrayData, alphaTransferFunctions);
        adj->profiles[2] = 0;
        adj->csProfile = d->profile->lcmsProfile();
        adj->cmstransform  = cmsCreateTransform(adj->profiles[0], this->colorSpaceType(), 0, this->colorSpaceType(),
                                                KoColorConversionTransformation::adjustmentRenderingIntent(),
                                                KoColorConversionTransformation::adjustmentConversionFlags());
 
        adj->cmsAlphaTransform  = cmsCreateTransform(adj->profiles[1], TYPE_GRAY_FLT, 0, TYPE_GRAY_FLT,
                                  KoColorConversionTransformation::adjustmentRenderingIntent(),
                                  KoColorConversionTransformation::adjustmentConversionFlags());
 
        delete [] transferFunctions;
        delete [] alphaTransferFunctions;
        return adj;
    }

References KoColorConversionTransformation::adjustmentConversionFlags(), KoColorConversionTransformation::adjustmentRenderingIntent(), LcmsColorSpace< _CSTraits >::KoLcmsColorTransformation::cmsAlphaTransform, LcmsColorSpace< _CSTraits >::KoLcmsColorTransformation::cmstransform, KoColorSpaceAbstract< _CSTraits >::colorChannelCount(), KoLcmsInfo::colorSpaceSignature(), LcmsColorSpace< _CSTraits >::KoLcmsColorTransformation::csProfile, LcmsColorSpace< _CSTraits >::d, LcmsColorProfileContainer::lcmsProfile(), LcmsColorSpace< _CSTraits >::Private::profile, and LcmsColorSpace< _CSTraits >::KoLcmsColorTransformation::profiles.

◆ difference()

template<class _CSTraits >

quint8 LcmsColorSpace< _CSTraits >::difference	(	const quint8 *	src1,
		const quint8 *	src2 ) const

inlineoverridevirtual

Get the difference between 2 colors, normalized in the range (0,255). Only completely opaque and completely transparent are taken into account when computing the difference; other transparency levels are not regarded when finding the difference.

Completely transparent pixels are treated as if they are completely different from any non-transparent pixels.

Implements KoColorSpace.

Definition at line 362 of file LcmsColorSpace.h.

    {
        quint8 lab1[8], lab2[8];
        cmsCIELab labF1, labF2;
 
        if (this->opacityU8(src1) == OPACITY_TRANSPARENT_U8
                || this->opacityU8(src2) == OPACITY_TRANSPARENT_U8) {
            return (this->opacityU8(src1) == this->opacityU8(src2) ? 0 : 255);
        }
        Q_ASSERT(this->toLabA16Converter());
        this->toLabA16Converter()->transform(src1, lab1, 1);
        this->toLabA16Converter()->transform(src2, lab2, 1);
        cmsLabEncoded2Float(&labF1, (cmsUInt16Number *)lab1);
        cmsLabEncoded2Float(&labF2, (cmsUInt16Number *)lab2);
        qreal diff = cmsDeltaE(&labF1, &labF2);
 
        if (diff > 255.0) {
            return 255;
        } else {
            return quint8(diff);
        }
    }

References OPACITY_TRANSPARENT_U8, KoColorSpaceAbstract< _CSTraits >::opacityU8(), KoColorSpace::toLabA16Converter(), and KoColorConversionTransformation::transform().

◆ differenceA()

template<class _CSTraits >

quint8 LcmsColorSpace< _CSTraits >::differenceA	(	const quint8 *	src1,
		const quint8 *	src2 ) const

inlineoverridevirtual

Get the difference between 2 colors, normalized in the range (0,255). This function takes the Alpha channel of the pixel into account. Alpha channel has the same weight as Lightness channel.

Completely transparent pixels are treated as if their color channels are the same as ones of the other pixel. In other words, only alpha channel difference is compared.

Implements KoColorSpace.

Definition at line 385 of file LcmsColorSpace.h.

    {
        quint8 lab1[8];
        quint8 lab2[8];
        cmsCIELab labF1;
        cmsCIELab labF2;
 
        if (this->opacityU8(src1) == OPACITY_TRANSPARENT_U8
                || this->opacityU8(src2) == OPACITY_TRANSPARENT_U8) {
 
 
            const qreal alphaScale = 100.0 / 255.0;
            return qRound(alphaScale * qAbs(this->opacityU8(src1) - this->opacityU8(src2)));
        }
        Q_ASSERT(this->toLabA16Converter());
        this->toLabA16Converter()->transform(src1, lab1, 1);
        this->toLabA16Converter()->transform(src2, lab2, 1);
        cmsLabEncoded2Float(&labF1, (cmsUInt16Number *)lab1);
        cmsLabEncoded2Float(&labF2, (cmsUInt16Number *)lab2);
 
        cmsFloat64Number dL;
        cmsFloat64Number da;
        cmsFloat64Number db;
        cmsFloat64Number dAlpha;
 
        dL = fabs((qreal)(labF1.L - labF2.L));
        da = fabs((qreal)(labF1.a - labF2.a));
        db = fabs((qreal)(labF1.b - labF2.b));
 
        static const int LabAAlphaPos = 3;
        static const cmsFloat64Number alphaScale = 100.0 / KoColorSpaceMathsTraits<quint16>::max;
        quint16 alpha1 = reinterpret_cast<quint16 *>(lab1)[LabAAlphaPos];
        quint16 alpha2 = reinterpret_cast<quint16 *>(lab2)[LabAAlphaPos];
        dAlpha = fabs((qreal)(alpha1 - alpha2)) * alphaScale;
 
        qreal diff = pow(dL * dL + da * da + db * db + dAlpha * dAlpha, 0.5);
 
        if (diff > 255.0) {
            return 255;
        } else {
            return quint8(diff);
        }
    }

References OPACITY_TRANSPARENT_U8, KoColorSpaceAbstract< _CSTraits >::opacityU8(), KoColorSpace::toLabA16Converter(), and KoColorConversionTransformation::transform().

◆ fromQColor()

template<class _CSTraits >

void LcmsColorSpace< _CSTraits >::fromQColor	(	const QColor &	color,
		quint8 *	dst ) const

inlineoverridevirtual

The fromQColor methods take a given color defined as an RGB QColor and fills a byte array with the corresponding color in the the colorspace managed by this strategy.

Parameters

color	the QColor that will be used to fill dst
dst	a pointer to a pixel

Implements KoColorSpace.

Definition at line 262 of file LcmsColorSpace.h.

    {
        std::array<quint8, 3> qcolordata;
 
        qcolordata[2] = static_cast<quint8>(color.red());
        qcolordata[1] = static_cast<quint8>(color.green());
        qcolordata[0] = static_cast<quint8>(color.blue());
 
        // Default sRGB
        KIS_ASSERT(d->defaultTransformations && d->defaultTransformations->fromRGB);
        cmsDoTransform(d->defaultTransformations->fromRGB, qcolordata.data(), dst, 1);
 
        this->setOpacity(dst, static_cast<quint8>(color.alpha()), 1);
    }

References LcmsColorSpace< _CSTraits >::d, LcmsColorSpace< _CSTraits >::Private::defaultTransformations, KoLcmsDefaultTransformations::fromRGB, KIS_ASSERT, and KoColorSpaceAbstract< _CSTraits >::setOpacity().

◆ hasHighDynamicRange()

template<class _CSTraits >

bool LcmsColorSpace< _CSTraits >::hasHighDynamicRange ( ) const

inlineoverridevirtual

Returns true if the colorspace supports channel values outside the (normalised) range 0 to 1.

Implements KoColorSpace.

Reimplemented in RgbF16ColorSpace, RgbF32ColorSpace, XyzF16ColorSpace, XyzF32ColorSpace, and YCbCrF32ColorSpace.

Definition at line 246 of file LcmsColorSpace.h.

    {
        return false;
    }

◆ init()

template<class _CSTraits >

void LcmsColorSpace< _CSTraits >::init ( )

inlineprotected

Definition at line 200 of file LcmsColorSpace.h.

    {
        KIS_ASSERT(d->profile);
 
        if (KoLcmsDefaultTransformations::s_RGBProfile == 0) {
            KoLcmsDefaultTransformations::s_RGBProfile = cmsCreate_sRGBProfile();
        }
        d->defaultTransformations = KoLcmsDefaultTransformations::s_transformations[this->id()][ d->profile];
        if (!d->defaultTransformations) {
            KoColorConversionTransformation::ConversionFlags conversionFlags = KoColorConversionTransformation::internalConversionFlags();
            d->defaultTransformations = new KoLcmsDefaultTransformations;
            d->defaultTransformations->fromRGB = cmsCreateTransform(KoLcmsDefaultTransformations::s_RGBProfile,
                                                 TYPE_BGR_8,
                                                 d->profile->lcmsProfile(),
                                                 this->colorSpaceType(),
                                                 KoColorConversionTransformation::internalRenderingIntent(),
                                                 conversionFlags);
            KIS_SAFE_ASSERT_RECOVER_NOOP(d->defaultTransformations->fromRGB || !d->colorProfile->isSuitableForOutput());
 
            // LCMS has a too optimistic optimization when transforming from linear color spaces
            if (d->profile->isLinear()) {
                conversionFlags |= KoColorConversionTransformation::NoOptimization;
            }
 
            d->defaultTransformations->toRGB = cmsCreateTransform(d->profile->lcmsProfile(),
                                               this->colorSpaceType(),
                                               KoLcmsDefaultTransformations::s_RGBProfile,
                                               TYPE_BGR_8,
                                               KoColorConversionTransformation::internalRenderingIntent(),
                                               conversionFlags);
            KIS_SAFE_ASSERT_RECOVER_NOOP(d->defaultTransformations->toRGB);
 
            d->defaultTransformations->toRGB16 = cmsCreateTransform(d->profile->lcmsProfile(),
                                                 this->colorSpaceType(),
                                                 KoLcmsDefaultTransformations::s_RGBProfile,
                                                 TYPE_BGR_16,
                                                 KoColorConversionTransformation::internalRenderingIntent(),
                                                 conversionFlags);
            KIS_SAFE_ASSERT_RECOVER_NOOP(d->defaultTransformations->toRGB16);
 
            KoLcmsDefaultTransformations::s_transformations[ this->id()][ d->profile ] = d->defaultTransformations;
        }
    }

References LcmsColorSpace< _CSTraits >::Private::colorProfile, LcmsColorSpace< _CSTraits >::d, LcmsColorSpace< _CSTraits >::Private::defaultTransformations, KoLcmsDefaultTransformations::fromRGB, KoColorSpace::id, KoColorConversionTransformation::internalConversionFlags(), KoColorConversionTransformation::internalRenderingIntent(), LcmsColorProfileContainer::isLinear(), KoColorProfile::isSuitableForOutput(), KIS_ASSERT, KIS_SAFE_ASSERT_RECOVER_NOOP, LcmsColorProfileContainer::lcmsProfile(), KoColorConversionTransformation::NoOptimization, LcmsColorSpace< _CSTraits >::Private::profile, KoLcmsDefaultTransformations::s_RGBProfile, KoLcmsDefaultTransformations::s_transformations, KoLcmsDefaultTransformations::toRGB, and KoLcmsDefaultTransformations::toRGB16.

◆ lcmsProfile()

template<class _CSTraits >

LcmsColorProfileContainer * LcmsColorSpace< _CSTraits >::lcmsProfile ( ) const

inlineprivate

Definition at line 431 of file LcmsColorSpace.h.

    {
        return d->profile;
    }

References LcmsColorSpace< _CSTraits >::d, and LcmsColorSpace< _CSTraits >::Private::profile.

◆ profile()

template<class _CSTraits >

const KoColorProfile * LcmsColorSpace< _CSTraits >::profile ( ) const

inlineoverridevirtual

Return the profile of this color space.

Implements KoColorSpace.

Definition at line 251 of file LcmsColorSpace.h.

    {
        return d->colorProfile;
    }

References LcmsColorSpace< _CSTraits >::Private::colorProfile, and LcmsColorSpace< _CSTraits >::d.

◆ profileIsCompatible()

template<class _CSTraits >

bool LcmsColorSpace< _CSTraits >::profileIsCompatible ( const KoColorProfile * profile ) const

inlineoverridevirtual

Returns: true if the profile given in argument can be used by this color space

Implements KoColorSpace.

Definition at line 256 of file LcmsColorSpace.h.

    {
        const IccColorProfile *p = dynamic_cast<const IccColorProfile *>(profile);
        return (p && p->asLcms()->colorSpaceSignature() == colorSpaceSignature());
    }

References KoLcmsInfo::colorSpaceSignature(), p, and LcmsColorSpace< _CSTraits >::profile().

◆ toQColor()

template<class _CSTraits >

void LcmsColorSpace< _CSTraits >::toQColor	(	const quint8 *	src,
		QColor *	c ) const

inlineoverridevirtual

The toQColor methods take a byte array that is at least pixelSize() long and converts the contents to a QColor, using the given profile as a source profile and the optional profile as a destination profile.

Parameters

src	a pointer to the source pixel
c	the QColor that will be filled with the color at src

Implements KoColorSpace.

Definition at line 277 of file LcmsColorSpace.h.

    {
        std::array<quint8, 3> qcolordata;
 
        // Default sRGB transform
        KIS_ASSERT(d->defaultTransformations && d->defaultTransformations->toRGB);
        cmsDoTransform(d->defaultTransformations->toRGB, src, qcolordata.data(), 1);
 
        color->setRgb(qcolordata[2], qcolordata[1], qcolordata[0]);
        color->setAlpha(this->opacityU8(src));
    }

References LcmsColorSpace< _CSTraits >::d, LcmsColorSpace< _CSTraits >::Private::defaultTransformations, KIS_ASSERT, KoColorSpaceAbstract< _CSTraits >::opacityU8(), and KoLcmsDefaultTransformations::toRGB.

◆ toQColor16()

template<class _CSTraits >

void LcmsColorSpace< _CSTraits >::toQColor16	(	const quint8 *	src,
		QColor *	c ) const

inlineoverridevirtual

By default this does the same as toQColor

Reimplemented from KoColorSpaceAbstract< _CSTraits >.

Definition at line 289 of file LcmsColorSpace.h.

    {
        std::array<quint16, 3> qcolordata;
 
        // Default sRGB transform
        Q_ASSERT(d->defaultTransformations && d->defaultTransformations->toRGB16);
        cmsDoTransform(d->defaultTransformations->toRGB16, src, qcolordata.data(), 1);
 
        color->setRgba64(QRgba64::fromRgba64(qcolordata[2], qcolordata[1], qcolordata[0], 0x0000));
        color->setAlpha(this->opacityU8(src));
    }

References LcmsColorSpace< _CSTraits >::d, LcmsColorSpace< _CSTraits >::Private::defaultTransformations, KoColorSpaceAbstract< _CSTraits >::opacityU8(), and KoLcmsDefaultTransformations::toRGB16.

Member Data Documentation

◆ d

template<class _CSTraits >

Private* const LcmsColorSpace< _CSTraits >::d

private

Definition at line 453 of file LcmsColorSpace.h.

The documentation for this class was generated from the following file:

plugins/color/lcms2engine/LcmsColorSpace.h

Classes

Public Member Functions

Protected Member Functions

Private Types

Private Member Functions

Static Private Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Member Typedef Documentation

◆ KisLcmsLastTransformationSP

◆ KisLcmsTransformationStack

Constructor & Destructor Documentation

◆ LcmsColorSpace()

◆ ~LcmsColorSpace()

Member Function Documentation

◆ asLcmsProfile()

◆ createBrightnessContrastAdjustment()

◆ createPerChannelAdjustment()

◆ difference()

◆ differenceA()

◆ fromQColor()

◆ hasHighDynamicRange()

◆ init()

◆ lcmsProfile()

◆ profile()

◆ profileIsCompatible()

◆ toQColor()

◆ toQColor16()

Member Data Documentation

◆ d