#include <KoColorConversionSystem.h>

Inheritance diagram for KoColorConversionSystem:

Classes
struct	Node

struct	NodeKey

struct	Path

struct	RegistryInterface

struct	Vertex

Public Member Functions
QString	bestPathToDot (const QString &srcKey, const QString &dstKey) const

KoColorConversionTransformation *	createColorConverter (const KoColorSpace srcColorSpace, const KoColorSpace dstColorSpace, KoColorConversionTransformation::Intent renderingIntent, KoColorConversionTransformation::ConversionFlags conversionFlags) const

void	createColorConverters (const KoColorSpace colorSpace, const QList< QPair< KoID, KoID > > &possibilities, KoColorConversionTransformation &fromCS, KoColorConversionTransformation *&toCS) const

bool	existsGoodPath (const QString &srcModelId, const QString &srcDepthId, const QString &srcProfileName, const QString &dstModelId, const QString &dstDepthId, const QString &dstProfileName) const

bool	existsPath (const QString &srcModelId, const QString &srcDepthId, const QString &srcProfileName, const QString &dstModelId, const QString &dstDepthId, const QString &dstProfileName) const

Path	findBestPath (const NodeKey &src, const NodeKey &dst) const

Path	findBestPath (const QString &srcModelId, const QString &srcDepthId, const QString &srcProfileName, const QString &dstModelId, const QString &dstDepthId, const QString &dstProfileName) const

void	insertColorProfile (const KoColorProfile *)

void	insertColorSpace (const KoColorSpaceFactory *)

	KoColorConversionSystem (RegistryInterface *registryInterface)

	Private (RegistryInterface *_registryInterface)

QString	toDot () const

	~KoColorConversionSystem ()

Public Member Functions inherited from Private
	Private (KisCanvas2 *c)

Public Attributes
QHash< NodeKey, Node * >	graph

RegistryInterface *	registryInterface

QList< Vertex * >	vertexes

Public Attributes inherited from Private
KisCanvas2 *	canvas

int	displayedFrame

int	intendedFrame

Private Member Functions
void	connectToEngine (Node _node, Node _engine)

Node *	createNode (const QString &_modelId, const QString &_depthId, const QString &_profileName)

KoColorConversionTransformation *	createTransformationFromPath (const KoColorConversionSystem::Path &path, const KoColorSpace srcColorSpace, const KoColorSpace dstColorSpace, KoColorConversionTransformation::Intent renderingIntent, KoColorConversionTransformation::ConversionFlags conversionFlags) const

Vertex *	createVertex (Node srcNode, Node dstNode)

const KoColorSpace *	defaultColorSpaceForNode (const Node *node) const

void	deletePaths (QList< KoColorConversionSystem::Path * > paths) const

Path	findBestPath (const Node srcNode, const Node dstNode) const

Node *	insertEngine (const KoColorSpaceEngine *engine)

const Node *	nodeFor (const KoColorSpace *) const

Node *	nodeFor (const NodeKey &key)

const Node *	nodeFor (const NodeKey &key) const

Node *	nodeFor (const QString &colorModelId, const QString &colorDepthId, const QString &_profileName)

const Node *	nodeFor (const QString &colorModelId, const QString &colorDepthId, const QString &_profileName) const

QList< Node * >	nodesFor (const QString &_modelId, const QString &_depthId)

Vertex *	vertexBetween (Node srcNode, Node dstNode)

QString	vertexToDot (Vertex *v, const QString &options) const

Private Attributes
Private *const	d

Friends
uint	qHash (const KoColorConversionSystem::NodeKey &key)

Detailed Description

This class hold the logic related to pigment's Color Conversion System. It's basically a graph containing all the possible color transformation between the color spaces. The most useful functions are createColorConverter to create a color conversion between two color spaces, and insertColorSpace which is called by KoColorSpaceRegistry each time a new color space is added to the registry.

This class is not part of public API, and can be changed without notice.

Definition at line 32 of file KoColorConversionSystem.h.

Constructor & Destructor Documentation

◆ KoColorConversionSystem()

KoColorConversionSystem::KoColorConversionSystem ( RegistryInterface * registryInterface )

Construct a Color Conversion System, leave to the KoColorSpaceRegistry to create it.

Definition at line 21 of file KoColorConversionSystem.cpp.

    : d(new Private(registryInterface))
{
}

◆ ~KoColorConversionSystem()

KoColorConversionSystem::~KoColorConversionSystem ( )

Definition at line 26 of file KoColorConversionSystem.cpp.

{
    qDeleteAll(d->graph);
    qDeleteAll(d->vertexes);
    delete d;
}

References d.

Member Function Documentation

◆ bestPathToDot()

QString KoColorConversionSystem::bestPathToDot	(	const QString &	srcKey,
		const QString &	dstKey ) const

This function return a text that can be compiled using dot to display the graph of color conversion connection, with a red link to show the path of the best color conversion.

Definition at line 400 of file KoColorConversionSystem.cpp.

{
    const Node* srcNode = 0;
    const Node* dstNode = 0;
    Q_FOREACH (Node* node, d->graph) {
        if (node->id() == srcKey) {
            srcNode = node;
        }
        if (node->id() == dstKey) {
            dstNode = node;
        }
    }
    Path p = findBestPath(srcNode, dstNode);
    Q_ASSERT(!p.isEmpty());
    QString dot = "digraph CCS {\n" +
            QString("  \"%1\" [color=red]\n").arg(srcNode->id()) +
            QString("  \"%1\" [color=red]\n").arg(dstNode->id());
    Q_FOREACH (Vertex* oV, d->vertexes) {
        QString options;
        if (p.vertexes.contains(oV)) {
            options = "[color=red]";
        }
        dot += vertexToDot(oV, options) ;
    }
    dot += "}\n";
    return dot;
}

References d, findBestPath(), KoColorConversionSystem::Node::id(), p, and vertexToDot().

◆ connectToEngine()

void KoColorConversionSystem::connectToEngine	(	Node *	_node,
		Node *	_engine )

private

Initialise a node for ICC color spaces

Definition at line 33 of file KoColorConversionSystem.cpp.

{
    Vertex* v1 = createVertex(_node, _engine);
    Vertex* v2 = createVertex(_engine, _node);
 
    Q_UNUSED(v1);
    Q_UNUSED(v2);
}

References createVertex().

◆ createColorConverter()

KoColorConversionTransformation * KoColorConversionSystem::createColorConverter	(	const KoColorSpace *	srcColorSpace,
		const KoColorSpace *	dstColorSpace,
		KoColorConversionTransformation::Intent	renderingIntent,
		KoColorConversionTransformation::ConversionFlags	conversionFlags ) const

This function is called by the color space to create a color conversion between two color space. This function search in the graph of transformations the best possible path between the two color space.

Definition at line 220 of file KoColorConversionSystem.cpp.

{
    Q_ASSERT(srcColorSpace);
    Q_ASSERT(dstColorSpace);
    if (*srcColorSpace == *dstColorSpace) {
        return new KoCopyColorConversionTransformation(srcColorSpace);
    }
    dbgPigmentCCS << srcColorSpace->id() << (srcColorSpace->profile() ? srcColorSpace->profile()->name() : "default");
    dbgPigmentCCS << dstColorSpace->id() << (dstColorSpace->profile() ? dstColorSpace->profile()->name() : "default");
    Path path = findBestPath(
                nodeFor(srcColorSpace),
                nodeFor(dstColorSpace));
    Q_ASSERT(path.length() > 0);
    KoColorConversionTransformation* transfo = createTransformationFromPath(path, srcColorSpace, dstColorSpace, renderingIntent, conversionFlags);
    Q_ASSERT(transfo);
    Q_ASSERT(*transfo->srcColorSpace() == *srcColorSpace);
    Q_ASSERT(*transfo->dstColorSpace() == *dstColorSpace);
    return transfo;
}

References createTransformationFromPath(), dbgPigmentCCS, KoColorConversionTransformation::dstColorSpace, findBestPath(), KoColorSpace::id, KoColorProfile::name, nodeFor(), KoColorSpace::profile(), and KoColorConversionTransformation::srcColorSpace.

◆ createColorConverters()

void KoColorConversionSystem::createColorConverters	(	const KoColorSpace *	colorSpace,
		const QList< QPair< KoID, KoID > > &	possibilities,
		KoColorConversionTransformation *&	fromCS,
		KoColorConversionTransformation *&	toCS ) const

This function creates two transformations, one from the color space and one to the color space. The destination color space is picked from a list of color space, such as the conversion between the two color space is of the best quality.

The typical use case of this function is for KoColorTransformationFactory which doesn't support all color spaces, so unsupported color space have to find an acceptable conversion in order to use that KoColorTransformationFactory.

Parameters

colorSpace	the source color space
possibilities	a list of color space among which we need to find the best conversion
fromCS	the conversion from the source color space will be affected to this variable
toCS	the revert conversion to the source color space will be affected to this variable

Definition at line 240 of file KoColorConversionSystem.cpp.

{
    // TODO This function currently only select the best conversion only based on the transformation
    // from colorSpace to one of the color spaces in the list, but not the other way around
    // it might be worth to look also the return path.
    const Node* csNode = nodeFor(colorSpace);
    PathQualityChecker pQC(csNode->referenceDepth);
    // Look for a color conversion
    Path bestPath;
    typedef QPair<KoID, KoID> KoID2KoID;
    Q_FOREACH (const KoID2KoID & possibility, possibilities) {
        const KoColorSpaceFactory* csf = d->registryInterface->colorSpaceFactory(possibility.first.id(), possibility.second.id());
        if (csf) {
            Path path = findBestPath(csNode, nodeFor(csf->colorModelId().id(), csf->colorDepthId().id(), csf->defaultProfile()));
            Q_ASSERT(path.length() > 0);
            path.isGood = pQC.isGoodPath(path);
 
            if (bestPath.isEmpty()) {
                bestPath = path;
            } else if ((!bestPath.isGood &&  path.isGood) || pQC.lessWorseThan(path, bestPath)) {
                bestPath = path;
            }
        }
    }
    Q_ASSERT(!bestPath.isEmpty());
    const KoColorSpace* endColorSpace = defaultColorSpaceForNode(bestPath.endNode());
    fromCS = createTransformationFromPath(bestPath, colorSpace, endColorSpace, KoColorConversionTransformation::internalRenderingIntent(), KoColorConversionTransformation::internalConversionFlags());
    Path returnPath = findBestPath(bestPath.endNode(), csNode);
    Q_ASSERT(!returnPath.isEmpty());
    toCS = createTransformationFromPath(returnPath, endColorSpace, colorSpace, KoColorConversionTransformation::internalRenderingIntent(), KoColorConversionTransformation::internalConversionFlags());
    Q_ASSERT(*toCS->dstColorSpace() == *fromCS->srcColorSpace());
    Q_ASSERT(*fromCS->dstColorSpace() == *toCS->srcColorSpace());
}

References KoColorSpaceFactory::colorDepthId(), KoColorSpaceFactory::colorModelId(), createTransformationFromPath(), d, defaultColorSpaceForNode(), KoColorSpaceFactory::defaultProfile(), KoColorConversionTransformation::dstColorSpace, KoColorConversionSystem::Path::endNode(), findBestPath(), KoID::id(), KoColorConversionTransformation::internalConversionFlags(), KoColorConversionTransformation::internalRenderingIntent(), KoColorConversionSystem::Path::isEmpty(), KoColorConversionSystem::Path::isGood, PathQualityChecker::isGoodPath(), PathQualityChecker::lessWorseThan(), nodeFor(), KoColorConversionSystem::Node::referenceDepth, and KoColorConversionTransformation::srcColorSpace.

◆ createNode()

KoColorConversionSystem::Node * KoColorConversionSystem::createNode	(	const QString &	_modelId,
		const QString &	_depthId,
		const QString &	_profileName )

private

Create a new node

Definition at line 165 of file KoColorConversionSystem.cpp.

{
    Node* n = new Node;
    n->modelId = _modelId;
    n->depthId = _depthId;
    n->profileName = _profileName;
    d->graph.insert(NodeKey(_modelId, _depthId, _profileName), n);
    return n;
}

References d, KoColorConversionSystem::Node::depthId, KoColorConversionSystem::Node::modelId, and KoColorConversionSystem::Node::profileName.

◆ createTransformationFromPath()

KoColorConversionTransformation * KoColorConversionSystem::createTransformationFromPath	(	const KoColorConversionSystem::Path &	path,
		const KoColorSpace *	srcColorSpace,
		const KoColorSpace *	dstColorSpace,
		KoColorConversionTransformation::Intent	renderingIntent,
		KoColorConversionTransformation::ConversionFlags	conversionFlags ) const

private

Definition at line 274 of file KoColorConversionSystem.cpp.

{
    Q_ASSERT(srcColorSpace->colorModelId().id() == path.startNode()->modelId);
    Q_ASSERT(srcColorSpace->colorDepthId().id() == path.startNode()->depthId);
    Q_ASSERT(dstColorSpace->colorModelId().id() == path.endNode()->modelId);
    Q_ASSERT(dstColorSpace->colorDepthId().id() == path.endNode()->depthId);
 
    KoColorConversionTransformation* transfo;
 
    const QList< Path::node2factory > pathOfNode = path.compressedPath();
 
    if (pathOfNode.size() == 2) { // Direct connection
        transfo = pathOfNode[1].second->createColorTransformation(srcColorSpace, dstColorSpace, renderingIntent, conversionFlags);
    }
    else {
 
        KoMultipleColorConversionTransformation* mccTransfo = new KoMultipleColorConversionTransformation(srcColorSpace, dstColorSpace, renderingIntent, conversionFlags);
 
        transfo = mccTransfo;
 
        // Get the first intermediary color space
        dbgPigmentCCS << pathOfNode[ 0 ].first->id() << " to " << pathOfNode[ 1 ].first->id();
 
        const KoColorSpace* intermCS =
                defaultColorSpaceForNode(pathOfNode[1].first);
 
        mccTransfo->appendTransfo(pathOfNode[1].second->createColorTransformation(srcColorSpace, intermCS, renderingIntent, conversionFlags));
 
        for (int i = 2; i < pathOfNode.size() - 1; i++) {
            dbgPigmentCCS << pathOfNode[ i - 1 ].first->id() << " to " << pathOfNode[ i ].first->id();
            const KoColorSpace* intermCS2 = defaultColorSpaceForNode(pathOfNode[i].first);
            Q_ASSERT(intermCS2);
            mccTransfo->appendTransfo(pathOfNode[i].second->createColorTransformation(intermCS, intermCS2, renderingIntent, conversionFlags));
            intermCS = intermCS2;
        }
 
        dbgPigmentCCS << pathOfNode[ pathOfNode.size() - 2 ].first->id() << " to " << pathOfNode[ pathOfNode.size() - 1 ].first->id();
        mccTransfo->appendTransfo(pathOfNode.last().second->createColorTransformation(intermCS, dstColorSpace, renderingIntent, conversionFlags));
    }
    return transfo;
}

References KoMultipleColorConversionTransformation::appendTransfo(), KoColorSpace::colorDepthId(), KoColorSpace::colorModelId(), dbgPigmentCCS, defaultColorSpaceForNode(), and KoID::id().

◆ createVertex()

KoColorConversionSystem::Vertex * KoColorConversionSystem::createVertex	(	Node *	srcNode,
		Node *	dstNode )

private

create a vertex between two nodes and return it.

Definition at line 327 of file KoColorConversionSystem.cpp.

{
    Vertex* v = new Vertex(srcNode, dstNode);
    srcNode->outputVertexes.append(v);
    d->vertexes.append(v);
    return v;
}

References d, KoColorConversionSystem::Node::outputVertexes, and v.

◆ defaultColorSpaceForNode()

const KoColorSpace * KoColorConversionSystem::defaultColorSpaceForNode ( const Node * node ) const

private

Query the registry to get the color space associated with this node. (default profile)

Definition at line 160 of file KoColorConversionSystem.cpp.

{
    return d->registryInterface->colorSpace(node->modelId, node->depthId, node->profileName);
}

References d, KoColorConversionSystem::Node::depthId, KoColorConversionSystem::Node::modelId, and KoColorConversionSystem::Node::profileName.

◆ deletePaths()

void KoColorConversionSystem::deletePaths ( QList< KoColorConversionSystem::Path * > paths ) const

private

Delete all the paths of the list given in argument.

◆ existsGoodPath()

bool KoColorConversionSystem::existsGoodPath	(	const QString &	srcModelId,
		const QString &	srcDepthId,
		const QString &	srcProfileName,
		const QString &	dstModelId,
		const QString &	dstDepthId,
		const QString &	dstProfileName ) const

Returns: true if there is a good path between two color spaces

Definition at line 365 of file KoColorConversionSystem.cpp.

{
    const Node* srcNode = nodeFor(srcModelId, srcDepthId, srcProfileName);
    const Node* dstNode = nodeFor(dstModelId, dstDepthId, dstProfileName);
    if (srcNode == dstNode) return true;
    if (!srcNode) return false;
    if (!dstNode) return false;
    Path path = findBestPath(srcNode, dstNode);
    bool existAndGood = path.isGood;
    return existAndGood;
}

References findBestPath(), and nodeFor().

◆ existsPath()

bool KoColorConversionSystem::existsPath	(	const QString &	srcModelId,
		const QString &	srcDepthId,
		const QString &	srcProfileName,
		const QString &	dstModelId,
		const QString &	dstDepthId,
		const QString &	dstProfileName ) const

Returns: true if there is a path between two color spaces

Definition at line 352 of file KoColorConversionSystem.cpp.

{
    dbgPigmentCCS << "srcModelId = " << srcModelId << " srcDepthId = " << srcDepthId << " srcProfileName = " << srcProfileName << " dstModelId = " << dstModelId << " dstDepthId = " << dstDepthId << " dstProfileName = " << dstProfileName;
    const Node* srcNode = nodeFor(srcModelId, srcDepthId, srcProfileName);
    const Node* dstNode = nodeFor(dstModelId, dstDepthId, dstProfileName);
    if (srcNode == dstNode) return true;
    if (!srcNode) return false;
    if (!dstNode) return false;
    Path path = findBestPath(srcNode, dstNode);
    bool exist = !path.isEmpty();
    return exist;
}

References dbgPigmentCCS, findBestPath(), and nodeFor().

◆ findBestPath() [1/3]

KoColorConversionSystem::Path KoColorConversionSystem::findBestPath	(	const Node *	srcNode,
		const Node *	dstNode ) const

private

looks for the best path between two nodes

Definition at line 428 of file KoColorConversionSystem.cpp.

{
    KIS_ASSERT(srcNode);
    KIS_ASSERT(dstNode);
 
    dbgPigmentCCS << "Find best path between " << srcNode->id() << " and  " << dstNode->id();
 
    PathQualityChecker pQC(qMin(srcNode->referenceDepth, dstNode->referenceDepth));
    Node2PathHash node2path; // current best path to reach a given node
    QList<Path> possiblePaths; // list of all paths
    // Generate the initial list of paths
    Q_FOREACH (Vertex* v, srcNode->outputVertexes) {
        if (v->dstNode->isInitialized) {
            Path p;
            p.appendVertex(v);
            Node* endNode = v->dstNode;
            if (endNode == dstNode) {
                Q_ASSERT(pQC.isGoodPath(p));  // <- it's a direct link, it has to be a good path
                p.isGood = true;
                return p;
            } else {
                //Q_ASSERT(!node2path.contains(endNode));   // That would be a total fuck up if there are two vertices between two nodes
                node2path.insert(endNode, p);
                possiblePaths.append(p);
            }
        }
    }
 
    Path currentBestPath;
    // Continue while there are any possibilities remaining
    while (possiblePaths.size() > 0) {
 
        // Loop through all paths and explore one step further
        const QList<Path> currentPaths = possiblePaths;
        for (const Path &p : currentPaths) {
            const Node* endNode = p.endNode();
            for (Vertex* v : endNode->outputVertexes) {
                if (v->dstNode->isInitialized && !p.contains(v->dstNode)) {
                    Path newP = p;  // Candidate
                    newP.appendVertex(v);
                    Node* newEndNode = v->dstNode;
                    if (newEndNode == dstNode) {
                        if (pQC.isGoodPath(newP)) { // Victory
                            newP.isGood = true;
                            return newP;
                        } else if (pQC.lessWorseThan(newP, currentBestPath)) {
                            if (newP.startNode() && newP.endNode() && currentBestPath.startNode() && currentBestPath.endNode()) {
                                Q_ASSERT(newP.startNode()->id() == currentBestPath.startNode()->id());
                                Q_ASSERT(newP.endNode()->id() == currentBestPath.endNode()->id());
                                // Can we do better than dumping memory values???
                                // warnPigment << pQC.lessWorseThan(newP, currentBestPath) << " " << newP << "  " << currentBestPath;
                                currentBestPath = newP;
                            }
                        }
                    } else {
                        // This is an incomplete path. Check if there's a better way to get to its endpoint.
                        Node2PathHash::Iterator it = node2path.find(newEndNode);
                        if (it != node2path.end()) {
                            Path &p2 = it.value();
                            if (pQC.lessWorseThan(newP, p2)) {
                                p2 = newP;
                                possiblePaths.append(newP);
                            }
                        } else {
                            node2path.insert(newEndNode, newP);
                            possiblePaths.append(newP);
                        }
                    }
                }
            }
            possiblePaths.removeAll(p); // Remove from list of remaining paths
        }
    }
 
    if (!currentBestPath.isEmpty()) {
        warnPigment << "No good path from " << srcNode->id() << " to " << dstNode->id() << " found : length = " << currentBestPath.length() << " cost = " << currentBestPath.cost << " referenceDepth = " << currentBestPath.referenceDepth << " respectColorCorrectness = " << " isGood = " << currentBestPath.isGood ;
        return currentBestPath;
    }
    errorPigment << "No path from " << srcNode->id() << " to " << dstNode->id() << " found not ";
    return currentBestPath;
}

◆ findBestPath() [2/3]

KoColorConversionSystem::Path KoColorConversionSystem::findBestPath	(	const NodeKey &	src,
		const NodeKey &	dst ) const

Returns: the best path for the specified color spaces. Used for testing purposes only

Definition at line 388 of file KoColorConversionSystem.cpp.

{
    const Node *srcNode = nodeFor(src);
    const Node *dstNode = nodeFor(dst);
 
    KIS_ASSERT(srcNode);
    KIS_ASSERT(dstNode);
 
    return findBestPath(srcNode, dstNode);
}

References findBestPath(), KIS_ASSERT, and nodeFor().

◆ findBestPath() [3/3]

KoColorConversionSystem::Path KoColorConversionSystem::findBestPath	(	const QString &	srcModelId,
		const QString &	srcDepthId,
		const QString &	srcProfileName,
		const QString &	dstModelId,
		const QString &	dstDepthId,
		const QString &	dstProfileName ) const

Returns: the best path for the specified color spaces. Used for testing purposes only

Definition at line 377 of file KoColorConversionSystem.cpp.

{
    const Node *srcNode = nodeFor(srcModelId, srcDepthId, srcProfileName);
    const Node *dstNode = nodeFor(dstModelId, dstDepthId, dstProfileName);
 
    KIS_ASSERT(srcNode);
    KIS_ASSERT(dstNode);
 
    return findBestPath(srcNode, dstNode);
}

References findBestPath(), KIS_ASSERT, and nodeFor().

◆ insertColorProfile()

void KoColorConversionSystem::insertColorProfile ( const KoColorProfile * _profile )

Definition at line 116 of file KoColorConversionSystem.cpp.

{
    dbgPigmentCCS << _profile->name();
    const QList< const KoColorSpaceFactory* >& factories = d->registryInterface->colorSpacesFor(_profile);
    Q_FOREACH (const KoColorSpaceFactory* factory, factories) {
        QString modelId = factory->colorModelId().id();
        QString depthId = factory->colorDepthId().id();
        Node* n = nodeFor(modelId, depthId, _profile->name());
        n->init(factory);
        if (!factory->colorSpaceEngine().isEmpty()) {
            KoColorSpaceEngine* engine = KoColorSpaceEngineRegistry::instance()->get(factory->colorSpaceEngine());
            Q_ASSERT(engine);
            Node* engineNode = d->graph[ NodeKey(engine->id(), engine->id(), engine->id())];
            Q_ASSERT(engineNode);
 
            if (engine->supportsColorSpace(modelId, depthId, _profile)) {
                connectToEngine(n, engineNode);
            }
        }
        const QList<KoColorConversionTransformationFactory*> cctfs = factory->colorConversionLinks();
        Q_FOREACH (KoColorConversionTransformationFactory* cctf, cctfs) {
            Node* srcNode = nodeFor(cctf->srcColorModelId(), cctf->srcColorDepthId(), cctf->srcProfile());
            Q_ASSERT(srcNode);
            Node* dstNode = nodeFor(cctf->dstColorModelId(), cctf->dstColorDepthId(), cctf->dstProfile());
            Q_ASSERT(dstNode);
            if (srcNode == n || dstNode == n) {
                // Check if the two nodes are already connected
                Vertex* v = vertexBetween(srcNode, dstNode);
                // If the vertex doesn't already exist, then create it
                if (!v) {
                    v = createVertex(srcNode, dstNode);
                }
                Q_ASSERT(v); // we should have one now
                if (dstNode->modelId == modelId && dstNode->depthId == depthId) {
                    v->setFactoryFromDst(cctf);
                }
                if (srcNode->modelId == modelId && srcNode->depthId == depthId) {
                    v->setFactoryFromSrc(cctf);
                }
            }
        }
    }
}

References KoColorSpaceFactory::colorConversionLinks(), KoColorSpaceFactory::colorDepthId(), KoColorSpaceFactory::colorModelId(), KoColorSpaceFactory::colorSpaceEngine(), connectToEngine(), createVertex(), d, dbgPigmentCCS, KoColorConversionSystem::Node::depthId, KoColorConversionTransformationFactory::dstColorDepthId(), KoColorConversionTransformationFactory::dstColorModelId(), KoColorConversionTransformationFactory::dstProfile, KoGenericRegistry< T >::get(), KoID::id(), KoColorSpaceEngine::id, KoColorConversionSystem::Node::init(), KoColorSpaceEngineRegistry::instance(), KoColorConversionSystem::Node::modelId, KoColorProfile::name, nodeFor(), KoColorConversionTransformationFactory::srcColorDepthId(), KoColorConversionTransformationFactory::srcColorModelId(), KoColorConversionTransformationFactory::srcProfile, KoColorSpaceEngine::supportsColorSpace(), v, and vertexBetween().

◆ insertColorSpace()

void KoColorConversionSystem::insertColorSpace ( const KoColorSpaceFactory * csf )

This function is called by the KoColorSpaceRegistry to add a new color space to the graph of transformation.

Definition at line 56 of file KoColorConversionSystem.cpp.

{
    dbgPigment << "Inserting color space " << csf->name() << " (" << csf->id() << ") Model: " << csf->colorModelId() << " Depth: " << csf->colorDepthId() << " into the CCS";
    const QList<const KoColorProfile*> profiles = d->registryInterface->profilesFor(csf);
    QString modelId = csf->colorModelId().id();
    QString depthId = csf->colorDepthId().id();
    if (profiles.isEmpty()) { // There is no profile for this CS, create a node without profile name if the color engine isn't icc-based
        if (csf->colorSpaceEngine() != "icc") {
            Node* n = nodeFor(modelId, depthId, "default");
            n->init(csf);
        }
        else {
            dbgPigment << "Cannot add node for " << csf->name() << ", since there are no profiles available";
        }
    } else {
        // Initialise the nodes
        Q_FOREACH (const KoColorProfile* profile, profiles) {
            Node* n = nodeFor(modelId, depthId, profile->name());
            n->init(csf);
            if (!csf->colorSpaceEngine().isEmpty()) {
                KoColorSpaceEngine* engine = KoColorSpaceEngineRegistry::instance()->get(csf->colorSpaceEngine());
                Q_ASSERT(engine);
                NodeKey engineKey(engine->id(), engine->id(), engine->id());
                Node* engineNode = 0;
                QHash<NodeKey, Node*>::ConstIterator it = d->graph.constFind(engineKey);
                if (it != d->graph.constEnd()) {
                    engineNode = it.value();
                } else {
                    engineNode = insertEngine(engine);
                }
 
                if (engine->supportsColorSpace(modelId, depthId, profile)) {
                    connectToEngine(n, engineNode);
                }
            }
        }
    }
    // Construct a link for "custom" transformation
    const QList<KoColorConversionTransformationFactory*> cctfs = csf->colorConversionLinks();
    Q_FOREACH (KoColorConversionTransformationFactory* cctf, cctfs) {
        Node* srcNode = nodeFor(cctf->srcColorModelId(), cctf->srcColorDepthId(), cctf->srcProfile());
        Q_ASSERT(srcNode);
        Node* dstNode = nodeFor(cctf->dstColorModelId(), cctf->dstColorDepthId(), cctf->dstProfile());
        Q_ASSERT(dstNode);
        // Check if the two nodes are already connected
        Vertex* v = vertexBetween(srcNode, dstNode);
        // If the vertex doesn't already exist, then create it
        if (!v) {
            v = createVertex(srcNode, dstNode);
        }
        Q_ASSERT(v); // we should have one now
        if (dstNode->modelId == modelId && dstNode->depthId == depthId) {
            v->setFactoryFromDst(cctf);
        }
        if (srcNode->modelId == modelId && srcNode->depthId == depthId) {
            v->setFactoryFromSrc(cctf);
        }
    }
}

References KoColorSpaceFactory::colorConversionLinks(), KoColorSpaceFactory::colorDepthId(), KoColorSpaceFactory::colorModelId(), KoColorSpaceFactory::colorSpaceEngine(), connectToEngine(), createVertex(), d, dbgPigment, KoColorConversionSystem::Node::depthId, KoColorConversionTransformationFactory::dstColorDepthId(), KoColorConversionTransformationFactory::dstColorModelId(), KoColorConversionTransformationFactory::dstProfile, KoGenericRegistry< T >::get(), KoID::id(), KoColorSpaceEngine::id, KoColorSpaceFactory::id(), KoColorConversionSystem::Node::init(), insertEngine(), KoColorSpaceEngineRegistry::instance(), KoColorConversionSystem::Node::modelId, KoColorProfile::name, KoColorSpaceFactory::name(), nodeFor(), KoColorConversionTransformationFactory::srcColorDepthId(), KoColorConversionTransformationFactory::srcColorModelId(), KoColorConversionTransformationFactory::srcProfile, KoColorSpaceEngine::supportsColorSpace(), v, and vertexBetween().

◆ insertEngine()

KoColorConversionSystem::Node * KoColorConversionSystem::insertEngine ( const KoColorSpaceEngine * engine )

private

Insert an engine.

Definition at line 42 of file KoColorConversionSystem.cpp.

{
    NodeKey key(engine->id(), engine->id(), engine->id());
    Node* n = new Node;
    n->modelId = engine->id();
    n->depthId = engine->id();
    n->profileName = engine->id();
    n->referenceDepth = 64; // engine don't have reference depth,
    d->graph.insert(key, n);
    n->init(engine);
    return n;
}

References d, KoColorConversionSystem::Node::depthId, KoColorSpaceEngine::id, KoColorConversionSystem::Node::init(), KoColorConversionSystem::Node::modelId, KoColorConversionSystem::Node::profileName, and KoColorConversionSystem::Node::referenceDepth.

◆ nodeFor() [1/5]

const KoColorConversionSystem::Node * KoColorConversionSystem::nodeFor ( const KoColorSpace * _colorSpace ) const

private

Definition at line 175 of file KoColorConversionSystem.cpp.

{
    const KoColorProfile* profile = _colorSpace->profile();
    return nodeFor(_colorSpace->colorModelId().id(), _colorSpace->colorDepthId().id(),
                   profile ? profile->name() : "default");
}

References KoColorSpace::colorDepthId(), KoColorSpace::colorModelId(), KoID::id(), KoColorProfile::name, nodeFor(), and KoColorSpace::profile().

◆ nodeFor() [2/5]

KoColorConversionSystem::Node * KoColorConversionSystem::nodeFor ( const NodeKey & key )

private

Returns: the node corresponding to that key, or create it if needed

Definition at line 199 of file KoColorConversionSystem.cpp.

{
    QHash<NodeKey, Node*>::ConstIterator it = d->graph.constFind(key);
    if (it != d->graph.constEnd()) {
        return it.value();
    } else {
        return createNode(key.modelId, key.depthId, key.profileName);
    }
}

References createNode(), d, KoColorConversionSystem::NodeKey::depthId, KoColorConversionSystem::NodeKey::modelId, and KoColorConversionSystem::NodeKey::profileName.

◆ nodeFor() [3/5]

const KoColorConversionSystem::Node * KoColorConversionSystem::nodeFor ( const NodeKey & key ) const

private

Definition at line 188 of file KoColorConversionSystem.cpp.

{
    dbgPigmentCCS << "Look for node: " << key.modelId << " " << key.depthId << " " << key.profileName << " " << d->graph.value(key);
    return d->graph.value(key);
}

References d, dbgPigmentCCS, KoColorConversionSystem::NodeKey::depthId, KoColorConversionSystem::NodeKey::modelId, and KoColorConversionSystem::NodeKey::profileName.

◆ nodeFor() [4/5]

KoColorConversionSystem::Node * KoColorConversionSystem::nodeFor	(	const QString &	colorModelId,
		const QString &	colorDepthId,
		const QString &	_profileName )

private

Returns: the node associated with that key, and create it if needed

Definition at line 194 of file KoColorConversionSystem.cpp.

{
    return nodeFor(NodeKey(_colorModelId, _colorDepthId, _profileName));
}

References nodeFor().

◆ nodeFor() [5/5]

const KoColorConversionSystem::Node * KoColorConversionSystem::nodeFor	(	const QString &	colorModelId,
		const QString &	colorDepthId,
		const QString &	_profileName ) const

private

Definition at line 182 of file KoColorConversionSystem.cpp.

{
    dbgPigmentCCS << "Look for node: " << _colorModelId << " " << _colorDepthId << " " << _profileName;
    return nodeFor(NodeKey(_colorModelId, _colorDepthId, _profileName));
}

References dbgPigmentCCS, and nodeFor().

◆ nodesFor()

QList< KoColorConversionSystem::Node * > KoColorConversionSystem::nodesFor	(	const QString &	_modelId,
		const QString &	_depthId )

private

Returns: the list of nodes that correspond to a given model and depth.

Definition at line 209 of file KoColorConversionSystem.cpp.

{
    QList<Node*> nodes;
    Q_FOREACH (Node* node, d->graph) {
        if (node->modelId == _modelId &&  node->depthId == _depthId) {
            nodes << node;
        }
    }
    return nodes;
}

References d, KoColorConversionSystem::Node::depthId, and KoColorConversionSystem::Node::modelId.

◆ Private()

KoColorConversionSystem::Private ( RegistryInterface * _registryInterface )

inline

Definition at line 326 of file KoColorConversionSystem_p.h.

326: registryInterface(_registryInterface) {}

◆ toDot()

QString KoColorConversionSystem::toDot ( ) const

This function return a text that can be compiled using dot to display the graph of color conversion connection.

Definition at line 342 of file KoColorConversionSystem.cpp.

{
    QString dot = "digraph CCS {\n";
    Q_FOREACH (Vertex* oV, d->vertexes) {
        dot += vertexToDot(oV, "default") ;
    }
    dot += "}\n";
    return dot;
}

References d, and vertexToDot().

◆ vertexBetween()

KoColorConversionSystem::Vertex * KoColorConversionSystem::vertexBetween	(	KoColorConversionSystem::Node *	srcNode,
		KoColorConversionSystem::Node *	dstNode )

private

Returns: the vertex between two nodes, or null if the vertex doesn't exist

Definition at line 317 of file KoColorConversionSystem.cpp.

{
    Q_FOREACH (Vertex* oV, srcNode->outputVertexes) {
        if (oV->dstNode == dstNode) {
            return oV;
        }
    }
    return 0;
}

References KoColorConversionSystem::Vertex::dstNode, and KoColorConversionSystem::Node::outputVertexes.

◆ vertexToDot()

QString KoColorConversionSystem::vertexToDot	(	KoColorConversionSystem::Vertex *	v,
		const QString &	options ) const

private

Definition at line 337 of file KoColorConversionSystem.cpp.

{
    return QString("  \"%1\" -> \"%2\" %3\n").arg(v->srcNode->id()).arg(v->dstNode->id()).arg(options);
}

References v.

Friends And Related Symbol Documentation

◆ qHash

uint qHash ( const KoColorConversionSystem::NodeKey & key )

friend

Definition at line 319 of file KoColorConversionSystem_p.h.

{
    return qHash(key.modelId) + qHash(key.depthId);
}

Member Data Documentation

◆ d

Private* const KoColorConversionSystem::d

private

Definition at line 176 of file KoColorConversionSystem.h.

◆ graph

QHash<NodeKey, Node*> KoColorConversionSystem::graph

Definition at line 328 of file KoColorConversionSystem_p.h.

◆ registryInterface

RegistryInterface* KoColorConversionSystem::registryInterface

Definition at line 330 of file KoColorConversionSystem_p.h.

◆ vertexes

QList<Vertex*> KoColorConversionSystem::vertexes

Definition at line 329 of file KoColorConversionSystem_p.h.

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

libs/pigment/KoColorConversionSystem.h
libs/pigment/KoColorConversionSystem_p.h
libs/pigment/KoColorConversionSystem.cpp

Classes

Public Member Functions

Public Attributes

Private Member Functions

Private Attributes

Friends

Detailed Description

Constructor & Destructor Documentation

◆ KoColorConversionSystem()

◆ ~KoColorConversionSystem()

Member Function Documentation

◆ bestPathToDot()

◆ connectToEngine()

◆ createColorConverter()

◆ createColorConverters()

◆ createNode()

◆ createTransformationFromPath()

◆ createVertex()

◆ defaultColorSpaceForNode()

◆ deletePaths()

◆ existsGoodPath()

◆ existsPath()

◆ findBestPath() [1/3]

◆ findBestPath() [2/3]

◆ findBestPath() [3/3]

◆ insertColorProfile()

◆ insertColorSpace()

◆ insertEngine()

◆ nodeFor() [1/5]

◆ nodeFor() [2/5]

◆ nodeFor() [3/5]

◆ nodeFor() [4/5]

◆ nodeFor() [5/5]

◆ nodesFor()

◆ Private()

◆ toDot()

◆ vertexBetween()

◆ vertexToDot()

Friends And Related Symbol Documentation

◆ qHash

Member Data Documentation

◆ d

◆ graph

◆ registryInterface

◆ vertexes