KisDisplayColorConverter Class Reference

#include <kis_display_color_converter.h>

Inheritance diagram for KisDisplayColorConverter:

Classes
struct	Private

Public Types
using	ConversionOptions = std::pair<KoColorConversionTransformation::Intent, KoColorConversionTransformation::ConversionFlags>

Signals
void	displayConfigurationChanged ()

Public Member Functions
KoColor	applyDisplayFiltering (const KoColor &srcColor, const KoID &bitDepthId) const
void	applyDisplayFilteringF32 (KisFixedPaintDeviceSP device, const KoColorSpace *dstColorSpace) const
KoColor	approximateFromRenderedQColor (const QColor &c) const
bool	canSkipDisplayConversion (const KoColorSpace *cs) const
ConversionOptions	conversionOptions () const
QColor	convertColorToDisplayColorSpace (const KoColor color, bool applyOcio=false) const
	convertColorToDisplayColorSpace This applies displayfiltering to the given KoColor, and then funnels the resulting data into a QColor for display. This function is used to draw canvas decorations into the canvas colorspace, as required for proper HDR and wide gamut support.
QImage	convertImageToDisplayColorSpace (KisPaintDeviceSP srcDevice, QRect source=QRect(), bool applyOcio=false) const
	convertImageToDisplayColorSpace Same as convertColorToDisplayColorSpace, but then for a KisPaintDevice.
KisDisplayConfig	displayConfig () const
QSharedPointer< KisDisplayFilter >	displayFilter () const
KoColorDisplayRendererInterface *	displayRendererInterface () const
KoColor	fromHsiF (qreal h, qreal s, qreal i)
KoColor	fromHslF (qreal h, qreal s, qreal l, qreal a=1.0)
KoColor	fromHsv (int h, int s, int v, int a=255) const
KoColor	fromHsvF (qreal h, qreal s, qreal v, qreal a=1.0)
KoColor	fromHsyF (qreal h, qreal s, qreal y, qreal R=0.2126, qreal G=0.7152, qreal B=0.0722, qreal gamma=2.2)
void	getHsiF (const KoColor &srcColor, qreal *h, qreal *s, qreal *i)
void	getHslF (const KoColor &srcColor, qreal *h, qreal *s, qreal *l, qreal *a=0)
void	getHsv (const KoColor &srcColor, int *h, int *s, int *v, int *a=0) const
void	getHsvF (const KoColor &srcColor, qreal *h, qreal *s, qreal *v, qreal *a=0)
void	getHsyF (const KoColor &srcColor, qreal *h, qreal *s, qreal *y, qreal R=0.2126, qreal G=0.7152, qreal B=0.0722, qreal gamma=2.2)
KisHandlePalette	handlePaletteForDisplayColorSpace () const
	handlePaletteForDisplayColorSpace
	KisDisplayColorConverter ()
	KisDisplayColorConverter (KoCanvasResourceProvider *resourceManager, QObject *parent)
KisMultiSurfaceDisplayConfig	multiSurfaceDisplayConfig () const
const KoColorSpace *	nodeColorSpace () const
const KoColorSpace *	paintingColorSpace () const
void	setDisplayFilter (QSharedPointer< KisDisplayFilter > displayFilter)
void	setImage (KisImageSP image)
void	setImageColorSpace (const KoColorSpace *cs)
void	setMultiSurfaceDisplayConfig (const KisMultiSurfaceDisplayConfig &config)
QPalette	systemPaletteForDisplayColorSpace () const
	systemPaletteForDisplayColorSpace
QColor	toQColor (const KoColor &c, bool proofToPaintColors=false) const
QImage	toQImage (const KoColorSpace *srcColorSpace, const quint8 *data, QSize size, bool proofPaintColors=false) const
QImage	toQImage (KisPaintDeviceSP srcDevice, bool proofPaintColors=false) const
	~KisDisplayColorConverter () override

Static Public Member Functions
static KisDisplayColorConverter *	dumbConverterInstance ()

Private Member Functions
template<class Policy >
Policy::Result	convertToDisplayImpl (const KoColor &srcColor, bool alreadyInDestinationF32=false) const
	Q_PRIVATE_SLOT (m_d, void selectPaintingColorSpace())
	Q_PRIVATE_SLOT (m_d, void slotCanvasResourceChanged(int key, const QVariant &v))
	Q_PRIVATE_SLOT (m_d, void slotUpdateCurrentNodeColorSpace())
KoColor	toKoColor (const QColor &c)
Q_SLOT void	updatePalettes ()

Private Attributes
const QScopedPointer< Private >	m_d

Detailed Description

Special helper class that provides primitives for converting colors when displaying. We have at least 3 color spaces:

1) Image color space (any: RGB, CMYK, Lab, etc) 2) Display color space (a limited RGB color space) 3) Color selectors color space (the one where color selectors generate their HSV-based colors. Right now it is sRGB.

KoColor may be in any of these color spaces. QColor should always be in the display color space only.

Definition at line 39 of file kis_display_color_converter.h.

Member Typedef Documentation

ConversionOptions

using KisDisplayColorConverter::ConversionOptions = std::pair<KoColorConversionTransformation::Intent, KoColorConversionTransformation::ConversionFlags>

Definition at line 133 of file kis_display_color_converter.h.

Constructor & Destructor Documentation

KisDisplayColorConverter() [1/2]

KisDisplayColorConverter::KisDisplayColorConverter

(

)

Definition at line 279 of file kis_display_color_converter.cpp.

    : m_d(new Private(this, 0))
{
    setDisplayFilter(QSharedPointer<KisDisplayFilter>(0));
 
    m_d->inputImageProfile = KoColorSpaceRegistry::instance()->p709SRGBProfile();
    m_d->paintingColorSpace = KoColorSpaceRegistry::instance()->rgb8();
 
    m_d->setCurrentNode(0);
}

References KoColorSpaceRegistry::instance(), m_d, KoColorSpaceRegistry::p709SRGBProfile(), KoColorSpaceRegistry::rgb8(), and setDisplayFilter().

KisDisplayColorConverter() [2/2]

KisDisplayColorConverter::KisDisplayColorConverter	(	KoCanvasResourceProvider *	resourceManager,
		QObject *	parent )

Definition at line 261 of file kis_display_color_converter.cpp.

    : QObject(parent),
      m_d(new Private(this, resourceManager))
{
    connect(m_d->resourceManager, SIGNAL(canvasResourceChanged(int,QVariant)),
            SLOT(slotCanvasResourceChanged(int,QVariant)));
    connect(KisConfigNotifier::instance(), SIGNAL(configChanged()),
            SLOT(selectPaintingColorSpace()));
 
    m_d->inputImageProfile = KoColorSpaceRegistry::instance()->p709SRGBProfile();
    m_d->paintingColorSpace = KoColorSpaceRegistry::instance()->rgb8();
    m_d->setCurrentNode(0);
    setDisplayFilter(QSharedPointer<KisDisplayFilter>(0));
    updatePalettes();
    connect(this, SIGNAL(displayConfigurationChanged()), this, SLOT(updatePalettes()));
    connect(KisPart::instance()->currentMainwindow(), SIGNAL(themeChanged()), this, SLOT(updatePalettes()));
}

References displayConfigurationChanged(), KisConfigNotifier::instance(), KoColorSpaceRegistry::instance(), KisPart::instance(), m_d, KoColorSpaceRegistry::p709SRGBProfile(), KoColorSpaceRegistry::rgb8(), setDisplayFilter(), and updatePalettes().

~KisDisplayColorConverter()

KisDisplayColorConverter::~KisDisplayColorConverter ( )

override

Definition at line 290 of file kis_display_color_converter.cpp.

{
}

Member Function Documentation

applyDisplayFiltering()

KoColor KisDisplayColorConverter::applyDisplayFiltering	(	const KoColor &	srcColor,
		const KoID &	bitDepthId ) const

Definition at line 562 of file kis_display_color_converter.cpp.

{
    KoColor c(srcColor);
 
    if (m_d->useOcio()) {
        KIS_ASSERT_RECOVER(m_d->ocioInputColorSpace()->pixelSize() == 16) {
            return srcColor;
        }
 
        c.convertTo(m_d->ocioInputColorSpace());
        m_d->displayFilter->filter(c.data(), 1);
        c.setProfile(m_d->ocioOutputProfile());
    }
 
    c.convertTo(m_d->openGLSurfaceColorSpace(bitDepthId), m_d->multiSurfaceDisplayConfig.intent, m_d->multiSurfaceDisplayConfig.conversionFlags);
    return c;
}

References KoColor::convertTo(), KoColor::data(), KIS_ASSERT_RECOVER, m_d, and KoColor::setProfile().

applyDisplayFilteringF32()

void KisDisplayColorConverter::applyDisplayFilteringF32	(	KisFixedPaintDeviceSP	device,
		const KoColorSpace *	dstColorSpace ) const

Apply display filtering and convert device into dstColorSpace on exiting the function. The conversion can actually change the bit-depth of the device if necessary

This method is optimized for the case when device is already in 32f version of the painting color space.

Definition at line 682 of file kis_display_color_converter.cpp.

{
    KIS_SAFE_ASSERT_RECOVER_RETURN(device->colorSpace()->colorDepthId() == Float32BitsColorDepthID);
    KIS_SAFE_ASSERT_RECOVER_RETURN(device->colorSpace()->colorModelId() == RGBAColorModelID);
    KIS_SAFE_ASSERT_RECOVER_RETURN(device->bounds().isValid());
 
    if (m_d->useOcio()) {
        KIS_ASSERT_RECOVER_RETURN(m_d->ocioInputColorSpace()->pixelSize() == 16);
 
        device->convertTo(m_d->ocioInputColorSpace());
        m_d->displayFilter->filter(device->data(), device->bounds().width() * device->bounds().height());
        device->setProfile(m_d->ocioOutputProfile());
    }
 
    KIS_SAFE_ASSERT_RECOVER_RETURN(dstColorSpace);
    device->convertTo(dstColorSpace);
}

References KisFixedPaintDevice::bounds(), KoColorSpace::colorDepthId(), KoColorSpace::colorModelId(), KisFixedPaintDevice::colorSpace(), KisFixedPaintDevice::convertTo(), KisFixedPaintDevice::data(), Float32BitsColorDepthID, KIS_ASSERT_RECOVER_RETURN, KIS_SAFE_ASSERT_RECOVER_RETURN, m_d, RGBAColorModelID, and KisFixedPaintDevice::setProfile().

approximateFromRenderedQColor()

KoColor KisDisplayColorConverter::approximateFromRenderedQColor

(

const QColor &

c

)

const

Definition at line 593 of file kis_display_color_converter.cpp.

{
    return m_d->approximateFromQColor(c);
}

References m_d.

canSkipDisplayConversion()

bool KisDisplayColorConverter::canSkipDisplayConversion

(

const KoColorSpace *

cs

)

const

Definition at line 581 of file kis_display_color_converter.cpp.

{
    const KoColorProfile *displayProfile = m_d->openGLSurfaceProfile();
 
    return !m_d->useOcio() &&
        cs->colorModelId() == RGBAColorModelID &&
        (!!cs->profile() == !!displayProfile) &&
        (!cs->profile() ||
         cs->profile()->uniqueId() == displayProfile->uniqueId());
}

References KoColorSpace::colorModelId(), m_d, KoColorSpace::profile(), RGBAColorModelID, and KoColorProfile::uniqueId().

conversionOptions()

KisDisplayColorConverter::ConversionOptions KisDisplayColorConverter::conversionOptions

(

)

const

Definition at line 529 of file kis_display_color_converter.cpp.

{
    return m_d->multiSurfaceDisplayConfig.options();
}

References m_d.

convertColorToDisplayColorSpace()

QColor KisDisplayColorConverter::convertColorToDisplayColorSpace	(	const KoColor	color,
		bool	applyOcio = false ) const

convertColorToDisplayColorSpace This applies displayfiltering to the given KoColor, and then funnels the resulting data into a QColor for display. This function is used to draw canvas decorations into the canvas colorspace, as required for proper HDR and wide gamut support.

Parameters

color	the KoColor to convert.
applyOcio	whether to also apply OCIO. This is only really relevant for color pickers.

Returns

a QColor in the display color space.

No idea why it wouldn't be RGBAColorModelID, but do something useful in any case...

Definition at line 706 of file kis_display_color_converter.cpp.

{
    KoColor newColor;
    if (applyOcio) {
        newColor = applyDisplayFiltering(color, Float32BitsColorDepthID);
    } else {
        newColor = KoColor(color);
        newColor.convertTo(m_d->openGLSurfaceColorSpace(Float32BitsColorDepthID), m_d->multiSurfaceDisplayConfig.intent, m_d->multiSurfaceDisplayConfig.conversionFlags);
    }
 
    KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE(newColor.colorSpace()->colorModelId() == RGBAColorModelID, newColor.toQColor());
 
    QVector<float> norm(newColor.colorSpace()->channelCount());
    newColor.colorSpace()->normalisedChannelsValue(newColor.data(), norm);
 
    // sort into RGBA order... maybe a little overengineered.
    QVector<float> sorted = norm;
    for (int ch = 0; ch < norm.size(); ch++) {
        const KoChannelInfo *info = newColor.colorSpace()->channels().at(ch);
        sorted[info->displayPosition()] = norm[ch];
    }
 
    // We need to manually create a QColor here, because if we use KoColor.toQColor, the whole KoColor is first
    // converted to sRGB before becoming a QColor, while we explicitely do not want that for our QColor.
    // This is further complicated by the fact that QColors cannot have any (Q)ColorSpace metadata associated with it, unlike KoColor.
    return QColor::fromRgbF(sorted[0], sorted[1], sorted[2], sorted[3]);
}

References applyDisplayFiltering(), KoColorSpace::channelCount(), KoColorSpace::channels, KoColorSpace::colorModelId(), KoColor::colorSpace(), KoColor::convertTo(), KoColor::data(), KoChannelInfo::displayPosition(), Float32BitsColorDepthID, KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE, m_d, KoColorSpace::normalisedChannelsValue(), RGBAColorModelID, and KoColor::toQColor().

convertImageToDisplayColorSpace()

QImage KisDisplayColorConverter::convertImageToDisplayColorSpace	(	KisPaintDeviceSP	srcDevice,
		QRect	source = QRect(),
		bool	applyOcio = false ) const

convertImageToDisplayColorSpace Same as convertColorToDisplayColorSpace, but then for a KisPaintDevice.

Parameters

srcDevice	– src device to process.
source	– source rect.
applyOcio	– whether to also apply OCIO. Only useful for previews and not UI elements.

Returns

a QImage in the display color space.

Definition at line 735 of file kis_display_color_converter.cpp.

{
    KisPaintDeviceSP conversionDevice = new KisPaintDevice(*srcDevice.data());
    const QRect s = source.isValid()? source: conversionDevice->exactBounds();
 
    if (m_d->useOcio() && applyOcio) {
        KIS_ASSERT_RECOVER(m_d->ocioInputColorSpace()->pixelSize() == 16) {
            return QImage();
        }
 
        conversionDevice->convertTo(m_d->ocioInputColorSpace());
        KisSequentialIterator it(conversionDevice, s);
        int numConseqPixels = it.nConseqPixels();
        while (it.nextPixels(numConseqPixels)) {
            numConseqPixels = it.nConseqPixels();
            m_d->displayFilter->filter(it.rawData(), numConseqPixels);
        }
        conversionDevice->setProfile(m_d->ocioOutputProfile(), 0);
    }
 
    conversionDevice->convertTo(m_d->openGLSurfaceColorSpace(Float32BitsColorDepthID), m_d->multiSurfaceDisplayConfig.intent, m_d->multiSurfaceDisplayConfig.conversionFlags);
    return conversionDevice->convertToQImage(m_d->openGLSurfaceProfile(), s, m_d->multiSurfaceDisplayConfig.intent, m_d->multiSurfaceDisplayConfig.conversionFlags);
}

References KisPaintDevice::convertTo(), KisPaintDevice::convertToQImage(), KisSharedPtr< T >::data(), KisPaintDevice::exactBounds(), Float32BitsColorDepthID, KIS_ASSERT_RECOVER, m_d, KisSequentialIteratorBase< IteratorPolicy, SourcePolicy, ProgressPolicy >::nConseqPixels(), KisSequentialIteratorBase< IteratorPolicy, SourcePolicy, ProgressPolicy >::nextPixels(), KisSequentialIteratorBase< IteratorPolicy, SourcePolicy, ProgressPolicy >::rawData(), KisPaintDevice::setProfile(), and source().

convertToDisplayImpl()

template<class Policy >

Policy::Result KisDisplayColorConverter::convertToDisplayImpl ( const KoColor & srcColor, bool alreadyInDestinationF32 = false ) const

private

displayConfig()

KisDisplayConfig KisDisplayColorConverter::displayConfig

(

)

const

Definition at line 514 of file kis_display_color_converter.cpp.

{
    return m_d->multiSurfaceDisplayConfig.uiDisplayConfig();
}

References m_d.

displayConfigurationChanged

void KisDisplayColorConverter::displayConfigurationChanged ( )

signal

displayFilter()

QSharedPointer< KisDisplayFilter > KisDisplayColorConverter::displayFilter

(

)

const

Definition at line 519 of file kis_display_color_converter.cpp.

{
    return m_d->displayFilter;
}

References m_d.

displayRendererInterface()

KoColorDisplayRendererInterface * KisDisplayColorConverter::displayRendererInterface

(

)

const

Definition at line 310 of file kis_display_color_converter.cpp.

{
    return m_d->displayRenderer.data();
}

References m_d.

dumbConverterInstance()

KisDisplayColorConverter * KisDisplayColorConverter::dumbConverterInstance ( )

static

Definition at line 305 of file kis_display_color_converter.cpp.

{
    return s_instance;
}

fromHsiF()

KoColor KisDisplayColorConverter::fromHsiF	(	qreal	h,
		qreal	s,
		qreal	i )

Definition at line 878 of file kis_display_color_converter.cpp.

{
    // generate HSI from sRGB!
    qreal r=0.0;
    qreal g=0.0;
    qreal b=0.0;
    qreal a=1.0;
    HSIToRGB(h, s, i, &r, &g, &b);
    QColor qcolor;
    qcolor.setRgbF(qBound(0.0,r,1.0), qBound(0.0,g,1.0), qBound(0.0,b,1.0), a);
    return m_d->approximateFromQColor(qcolor);
}

References HSIToRGB(), and m_d.

fromHslF()

KoColor KisDisplayColorConverter::fromHslF	(	qreal	h,
		qreal	s,
		qreal	l,
		qreal	a = 1.0 )

Definition at line 842 of file kis_display_color_converter.cpp.

{
    // generate HSL from sRGB!
    QColor qcolor(QColor::fromHslF(h, s, l, a));
    if (!qcolor.isValid()) {
        warnKrita << "Could not construct valid color from h" << h << "s" << s << "l" << l << "a" << a;
        qcolor = Qt::black;
    }
    return m_d->approximateFromQColor(qcolor);
 
}

References m_d, and warnKrita.

fromHsv()

KoColor KisDisplayColorConverter::fromHsv	(	int	h,
		int	s,
		int	v,
		int	a = 255 ) const

Definition at line 797 of file kis_display_color_converter.cpp.

{
    // generate HSV from sRGB!
    QColor qcolor(QColor::fromHsv(h, s, v, a));
    return m_d->approximateFromQColor(qcolor);
}

References m_d, and v.

fromHsvF()

KoColor KisDisplayColorConverter::fromHsvF	(	qreal	h,
		qreal	s,
		qreal	v,
		qreal	a = 1.0 )

Definition at line 811 of file kis_display_color_converter.cpp.

{
    // generate HSV from sRGB!
    QColor qcolor(QColor::fromHsvF(h, s, v, a));
    return m_d->approximateFromQColor(qcolor);
}

References m_d, and v.

fromHsyF()

KoColor KisDisplayColorConverter::fromHsyF	(	qreal	h,
		qreal	s,
		qreal	y,
		qreal	R = 0.2126,
		qreal	G = 0.7152,
		qreal	B = 0.0722,
		qreal	gamma = 2.2 )

Definition at line 901 of file kis_display_color_converter.cpp.

{
    // generate HSL from sRGB!
    QVector <qreal> channelValues(3);
    y = pow(y, gamma);
    HSYToRGB(h, s, y, &channelValues[0], &channelValues[1], &channelValues[2], R, G, B);
    KoColorSpaceRegistry::instance()->rgb8()->profile()->delinearizeFloatValueFast(channelValues);
    QColor qcolor;
    qcolor.setRgbF(qBound(0.0,channelValues[0],1.0), qBound(0.0,channelValues[1],1.0), qBound(0.0,channelValues[2],1.0), 1.0);
    return m_d->approximateFromQColor(qcolor);
}

References B, KoColorProfile::delinearizeFloatValueFast(), G, HSYToRGB(), KoColorSpaceRegistry::instance(), m_d, KoColorSpace::profile(), R, and KoColorSpaceRegistry::rgb8().

getHsiF()

void KisDisplayColorConverter::getHsiF	(	const KoColor &	srcColor,
		qreal *	h,
		qreal *	s,
		qreal *	i )

Definition at line 891 of file kis_display_color_converter.cpp.

{
    // we are going through sRGB here!
    QColor color = m_d->approximateToQColor(srcColor);
    qreal r=color.redF();
    qreal g=color.greenF();
    qreal b=color.blueF();
    RGBToHSI(r, g, b, h, s, i);
}

References m_d, and RGBToHSI().

getHslF()

void KisDisplayColorConverter::getHslF	(	const KoColor &	srcColor,
		qreal *	h,
		qreal *	s,
		qreal *	l,
		qreal *	a = 0 )

Definition at line 854 of file kis_display_color_converter.cpp.

{
    // we are going through sRGB here!
    QColor color = m_d->approximateToQColor(srcColor);
#if (QT_VERSION < QT_VERSION_CHECK(6, 0, 0))
    color.getHslF(h, s, l, a);
#else
    float fH, fS, fL, fA;
    fH = *h;
    fS = *s;
    fL = *l;
    if (a) {
        fA = *a;
    }
    color.getHslF(&fH, &fS, &fL, &fA);
    *h = fH;
    *s = fS;
    *l = fL;
    if (a) {
        *a = fA;
    }
#endif
}

References m_d.

getHsv()

void KisDisplayColorConverter::getHsv	(	const KoColor &	srcColor,
		int *	h,
		int *	s,
		int *	v,
		int *	a = 0 ) const

Definition at line 804 of file kis_display_color_converter.cpp.

{
    // we are going through sRGB here!
    QColor color = m_d->approximateToQColor(srcColor);
    color.getHsv(h, s, v, a);
}

References m_d, and v.

getHsvF()

void KisDisplayColorConverter::getHsvF	(	const KoColor &	srcColor,
		qreal *	h,
		qreal *	s,
		qreal *	v,
		qreal *	a = 0 )

Definition at line 818 of file kis_display_color_converter.cpp.

{
    // we are going through sRGB here!
    QColor color = m_d->approximateToQColor(srcColor);
#if (QT_VERSION < QT_VERSION_CHECK(6, 0, 0))
    color.getHsvF(h, s, v, a);
#else
    float fH, fS, fV, fA;
    fH = *h;
    fS = *s;
    fV = *v;
    if (a) {
        fA = *a;
    }
    color.getHsvF(&fH, &fS, &fV, &fA);
    *h = fH;
    *s = fS;
    *v = fV;
    if (a) {
        *a = fA;
    }
#endif
}

References m_d, and v.

getHsyF()

void KisDisplayColorConverter::getHsyF	(	const KoColor &	srcColor,
		qreal *	h,
		qreal *	s,
		qreal *	y,
		qreal	R = 0.2126,
		qreal	G = 0.7152,
		qreal	B = 0.0722,
		qreal	gamma = 2.2 )

Definition at line 913 of file kis_display_color_converter.cpp.

{
    // we are going through sRGB here!
    QColor color = m_d->approximateToQColor(srcColor);
    QVector <qreal> channelValues(3);
    channelValues[0]=color.redF();
    channelValues[1]=color.greenF();
    channelValues[2]=color.blueF();
    //TODO: if we're going to have KoColor here, remember to check whether the TRC of the profile exists...
    KoColorSpaceRegistry::instance()->rgb8()->profile()->linearizeFloatValueFast(channelValues);
    RGBToHSY(channelValues[0], channelValues[1], channelValues[2], h, s, y, R, G, B);
    *y = pow(*y, 1/gamma);
}

References B, G, KoColorSpaceRegistry::instance(), KoColorProfile::linearizeFloatValueFast(), m_d, KoColorSpace::profile(), R, KoColorSpaceRegistry::rgb8(), and RGBToHSY().

handlePaletteForDisplayColorSpace()

KisHandlePalette KisDisplayColorConverter::handlePaletteForDisplayColorSpace

(

)

const

handlePaletteForDisplayColorSpace

Returns

KisHandlePalette suitable to draw canvas decorations with.

Definition at line 759 of file kis_display_color_converter.cpp.

{
    return m_d->handlePalette;
}

References m_d.

multiSurfaceDisplayConfig()

KisMultiSurfaceDisplayConfig KisDisplayColorConverter::multiSurfaceDisplayConfig

(

)

const

Definition at line 524 of file kis_display_color_converter.cpp.

{
    return m_d->multiSurfaceDisplayConfig;
}

References m_d.

nodeColorSpace()

const KoColorSpace * KisDisplayColorConverter::nodeColorSpace

(

)

const

Definition at line 472 of file kis_display_color_converter.cpp.

{
    return m_d->nodeColorSpace;
}

References m_d.

paintingColorSpace()

const KoColorSpace * KisDisplayColorConverter::paintingColorSpace

(

)

const

Definition at line 463 of file kis_display_color_converter.cpp.

{
    KIS_SAFE_ASSERT_RECOVER(m_d->paintingColorSpace) {
        return KoColorSpaceRegistry::instance()->rgb8();
    }
 
    return m_d->paintingColorSpace;
}

References KoColorSpaceRegistry::instance(), KIS_SAFE_ASSERT_RECOVER, m_d, and KoColorSpaceRegistry::rgb8().

Q_PRIVATE_SLOT() [1/3]

KisDisplayColorConverter::Q_PRIVATE_SLOT ( m_d , void selectPaintingColorSpace() )

private

Q_PRIVATE_SLOT() [2/3]

KisDisplayColorConverter::Q_PRIVATE_SLOT ( m_d , void slotCanvasResourceChangedint key, const QVariant &v )

private

Q_PRIVATE_SLOT() [3/3]

KisDisplayColorConverter::Q_PRIVATE_SLOT ( m_d , void slotUpdateCurrentNodeColorSpace() )

private

setDisplayFilter()

void KisDisplayColorConverter::setDisplayFilter

(

QSharedPointer< KisDisplayFilter >

displayFilter

)

Definition at line 487 of file kis_display_color_converter.cpp.

{
    if (m_d->displayFilter && displayFilter &&
        displayFilter->lockCurrentColorVisualRepresentation()) {
 
        KoColor color(m_d->intermediateFgColor);
        displayFilter->approximateInverseTransformation(color.data(), 1);
        color.convertTo(m_d->paintingColorSpace);
        m_d->resourceManager->setForegroundColor(color);
    }
 
    m_d->displayFilter = displayFilter;
 
    if (m_d->displayFilter) {
        m_d->updateIntermediateFgColor(
            m_d->resourceManager->foregroundColor());
    }
 
 
    { // sanity check
        // KisConfig cfg;
        // KIS_ASSERT_RECOVER_NOOP(cfg.useOcio() == (bool) m_d->displayFilter);
    }
 
    m_d->selectPaintingColorSpace();
}

References KoColor::convertTo(), KoColor::data(), displayFilter(), and m_d.

setImage()

void KisDisplayColorConverter::setImage

(

KisImageSP

image

)

setImageColorSpace()

void KisDisplayColorConverter::setImageColorSpace

(

const KoColorSpace *

cs

)

Definition at line 294 of file kis_display_color_converter.cpp.

{
    m_d->inputImageProfile =
        cs->colorModelId() == RGBAColorModelID ?
        cs->profile() :
        KoColorSpaceRegistry::instance()->p709SRGBProfile();
 
    m_d->notifyDisplayConfigurationChanged();
}

References KoColorSpace::colorModelId(), KoColorSpaceRegistry::instance(), m_d, KoColorSpaceRegistry::p709SRGBProfile(), KoColorSpace::profile(), and RGBAColorModelID.

setMultiSurfaceDisplayConfig()

void KisDisplayColorConverter::setMultiSurfaceDisplayConfig

(

const KisMultiSurfaceDisplayConfig &

config

)

Definition at line 477 of file kis_display_color_converter.cpp.

{
    if (m_d->multiSurfaceDisplayConfig == config) return;
 
 
 
    m_d->multiSurfaceDisplayConfig = config;
    m_d->notifyDisplayConfigurationChanged();
}

References m_d.

systemPaletteForDisplayColorSpace()

QPalette KisDisplayColorConverter::systemPaletteForDisplayColorSpace

(

)

const

systemPaletteForDisplayColorSpace

Returns

QPalette suitable to draw canvas decorations with.

Definition at line 764 of file kis_display_color_converter.cpp.

{
    return m_d->systemPalette;
}

References m_d.

toKoColor()

KoColor KisDisplayColorConverter::toKoColor ( const QColor & c )

private

toQColor()

QColor KisDisplayColorConverter::toQColor	(	const KoColor &	c,
		bool	proofToPaintColors = false ) const

Definition at line 534 of file kis_display_color_converter.cpp.

{
    KoColor c(srcColor);
 
    if (proofToPaintColors && m_d->needsColorProofing(c.colorSpace())) {
        c.convertTo(m_d->paintingColorSpace, m_d->multiSurfaceDisplayConfig.intent, m_d->multiSurfaceDisplayConfig.conversionFlags);
    }
 
    if (m_d->useOcio()) {
        KIS_ASSERT_RECOVER(m_d->ocioInputColorSpace()->pixelSize() == 16) {
            return QColor(Qt::green);
        }
 
        c.convertTo(m_d->ocioInputColorSpace());
        m_d->displayFilter->filter(c.data(), 1);
        c.setProfile(m_d->ocioOutputProfile());
    }
 
    // we expect the display profile is rgb8, which is BGRA here
    KIS_ASSERT_RECOVER(m_d->qtWidgetsColorSpace()->pixelSize() == 4) {
        return QColor(Qt::red);
    }
 
    c.convertTo(m_d->qtWidgetsColorSpace(), m_d->multiSurfaceDisplayConfig.intent, m_d->multiSurfaceDisplayConfig.conversionFlags);
    const quint8 *p = c.data();
    return QColor(p[2], p[1], p[0], p[3]);
}

References KoColor::colorSpace(), KoColor::convertTo(), KoColor::data(), KIS_ASSERT_RECOVER, m_d, p, and KoColor::setProfile().

toQImage() [1/2]

QImage KisDisplayColorConverter::toQImage	(	const KoColorSpace *	srcColorSpace,
		const quint8 *	data,
		QSize	size,
		bool	proofPaintColors = false ) const

Definition at line 638 of file kis_display_color_converter.cpp.

{
    const int numPixels = size.width() * size.height();
 
    const KoColorSpace  *colorSpace = srcColorSpace;
    const quint8 *pixels = data;
 
    QScopedArrayPointer<quint8> proofBuffer;
 
    if (proofPaintColors && m_d->needsColorProofing(srcColorSpace)) {
        const int imageSize = numPixels * paintingColorSpace()->pixelSize();
        proofBuffer.reset(new quint8[imageSize]);
        colorSpace->convertPixelsTo(pixels, proofBuffer.data(),
                                      paintingColorSpace(),
                                      numPixels,
                                      m_d->multiSurfaceDisplayConfig.intent,
                                      m_d->multiSurfaceDisplayConfig.conversionFlags);
        colorSpace = paintingColorSpace();
        pixels = proofBuffer.data();
    }
 
    QScopedArrayPointer<quint8> ocioBuffer;
    if (m_d->useOcio()) {
        const int imageSize = numPixels * m_d->ocioInputColorSpace()->pixelSize();
        ocioBuffer.reset(new quint8[imageSize]);
        colorSpace->convertPixelsTo(pixels, ocioBuffer.data(),
                                      m_d->ocioInputColorSpace(),
                                      numPixels,
                                      m_d->multiSurfaceDisplayConfig.intent,
                                      m_d->multiSurfaceDisplayConfig.conversionFlags);
        m_d->displayFilter->filter(ocioBuffer.data(), numPixels);
 
        return m_d->ocioOutputColorSpace()->convertToQImage(ocioBuffer.data(), size.width(), size.height(),
                                                            m_d->qtWidgetsProfile(),
                                                            m_d->multiSurfaceDisplayConfig.intent,
                                                            m_d->multiSurfaceDisplayConfig.conversionFlags);
    }
 
    return colorSpace->convertToQImage(pixels, size.width(), size.height(),
                                          m_d->qtWidgetsProfile(),
                                          m_d->multiSurfaceDisplayConfig.intent,
                                          m_d->multiSurfaceDisplayConfig.conversionFlags);
}

References KoColorSpace::convertPixelsTo(), KoColorSpace::convertToQImage(), m_d, paintingColorSpace(), and KoColorSpace::pixelSize().

toQImage() [2/2]

QImage KisDisplayColorConverter::toQImage	(	KisPaintDeviceSP	srcDevice,
		bool	proofPaintColors = false ) const

Converts the exactBounds() (!) of the srcDevice into QImage properly rendered into display RGB space. Please note that the offset of the image in QImage is always zero for efficiency reasons.

Definition at line 598 of file kis_display_color_converter.cpp.

{
    KisPaintDeviceSP device = srcDevice;
 
    QRect bounds = srcDevice->exactBounds();
    if (bounds.isEmpty()) return QImage();
 
    if (proofPaintColors && m_d->needsColorProofing(srcDevice->colorSpace())) {
        srcDevice->convertTo(paintingColorSpace(), m_d->multiSurfaceDisplayConfig.intent, m_d->multiSurfaceDisplayConfig.conversionFlags);
    }
 
    if (m_d->useOcio()) {
        KIS_ASSERT_RECOVER(m_d->ocioInputColorSpace()->pixelSize() == 16) {
            return QImage();
        }
 
        device = new KisPaintDevice(*srcDevice);
        device->convertTo(m_d->ocioInputColorSpace());
 
        KisSequentialIterator it(device, bounds);
        int numConseqPixels = it.nConseqPixels();
        while (it.nextPixels(numConseqPixels)) {
            numConseqPixels = it.nConseqPixels();
            m_d->displayFilter->filter(it.rawData(), numConseqPixels);
        }
 
        device->setProfile(m_d->ocioOutputProfile(), 0);
    }
 
    // we expect the display profile is rgb8, which is BGRA here
    KIS_ASSERT_RECOVER(m_d->qtWidgetsColorSpace()->pixelSize() == 4) {
        return QImage();
    }
 
    return device->convertToQImage(m_d->qtWidgetsProfile(),
                                   bounds,
                                   m_d->multiSurfaceDisplayConfig.intent,
                                   m_d->multiSurfaceDisplayConfig.conversionFlags);
}

References bounds, KisPaintDevice::colorSpace(), KisPaintDevice::convertTo(), KisPaintDevice::convertToQImage(), KisPaintDevice::exactBounds(), KIS_ASSERT_RECOVER, m_d, KisSequentialIteratorBase< IteratorPolicy, SourcePolicy, ProgressPolicy >::nConseqPixels(), KisSequentialIteratorBase< IteratorPolicy, SourcePolicy, ProgressPolicy >::nextPixels(), paintingColorSpace(), KisSequentialIteratorBase< IteratorPolicy, SourcePolicy, ProgressPolicy >::rawData(), and KisPaintDevice::setProfile().

updatePalettes()

void KisDisplayColorConverter::updatePalettes ( )

private

Definition at line 369 of file kis_display_color_converter.cpp.

{
    KisHandlePalette palette;
    KoColor c;
    c.fromQColor(palette.gradientFillColor);
    palette.gradientFillColor = convertColorToDisplayColorSpace(c);
 
    c.fromQColor(palette.highlightColor);
    palette.highlightColor = convertColorToDisplayColorSpace(c);
 
    c.fromQColor(palette.highlightOutlineColor);
    palette.highlightOutlineColor = convertColorToDisplayColorSpace(c);
 
    c.fromQColor(palette.primaryColor);
    palette.primaryColor = convertColorToDisplayColorSpace(c);
 
    c.fromQColor(palette.secondaryColor);
    palette.secondaryColor = convertColorToDisplayColorSpace(c);
 
    c.fromQColor(palette.selectionColor);
    palette.selectionColor = convertColorToDisplayColorSpace(c);
 
    c.fromQColor(palette.white);
    palette.white = convertColorToDisplayColorSpace(c);
 
    c.fromQColor(palette.black);
    palette.black = convertColorToDisplayColorSpace(c);
 
    QPalette pal = qApp->palette();
    for (int r = 0; r < QPalette::NColorRoles; r++) {
        for (int cg = 0; cg < QPalette::NColorGroups; cg++) {
            c.fromQColor(pal.brush(QPalette::ColorGroup(cg), QPalette::ColorRole(r)).color());
            pal.setBrush(QPalette::ColorGroup(cg), QPalette::ColorRole(r), convertColorToDisplayColorSpace(c));
        }
    }
 
    m_d->handlePalette = palette;
    m_d->systemPalette = pal;
}

References convertColorToDisplayColorSpace(), KoColor::fromQColor(), m_d, and palette.

Member Data Documentation

m_d

const QScopedPointer<Private> KisDisplayColorConverter::m_d

private

Definition at line 154 of file kis_display_color_converter.h.

---

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

• libs/ui/canvas/kis_display_color_converter.h
• libs/ui/canvas/kis_display_color_converter.cpp