#include <KoLabColorSpace.h>

Inheritance diagram for KoLabColorSpace:

Public Member Functions
virtual KoColorSpace *	clone () const

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

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

QVector< double >	fromHSY (qreal hue, qreal sat, qreal *luma) const override

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

QVector< double >	fromYUV (qreal y, qreal u, qreal *v) const override

	KoLabColorSpace ()

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

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

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

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

	~KoLabColorSpace () override

Public Member Functions inherited from KoSimpleColorSpace< KoLabU16Traits >
KoID	colorDepthId () const override

void	colorFromXML (quint8 *, const QDomElement &) const override

KoID	colorModelId () const override

virtual QString	colorSpaceEngine () const

virtual quint32	colorSpaceType () const

void	colorToXML (const quint8 *, QDomDocument &, QDomElement &) const override

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

KoColorTransformation *	createBrightnessContrastAdjustment (const quint16 *) const override

KoColorTransformation *	createDarkenAdjustment (qint32, bool, qreal) const override

virtual KoColorTransformation *	createDesaturateAdjustment () const

KoColorTransformation *	createPerChannelAdjustment (const quint16 const ) const override

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

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

QVector< double >	fromHSY (qreal , qreal , qreal *) const override

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

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

QVector< double >	fromYUV (qreal , qreal , qreal *) const override

bool	hasHighDynamicRange () const override

virtual void	invertColor (quint8 *, qint32) const

	KoSimpleColorSpace (const QString &id, const QString &name, const KoID &colorModelId, const KoID &colorDepthId)

const KoColorProfile *	profile () const override

bool	profileIsCompatible (const KoColorProfile *) const override

void	toHSY (const QVector< double > &, qreal , qreal , qreal *) const override

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

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

void	toYUV (const QVector< double > &, qreal , qreal , qreal *) const override

bool	willDegrade (ColorSpaceIndependence independence) const override

	~KoSimpleColorSpace () override

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

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

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

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

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

quint32	channelCount () const override

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

quint32	colorChannelCount () const override

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

KoColorTransformation *	createInvertTransformation () const override

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

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

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

quint8	intensity8 (const quint8 *src) const override

qreal	intensityF (const quint8 *src) const override

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

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

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

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

qreal	opacityF (const quint8 *U8_pixel) const override

quint8	opacityU8 (const quint8 *U8_pixel) const override

quint32	pixelSize () const override

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

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

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

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

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

virtual void	addDitherOp (KisDitherOp *op)

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

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

QList< KoChannelInfo * >	channels () const

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

virtual QList< KoCompositeOp * >	compositeOps () const

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

virtual KoConvolutionOp *	convolutionOp () const

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

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

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

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

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

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

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

QPolygonF	estimatedTRCXYY () const

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

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

QPolygonF	gamutXYY () const

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

QString	id () const

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

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

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

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

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

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

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

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

QVector< qreal >	lumaCoefficients () const

virtual KoMixColorsOp *	mixColorsOp () const

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

QString	name () const

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

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

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

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

Static Public Member Functions
static QString	colorSpaceId ()

Static Private Attributes
static const quint32	CHANNEL_A = 1

static const quint32	CHANNEL_AB_ZERO_OFFSET = 0x8000

static const quint32	CHANNEL_ALPHA = 3

static const quint32	CHANNEL_B = 2

static const quint32	CHANNEL_L = 0

static const quint32	MAX_CHANNEL_AB = 0xffff

static const quint32	MAX_CHANNEL_L = 0xff00

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

Public Attributes inherited from KoColorSpace
ThreadLocalCache	channelFlagsApplicationCache

QList< KoChannelInfo * >	channels

QVector< qreal >	colorants

QHash< QString, KoCompositeOp * >	compositeOps

ThreadLocalCache	conversionCache

KoConvolutionOp *	convolutionOp

Deletability	deletability

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

QPolygonF	gamutXYY

KoColorSpaceEngine *	iccEngine

QString	id

quint32	idNumber

QVector< qreal >	lumaCoefficients

KoMixColorsOp *	mixColorsOp

QString	name

KoColorConversionTransformation *	transfoFromLABA16

KoColorConversionTransformation *	transfoFromRGBA16

KoColorConversionTransformation *	transfoToLABA16

KoColorConversionTransformation *	transfoToRGBA16

QPolygonF	TRCXYY

Public Attributes inherited from Private
KisCanvas2 *	canvas

int	displayedFrame

int	intendedFrame

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

const KoColorConversionTransformation *	fromLabA16Converter () const

const KoColorConversionTransformation *	fromRgbA16Converter () const

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

virtual bool	preferCompositionInSourceColorSpace () const

const KoColorConversionTransformation *	toLabA16Converter () const

const KoColorConversionTransformation *	toRgbA16Converter () const

virtual	~KoColorSpace ()

Protected Attributes inherited from KoColorSpace
Private *const	d

Detailed Description

Basic and simple implementation of the LAB colorspace

Definition at line 21 of file KoLabColorSpace.h.

Constructor & Destructor Documentation

◆ KoLabColorSpace()

KoLabColorSpace::KoLabColorSpace ( )

Definition at line 26 of file KoLabColorSpace.cpp.

                                 :
        KoSimpleColorSpace<KoLabU16Traits>(colorSpaceId(),
                                           i18n("L*a*b* (16-bit integer/channel, unmanaged)"),
                                           LABAColorModelID,
                                           Integer16BitsColorDepthID)
{
    addChannel(new KoChannelInfo(i18nc("Lightness value in Lab color model", "Lightness"), CHANNEL_L     * sizeof(quint16), CHANNEL_L, KoChannelInfo::COLOR, KoChannelInfo::UINT16, sizeof(quint16), QColor(100, 100, 100)));
    addChannel(new KoChannelInfo(i18n("a*"),        CHANNEL_A     * sizeof(quint16), CHANNEL_A, KoChannelInfo::COLOR, KoChannelInfo::UINT16, sizeof(quint16), QColor(150, 150, 150)));
    addChannel(new KoChannelInfo(i18n("b*"),        CHANNEL_B     * sizeof(quint16), CHANNEL_B, KoChannelInfo::COLOR, KoChannelInfo::UINT16, sizeof(quint16), QColor(200, 200, 200)));
    addChannel(new KoChannelInfo(i18n("Alpha"),     CHANNEL_ALPHA * sizeof(quint16), CHANNEL_ALPHA, KoChannelInfo::ALPHA, KoChannelInfo::UINT16, sizeof(quint16)));
 
    // ADD, ALPHA_DARKEN, BURN, DIVIDE, DODGE, ERASE, MULTIPLY, OVER, OVERLAY, SCREEN, SUBTRACT
    addStandardCompositeOps<KoLabU16Traits>(this);
    addStandardDitherOps<KoLabU16Traits>(this);
}

References KoColorSpace::addChannel(), KoChannelInfo::ALPHA, CHANNEL_A, CHANNEL_ALPHA, CHANNEL_B, CHANNEL_L, KoChannelInfo::COLOR, and KoChannelInfo::UINT16.

◆ ~KoLabColorSpace()

KoLabColorSpace::~KoLabColorSpace ( )

override

Definition at line 42 of file KoLabColorSpace.cpp.

43{

44}

Member Function Documentation

◆ clone()

KoColorSpace * KoLabColorSpace::clone ( ) const

virtual

Definition at line 53 of file KoLabColorSpace.cpp.

{
    return new KoLabColorSpace();
}

References KoLabColorSpace().

◆ colorSpaceId()

QString KoLabColorSpace::colorSpaceId ( )

static

Definition at line 47 of file KoLabColorSpace.cpp.

{
    return QStringLiteral("LABA");
}

◆ convertChannelToVisualRepresentation() [1/2]

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

overridevirtual

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

Reimplemented from KoColorSpaceAbstract< _CSTrait >.

Definition at line 246 of file KoLabColorSpace.cpp.

{
    for (uint pixelIndex = 0; pixelIndex < nPixels; ++pixelIndex) {
        for (uint channelIndex = 0; channelIndex < ColorSpaceTraits::channels_nb; ++channelIndex) {
 
            if (selectedChannels.testBit(channelIndex)) {
                ColorSpaceTraits::nativeArray((dst + (pixelIndex * ColorSpaceTraits::pixelSize)))[channelIndex] =
                    ColorSpaceTraits::nativeArray((src + (pixelIndex * ColorSpaceTraits::pixelSize)))[channelIndex];
            } else {
                ColorSpaceTraits::channels_type v;
                switch (channelIndex) {
                case ColorSpaceTraits::L_pos:
                    v = ColorSpaceTraits::math_trait::halfValueL;
                    break;
                case ColorSpaceTraits::a_pos:
                case ColorSpaceTraits::b_pos:
                    v = ColorSpaceTraits::math_trait::halfValueAB;
                    break;
                default:
                    v = ColorSpaceTraits::math_trait::zeroValue;
                    break;
                }
                ColorSpaceTraits::nativeArray((dst + (pixelIndex * ColorSpaceTraits::pixelSize)))[channelIndex] = v;
            }
        }
    }
}

References v.

◆ convertChannelToVisualRepresentation() [2/2]

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

overridevirtual

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.

Reimplemented from KoColorSpaceAbstract< _CSTrait >.

Definition at line 211 of file KoLabColorSpace.cpp.

{
    for (uint pixelIndex = 0; pixelIndex < nPixels; ++pixelIndex) {
        for (uint channelIndex = 0; channelIndex < ColorSpaceTraits::channels_nb; ++channelIndex) {
            if (channelIndex != ColorSpaceTraits::alpha_pos) {
                if (channelIndex == ColorSpaceTraits::L_pos) {
                    ColorSpaceTraits::channels_type c = ColorSpaceTraits::nativeArray((src + (pixelIndex * ColorSpaceTraits::pixelSize)))[selectedChannelIndex];
                    switch (selectedChannelIndex) {
                    case ColorSpaceTraits::L_pos:
                        break;
                    case ColorSpaceTraits::a_pos:
                    case ColorSpaceTraits::b_pos:
                        if (c <= ColorSpaceTraits::math_trait::halfValueAB) {
                            c = ColorSpaceTraits::math_trait::unitValueL * (((qreal)c - ColorSpaceTraits::math_trait::zeroValueAB) / (2.0 * (ColorSpaceTraits::math_trait::halfValueAB - ColorSpaceTraits::math_trait::zeroValueAB)));
                        } else {
                            c = ColorSpaceTraits::math_trait::unitValueL * (0.5 + ((qreal)c - ColorSpaceTraits::math_trait::halfValueAB) / (2.0 * (ColorSpaceTraits::math_trait::unitValueAB - ColorSpaceTraits::math_trait::halfValueAB)));
                        }
                        break;
                    // As per KoChannelInfo alpha channels are [0..1]
                    default:
                        c = ColorSpaceTraits::math_trait::unitValueL * (qreal)c / ColorSpaceTraits::math_trait::unitValue;
                        break;
                    }
                    ColorSpaceTraits::nativeArray(dst + (pixelIndex * ColorSpaceTraits::pixelSize))[channelIndex] = c;
                } else {
                    ColorSpaceTraits::nativeArray(dst + (pixelIndex * ColorSpaceTraits::pixelSize))[channelIndex] = ColorSpaceTraits::math_trait::halfValueAB;
                }
            } else {
                ColorSpaceTraits::nativeArray((dst + (pixelIndex * ColorSpaceTraits::pixelSize)))[channelIndex] =
                    ColorSpaceTraits::nativeArray((src + (pixelIndex * ColorSpaceTraits::pixelSize)))[channelIndex];
            }
        }
    }
}

◆ fromHSY()

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

overridevirtual

Implements KoColorSpace.

Definition at line 162 of file KoLabColorSpace.cpp.

{
    QVector <double> channelValues(4);
    LCHToLab(*luma, *sat, *hue, &channelValues[0],&channelValues[1],&channelValues[2]);
    channelValues[3]=1.0;
    return channelValues;
}

References LCHToLab().

◆ fromQColor()

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

overridevirtual

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

Parameters

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

Implements KoColorSpace.

Definition at line 58 of file KoLabColorSpace.cpp.

{
    // Convert between RGB and CIE-Lab color spaces
    // Uses ITU-R recommendation BT.709 with D65 as reference white.
    // algorithm contributed by "Mark A. Ruzon" <ruzon@CS.Stanford.EDU>
 
    int R, G, B, A;
    c.getRgb(&R, &G, &B, &A);
 
    double X, Y, Z, fX, fY, fZ;
 
    X = 0.412453 * R + 0.357580 * G + 0.180423 * B;
    Y = 0.212671 * R + 0.715160 * G + 0.072169 * B;
    Z = 0.019334 * R + 0.119193 * G + 0.950227 * B;
 
    X /= (255 * 0.950456);
    Y /=  255;
    Z /= (255 * 1.088754);
 
    quint8 L, a, b;
 
    if (Y > 0.008856) {
        fY = pow(Y, 1.0 / 3.0);
        L = static_cast<int>(116.0 * fY - 16.0 + 0.5);
    } else {
        fY = 7.787 * Y + 16.0 / 116.0;
        L = static_cast<int>(903.3 * Y + 0.5);
    }
 
    if (X > 0.008856)
        fX = pow(X, 1.0 / 3.0);
    else
        fX = 7.787 * X + 16.0 / 116.0;
 
    if (Z > 0.008856)
        fZ = pow(Z, 1.0 / 3.0);
    else
        fZ = 7.787 * Z + 16.0 / 116.0;
 
    a = static_cast<int>(500.0 * (fX - fY) + 0.5);
    b = static_cast<int>(200.0 * (fY - fZ) + 0.5);
 
    dst[CHANNEL_L] = UINT8_TO_UINT16(L);
    dst[CHANNEL_A] = UINT8_TO_UINT16(a);
    dst[CHANNEL_B] = UINT8_TO_UINT16(b);
    dst[CHANNEL_ALPHA] = UINT8_TO_UINT16(A);
}

References A, B, CHANNEL_A, CHANNEL_ALPHA, CHANNEL_B, CHANNEL_L, G, R, and UINT8_TO_UINT16().

◆ fromYUV()

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

overridevirtual

Implements KoColorSpace.

Definition at line 177 of file KoLabColorSpace.cpp.

{
    QVector <double> channelValues(4);
    channelValues[0]=*y;
    channelValues[1]=*v;
    channelValues[2]=*u;
    channelValues[3]=1.0;
    return channelValues;
}

References u, and v.

◆ scaleToU8()

quint8 KoLabColorSpace::scaleToU8	(	const quint8 *	srcPixel,
		qint32	channelPos ) const

overridevirtual

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.

Reimplemented from KoColorSpaceAbstract< _CSTrait >.

Definition at line 187 of file KoLabColorSpace.cpp.

{
    typename ColorSpaceTraits::channels_type c = ColorSpaceTraits::nativeArray(srcPixel)[channelIndex];
    qreal b = 0;
    switch (channelIndex) {
    case ColorSpaceTraits::L_pos:
        b = ((qreal)c) / ColorSpaceTraits::math_trait::unitValueL;
        break;
    case ColorSpaceTraits::a_pos:
    case ColorSpaceTraits::b_pos:
        if (c <= ColorSpaceTraits::math_trait::halfValueAB) {
            b = ((qreal)c - ColorSpaceTraits::math_trait::zeroValueAB) / (2.0 * (ColorSpaceTraits::math_trait::halfValueAB - ColorSpaceTraits::math_trait::zeroValueAB));
        } else {
            b = 0.5 + ((qreal)c - ColorSpaceTraits::math_trait::halfValueAB) / (2.0 * (ColorSpaceTraits::math_trait::unitValueAB - ColorSpaceTraits::math_trait::halfValueAB));
        }
        break;
    default:
        b = ((qreal)c) / ColorSpaceTraits::math_trait::unitValue;
        break;
    }
 
    return KoColorSpaceMaths<qreal, quint8>::scaleToA(b);
}

References KoColorSpaceMaths< _T, _Tdst >::scaleToA().

◆ toHSY()

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

overridevirtual

Implements KoColorSpace.

Definition at line 157 of file KoLabColorSpace.cpp.

{
    LabToLCH(channelValues[0],channelValues[1],channelValues[2], luma, sat, hue);
}

References LabToLCH().

◆ toQColor()

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

overridevirtual

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

Parameters

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

Implements KoColorSpace.

Definition at line 106 of file KoLabColorSpace.cpp.

{
    // Convert between RGB and CIE-Lab color spaces
    // Uses ITU-R recommendation BT.709 with D65 as reference white.
    // algorithm contributed by "Mark A. Ruzon" <ruzon@CS.Stanford.EDU>
    quint8 L, a, b, A;
    L = UINT16_TO_UINT8(src[CHANNEL_L]);
    a = UINT16_TO_UINT8(src[CHANNEL_A]);
    b = UINT16_TO_UINT8(src[CHANNEL_B]);
    A = UINT16_TO_UINT8(src[CHANNEL_ALPHA]);
 
    double X, Y, Z, fX, fY, fZ;
    int RR, GG, BB;
 
    fY = pow((L + 16.0) / 116.0, 3.0);
    if (fY < 0.008856)
        fY = L / 903.3;
    Y = fY;
 
    if (fY > 0.008856)
        fY = pow(fY, 1.0 / 3.0);
    else
        fY = 7.787 * fY + 16.0 / 116.0;
 
    fX = a / 500.0 + fY;
    if (fX > 0.206893)
        X = pow(fX, 3.0);
    else
        X = (fX - 16.0 / 116.0) / 7.787;
 
    fZ = fY - b / 200.0;
    if (fZ > 0.206893)
        Z = pow(fZ, 3.0);
    else
        Z = (fZ - 16.0 / 116.0) / 7.787;
 
    X *= 0.950456 * 255;
    Y *= 255;
    Z *= 1.088754 * 255;
 
    RR = static_cast<int>(3.240479 * X - 1.537150 * Y - 0.498535 * Z + 0.5);
    GG = static_cast<int>(-0.969256 * X + 1.875992 * Y + 0.041556 * Z + 0.5);
    BB = static_cast<int>(0.055648 * X - 0.204043 * Y + 1.057311 * Z + 0.5);
 
    quint8 R = RR < 0 ? 0 : RR > 255 ? 255 : RR;
    quint8 G = GG < 0 ? 0 : GG > 255 ? 255 : GG;
    quint8 B = BB < 0 ? 0 : BB > 255 ? 255 : BB;
 
    c->setRgba(qRgba(R, G, B, A));
}

References A, B, CHANNEL_A, CHANNEL_ALPHA, CHANNEL_B, CHANNEL_L, G, R, and UINT16_TO_UINT8().

◆ toYUV()

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

overridevirtual

Implements KoColorSpace.

Definition at line 170 of file KoLabColorSpace.cpp.

{
    *y =channelValues[0];
    *v=channelValues[1];
    *u=channelValues[2];
}

References u, and v.

Member Data Documentation

◆ CHANNEL_A

const quint32 KoLabColorSpace::CHANNEL_A = 1

staticprivate

Definition at line 49 of file KoLabColorSpace.h.

◆ CHANNEL_AB_ZERO_OFFSET

const quint32 KoLabColorSpace::CHANNEL_AB_ZERO_OFFSET = 0x8000

staticprivate

Definition at line 54 of file KoLabColorSpace.h.

◆ CHANNEL_ALPHA

const quint32 KoLabColorSpace::CHANNEL_ALPHA = 3

staticprivate

Definition at line 51 of file KoLabColorSpace.h.

◆ CHANNEL_B

const quint32 KoLabColorSpace::CHANNEL_B = 2

staticprivate

Definition at line 50 of file KoLabColorSpace.h.

◆ CHANNEL_L

const quint32 KoLabColorSpace::CHANNEL_L = 0

staticprivate

Definition at line 48 of file KoLabColorSpace.h.

◆ MAX_CHANNEL_AB

const quint32 KoLabColorSpace::MAX_CHANNEL_AB = 0xffff

staticprivate

Definition at line 53 of file KoLabColorSpace.h.

◆ MAX_CHANNEL_L

const quint32 KoLabColorSpace::MAX_CHANNEL_L = 0xff00

staticprivate

Definition at line 52 of file KoLabColorSpace.h.

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

libs/pigment/colorspaces/KoLabColorSpace.h
libs/pigment/colorspaces/KoLabColorSpace.cpp

Public Member Functions

Static Public Member Functions

Static Private Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ KoLabColorSpace()

◆ ~KoLabColorSpace()

Member Function Documentation

◆ clone()

◆ colorSpaceId()

◆ convertChannelToVisualRepresentation() [1/2]

◆ convertChannelToVisualRepresentation() [2/2]

◆ fromHSY()

◆ fromQColor()

◆ fromYUV()

◆ scaleToU8()

◆ toHSY()

◆ toQColor()

◆ toYUV()

Member Data Documentation

◆ CHANNEL_A

◆ CHANNEL_AB_ZERO_OFFSET

◆ CHANNEL_ALPHA

◆ CHANNEL_B

◆ CHANNEL_L

◆ MAX_CHANNEL_AB

◆ MAX_CHANNEL_L