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, bool reactOnThemeChange=true)
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 281 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,
		bool	reactOnThemeChange = true )

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()));
    
    if(reactOnThemeChange)
        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 292 of file kis_display_color_converter.cpp.

{
}

Member Function Documentation

applyDisplayFiltering()

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

Definition at line 564 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 684 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 595 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 583 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 531 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 708 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 737 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 516 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 521 of file kis_display_color_converter.cpp.

{
    return m_d->displayFilter;
}

References m_d.

displayRendererInterface()

KoColorDisplayRendererInterface * KisDisplayColorConverter::displayRendererInterface

(

)

const

Definition at line 312 of file kis_display_color_converter.cpp.

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

References m_d.

dumbConverterInstance()

KisDisplayColorConverter * KisDisplayColorConverter::dumbConverterInstance ( )

static

Definition at line 307 of file kis_display_color_converter.cpp.

{
    return s_instance;
}

fromHsiF()

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

Definition at line 880 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 844 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 799 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 813 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 903 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 893 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 856 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 806 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 820 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 915 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 761 of file kis_display_color_converter.cpp.

{
    return m_d->handlePalette;
}

References m_d.

multiSurfaceDisplayConfig()

KisMultiSurfaceDisplayConfig KisDisplayColorConverter::multiSurfaceDisplayConfig

(

)

const

Definition at line 526 of file kis_display_color_converter.cpp.

{
    return m_d->multiSurfaceDisplayConfig;
}

References m_d.

nodeColorSpace()

const KoColorSpace * KisDisplayColorConverter::nodeColorSpace

(

)

const

Definition at line 474 of file kis_display_color_converter.cpp.

{
    return m_d->nodeColorSpace;
}

References m_d.

paintingColorSpace()

const KoColorSpace * KisDisplayColorConverter::paintingColorSpace

(

)

const

Definition at line 465 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 489 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 296 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 479 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 766 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 536 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 640 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 600 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 371 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 KisHandlePalette::black, convertColorToDisplayColorSpace(), KoColor::fromQColor(), KisHandlePalette::gradientFillColor, KisHandlePalette::highlightColor, KisHandlePalette::highlightOutlineColor, m_d, KisHandlePalette::primaryColor, KisHandlePalette::secondaryColor, KisHandlePalette::selectionColor, and KisHandlePalette::white.

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