#include <KoColorConversionTransformation.h>

Inheritance diagram for KoColorConversionTransformation:

Public Types
enum	ConversionFlag { Empty = 0x0 , NoOptimization = 0x0100 , GamutCheck = 0x1000 , SoftProofing = 0x4000 , BlackpointCompensation = 0x2000 , NoWhiteOnWhiteFixup = 0x0004 , HighQuality = 0x0400 , LowQuality = 0x0800 , CopyAlpha = 0x04000000 , NoAdaptationAbsoluteIntent = 01000000 }

enum	Intent { IntentPerceptual = 0 , IntentRelativeColorimetric = 1 , IntentSaturation = 2 , IntentAbsoluteColorimetric = 3 }

Public Member Functions
ConversionFlags	conversionFlags () const

const KoColorSpace *	dstColorSpace () const

bool	isValid () const override

	KoColorConversionTransformation (const KoColorSpace srcCs, const KoColorSpace dstCs, Intent renderingIntent, ConversionFlags conversionFlags)

Intent	renderingIntent () const

const KoColorSpace *	srcColorSpace () const

void	transform (const quint8 src, quint8 dst, qint32 nPixels) const override=0

void	transformInPlace (const quint8 src, quint8 dst, qint32 nPixels) const

	~KoColorConversionTransformation () override

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

Public Member Functions inherited from KoColorTransformation
virtual int	parameterId (const QString &name) const

virtual QList< QString >	parameters () const

virtual void	setParameter (int id, const QVariant &parameter)

void	setParameters (const QHash< QString, QVariant > &parameters)

virtual	~KoColorTransformation ()

Static Public Member Functions
static ConversionFlags	adjustmentConversionFlags ()

static Intent	adjustmentRenderingIntent ()

static ConversionFlags	internalConversionFlags ()

static Intent	internalRenderingIntent ()

Public Attributes
ConversionFlags	conversionFlags

const KoColorSpace *	dstColorSpace

Intent	renderingIntent

const KoColorSpace *	srcColorSpace

Public Attributes inherited from Private
KisCanvas2 *	canvas

int	displayedFrame

int	intendedFrame

Private Member Functions
void	setDstColorSpace (const KoColorSpace *) const

void	setSrcColorSpace (const KoColorSpace *) const

Private Attributes
Private *const	d

Friends
class	KoColorConversionCache

Detailed Description

This is the base class of all color transform that convert the color of a pixel

Definition at line 17 of file KoColorConversionTransformation.cpp.

Member Enumeration Documentation

◆ ConversionFlag

enum KoColorConversionTransformation::ConversionFlag

Flags for the color conversion, see lcms2 documentation for more information

Enumerator
Empty
NoOptimization
GamutCheck
SoftProofing
BlackpointCompensation
NoWhiteOnWhiteFixup
HighQuality
LowQuality
CopyAlpha
NoAdaptationAbsoluteIntent

Definition at line 40 of file KoColorConversionTransformation.h.

                        {
        Empty                   = 0x0,
        NoOptimization          = 0x0100,
        GamutCheck              = 0x1000,    // Out of Gamut alarm
        SoftProofing            = 0x4000,    // Do softproofing
        BlackpointCompensation  = 0x2000,
        NoWhiteOnWhiteFixup     = 0x0004,    // Don't fix scum dot
        HighQuality             = 0x0400,    // Use more memory to give better accuracy
        LowQuality              = 0x0800,    // Use less memory to minimize resources
        CopyAlpha               = 0x04000000, //Let LCMS handle the alpha. Should always be on.
        NoAdaptationAbsoluteIntent = 01000000 // Krita-only flag, should be stripped off before passing to lcms (proofing only)
 
    };

◆ Intent

enum KoColorConversionTransformation::Intent

Possible value for the intent of a color conversion (useful only for ICC transformations)

Enumerator
IntentPerceptual
IntentRelativeColorimetric
IntentSaturation
IntentAbsoluteColorimetric

Definition at line 30 of file KoColorConversionTransformation.h.

                {
        IntentPerceptual = 0,
        IntentRelativeColorimetric = 1,
        IntentSaturation = 2,
        IntentAbsoluteColorimetric = 3
    };

Constructor & Destructor Documentation

◆ KoColorConversionTransformation()

KoColorConversionTransformation::KoColorConversionTransformation	(	const KoColorSpace *	srcCs,
		const KoColorSpace *	dstCs,
		Intent	renderingIntent,
		ConversionFlags	conversionFlags )

Definition at line 24 of file KoColorConversionTransformation.cpp.

    : d(new Private)
{
    Q_ASSERT(srcCs);
    Q_ASSERT(dstCs);
 
    d->srcColorSpace = srcCs;
    d->dstColorSpace = dstCs;
    d->renderingIntent = renderingIntent;
    d->conversionFlags = conversionFlags;
}

References conversionFlags, d, and renderingIntent.

◆ ~KoColorConversionTransformation()

KoColorConversionTransformation::~KoColorConversionTransformation ( )

override

Definition at line 39 of file KoColorConversionTransformation.cpp.

{
    delete d;
}

References d.

Member Function Documentation

◆ adjustmentConversionFlags()

static ConversionFlags KoColorConversionTransformation::adjustmentConversionFlags ( )

inlinestatic

Definition at line 77 of file KoColorConversionTransformation.h.

77{ return ConversionFlags(BlackpointCompensation | NoWhiteOnWhiteFixup); }

◆ adjustmentRenderingIntent()

static Intent KoColorConversionTransformation::adjustmentRenderingIntent ( )

inlinestatic

Definition at line 76 of file KoColorConversionTransformation.h.

76{ return IntentPerceptual; }

◆ conversionFlags()

ConversionFlags KoColorConversionTransformation::conversionFlags ( ) const

Returns: the conversion flags

◆ dstColorSpace()

const KoColorSpace * KoColorConversionTransformation::dstColorSpace ( ) const

Returns: the destination color space for this transformation.

◆ internalConversionFlags()

static ConversionFlags KoColorConversionTransformation::internalConversionFlags ( )

inlinestatic

Definition at line 74 of file KoColorConversionTransformation.h.

74{ return BlackpointCompensation; }

◆ internalRenderingIntent()

static Intent KoColorConversionTransformation::internalRenderingIntent ( )

inlinestatic

We have numerous places where we need to convert color spaces.

In several cases the user asks us about the conversion explicitly, e.g. when changing the image type or converting pixel data to the monitor profile. Doing this explicitly the user can choose what rendering intent and conversion flags to use.

But there are also cases when we have to do a conversion internally (transparently for the user), for example, when merging heterogeneous images, creating thumbnails, converting data to/from QImage or while doing some adjustments. We cannot ask the user about parameters for every single conversion. That's why in all these non-critical cases the following default values should be used.

Definition at line 73 of file KoColorConversionTransformation.h.

73{ return IntentPerceptual; }

◆ isValid()

bool KoColorConversionTransformation::isValid ( ) const

inlineoverridevirtual

Returns: false if the transformation is not valid

Reimplemented from KoColorTransformation.

Definition at line 125 of file KoColorConversionTransformation.h.

125{ return true; }

◆ renderingIntent()

Intent KoColorConversionTransformation::renderingIntent ( ) const

Returns: the rendering intent of this transformation (this is only useful for ICC transformations)

◆ setDstColorSpace()

void KoColorConversionTransformation::setDstColorSpace ( const KoColorSpace * cs ) const

private

Definition at line 81 of file KoColorConversionTransformation.cpp.

{
    Q_ASSERT(*d->dstColorSpace == *cs);
    d->dstColorSpace = cs;
}

References d.

◆ setSrcColorSpace()

void KoColorConversionTransformation::setSrcColorSpace ( const KoColorSpace * cs ) const

private

Definition at line 75 of file KoColorConversionTransformation.cpp.

{
    Q_ASSERT(*d->srcColorSpace == *cs);
    d->srcColorSpace = cs;
}

References d.

◆ srcColorSpace()

const KoColorSpace * KoColorConversionTransformation::srcColorSpace ( ) const

Returns: the source color space for this transformation.

◆ transform()

void KoColorConversionTransformation::transform	(	const quint8 *	src,
		quint8 *	dst,
		qint32	nPixels ) const

overridepure virtual

perform the color conversion between two buffers. Make sure that src is not the same as dst!

Parameters

nPixels the number of pixels in the buffers.

Implements KoColorTransformation.

Implemented in KoColorConversionFromAlphaTransformation< alpha_channel_type >, KoColorConversionAlphaToLab16Transformation< alpha_channel_type >, KoColorConversionGrayAFromAlphaTransformation< alpha_channel_type, gray_channel_type >, KoColorConversionToAlphaTransformation< alpha_channel_type >, KoColorConversionLab16ToAlphaTransformation< alpha_channel_type >, KoColorConversionGrayAToAlphaTransformation< gray_channel_type, alpha_channel_type >, KoMultipleColorConversionTransformation, ApplyRgbShaper< SrcCSTraits, DstCSTraits, Policy >, KoSimpleColorConversionTransformation, KoLcmsColorConversionTransformation, KoLcmsColorProofingConversionTransformation, KoScaleColorConversionTransformation< _src_CSTraits_, _dst_CSTraits_ >, and KoCopyColorConversionTransformation.

◆ transformInPlace()

void KoColorConversionTransformation::transformInPlace	(	const quint8 *	src,
		quint8 *	dst,
		qint32	nPixels ) const

perform the color conversion between two or one buffer. This is a convenience function that allows doing the conversion in-place

Parameters

nPixels the number of pixels in the buffers.

Definition at line 64 of file KoColorConversionTransformation.cpp.

{
    if (src != dst) {
        transform(src, dst, nPixels);
    } else {
        QByteArray buffer(srcColorSpace()->pixelSize() * nPixels, 0);
        transform(src, reinterpret_cast<quint8*>(buffer.data()), nPixels);
        memcpy(dst, buffer.data(), buffer.size());
    }
}