#include <KoMultipleColorConversionTransformation.h>

Inheritance diagram for KoMultipleColorConversionTransformation:

Public Member Functions
void	appendTransfo (KoColorConversionTransformation *transfo)

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

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

	~KoMultipleColorConversionTransformation () override

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

Public Member Functions inherited from KoColorConversionTransformation
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	transformInPlace (const quint8 src, quint8 dst, qint32 nPixels) const

	~KoColorConversionTransformation () override

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 ()

Public Attributes
quint32	maxPixelSize

QList< KoColorConversionTransformation * >	transfos

Public Attributes inherited from Private
KisCanvas2 *	canvas

int	displayedFrame

int	intendedFrame

Public Attributes inherited from KoColorConversionTransformation
ConversionFlags	conversionFlags

const KoColorSpace *	dstColorSpace

Intent	renderingIntent

const KoColorSpace *	srcColorSpace

Private Attributes
Private *const	d

Additional Inherited Members
Public Types inherited from KoColorConversionTransformation
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 }

Static Public Member Functions inherited from KoColorConversionTransformation
static ConversionFlags	adjustmentConversionFlags ()

static Intent	adjustmentRenderingIntent ()

static ConversionFlags	internalConversionFlags ()

static Intent	internalRenderingIntent ()

Detailed Description

This color conversion transformation allows to create a chain of color conversion between two color spaces. For instance, imagine we have three color spaces : CSA , CSB and CSC , we only know a transformation from CSA to CSB and from CSB to CSC , and we want to convert from CSA to CSC. Then we can create a KoMultipleColorConversionTransformation, and add to it with KoMultipleColorConversionTransformation::appendTransfo a transformation from CSA to CSB and a transformation from CSB to CSC.

Definition at line 13 of file KoMultipleColorConversionTransformation.cpp.

Constructor & Destructor Documentation

◆ KoMultipleColorConversionTransformation()

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

Create a color transformation from srcCs to dstCs.

Parameters

srcCs	the first color space in the chain
dstCs	the last color space in the chain

Definition at line 19 of file KoMultipleColorConversionTransformation.cpp.

    : KoColorConversionTransformation(srcCs, dstCs, renderingIntent, conversionFlags)
    , d(new Private)
{
    d->maxPixelSize = qMax(srcCs->pixelSize(), dstCs->pixelSize());
}

References d, and KoColorSpace::pixelSize().

◆ ~KoMultipleColorConversionTransformation()

KoMultipleColorConversionTransformation::~KoMultipleColorConversionTransformation ( )

override

Definition at line 25 of file KoMultipleColorConversionTransformation.cpp.

{
    Q_FOREACH (KoColorConversionTransformation* transfo, d->transfos) {
        delete transfo;
    }
    delete d;
}

References d.

Member Function Documentation

◆ appendTransfo()

void KoMultipleColorConversionTransformation::appendTransfo ( KoColorConversionTransformation * transfo )

Add a transformation to the chain.

Parameters

transfo this transformation is then deleted when the KoMultipleColorConversionTransformation is deleted.

Definition at line 32 of file KoMultipleColorConversionTransformation.cpp.

{
    d->transfos.append(transfo);
    d->maxPixelSize = qMax(d->maxPixelSize, transfo->srcColorSpace()->pixelSize());
    d->maxPixelSize = qMax(d->maxPixelSize, transfo->dstColorSpace()->pixelSize());
}

References d, KoColorConversionTransformation::dstColorSpace, KoColorSpace::pixelSize(), and KoColorConversionTransformation::srcColorSpace.

◆ transform()

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

overridevirtual

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 KoColorConversionTransformation.

Definition at line 38 of file KoMultipleColorConversionTransformation.cpp.

{
    Q_ASSERT(d->transfos.size() > 1); // Be sure to have a more than one transformation
    quint8 *buff1 = new quint8[d->maxPixelSize*nPixels];
    quint8 *buff2 = 0;
    if (d->transfos.size() > 2) {
        buff2 = new quint8[d->maxPixelSize*nPixels]; // a second buffer is needed
    }
    d->transfos.first()->transform(src, buff1, nPixels);
    int lastIndex = d->transfos.size() - 2;
    for (int i = 1; i <= lastIndex; i++) {
        d->transfos[i]->transform(buff1, buff2, nPixels);
        quint8* tmp = buff1;
        buff1 = buff2;
        buff2 = tmp;
    }
    d->transfos.last()->transform(buff1, dst, nPixels);
    delete [] buff2;
    delete [] buff1;
}