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

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 37 of file kis_display_color_converter.h.

Member Typedef Documentation

ConversionOptions

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

Definition at line 98 of file kis_display_color_converter.h.

Constructor & Destructor Documentation

KisDisplayColorConverter() [1/2]

KisDisplayColorConverter::KisDisplayColorConverter

(

)

Definition at line 244 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 230 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->setCurrentNode(0);
    setDisplayFilter(QSharedPointer<KisDisplayFilter>(0));
}

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

~KisDisplayColorConverter()

KisDisplayColorConverter::~KisDisplayColorConverter ( )

override

Definition at line 255 of file kis_display_color_converter.cpp.

{
}

Member Function Documentation

applyDisplayFiltering()

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

Definition at line 487 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 607 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 518 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 506 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 454 of file kis_display_color_converter.cpp.

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

References m_d.

convertToDisplayImpl()

template<class Policy >

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

private

displayConfig()

KisDisplayConfig KisDisplayColorConverter::displayConfig

(

)

const

Definition at line 439 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 444 of file kis_display_color_converter.cpp.

{
    return m_d->displayFilter;
}

References m_d.

displayRendererInterface()

KoColorDisplayRendererInterface * KisDisplayColorConverter::displayRendererInterface

(

)

const

Definition at line 275 of file kis_display_color_converter.cpp.

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

References m_d.

dumbConverterInstance()

KisDisplayColorConverter * KisDisplayColorConverter::dumbConverterInstance ( )

static

Definition at line 270 of file kis_display_color_converter.cpp.

{
    return s_instance;
}

fromHsiF()

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

Definition at line 740 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 704 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 659 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 673 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 763 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 753 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 716 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 666 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 680 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 775 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().

multiSurfaceDisplayConfig()

KisMultiSurfaceDisplayConfig KisDisplayColorConverter::multiSurfaceDisplayConfig

(

)

const

Definition at line 449 of file kis_display_color_converter.cpp.

{
    return m_d->multiSurfaceDisplayConfig;
}

References m_d.

nodeColorSpace()

const KoColorSpace * KisDisplayColorConverter::nodeColorSpace

(

)

const

Definition at line 397 of file kis_display_color_converter.cpp.

{
    return m_d->nodeColorSpace;
}

References m_d.

paintingColorSpace()

const KoColorSpace * KisDisplayColorConverter::paintingColorSpace

(

)

const

Definition at line 388 of file kis_display_color_converter.cpp.

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

References KoColorSpaceRegistry::instance(), KIS_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 412 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 259 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 402 of file kis_display_color_converter.cpp.

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

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 459 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 563 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 523 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().

Member Data Documentation

m_d

const QScopedPointer<Private> KisDisplayColorConverter::m_d

private

Definition at line 118 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