KisVisualColorModel Class Reference

The KisVisualColorModel class allows manipulating a KoColor using various color models. More...

#include <KisVisualColorModel.h>

Inheritance diagram for KisVisualColorModel:

Classes
struct	Private

Public Types
enum	ColorModel {   None , Channel , HSV , HSL ,   HSI , HSY , YUV }

Public Slots
void	slotLoadACSConfig ()
	slotLoadACSConfig loads supported settings from Advanced Color Selector
void	slotSetChannelValues (const QVector4D &values)
void	slotSetColor (const KoColor &c)
void	slotSetColorSpace (const KoColorSpace *cs)

Signals
void	sigChannelValuesChanged (const QVector4D &values, quint32 channelFlags)
void	sigColorModelChanged ()
	sigColorModelChanged is emitted whenever the color model changes.
void	sigColorSpaceChanged ()
	sigColorSpaceChanged notifies that the color space from which the channel values are derived changed, and thus invalidating the current ones.
void	sigNewColor (const KoColor &c)

Public Member Functions
QVector4D	channelValues () const
int	colorChannelCount () const
ColorModel	colorModel () const
const KoColorSpace *	colorSpace () const
KoColor	convertChannelValuesToKoColor (const QVector4D &values) const
QVector4D	convertKoColorToChannelValues (KoColor c) const
void	copyState (const KisVisualColorModel &other)
	Copy the internal state of another KisVisualColorModel.
KoColor	currentColor () const
bool	isHSXModel () const
	KisVisualColorModel ()
QVector4D	maxChannelValues () const
void	setMaxChannelValues (const QVector4D &maxValues)
void	setRGBColorModel (ColorModel model)
	Set the HSX color model used for RGB color spaces.
bool	supportsExposure () const
	~KisVisualColorModel () override

Private Member Functions
void	emitChannelValues ()
void	loadColorSpace (const KoColorSpace *cs)

Private Attributes
const QScopedPointer< Private >	m_d

Detailed Description

The KisVisualColorModel class allows manipulating a KoColor using various color models.

This enables different widgets to easily manipulate the same color representation (like HSV channels of an RGB color etc.) in a synchronized way without having to know the details of the underlying color space. NOTE: This class is meant to be shared between GUI classes using KisVisualColorModelSP, so DO NOT SET a QObject parent in this case.

Definition at line 31 of file KisVisualColorModel.h.

Member Enumeration Documentation

ColorModel

enum KisVisualColorModel::ColorModel

Enumerator
None
Channel
HSV
HSL
HSI
HSY
YUV

Definition at line 35 of file KisVisualColorModel.h.

{ None, Channel, HSV, HSL, HSI, HSY, YUV };

Constructor & Destructor Documentation

KisVisualColorModel()

KisVisualColorModel::KisVisualColorModel

(

)

Definition at line 49 of file KisVisualColorModel.cpp.

    : QObject(0)
    , m_d(new Private)
{
    KConfigGroup cfg =  KSharedConfig::openConfig()->group("advancedColorSelector");
    m_d->acs_config = KisColorSelectorConfiguration::fromString(cfg.readEntry("colorSelectorConfiguration", KisColorSelectorConfiguration().toString()));
 
}

References KisColorSelectorConfiguration::fromString(), and m_d.

~KisVisualColorModel()

KisVisualColorModel::~KisVisualColorModel ( )

override

Definition at line 58 of file KisVisualColorModel.cpp.

{
}

Member Function Documentation

channelValues()

QVector4D KisVisualColorModel::channelValues

(

)

const

Definition at line 130 of file KisVisualColorModel.cpp.

{
    return m_d->channelValues;
}

References m_d.

colorChannelCount()

int KisVisualColorModel::colorChannelCount

(

)

const

Definition at line 135 of file KisVisualColorModel.cpp.

{
    return m_d->colorChannelCount;
}

References m_d.

colorModel()

KisVisualColorModel::ColorModel KisVisualColorModel::colorModel

(

)

const

Definition at line 140 of file KisVisualColorModel.cpp.

{
    return m_d->model;
}

References m_d.

colorSpace()

const KoColorSpace * KisVisualColorModel::colorSpace

(

)

const

Definition at line 190 of file KisVisualColorModel.cpp.

{
    return m_d->currentCS;
}

References m_d.

convertChannelValuesToKoColor()

KoColor KisVisualColorModel::convertChannelValuesToKoColor

(

const QVector4D &

values

)

const

Definition at line 205 of file KisVisualColorModel.cpp.

{
    KoColor c(m_d->currentCS);
    QVector4D baseValues(values);
    QVector<float> channelVec(c.colorSpace()->channelCount());
    channelVec.fill(1.0);
 
    if (m_d->model != ColorModel::Channel && m_d->isRGBA) {
 
        if (m_d->model == ColorModel::HSV) {
            HSVToRGB(values.x()*360, values.y(), values.z(), &baseValues[0], &baseValues[1], &baseValues[2]);
        }
        else if (m_d->model == ColorModel::HSL) {
            HSLToRGB(values.x()*360, values.y(), values.z(), &baseValues[0], &baseValues[1], &baseValues[2]);
        }
        else if (m_d->model == ColorModel::HSI) {
            // why suddenly qreal?
            qreal temp[3];
            HSIToRGB(values.x(), values.y(), values.z(), &temp[0], &temp[1], &temp[2]);
            baseValues.setX(temp[0]);
            baseValues.setY(temp[1]);
            baseValues.setZ(temp[2]);
        }
        else /*if (m_d->model == ColorModel::HSY)*/ {
            qreal temp[3];
            qreal Y = pow(values.z(), m_d->gamma);
            HSYToRGB(values.x(), values.y(), Y, &temp[0], &temp[1], &temp[2],
                    m_d->lumaRGB[0], m_d->lumaRGB[1], m_d->lumaRGB[2]);
            baseValues.setX(temp[0]);
            baseValues.setY(temp[1]);
            baseValues.setZ(temp[2]);
            if (!m_d->isLinear) {
                // Note: not all profiles define a TRC necessary for (de-)linearization,
                // substituting with a linear profiles would be better
                QVector<qreal> tempVec({baseValues[0], baseValues[1], baseValues[2]});
                if (m_d->exposureSupported) {
                    m_d->currentCS->profile()->delinearizeFloatValue(tempVec);
                }
                else {
                    m_d->currentCS->profile()->delinearizeFloatValueFast(tempVec);
                }
                baseValues = QVector4D(tempVec[0], tempVec[1], tempVec[2], 0);
            }
        }
        if (m_d->applyGamma) {
            for (int i=0; i<3; i++) {
                baseValues[i] = pow(baseValues[i], 2.2);
            }
        }
    } else if (m_d->model != ColorModel::Channel && m_d->isLABlike) {
        QVector<qreal> tempVec({baseValues[0], baseValues[1], baseValues[2]});
        LCHToLab(values.z(), values.y(), values.x(), &tempVec[0], &tempVec[1], &tempVec[2]);
        baseValues = QVector4D(tempVec[0], tempVec[1], tempVec[2], 0);
    }
 
    if (m_d->exposureSupported) {
        for (int i = 0; i < m_d->colorChannelCount; i++) {
            baseValues[i] *= m_d->channelMaxValues[i];
        }
    }
 
    for (int i=0; i<m_d->colorChannelCount; i++) {
        channelVec[m_d->logicalToMemoryPosition[i]] = baseValues[i];
    }
 
    c.colorSpace()->fromNormalisedChannelsValue(c.data(), channelVec);
 
    return c;
 
}

References Channel, KoColorSpace::channelCount(), KoColor::colorSpace(), KoColor::data(), KoColorSpace::fromNormalisedChannelsValue(), HSI, HSIToRGB(), HSL, HSLToRGB(), HSV, HSVToRGB(), HSYToRGB(), LCHToLab(), and m_d.

convertKoColorToChannelValues()

QVector4D KisVisualColorModel::convertKoColorToChannelValues

(

KoColor

c

)

const

Definition at line 276 of file KisVisualColorModel.cpp.

{
    if (c.colorSpace() != m_d->currentCS) {
        c.convertTo(m_d->currentCS);
    }
    QVector<float> channelVec (c.colorSpace()->channelCount());
    channelVec.fill(1.0);
    m_d->currentCS->normalisedChannelsValue(c.data(), channelVec);
    QVector4D channelValuesDisplay(0, 0, 0, 0), coordinates(0, 0, 0, 0);
 
    for (int i =0; i<m_d->colorChannelCount; i++) {
        channelValuesDisplay[i] = channelVec[m_d->logicalToMemoryPosition[i]];
    }
 
    if (m_d->exposureSupported) {
        for (int i = 0; i < m_d->colorChannelCount; i++) {
            channelValuesDisplay[i] /= m_d->channelMaxValues[i];
        }
    }
    if (m_d->model != ColorModel::Channel && m_d->isRGBA) {
        if (m_d->applyGamma) {
            for (int i=0; i<3; i++) {
                channelValuesDisplay[i] = pow(channelValuesDisplay[i], 1/2.2);
            }
        }
        if (m_d->model == ColorModel::HSV) {
            QVector3D hsv;
            RGBToHSV(channelValuesDisplay[0], channelValuesDisplay[1], channelValuesDisplay[2], &hsv[0], &hsv[1], &hsv[2]);
            hsv[0] /= 360;
            coordinates = QVector4D(hsv, 0.f);
        } else if (m_d->model == ColorModel::HSL) {
            QVector3D hsl;
            RGBToHSL(channelValuesDisplay[0], channelValuesDisplay[1], channelValuesDisplay[2], &hsl[0], &hsl[1], &hsl[2]);
            hsl[0] /= 360;
            coordinates = QVector4D(hsl, 0.f);
        } else if (m_d->model == ColorModel::HSI) {
            qreal hsi[3];
            RGBToHSI(channelValuesDisplay[0], channelValuesDisplay[1], channelValuesDisplay[2], &hsi[0], &hsi[1], &hsi[2]);
            coordinates = QVector4D(hsi[0], hsi[1], hsi[2], 0.f);
        } else if (m_d->model == ColorModel::HSY) {
            if (!m_d->isLinear) {
                // Note: not all profiles define a TRC necessary for (de-)linearization,
                // substituting with a linear profiles would be better
                QVector<qreal> temp({channelValuesDisplay[0], channelValuesDisplay[1], channelValuesDisplay[2]});
                m_d->currentCS->profile()->linearizeFloatValue(temp);
                channelValuesDisplay = QVector4D(temp[0], temp[1], temp[2], 0);
            }
            qreal hsy[3];
            RGBToHSY(channelValuesDisplay[0], channelValuesDisplay[1], channelValuesDisplay[2], &hsy[0], &hsy[1], &hsy[2],
                     m_d->lumaRGB[0], m_d->lumaRGB[1], m_d->lumaRGB[2]);
            hsy[2] = pow(hsy[2], 1/m_d->gamma);
            coordinates = QVector4D(hsy[0], hsy[1], hsy[2], 0.f);
        }
        // if we couldn't determine a hue, keep last value
        if (coordinates[0] < 0) {
            coordinates[0] = m_d->channelValues[0];
        }
        for (int i=0; i<3; i++) {
            coordinates[i] = qBound(0.f, coordinates[i], 1.f);
        }
    } else if (m_d->model != ColorModel::Channel && m_d->isLABlike) {
        qreal lch[3];
        LabToLCH(channelValuesDisplay[0], channelValuesDisplay[1], channelValuesDisplay[2], &lch[0], &lch[1], &lch[2]);
        coordinates = QVector4D(lch[2], lch[1], lch[0], 0.f);
 
        if (coordinates[0] < 0) {
            coordinates[0] = m_d->channelValues[0];
        }
        for (int i=0; i<3; i++) {
            coordinates[i] = qBound(0.f, coordinates[i], 1.f);
        }
    } else {
        for (int i=0; i<4; i++) {
            coordinates[i] = qBound(0.f, channelValuesDisplay[i], 1.f);
        }
    }
    return coordinates;
}

References Channel, KoColorSpace::channelCount(), KoColor::colorSpace(), KoColor::convertTo(), KoColor::data(), HSI, HSL, HSV, HSY, LabToLCH(), m_d, RGBToHSI(), RGBToHSL(), RGBToHSV(), and RGBToHSY().

copyState()

void KisVisualColorModel::copyState

(

const KisVisualColorModel &

other

)

Copy the internal state of another KisVisualColorModel.

This will Q_EMIT all necessary signals to update widgets so they can reflect the new state correctly.

Parameters

other

the model to copy

Definition at line 163 of file KisVisualColorModel.cpp.

{
    m_d->channelMaxValues = other.m_d->channelMaxValues;
    setRGBColorModel(other.m_d->modelRGB);
    if (other.colorSpace()) {
        slotSetColorSpace(other.colorSpace());
        slotSetChannelValues(other.channelValues());
    }
}

References channelValues(), colorSpace(), m_d, setRGBColorModel(), slotSetChannelValues(), and slotSetColorSpace().

currentColor()

KoColor KisVisualColorModel::currentColor

(

)

const

Definition at line 125 of file KisVisualColorModel.cpp.

{
    return m_d->currentcolor;
}

References m_d.

emitChannelValues()

void KisVisualColorModel::emitChannelValues ( )

private

Definition at line 459 of file KisVisualColorModel.cpp.

{
    bool updatesAllowed = m_d->allowUpdates;
    m_d->allowUpdates = false;
    Q_EMIT sigChannelValuesChanged(m_d->channelValues, (1u << m_d->colorChannelCount) - 1);
    m_d->allowUpdates = updatesAllowed;
}

References m_d, and sigChannelValuesChanged().

isHSXModel()

bool KisVisualColorModel::isHSXModel

(

)

const

Definition at line 195 of file KisVisualColorModel.cpp.

{
    return (m_d->model >= ColorModel::HSV && m_d->model <= ColorModel::HSY);
}

References HSV, HSY, and m_d.

loadColorSpace()

void KisVisualColorModel::loadColorSpace ( const KoColorSpace * cs )

private

Definition at line 402 of file KisVisualColorModel.cpp.

{
    const QList<KoChannelInfo *> channelList = cs->channels();
    int cCount = 0;
 
    for (int i = 0; i < channelList.size(); i++) {
        const KoChannelInfo *channel = channelList.at(i);
        if (channel->channelType() != KoChannelInfo::ALPHA) {
            quint32 logical = channel->displayPosition();
            if (logical > cs->alphaPos()) {
                --logical;
            }
            m_d->logicalToMemoryPosition[logical] = i;
            m_d->channelMaxValues[logical] = channel->getUIMax();
            ++cCount;
        }
    }
    KIS_ASSERT_X(cCount < 5, "", "unsupported channel count!");
 
    m_d->colorChannelCount = cCount;
 
    if ((cs->colorDepthId() == Float16BitsColorDepthID
        || cs->colorDepthId() == Float32BitsColorDepthID
        || cs->colorDepthId() == Float64BitsColorDepthID)
        && cs->colorModelId() != LABAColorModelID
        && cs->colorModelId() != CMYKAColorModelID) {
        m_d->exposureSupported = true;
    } else {
        m_d->exposureSupported = false;
    }
    m_d->isRGBA = (cs->colorModelId() == RGBAColorModelID);
    m_d->isLABlike = (cs->colorModelId() == LABAColorModelID || cs->colorModelId() == YCbCrAColorModelID);
 
    const KoColorProfile *profile = cs->profile();
    m_d->isLinear = (profile && profile->isLinear());
 
    if (m_d->isRGBA) {
        m_d->applyGamma = (m_d->isLinear && m_d->modelRGB != ColorModel::HSY);
        // Note: only profiles that define colorants will give precise luma coefficients.
        // Maybe using the explicitly set values of the Advanced Color Selector is better?
        QVector <qreal> luma = cs->lumaCoefficients();
        memcpy(m_d->lumaRGB, luma.constData(), 3*sizeof(qreal));
        m_d->model = m_d->modelRGB;
    } else if (m_d->isLABlike) {
        m_d->model = m_d->modelRGB;
    } else {
        m_d->model = KisVisualColorModel::Channel;
    }
 
    const KoColorSpace *oldCS = m_d->currentCS;
    m_d->currentCS = cs;
 
    if (!oldCS || (oldCS->colorModelId() != cs->colorModelId())) {
        Q_EMIT sigColorModelChanged();
    }
}

References KoChannelInfo::ALPHA, KoColorSpace::alphaPos(), Channel, KoColorSpace::channels, KoChannelInfo::channelType(), CMYKAColorModelID, KoColorSpace::colorDepthId(), KoColorSpace::colorModelId(), KoChannelInfo::displayPosition(), Float16BitsColorDepthID, Float32BitsColorDepthID, Float64BitsColorDepthID, KoChannelInfo::getUIMax(), HSY, KoColorProfile::isLinear(), KIS_ASSERT_X, LABAColorModelID, KoColorSpace::lumaCoefficients, m_d, KoColorSpace::profile(), RGBAColorModelID, sigColorModelChanged(), and YCbCrAColorModelID.

maxChannelValues()

QVector4D KisVisualColorModel::maxChannelValues

(

)

const

Definition at line 145 of file KisVisualColorModel.cpp.

{
    return m_d->channelMaxValues;
}

References m_d.

setMaxChannelValues()

void KisVisualColorModel::setMaxChannelValues

(

const QVector4D &

maxValues

)

Definition at line 150 of file KisVisualColorModel.cpp.

{
    if (maxValues == m_d->channelMaxValues) {
        return;
    }
    m_d->channelMaxValues = maxValues;
    if (m_d->exposureSupported) {
        // need to re-scale our normalized channel values on exposure changes:
        m_d->channelValues = convertKoColorToChannelValues(m_d->currentcolor);
        emitChannelValues();
    }
}

References convertKoColorToChannelValues(), emitChannelValues(), and m_d.

setRGBColorModel()

void KisVisualColorModel::setRGBColorModel

(

KisVisualColorModel::ColorModel

model

)

Set the HSX color model used for RGB color spaces.

Definition at line 173 of file KisVisualColorModel.cpp.

{
    if (model == m_d->modelRGB) {
        return;
    }
    if (model >= ColorModel::HSV && model <= ColorModel::HSY) {
        m_d->modelRGB = model;
        if (m_d->isRGBA) {
            m_d->model = model;
            m_d->applyGamma = (m_d->isLinear && m_d->modelRGB != ColorModel::HSY);
            Q_EMIT sigColorModelChanged();
            m_d->channelValues = convertKoColorToChannelValues(m_d->currentcolor);
            emitChannelValues();
        }
    }
}

References convertKoColorToChannelValues(), emitChannelValues(), HSV, HSY, m_d, and sigColorModelChanged().

sigChannelValuesChanged

void KisVisualColorModel::sigChannelValuesChanged ( const QVector4D & values, quint32 channelFlags )

signal

sigColorModelChanged

void KisVisualColorModel::sigColorModelChanged ( )

signal

sigColorModelChanged is emitted whenever the color model changes.

This can either be due to a change in color space that uses a different channel model, or when the same color space gets represented in a different way, for example RGB representation switches from HSV to HSL etc. so the values of sigChannelValuesChanged() change meaning. Note: This will be followed by sigChannelValuesChanged() unless caused by a color space change, new channel values are not available yet when this signal occurs.

See also

getColorModel()

sigColorSpaceChanged

void KisVisualColorModel::sigColorSpaceChanged ( )

signal

sigColorSpaceChanged notifies that the color space from which the channel values are derived changed, and thus invalidating the current ones.

sigNewColor

void KisVisualColorModel::sigNewColor ( const KoColor & c )

signal

slotLoadACSConfig

void KisVisualColorModel::slotLoadACSConfig ( )

slot

slotLoadACSConfig loads supported settings from Advanced Color Selector

Definition at line 355 of file KisVisualColorModel.cpp.

{
    KConfigGroup cfg =  KSharedConfig::openConfig()->group("advancedColorSelector");
    m_d->acs_config = KisColorSelectorConfiguration::fromString(cfg.readEntry("colorSelectorConfiguration", KisColorSelectorConfiguration().toString()));
 
    m_d->gamma = cfg.readEntry("gamma", 2.2);
 
    KisVisualColorModel::ColorModel RGB_model = KisVisualColorModel::HSV;
 
    switch(m_d->acs_config.mainTypeParameter) {
 
    case KisColorSelectorConfiguration::SV:
    case KisColorSelectorConfiguration::SV2:
    case KisColorSelectorConfiguration::hsvSH:
    case KisColorSelectorConfiguration::VH:
        RGB_model = KisVisualColorModel::HSV;
        break;
 
    case KisColorSelectorConfiguration::SL:
    case KisColorSelectorConfiguration::hslSH:
    case KisColorSelectorConfiguration::LH:
        RGB_model = KisVisualColorModel::HSL;
        break;
 
    case KisColorSelectorConfiguration::SI:
    case KisColorSelectorConfiguration::hsiSH:
    case KisColorSelectorConfiguration::IH:
        RGB_model = KisVisualColorModel::HSI;
        break;
 
    case KisColorSelectorConfiguration::SY:
    case KisColorSelectorConfiguration::hsySH:
    case KisColorSelectorConfiguration::YH:
        RGB_model = KisVisualColorModel::HSY;
        break;
 
    default:
        KIS_SAFE_ASSERT_RECOVER_NOOP(false);
    }
    if (m_d->acs_config.mainType == KisColorSelectorConfiguration::Triangle) {
        //Triangle only really works in HSV mode.
        RGB_model = KisVisualColorModel::HSV;
    }
 
    setRGBColorModel(RGB_model);
}

References KisColorSelectorConfiguration::fromString(), HSI, KisColorSelectorConfiguration::hsiSH, HSL, KisColorSelectorConfiguration::hslSH, HSV, KisColorSelectorConfiguration::hsvSH, HSY, KisColorSelectorConfiguration::hsySH, KisColorSelectorConfiguration::IH, KIS_SAFE_ASSERT_RECOVER_NOOP, KisColorSelectorConfiguration::LH, m_d, setRGBColorModel(), KisColorSelectorConfiguration::SI, KisColorSelectorConfiguration::SL, KisColorSelectorConfiguration::SV, KisColorSelectorConfiguration::SV2, KisColorSelectorConfiguration::SY, KisColorSelectorConfiguration::Triangle, KisColorSelectorConfiguration::VH, and KisColorSelectorConfiguration::YH.

slotSetChannelValues

void KisVisualColorModel::slotSetChannelValues ( const QVector4D & values )

slot

Definition at line 103 of file KisVisualColorModel.cpp.

{
    if (!m_d->allowUpdates) {
        return;
    }
 
    quint32 changeFlags = 0;
    QVector4D newValues(0, 0, 0, 0);
    for (int i = 0; i < m_d->colorChannelCount; i++) {
        newValues[i] = values[i];
        changeFlags |= quint32(values[i] != m_d->channelValues[i]) << i;
    }
    if (changeFlags != 0) {
        m_d->allowUpdates = false;
        m_d->channelValues = newValues;
        m_d->currentcolor = convertChannelValuesToKoColor(newValues);
        Q_EMIT sigChannelValuesChanged(m_d->channelValues, changeFlags);
        Q_EMIT sigNewColor(m_d->currentcolor);
        m_d->allowUpdates = true;
    }
}

References convertChannelValuesToKoColor(), m_d, sigChannelValuesChanged(), and sigNewColor().

slotSetColor

void KisVisualColorModel::slotSetColor ( const KoColor & c )

slot

Definition at line 62 of file KisVisualColorModel.cpp.

{
    if (!m_d->allowUpdates) {
        return;
    }
 
    if (!m_d->currentCS) {
        m_d->currentcolor = c;
        slotSetColorSpace(c.colorSpace());
    }
    else {
        m_d->currentcolor = c.convertedTo(m_d->currentCS);
        m_d->channelValues = convertKoColorToChannelValues(m_d->currentcolor);
        emitChannelValues();
    }
}

References KoColor::colorSpace(), KoColor::convertedTo(), convertKoColorToChannelValues(), emitChannelValues(), m_d, and slotSetColorSpace().

slotSetColorSpace

void KisVisualColorModel::slotSetColorSpace ( const KoColorSpace * cs )

slot

Definition at line 79 of file KisVisualColorModel.cpp.

{
    if (!m_d->currentCS || *m_d->currentCS != *cs) {
        const KoColorSpace *csNew = cs;
 
        // PQ color space is not very suitable for color picking, substitute with linear one
        if (cs->colorModelId() == RGBAColorModelID
                && KoColorSpaceRegistry::instance()->p2020PQProfile()
                && cs->profile()->uniqueId() == KoColorSpaceRegistry::instance()->p2020PQProfile()->uniqueId()) {
 
            csNew = KoColorSpaceRegistry::instance()->
                    colorSpace(RGBAColorModelID.id(), Float32BitsColorDepthID.id(),
                               KoColorSpaceRegistry::instance()->p2020G10Profile());
        }
 
 
        // TODO: split off non-config related initializations
        loadColorSpace(csNew);
        m_d->currentcolor = KoColor(csNew);
        m_d->channelValues = convertKoColorToChannelValues(m_d->currentcolor);
        Q_EMIT sigColorSpaceChanged();
    }
}

References KoColorSpace::colorModelId(), colorSpace(), convertKoColorToChannelValues(), Float32BitsColorDepthID, KoID::id(), KoColorSpaceRegistry::instance(), loadColorSpace(), m_d, KoColorSpaceRegistry::p2020G10Profile(), KoColorSpaceRegistry::p2020PQProfile(), KoColorSpace::profile(), RGBAColorModelID, sigColorSpaceChanged(), and KoColorProfile::uniqueId().

supportsExposure()

bool KisVisualColorModel::supportsExposure

(

)

const

Definition at line 200 of file KisVisualColorModel.cpp.

{
    return (m_d->exposureSupported);
}

References m_d.

Member Data Documentation

m_d

const QScopedPointer<Private> KisVisualColorModel::m_d

private

Definition at line 103 of file KisVisualColorModel.h.

---

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

• libs/widgets/KisVisualColorModel.h
• libs/widgets/KisVisualColorModel.cpp