KoColor Class Reference

#include <KoColor.h>

Inheritance diagram for KoColor:

Public Member Functions
void	add (const KoColor &value)
KoColor	added (const KoColor &value) const
void	addMetadata (QString key, QVariant value)
void	clearMetadata ()
	clearMetadata clear th metadata map inside the KoColor.
const KoColorSpace *	colorSpace () const
	return the current colorSpace
KoColor	convertedTo (const KoColorSpace *cs) const
KoColor	convertedTo (const KoColorSpace *cs, KoColorConversionTransformation::Intent renderingIntent, KoColorConversionTransformation::ConversionFlags conversionFlags) const
void	convertTo (const KoColorSpace *cs)
void	convertTo (const KoColorSpace *cs, KoColorConversionTransformation::Intent renderingIntent, KoColorConversionTransformation::ConversionFlags conversionFlags)
quint8 *	data ()
const quint8 *	data () const
void	dump () const
	use qDebug calls to print internal info
void	fromKoColor (const KoColor &src)
void	fromQColor (const QColor &c)
	Convenient function for converting from a QColor.
	KoColor ()
	Create an empty KoColor. It will be valid, but also black and transparent.
	KoColor (const KoColor &rhs)
	Copy constructor – deep copies the colors.
	KoColor (const KoColor &src, const KoColorSpace *colorSpace)
	Create a KoColor by converting src into another colorspace.
	KoColor (const KoColorSpace *colorSpace)
	Create a null KoColor. It will be valid, but all channels will be set to 0.
	KoColor (const QColor &color, const KoColorSpace *colorSpace)
	KoColor (const quint8 *data, const KoColorSpace *colorSpace)
	Create a KoColor using a native color strategy. The data is copied.
QMap< QString, QVariant >	metadata () const
qreal	opacityF () const
quint8	opacityU8 () const
KoColor &	operator= (const KoColor &rhs)
bool	operator== (const KoColor &other) const
const KoColorProfile *	profile () const
	return the current profile
void	setColor (const quint8 *data, const KoColorSpace *colorSpace=0)
void	setOpacity (qreal alpha)
void	setOpacity (quint8 alpha)
void	setProfile (const KoColorProfile *profile)
	assign new profile without converting pixel data
void	subtract (const KoColor &value)
KoColor	subtracted (const KoColor &value) const
QColor	toQColor () const
	a convenience method for the above.
void	toQColor (QColor *c) const
	a convenience method for the above.
QString	toSVG11 (QHash< QString, const KoColorProfile * > *profileList) const
	toSVG11
QString	toXML () const
	toXML creates a string with XML that represents the current color. The XML is extended with a "channeldepth" attribute so we can restore the color to the same channel depth.
void	toXML (QDomDocument &doc, QDomElement &colorElt) const

Static Public Member Functions
static KoColor	createTransparent (const KoColorSpace *cs)
static KoColor	fromSVG11 (const QString value, QHash< QString, const KoColorProfile * > profileList, KoColor current=KoColor())
	fromSVG11 Parses a color attribute value and returns a KoColor. SVG defines the colorprofiles elsewhere in the file, so this function expects you to first figure out the profiles and which colorspaces these match to, and it will then use those colorspaces to generate the kocolor. If it cannot find the appropriate colorspace, it will return the color fallback. If that doesn't work, an empty KoColor. This function ignores url() values. Colors will be F32 unless they are lab and cmyk, in which case they'll be U16.
static KoColor	fromXML (const QDomElement &elt, const QString &channelDepthId)
static KoColor	fromXML (const QDomElement &elt, const QString &channelDepthId, bool *ok)
static KoColor	fromXML (const QString &xml)
	fromXML restores a KoColor from a string saved with toXML(). If the string does not contain the "channeldepth" attribute, 16 bit integer is assumed.
static QString	toQString (const KoColor &color)
	toQString create a user-visible string of the channel names and the channel values

Private Member Functions
void	assertPermanentColorspace ()

Private Attributes
const KoColorSpace *	m_colorSpace
quint8	m_data [MAX_PIXEL_SIZE]
QMap< QString, QVariant >	m_metadata
quint8	m_size

Detailed Description

A KoColor describes a color in a certain colorspace. The color is stored in a buffer that can be manipulated by the function of the color space.

Definition at line 30 of file KoColor.h.

Constructor & Destructor Documentation

KoColor() [1/6]

KoColor::KoColor

(

)

Create an empty KoColor. It will be valid, but also black and transparent.

Definition at line 75 of file KoColor.cpp.

    : m_colorSpace(s_defaultKoColor->value->m_colorSpace)
    , m_size(s_defaultKoColor->value->m_size)
{
    memcpy(m_data, s_defaultKoColor->value->m_data, m_size);
}

References m_data, and m_size.

KoColor() [2/6]

KoColor::KoColor ( const KoColorSpace * colorSpace )

explicit

Create a null KoColor. It will be valid, but all channels will be set to 0.

Definition at line 82 of file KoColor.cpp.

{
    Q_ASSERT(colorSpace);
    m_colorSpace = KoColorSpaceRegistry::instance()->permanentColorspace(colorSpace);
    m_size = m_colorSpace->pixelSize();
    Q_ASSERT(m_size <= MAX_PIXEL_SIZE);
    memset(m_data, 0, m_size);
}

References colorSpace(), KoColorSpaceRegistry::instance(), m_colorSpace, m_data, m_size, MAX_PIXEL_SIZE, KoColorSpaceRegistry::permanentColorspace(), and KoColorSpace::pixelSize().

KoColor() [3/6]

KoColor::KoColor	(	const QColor &	color,
		const KoColorSpace *	colorSpace )

Create a KoColor from a QColor. The QColor is immediately converted to native. The QColor is assumed to have the current monitor profile.

Definition at line 91 of file KoColor.cpp.

{
    Q_ASSERT(color.isValid());
    Q_ASSERT(colorSpace);
    m_colorSpace = KoColorSpaceRegistry::instance()->permanentColorspace(colorSpace);
 
    m_size = m_colorSpace->pixelSize();
    Q_ASSERT(m_size <= MAX_PIXEL_SIZE);
    memset(m_data, 0, m_size);
 
    m_colorSpace->fromQColor(color, m_data);
}

References colorSpace(), KoColorSpace::fromQColor(), KoColorSpaceRegistry::instance(), m_colorSpace, m_data, m_size, MAX_PIXEL_SIZE, KoColorSpaceRegistry::permanentColorspace(), and KoColorSpace::pixelSize().

KoColor() [4/6]

KoColor::KoColor	(	const quint8 *	data,
		const KoColorSpace *	colorSpace )

Create a KoColor using a native color strategy. The data is copied.

Definition at line 104 of file KoColor.cpp.

{
    Q_ASSERT(colorSpace);
    Q_ASSERT(data);
    m_colorSpace = KoColorSpaceRegistry::instance()->permanentColorspace(colorSpace);
    m_size = m_colorSpace->pixelSize();
    Q_ASSERT(m_size <= MAX_PIXEL_SIZE);
    memmove(m_data, data, m_size);
}

References colorSpace(), data(), KoColorSpaceRegistry::instance(), m_colorSpace, m_data, m_size, MAX_PIXEL_SIZE, KoColorSpaceRegistry::permanentColorspace(), and KoColorSpace::pixelSize().

KoColor() [5/6]

KoColor::KoColor	(	const KoColor &	src,
		const KoColorSpace *	colorSpace )

Create a KoColor by converting src into another colorspace.

Definition at line 115 of file KoColor.cpp.

{
    Q_ASSERT(colorSpace);
    m_colorSpace = KoColorSpaceRegistry::instance()->permanentColorspace(colorSpace);
    m_size = m_colorSpace->pixelSize();
    Q_ASSERT(m_size <= MAX_PIXEL_SIZE);
    memset(m_data, 0, m_size);
 
    src.colorSpace()->convertPixelsTo(src.m_data, m_data, colorSpace, 1, KoColorConversionTransformation::internalRenderingIntent(), KoColorConversionTransformation::internalConversionFlags());
}

References colorSpace(), KoColorSpaceRegistry::instance(), KoColorConversionTransformation::internalConversionFlags(), KoColorConversionTransformation::internalRenderingIntent(), m_colorSpace, m_data, m_size, MAX_PIXEL_SIZE, KoColorSpaceRegistry::permanentColorspace(), and KoColorSpace::pixelSize().

KoColor() [6/6]

KoColor::KoColor ( const KoColor & rhs )

inline

Copy constructor – deep copies the colors.

Definition at line 51 of file KoColor.h.

        : m_colorSpace(rhs.m_colorSpace)
        , m_size(rhs.m_size)
        , m_metadata(rhs.m_metadata)
    {
        memcpy(m_data, rhs.m_data, m_size);
    }

References m_data.

Member Function Documentation

add()

void KoColor::add

(

const KoColor &

value

)

Channelwise adds value to *this and stores the result in *this

Throws a safe assert if the colorspaces of the two colors are different

Definition at line 244 of file KoColor.cpp.

{
    KIS_SAFE_ASSERT_RECOVER_RETURN(*m_colorSpace == *value.colorSpace());
 
    QVector<float> channels1(m_colorSpace->channelCount());
    QVector<float> channels2(m_colorSpace->channelCount());
 
    m_colorSpace->normalisedChannelsValue(m_data, channels1);
    m_colorSpace->normalisedChannelsValue(value.data(), channels2);
 
    for (int i = 0; i < channels1.size(); i++) {
        channels1[i] += channels2[i];
    }
 
    m_colorSpace->fromNormalisedChannelsValue(m_data, channels1);
}

References KoColorSpace::channelCount(), KoColorSpace::fromNormalisedChannelsValue(), KIS_SAFE_ASSERT_RECOVER_RETURN, m_colorSpace, m_data, KoColorSpace::normalisedChannelsValue(), and value().

added()

KoColor KoColor::added

(

const KoColor &

value

)

const

Channelwise adds value to a copy of *this and returns the result

Throws a safe assert if the colorspaces of the two colors are different

Definition at line 261 of file KoColor.cpp.

{
    KoColor result(*this);
    result.add(value);
    return result;
}

References add(), and value().

addMetadata()

void KoColor::addMetadata	(	QString	key,
		QVariant	value )

store the given key, value pair in a KoColor.

Definition at line 666 of file KoColor.cpp.

{
    m_metadata.insert(key, value);
}

References m_metadata, and value().

assertPermanentColorspace()

void KoColor::assertPermanentColorspace ( )

inlineprivate

Definition at line 312 of file KoColor.h.

                                            {
#ifndef NODEBUG
        if (m_colorSpace) {
            Q_ASSERT(*m_colorSpace == *KoColorSpaceRegistry::instance()->permanentColorspace(m_colorSpace));
        }
#endif
    }

References KoColorSpaceRegistry::instance().

clearMetadata()

void KoColor::clearMetadata

(

)

clearMetadata clear th metadata map inside the KoColor.

Definition at line 676 of file KoColor.cpp.

{
    m_metadata.clear();
}

References m_metadata.

colorSpace()

const KoColorSpace * KoColor::colorSpace ( ) const

inline

return the current colorSpace

Definition at line 82 of file KoColor.h.

                                            {
        return m_colorSpace;
    }

convertedTo() [1/2]

KoColor KoColor::convertedTo

(

const KoColorSpace *

cs

)

const

Copies this color and converts it to the specified colorspace. If the specified colorspace is the same as the original colorspace, just returns a copy

Definition at line 170 of file KoColor.cpp.

{
    return convertedTo(cs,
                       KoColorConversionTransformation::internalRenderingIntent(),
                       KoColorConversionTransformation::internalConversionFlags());
}

References convertedTo(), KoColorConversionTransformation::internalConversionFlags(), and KoColorConversionTransformation::internalRenderingIntent().

convertedTo() [2/2]

KoColor KoColor::convertedTo	(	const KoColorSpace *	cs,
		KoColorConversionTransformation::Intent	renderingIntent,
		KoColorConversionTransformation::ConversionFlags	conversionFlags ) const

Copies this color and converts it to the specified colorspace. If the specified colorspace is the same as the original colorspace, just returns a copy

Definition at line 163 of file KoColor.cpp.

{
    KoColor result(*this);
    result.convertTo(cs, renderingIntent, conversionFlags);
    return result;
}

References convertTo().

convertTo() [1/2]

void KoColor::convertTo

(

const KoColorSpace *

cs

)

Definition at line 156 of file KoColor.cpp.

{
    convertTo(cs,
              KoColorConversionTransformation::internalRenderingIntent(),
              KoColorConversionTransformation::internalConversionFlags());
}

References convertTo(), KoColorConversionTransformation::internalConversionFlags(), and KoColorConversionTransformation::internalRenderingIntent().

convertTo() [2/2]

void KoColor::convertTo	(	const KoColorSpace *	cs,
		KoColorConversionTransformation::Intent	renderingIntent,
		KoColorConversionTransformation::ConversionFlags	conversionFlags )

Convert this KoColor to the specified colorspace. If the specified colorspace is the same as the original colorspace, do nothing

Definition at line 136 of file KoColor.cpp.

{
    //dbgPigment <<"Our colormodel:" << d->colorSpace->id().name()
    //      << ", new colormodel: " << cs->id().name() << "\n";
 
    if (*m_colorSpace == *cs)
        return;
 
    quint8 data[MAX_PIXEL_SIZE];
    const size_t size = cs->pixelSize();
    Q_ASSERT(size <= MAX_PIXEL_SIZE);
    memset(data, 0, size);
 
    m_colorSpace->convertPixelsTo(m_data, data, cs, 1, renderingIntent, conversionFlags);
 
    memcpy(m_data, data, size);
    m_size = size;
    m_colorSpace = KoColorSpaceRegistry::instance()->permanentColorspace(cs);
}

References KoColorSpace::convertPixelsTo(), data(), KoColorSpaceRegistry::instance(), m_colorSpace, m_data, m_size, MAX_PIXEL_SIZE, KoColorSpaceRegistry::permanentColorspace(), and KoColorSpace::pixelSize().

createTransparent()

KoColor KoColor::createTransparent ( const KoColorSpace * cs )

static

Not all color spaces support creation of a color from QColor, so we should create the default backdrop color explicitly.

See also

KoColorSpace::transparentColor

Definition at line 681 of file KoColor.cpp.

{
    KoColor result;
 
    result.m_colorSpace = KoColorSpaceRegistry::instance()->permanentColorspace(cs);
    result.m_size = cs->pixelSize();
    cs->transparentColor(result.m_data, 1);
 
    return result;
}

References KoColorSpaceRegistry::instance(), m_colorSpace, m_data, m_size, KoColorSpaceRegistry::permanentColorspace(), KoColorSpace::pixelSize(), and KoColorSpace::transparentColor().

data() [1/2]

quint8 * KoColor::data ( )

inline

Returns

the buffer associated with this color object to be used with the transformation object created by the color space of this KoColor or to copy to a different buffer from the same color space

Definition at line 144 of file KoColor.h.

                    {
        return m_data;
    }

data() [2/2]

const quint8 * KoColor::data ( ) const

inline

Returns

the buffer associated with this color object to be used with the transformation object created by the color space of this KoColor or to copy to a different buffer from the same color space

Definition at line 153 of file KoColor.h.

                                {
        return m_data;
    }

dump()

void KoColor::dump

(

)

const

use qDebug calls to print internal info

Definition at line 269 of file KoColor.cpp.

{
    dbgPigment <<"KoColor (" << this <<")," << m_colorSpace->id() <<"";
    QList<KoChannelInfo *> channels = m_colorSpace->channels();
 
    QList<KoChannelInfo *>::const_iterator begin = channels.constBegin();
    QList<KoChannelInfo *>::const_iterator end = channels.constEnd();
 
    for (QList<KoChannelInfo *>::const_iterator it = begin; it != end; ++it) {
        KoChannelInfo * ch = (*it);
        // XXX: setNum always takes a byte.
        if (ch->size() == sizeof(quint8)) {
            // Byte
            dbgPigment <<"Channel (byte):" << ch->name() <<":" << QString().setNum(m_data[ch->pos()]) <<"";
        } else if (ch->size() == sizeof(quint16)) {
            // Short (may also by an nvidia half)
            dbgPigment <<"Channel (short):" << ch->name() <<":" << QString().setNum(*((const quint16 *)(m_data+ch->pos())))  <<"";
        } else if (ch->size() == sizeof(quint32)) {
            // Integer (may also be float... Find out how to distinguish these!)
            dbgPigment <<"Channel (int):" << ch->name() <<":" << QString().setNum(*((const quint32 *)(m_data+ch->pos())))  <<"";
        }
    }
}

References KoColorSpace::channels, dbgPigment, KoColorSpace::id, m_colorSpace, m_data, KoChannelInfo::name(), KoChannelInfo::pos(), and KoChannelInfo::size().

fromKoColor()

void KoColor::fromKoColor

(

const KoColor &

src

)

Convert the color from src and replace the value of the current color with the converted data. Don't convert the color if src and this have the same colorspace.

Definition at line 294 of file KoColor.cpp.

{
    src.colorSpace()->convertPixelsTo(src.m_data, m_data, colorSpace(), 1, KoColorConversionTransformation::internalRenderingIntent(), KoColorConversionTransformation::internalConversionFlags());
}

References colorSpace(), KoColorConversionTransformation::internalConversionFlags(), KoColorConversionTransformation::internalRenderingIntent(), and m_data.

fromQColor()

void KoColor::fromQColor

(

const QColor &

c

)

Convenient function for converting from a QColor.

Definition at line 213 of file KoColor.cpp.

{
    if (m_colorSpace) {
        m_colorSpace->fromQColor(c, m_data);
    }
}

References KoColorSpace::fromQColor(), m_colorSpace, and m_data.

fromSVG11()

KoColor KoColor::fromSVG11 ( const QString value, QHash< QString, const KoColorProfile * > profileList, KoColor current = KoColor() )

static

fromSVG11 Parses a color attribute value and returns a KoColor. SVG defines the colorprofiles elsewhere in the file, so this function expects you to first figure out the profiles and which colorspaces these match to, and it will then use those colorspaces to generate the kocolor. If it cannot find the appropriate colorspace, it will return the color fallback. If that doesn't work, an empty KoColor. This function ignores url() values. Colors will be F32 unless they are lab and cmyk, in which case they'll be U16.

https://www.w3.org/TR/SVG11/types.html#DataTypeColor for hex, rgb() and colornames https://www.w3.org/TR/SVG11/types.html#DataTypeICCColor for icc-color() https://www.w3.org/TR/SVG11/painting.html#SpecifyingPaint

Parameters

value	the content of the svg color value
profileList	list of KoColorProfiles that were found inside the svg file, with the reference names.
current	the current color.

Returns

a KoColor as parsed from the value string.

Definition at line 534 of file KoColor.cpp.

{
    KoColor parsed(KoColorSpaceRegistry::instance()->rgb16(KoColorSpaceRegistry::instance()->p709SRGBProfile()));
    parsed.setOpacity(1.0);
 
    if (value.toLower() == "none") {
        return parsed;
    }
 
    // add the sRGB default name.
    profileList.insert("sRGB", KoColorSpaceRegistry::instance()->p709SRGBProfile());
    // first, try to split at \w\d\‍) space.
    // we want to split up a string like... colorcolor none rgb(0.8, 0.1, 200%) #ff0000 icc-color(blah, 0.0, 1.0, 1.0, 0.0);
    QRegExp splitDefinitions("(#?\\w+|[\\w\\-]*\\(.+\\))\\s");
    int pos = 0;
    int pos2 = 0;
    QStringList colorDefinitions;
    QString valueAdjust = value.split(";").first();
    valueAdjust.append(" ");
    while ((pos2 = splitDefinitions.indexIn(valueAdjust, pos)) != -1) {
        colorDefinitions.append(splitDefinitions.cap(1).trimmed());
        pos = pos2 + splitDefinitions.matchedLength();
    }
    if (pos < value.length()) {
        QString remainder = value.right(value.length()-pos);
        remainder.remove(";");
        colorDefinitions.append(remainder);
    }
    dbgPigment << "Color definitions found during svg11parsing" << colorDefinitions;
 
    for (QString def : colorDefinitions) {
        if (def.toLower() == "currentcolor") {
            parsed = current;
        } else if (QColor::isValidColor(def)) {
            parsed.fromQColor(QColor(def));
        } else if (def.toLower().startsWith("rgb")) {
            QString parse = def.trimmed();
            QStringList colors = parse.split(',');
            QString r = colors[0].right((colors[0].length() - 4)).trimmed();
            QString g = colors[1].trimmed();
            QString b = colors[2].left((colors[2].length() - 1)).trimmed();
 
            if (r.contains('%')) {
                r = r.left(r.length() - 1);
                r = QString::number(int((double(255 * r.toDouble()) / 100.0)));
            }
 
            if (g.contains('%')) {
                g = g.left(g.length() - 1);
                g = QString::number(int((double(255 * g.toDouble()) / 100.0)));
            }
 
            if (b.contains('%')) {
                b = b.left(b.length() - 1);
                b = QString::number(int((double(255 * b.toDouble()) / 100.0)));
            }
            parsed.fromQColor(QColor(r.toInt(), g.toInt(), b.toInt()));
 
        } else if (def.toLower().startsWith("icc-color")) {
            QStringList values = def.split(",");
            QString iccprofilename = values.first().split("(").last();
            values.removeFirst();
 
            // svg11 docs say that searching the name should be case-insensitive.
            QStringList entry = QStringList(profileList.keys()).filter(iccprofilename, Qt::CaseInsensitive);
            if (entry.empty()) {
                continue;
            }
            const KoColorProfile *profile = profileList.value(entry.first());
            if (!profile) {
                continue;
            }
            QString colormodel = profile->colorModelID();
            QString depth = "F32";
            if (colormodel == LABAColorModelID.id()) {
                // let our xml handling deal with lab
                QVector<float> labV(3);
                for (int i = 0; i < values.size(); i++) {
                    if (i<labV.size()) {
                        QString entry = values.at(i);
                        entry = entry.split(")").first();
                        labV[i] = entry.toDouble();
                    }
                }
                QString lab = QString("<Lab space='%1' L='%2' a='%3' b='%4' />")
                        .arg(profile->name())
                        .arg(labV[0])
                        .arg(labV[1])
                        .arg(labV[2]);
                QDomDocument doc;
                doc.setContent(lab);
                parsed = KoColor::fromXML(doc.documentElement(), "U16");
                continue;
            } else if (colormodel == CMYKAColorModelID.id()) {
                depth = "U16";
            } else if (colormodel == XYZAColorModelID.id()) {
                // Inkscape decided to have X and Z go from 0 to 2, and I can't for the live of me figure out why.
                // So we're just not parsing XYZ.
                continue;
            }
            const KoColorSpace * cs = KoColorSpaceRegistry::instance()->colorSpace(colormodel, depth, profile);
            if (!cs) {
                continue;
            }
            parsed = KoColor(cs);
            QVector<float> channelValues(parsed.colorSpace()->channelCount());
            channelValues.fill(0.0);
            channelValues[parsed.colorSpace()->alphaPos()] = 1.0;
            for (int channel = 0; channel < values.size(); channel++) {
                int location = KoChannelInfo::displayPositionToChannelIndex(channel, parsed.colorSpace()->channels());
                QString entry = values.at(channel);
                entry = entry.split(")").first();
                channelValues[location] = entry.toFloat();
            }
            parsed.colorSpace()->fromNormalisedChannelsValue(parsed.data(), channelValues);
        }
    }
 
    return parsed;
}

References KoColorSpace::alphaPos(), KoColorSpace::channelCount(), KoColorSpace::channels, CMYKAColorModelID, KoColorProfile::colorModelID(), colorSpace(), KoColorSpaceRegistry::colorSpace(), data(), dbgPigment, KoChannelInfo::displayPositionToChannelIndex(), KoColorSpace::fromNormalisedChannelsValue(), fromQColor(), fromXML(), KoID::id(), KoColorSpaceRegistry::instance(), KoColor(), LABAColorModelID, length(), KoColorProfile::name, profile(), setOpacity(), value(), and XYZAColorModelID.

fromXML() [1/3]

KoColor KoColor::fromXML ( const QDomElement & elt, const QString & channelDepthId )

static

Unserialize a color following Create's swatch color specification available at https://web.archive.org/web/20110826002520/http://create.freedesktop.org/wiki/Swatches_-_color_file_format/Draft

Parameters

elt	the element to unserialize (<CMYK />, <sRGB />, <RGB />)
channelDepthId	the bit depth is unspecified by the spec, this allow to select a preferred bit depth for creating the KoColor object (if that bit depth isn't available, this function will randomly select another bit depth)

Returns

the unserialize color, or an empty color object if the function failed to unserialize the color

Definition at line 350 of file KoColor.cpp.

{
    bool ok;
    return fromXML(elt, channelDepthId, &ok);
}

References fromXML().

fromXML() [2/3]

KoColor KoColor::fromXML ( const QDomElement & elt, const QString & channelDepthId, bool * ok )

static

Unserialize a color following Create's swatch color specification available at https://web.archive.org/web/20110826002520/http://create.freedesktop.org/wiki/Swatches_-_color_file_format/Draft

Parameters

elt	the element to unserialize (<CMYK />, <sRGB />, <RGB />)
channelDepthId	the bit depth is unspecified by the spec, this allow to select a preferred bit depth for creating the KoColor object (if that bit depth isn't available, this function will randomly select another bit depth)
ok	If a an error occurs, *ok is set to false; otherwise it's set to true

Returns

the unserialize color, or an empty color object if the function failed to unserialize the color

Definition at line 356 of file KoColor.cpp.

{
    *ok = true;
 
    QString modelId;
    QString modelName = elt.tagName();
    if (modelName == "CMYK") {
        modelId = CMYKAColorModelID.id();
    } else if (modelName == "RGB") {
        modelId = RGBAColorModelID.id();
    } else if (modelName == "sRGB") {
        modelId = RGBAColorModelID.id();
    } else if (modelName == "Lab") {
        modelId = LABAColorModelID.id();
    } else if (modelName == "XYZ") {
        modelId = XYZAColorModelID.id();
    } else if (modelName == "Gray") {
        modelId = GrayAColorModelID.id();
    } else if (modelName == "YCbCr") {
        modelId = YCbCrAColorModelID.id();
    }
 
    KoColorSpaceRegistry *colorSpaceRegistry = KoColorSpaceRegistry::instance();
 
    QString profileName;
    if (modelName == "sRGB") {
        const KoColorProfile *profile = colorSpaceRegistry->p709SRGBProfile();
        if (profile) {
            profileName = profile->name();
        }
    } else {
        profileName = elt.attribute("space", "");
        if (!colorSpaceRegistry->profileByName(profileName)) {
            profileName.clear();
        }
    }
 
    const KoColorSpace* cs = colorSpaceRegistry->colorSpace(modelId, channelDepthId, profileName);
    if (!cs) {
        QList<KoID> list = colorSpaceRegistry->colorDepthList(modelId, KoColorSpaceRegistry::AllColorSpaces);
        if (!list.empty()) {
            cs = colorSpaceRegistry->colorSpace(modelId, list[0].id(), profileName);
        }
    }
 
    if (!cs) {
        *ok = false;
        return KoColor();
    }
 
    KoColor c(cs);
    // TODO: Provide a way for colorFromXML() to notify the caller if parsing failed.
    //       Currently it returns default values on failure.
    cs->colorFromXML(c.data(), elt);
 
    QDomElement e = elt.nextSiblingElement("metadata");
    for (; !e.isNull(); e = e.nextSiblingElement("metadata")) {
        const QString name = e.attribute("name");
        const QString type = e.attribute("type");
        const QString value = e.attribute("value");
 
        QVariant v;
        if (type == "string") {
            v = KisDomUtils::toString(value);
        } else if (type == "int") {
            v = KisDomUtils::toInt(value);
        } else if (type == "double") {
            v = KisDomUtils::toDouble(value);
        }  else if (type == "bool") {
            v = KisDomUtils::toInt(value);
        } else {
            continue;
        }
 
        c.addMetadata(name , v);
    }
 
    return c;
}

References addMetadata(), KoColorSpaceRegistry::AllColorSpaces, CMYKAColorModelID, KoColorSpaceRegistry::colorDepthList(), KoColorSpace::colorFromXML(), KoColorSpaceRegistry::colorSpace(), data(), GrayAColorModelID, KoID::id(), KoColorSpaceRegistry::instance(), KoColor(), LABAColorModelID, KoColorProfile::name, KoColorSpaceRegistry::p709SRGBProfile(), profile(), KoColorSpaceRegistry::profileByName(), RGBAColorModelID, KisDomUtils::toDouble(), KisDomUtils::toInt(), KisDomUtils::toString(), v, value(), XYZAColorModelID, and YCbCrAColorModelID.

fromXML() [3/3]

KoColor KoColor::fromXML ( const QString & xml )

static

fromXML restores a KoColor from a string saved with toXML(). If the string does not contain the "channeldepth" attribute, 16 bit integer is assumed.

Parameters

xml	a valid XML document

Returns

a new KoColor object

Definition at line 446 of file KoColor.cpp.

{
    KoColor c;
    QDomDocument doc;
    if (!doc.setContent(xml)) {
        return c;
    }
 
    QDomElement root = doc.documentElement();
    QDomElement child = root.firstChildElement();
    QString channelDepthID = root.attribute("channeldepth", Integer16BitsColorDepthID.id());
 
    bool ok;
    if (child.hasAttribute("space") || child.tagName().toLower() == "srgb") {
        c = KoColor::fromXML(child, channelDepthID, &ok);
    } else if (root.hasAttribute("space") || root.tagName().toLower() == "srgb"){
        c = KoColor::fromXML(root, channelDepthID, &ok);
    } else {
        qWarning() << "Cannot parse color from xml" << xml;
    }
 
    return c;
}

References fromXML(), KoID::id(), and Integer16BitsColorDepthID.

metadata()

QMap< QString, QVariant > KoColor::metadata

(

)

const

Get a map with all the metadata The metadata is used by parsing functions to store extra data, like for example spot color names, or the original parsing model.

Definition at line 671 of file KoColor.cpp.

{
    return m_metadata;
}

References m_metadata.

opacityF()

qreal KoColor::opacityF

(

)

const

Definition at line 345 of file KoColor.cpp.

{
    return m_colorSpace->opacityF(m_data);
}

References m_colorSpace, m_data, and KoColorSpace::opacityF().

opacityU8()

quint8 KoColor::opacityU8

(

)

const

Convenient function that return the opacity of the color

Definition at line 341 of file KoColor.cpp.

{
    return m_colorSpace->opacityU8(m_data);
}

References m_colorSpace, m_data, and KoColorSpace::opacityU8().

operator=()

KoColor & KoColor::operator= ( const KoColor & rhs )

inline

assignment operator to copy the data from the param color into this one.

Parameters

rhs	the color we are going to copy

Returns

this color

Definition at line 64 of file KoColor.h.

                                                  {
        if (&rhs == this) {
            return *this;
        }
 
        m_colorSpace = rhs.m_colorSpace;
        m_metadata = rhs.m_metadata;
        m_size = rhs.m_size;
        memcpy(m_data, rhs.m_data, m_size);
 
        assertPermanentColorspace();
 
        return *this;
    }

References m_colorSpace, m_data, m_metadata, and m_size.

operator==()

bool KoColor::operator==

(

const KoColor &

other

)

const

Definition at line 126 of file KoColor.cpp.

                                                   {
    if (*colorSpace() != *other.colorSpace()) {
        return false;
    }
    if (m_size != other.m_size) {
        return false;
    }
    return memcmp(m_data, other.m_data, m_size) == 0;
}

References colorSpace(), m_data, and m_size.

profile()

const KoColorProfile * KoColor::profile

(

)

const

return the current profile

Definition at line 299 of file KoColor.cpp.

{
    return m_colorSpace->profile();
}

References m_colorSpace, and KoColorSpace::profile().

setColor()

void KoColor::setColor	(	const quint8 *	data,
		const KoColorSpace *	colorSpace = 0 )

Replace the existing color data, and colorspace with the specified data. The data is copied.

Definition at line 186 of file KoColor.cpp.

{
    Q_ASSERT(colorSpace);
 
    m_size = colorSpace->pixelSize();
    Q_ASSERT(m_size <= MAX_PIXEL_SIZE);
 
    memcpy(m_data, data, m_size);
    m_colorSpace = KoColorSpaceRegistry::instance()->permanentColorspace(colorSpace);
}

References colorSpace(), data(), KoColorSpaceRegistry::instance(), m_colorSpace, m_data, m_size, MAX_PIXEL_SIZE, KoColorSpaceRegistry::permanentColorspace(), and KoColorSpace::pixelSize().

setOpacity() [1/2]

void KoColor::setOpacity

(

qreal

alpha

)

Definition at line 337 of file KoColor.cpp.

{
    m_colorSpace->setOpacity(m_data, alpha, 1);
}

References m_colorSpace, m_data, and KoColorSpace::setOpacity().

setOpacity() [2/2]

void KoColor::setOpacity

(

quint8

alpha

)

Convenient function to set the opacity of the color.

Definition at line 333 of file KoColor.cpp.

{
    m_colorSpace->setOpacity(m_data, alpha, 1);
}

References m_colorSpace, m_data, and KoColorSpace::setOpacity().

setProfile()

void KoColor::setProfile

(

const KoColorProfile *

profile

)

assign new profile without converting pixel data

Definition at line 177 of file KoColor.cpp.

{
    const KoColorSpace *dstColorSpace =
            KoColorSpaceRegistry::instance()->colorSpace(colorSpace()->colorModelId().id(), colorSpace()->colorDepthId().id(), profile);
    if (!dstColorSpace) return;
 
    m_colorSpace = KoColorSpaceRegistry::instance()->permanentColorspace(dstColorSpace);
}

References colorSpace(), KoColorSpaceRegistry::colorSpace(), KoColorSpaceRegistry::instance(), m_colorSpace, KoColorSpaceRegistry::permanentColorspace(), and profile().

subtract()

void KoColor::subtract

(

const KoColor &

value

)

Channelwise subtracts value from *this and stores the result in *this

Throws a safe assert if the colorspaces of the two colors are different

Definition at line 220 of file KoColor.cpp.

{
    KIS_SAFE_ASSERT_RECOVER_RETURN(*m_colorSpace == *value.colorSpace());
 
    QVector<float> channels1(m_colorSpace->channelCount());
    QVector<float> channels2(m_colorSpace->channelCount());
 
    m_colorSpace->normalisedChannelsValue(m_data, channels1);
    m_colorSpace->normalisedChannelsValue(value.data(), channels2);
 
    for (int i = 0; i < channels1.size(); i++) {
        channels1[i] -= channels2[i];
    }
 
    m_colorSpace->fromNormalisedChannelsValue(m_data, channels1);
}

References KoColorSpace::channelCount(), KoColorSpace::fromNormalisedChannelsValue(), KIS_SAFE_ASSERT_RECOVER_RETURN, m_colorSpace, m_data, KoColorSpace::normalisedChannelsValue(), and value().

subtracted()

KoColor KoColor::subtracted

(

const KoColor &

value

)

const

Channelwise subtracts value from a copy of *this and returns the result

Throws a safe assert if the colorspaces of the two colors are different

Definition at line 237 of file KoColor.cpp.

{
    KoColor result(*this);
    result.subtract(value);
    return result;
}

References subtract(), and value().

toQColor() [1/2]

QColor KoColor::toQColor

(

)

const

a convenience method for the above.

Definition at line 206 of file KoColor.cpp.

{
    QColor c;
    toQColor(&c);
    return c;
}

References toQColor().

toQColor() [2/2]

void KoColor::toQColor

(

QColor *

c

)

const

a convenience method for the above.

Definition at line 198 of file KoColor.cpp.

{
    Q_ASSERT(c);
    if (m_colorSpace) {
        m_colorSpace->toQColor(m_data, c);
    }
}

References m_colorSpace, m_data, and KoColorSpace::toQColor().

toQString()

QString KoColor::toQString ( const KoColor & color )

static

toQString create a user-visible string of the channel names and the channel values

Parameters

color

the color to create the string from

Returns

a string that can be used to display the values of this color to the user.

Definition at line 655 of file KoColor.cpp.

{
    QStringList ls;
    Q_FOREACH (KoChannelInfo *channel, KoChannelInfo::displayOrderSorted(color.colorSpace()->channels())) {
        int realIndex = KoChannelInfo::displayPositionToChannelIndex(channel->displayPosition(), color.colorSpace()->channels());
        ls << channel->name();
        ls << color.colorSpace()->channelValueText(color.data(), realIndex);
    }
    return ls.join(" ");
}

References KoColorSpace::channels, KoColorSpace::channelValueText(), colorSpace(), data(), KoChannelInfo::displayOrderSorted(), KoChannelInfo::displayPosition(), KoChannelInfo::displayPositionToChannelIndex(), and KoChannelInfo::name().

toSVG11()

QString KoColor::toSVG11

(

QHash< QString, const KoColorProfile * > *

profileList

)

const

toSVG11

Parameters

profileList

list of profiles, this will map the profile to a name, so it may be embedded.

Returns

a color definition string with both a srgb hexcode fallback as well as a icc-color definition.

Definition at line 470 of file KoColor.cpp.

{
    QStringList colorDefinitions;
    colorDefinitions.append(toQColor().name());
 
    QVector<float> channelValues(colorSpace()->channelCount());
    channelValues.fill(0.0);
    colorSpace()->normalisedChannelsValue(data(), channelValues);
 
    bool sRGB = false;
    if (colorSpace() && colorSpace()->profile()
            && colorSpace()->profile()->getColorPrimaries() == ColorPrimaries::PRIMARIES_ITU_R_BT_709_5
            && colorSpace()->profile()->getTransferCharacteristics() != TransferCharacteristics::TRC_LINEAR) {
        sRGB = true;
    }
 
    // We don't write a icc-color definition for XYZ and 8bit sRGB.
    if (!(sRGB && colorSpace()->colorDepthId() == Integer8BitsColorDepthID) &&
            colorSpace()->colorModelId() != XYZAColorModelID) {
        QStringList iccColor;
        QString csName = colorSpace()->profile()->name();
        // remove forbidden characters
        // https://www.w3.org/TR/SVG11/types.html#DataTypeName
#if (QT_VERSION < QT_VERSION_CHECK(6, 0, 0))
        csName.remove(QRegExp("[\\(\\),\\s]"));
#else
        QRegExp reg("[\\(\\),\\s]");
        reg.removeIn(csName);
#endif
        //reuse existing name if possible. We're looking for the color profile, because svg doesn't care about depth.
        csName = profileList->key(colorSpace()->profile(), csName);
 
        if (sRGB) {
            csName = "sRGB";
        }
 
        iccColor.append(csName);
 
        if (colorSpace()->colorModelId() == LABAColorModelID) {
            QDomDocument doc;
            QDomElement el = doc.createElement("color");
            toXML(doc, el);
            QDomElement lab = el.firstChildElement();
            iccColor.append(lab.attribute("L", "0.0"));
            iccColor.append(lab.attribute("a", "0.0"));
            iccColor.append(lab.attribute("b", "0.0"));
        }
        else {
            for (int i = 0; i < channelValues.size(); i++) {
                int location = KoChannelInfo::displayPositionToChannelIndex(i, colorSpace()->channels());
                if (i != int(colorSpace()->alphaPos())) {
                    iccColor.append(QString::number(channelValues.at(location), 'g', 10));
                }
            }
        }
        colorDefinitions.append(QString("icc-color(%1)").arg(iccColor.join(", ")));
        if (!profileList->contains(csName) && !sRGB) {
            profileList->insert(csName, colorSpace()->profile());
        }
    }
 
    return colorDefinitions.join(" ");
}

References colorSpace(), data(), KoChannelInfo::displayPositionToChannelIndex(), Integer8BitsColorDepthID, LABAColorModelID, KoColorProfile::name, KoColorSpace::normalisedChannelsValue(), PRIMARIES_ITU_R_BT_709_5, profile(), KoColorSpace::profile(), toQColor(), toXML(), TRC_LINEAR, and XYZAColorModelID.

toXML() [1/2]

QString KoColor::toXML

(

)

const

toXML creates a string with XML that represents the current color. The XML is extended with a "channeldepth" attribute so we can restore the color to the same channel depth.

Returns

a valid XML document in a string

Definition at line 436 of file KoColor.cpp.

{
    QDomDocument cdataDoc = QDomDocument("color");
    QDomElement cdataRoot = cdataDoc.createElement("color");
    cdataDoc.appendChild(cdataRoot);
    cdataRoot.setAttribute("channeldepth", colorSpace()->colorDepthId().id());
    toXML(cdataDoc, cdataRoot);
    return cdataDoc.toString();
}

References colorSpace(), and toXML().

toXML() [2/2]

void KoColor::toXML	(	QDomDocument &	doc,
		QDomElement &	colorElt ) const

Serialize this color following Create's swatch color specification available at https://web.archive.org/web/20110826002520/http://create.freedesktop.org/wiki/Swatches_-_color_file_format/Draft

This function doesn't create the <color /> element but rather the <CMYK />, <sRGB />, <RGB /> ... elements. It is assumed that colorElt is the <color /> element.

Parameters

colorElt	root element for the serialization, it is assumed that this element is <color />
doc	is the document containing colorElt

Definition at line 304 of file KoColor.cpp.

{
    m_colorSpace->colorToXML(m_data, doc, colorElt);
 
    for (QString key : m_metadata.keys()) {
 
        QDomElement e = doc.createElement("metadata");
        e.setAttribute("name", QString(key.toLatin1()));
        QVariant v = m_metadata.value(key);
        e.setAttribute("type", v.typeName());
 
        QString attrName = "value";
        if(v.type() == QVariant::String ) {
            e.setAttribute(attrName, v.toString());
            e.setAttribute("type", "string");
        } else if(v.type() == QVariant::Int ) {
            e.setAttribute(attrName, v.toInt());
        } else if(v.type() == QVariant::Double ) {
            e.setAttribute(attrName, v.toDouble());
        } else  if(v.type() == QVariant::Bool ) {
            e.setAttribute(attrName, v.toBool());
        } else {
            qWarning() << "no KoColor serialization for QVariant type:" << v.type();
        }
        colorElt.appendChild(e);
    }
 
}

References KoColorSpace::colorToXML(), m_colorSpace, m_data, m_metadata, and v.

Member Data Documentation

m_colorSpace

const KoColorSpace* KoColor::m_colorSpace

private

Definition at line 320 of file KoColor.h.

m_data

quint8 KoColor::m_data[MAX_PIXEL_SIZE]

private

Definition at line 321 of file KoColor.h.

m_metadata

QMap<QString, QVariant> KoColor::m_metadata

private

Definition at line 323 of file KoColor.h.

m_size

quint8 KoColor::m_size

private

Definition at line 322 of file KoColor.h.

---

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

• libs/pigment/KoColor.h
• libs/pigment/KoColor.cpp