#include <KoColorSpace.h>

Inheritance diagram for KoColorSpace:

Classes
struct	ThreadLocalCache

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

virtual void	addDitherOp (KisDitherOp *op)

virtual quint32	alphaPos () const =0

virtual void	applyAlphaNormedFloatMask (quint8 pixels, const float alpha, qint32 nPixels) const =0

virtual void	applyAlphaU8Mask (quint8 pixels, const quint8 alpha, qint32 nPixels) const =0

virtual void	applyInverseAlphaU8Mask (quint8 pixels, const quint8 alpha, qint32 nPixels) const =0

virtual void	applyInverseNormedFloatMask (quint8 pixels, const float alpha, qint32 nPixels) const =0

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

virtual quint32	channelCount () const =0

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

QList< KoChannelInfo * >	channels () const

virtual QString	channelValueText (const quint8 *pixel, quint32 channelIndex) const =0

virtual quint32	colorChannelCount () const =0

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 void	convertChannelToVisualRepresentation (const quint8 src, quint8 dst, quint32 nPixels, const QBitArray selectedChannels) const =0

virtual void	convertChannelToVisualRepresentation (const quint8 src, quint8 dst, quint32 nPixels, const qint32 selectedChannelIndex) const =0

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 void	copyOpacityU8 (quint8 src, quint8 dst, qint32 nPixels) const =0

virtual KoColorTransformation *	createBrightnessContrastAdjustment (const quint16 *transferValues) const =0

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 KoColorTransformation *	createDarkenAdjustment (qint32 shade, bool compensate, qreal compensation) const =0

virtual KoColorTransformation *	createInvertTransformation () const =0

virtual KoColorTransformation *	createPerChannelAdjustment (const quint16 const transferValues) const =0

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 quint8	difference (const quint8 src1, const quint8 src2) const =0

virtual quint8	differenceA (const quint8 src1, const quint8 src2) const =0

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

QPolygonF	estimatedTRCXYY () const

virtual void	fillGrayBrushWithColor (quint8 dst, const QRgb brush, quint8 *brushColor, qint32 nPixels) const =0

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 void	fillInverseAlphaNormedFloatMaskWithColor (quint8 pixels, const float alpha, const quint8 *brushColor, qint32 nPixels) const =0

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	fromNormalisedChannelsValue (quint8 *pixel, const QVector< float > &values) const =0

virtual void	fromQColor (const QColor &color, quint8 *dst) const =0

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

virtual bool	hasHighDynamicRange () const =0

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

virtual quint8	intensity8 (const quint8 *src) const =0

virtual qreal	intensityF (const quint8 *src) const =0

	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

virtual void	multiplyAlpha (quint8 *pixels, quint8 alpha, qint32 nPixels) const =0

QString	name () const

virtual void	normalisedChannelsValue (const quint8 *pixel, QVector< float > &channels) const =0

virtual QString	normalisedChannelValueText (const quint8 *pixel, quint32 channelIndex) const =0

virtual qreal	opacityF (const quint8 *pixel) const =0

virtual quint8	opacityU8 (const quint8 *pixel) const =0

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

virtual quint32	pixelSize () const =0

virtual const KoColorProfile *	profile () const =0

virtual bool	profileIsCompatible (const KoColorProfile *profile) const =0

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

virtual quint8	scaleToU8 (const quint8 *srcPixel, qint32 channelPos) const =0

virtual void	setOpacity (quint8 *pixels, qreal alpha, qint32 nPixels) const =0

virtual void	setOpacity (quint8 *pixels, quint8 alpha, qint32 nPixels) const =0

virtual void	singleChannelPixel (quint8 dstPixel, const quint8 srcPixel, quint32 channelIndex) const =0

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	toQColor (const quint8 src, QColor c) const =0

virtual void	toQColor16 (const quint8 src, QColor c) const =0

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 Attributes
ThreadLocalCache	channelFlagsApplicationCache

QList< KoChannelInfo * >	channels

QVector< KoColorimetryUtils::xyY >	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 Member Functions
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 ()

Protected Attributes
Private *const	d

Friends
class	KoColorSpaceFactory

class	KoColorSpaceRegistry

Detailed Description

A KoColorSpace is the definition of a certain color space.

A color model and a color space are two related concepts. A color model is more general in that it describes the channels involved and how they in broad terms combine to describe a color. Examples are RGB, HSV, CMYK.

A color space is more specific in that it also describes exactly how the channels are combined. So for each color model there can be a number of specific color spaces. So RGB is the model and sRGB, adobeRGB, etc are colorspaces.

In Pigment KoColorSpace acts as both a color model and a color space. You can think of the class definition as the color model, but the instance of the class as representing a colorspace.

A third concept is the profile represented by KoColorProfile. It represents the info needed to specialize a color model into a color space.

KoColorSpace is an abstract class serving as an interface.

Subclasses implement actual color spaces Some subclasses implement only some parts and are named Traits

Definition at line 77 of file KoColorSpace.h.

Constructor & Destructor Documentation

◆ KoColorSpace() [1/2]

KoColorSpace::KoColorSpace ( )

protected

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

Definition at line 39 of file KoColorSpace.cpp.

    : d(new Private())
{
}

◆ KoColorSpace() [2/2]

KoColorSpace::KoColorSpace	(	const QString &	id,
		const QString &	name,
		KoMixColorsOp *	mixColorsOp,
		KoConvolutionOp *	convolutionOp )

Should be called by real color spaces.

Definition at line 44 of file KoColorSpace.cpp.

    : d(new Private())
{
    d->id = id;
    d->idNumber = qHash(d->id);
    d->name = name;
    d->mixColorsOp = mixColorsOp;
    d->convolutionOp = convolutionOp;
    d->transfoToRGBA16 = 0;
    d->transfoFromRGBA16 = 0;
    d->transfoToLABA16 = 0;
    d->transfoFromLABA16 = 0;
    d->gamutXYY = QPolygonF();
    d->TRCXYY = QPolygonF();
    d->colorants = QVector <KoColorimetryUtils::xyY> (0);
    d->lumaCoefficients = QVector <qreal> (0);
    d->iccEngine = 0;
    d->deletability = NotOwnedByRegistry;
}

References convolutionOp, d, id, mixColorsOp, name, NotOwnedByRegistry, and qHash().

◆ ~KoColorSpace()

KoColorSpace::~KoColorSpace ( )

protectedvirtual

Definition at line 64 of file KoColorSpace.cpp.

{
    Q_ASSERT(d->deletability != OwnedByRegistryDoNotDelete);
 
    Q_FOREACH(const KoCompositeOp *op, d->compositeOps) {
        delete op;
    }
    d->compositeOps.clear();
    for (const auto& map: d->ditherOps) {
        qDeleteAll(map);
    }
    d->ditherOps.clear();
    Q_FOREACH (KoChannelInfo * channel, d->channels) {
        delete channel;
    }
    d->channels.clear();
    if (d->deletability == NotOwnedByRegistry) {
        KoColorConversionCache* cache = KoColorSpaceRegistry::instance()->colorConversionCache();
        if (cache) {
            cache->colorSpaceIsDestroyed(this);
        }
    }
    delete d->mixColorsOp;
    delete d->convolutionOp;
    delete d->transfoToRGBA16;
    delete d->transfoFromRGBA16;
    delete d->transfoToLABA16;
    delete d->transfoFromLABA16;
    delete d;
}

References KoColorSpaceRegistry::colorConversionCache, KoColorConversionCache::colorSpaceIsDestroyed(), d, KoColorSpaceRegistry::instance(), NotOwnedByRegistry, and OwnedByRegistryDoNotDelete.

Member Function Documentation

◆ addChannel()

void KoColorSpace::addChannel ( KoChannelInfo * ci )

protectedvirtual

Use this function in the constructor of your colorspace to add the information about a channel.

Parameters

ci	a pointer to the information about a channel

Definition at line 311 of file KoColorSpace.cpp.

{
    d->channels.push_back(ci);
}

References d.

◆ addCompositeOp()

void KoColorSpace::addCompositeOp ( const KoCompositeOp * op )

virtual

add a composite op to this colorspace.

Definition at line 387 of file KoColorSpace.cpp.

{
    if (op->colorSpace()->id() == id()) {
        d->compositeOps.insert(op->id(), const_cast<KoCompositeOp*>(op));
    }
}

References KoCompositeOp::colorSpace, d, id, and KoCompositeOp::id.

◆ addDitherOp()

void KoColorSpace::addDitherOp ( KisDitherOp * op )

virtual

Definition at line 354 of file KoColorSpace.cpp.

{
    if (op->sourceDepthId() == colorDepthId()) {
        if (!d->ditherOps.contains(op->destinationDepthId().id())) {
            d->ditherOps.insert(op->destinationDepthId().id(), {{op->type(), op}});
        } else {
            d->ditherOps[op->destinationDepthId().id()].insert(op->type(), op);
        }
    }
}

References colorDepthId(), d, KisDitherOp::destinationDepthId(), KoID::id(), KisDitherOp::sourceDepthId(), and KisDitherOp::type().

◆ alphaPos()

virtual quint32 KoColorSpace::alphaPos ( ) const

pure virtual

Position of the alpha channel in a pixel

◆ applyAlphaNormedFloatMask()

virtual void KoColorSpace::applyAlphaNormedFloatMask	(	quint8 *	pixels,
		const float *	alpha,
		qint32	nPixels ) const

pure virtual

Applies the specified float alpha mask to the pixels. We assume that there are just as many alpha values as pixels but we do not check this; alpha values have to be between 0.0 and 1.0

◆ applyAlphaU8Mask()

virtual void KoColorSpace::applyAlphaU8Mask	(	quint8 *	pixels,
		const quint8 *	alpha,
		qint32	nPixels ) const

pure virtual

Applies the specified 8-bit alpha mask to the pixels. We assume that there are just as many alpha values as pixels but we do not check this; the alpha values are assumed to be 8-bits.

◆ applyInverseAlphaU8Mask()

virtual void KoColorSpace::applyInverseAlphaU8Mask	(	quint8 *	pixels,
		const quint8 *	alpha,
		qint32	nPixels ) const

pure virtual

Applies the inverted 8-bit alpha mask to the pixels. We assume that there are just as many alpha values as pixels but we do not check this; the alpha values are assumed to be 8-bits.

◆ applyInverseNormedFloatMask()

virtual void KoColorSpace::applyInverseNormedFloatMask	(	quint8 *	pixels,
		const float *	alpha,
		qint32	nPixels ) const

pure virtual

Applies the inverted specified float alpha mask to the pixels. We assume that there are just as many alpha values as pixels but we do not check this; alpha values have to be between 0.0 and 1.0

◆ bitBlt()

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

virtual

Compose two arrays of pixels together. If source and target are not the same color model, the source pixels will be converted to the target model. We're "dst" – "dst" pixels are always in this colorspace.

Parameters

srcSpace	the colorspace of the source pixels that will be composited onto "us"
params	the information needed for blitting e.g. the source and destination pixel data, the opacity and flow, ...
op	the composition operator instance to use, e.g. COPY_OVER. This operator must belong to this (dst) color space, UNLESS preferCompositionInSourceColorSpace() returns true. In this case, the operator should be from the source color space. Besides avoiding recurring lookups via compositeOp(), this is necessary if this color space does not implement the desired composite op, but srcPace does. Use compositeOp() with valid srcSpace to get the appropriate op.
renderingIntent	the rendering intent
conversionFlags	the conversion flags.

Definition at line 498 of file KoColorSpace.cpp.

{
    Q_ASSERT_X(*op->colorSpace() == *this || (preferCompositionInSourceColorSpace() && *op->colorSpace() == *srcSpace),
               "KoColorSpace::bitBlt", QString("Composite op is for color space %1 (%2) while this is %3 (%4)").arg(op->colorSpace()->id()).arg(op->colorSpace()->profile()->name()).arg(id()).arg(profile()->name()).toLatin1());
 
    if(params.rows <= 0 || params.cols <= 0)
        return;
 
    if(!(*this == *srcSpace)) {
        if (preferCompositionInSourceColorSpace() &&
                (*op->colorSpace() == *srcSpace || srcSpace->hasCompositeOp(op->id()))) {
 
            quint32           conversionDstBufferStride = params.cols * srcSpace->pixelSize();
            QVector<quint8> * conversionDstCache        = d->conversionCache.get(params.rows * conversionDstBufferStride);
            quint8*           conversionDstData         = conversionDstCache->data();
 
            for(qint32 row=0; row<params.rows; row++) {
                convertPixelsTo(params.dstRowStart + row * params.dstRowStride,
                                conversionDstData  + row * conversionDstBufferStride, srcSpace, params.cols,
                                renderingIntent, conversionFlags);
            }
 
            // TODO: Composite op substitution should eventually be removed here, but it's not urgent.
            //       Code should just provide srcSpace to KoColorSpace::compositeOp() to avoid the lookups.
            const KoCompositeOp *otherOp = (*op->colorSpace() == *srcSpace) ? op : srcSpace->compositeOp(op->id());
 
            KoCompositeOp::ParameterInfo paramInfo(params);
            paramInfo.dstRowStart  = conversionDstData;
            paramInfo.dstRowStride = conversionDstBufferStride;
            otherOp->composite(paramInfo);
 
            for(qint32 row=0; row<params.rows; row++) {
                srcSpace->convertPixelsTo(conversionDstData  + row * conversionDstBufferStride,
                                          params.dstRowStart + row * params.dstRowStride, this, params.cols,
                                          renderingIntent, conversionFlags);
            }
 
        } else {
            quint32           conversionBufferStride = params.cols * pixelSize();
            QVector<quint8> * conversionCache        = d->conversionCache.get(params.rows * conversionBufferStride);
            quint8*           conversionData         = conversionCache->data();
 
 
            const bool noChannelFlags = params.channelFlags.isEmpty() ||
                    params.channelFlags == srcSpace->channelFlags(true, true);
 
            if (noChannelFlags) {
                for(qint32 row=0; row<params.rows; row++) {
                    srcSpace->convertPixelsTo(params.srcRowStart + row * params.srcRowStride,
                                              conversionData     + row * conversionBufferStride, this, params.cols,
                                              renderingIntent, conversionFlags);
                }
 
                KoCompositeOp::ParameterInfo paramInfo(params);
                paramInfo.srcRowStart  = conversionData;
                paramInfo.srcRowStride = conversionBufferStride;
                paramInfo.channelFlags = QBitArray();
                op->composite(paramInfo);
            } else {
                quint32           homogenizationBufferStride = params.cols * srcSpace->pixelSize();
                QVector<quint8> * homogenizationCache        = d->channelFlagsApplicationCache.get(homogenizationBufferStride);
                quint8*           homogenizationData         = homogenizationCache->data();
 
                for(qint32 row=0; row<params.rows; row++) {
                    srcSpace->convertChannelToVisualRepresentation(params.srcRowStart + row * params.srcRowStride,
                                                                   homogenizationData, params.cols,
                                                                   params.channelFlags | srcSpace->channelFlags(false, true));
                    srcSpace->convertPixelsTo(homogenizationData,
                                              conversionData + row * conversionBufferStride, this, params.cols,
                                              renderingIntent, conversionFlags);
                }
 
 
                KoCompositeOp::ParameterInfo paramInfo(params);
                paramInfo.srcRowStart  = conversionData;
                paramInfo.srcRowStride = conversionBufferStride;
                paramInfo.channelFlags = channelFlags(true, params.channelFlags.testBit(srcSpace->alphaPos()));
                op->composite(paramInfo);
            }
 
 
        }
    }
    else {
        op->composite(params);
    }
}

References alphaPos(), channelFlags(), KoCompositeOp::ParameterInfo::channelFlags, KoCompositeOp::colorSpace, KoCompositeOp::ParameterInfo::cols, KoCompositeOp::composite(), compositeOp(), conversionCache, convertChannelToVisualRepresentation(), convertPixelsTo(), d, KoCompositeOp::ParameterInfo::dstRowStart, KoCompositeOp::ParameterInfo::dstRowStride, hasCompositeOp(), id, KoCompositeOp::id, KoColorProfile::name, name, pixelSize(), preferCompositionInSourceColorSpace(), profile(), KoCompositeOp::ParameterInfo::rows, KoCompositeOp::ParameterInfo::srcRowStart, and KoCompositeOp::ParameterInfo::srcRowStride.

◆ channelCount()

virtual quint32 KoColorSpace::channelCount ( ) const

pure virtual

The total number of channels for a single pixel in this color model

◆ channelFlags()

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

returns a QBitArray that contains true for the specified channel types:

Parameters

color	if true, set all color channels to true
alpha	if true, set all alpha channels to true

The order of channels is the colorspace descriptive order, not the pixel order.

Definition at line 297 of file KoColorSpace.cpp.

{
    QBitArray ba(d->channels.size());
    if (!color && !alpha) return ba;
 
    for (int i = 0; i < d->channels.size(); ++i) {
        KoChannelInfo * channel = d->channels.at(i);
        if ((color && channel->channelType() == KoChannelInfo::COLOR) ||
                (alpha && channel->channelType() == KoChannelInfo::ALPHA))
            ba.setBit(i, true);
    }
    return ba;
}

References KoChannelInfo::ALPHA, KoChannelInfo::channelType(), KoChannelInfo::COLOR, and d.

◆ channels()

QList< KoChannelInfo * > KoColorSpace::channels ( ) const

Return a list describing all the channels this color model has. The order of the channels in the list is the order of channels in the pixel. To find out the preferred display position, use KoChannelInfo::displayPosition.

◆ channelValueText()

virtual QString KoColorSpace::channelValueText	(	const quint8 *	pixel,
		quint32	channelIndex ) const

pure virtual

Return a string with the channel's value suitable for display in the gui.

◆ colorChannelCount()

virtual quint32 KoColorSpace::colorChannelCount ( ) const

pure virtual

The total number of color channels (excludes alpha) for a single pixel in this color model.

◆ colorDepthId()

virtual KoID KoColorSpace::colorDepthId ( ) const

pure virtual

Returns: a string that identify the bit depth (for instance "U8" or "F16" ...)

See also: KoColorModelStandardIds.h

Implemented in KoAlphaColorSpaceImpl< _CSTrait >, KoSimpleColorSpace< _CSTraits >, KoSimpleColorSpace< KoBgrU16Traits >, KoSimpleColorSpace< KoBgrU8Traits >, KoSimpleColorSpace< KoLabU16Traits >, CmykF32ColorSpace, CmykU16ColorSpace, CmykU8ColorSpace, GrayF16ColorSpace, GrayF32ColorSpace, GrayAU16ColorSpace, GrayAU8ColorSpace, LabF32ColorSpace, LabU16ColorSpace, LabU8ColorSpace, RgbF16ColorSpace, RgbF32ColorSpace, RgbU16ColorSpace, RgbU8ColorSpace, XyzF16ColorSpace, XyzF32ColorSpace, XyzU16ColorSpace, XyzU8ColorSpace, YCbCrF32ColorSpace, YCbCrU16ColorSpace, and YCbCrU8ColorSpace.

◆ colorFromXML()

virtual void KoColorSpace::colorFromXML	(	quint8 *	pixel,
		const QDomElement &	elt ) const

pure virtual

Unserialize a color following Create's swatch color specification available at https://web.archive.org/web/20110826002520/http://create.freedesktop.org/wiki/Swatches_-_color_file_format/Draft

Parameters

pixel	buffer where the color will be unserialized
elt	the element to unserialize (<CMYK />, <sRGB />, <RGB />)

Returns: the unserialize color, or an empty color object if the function failed to unserialize the color

Implemented in KoAlphaColorSpaceImpl< _CSTrait >, KoSimpleColorSpace< _CSTraits >, KoSimpleColorSpace< KoBgrU16Traits >, KoSimpleColorSpace< KoBgrU8Traits >, KoSimpleColorSpace< KoLabU16Traits >, CmykF32ColorSpace, CmykU16ColorSpace, CmykU8ColorSpace, GrayF16ColorSpace, GrayF32ColorSpace, GrayAU16ColorSpace, GrayAU8ColorSpace, LabF32ColorSpace, LabU16ColorSpace, LabU8ColorSpace, RgbF16ColorSpace, RgbF32ColorSpace, RgbU16ColorSpace, RgbU8ColorSpace, XyzF16ColorSpace, XyzF32ColorSpace, XyzU16ColorSpace, XyzU8ColorSpace, YCbCrF32ColorSpace, YCbCrU16ColorSpace, and YCbCrU8ColorSpace.

◆ colorModelId()

virtual KoID KoColorSpace::colorModelId ( ) const

pure virtual

Returns: a string that identify the color model (for instance "RGB" or "CMYK" ...)

See also: KoColorModelStandardIds.h

Implemented in KoAlphaColorSpaceImpl< _CSTrait >, KoSimpleColorSpace< _CSTraits >, KoSimpleColorSpace< KoBgrU16Traits >, KoSimpleColorSpace< KoBgrU8Traits >, KoSimpleColorSpace< KoLabU16Traits >, CmykF32ColorSpace, CmykU16ColorSpace, CmykU8ColorSpace, GrayF16ColorSpace, GrayF32ColorSpace, GrayAU16ColorSpace, GrayAU8ColorSpace, LabF32ColorSpace, LabU16ColorSpace, LabU8ColorSpace, RgbF16ColorSpace, RgbF32ColorSpace, RgbU16ColorSpace, RgbU8ColorSpace, XyzF16ColorSpace, XyzF32ColorSpace, XyzU16ColorSpace, XyzU8ColorSpace, YCbCrF32ColorSpace, YCbCrU16ColorSpace, and YCbCrU8ColorSpace.

◆ colorToXML()

virtual void KoColorSpace::colorToXML	(	const quint8 *	pixel,
		QDomDocument &	doc,
		QDomElement &	colorElt ) const

pure virtual

Serialize this color following Create's swatch color specification available at https://web.archive.org/web/20110826002520/http://create.freedesktop.org/wiki/Swatches_-_color_file_format/Draft

This function doesn't create the <color /> element but rather the <CMYK />, <sRGB />, <RGB /> ... elements. It is assumed that colorElt is the <color /> element.

Parameters

pixel	buffer to serialized
colorElt	root element for the serialization, it is assumed that this element is <color />
doc	is the document containing colorElt

Implemented in KoAlphaColorSpaceImpl< _CSTrait >, KoSimpleColorSpace< _CSTraits >, KoSimpleColorSpace< KoBgrU16Traits >, KoSimpleColorSpace< KoBgrU8Traits >, KoSimpleColorSpace< KoLabU16Traits >, CmykF32ColorSpace, CmykU16ColorSpace, CmykU8ColorSpace, GrayF16ColorSpace, GrayF32ColorSpace, GrayAU16ColorSpace, GrayAU8ColorSpace, LabF32ColorSpace, LabU16ColorSpace, LabU8ColorSpace, RgbF16ColorSpace, RgbF32ColorSpace, RgbU16ColorSpace, RgbU8ColorSpace, XyzF16ColorSpace, XyzF32ColorSpace, XyzU16ColorSpace, XyzU8ColorSpace, YCbCrF32ColorSpace, YCbCrU16ColorSpace, and YCbCrU8ColorSpace.

◆ compositeOp()

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

Retrieve a single composite op from the ones this colorspace offers. If the requested composite op does not exist, COMPOSITE_OVER is returned.

Parameters

srcSpace optional source color space. Some color spaces prefer blitting in source color space. If already known, additional composite ops may be available. Note: if given, the returned op is only safe to use with this exact source color space!

Definition at line 370 of file KoColorSpace.cpp.

{
    if (srcSpace && preferCompositionInSourceColorSpace()) {
        if (const KoCompositeOp *op = srcSpace->compositeOp(id)) {
            return op;
        }
    }
    const QHash<QString, KoCompositeOp*>::ConstIterator it = d->compositeOps.constFind(id);
    if (it != d->compositeOps.constEnd()) {
        return it.value();
    }
    else {
        warnPigment << "Asking for nonexistent composite operation " << id << ", returning " << COMPOSITE_OVER;
        return d->compositeOps.value(COMPOSITE_OVER);
    }
}

References COMPOSITE_OVER, compositeOp(), d, preferCompositionInSourceColorSpace(), and warnPigment.

◆ compositeOps()

virtual QList< KoCompositeOp * > KoColorSpace::compositeOps ( ) const

virtual

Returns the list of user-visible composite ops supported by this colorspace.

◆ convertChannelToVisualRepresentation() [1/2]

virtual void KoColorSpace::convertChannelToVisualRepresentation	(	const quint8 *	src,
		quint8 *	dst,
		quint32	nPixels,
		const QBitArray	selectedChannels ) const

pure virtual

Convert nPixels pixels in src into their human-visible visual representation. The channels are shown as if other channels were null (or, if Lab, L = 1.0, *a = *b = 0.0).

Both buffers are in the same color space.

Parameters

src	source buffer in (*this) color space
dst	destination buffer in the same color space as `src`
nPixels	length of the buffers in number of pixels
pixelSize	stride of each pixel in the destination buffer
selectedChannels	Bitmap of selected channels

◆ convertChannelToVisualRepresentation() [2/2]

virtual void KoColorSpace::convertChannelToVisualRepresentation	(	const quint8 *	src,
		quint8 *	dst,
		quint32	nPixels,
		const qint32	selectedChannelIndex ) const

pure virtual

Convert nPixels pixels in src into their human-visible visual representation. The channel is shown as grayscale.

Both buffers are in the same color space.

Parameters

src	source buffer in (*this) color space
dst	destination buffer in the same color space as `src`
nPixels	length of the buffers in number of pixels
pixelSize	stride of each pixel in the destination buffer
selectedChannelIndex	Index of the selected channel.

◆ convertPixelsTo()

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

virtual

Convert a byte array of srcLen pixels *src to the specified color space and put the converted bytes into the prepared byte array *dst.

Returns false if the conversion failed, true if it succeeded

This function is not thread-safe. If you want to apply multiple conversion in different threads at the same time, you need to create one color converter per-thread using createColorConverter.

Reimplemented in KoSimpleColorSpace< _CSTraits >, KoSimpleColorSpace< KoBgrU16Traits >, KoSimpleColorSpace< KoBgrU8Traits >, and KoSimpleColorSpace< KoLabU16Traits >.

Definition at line 459 of file KoColorSpace.cpp.

{
    if (*this == *dstColorSpace) {
        if (src != dst) {
            memcpy(dst, src, numPixels * sizeof(quint8) * pixelSize());
        }
    } else {
        KoCachedColorConversionTransformation cct = KoColorSpaceRegistry::instance()->colorConversionCache()->cachedConverter(this, dstColorSpace, renderingIntent, conversionFlags);
        cct.transformation()->transform(src, dst, numPixels);
    }
    return true;
}

References KoColorConversionCache::cachedConverter(), KoColorSpaceRegistry::colorConversionCache, KoColorSpaceRegistry::instance(), pixelSize(), KoColorConversionTransformation::transform(), and KoCachedColorConversionTransformation::transformation().

◆ convertToQImage()

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

virtual

Convert the pixels in data to (8-bit BGRA) QImage using the specified profiles.

Parameters

data	A pointer to a contiguous memory region containing width * height pixels
width	in pixels
height	in pixels
dstProfile	destination profile
renderingIntent	the rendering intent
conversionFlags	conversion flags

Reimplemented in KoAlphaColorSpaceImpl< _CSTrait >.

Definition at line 855 of file KoColorSpace.cpp.

{
    QImage img = QImage(width, height, QImage::Format_ARGB32);
 
    const KoColorSpace * dstCS = KoColorSpaceRegistry::instance()->rgb8(dstProfile);
 
    if (data)
        this->convertPixelsTo(const_cast<quint8 *>(data), img.bits(), dstCS, width * height, renderingIntent, conversionFlags);
 
    return img;
}

References convertPixelsTo(), KoColorSpaceRegistry::instance(), and KoColorSpaceRegistry::rgb8().

◆ convolutionOp()

virtual KoConvolutionOp * KoColorSpace::convolutionOp ( ) const

virtual

Returns: the convolution operation of this colorspace (do not delete it locally, it's deleted by the colorspace).

◆ copyOpacityU8()

virtual void KoColorSpace::copyOpacityU8	(	quint8 *	src,
		quint8 *	dst,
		qint32	nPixels ) const

pure virtual

Copy the opacity of a run of pixels.

src – pixels to get opacity from. This is in the source colorspace. dst – pixels in Alpha8 colorspace to be assigned the opacity of src pixel nPixels – the number of pixels

◆ createBrightnessContrastAdjustment()

virtual KoColorTransformation * KoColorSpace::createBrightnessContrastAdjustment ( const quint16 * transferValues ) const

pure virtual

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.

◆ createColorConverter()

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

virtual

Create a color conversion transformation.

Definition at line 450 of file KoColorSpace.cpp.

{
    if (*this == *dstColorSpace) {
        return new KoCopyColorConversionTransformation(this);
    } else {
        return KoColorSpaceRegistry::instance()->createColorConverter(this, dstColorSpace, renderingIntent, conversionFlags);
    }
}

References KoColorSpaceRegistry::createColorConverter(), and KoColorSpaceRegistry::instance().

◆ createColorTransformation()

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

Definition at line 588 of file KoColorSpace.cpp.

{
    KoColorTransformationFactory* factory = KoColorTransformationFactoryRegistry::instance()->get(id);
    if (!factory) return 0;
    QPair<KoID, KoID> model(colorModelId(), colorDepthId());
    QList< QPair<KoID, KoID> > models = factory->supportedModels();
    if (models.isEmpty() || models.contains(model)) {
        return factory->createTransformation(this, parameters);
    } else {
        // Find the best solution
        // TODO use the color conversion cache
        KoColorConversionTransformation* csToFallBack = 0;
        KoColorConversionTransformation* fallBackToCs = 0;
        KoColorSpaceRegistry::instance()->createColorConverters(this, models, csToFallBack, fallBackToCs);
        Q_ASSERT(csToFallBack);
        Q_ASSERT(fallBackToCs);
        KoColorTransformation* transfo = factory->createTransformation(fallBackToCs->srcColorSpace(), parameters);
        return new KoFallBackColorTransformation(csToFallBack, fallBackToCs, transfo);
    }
}

References colorDepthId(), colorModelId(), KoColorSpaceRegistry::createColorConverters(), KoColorTransformationFactory::createTransformation(), KoGenericRegistry< T >::get(), KoColorSpaceRegistry::instance(), KoColorTransformationFactoryRegistry::instance(), KoColorConversionTransformation::srcColorSpace, and KoColorTransformationFactory::supportedModels().

◆ createDarkenAdjustment()

virtual KoColorTransformation * KoColorSpace::createDarkenAdjustment	(	qint32	shade,
		bool	compensate,
		qreal	compensation ) const

pure virtual

Darken all color channels with the given amount. If compensate is true, the compensation factor will be used to limit the darkening.

◆ createInvertTransformation()

virtual KoColorTransformation * KoColorSpace::createInvertTransformation ( ) const

pure virtual

Invert color channels of the given pixels This function is thread-safe, but you need to create one KoColorTransformation per thread.

◆ createPerChannelAdjustment()

virtual KoColorTransformation * KoColorSpace::createPerChannelAdjustment ( const quint16 *const * transferValues ) const

pure virtual

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)

◆ createProofingTransform()

KoColorConversionTransformation * KoColorSpace::createProofingTransform	(	const KoColorSpace *	dstColorSpace,
		const KoColorSpace *	proofingSpace,
		KoColorConversionTransformation::Intent	renderingIntent,
		KoColorConversionTransformation::Intent	proofingIntent,
		bool	bpcFirstTransform,
		quint8 *	gamutWarning,
		KoColorConversionTransformation::ConversionFlags	displayConversionFlags ) const

virtual

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.

Parameters

dstColorSpace	– destination space, typically the display profile.
proofingSpace	– space to proof to.
renderingIntent	– rendering intent for the first transform.
proofingIntent	– rendering intent for the second transform.
bcpFirstTransform	– whether the first transform should use blackpoint compensation. All other flags are handled by displayFlags.
gamutWarning	– The color of the gamut warning in dstColorSpace. Gamut warnings require Gamut warning flag being set on display flags.
adaptationState	– Whether the white point is being adapted in Absolute colorimetric. [0.0 1.0] with 0 no adaptation, 1 full adaptation.
displayConversionFlags	– the rest of the conversion flags. This includes blackpoint compensation for the second transform, as well as gamut warnings.

Returns: a KoColorConversionTransform that can softproof.

Definition at line 477 of file KoColorSpace.cpp.

{
    if (!d->iccEngine) {
        d->iccEngine = KoColorSpaceEngineRegistry::instance()->get("icc");
    }
    if (!d->iccEngine) return 0;
 
    return d->iccEngine->createColorProofingTransformation(this, dstColorSpace, proofingSpace, renderingIntent, proofingIntent, bpcFirstTransform, gamutWarning, displayConversionFlags);
}

References d, KoGenericRegistry< T >::get(), and KoColorSpaceEngineRegistry::instance().

◆ decreaseHue()

void KoColorSpace::decreaseHue	(	quint8 *	pixel,
		qreal	step ) const

virtual

Definition at line 743 of file KoColorSpace.cpp.

                                                              {
    int channelnumber = channelCount();
    QVector <double> channelValues(channelnumber);
    QVector <float> channelValuesF(channelnumber);
    normalisedChannelsValue(pixel, channelValuesF);
    for (int i=0;i<channelnumber;i++){
        channelValues[i]=channelValuesF[i];
    }
    profile()->linearizeFloatValue(channelValues);
    qreal hue, sat, luma = 0.0;
    toHSY(channelValues, &hue, &sat, &luma);
    if (hue-step<0.0){
        hue=1.0-(step-hue);
    } else {
        hue -= step;
    }
    channelValues = fromHSY(&hue, &sat, &luma);
    profile()->delinearizeFloatValue(channelValues);
    for (int i=0;i<channelnumber;i++){
        channelValuesF[i]=channelValues[i];
    }
    fromNormalisedChannelsValue(pixel, channelValuesF);
    setOpacity(pixel, 1.0, 1);
}

References channelCount(), KoColorProfile::delinearizeFloatValue(), fromHSY(), fromNormalisedChannelsValue(), KoColorProfile::linearizeFloatValue(), normalisedChannelsValue(), profile(), setOpacity(), and toHSY().

◆ decreaseLuminosity()

void KoColorSpace::decreaseLuminosity	(	quint8 *	pixel,
		qreal	step ) const

virtual

Definition at line 639 of file KoColorSpace.cpp.

                                                                      {
    int channelnumber = channelCount();
    QVector <double> channelValues(channelnumber);
    QVector <float> channelValuesF(channelnumber);
    normalisedChannelsValue(pixel, channelValuesF);
    for (int i=0;i<channelnumber;i++){
        channelValues[i]=channelValuesF[i];
    }
    if (profile()->hasTRC()){
        //only linearise and crunch the luma if there's a TRC
        profile()->linearizeFloatValue(channelValues);
        qreal hue, sat, luma = 0.0;
        toHSY(channelValues, &hue, &sat, &luma);
        luma = pow(luma, 1/2.2);
        if (luma-step<0.0) {
            luma=0.0;
        } else {
            luma -= step;
        }
        luma = pow(luma, 2.2);
        channelValues = fromHSY(&hue, &sat, &luma);
        profile()->delinearizeFloatValue(channelValues);
    } else {
        qreal hue, sat, luma = 0.0;
        toHSY(channelValues, &hue, &sat, &luma);
        if (luma-step<0.0) {
            luma=0.0;
        } else {
            luma -= step;
        }
        channelValues = fromHSY(&hue, &sat, &luma);
    }
    for (int i=0;i<channelnumber;i++){
        channelValuesF[i]=channelValues[i];
    }
    fromNormalisedChannelsValue(pixel, channelValuesF);
    setOpacity(pixel, 1.0, 1);
}

References channelCount(), KoColorProfile::delinearizeFloatValue(), fromHSY(), fromNormalisedChannelsValue(), KoColorProfile::linearizeFloatValue(), normalisedChannelsValue(), profile(), setOpacity(), and toHSY().

◆ decreaseSaturation()

void KoColorSpace::decreaseSaturation	(	quint8 *	pixel,
		qreal	step ) const

virtual

Definition at line 698 of file KoColorSpace.cpp.

                                                                     {
    int channelnumber = channelCount();
    QVector <double> channelValues(channelnumber);
    QVector <float> channelValuesF(channelnumber);
    normalisedChannelsValue(pixel, channelValuesF);
    for (int i=0;i<channelnumber;i++){
        channelValues[i]=channelValuesF[i];
    }
    profile()->linearizeFloatValue(channelValues);
    qreal hue, sat, luma = 0.0;
    toHSY(channelValues, &hue, &sat, &luma);
    sat -= step;
    sat = qBound(0.0, sat, 1.0);
    channelValues = fromHSY(&hue, &sat, &luma);
    profile()->delinearizeFloatValue(channelValues);
    for (int i=0;i<channelnumber;i++){
        channelValuesF[i]=channelValues[i];
    }
    fromNormalisedChannelsValue(pixel, channelValuesF);
    setOpacity(pixel, 1.0, 1);
}

References channelCount(), KoColorProfile::delinearizeFloatValue(), fromHSY(), fromNormalisedChannelsValue(), KoColorProfile::linearizeFloatValue(), normalisedChannelsValue(), profile(), setOpacity(), and toHSY().

◆ difference()

virtual quint8 KoColorSpace::difference	(	const quint8 *	src1,
		const quint8 *	src2 ) const

pure virtual

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.

◆ differenceA()

virtual quint8 KoColorSpace::differenceA	(	const quint8 *	src1,
		const quint8 *	src2 ) const

pure virtual

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.

◆ ditherOp()

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

virtual

Retrieve the elevate-to-normalized floating point dithering op.

Definition at line 333 of file KoColorSpace.cpp.

{
    const auto it = d->ditherOps.constFind(depth);
    if (it != d->ditherOps.constEnd()) {
        switch (type) {
        case DITHER_FAST:
        case DITHER_BAYER:
            return it->constFind(DITHER_BAYER).value();
        case DITHER_BEST:
        case DITHER_BLUE_NOISE:
            return it->constFind(DITHER_BLUE_NOISE).value();
        case DITHER_NONE:
        default:
            return it->constFind(DITHER_NONE).value();
        }
    } else {
        warnPigment << "Asking for dither op from " << colorDepthId() << "to an unsupported depth" << depth << "!";
        return nullptr;
    }
}

References colorDepthId(), d, DITHER_BAYER, DITHER_BEST, DITHER_BLUE_NOISE, DITHER_FAST, DITHER_NONE, and warnPigment.

◆ estimatedTRCXYY()

QPolygonF KoColorSpace::estimatedTRCXYY ( ) const

Definition at line 188 of file KoColorSpace.cpp.

{
    if (d->TRCXYY.empty()){
        const QList<KoChannelInfo *> channelInfo = this->channels();
 
        qreal max = 1.0;
        if ((colorModelId().id()=="CMYKA" || colorModelId().id()=="LABA") && colorDepthId().id()=="F32") {
            //boundaries for cmyka/laba have trouble getting the max values for Float, and are pretty awkward in general.
            max = channelInfo[0]->getUIMax();
        }
        const KoColorSpace* xyzColorSpace = KoColorSpaceRegistry::instance()->colorSpace("XYZA", "F32");
        quint8 *data = new quint8[pixelSize()];
        quint8 *data2 = new quint8[xyzColorSpace->pixelSize()];
 
        // This is fixed to 5 since the maximum number of channels are 5 for CMYKA
        QVector <float> channelValuesF(5);//for getting the coordinates.
 
        d->colorants = QVector<KoColorimetryUtils::xyY>(colorChannelCount());
 
        const int segments = 10;
        for (quint32 i=0; i<colorChannelCount(); i++) {
            qreal colorantY=1.0;
            if (colorModelId().id()!="CMYKA") {
                for (int j = 0; j <= segments; j++) {
                    channelValuesF.fill(0.0);
                    channelValuesF[channelInfo[i]->displayPosition()] = ((max/segments)*(segments-j));
 
                    if (colorModelId().id()!="XYZA") { //no need for conversion when using xyz.
                        fromNormalisedChannelsValue(data, channelValuesF);
                        convertPixelsTo(data, data2, xyzColorSpace, 1, KoColorConversionTransformation::IntentAbsoluteColorimetric,         KoColorConversionTransformation::adjustmentConversionFlags());
                        xyzColorSpace->normalisedChannelsValue(data2,channelValuesF);
                    }
                    if (j==0) {
                        colorantY = channelValuesF[1];
                        d->colorants[i].x = channelValuesF[0]/(channelValuesF[0]+channelValuesF[1]+channelValuesF[2]);
                        d->colorants[i].y = channelValuesF[1]/(channelValuesF[0]+channelValuesF[1]+channelValuesF[2]);
                        d->colorants[i].Y = channelValuesF[1];
                    }
                    d->TRCXYY << QPointF(channelValuesF[1]/colorantY, ((1.0/segments)*(segments-j)));
                }
            } else {
                for (int j = 0; j <= segments; j++) {
                    channelValuesF.fill(0.0);
                    channelValuesF[i] = ((max/segments)*(j));
 
                    fromNormalisedChannelsValue(data, channelValuesF);
 
                    convertPixelsTo(data, data2, xyzColorSpace, 1, KoColorConversionTransformation::IntentAbsoluteColorimetric,         KoColorConversionTransformation::adjustmentConversionFlags());
 
                    xyzColorSpace->normalisedChannelsValue(data2,channelValuesF);
 
                    if (j==0) {
                        colorantY = channelValuesF[1];
                        d->colorants[i].x = channelValuesF[0]/(channelValuesF[0]+channelValuesF[1]+channelValuesF[2]);
                        d->colorants[i].y = channelValuesF[1]/(channelValuesF[0]+channelValuesF[1]+channelValuesF[2]);
                        d->colorants[i].Y = channelValuesF[1];
                    }
                    d->TRCXYY << QPointF(channelValuesF[1]/colorantY, ((1.0/segments)*(j)));
                }
            }
        }
 
        delete[] data;
        delete[] data2;
        return d->TRCXYY;
    } else {
        return d->TRCXYY;
    }
}

References KoColorConversionTransformation::adjustmentConversionFlags(), channels, colorChannelCount(), colorDepthId(), colorModelId(), KoColorSpaceRegistry::colorSpace(), convertPixelsTo(), d, fromNormalisedChannelsValue(), KoID::id(), KoColorSpaceRegistry::instance(), KoColorConversionTransformation::IntentAbsoluteColorimetric, normalisedChannelsValue(), and pixelSize().

◆ fillGrayBrushWithColor()

virtual void KoColorSpace::fillGrayBrushWithColor	(	quint8 *	dst,
		const QRgb *	brush,
		quint8 *	brushColor,
		qint32	nPixels ) const

pure virtual

Fills dst with specified brushColor and then applies inverted brush mask specified in brush. Premultiplied red channel of the brush is used as an alpha channel for destination pixels.

The equation is:

dstC = colorC;
dstA = qAlpha(brush) * (255 - qRed(brush)) / 255;

◆ fillGrayBrushWithColorAndLightnessOverlay()

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

virtual

Fills dst with specified brushColor and then applies inverted brush mask specified in brush. Inverted red channel of the brush is used as lightness of the destination. Alpha channel of the brush is used as alpha of the destination.

The equation is:

dstL_hsl = preserveLightness(colorL_hsl, lightFactor);
dstA = qAlpha(brush);

For details on preserveLightness() formula, see KoColorSpacePreserveLightnessUtils.h

Reimplemented in KoRgbU16ColorSpace, KoRgbU8ColorSpace, RgbF16ColorSpace, RgbF32ColorSpace, RgbU16ColorSpace, and RgbU8ColorSpace.

Definition at line 876 of file KoColorSpace.cpp.

{
    fillGrayBrushWithColorAndLightnessWithStrength(dst, brush, brushColor, 1.0, nPixels);
}

References fillGrayBrushWithColorAndLightnessWithStrength().

◆ fillGrayBrushWithColorAndLightnessWithStrength()

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

virtual

Fallback implementation. All RGB color spaces have their own implementation without any conversions.

Reimplemented in KoRgbU16ColorSpace, KoRgbU8ColorSpace, RgbF16ColorSpace, RgbF32ColorSpace, RgbU16ColorSpace, and RgbU8ColorSpace.

Definition at line 881 of file KoColorSpace.cpp.

{
 
    const int rgbPixelSize = sizeof(KoBgrU16Traits::Pixel);
    QScopedArrayPointer<quint8> rgbBuffer(new quint8[(nPixels + 1) * rgbPixelSize]);
    quint8* rgbBrushColorBuffer = rgbBuffer.data() + nPixels * rgbPixelSize;
 
    // NOTE: dst buffer is not read during the process, so there is
    //       no need to convert that, just pass an uninitialized array
    this->toRgbA16(brushColor, rgbBrushColorBuffer, 1);
    fillGrayBrushWithColorPreserveLightnessRGB<KoBgrU16Traits>(rgbBuffer.data(), brush, rgbBrushColorBuffer, strength, nPixels);
    this->fromRgbA16(rgbBuffer.data(), dst, nPixels);
}

References fromRgbA16(), and toRgbA16().

◆ fillInverseAlphaNormedFloatMaskWithColor()

virtual void KoColorSpace::fillInverseAlphaNormedFloatMaskWithColor	(	quint8 *	pixels,
		const float *	alpha,
		const quint8 *	brushColor,
		qint32	nPixels ) const

pure virtual

Fills pixels with specified brushColor and then applies inverted brush mask specified in alpha.

◆ fromHSY()

virtual QVector< double > KoColorSpace::fromHSY	(	qreal *	hue,
		qreal *	sat,
		qreal *	luma ) const

pure virtual

◆ fromLabA16()

void KoColorSpace::fromLabA16	(	const quint8 *	src,
		quint8 *	dst,
		quint32	nPixels ) const

virtual

Convert the specified data from Lab (D50). to this colorspace. All colorspaces are guaranteed to support this.

Parameters

src	the pixels in 16 bit lab format
dst	the destination data
nPixels	the number of pixels in the array

Reimplemented in KoAlphaColorSpaceImpl< _CSTrait >, KoSimpleColorSpace< _CSTraits >, KoSimpleColorSpace< KoBgrU16Traits >, KoSimpleColorSpace< KoBgrU8Traits >, and KoSimpleColorSpace< KoLabU16Traits >.

Definition at line 435 of file KoColorSpace.cpp.

{
    fromLabA16Converter()->transform(src, dst, nPixels);
}

References fromLabA16Converter(), and KoColorConversionTransformation::transform().

◆ fromLabA16Converter()

const KoColorConversionTransformation * KoColorSpace::fromLabA16Converter ( ) const

protected

Definition at line 408 of file KoColorSpace.cpp.

{
    if (!d->transfoFromLABA16) {
        d->transfoFromLABA16 = KoColorSpaceRegistry::instance()->createColorConverter(KoColorSpaceRegistry::instance()->lab16(), this, KoColorConversionTransformation::internalRenderingIntent(), KoColorConversionTransformation::internalConversionFlags()) ;
    }
    return d->transfoFromLABA16;
}

References KoColorSpaceRegistry::createColorConverter(), d, KoColorSpaceRegistry::instance(), KoColorConversionTransformation::internalConversionFlags(), and KoColorConversionTransformation::internalRenderingIntent().

◆ fromNormalisedChannelsValue()

virtual void KoColorSpace::fromNormalisedChannelsValue	(	quint8 *	pixel,
		const QVector< float > &	values ) const

pure virtual

Write in the pixel the value from the normalized vector.

◆ fromQColor()

virtual void KoColorSpace::fromQColor	(	const QColor &	color,
		quint8 *	dst ) const

pure virtual

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

◆ fromRgbA16()

void KoColorSpace::fromRgbA16	(	const quint8 *	src,
		quint8 *	dst,
		quint32	nPixels ) const

virtual

Convert the specified data from sRGB 16 bits. to this colorspace. All colorspaces are guaranteed to support this.

Parameters

src	the pixels in 16 bit rgb format
dst	the destination data
nPixels	the number of pixels in the array

Reimplemented in KoAlphaColorSpaceImpl< _CSTrait >, KoSimpleColorSpace< _CSTraits >, KoSimpleColorSpace< KoBgrU16Traits >, KoSimpleColorSpace< KoBgrU8Traits >, and KoSimpleColorSpace< KoLabU16Traits >.

Definition at line 445 of file KoColorSpace.cpp.

{
    fromRgbA16Converter()->transform(src, dst, nPixels);
}

References fromRgbA16Converter(), and KoColorConversionTransformation::transform().

◆ fromRgbA16Converter()

const KoColorConversionTransformation * KoColorSpace::fromRgbA16Converter ( ) const

protected

Definition at line 422 of file KoColorSpace.cpp.

{
    if (!d->transfoFromRGBA16) {
        d->transfoFromRGBA16 = KoColorSpaceRegistry::instance()->createColorConverter(KoColorSpaceRegistry::instance()->rgb16() , this, KoColorConversionTransformation::internalRenderingIntent(), KoColorConversionTransformation::internalConversionFlags()) ;
    }
    return d->transfoFromRGBA16;
}

References KoColorSpaceRegistry::createColorConverter(), d, KoColorSpaceRegistry::instance(), KoColorConversionTransformation::internalConversionFlags(), and KoColorConversionTransformation::internalRenderingIntent().

◆ fromYUV()

virtual QVector< double > KoColorSpace::fromYUV	(	qreal *	y,
		qreal *	u,
		qreal *	v ) const

pure virtual

◆ gamutXYY()

QPolygonF KoColorSpace::gamutXYY ( ) const

◆ hasCompositeOp()

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

virtual

Tests if the colorspace offers the specific composite op.

Parameters

srcSpace optional source color space. Some color spaces prefer blitting in source color space. If already known, additional composite ops may be available.

Definition at line 315 of file KoColorSpace.cpp.

{
    if (srcSpace && preferCompositionInSourceColorSpace() && srcSpace->hasCompositeOp(id)) {
        return true;
    }
    return d->compositeOps.contains(id);
}

References d, hasCompositeOp(), and preferCompositionInSourceColorSpace().

◆ hasHighDynamicRange()

virtual bool KoColorSpace::hasHighDynamicRange ( ) const

pure virtual

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

◆ id()

QString KoColorSpace::id ( ) const

ID for use in files and internally: unchanging name. As the id must be unique it is usually the concatenation of the id of the color model and of the color depth, for instance "RGBA8" or "CMYKA16" or "XYZA32f".

◆ increaseBlue()

void KoColorSpace::increaseBlue	(	quint8 *	pixel,
		qreal	step ) const

virtual

Definition at line 811 of file KoColorSpace.cpp.

                                                               {
    int channelnumber = channelCount();
    QVector <double> channelValues(channelnumber);
    QVector <float> channelValuesF(channelnumber);
    normalisedChannelsValue(pixel, channelValuesF);
    for (int i=0;i<channelnumber;i++){
        channelValues[i]=channelValuesF[i];
    }
    profile()->linearizeFloatValue(channelValues);
    qreal y, u, v = 0.0;
    toYUV(channelValues, &y, &u, &v);
    v += step;
    v = qBound(0.0, v, 1.0);
    channelValues = fromYUV(&y, &u, &v);
    profile()->delinearizeFloatValue(channelValues);
    for (int i=0;i<channelnumber;i++){
        channelValuesF[i]=channelValues[i];
    }
    fromNormalisedChannelsValue(pixel, channelValuesF);
    setOpacity(pixel, 1.0, 1);
}

References channelCount(), KoColorProfile::delinearizeFloatValue(), fromNormalisedChannelsValue(), fromYUV(), KoColorProfile::linearizeFloatValue(), normalisedChannelsValue(), profile(), setOpacity(), toYUV(), u, and v.

◆ increaseGreen()

void KoColorSpace::increaseGreen	(	quint8 *	pixel,
		qreal	step ) const

virtual

Definition at line 789 of file KoColorSpace.cpp.

                                                                {
    int channelnumber = channelCount();
    QVector <double> channelValues(channelnumber);
    QVector <float> channelValuesF(channelnumber);
    normalisedChannelsValue(pixel, channelValuesF);
    for (int i=0;i<channelnumber;i++){
        channelValues[i]=channelValuesF[i];
    }
    profile()->linearizeFloatValue(channelValues);
    qreal y, u, v = 0.0;
    toYUV(channelValues, &y, &u, &v);
    u -= step;
    u = qBound(0.0, u, 1.0);
    channelValues = fromYUV(&y, &u, &v);
    profile()->delinearizeFloatValue(channelValues);
    for (int i=0;i<channelnumber;i++){
        channelValuesF[i]=channelValues[i];
    }
    fromNormalisedChannelsValue(pixel, channelValuesF);
    setOpacity(pixel, 1.0, 1);
}

References channelCount(), KoColorProfile::delinearizeFloatValue(), fromNormalisedChannelsValue(), fromYUV(), KoColorProfile::linearizeFloatValue(), normalisedChannelsValue(), profile(), setOpacity(), toYUV(), u, and v.

◆ increaseHue()

void KoColorSpace::increaseHue	(	quint8 *	pixel,
		qreal	step ) const

virtual

Definition at line 719 of file KoColorSpace.cpp.

                                                              {
    int channelnumber = channelCount(); //doesn't work for cmyka...
    QVector <double> channelValues(channelnumber);
    QVector <float> channelValuesF(channelnumber);
    normalisedChannelsValue(pixel, channelValuesF);
    for (int i=0;i<channelnumber;i++){
        channelValues[i]=channelValuesF[i];
    }
    profile()->linearizeFloatValue(channelValues);
    qreal hue, sat, luma = 0.0;
    toHSY(channelValues, &hue, &sat, &luma);
    if (hue+step>1.0){
        hue=(hue+step)- 1.0;
    } else {
        hue += step;
    }
    channelValues = fromHSY(&hue, &sat, &luma);
    profile()->delinearizeFloatValue(channelValues);
    for (int i=0;i<channelnumber;i++){
        channelValuesF[i]=channelValues[i];
    }
    fromNormalisedChannelsValue(pixel, channelValuesF);
    setOpacity(pixel, 1.0, 1);
}

References channelCount(), KoColorProfile::delinearizeFloatValue(), fromHSY(), fromNormalisedChannelsValue(), KoColorProfile::linearizeFloatValue(), normalisedChannelsValue(), profile(), setOpacity(), and toHSY().

◆ increaseLuminosity()

void KoColorSpace::increaseLuminosity	(	quint8 *	pixel,
		qreal	step ) const

virtual

Definition at line 609 of file KoColorSpace.cpp.

                                                                     {
    int channelnumber = channelCount();
    QVector <double> channelValues(channelnumber);
    QVector <float> channelValuesF(channelnumber);
    normalisedChannelsValue(pixel, channelValuesF);
    for (int i=0;i<channelnumber;i++){
        channelValues[i]=channelValuesF[i];
    }
    if (profile()->hasTRC()){
        //only linearise and crunch the luma if there's a TRC
        profile()->linearizeFloatValue(channelValues);
        qreal hue, sat, luma = 0.0;
        toHSY(channelValues, &hue, &sat, &luma);
        luma = pow(luma, 1/2.2);
        luma = qMin(1.0, luma + step);
        luma = pow(luma, 2.2);
        channelValues = fromHSY(&hue, &sat, &luma);
        profile()->delinearizeFloatValue(channelValues);
    } else {
        qreal hue, sat, luma = 0.0;
        toHSY(channelValues, &hue, &sat, &luma);
        luma = qMin(1.0, luma + step);
        channelValues = fromHSY(&hue, &sat, &luma);
    }
    for (int i=0;i<channelnumber;i++){
        channelValuesF[i]=channelValues[i];
    }
    fromNormalisedChannelsValue(pixel, channelValuesF);
    setOpacity(pixel, 1.0, 1);
}

References channelCount(), KoColorProfile::delinearizeFloatValue(), fromHSY(), fromNormalisedChannelsValue(), KoColorProfile::linearizeFloatValue(), normalisedChannelsValue(), profile(), setOpacity(), and toHSY().

◆ increaseRed()

void KoColorSpace::increaseRed	(	quint8 *	pixel,
		qreal	step ) const

virtual

Definition at line 768 of file KoColorSpace.cpp.

                                                              {
    int channelnumber = channelCount();
    QVector <double> channelValues(channelnumber);
    QVector <float> channelValuesF(channelnumber);
    normalisedChannelsValue(pixel, channelValuesF);
    for (int i=0;i<channelnumber;i++){
        channelValues[i]=channelValuesF[i];
    }
    profile()->linearizeFloatValue(channelValues);
    qreal y, u, v = 0.0;
    toYUV(channelValues, &y, &u, &v);
    u += step;
    u = qBound(0.0, u, 1.0);
    channelValues = fromYUV(&y, &u, &v);
    profile()->delinearizeFloatValue(channelValues);
    for (int i=0;i<channelnumber;i++){
        channelValuesF[i]=channelValues[i];
    }
    fromNormalisedChannelsValue(pixel, channelValuesF);
    setOpacity(pixel, 1.0, 1);
}

References channelCount(), KoColorProfile::delinearizeFloatValue(), fromNormalisedChannelsValue(), fromYUV(), KoColorProfile::linearizeFloatValue(), normalisedChannelsValue(), profile(), setOpacity(), toYUV(), u, and v.

◆ increaseSaturation()

void KoColorSpace::increaseSaturation	(	quint8 *	pixel,
		qreal	step ) const

virtual

Definition at line 677 of file KoColorSpace.cpp.

                                                                     {
    int channelnumber = channelCount();
    QVector <double> channelValues(channelnumber);
    QVector <float> channelValuesF(channelnumber);
    normalisedChannelsValue(pixel, channelValuesF);
    for (int i=0;i<channelnumber;i++){
        channelValues[i]=channelValuesF[i];
    }
    profile()->linearizeFloatValue(channelValues);
    qreal hue, sat, luma = 0.0;
    toHSY(channelValues, &hue, &sat, &luma);
    sat += step;
    sat = qBound(0.0, sat, 1.0);
    channelValues = fromHSY(&hue, &sat, &luma);
    profile()->delinearizeFloatValue(channelValues);
    for (int i=0;i<channelnumber;i++){
        channelValuesF[i]=channelValues[i];
    }
    fromNormalisedChannelsValue(pixel, channelValuesF);
    setOpacity(pixel, 1.0, 1);
}

References channelCount(), KoColorProfile::delinearizeFloatValue(), fromHSY(), fromNormalisedChannelsValue(), KoColorProfile::linearizeFloatValue(), normalisedChannelsValue(), profile(), setOpacity(), and toHSY().

◆ increaseYellow()

void KoColorSpace::increaseYellow	(	quint8 *	pixel,
		qreal	step ) const

virtual

Definition at line 833 of file KoColorSpace.cpp.

                                                                 {
    int channelnumber = channelCount();
    QVector <double> channelValues(channelnumber);
    QVector <float> channelValuesF(channelnumber);
    normalisedChannelsValue(pixel, channelValuesF);
    for (int i=0;i<channelnumber;i++){
        channelValues[i]=channelValuesF[i];
    }
    profile()->linearizeFloatValue(channelValues);
    qreal y, u, v = 0.0;
    toYUV(channelValues, &y, &u, &v);
    v -= step;
    v = qBound(0.0, v, 1.0);
    channelValues = fromYUV(&y, &u, &v);
    profile()->delinearizeFloatValue(channelValues);
    for (int i=0;i<channelnumber;i++){
        channelValuesF[i]=channelValues[i];
    }
    fromNormalisedChannelsValue(pixel, channelValuesF);
    setOpacity(pixel, 1.0, 1);
}

References channelCount(), KoColorProfile::delinearizeFloatValue(), fromNormalisedChannelsValue(), fromYUV(), KoColorProfile::linearizeFloatValue(), normalisedChannelsValue(), profile(), setOpacity(), toYUV(), u, and v.

◆ intensity8()

virtual quint8 KoColorSpace::intensity8 ( const quint8 * src ) const

pure virtual

Calculate the intensity of the given pixel, scaled down to the range 0-255. XXX: Maybe this should be more flexible

◆ intensityF()

virtual qreal KoColorSpace::intensityF ( const quint8 * src ) const

pure virtual

Calculate the intensity of the given pixel, scaled down to the range 0-1

◆ lumaCoefficients()

QVector< qreal > KoColorSpace::lumaCoefficients ( ) const

◆ mixColorsOp()

virtual KoMixColorsOp * KoColorSpace::mixColorsOp ( ) const

virtual

Returns: the mix color operation of this colorspace (do not delete it locally, it's deleted by the colorspace).

◆ modulateLightnessByGrayBrush()

void KoColorSpace::modulateLightnessByGrayBrush	(	quint8 *	dst,
		const QRgb *	brush,
		qreal	strength,
		qint32	nPixels ) const

virtual

Fallback implementation. All RGB color spaces have their own implementation without any conversions.

Reimplemented in KoRgbU16ColorSpace, KoRgbU8ColorSpace, RgbF16ColorSpace, RgbF32ColorSpace, RgbU16ColorSpace, and RgbU8ColorSpace.

Definition at line 897 of file KoColorSpace.cpp.

{
 
    const int rgbPixelSize = sizeof(KoBgrU16Traits::Pixel);
    QScopedArrayPointer<quint8> dstBuffer(new quint8[nPixels * rgbPixelSize]);
 
    this->toRgbA16(dst, dstBuffer.data(), nPixels);
    modulateLightnessByGrayBrushRGB<KoBgrU16Traits>(dstBuffer.data(), brush, strength, nPixels);
    this->fromRgbA16(dstBuffer.data(), dst, nPixels);
}

References fromRgbA16(), and toRgbA16().

◆ multiplyAlpha()

virtual void KoColorSpace::multiplyAlpha	(	quint8 *	pixels,
		quint8	alpha,
		qint32	nPixels ) const

pure virtual

Multiply the alpha channel of the given run of pixels by the given value.

pixels – a pointer to the pixels that will have their alpha set to this value alpha – a downscaled 8-bit value for opacity nPixels – the number of pixels

◆ name()

QString KoColorSpace::name ( ) const

User visible name which contains the name of the color model and of the color depth. For instance "RGBA (8-bits)" or "CMYKA (16-bits)".

◆ normalisedChannelsValue()

virtual void KoColorSpace::normalisedChannelsValue	(	const quint8 *	pixel,
		QVector< float > &	channels ) const

pure virtual

Return a QVector of floats with channels' values normalized to floating point range 0 to 1.

◆ normalisedChannelValueText()

virtual QString KoColorSpace::normalisedChannelValueText	(	const quint8 *	pixel,
		quint32	channelIndex ) const

pure virtual

Return a string with the channel's value with integer channels normalised to the floating point range 0 to 1, if appropriate.

◆ opacityF()

virtual qreal KoColorSpace::opacityF ( const quint8 * pixel ) const

pure virtual

◆ opacityU8()

virtual quint8 KoColorSpace::opacityU8 ( const quint8 * pixel ) const

pure virtual

Get the alpha value of the given pixel, downscaled to an 8-bit value.

◆ operator==()

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

virtual

Definition at line 95 of file KoColorSpace.cpp.

{
    const KoColorProfile* p1 = rhs.profile();
    const KoColorProfile* p2 = profile();
    return d->idNumber == rhs.d->idNumber && ((p1 == p2) || (*p1 == *p2));
}

References d, p1, p2, and profile().

◆ pixelSize()

virtual quint32 KoColorSpace::pixelSize ( ) const

pure virtual

The size in bytes of a single pixel in this color model

◆ preferCompositionInSourceColorSpace()

bool KoColorSpace::preferCompositionInSourceColorSpace ( ) const

protectedvirtual

This function defines the behavior of the bitBlt function when the composition of pixels in different colorspaces is requested, that is in case:

srcCS == any dstCS == this

1) preferCompositionInSourceColorSpace() == false,

the source pixels are first converted to *this color space and then composition is performed.

2) preferCompositionInSourceColorSpace() == true,

the destination pixels are first converted into *srcCS color space, then the composition is done, and the result is finally converted into *this colorspace.

This is used by alpha8() color space mostly, because it has weaker representation of the color, so the composition should be done in CS with richer functionality.

Reimplemented in KoAlphaColorSpaceImpl< _CSTrait >.

Definition at line 871 of file KoColorSpace.cpp.

{
    return false;
}

◆ profile()

virtual const KoColorProfile * KoColorSpace::profile ( ) const

pure virtual

Return the profile of this color space.

◆ profileIsCompatible()

virtual bool KoColorSpace::profileIsCompatible ( const KoColorProfile * profile ) const

pure virtual

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

◆ proofPixelsTo()

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

virtual

proofPixelsTo

Parameters

src	source
dst	destination
numPixels	the amount of pixels.
proofingTransform	the intent used for proofing.

Returns

Definition at line 487 of file KoColorSpace.cpp.

{
    proofingTransform->transform(src, dst, numPixels);
 
    //the transform is deleted in the destructor.
    return true;
}

References KoColorConversionTransformation::transform().

◆ scaleToU8()

virtual quint8 KoColorSpace::scaleToU8	(	const quint8 *	srcPixel,
		qint32	channelPos ) const

pure virtual

Convert the value of the channel at the specified position into an 8-bit value. The position is not the number of bytes, but the position of the channel as defined in the channel info list.

◆ setOpacity() [1/2]

virtual void KoColorSpace::setOpacity	(	quint8 *	pixels,
		qreal	alpha,
		qint32	nPixels ) const

pure virtual

◆ setOpacity() [2/2]

virtual void KoColorSpace::setOpacity	(	quint8 *	pixels,
		quint8	alpha,
		qint32	nPixels ) const

pure virtual

Set the alpha channel of the given run of pixels to the given value.

pixels – a pointer to the pixels that will have their alpha set to this value alpha – a downscaled 8-bit value for opacity nPixels – the number of pixels

◆ singleChannelPixel()

virtual void KoColorSpace::singleChannelPixel	(	quint8 *	dstPixel,
		const quint8 *	srcPixel,
		quint32	channelIndex ) const

pure virtual

Set dstPixel to the pixel containing only the given channel of srcPixel. The remaining channels should be set to whatever makes sense for 'empty' channels of this color space, with the intent being that the pixel should look like it only has the given channel.

◆ toHSY()

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

pure virtual

◆ toLabA16()

void KoColorSpace::toLabA16	(	const quint8 *	src,
		quint8 *	dst,
		quint32	nPixels ) const

virtual

Convert the specified data to Lab (D50). All colorspaces are guaranteed to support this

Parameters

src	the source data
dst	the destination data
nPixels	the number of source pixels

Reimplemented in KoAlphaColorSpaceImpl< _CSTrait >, KoSimpleColorSpace< _CSTraits >, KoSimpleColorSpace< KoBgrU16Traits >, KoSimpleColorSpace< KoBgrU8Traits >, and KoSimpleColorSpace< KoLabU16Traits >.

Definition at line 430 of file KoColorSpace.cpp.

{
    toLabA16Converter()->transform(src, dst, nPixels);
}

References toLabA16Converter(), and KoColorConversionTransformation::transform().

◆ toLabA16Converter()

const KoColorConversionTransformation * KoColorSpace::toLabA16Converter ( ) const

protected

Definition at line 400 of file KoColorSpace.cpp.

{
    if (!d->transfoToLABA16) {
        d->transfoToLABA16 = KoColorSpaceRegistry::instance()->createColorConverter(this, KoColorSpaceRegistry::instance()->lab16(), KoColorConversionTransformation::internalRenderingIntent(), KoColorConversionTransformation::internalConversionFlags()) ;
    }
    return d->transfoToLABA16;
}

References KoColorSpaceRegistry::createColorConverter(), d, KoColorSpaceRegistry::instance(), KoColorConversionTransformation::internalConversionFlags(), and KoColorConversionTransformation::internalRenderingIntent().

◆ toQColor()

virtual void KoColorSpace::toQColor	(	const quint8 *	src,
		QColor *	c ) const

pure virtual

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

◆ toQColor16()

virtual void KoColorSpace::toQColor16	(	const quint8 *	src,
		QColor *	c ) const

pure virtual

The toQColor16 methods take a byte array that is at least pixelSize() long and converts the contents to a 16 bit 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

◆ toRgbA16()

void KoColorSpace::toRgbA16	(	const quint8 *	src,
		quint8 *	dst,
		quint32	nPixels ) const

virtual

Convert the specified data to sRGB 16 bits. All colorspaces are guaranteed to support this

Parameters

src	the source data
dst	the destination data
nPixels	the number of source pixels

Reimplemented in KoAlphaColorSpaceImpl< _CSTrait >, KoSimpleColorSpace< _CSTraits >, KoSimpleColorSpace< KoBgrU16Traits >, KoSimpleColorSpace< KoBgrU8Traits >, and KoSimpleColorSpace< KoLabU16Traits >.

Definition at line 440 of file KoColorSpace.cpp.

{
    toRgbA16Converter()->transform(src, dst, nPixels);
}

References toRgbA16Converter(), and KoColorConversionTransformation::transform().

◆ toRgbA16Converter()

const KoColorConversionTransformation * KoColorSpace::toRgbA16Converter ( ) const

protected

Definition at line 415 of file KoColorSpace.cpp.

{
    if (!d->transfoToRGBA16) {
        d->transfoToRGBA16 = KoColorSpaceRegistry::instance()->createColorConverter(this, KoColorSpaceRegistry::instance()->rgb16(), KoColorConversionTransformation::internalRenderingIntent(), KoColorConversionTransformation::internalConversionFlags()) ;
    }
    return d->transfoToRGBA16;
}

References KoColorSpaceRegistry::createColorConverter(), d, KoColorSpaceRegistry::instance(), KoColorConversionTransformation::internalConversionFlags(), and KoColorConversionTransformation::internalRenderingIntent().

◆ toYUV()

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

pure virtual

◆ transparentColor()

void KoColorSpace::transparentColor	(	quint8 *	dst,
		quint32	nPixels ) const

virtual

Fills the provided buffer with fully transparent color in this color space.

Not all color spaces support conversion from QColor (e.g. InputClass spaces), so for them we need to generate this color separately.

Definition at line 394 of file KoColorSpace.cpp.

{
    memset(dst, 0, pixelSize() * nPixels);
    setOpacity(dst, OPACITY_TRANSPARENT_U8, nPixels);
}

References OPACITY_TRANSPARENT_U8, pixelSize(), and setOpacity().

◆ willDegrade()

virtual bool KoColorSpace::willDegrade ( ColorSpaceIndependence independence ) const

pure virtual

If false, images in this colorspace will degrade considerably by functions, tools and filters that have the given measure of colorspace independence.

Parameters

independence the measure to which this colorspace will suffer from the manipulations of the tool or filter asking

Returns: false if no degradation will take place, true if degradation will take place

Implemented in KoAlphaColorSpaceImpl< _CSTrait >, KoSimpleColorSpace< _CSTraits >, KoSimpleColorSpace< KoBgrU16Traits >, KoSimpleColorSpace< KoBgrU8Traits >, KoSimpleColorSpace< KoLabU16Traits >, CmykF32ColorSpace, CmykU16ColorSpace, CmykU8ColorSpace, LabF32ColorSpace, LabU16ColorSpace, LabU8ColorSpace, RgbF16ColorSpace, RgbF32ColorSpace, RgbU16ColorSpace, XyzF16ColorSpace, XyzF32ColorSpace, XyzU16ColorSpace, XyzU8ColorSpace, YCbCrF32ColorSpace, YCbCrU16ColorSpace, YCbCrU8ColorSpace, GrayF16ColorSpace, GrayF32ColorSpace, GrayAU16ColorSpace, GrayAU8ColorSpace, and RgbU8ColorSpace.

Friends And Related Symbol Documentation

◆ KoColorSpaceFactory

friend class KoColorSpaceFactory

friend

Definition at line 80 of file KoColorSpace.h.

◆ KoColorSpaceRegistry

friend class KoColorSpaceRegistry

friend

Definition at line 79 of file KoColorSpace.h.

Member Data Documentation

◆ channelFlagsApplicationCache

ThreadLocalCache KoColorSpace::channelFlagsApplicationCache

mutable

Definition at line 52 of file KoColorSpace_p.h.

◆ channels

QList< KoChannelInfo * > KoColorSpace::channels

Definition at line 46 of file KoColorSpace_p.h.

◆ colorants

QVector<KoColorimetryUtils::xyY> KoColorSpace::colorants

Definition at line 61 of file KoColorSpace_p.h.

◆ compositeOps

QList< KoCompositeOp * > KoColorSpace::compositeOps

Definition at line 45 of file KoColorSpace_p.h.

◆ conversionCache

ThreadLocalCache KoColorSpace::conversionCache

mutable

Definition at line 51 of file KoColorSpace_p.h.

◆ convolutionOp

KoConvolutionOp * KoColorSpace::convolutionOp

Definition at line 48 of file KoColorSpace_p.h.

◆ d

Private* const KoColorSpace::d

protected

Definition at line 751 of file KoColorSpace.h.

◆ deletability

Deletability KoColorSpace::deletability

Definition at line 66 of file KoColorSpace_p.h.

◆ ditherOps

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

Definition at line 49 of file KoColorSpace_p.h.

◆ gamutXYY

QPolygonF KoColorSpace::gamutXYY

Definition at line 59 of file KoColorSpace_p.h.

◆ iccEngine

KoColorSpaceEngine* KoColorSpace::iccEngine

Definition at line 64 of file KoColorSpace_p.h.

◆ id

QString KoColorSpace::id

Definition at line 42 of file KoColorSpace_p.h.

◆ idNumber

quint32 KoColorSpace::idNumber

Definition at line 43 of file KoColorSpace_p.h.

◆ lumaCoefficients

QVector< qreal > KoColorSpace::lumaCoefficients

Definition at line 62 of file KoColorSpace_p.h.

◆ mixColorsOp

KoMixColorsOp * KoColorSpace::mixColorsOp

Definition at line 47 of file KoColorSpace_p.h.

◆ name

QString KoColorSpace::name

Definition at line 44 of file KoColorSpace_p.h.

◆ transfoFromLABA16

KoColorConversionTransformation* KoColorSpace::transfoFromLABA16

mutable

Definition at line 57 of file KoColorSpace_p.h.

◆ transfoFromRGBA16

KoColorConversionTransformation* KoColorSpace::transfoFromRGBA16

mutable

Definition at line 55 of file KoColorSpace_p.h.

◆ transfoToLABA16

KoColorConversionTransformation* KoColorSpace::transfoToLABA16

mutable

Definition at line 56 of file KoColorSpace_p.h.

◆ transfoToRGBA16

KoColorConversionTransformation* KoColorSpace::transfoToRGBA16

mutable

Definition at line 54 of file KoColorSpace_p.h.

◆ TRCXYY

QPolygonF KoColorSpace::TRCXYY

Definition at line 60 of file KoColorSpace_p.h.

The documentation for this struct was generated from the following files:

libs/pigment/KoColorSpace.h
libs/pigment/KoColorSpace_p.h
libs/pigment/KoColorSpace.cpp

Classes

Public Member Functions

Public Attributes

Protected Member Functions

Protected Attributes

Friends

Detailed Description

Constructor & Destructor Documentation

◆ KoColorSpace() [1/2]

◆ KoColorSpace() [2/2]

◆ ~KoColorSpace()

Member Function Documentation

◆ addChannel()

◆ addCompositeOp()

◆ addDitherOp()

◆ alphaPos()

◆ applyAlphaNormedFloatMask()

◆ applyAlphaU8Mask()

◆ applyInverseAlphaU8Mask()

◆ applyInverseNormedFloatMask()

◆ bitBlt()

◆ channelCount()

◆ channelFlags()

◆ channels()

◆ channelValueText()

◆ colorChannelCount()

◆ colorDepthId()

◆ colorFromXML()

◆ colorModelId()

◆ colorToXML()

◆ compositeOp()

◆ compositeOps()

◆ convertChannelToVisualRepresentation() [1/2]

◆ convertChannelToVisualRepresentation() [2/2]

◆ convertPixelsTo()

◆ convertToQImage()

◆ convolutionOp()

◆ copyOpacityU8()

◆ createBrightnessContrastAdjustment()

◆ createColorConverter()

◆ createColorTransformation()

◆ createDarkenAdjustment()

◆ createInvertTransformation()

◆ createPerChannelAdjustment()

◆ createProofingTransform()

◆ decreaseHue()

◆ decreaseLuminosity()

◆ decreaseSaturation()

◆ difference()

◆ differenceA()

◆ ditherOp()

◆ estimatedTRCXYY()

◆ fillGrayBrushWithColor()

◆ fillGrayBrushWithColorAndLightnessOverlay()

◆ fillGrayBrushWithColorAndLightnessWithStrength()

◆ fillInverseAlphaNormedFloatMaskWithColor()

◆ fromHSY()

◆ fromLabA16()

◆ fromLabA16Converter()

◆ fromNormalisedChannelsValue()

◆ fromQColor()

◆ fromRgbA16()

◆ fromRgbA16Converter()

◆ fromYUV()

◆ gamutXYY()

◆ hasCompositeOp()

◆ hasHighDynamicRange()

◆ id()

◆ increaseBlue()

◆ increaseGreen()

◆ increaseHue()

◆ increaseLuminosity()

◆ increaseRed()

◆ increaseSaturation()

◆ increaseYellow()

◆ intensity8()

◆ intensityF()

◆ lumaCoefficients()

◆ mixColorsOp()

◆ modulateLightnessByGrayBrush()