#include <kis_meta_data_merge_strategy_p.h>

Inheritance diagram for KisMetaData::SmartMergeStrategy:

Public Member Functions
QString	description () const override

QString	id () const override

void	merge (Store dst, QList< const Store > srcs, QList< double > score) const override

QString	name () const override

	SmartMergeStrategy ()

	~SmartMergeStrategy () override

Public Member Functions inherited from KisMetaData::MergeStrategy
virtual	~MergeStrategy ()

Protected Member Functions
Value	election (QList< const Store * > srcs, QList< double > score, const QString &key) const

void	mergeEntry (Store dst, QList< const Store > srcs, const Schema *schema, const QString &identifier) const

Detailed Description

Definition at line 50 of file kis_meta_data_merge_strategy_p.h.

Constructor & Destructor Documentation

◆ SmartMergeStrategy()

SmartMergeStrategy::SmartMergeStrategy ( )

Definition at line 148 of file kis_meta_data_merge_strategy_p.cc.

149{

150}

◆ ~SmartMergeStrategy()

SmartMergeStrategy::~SmartMergeStrategy ( )

override

Definition at line 152 of file kis_meta_data_merge_strategy_p.cc.

153{

154}

Member Function Documentation

◆ description()

QString SmartMergeStrategy::description ( ) const

overridevirtual

Returns: a description of this merge strategy

Implements KisMetaData::MergeStrategy.

Definition at line 165 of file kis_meta_data_merge_strategy_p.cc.

{
    return i18n("This merge strategy attempts to find the best solution for merging, "
                "for instance by merging the list of authors together, or keeping "
                "identical photographic information.");
}

◆ election()

Value SmartMergeStrategy::election	(	QList< const Store * >	srcs,
		QList< double >	score,
		const QString &	key ) const

protected

Definition at line 177 of file kis_meta_data_merge_strategy_p.cc.

{
    QList<ScoreValue> scoreValues;
    for (int i = 0; i < srcs.size(); i++) {
        if (srcs[i]->containsEntry(key)) {
            const Value& nv = srcs[i]->getEntry(key).value();
            if (nv.type() != Value::Invalid) {
                bool found = false;
                for (int j = 0; j < scoreValues.size(); j++) {
                    ScoreValue& sv = scoreValues[j];
                    if (sv.value == nv) {
                        found = true;
                        sv.score += scores[i];
                        break;
                    }
                }
                if (!found) {
                    ScoreValue sv;
                    sv.score = scores[i];
                    sv.value = nv;
                    scoreValues.append(sv);
                }
            }
        }
    }
    if (scoreValues.size() < 1) {
        warnMetaData << "SmartMergeStrategy::election returned less than 1 score value";
        return Value();
    }
    const ScoreValue* bestSv = 0;
    double bestScore = -1.0;
    Q_FOREACH (const ScoreValue& sv, scoreValues) {
        if (sv.score > bestScore) {
            bestScore = sv.score;
            bestSv = &sv;
        }
    }
    if (bestSv) {
        return bestSv->value;
    }
    else {
        return Value();
    }
}

References KisMetaData::Value::Invalid, ScoreValue::score, KisMetaData::Value::type(), ScoreValue::value, and warnMetaData.

◆ id()

QString SmartMergeStrategy::id ( ) const

overridevirtual

Returns: the id of this merge strategy

Implements KisMetaData::MergeStrategy.

Definition at line 156 of file kis_meta_data_merge_strategy_p.cc.

{
    return "Smart";
}

◆ merge()

void SmartMergeStrategy::merge	(	Store *	dst,
		QList< const Store * >	srcs,
		QList< double >	scores ) const

overridevirtual

Call this function to merge a list of meta data stores in one.

Parameters

dst	the destination store
srcs	the list of source meta data store
scores	a list of score which defines the importance of each store compared to the other the sum of score is expected to be equal to 1.0. One way to attribute a score is to compute the area of each layer and then to give a higher score to the biggest layer. srcs and scores list must have the same size.

Implements KisMetaData::MergeStrategy.

Definition at line 237 of file kis_meta_data_merge_strategy_p.cc.

{
    dbgMetaData << "Smart merging of meta data";
    Q_ASSERT(srcs.size() == scores.size());
    Q_ASSERT(srcs.size() > 0);
    if (srcs.size() == 1) {
        dst->copyFrom(srcs[0]);
        return;
    }
    // Initialize some schema
    const KisMetaData::Schema* dcSchema = KisMetaData::SchemaRegistry::instance()->schemaFromUri(KisMetaData::Schema::DublinCoreSchemaUri);
//     const KisMetaData::Schema* psSchema = KisMetaData::SchemaRegistry::instance()->schemaFromUri(KisMetaData::Schema::PhotoshopSchemaUri);
    const KisMetaData::Schema* XMPRightsSchema = KisMetaData::SchemaRegistry::instance()->schemaFromUri(KisMetaData::Schema::XMPRightsSchemaUri);
    const KisMetaData::Schema* XMPSchema = KisMetaData::SchemaRegistry::instance()->schemaFromUri(KisMetaData::Schema::XMPSchemaUri);
    // Sort the stores and scores
    {
        QMultiMap<double, const Store*> scores2srcs;
        for (int i = 0; i < scores.size(); ++i) {
            scores2srcs.insert(scores[i], srcs[i]);
        }
        srcs = scores2srcs.values();
        scores = scores2srcs.keys();
    }
 
    // First attempt to see if one of the store has a higher score than the others
    if (scores[0] > 2 * scores[1]) { // One of the store has a higher importance than the other ones
        dst->copyFrom(srcs[0]);
    } else {
        // Merge exif info
 
 
        // Election
        Q_FOREACH (const Store* store, srcs) {
            QList<QString> keys = store->keys();
            Q_FOREACH (const QString & key, keys) {
                if (!dst->containsEntry(key)) {
                    Value v = election(srcs, scores, key);
                    if (v.type() != Value::Invalid) {
                        dst->getEntry(key).value() = v;
                    }
                }
            }
        }
 
        // Compute rating
        double rating = 0.0;
        double norm = 0.0;
        for (int i = 0; i < srcs.size(); i++) {
            const Store* store = srcs[i];
            if (store->containsEntry(XMPSchema, "Rating")) {
                double score = scores[i];
                rating += score * store->getEntry(XMPSchema, "Rating").value().asVariant().toDouble();
                norm += score;
            }
        }
        if (norm > 0.01) {
            dst->getEntry(XMPSchema, "Rating").value() = QVariant((int)(rating / norm));
        }
    }
    // Merge the list of authors and keywords and other stuff
    mergeEntry(dst, srcs, dcSchema, "contributor");
    mergeEntry(dst, srcs, dcSchema, "creator");
    mergeEntry(dst, srcs, dcSchema, "publisher");
    mergeEntry(dst, srcs, dcSchema, "subject");
    mergeEntry(dst, srcs, XMPRightsSchema, "Owner");
    mergeEntry(dst, srcs, XMPSchema, "Identifier");
}

References KisMetaData::Value::asVariant(), KisMetaData::Store::containsEntry(), KisMetaData::Store::copyFrom(), dbgMetaData, KisMetaData::Schema::DublinCoreSchemaUri, election(), KisMetaData::Store::getEntry(), KisMetaData::SchemaRegistry::instance(), KisMetaData::Value::Invalid, KisMetaData::Store::keys(), mergeEntry(), KisMetaData::SchemaRegistry::schemaFromUri(), v, KisMetaData::Entry::value(), KisMetaData::Schema::XMPRightsSchemaUri, and KisMetaData::Schema::XMPSchemaUri.

◆ mergeEntry()

void SmartMergeStrategy::mergeEntry	(	Store *	dst,
		QList< const Store * >	srcs,
		const Schema *	schema,
		const QString &	identifier ) const

protected

Merge multiple entries in one.

Definition at line 222 of file kis_meta_data_merge_strategy_p.cc.

{
    bool foundOnce = false;
    Value v(QList<Value>(), Value::OrderedArray);
    Q_FOREACH (const Store* store, srcs) {
        if (store->containsEntry(schema, identifier)) {
            v += store->getEntry(schema, identifier).value();
            foundOnce = true;
        }
    }
    if (foundOnce) {
        dst->getEntry(schema, identifier).value() = v;
    }
}