diff --git a/openbr/core/core.cpp b/openbr/core/core.cpp
index 5365503..d2f8553 100644
--- a/openbr/core/core.cpp
+++ b/openbr/core/core.cpp
@@ -463,7 +463,7 @@ void br::Convert(const File &fileType, const File &inputFile, const File &output
 
         if ((targetFiles.size() != m.cols || queryFiles.size() != m.rows)
             && (m.cols != 1 || targetFiles.size() != m.rows || queryFiles.size() != m.rows))
-            qFatal("Similarity matrix and file size mismatch.");
+            qFatal("Similarity matrix (%d, %d) and header (%d, %d) size mismatch.", m.rows, m.cols, queryFiles.size(), targetFiles.size());
 
         QSharedPointer<Output> o(Factory<Output>::make(outputFile));
         o->initialize(targetFiles, queryFiles);
diff --git a/openbr/core/fuse.cpp b/openbr/core/fuse.cpp
index f2a6e53..146fa90 100644
--- a/openbr/core/fuse.cpp
+++ b/openbr/core/fuse.cpp
@@ -30,6 +30,9 @@ using namespace cv;
 
 static void normalizeMatrix(Mat &matrix, const Mat &mask, const QString &method)
 {
+    if (matrix.rows != mask.rows && matrix.cols != mask.cols)
+        qFatal("Similarity matrix (%d, %d) and mask (%d, %d) size mismatch.", matrix.rows, matrix.cols, mask.rows, mask.cols);
+
     if (method == "None") return;
 
     QList<float> vals; vals.reserve(matrix.rows*matrix.cols);
diff --git a/openbr/openbr_plugin.h b/openbr/openbr_plugin.h
index 6cb0189..033b618 100644
--- a/openbr/openbr_plugin.h
+++ b/openbr/openbr_plugin.h
@@ -483,7 +483,7 @@ struct TemplateList : public QList<Template>
     }
 
     /*!
-     * \brief Returns a #br::TemplateList containing templates with one matrix at the specified index \em index.
+     * \brief Returns a list of #br::TemplateList containing templates with a each TemplateList containing the number of matrices specified by \em partitionSizes.
      */
     QList<TemplateList> partition(const QList<int> &partitionSizes) const
     {
diff --git a/openbr/plugins/distance.cpp b/openbr/plugins/distance.cpp
index 2c899ea..3038820 100644
--- a/openbr/plugins/distance.cpp
+++ b/openbr/plugins/distance.cpp
@@ -187,47 +187,61 @@ class OperationDistance : public Distance
 {
     Q_OBJECT
     Q_ENUMS(Operation)
-    Q_PROPERTY(br::Distance* distance READ get_distance WRITE set_distance RESET reset_distance STORED false)
+    Q_PROPERTY(QString description READ get_description WRITE set_description RESET reset_description STORED false)
     Q_PROPERTY(Operation operation READ get_operation WRITE set_operation RESET reset_operation STORED false)
+    Q_PROPERTY(QList<int> split READ get_split WRITE set_split RESET reset_split STORED false)
+
+    QList<br::Distance*> distances;
 
 public:
     /*!< */
     enum Operation {Mean, Sum, Max, Min};
 
 private:
-    BR_PROPERTY(br::Distance*, distance, make("Dist(L2)"))
+    BR_PROPERTY(QString, description, "IdenticalDistance")
     BR_PROPERTY(Operation, operation, Mean)
+    BR_PROPERTY(QList<int>, split, QList<int>())
 
     void train(const TemplateList &src)
     {
-        distance->train(src);
+        // Default is to train on each matrix
+        if (split.isEmpty()) for (int i=0; i<src.at(0).size(); i++) split.append(1);
+
+        QList<TemplateList> partitionedSrc = src.partition(split);
+
+        while (distances.size() < partitionedSrc.size())
+            distances.append(make(description));
+
+        // Train on each of the partitions
+        for (int i=0; i<distances.size(); i++)
+            distances[i]->train(partitionedSrc[i]);
     }
 
     float compare(const Template &a, const Template &b) const
     {
         if (a.size() != b.size()) qFatal("Comparison size mismatch");
 
-        QList<float> distances;
-        for (int i = 0; i < a.size(); i++) {
+        QList<float> scores;
+        for (int i=0; i<distances.size(); i++) {
             Template ai = a.file;
-            ai.m() = a[i].clone();
+            ai.m() = a[i];
             Template bi = b.file;
-            bi.m() = b[i].clone();
-            distances.append(distance->compare(ai,bi));
+            bi.m() = b[i];
+            scores.append(distances[i]->compare(ai,bi));
         }
 
         switch (operation) {
           case Mean:
-            return std::accumulate(distances.begin(),distances.end(),0.0)/(float)distances.size();
+            return std::accumulate(scores.begin(),scores.end(),0.0)/(float)scores.size();
             break;
           case Sum:
-            return std::accumulate(distances.begin(),distances.end(),0.0);
+            return std::accumulate(scores.begin(),scores.end(),0.0);
             break;
           case Min:
-            return *std::min_element(distances.begin(),distances.end());
+            return *std::min_element(scores.begin(),scores.end());
             break;
           case Max:
-            return *std::max_element(distances.begin(),distances.end());
+            return *std::max_element(scores.begin(),scores.end());
             break;
           default:
             qFatal("Invalid operation.");
@@ -236,12 +250,19 @@ private:
 
     void store(QDataStream &stream) const
     {
-        distance->store(stream);
+        stream << distances.size();
+        foreach (Distance *distance, distances)
+            distance->store(stream);
     }
 
     void load(QDataStream &stream)
     {
-        distance->load(stream);
+        int numDistances;
+        stream >> numDistances;
+        while (distances.size() < numDistances)
+            distances.append(make(description));
+        foreach (Distance *distance, distances)
+            distance->load(stream);
     }
 };
 
diff --git a/openbr/plugins/quality.cpp b/openbr/plugins/quality.cpp
index 6848e18..78fc093 100644
--- a/openbr/plugins/quality.cpp
+++ b/openbr/plugins/quality.cpp
@@ -179,12 +179,7 @@ class MatchProbabilityDistance : public Distance
             }
         }
 
-        qDebug() << "Genuines: " << genuineScores.mid(0,5);
-        qDebug() << "Impostors: " << impostorScores.mid(0,5);
-
         mp = MP(genuineScores, impostorScores);
-
-        qDebug() << mp(-0.881882,true);
     }
 
     float compare(const Template &target, const Template &query) const
@@ -192,7 +187,6 @@ class MatchProbabilityDistance : public Distance
         const float rawScore = distance->compare(target, query);
         if (rawScore == -std::numeric_limits<float>::max()) return rawScore;
         if (!Globals->scoreNormalization) return -log(rawScore+1);
-        qDebug() << mp(rawScore, gaussian) << rawScore;
         return mp(rawScore, gaussian);
     }