Merge branch 'reorg'

Jordan Cheney
2 parents 8fde04e6 f213e68c
Showing 317 changed files with 19149 additions and 13709 deletions
openbr/plugins/classification/adaboost.cpp
openbr/plugins/ebif.cpp → openbr/plugins/classification/ebif.cpp
openbr/plugins/tree.cpp → openbr/plugins/classification/forest.cpp
openbr/plugins/ipc2013.cpp → openbr/plugins/classification/ipc2013.cpp
openbr/plugins/eigen3.cpp → openbr/plugins/classification/lda.cpp
openbr/plugins/liblinear.cpp → openbr/plugins/classification/liblinear.cpp
openbr/plugins/nn.cpp → openbr/plugins/classification/mlp.cpp
openbr/plugins/nt4.cpp → openbr/plugins/classification/nt4.cpp
openbr/plugins/pp4.cpp → openbr/plugins/classification/pp4.cpp
openbr/plugins/pp5.cpp → openbr/plugins/classification/pp5.cpp
openbr/plugins/svm.cpp → openbr/plugins/classification/svm.cpp
openbr/plugins/classification/turk.cpp
openbr/plugins/cluster/collectnn.cpp
openbr/plugins/cluster/kmeans.cpp
openbr/plugins/cluster.cpp → openbr/plugins/cluster/knn.cpp
openbr/plugins/cluster/lognn.cpp
openbr/plugins/cluster/randomcentroids.cpp
openbr/plugins/cmake/eigen3.cmake
openbr/plugins/ipc2013.cmake → openbr/plugins/cmake/ipc2013.cmake
openbr/plugins/jni.cmake → openbr/plugins/cmake/jni.cmake
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * Copyright 2012 The MITRE Corporation                                      *
+ *                                                                           *
+ * Licensed under the Apache License, Version 2.0 (the "License");           *
+ * you may not use this file except in compliance with the License.          *
+ * You may obtain a copy of the License at                                   *
+ *                                                                           *
+ *     http://www.apache.org/licenses/LICENSE-2.0                            *
+ *                                                                           *
+ * Unless required by applicable law or agreed to in writing, software       *
+ * distributed under the License is distributed on an "AS IS" BASIS,         *
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  *
+ * See the License for the specific language governing permissions and       *
+ * limitations under the License.                                            *
+ * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+
+#include <openbr/plugins/openbr_internal.h>
+#include <openbr/core/opencvutils.h>
+
+using namespace cv;
+
+namespace br
+{
+
+/*!
+ * \ingroup transforms
+ * \brief Wraps OpenCV's Ada Boost framework
+ * \author Scott Klum \cite sklum
+ * \brief http://docs.opencv.org/modules/ml/doc/boosting.html
+ */
+class AdaBoostTransform : public Transform
+{
+    Q_OBJECT
+    Q_ENUMS(Type)
+    Q_ENUMS(SplitCriteria)
+
+    Q_PROPERTY(Type type READ get_type WRITE set_type RESET reset_type STORED false)
+    Q_PROPERTY(SplitCriteria splitCriteria READ get_splitCriteria WRITE set_splitCriteria RESET reset_splitCriteria STORED false)
+    Q_PROPERTY(int weakCount READ get_weakCount WRITE set_weakCount RESET reset_weakCount STORED false)
+    Q_PROPERTY(float trimRate READ get_trimRate WRITE set_trimRate RESET reset_trimRate STORED false)
+    Q_PROPERTY(int folds READ get_folds WRITE set_folds RESET reset_folds STORED false)
+    Q_PROPERTY(int maxDepth READ get_maxDepth WRITE set_maxDepth RESET reset_maxDepth STORED false)
+    Q_PROPERTY(bool returnConfidence READ get_returnConfidence WRITE set_returnConfidence RESET reset_returnConfidence STORED false)
+    Q_PROPERTY(bool overwriteMat READ get_overwriteMat WRITE set_overwriteMat RESET reset_overwriteMat STORED false)
+    Q_PROPERTY(QString inputVariable READ get_inputVariable WRITE set_inputVariable RESET reset_inputVariable STORED false)
+    Q_PROPERTY(QString outputVariable READ get_outputVariable WRITE set_outputVariable RESET reset_outputVariable STORED false)
+
+public:
+    enum Type { Discrete = CvBoost::DISCRETE,
+                Real = CvBoost::REAL,
+                Logit = CvBoost::LOGIT,
+                Gentle = CvBoost::GENTLE};
+
+    enum SplitCriteria { Default = CvBoost::DEFAULT,
+                         Gini = CvBoost::GINI,
+                         Misclass = CvBoost::MISCLASS,
+                         Sqerr = CvBoost::SQERR};
+
+private:
+    BR_PROPERTY(Type, type, Real)
+    BR_PROPERTY(SplitCriteria, splitCriteria, Default)
+    BR_PROPERTY(int, weakCount, 100)
+    BR_PROPERTY(float, trimRate, .95)
+    BR_PROPERTY(int, folds, 0)
+    BR_PROPERTY(int, maxDepth, 1)
+    BR_PROPERTY(bool, returnConfidence, true)
+    BR_PROPERTY(bool, overwriteMat, true)
+    BR_PROPERTY(QString, inputVariable, "Label")
+    BR_PROPERTY(QString, outputVariable, "")
+
+    CvBoost boost;
+
+    void train(const TemplateList &data)
+    {
+        Mat samples = OpenCVUtils::toMat(data.data());
+        Mat labels = OpenCVUtils::toMat(File::get<float>(data, inputVariable));
+
+        Mat types = Mat(samples.cols + 1, 1, CV_8U);
+        types.setTo(Scalar(CV_VAR_NUMERICAL));
+        types.at<char>(samples.cols, 0) = CV_VAR_CATEGORICAL;
+
+        CvBoostParams params;
+        params.boost_type = type;
+        params.split_criteria = splitCriteria;
+        params.weak_count = weakCount;
+        params.weight_trim_rate = trimRate;
+        params.cv_folds = folds;
+        params.max_depth = maxDepth;
+
+        boost.train( samples, CV_ROW_SAMPLE, labels, Mat(), Mat(), types, Mat(),
+                    params);
+    }
+
+    void project(const Template &src, Template &dst) const
+    {
+        dst = src;
+        float response;
+        if (returnConfidence) {
+            response = boost.predict(src.m().reshape(1,1),Mat(),Range::all(),false,true)/weakCount;
+        } else {
+            response = boost.predict(src.m().reshape(1,1));
+        }
+
+        if (overwriteMat) {
+            dst.m() = Mat(1, 1, CV_32F);
+            dst.m().at<float>(0, 0) = response;
+        } else {
+            dst.file.set(outputVariable, response);
+        }
+    }
+
+    void load(QDataStream &stream)
+    {
+        OpenCVUtils::loadModel(boost,stream);
+    }
+
+    void store(QDataStream &stream) const
+    {
+        OpenCVUtils::storeModel(boost,stream);
+    }
+
+
+    void init()
+    {
+        if (outputVariable.isEmpty())
+            outputVariable = inputVariable;
+    }
+};
+
+BR_REGISTER(Transform, AdaBoostTransform)
+
+} // namespace br
+
+#include "classification/adaboost.moc"
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * Copyright 2012 The MITRE Corporation                                      *
+ *                                                                           *
+ * Licensed under the Apache License, Version 2.0 (the "License");           *
+ * you may not use this file except in compliance with the License.          *
+ * You may obtain a copy of the License at                                   *
+ *                                                                           *
+ *     http://www.apache.org/licenses/LICENSE-2.0                            *
+ *                                                                           *
+ * Unless required by applicable law or agreed to in writing, software       *
+ * distributed under the License is distributed on an "AS IS" BASIS,         *
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  *
+ * See the License for the specific language governing permissions and       *
+ * limitations under the License.                                            *
+ * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+
 #include <opencv2/imgproc/imgproc.hpp>
-#include "openbr_internal.h"
-#include "openbr/core/common.h"
-#include "openbr/core/opencvutils.h"
+#include <openbr/plugins/openbr_internal.h>
+#include <openbr/core/common.h>
+#include <openbr/core/opencvutils.h>
 using namespace cv;
@@ -128,4 +144,4 @@ BR_REGISTER(Transform, EBIFTransform)
 } // namespace br
-#include "ebif.moc"
+#include "classification/ebif.moc"
-#include "openbr_internal.h"
-#include "openbr/core/opencvutils.h"
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * Copyright 2012 The MITRE Corporation                                      *
+ *                                                                           *
+ * Licensed under the Apache License, Version 2.0 (the "License");           *
+ * you may not use this file except in compliance with the License.          *
+ * You may obtain a copy of the License at                                   *
+ *                                                                           *
+ *     http://www.apache.org/licenses/LICENSE-2.0                            *
+ *                                                                           *
+ * Unless required by applicable law or agreed to in writing, software       *
+ * distributed under the License is distributed on an "AS IS" BASIS,         *
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  *
+ * See the License for the specific language governing permissions and       *
+ * limitations under the License.                                            *
+ * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+
+#include <openbr/plugins/openbr_internal.h>
+#include <openbr/core/opencvutils.h>
-using namespace std;
 using namespace cv;
 namespace br
@@ -250,113 +265,6 @@ class ForestInductionTransform : public ForestTransform
 BR_REGISTER(Transform, ForestInductionTransform)
-/*!
- * \ingroup transforms
- * \brief Wraps OpenCV's Ada Boost framework
- * \author Scott Klum \cite sklum
- * \brief http://docs.opencv.org/modules/ml/doc/boosting.html
- */
-class AdaBoostTransform : public Transform
-{
-    Q_OBJECT
-    Q_ENUMS(Type)
-    Q_ENUMS(SplitCriteria)
-
-    Q_PROPERTY(Type type READ get_type WRITE set_type RESET reset_type STORED false)
-    Q_PROPERTY(SplitCriteria splitCriteria READ get_splitCriteria WRITE set_splitCriteria RESET reset_splitCriteria STORED false)
-    Q_PROPERTY(int weakCount READ get_weakCount WRITE set_weakCount RESET reset_weakCount STORED false)
-    Q_PROPERTY(float trimRate READ get_trimRate WRITE set_trimRate RESET reset_trimRate STORED false)
-    Q_PROPERTY(int folds READ get_folds WRITE set_folds RESET reset_folds STORED false)
-    Q_PROPERTY(int maxDepth READ get_maxDepth WRITE set_maxDepth RESET reset_maxDepth STORED false)
-    Q_PROPERTY(bool returnConfidence READ get_returnConfidence WRITE set_returnConfidence RESET reset_returnConfidence STORED false)
-    Q_PROPERTY(bool overwriteMat READ get_overwriteMat WRITE set_overwriteMat RESET reset_overwriteMat STORED false)
-    Q_PROPERTY(QString inputVariable READ get_inputVariable WRITE set_inputVariable RESET reset_inputVariable STORED false)
-    Q_PROPERTY(QString outputVariable READ get_outputVariable WRITE set_outputVariable RESET reset_outputVariable STORED false)
-
-public:
-    enum Type { Discrete = CvBoost::DISCRETE,
-                Real = CvBoost::REAL,
-                Logit = CvBoost::LOGIT,
-                Gentle = CvBoost::GENTLE};
-
-    enum SplitCriteria { Default = CvBoost::DEFAULT,
-                         Gini = CvBoost::GINI,
-                         Misclass = CvBoost::MISCLASS,
-                         Sqerr = CvBoost::SQERR};
-
-private:
-    BR_PROPERTY(Type, type, Real)
-    BR_PROPERTY(SplitCriteria, splitCriteria, Default)
-    BR_PROPERTY(int, weakCount, 100)
-    BR_PROPERTY(float, trimRate, .95)
-    BR_PROPERTY(int, folds, 0)
-    BR_PROPERTY(int, maxDepth, 1)
-    BR_PROPERTY(bool, returnConfidence, true)
-    BR_PROPERTY(bool, overwriteMat, true)
-    BR_PROPERTY(QString, inputVariable, "Label")
-    BR_PROPERTY(QString, outputVariable, "")
-
-    CvBoost boost;
-
-    void train(const TemplateList &data)
-    {
-        Mat samples = OpenCVUtils::toMat(data.data());
-        Mat labels = OpenCVUtils::toMat(File::get<float>(data, inputVariable));
-
-        Mat types = Mat(samples.cols + 1, 1, CV_8U);
-        types.setTo(Scalar(CV_VAR_NUMERICAL));
-        types.at<char>(samples.cols, 0) = CV_VAR_CATEGORICAL;
-
-        CvBoostParams params;
-        params.boost_type = type;
-        params.split_criteria = splitCriteria;
-        params.weak_count = weakCount;
-        params.weight_trim_rate = trimRate;
-        params.cv_folds = folds;
-        params.max_depth = maxDepth;
-
-        boost.train( samples, CV_ROW_SAMPLE, labels, Mat(), Mat(), types, Mat(),
-                    params);
-    }
-
-    void project(const Template &src, Template &dst) const
-    {
-        dst = src;
-        float response;
-        if (returnConfidence) {
-            response = boost.predict(src.m().reshape(1,1),Mat(),Range::all(),false,true)/weakCount;
-        } else {
-            response = boost.predict(src.m().reshape(1,1));
-        }
-
-        if (overwriteMat) {
-            dst.m() = Mat(1, 1, CV_32F);
-            dst.m().at<float>(0, 0) = response;
-        } else {
-            dst.file.set(outputVariable, response);
-        }
-    }
-
-    void load(QDataStream &stream)
-    {
-        OpenCVUtils::loadModel(boost,stream);
-    }
-
-    void store(QDataStream &stream) const
-    {
-        OpenCVUtils::storeModel(boost,stream);
-    }
-
-
-    void init()
-    {
-        if (outputVariable.isEmpty())
-            outputVariable = inputVariable;
-    }
-};
-
-BR_REGISTER(Transform, AdaBoostTransform)
-
 } // namespace br
-#include "tree.moc"
+#include "classification/forest.moc"
-#include "openbr_internal.h"
 #include <pxcaccelerator.h>
 #include <pxcface.h>
 #include <pxcimage.h>
 #include <pxcsession.h>
+#include <openbr/plugins/openbr_internal.h>
+
 using namespace br;
 static PXCSession *pxcSession = NULL;
@@ -16,11 +16,11 @@
 #include <Eigen/Dense>
-#include "openbr_internal.h"
+#include <openbr/plugins/openbr_internal.h>
-#include "openbr/core/common.h"
-#include "openbr/core/eigenutils.h"
-#include "openbr/core/opencvutils.h"
+#include <openbr/core/common.h>
+#include <openbr/core/eigenutils.h>
+#include <openbr/core/opencvutils.h>
 namespace br
 {
@@ -652,46 +652,6 @@ class SparseLDATransform : public Transform
 BR_REGISTER(Transform, SparseLDATransform)
-/*!
- * \ingroup distances
- * \brief L1 distance computed using eigen.
- * \author Josh Klontz \cite jklontz
- */
-class L1Distance : public UntrainableDistance
-{
-    Q_OBJECT
-
-    float compare(const cv::Mat &a, const cv::Mat &b) const
-    {
-        const int size = a.rows * a.cols;
-        Eigen::Map<Eigen::VectorXf> aMap((float*)a.data, size);
-        Eigen::Map<Eigen::VectorXf> bMap((float*)b.data, size);
-        return (aMap-bMap).cwiseAbs().sum();
-    }
-};
-
-BR_REGISTER(Distance, L1Distance)
-
-/*!
- * \ingroup distances
- * \brief L2 distance computed using eigen.
- * \author Josh Klontz \cite jklontz
- */
-class L2Distance : public UntrainableDistance
-{
-    Q_OBJECT
-
-    float compare(const cv::Mat &a, const cv::Mat &b) const
-    {
-        const int size = a.rows * a.cols;
-        Eigen::Map<Eigen::VectorXf> aMap((float*)a.data, size);
-        Eigen::Map<Eigen::VectorXf> bMap((float*)b.data, size);
-        return (aMap-bMap).squaredNorm();
-    }
-};
-
-BR_REGISTER(Distance, L2Distance)
-
 } // namespace br
-#include "eigen3.moc"
+#include "classification/lda.moc"
@@ -2,8 +2,8 @@
 #include <opencv2/core/core.hpp>
 #include <opencv2/ml/ml.hpp>
-#include "openbr_internal.h"
-#include "openbr/core/opencvutils.h"
+#include <openbr/plugins/openbr_internal.h>
+#include <openbr/core/opencvutils.h>
 #include <linear.h>
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * Copyright 2012 The MITRE Corporation                                      *
+ *                                                                           *
+ * Licensed under the Apache License, Version 2.0 (the "License");           *
+ * you may not use this file except in compliance with the License.          *
+ * You may obtain a copy of the License at                                   *
+ *                                                                           *
+ *     http://www.apache.org/licenses/LICENSE-2.0                            *
+ *                                                                           *
+ * Unless required by applicable law or agreed to in writing, software       *
+ * distributed under the License is distributed on an "AS IS" BASIS,         *
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  *
+ * See the License for the specific language governing permissions and       *
+ * limitations under the License.                                            *
+ * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+
 #include <opencv2/ml/ml.hpp>
-#include "openbr_internal.h"
-#include "openbr/core/qtutils.h"
-#include "openbr/core/opencvutils.h"
-#include "openbr/core/eigenutils.h"
-#include <QString>
-#include <QTemporaryFile>
+#include <openbr/plugins/openbr_internal.h>
+#include <openbr/core/opencvutils.h>
-using namespace std;
 using namespace cv;
 namespace br
 {
-static void storeMLP(const CvANN_MLP &mlp, QDataStream &stream)
-{
-    // Create local file
-    QTemporaryFile tempFile;
-    tempFile.open();
-    tempFile.close();
-
-    // Save MLP to local file
-    mlp.save(qPrintable(tempFile.fileName()));
-
-    // Copy local file contents to stream
-    tempFile.open();
-    QByteArray data = tempFile.readAll();
-    tempFile.close();
-    stream << data;
-}
-
-static void loadMLP(CvANN_MLP &mlp, QDataStream &stream)
-{
-    // Copy local file contents from stream
-    QByteArray data;
-    stream >> data;
-
-    // Create local file
-    QTemporaryFile tempFile(QDir::tempPath()+"/MLP");
-    tempFile.open();
-    tempFile.write(data);
-    tempFile.close();
-
-    // Load MLP from local file
-    mlp.load(qPrintable(tempFile.fileName()));
-}
-
 /*!
  * \ingroup transforms
  * \brief Wraps OpenCV's multi-layer perceptron framework
@@ -124,12 +102,12 @@ private:
     void load(QDataStream &stream)
     {
-        loadMLP(mlp,stream);
+        OpenCVUtils::loadModel(mlp, stream);
     }
     void store(QDataStream &stream) const
     {
-        storeMLP(mlp,stream);
+        OpenCVUtils::storeModel(mlp, stream);
     }
 };
@@ -137,4 +115,4 @@ BR_REGISTER(Transform, MLPTransform)
 } // namespace br
-#include "nn.moc"
+#include "classification/mlp.moc"
@@ -457,4 +457,4 @@ class NT4Compare : public Distance
 BR_REGISTER(Distance, NT4Compare)
-#include "nt4.moc"
+#include "classification/nt4.moc"
@@ -593,4 +593,4 @@ class PP5GalleryTransform: public UntrainableMetaTransform
 BR_REGISTER(Transform, PP5GalleryTransform)
-#include "plugins/pp5.moc"
+#include "classification/pp5.moc"
@@ -18,8 +18,8 @@
 #include <opencv2/core/core.hpp>
 #include <opencv2/ml/ml.hpp>
-#include "openbr_internal.h"
-#include "openbr/core/opencvutils.h"
+#include <openbr/plugins/openbr_internal.h>
+#include <openbr/core/opencvutils.h>
 using namespace cv;
@@ -261,4 +261,4 @@ BR_REGISTER(Distance, SVMDistance)
 } // namespace br
-#include "svm.moc"
+#include "classification/svm.moc"
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * Copyright 2012 The MITRE Corporation                                      *
+ *                                                                           *
+ * Licensed under the Apache License, Version 2.0 (the "License");           *
+ * you may not use this file except in compliance with the License.          *
+ * You may obtain a copy of the License at                                   *
+ *                                                                           *
+ *     http://www.apache.org/licenses/LICENSE-2.0                            *
+ *                                                                           *
+ * Unless required by applicable law or agreed to in writing, software       *
+ * distributed under the License is distributed on an "AS IS" BASIS,         *
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  *
+ * See the License for the specific language governing permissions and       *
+ * limitations under the License.                                            *
+ * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+
+#include <openbr/plugins/openbr_internal.h>
+
+namespace br
+{
+
+/*!
+ * \ingroup transforms
+ * \brief Convenience class for training turk attribute regressors
+ * \author Josh Klontz \cite jklontz
+ */
+class TurkClassifierTransform : public Transform
+{
+    Q_OBJECT
+    Q_PROPERTY(QString key READ get_key WRITE set_key RESET reset_key STORED false)
+    Q_PROPERTY(QStringList values READ get_values WRITE set_values RESET reset_values STORED false)
+    Q_PROPERTY(bool isMeta READ get_isMeta WRITE set_isMeta RESET reset_isMeta STORED false)
+    BR_PROPERTY(QString, key, QString())
+    BR_PROPERTY(QStringList, values, QStringList())
+    BR_PROPERTY(bool, isMeta, false)
+
+    Transform *child;
+
+    void init()
+    {
+        QStringList classifiers;
+        foreach (const QString &value, values)
+            classifiers.append(QString("(SVM(RBF,EPS_SVR,returnDFVal=true,inputVariable=%1,outputVariable=predicted_%1)%2)").arg(key + "_" + value, isMeta ? QString("+Average+SaveMat(predicted_%1)").arg(value) : QString()));
+        child = Transform::make(classifiers.join("/") + (classifiers.size() > 1 ? "+Cat" : ""));
+    }
+
+    void train(const QList<TemplateList> &data)
+    {
+        child->train(data);
+    }
+
+    void project(const Template &src, Template &dst) const
+    {
+        child->project(src, dst);
+    }
+
+    void store(QDataStream &stream) const
+    {
+        child->store(stream);
+    }
+
+    void load(QDataStream &stream)
+    {
+        child->load(stream);
+    }
+};
+
+BR_REGISTER(Transform, TurkClassifierTransform)
+
+} // namespace br
+
+#include "classification/turk.moc"
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * Copyright 2012 The MITRE Corporation                                      *
+ *                                                                           *
+ * Licensed under the Apache License, Version 2.0 (the "License");           *
+ * you may not use this file except in compliance with the License.          *
+ * You may obtain a copy of the License at                                   *
+ *                                                                           *
+ *     http://www.apache.org/licenses/LICENSE-2.0                            *
+ *                                                                           *
+ * Unless required by applicable law or agreed to in writing, software       *
+ * distributed under the License is distributed on an "AS IS" BASIS,         *
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  *
+ * See the License for the specific language governing permissions and       *
+ * limitations under the License.                                            *
+ * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+
+#include <openbr/plugins/openbr_internal.h>
+
+namespace br
+{
+
+/*!
+ * \ingroup transforms
+ * \brief Collect nearest neighbors and append them to metadata.
+ * \author Charles Otto \cite caotto
+ */
+class CollectNNTransform : public UntrainableMetaTransform
+{
+    Q_OBJECT
+
+    Q_PROPERTY(int keep READ get_keep WRITE set_keep RESET reset_keep STORED false)
+    BR_PROPERTY(int, keep, 20)
+
+    void project(const Template &src, Template &dst) const
+    {
+        dst.file = src.file;
+        dst.clear();
+        dst.m() = cv::Mat();
+        Neighbors neighbors;
+        for (int i=0; i < src.m().cols;i++) {
+            // skip self compares
+            if (i == src.file.get<int>("FrameNumber"))
+                continue;
+            neighbors.append(Neighbor(i, src.m().at<float>(0,i)));
+        }
+        int actuallyKeep = std::min(keep, neighbors.size());
+        std::partial_sort(neighbors.begin(), neighbors.begin()+actuallyKeep, neighbors.end(), compareNeighbors);
+
+        Neighbors selected = neighbors.mid(0, actuallyKeep);
+        dst.file.set("neighbors", QVariant::fromValue(selected));
+    }
+};
+
+BR_REGISTER(Transform, CollectNNTransform)
+
+} // namespace br
+
+#include "cluster/collectnn.moc"
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * Copyright 2012 The MITRE Corporation                                      *
+ *                                                                           *
+ * Licensed under the Apache License, Version 2.0 (the "License");           *
+ * you may not use this file except in compliance with the License.          *
+ * You may obtain a copy of the License at                                   *
+ *                                                                           *
+ *     http://www.apache.org/licenses/LICENSE-2.0                            *
+ *                                                                           *
+ * Unless required by applicable law or agreed to in writing, software       *
+ * distributed under the License is distributed on an "AS IS" BASIS,         *
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  *
+ * See the License for the specific language governing permissions and       *
+ * limitations under the License.                                            *
+ * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+
+#include <opencv2/flann/flann.hpp>
+
+#include <openbr/plugins/openbr_internal.h>
+#include <openbr/core/opencvutils.h>
+
+using namespace cv;
+
+namespace br
+{
+
+/*!
+ * \ingroup transforms
+ * \brief Wraps OpenCV kmeans and flann.
+ * \author Josh Klontz \cite jklontz
+ */
+class KMeansTransform : public Transform
+{
+    Q_OBJECT
+    Q_PROPERTY(int kTrain READ get_kTrain WRITE set_kTrain RESET reset_kTrain STORED false)
+    Q_PROPERTY(int kSearch READ get_kSearch WRITE set_kSearch RESET reset_kSearch STORED false)
+    BR_PROPERTY(int, kTrain, 256)
+    BR_PROPERTY(int, kSearch, 1)
+
+    Mat centers;
+    mutable QScopedPointer<flann::Index> index;
+    mutable QMutex mutex;
+
+    void reindex()
+    {
+        index.reset(new flann::Index(centers, flann::LinearIndexParams()));
+    }
+
+    void train(const TemplateList &data)
+    {
+        Mat bestLabels;
+        const double compactness = kmeans(OpenCVUtils::toMatByRow(data.data()), kTrain, bestLabels, TermCriteria(TermCriteria::MAX_ITER, 10, 0), 3, KMEANS_PP_CENTERS, centers);
+        qDebug("KMeans compactness = %f", compactness);
+        reindex();
+    }
+
+    void project(const Template &src, Template &dst) const
+    {
+        QMutexLocker locker(&mutex);
+        Mat dists, indicies;
+        index->knnSearch(src, indicies, dists, kSearch);
+        dst = indicies.reshape(1, 1);
+    }
+
+    void load(QDataStream &stream)
+    {
+        stream >> centers;
+        reindex();
+    }
+
+    void store(QDataStream &stream) const
+    {
+        stream << centers;
+    }
+};
+
+BR_REGISTER(Transform, KMeansTransform)
+
+} // namespace br
+
+#include "cluster/kmeans.moc"
@@ -14,12 +14,8 @@
  * limitations under the License.                                            *
  * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
-#include <opencv2/flann/flann.hpp>
-
-#include "openbr_internal.h"
-#include "openbr/core/common.h"
-#include "openbr/core/opencvutils.h"
-#include <fstream>
+#include <openbr/plugins/openbr_internal.h>
+#include <openbr/core/common.h>
 using namespace cv;
@@ -28,58 +24,6 @@ namespace br
 /*!
  * \ingroup transforms
- * \brief Wraps OpenCV kmeans and flann.
- * \author Josh Klontz \cite jklontz
- */
-class KMeansTransform : public Transform
-{
-    Q_OBJECT
-    Q_PROPERTY(int kTrain READ get_kTrain WRITE set_kTrain RESET reset_kTrain STORED false)
-    Q_PROPERTY(int kSearch READ get_kSearch WRITE set_kSearch RESET reset_kSearch STORED false)
-    BR_PROPERTY(int, kTrain, 256)
-    BR_PROPERTY(int, kSearch, 1)
-
-    Mat centers;
-    mutable QScopedPointer<flann::Index> index;
-    mutable QMutex mutex;
-
-    void reindex()
-    {
-        index.reset(new flann::Index(centers, flann::LinearIndexParams()));
-    }
-
-    void train(const TemplateList &data)
-    {
-        Mat bestLabels;
-        const double compactness = kmeans(OpenCVUtils::toMatByRow(data.data()), kTrain, bestLabels, TermCriteria(TermCriteria::MAX_ITER, 10, 0), 3, KMEANS_PP_CENTERS, centers);
-        qDebug("KMeans compactness = %f", compactness);
-        reindex();
-    }
-
-    void project(const Template &src, Template &dst) const
-    {
-        QMutexLocker locker(&mutex);
-        Mat dists, indicies;
-        index->knnSearch(src, indicies, dists, kSearch);
-        dst = indicies.reshape(1, 1);
-    }
-
-    void load(QDataStream &stream)
-    {
-        stream >> centers;
-        reindex();
-    }
-
-    void store(QDataStream &stream) const
-    {
-        stream << centers;
-    }
-};
-
-BR_REGISTER(Transform, KMeansTransform)
-
-/*!
- * \ingroup transforms
  * \brief K nearest neighbors classifier.
  * \author Josh Klontz \cite jklontz
  */
@@ -151,148 +95,6 @@ class KNNTransform : public Transform
 BR_REGISTER(Transform, KNNTransform)
-/*!
- * \ingroup transforms
- * \brief Chooses k random points to be centroids.
- * \author Austin Blanton \cite imaus10
- * \see KMeansTransform
- */
-class RandomCentroidsTransform : public Transform
-{
-    Q_OBJECT
-    Q_PROPERTY(int kTrain READ get_kTrain WRITE set_kTrain RESET reset_kTrain STORED false)
-    Q_PROPERTY(int kSearch READ get_kSearch WRITE set_kSearch RESET reset_kSearch STORED false)
-    BR_PROPERTY(int, kTrain, 256)
-    BR_PROPERTY(int, kSearch, 1)
-
-    Mat centers;
-    mutable QScopedPointer<flann::Index> index;
-    mutable QMutex mutex;
-
-    void reindex()
-    {
-        index.reset(new flann::Index(centers, flann::LinearIndexParams()));
-    }
-
-    void train(const TemplateList &data)
-    {
-        Mat flat = OpenCVUtils::toMatByRow(data.data());
-        QList<int> sample = Common::RandSample(kTrain, flat.rows, 0, true);
-        foreach (const int &idx, sample)
-            centers.push_back(flat.row(idx));
-        reindex();
-    }
-
-    void project(const Template &src, Template &dst) const
-    {
-        QMutexLocker locker(&mutex);
-        Mat dists, indicies;
-        index->knnSearch(src, indicies, dists, kSearch);
-        dst = indicies.reshape(1, 1);
-    }
-
-    void load(QDataStream &stream)
-    {
-        stream >> centers;
-        reindex();
-    }
-
-    void store(QDataStream &stream) const
-    {
-        stream << centers;
-    }
-};
-
-BR_REGISTER(Transform, RandomCentroidsTransform)
-
-class RegInitializer : public Initializer
-{
-    Q_OBJECT
-
-    void initialize() const
-    {
-        qRegisterMetaType<br::Neighbors>();
-    }
-};
-BR_REGISTER(Initializer, RegInitializer)
-
-class CollectNNTransform : public UntrainableMetaTransform
-{
-    Q_OBJECT
-
-    Q_PROPERTY(int keep READ get_keep WRITE set_keep RESET reset_keep STORED false)
-    BR_PROPERTY(int, keep, 20)
-
-    void project(const Template &src, Template &dst) const
-    {
-        dst.file = src.file;
-        dst.clear();
-        dst.m() = cv::Mat();
-        Neighbors neighbors;
-        for (int i=0; i < src.m().cols;i++) {
-            // skip self compares
-            if (i == src.file.get<int>("FrameNumber"))
-                continue;
-            neighbors.append(Neighbor(i, src.m().at<float>(0,i)));
-        }
-        int actuallyKeep = std::min(keep, neighbors.size());
-        std::partial_sort(neighbors.begin(), neighbors.begin()+actuallyKeep, neighbors.end(), compareNeighbors);
-
-        Neighbors selected = neighbors.mid(0, actuallyKeep);
-        dst.file.set("neighbors", QVariant::fromValue(selected));
-    }
-};
-BR_REGISTER(Transform, CollectNNTransform)
-
-class LogNNTransform : public TimeVaryingTransform
-{
-    Q_OBJECT
-
-    Q_PROPERTY(QString fileName READ get_fileName WRITE set_fileName RESET reset_fileName STORED false)
-    BR_PROPERTY(QString, fileName, "")
-
-    std::fstream fout;
-
-    void projectUpdate(const Template &src, Template &dst)
-    {
-        dst = src;
-
-        if (!dst.file.contains("neighbors")) {
-            fout << std::endl;
-            return;
-        }
-
-        Neighbors neighbors = dst.file.get<Neighbors>("neighbors");
-        if (neighbors.isEmpty() ) {
-            fout << std::endl;
-            return;
-        }
-
-        QString aLine;
-        aLine.append(QString::number(neighbors[0].first)+":"+QString::number(neighbors[0].second));
-        for (int i=1; i < neighbors.size();i++)
-            aLine.append(","+QString::number(neighbors[i].first)+":"+QString::number(neighbors[i].second));
-
-        fout << qPrintable(aLine) << std::endl;
-    }
-
-    void init()
-    {
-        if (!fileName.isEmpty())
-            fout.open(qPrintable(fileName), std::ios_base::out);
-    }
-
-    void finalize(TemplateList &output)
-    {
-        (void) output;
-        fout.close();
-    }
-
-public:
-    LogNNTransform() : TimeVaryingTransform(false, false) {}
-};
-BR_REGISTER(Transform, LogNNTransform)
-
 } // namespace br
-#include "cluster.moc"
+#include "cluster/knn.moc"
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * Copyright 2012 The MITRE Corporation                                      *
+ *                                                                           *
+ * Licensed under the Apache License, Version 2.0 (the "License");           *
+ * you may not use this file except in compliance with the License.          *
+ * You may obtain a copy of the License at                                   *
+ *                                                                           *
+ *     http://www.apache.org/licenses/LICENSE-2.0                            *
+ *                                                                           *
+ * Unless required by applicable law or agreed to in writing, software       *
+ * distributed under the License is distributed on an "AS IS" BASIS,         *
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  *
+ * See the License for the specific language governing permissions and       *
+ * limitations under the License.                                            *
+ * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+
+#include <fstream>
+
+#include <openbr/plugins/openbr_internal.h>
+
+namespace br
+{
+
+/*!
+ * \ingroup transforms
+ * \brief Log nearest neighbors to specified file.
+ * \author Charles Otto \cite caotto
+ */
+class LogNNTransform : public TimeVaryingTransform
+{
+    Q_OBJECT
+
+    Q_PROPERTY(QString fileName READ get_fileName WRITE set_fileName RESET reset_fileName STORED false)
+    BR_PROPERTY(QString, fileName, "")
+
+    std::fstream fout;
+
+    void projectUpdate(const Template &src, Template &dst)
+    {
+        dst = src;
+
+        if (!dst.file.contains("neighbors")) {
+            fout << std::endl;
+            return;
+        }
+
+        Neighbors neighbors = dst.file.get<Neighbors>("neighbors");
+        if (neighbors.isEmpty() ) {
+            fout << std::endl;
+            return;
+        }
+
+        QString aLine;
+        aLine.append(QString::number(neighbors[0].first)+":"+QString::number(neighbors[0].second));
+        for (int i=1; i < neighbors.size();i++)
+            aLine.append(","+QString::number(neighbors[i].first)+":"+QString::number(neighbors[i].second));
+
+        fout << qPrintable(aLine) << std::endl;
+    }
+
+    void init()
+    {
+        if (!fileName.isEmpty())
+            fout.open(qPrintable(fileName), std::ios_base::out);
+    }
+
+    void finalize(TemplateList &output)
+    {
+        (void) output;
+        fout.close();
+    }
+
+public:
+    LogNNTransform() : TimeVaryingTransform(false, false) {}
+};
+
+BR_REGISTER(Transform, LogNNTransform)
+
+} // namespace br
+
+#include "cluster/lognn.moc"
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * Copyright 2012 The MITRE Corporation                                      *
+ *                                                                           *
+ * Licensed under the Apache License, Version 2.0 (the "License");           *
+ * you may not use this file except in compliance with the License.          *
+ * You may obtain a copy of the License at                                   *
+ *                                                                           *
+ *     http://www.apache.org/licenses/LICENSE-2.0                            *
+ *                                                                           *
+ * Unless required by applicable law or agreed to in writing, software       *
+ * distributed under the License is distributed on an "AS IS" BASIS,         *
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  *
+ * See the License for the specific language governing permissions and       *
+ * limitations under the License.                                            *
+ * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+
+#include <opencv2/flann/flann.hpp>
+
+#include <openbr/plugins/openbr_internal.h>
+#include <openbr/core/common.h>
+#include <openbr/core/opencvutils.h>
+
+using namespace cv;
+
+namespace br
+{
+
+/*!
+ * \ingroup transforms
+ * \brief Chooses k random points to be centroids.
+ * \author Austin Blanton \cite imaus10
+ * \see KMeansTransform
+ */
+class RandomCentroidsTransform : public Transform
+{
+    Q_OBJECT
+    Q_PROPERTY(int kTrain READ get_kTrain WRITE set_kTrain RESET reset_kTrain STORED false)
+    Q_PROPERTY(int kSearch READ get_kSearch WRITE set_kSearch RESET reset_kSearch STORED false)
+    BR_PROPERTY(int, kTrain, 256)
+    BR_PROPERTY(int, kSearch, 1)
+
+    Mat centers;
+    mutable QScopedPointer<flann::Index> index;
+    mutable QMutex mutex;
+
+    void reindex()
+    {
+        index.reset(new flann::Index(centers, flann::LinearIndexParams()));
+    }
+
+    void train(const TemplateList &data)
+    {
+        Mat flat = OpenCVUtils::toMatByRow(data.data());
+        QList<int> sample = Common::RandSample(kTrain, flat.rows, 0, true);
+        foreach (const int &idx, sample)
+            centers.push_back(flat.row(idx));
+        reindex();
+    }
+
+    void project(const Template &src, Template &dst) const
+    {
+        QMutexLocker locker(&mutex);
+        Mat dists, indicies;
+        index->knnSearch(src, indicies, dists, kSearch);
+        dst = indicies.reshape(1, 1);
+    }
+
+    void load(QDataStream &stream)
+    {
+        stream >> centers;
+        reindex();
+    }
+
+    void store(QDataStream &stream) const
+    {
+        stream << centers;
+    }
+};
+
+BR_REGISTER(Transform, RandomCentroidsTransform)
+
+} //namespace br
+
+#include "cluster/randomcentroids.moc"
+set(BR_WITH_EIGEN3 ON CACHE BOOL "Build Eigen3 plugins")
+
+if(${BR_WITH_EIGEN3})
+  find_package(Eigen3 REQUIRED)
+  install(FILES ${EIGEN3_LICENSE} RENAME Eigen3 DESTINATION share/openbr/licenses)
+else()
+  set(BR_EXCLUDED_PLUGINS ${BR_EXCLUDED_PLUGINS} plugins/classification/lda.cpp)
+  set(BR_EXCLUDED_PLUGINS ${BR_EXCLUDED_PLUGINS} plugins/distance/L1.cpp)
+  set(BR_EXCLUDED_PLUGINS ${BR_EXCLUDED_PLUGINS} plugins/distance/L2.cpp)
+  set(BR_EXCLUDED_PLUGINS ${BR_EXCLUDED_PLUGINS} plugins/imgproc/revertaffine.cpp)
+  set(BR_EXCLUDED_PLUGINS ${BR_EXCLUDED_PLUGINS} plugins/imgproc/integralsampler.cpp)
+  set(BR_EXCLUDED_PLUGINS ${BR_EXCLUDED_PLUGINS} plugins/imgproc/recursiveintegralsampler.cpp)
+  set(BR_EXCLUDED_PLUGINS ${BR_EXCLUDED_PLUGINS} plugins/metadata/consolidatedetections.cpp)
+  set(BR_EXCLUDED_PLUGINS ${BR_EXCLUDED_PLUGINS} plugins/metadata/delaunay.cpp)
+  set(BR_EXCLUDED_PLUGINS ${BR_EXCLUDED_PLUGINS} plugins/metadata/procrustes.cpp)
+endif()
@@ -2,7 +2,8 @@ set(BR_WITH_IPC2013 OFF CACHE BOOL &quot;Build with Intel Perceptual Computing SDK 20
 if(${BR_WITH_IPC2013})
   find_package(IPC2013 REQUIRED)
-  set(BR_THIRDPARTY_SRC ${BR_THIRDPARTY_SRC} plugins/ipc2013.cpp)
   set(BR_THIRDPARTY_LIBS ${BR_THIRDPARTY_LIBS} ${IPC2013_LIBS})
   install(DIRECTORY ${IPC2013_DIR}/bin/x64/ DESTINATION bin)
+else()
+  set(BR_EXCLUDED_PLUGINS ${BR_EXCLUDED_PLUGINS} plugins/classification/ipc2013.cpp)
 endif()
@@ -3,10 +3,10 @@ set(BR_WITH_JAVA OFF CACHE BOOL &quot;Use Java Code&quot;)
 if (${BR_WITH_JAVA})
 	find_package(JNI REQUIRED)
         find_package(JAVA REQUIRED)
-	set(BR_THIRDPARTY_SRC ${BR_THIRDPARTY_SRC} plugins/jni.cpp)
 	set(BR_THIRDPARTY_LIBS ${BR_THIRDPARTY_LIBS} ${JNI_LIBRARIES})
 	include_directories(${JAVA_INCLUDE_PATH})
 	include_directories(${JAVA_INCLUDE_PATH2})
-
+else()
+  set(BR_EXCLUDED_PLUGINS ${BR_EXCLUDED_PLUGINS} plugins/core/jni.cpp)
 endif()
@@ -3,5 +3,6 @@ set(BR_WITH_LIBLINEAR OFF CACHE BOOL &quot;Build with LibLinear&quot;)
 if(${BR_WITH_LIBLINEAR})
   find_package(LibLinear REQUIRED)
   set(BR_THIRDPARTY_SRC ${BR_THIRDPARTY_SRC} ${LibLinear_SRC})
-  set(BR_THIRDPARTY_SRC ${BR_THIRDPARTY_SRC} plugins/liblinear.cpp)
+else()
+  set(BR_EXCLUDED_PLUGINS ${BR_EXCLUDED_PLUGINS} plugins/classification/liblinear.cpp)
 endif()
@@ -2,6 +2,9 @@ set(BR_WITH_LIKELY OFF CACHE BOOL &quot;Build with Likely&quot;)
 if(${BR_WITH_LIKELY})
   find_package(Likely REQUIRED)
-  set(BR_THIRDPARTY_SRC ${BR_THIRDPARTY_SRC} plugins/likely.cpp)
   set(BR_THIRDPARTY_LIBS ${BR_THIRDPARTY_LIBS} ${Likely_LIBS})
+else()
+  set(BR_EXCLUDED_PLUGINS ${BR_EXCLUDED_PLUGINS} plugins/core/likely.cpp)
+  set(BR_EXCLUDED_PLUGINS ${BR_EXCLUDED_PLUGINS} plugins/format/lmat.cpp)
+  set(BR_EXCLUDED_PLUGINS ${BR_EXCLUDED_PLUGINS} plugins/gallery/lmat.cpp)
 endif()
 set(BR_WITH_MONGOOSE OFF CACHE BOOL "Build with Mongoose")
 if(${BR_WITH_MONGOOSE})
   find_package(Mongoose)
-  set(BR_THIRDPARTY_SRC ${BR_THIRDPARTY_SRC} plugins/mongoose.cpp ${MONGOOSE_SRC})
+  set(BR_THIRDPARTY_SRC ${BR_THIRDPARTY_SRC} ${MONGOOSE_SRC})
   install(FILES ${MONGOOSE_LICENSE} RENAME mongoose DESTINATION share/openbr/licenses)
+else()
+  set(BR_EXCLUDED_PLUGINS ${BR_EXCLUDED_PLUGINS} plugins/metadata/mongoose.cpp)
 endif()
@@ -3,6 +3,10 @@ if(${BR_WITH_QTNETWORK})
   find_package(Qt5Network)
   find_package(HttpParser)
   set(QT_DEPENDENCIES ${QT_DEPENDENCIES} Network)
-  set(BR_THIRDPARTY_SRC ${BR_THIRDPARTY_SRC} plugins/qtnetwork.cpp ${HTTPPARSER_SRC})
+  set(BR_THIRDPARTY_SRC ${BR_THIRDPARTY_SRC} ${HTTPPARSER_SRC})
   install(FILES ${HTTPPARSER_LICENSE} RENAME http-parser DESTINATION share/openbr/licenses)
+else()
+  set(BR_EXCLUDED_PLUGINS ${BR_EXCLUDED_PLUGINS} plugins/format/urlformat.cpp)
+  set(BR_EXCLUDED_PLUGINS ${BR_EXCLUDED_PLUGINS} plugins/format/postformat.cpp)
+  set(BR_EXCLUDED_PLUGINS ${BR_EXCLUDED_PLUGINS} plugins/gallery/postgallery.cpp)
 endif()
@@ -2,7 +2,8 @@ set(BR_WITH_NT4 OFF CACHE BOOL &quot;Build with Neurotec Biometric 4&quot;)
 if(${BR_WITH_NT4})
   find_package(NT4 REQUIRED)
-  set(BR_THIRDPARTY_SRC ${BR_THIRDPARTY_SRC} plugins/nt4.cpp)
   set(BR_THIRDPARTY_LIBS ${BR_THIRDPARTY_LIBS} ${NT4_LIBS})
   install(DIRECTORY ${NT4_DIR_LIB}/ DESTINATION lib)
+else()
+  set(BR_EXCLUDED_PLUGINS ${BR_EXCLUDED_PLUGINS} plugins/classification/nt4.cpp)
 endif()
@@ -2,8 +2,9 @@ set(BR_WITH_PP4 OFF CACHE BOOL &quot;Build with PittPatt 4&quot;)
 if(${BR_WITH_PP4})
   find_package(PP4 REQUIRED)
-  set(BR_THIRDPARTY_SRC ${BR_THIRDPARTY_SRC} plugins/pp4.cpp)
   set(BR_THIRDPARTY_LIBS ${BR_THIRDPARTY_LIBS} ${PP4_LIBS})
   install(DIRECTORY ${PP4_DIR}/lib/ DESTINATION lib)
   install(DIRECTORY ${PP4_DIR}/models/ DESTINATION models/pp4)
+else()
+  set(BR_EXCLUDED_PLUGINS ${BR_EXCLUDED_PLUGINS} plugins/classification/pp4.cpp)
 endif()
@@ -2,7 +2,6 @@ set(BR_WITH_PP5 OFF CACHE BOOL &quot;Build with PittPatt 5&quot;)
 if(${BR_WITH_PP5})
   find_package(PP5 REQUIRED)
-  set(BR_THIRDPARTY_SRC ${BR_THIRDPARTY_SRC} plugins/pp5.cpp)
   set(BR_THIRDPARTY_LIBS ${BR_THIRDPARTY_LIBS} ${PP5_LIBS})
   if(WIN32)
@@ -12,4 +11,6 @@ if(${BR_WITH_PP5})
   endif()
   install(DIRECTORY ${PP5_DIR}/models/ DESTINATION share/openbr/models/pp5)
+else()
+  set(BR_EXCLUDED_PLUGINS ${BR_EXCLUDED_PLUGINS} plugins/classification/pp5.cpp)
 endif()
+if(${BR_EMBEDDED})
+  set(BR_EXCLUDED_PLUGINS ${BR_EXCLUDED_PLUGINS} plugins/gui/show.cpp)
+endif()
-set(BR_WITH_STASM4 ON CACHE BOOL "Build with Stasm")
+set(BR_WITH_STASM4 OFF CACHE BOOL "Build with Stasm")
 if(${BR_WITH_STASM4})
   find_package(Stasm4 REQUIRED)
-  set(BR_THIRDPARTY_SRC ${BR_THIRDPARTY_SRC} plugins/stasm4.cpp)
   set(BR_THIRDPARTY_LIBS ${BR_THIRDPARTY_LIBS} ${Stasm4_LIBS})
   if(WIN32)
@@ -12,4 +11,7 @@ if(${BR_WITH_STASM4})
   endif()
   install(DIRECTORY ${Stasm_DIR}/data/ DESTINATION share/openbr/models/stasm)
+else()
+  set(BR_EXCLUDED_PLUGINS ${BR_EXCLUDED_PLUGINS} plugins/metadata/stasm4.cpp)
+  set(BR_EXCLUDED_PLUGINS ${BR_EXCLUDED_PLUGINS} plugins/imgproc/revertaffine.cpp)
 endif()
@@ -14,7 +14,7 @@
  * limitations under the License.                                            *
  * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
-#include "openbr_internal.h"
+#include <openbr/plugins/openbr_internal.h>
 namespace br
 {
@@ -108,4 +108,4 @@ BR_REGISTER(Initializer, AlgorithmsInitializer)
 } // namespace br
-#include "algorithms.moc"
+#include "core/algorithms.moc"
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * Copyright 2012 The MITRE Corporation                                      *
+ *                                                                           *
+ * Licensed under the Apache License, Version 2.0 (the "License");           *
+ * you may not use this file except in compliance with the License.          *
+ * You may obtain a copy of the License at                                   *
+ *                                                                           *
+ *     http://www.apache.org/licenses/LICENSE-2.0                            *
+ *                                                                           *
+ * Unless required by applicable law or agreed to in writing, software       *
+ * distributed under the License is distributed on an "AS IS" BASIS,         *
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  *
+ * See the License for the specific language governing permissions and       *
+ * limitations under the License.                                            *
+ * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+
+#include <openbr/plugins/openbr_internal.h>
+
+namespace br
+{
+
+/*!
+ * \ingroup initializers
+ * \brief Initializes global abbreviations with implemented algorithms for attributes
+ * \author Babatunde Ogunfemi \cite baba1472
+ */
+class AttributeAlgorithmsInitializer : public Initializer
+{
+    Q_OBJECT
+
+    void initialize() const
+    {
+        // Constants
+        QString BASE="Open+PP5Register+Rename(PP5_Landmark0_Right_Eye,Affine_0)+Rename(PP5_Landmark1_Left_Eye,Affine_1)+Affine(192,240,.345,.475)+Cvt(Gray)+Stasm(false,true,[(66.24,114),(125.76,114)])";
+        QString SUBSPACE ="Blur(1.1)+Gamma(0.2)+DoG(1,2)+ContrastEq(0.1,10)+LBP(1,2)+RectRegions(8,8,4,4)+Hist(59)+Cat+PCA(0.95)";
+
+        QString NOSE="RectFromStasmNoseWithBridge+ROI+Resize(36,24)+" + SUBSPACE;
+        QString MOUTH="RectFromStasmMouth+ROI+Resize(24,36)+" + SUBSPACE;
+        QString EYES="RectFromStasmEyes+ROI+Resize(24,36)+" + SUBSPACE;
+        QString HAIR="RectFromStasmHair+ROI+Resize(24,36)+" + SUBSPACE;
+        QString BROW="RectFromStasmBrow+ROI+Resize(24,36)+" + SUBSPACE;
+        QString JAW="RectFromStasmJaw+ROI+Resize(36,36)+" + SUBSPACE;
+        QString FACE = "Crop(24,30,144,190)+Resize(36,36)+" +  SUBSPACE;
+
+        // All Attributes
+        Globals->abbreviations.insert("AllAttributes", "AttributeBrow/AttributeMouth/AttributeEyes/AttributeFace/AttributeHair/AttributeNose/AttributeJaw");
+        Globals->abbreviations.insert("AllAttributesMatching", "(AttributeBrow)/(AttributeMouth)/(AttributeEyes)/(AttributeFace)/(AttributeHair)/(AttributeNose)/(AttributeJaw):AttributeMatch");
+
+        //Individual Attributes
+        Globals->abbreviations.insert("AttributeBrow", "(" + BASE+ "+" + BROW + "+"
+        "TurkClassifier(eyebrowposition,[closebrows,highbrows],3)/"
+        "TurkClassifier(unibrow,[unibrow],3)/"
+        "TurkClassifier(eyebroworientation,[eyebrowsdown,eyebrowsuptodown],3)/"
+        "TurkClassifier(thickeyebrows,[thickeyebrows,lighteyebrows],3))");
+        Globals->abbreviations.insert("AttributeMouth", "(" + BASE + "+" + MOUTH + "+"
+        "TurkClassifier(smiling,[smiling],3)/"
+        "TurkClassifier(lipthickness,[cherry,big,small],3)/"
+        "TurkClassifier(mouthbite,[underbite,overbite],3)/"
+        "TurkClassifier(mouthopen,[closed,noteeth,halfteeth,allteeth],3)/"
+        "TurkClassifier(mouthwidth,[small,wide],3)/"
+        "TurkClassifier(mustache,[nomustache,linemustache,lightmustache,normalmustache,down],3)/"
+        "TurkClassifier(mouthasymmetry,[asymmetrical],3))");
+        Globals->abbreviations.insert("AttributeEyes", "(" + BASE + "+" + EYES + "+ "
+        "TurkClassifier(eyeseparation,[close,wide],3)/"
+        "TurkClassifier(eyeslant,[slant2,slant1,wild],3)/"
+        "TurkClassifier(benteyes,[bent])/"
+        "TurkClassifier(eyecolor,[darkeyes,lighteyes],3)/"
+        "TurkClassifier(baggyeyes,[baggy],3)/"
+        "TurkClassifier(almondeyes,[almond],3)/"
+        "TurkClassifier(buriedeyes,[buriedeyes],3)/"
+        "TurkClassifier(sleepyeyes,[sleepy],3)/"
+        "TurkClassifier(lineeyes,[line],3)/"
+        "TurkClassifier(roundeyes,[round],3)/"
+        "TurkClassifier(sharpeyes,[sharp],3)/"
+        "TurkClassifier(smalleyes,[smalleyes],3)/"
+        "TurkClassifier(glasses,[glasses],3)/"
+        "TurkClassifier(eyelashvisibility,[feweyelashes],3))");
+        Globals->abbreviations.insert("AttributeFace", "(" + BASE + "+" + FACE + "+"
+        "TurkClassifier(gender,[male],3)/"
+        "TurkClassifier(faceshape,[round,triangular,rectangular],3)/"
+        "TurkClassifier(cheekdensity,[puffy,in,normal],3)/"
+        "TurkClassifier(facemarks,[scars,moles,normal],3)/"
+        "TurkClassifier(facelength,[long],3)/"
+        "TurkClassifier(nosetoeyedist,[short,long],3)/"
+        "TurkClassifier(nosetomouthdist,[long,small],3))");
+        Globals->abbreviations.insert("AttributeHair", "(" + BASE + "+" + HAIR + "+"
+        "TurkClassifier(foreheadwrinkles,[wrinkled],3)/"
+        "TurkClassifier(foreheadsize,[smallforehead,largeforehead],3)/"
+        "TurkClassifier(haircolor,[darkhair,lighthair,greyhair],3)/"
+        "TurkClassifier(hairdensity,[thick,bald,thin,halfbald],3)/"
+        "TurkClassifier(widowspeak,[widowspeak],3)/"
+        "TurkClassifier(hairstyle,[curlyhair],3))");
+        Globals->abbreviations.insert("AttributeNose", "(" + BASE + "+" + NOSE + "+"
+        "TurkClassifier(noseorientation,[upnose,downnose],3)/"
+        "TurkClassifier(nosewidth,[small,thick],3)/"
+        "TurkClassifier(nosesize,[smallnose,bignose],3)/"
+        "TurkClassifier(brokennose,[broken],3))");
+        Globals->abbreviations.insert("AttributeJaw", "(" + BASE + "+" + JAW + "+"
+        "TurkClassifier(beard,[nobeard,bigbeard,lightbeard,goatee,linebeard,normalbeard,lincolnbeard],3)/"
+        "TurkClassifier(chinsize,[shortchin,longchin],3))");
+        Globals->abbreviations.insert("AttributeMatch", "Fuse(["
+        "Turk(eyebrowposition,[closebrows,highbrows],3),"
+        "Turk(unibrow,[unibrow],3),"
+        "Turk(eyebroworientation,[eyebrowsdown,eyebrowsuptodown],3),"
+        "Turk(thickeyebrows,[thickeyebrows,lighteyebrows],3),"
+        "Turk(smiling,[smiling],3),"
+        "Turk(lipthickness,[cherry,big,small],3),"
+        "Turk(mouthbite,[underbite,overbite],3),"
+        "Turk(mouthopen,[closed,noteeth,halfteeth,allteeth],3),"
+        "Turk(mouthwidth,[small,wide],3),"
+        "Turk(mustache,[nomustache,linemustache,lightmustache,normalmustache,down],3),"
+        "Turk(mouthasymmetry,[asymmetrical],3),"
+        "Turk(eyeseparation,[close,wide],3),"
+        "Turk(eyeslant,[slant2,slant1,wild],3),"
+        "Turk(benteyes,[bent],3),"
+        "Turk(eyecolor,[darkeyes,lighteyes],3),"
+        "Turk(baggyeyes,[baggy],3),"
+        "Turk(almondeyes,[almond],3),"
+        "Turk(buriedeyes,[buriedeyes],3),"
+        "Turk(sleepyeyes,[sleepy],3),"
+        "Turk(lineeyes,[line],3),"
+        "Turk(roundeyes,[round],3),"
+        "Turk(sharpeyes,[sharp],3),"
+        "Turk(smalleyes,[smalleyes],3),"
+        "Turk(glasses,[glasses],3),"
+        "Turk(eyelashvisibility,[feweyelashes],3),"
+        "Turk(gender,[male],3),"
+        "Turk(faceshape,[round,triangular,rectangular],3),"
+        "Turk(cheekdensity,[puffy,in,normal],3),"
+        "Turk(facemarks,[scars,moles,normal],3),"
+        "Turk(facelength,[long],3),"
+        "Turk(nosetoeyedist,[short,long],3),"
+        "Turk(nosetomouthdist,[long,small],3),"
+        "Turk(foreheadwrinkles,[wrinkled],3),"
+        "Turk(foreheadsize,[smallforehead,largeforehead],3),"
+        "Turk(haircolor,[darkhair,lighthair,greyhair],3),"
+        "Turk(hairdensity,[thick,bald,thin,halfbald],3),"
+        "Turk(widowspeak,[widowspeak],3),"
+        "Turk(hairstyle,[curlyhair],3),"
+        "Turk(noseorientation,[upnose,downnose],3),"
+        "Turk(nosewidth,[small,thick],3),"
+        "Turk(nosesize,[smallnose,bignose],3),"
+        "Turk(brokennose,[broken],3),"
+        "Turk(beard,[nobeard,bigbeard,lightbeard,goatee,linebeard,normalbeard,lincolnbeard],3),"
+        "Turk(chinsize,[shortchin,longchin],3)])");
+    }
+};
+
+BR_REGISTER(Initializer, AttributeAlgorithmsInitializer)
+
+} // namespace br
+
+#include "core/attributealgorithms.moc"
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * Copyright 2012 The MITRE Corporation                                      *
+ *                                                                           *
+ * Licensed under the Apache License, Version 2.0 (the "License");           *
+ * you may not use this file except in compliance with the License.          *
+ * You may obtain a copy of the License at                                   *
+ *                                                                           *
+ *     http://www.apache.org/licenses/LICENSE-2.0                            *
+ *                                                                           *
+ * Unless required by applicable law or agreed to in writing, software       *
+ * distributed under the License is distributed on an "AS IS" BASIS,         *
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  *
+ * See the License for the specific language governing permissions and       *
+ * limitations under the License.                                            *
+ * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+
+#include <openbr/plugins/openbr_internal.h>
+
+namespace br
+{
+
+/*!
+ * \ingroup transforms
+ * \brief Caches br::Transform::project() results.
+ * \author Josh Klontz \cite jklontz
+ */
+class CacheTransform : public MetaTransform
+{
+    Q_OBJECT
+    Q_PROPERTY(br::Transform* transform READ get_transform WRITE set_transform RESET reset_transform)
+    BR_PROPERTY(br::Transform*, transform, NULL)
+
+    static QHash<QString, Template> cache;
+    static QMutex cacheLock;
+
+public:
+    ~CacheTransform()
+    {
+        if (cache.isEmpty()) return;
+
+        // Write to cache
+        QFile file("Cache");
+        if (!file.open(QFile::WriteOnly))
+            qFatal("Unable to open %s for writing.", qPrintable(file.fileName()));
+        QDataStream stream(&file);
+        stream << cache;
+        file.close();
+    }
+
+private:
+    void init()
+    {
+        if (!transform) return;
+
+        trainable = transform->trainable;
+        if (!cache.isEmpty()) return;
+
+        // Read from cache
+        QFile file("Cache");
+        if (file.exists()) {
+            if (!file.open(QFile::ReadOnly))
+                qFatal("Unable to open %s for reading.", qPrintable(file.fileName()));
+            QDataStream stream(&file);
+            stream >> cache;
+            file.close();
+        }
+    }
+
+    void train(const QList<TemplateList> &data)
+    {
+        transform->train(data);
+    }
+
+    void project(const Template &src, Template &dst) const
+    {
+        const QString &file = src.file;
+        if (cache.contains(file)) {
+            dst = cache[file];
+        } else {
+            transform->project(src, dst);
+            cacheLock.lock();
+            cache[file] = dst;
+            cacheLock.unlock();
+        }
+    }
+};
+
+QHash<QString, Template> CacheTransform::cache;
+QMutex CacheTransform::cacheLock;
+
+BR_REGISTER(Transform, CacheTransform)
+
+} // namespace br
+
+#include "core/cache.moc"
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * Copyright 2012 The MITRE Corporation                                      *
+ *                                                                           *
+ * Licensed under the Apache License, Version 2.0 (the "License");           *
+ * you may not use this file except in compliance with the License.          *
+ * You may obtain a copy of the License at                                   *
+ *                                                                           *
+ *     http://www.apache.org/licenses/LICENSE-2.0                            *
+ *                                                                           *
+ * Unless required by applicable law or agreed to in writing, software       *
+ * distributed under the License is distributed on an "AS IS" BASIS,         *
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  *
+ * See the License for the specific language governing permissions and       *
+ * limitations under the License.                                            *
+ * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+
+#include <openbr/plugins/openbr_internal.h>
+
+namespace br
+{
+
+/*!
+ * \ingroup transforms
+ * \brief It's like the opposite of ExpandTransform, but not really
+ * \author Charles Otto \cite caotto
+ *
+ * Given a set of templatelists as input, concatenate them onto a single Template
+ */
+class ContractTransform : public UntrainableMetaTransform
+{
+    Q_OBJECT
+
+    virtual void project(const TemplateList &src, TemplateList &dst) const
+    {
+        if (src.empty()) return;
+        Template out;
+
+        foreach (const Template &t, src) {
+            out.merge(t);
+        }
+        out.file.clearRects();
+        foreach (const Template &t, src) {
+            if (!t.file.rects().empty())
+                out.file.appendRects(t.file.rects());
+        }
+        dst.clear();
+        dst.append(out);
+    }
+
+    virtual void project(const Template &src, Template &dst) const
+    {
+        qFatal("this has gone bad");
+        (void) src; (void) dst;
+    }
+};
+
+BR_REGISTER(Transform, ContractTransform)
+
+} // namespace br
+
+#include "core/contract.moc"
-#include <QFutureSynchronizer>
-#include <QtConcurrentRun>
-#include "openbr_internal.h"
-#include "openbr/core/common.h"
-#include <openbr/core/qtutils.h>
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * Copyright 2012 The MITRE Corporation                                      *
+ *                                                                           *
+ * Licensed under the Apache License, Version 2.0 (the "License");           *
+ * you may not use this file except in compliance with the License.          *
+ * You may obtain a copy of the License at                                   *
+ *                                                                           *
+ *     http://www.apache.org/licenses/LICENSE-2.0                            *
+ *                                                                           *
+ * Unless required by applicable law or agreed to in writing, software       *
+ * distributed under the License is distributed on an "AS IS" BASIS,         *
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  *
+ * See the License for the specific language governing permissions and       *
+ * limitations under the License.                                            *
+ * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+
+#include <QtConcurrent>
+
+#include <openbr/plugins/openbr_internal.h>
+#include <openbr/core/common.h>
 namespace br
 {
@@ -134,138 +149,6 @@ class CrossValidateTransform : public MetaTransform
 BR_REGISTER(Transform, CrossValidateTransform)
-/*!
- * \ingroup distances
- * \brief Cross validate a distance metric.
- * \author Josh Klontz \cite jklontz
- */
-class CrossValidateDistance : public UntrainableDistance
-{
-    Q_OBJECT
-
-    float compare(const Template &a, const Template &b) const
-    {
-        static const QString key("Partition"); // More efficient to preallocate this
-        const int partitionA = a.file.get<int>(key, 0);
-        const int partitionB = b.file.get<int>(key, 0);
-        return (partitionA != partitionB) ? -std::numeric_limits<float>::max() : 0;
-    }
-};
-
-BR_REGISTER(Distance, CrossValidateDistance)
-
-/*!
- * \ingroup distances
- * \brief Checks target metadata against filters.
- * \author Josh Klontz \cite jklontz
- */
-class FilterDistance : public UntrainableDistance
-{
-    Q_OBJECT
-
-    float compare(const Template &a, const Template &b) const
-    {
-        (void) b; // Query template isn't checked
-        foreach (const QString &key, Globals->filters.keys()) {
-            bool keep = false;
-            const QString metadata = a.file.get<QString>(key, "");
-            if (Globals->filters[key].isEmpty()) continue;
-            if (metadata.isEmpty()) return -std::numeric_limits<float>::max();
-            foreach (const QString &value, Globals->filters[key]) {
-                if (metadata == value) {
-                    keep = true;
-                    break;
-                }
-            }
-            if (!keep) return -std::numeric_limits<float>::max();
-        }
-        return 0;
-    }
-};
-
-BR_REGISTER(Distance, FilterDistance)
-
-/*!
- * \ingroup distances
- * \brief Checks target metadata against query metadata.
- * \author Scott Klum \cite sklum
- */
-class MetadataDistance : public UntrainableDistance
-{
-    Q_OBJECT
-
-    Q_PROPERTY(QStringList filters READ get_filters WRITE set_filters RESET reset_filters STORED false)
-    BR_PROPERTY(QStringList, filters, QStringList())
-
-    float compare(const Template &a, const Template &b) const
-    {
-        foreach (const QString &key, filters) {
-            QString aValue = a.file.get<QString>(key, QString());
-            QString bValue = b.file.get<QString>(key, QString());
-
-            // The query value may be a range. Let's check.
-            if (bValue.isEmpty()) bValue = QtUtils::toString(b.file.get<QPointF>(key, QPointF()));
-
-            if (aValue.isEmpty() || bValue.isEmpty()) continue;
-
-            bool keep = false;
-            bool ok;
-
-            QPointF range = QtUtils::toPoint(bValue,&ok);
-
-            if (ok) /* Range */ {
-                int value = range.x();
-                int upperBound = range.y();
-
-                while (value <= upperBound) {
-                    if (aValue == QString::number(value)) {
-                        keep = true;
-                        break;
-                    }
-                    value++;
-                }
-            }
-            else if (aValue == bValue) keep = true;
-
-            if (!keep) return -std::numeric_limits<float>::max();
-        }
-        return 0;
-    }
-};
-
-
-BR_REGISTER(Distance, MetadataDistance)
-
-/*!
- * \ingroup distances
- * \brief Sets distance to -FLOAT_MAX if a target template has/doesn't have a key.
- * \author Scott Klum \cite sklum
- */
-class RejectDistance : public UntrainableDistance
-{
-    Q_OBJECT
-
-    Q_PROPERTY(QStringList keys READ get_keys WRITE set_keys RESET reset_keys STORED false)
-    BR_PROPERTY(QStringList, keys, QStringList())
-    Q_PROPERTY(bool rejectIfContains READ get_rejectIfContains WRITE set_rejectIfContains RESET reset_rejectIfContains STORED false)
-    BR_PROPERTY(bool, rejectIfContains, false)
-
-    float compare(const Template &a, const Template &b) const
-    {
-        // We don't look at the query
-        (void) b;
-
-        foreach (const QString &key, keys)
-            if ((rejectIfContains && a.file.contains(key)) || (!rejectIfContains && !a.file.contains(key)))
-                return -std::numeric_limits<float>::max();
-
-        return 0;
-    }
-};
-
-
-BR_REGISTER(Distance, RejectDistance)
-
 } // namespace br
-#include "validate.moc"
+#include "core/crossvalidate.moc"
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * Copyright 2012 The MITRE Corporation                                      *
+ *                                                                           *
+ * Licensed under the Apache License, Version 2.0 (the "License");           *
+ * you may not use this file except in compliance with the License.          *
+ * You may obtain a copy of the License at                                   *
+ *                                                                           *
+ *     http://www.apache.org/licenses/LICENSE-2.0                            *
+ *                                                                           *
+ * Unless required by applicable law or agreed to in writing, software       *
+ * distributed under the License is distributed on an "AS IS" BASIS,         *
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  *
+ * See the License for the specific language governing permissions and       *
+ * limitations under the License.                                            *
+ * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+
+#include <openbr/plugins/openbr_internal.h>
+
+namespace br
+{
+
+/*!
+ * \ingroup transforms
+ * \brief Removes all template's matrices.
+ * \see IdentityTransform FirstTransform RestTransform RemoveTransform
+ * \author Josh Klontz \cite jklontz
+ */
+class DiscardTransform : public UntrainableMetaTransform
+{
+    Q_OBJECT
+
+    void project(const Template &src, Template &dst) const
+    {
+        dst.file = src.file;
+    }
+};
+
+BR_REGISTER(Transform, DiscardTransform)
+
+} // namespace br
+
+#include "core/discard.moc"
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * Copyright 2012 The MITRE Corporation                                      *
+ *                                                                           *
+ * Licensed under the Apache License, Version 2.0 (the "License");           *
+ * you may not use this file except in compliance with the License.          *
+ * You may obtain a copy of the License at                                   *
+ *                                                                           *
+ *     http://www.apache.org/licenses/LICENSE-2.0                            *
+ *                                                                           *
+ * Unless required by applicable law or agreed to in writing, software       *
+ * distributed under the License is distributed on an "AS IS" BASIS,         *
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  *
+ * See the License for the specific language governing permissions and       *
+ * limitations under the License.                                            *
+ * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+
+#include <openbr/plugins/openbr_internal.h>
+
+namespace br
+{
+
+class DiscardTemplatesTransform : public UntrainableMetaTransform
+{
+    Q_OBJECT
+
+    void project(const Template &src, Template &dst) const
+    {
+        (void) src; (void) dst;
+        qFatal("Incorrect project called on DiscardTemplatesTransform");
+    }
+    void project(const TemplateList &src, TemplateList &dst) const
+    {
+        (void) src;
+        dst.clear();
+    }
+};
+
+BR_REGISTER(Transform, DiscardTemplatesTransform)
+
+} // namespace br
+
+#include "core/discardtemplates.moc"
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * Copyright 2012 The MITRE Corporation                                      *
+ *                                                                           *
+ * Licensed under the Apache License, Version 2.0 (the "License");           *
+ * you may not use this file except in compliance with the License.          *
+ * You may obtain a copy of the License at                                   *
+ *                                                                           *
+ *     http://www.apache.org/licenses/LICENSE-2.0                            *
+ *                                                                           *
+ * Unless required by applicable law or agreed to in writing, software       *
+ * distributed under the License is distributed on an "AS IS" BASIS,         *
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  *
+ * See the License for the specific language governing permissions and       *
+ * limitations under the License.                                            *
+ * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+
+#include <QtConcurrent>
+
+#include <openbr/plugins/openbr_internal.h>
+
+namespace br
+{
+
+static void _projectList(const Transform *transform, const TemplateList *src, TemplateList *dst)
+{
+    transform->project(*src, *dst);
+}
+
+class DistributeTemplateTransform : public MetaTransform
+{
+    Q_OBJECT
+    Q_PROPERTY(br::Transform* transform READ get_transform WRITE set_transform RESET reset_transform)
+    BR_PROPERTY(br::Transform*, transform, NULL)
+
+public:
+
+    Transform *smartCopy(bool &newTransform)
+    {
+        if (!transform->timeVarying()) {
+            newTransform = false;
+            return this;
+        }
+        newTransform = true;
+
+        DistributeTemplateTransform *output = new DistributeTemplateTransform;
+        bool newChild = false;
+        output->transform = transform->smartCopy(newChild);
+        if (newChild)
+            output->transform->setParent(output);
+
+        return output;
+    }
+
+    void train(const QList<TemplateList> &data)
+    {
+        if (!transform->trainable) {
+            qWarning("Attempted to train untrainable transform, nothing will happen.");
+            return;
+        }
+
+        QList<TemplateList> separated;
+        foreach (const TemplateList &list, data) {
+            foreach (const Template &t, list) {
+                separated.append(TemplateList());
+                separated.last().append(t);
+            }
+        }
+
+        transform->train(separated);
+    }
+
+    void project(const Template &src, Template &dst) const
+    {
+        TemplateList input;
+        input.append(src);
+        TemplateList output;
+        project(input, output);
+
+        if (output.size() != 1) qFatal("output contains more than 1 template");
+        else dst = output[0];
+    }
+
+    // For each input template, form a single element TemplateList, push all those
+    // lists through transform, and form dst by concatenating the results.
+    // Process the single elemnt templates in parallel if parallelism is enabled.
+    void project(const TemplateList &src, TemplateList &dst) const
+    {
+        // Pre-allocate output for each template
+        QList<TemplateList> output_buffer;
+        output_buffer.reserve(src.size());
+
+        // Can't declare this local to the loop because it would go out of scope
+        QList<TemplateList> input_buffer;
+        input_buffer.reserve(src.size());
+
+        QFutureSynchronizer<void> futures;
+
+        for (int i =0; i < src.size();i++) {
+            input_buffer.append(TemplateList());
+            output_buffer.append(TemplateList());
+        }
+        QList<QFuture<void> > temp;
+        temp.reserve(src.size());
+        for (int i=0; i<src.size(); i++) {
+            input_buffer[i].append(src[i]);
+
+            if (Globals->parallelism > 1) temp.append(QtConcurrent::run(_projectList, transform, &input_buffer[i], &output_buffer[i]));
+            else _projectList(transform, &input_buffer[i], &output_buffer[i]);
+        }
+        // We add the futures in reverse order, since in Qt 5.1 at least the
+        // waiting thread will wait on them in the order added (which for uniform priority
+        // threads is the order of execution), and we want the waiting thread to go in the opposite order
+        // so that it can steal runnables and do something besides wait.
+        for (int i = temp.size() - 1; i >= 0; i--) {
+            futures.addFuture(temp[i]);
+        }
+
+        futures.waitForFinished();
+
+        for (int i=0; i<src.size(); i++) dst.append(output_buffer[i]);
+    }
+
+    void projectUpdate(const TemplateList &src, TemplateList &dst)
+    {
+        this->project(src, dst);
+        return;
+    }
+
+    void init()
+    {
+        if (!transform)
+            return;
+
+        trainable = transform->trainable;
+    }
+
+};
+BR_REGISTER(Transform, DistributeTemplateTransform)
+
+} // namespace br
+
+#include "core/distributetemplate.moc"
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * Copyright 2012 The MITRE Corporation                                      *
+ *                                                                           *
+ * Licensed under the Apache License, Version 2.0 (the "License");           *
+ * you may not use this file except in compliance with the License.          *
+ * You may obtain a copy of the License at                                   *
+ *                                                                           *
+ *     http://www.apache.org/licenses/LICENSE-2.0                            *
+ *                                                                           *
+ * Unless required by applicable law or agreed to in writing, software       *
+ * distributed under the License is distributed on an "AS IS" BASIS,         *
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  *
+ * See the License for the specific language governing permissions and       *
+ * limitations under the License.                                            *
+ * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+
+#include <openbr/plugins/openbr_internal.h>
+
+namespace br
+{
+
+static TemplateList Downsample(const TemplateList &templates, int classes, int instances, float fraction, const QString &inputVariable, const QStringList &gallery, const QStringList &subjects)
+{
+    // Return early when no downsampling is required
+    if ((classes == std::numeric_limits<int>::max()) &&
+            (instances == std::numeric_limits<int>::max()) &&
+            (fraction >= 1) &&
+            (gallery.isEmpty()) &&
+            (subjects.isEmpty()))
+        return templates;
+
+    const bool atLeast = instances < 0;
+    instances = abs(instances);
+
+    QList<QString> allLabels = File::get<QString>(templates, inputVariable);
+
+    QList<QString> uniqueLabels = allLabels.toSet().toList();
+    qSort(uniqueLabels);
+
+    QMap<QString,int> counts = templates.countValues<QString>(inputVariable, instances != std::numeric_limits<int>::max());
+
+    if ((instances != std::numeric_limits<int>::max()) && (classes != std::numeric_limits<int>::max()))
+        foreach (const QString &label, counts.keys())
+            if (counts[label] < instances)
+                counts.remove(label);
+
+    uniqueLabels = counts.keys();
+    if ((classes != std::numeric_limits<int>::max()) && (uniqueLabels.size() < classes))
+        qWarning("Downsample requested %d classes but only %d are available.", classes, uniqueLabels.size());
+
+    QList<QString> selectedLabels = uniqueLabels;
+    if (classes < uniqueLabels.size()) {
+        std::random_shuffle(selectedLabels.begin(), selectedLabels.end());
+        selectedLabels = selectedLabels.mid(0, classes);
+    }
+
+    TemplateList downsample;
+    for (int i=0; i<selectedLabels.size(); i++) {
+        const QString selectedLabel = selectedLabels[i];
+        QList<int> indices;
+        for (int j=0; j<allLabels.size(); j++)
+            if ((allLabels[j] == selectedLabel) && (!templates.value(j).file.get<bool>("FTE", false)) && (!templates.value(j).file.get<bool>("PossibleFTE", false)))
+                indices.append(j);
+
+        std::random_shuffle(indices.begin(), indices.end());
+        const int max = atLeast ? indices.size() : std::min(indices.size(), instances);
+        for (int j=0; j<max; j++)
+            downsample.append(templates.value(indices[j]));
+    }
+
+    if (fraction < 1) {
+        std::random_shuffle(downsample.begin(), downsample.end());
+        downsample = downsample.mid(0, downsample.size()*fraction);
+    }
+
+    if (!gallery.isEmpty())
+        for (int i=downsample.size()-1; i>=0; i--)
+            if (!gallery.contains(downsample[i].file.get<QString>("Gallery")))
+                downsample.removeAt(i);
+
+    if (!subjects.isEmpty())
+        for (int i=downsample.size()-1; i>=0; i--)
+            if (subjects.contains(downsample[i].file.get<QString>(inputVariable)))
+                downsample.removeAt(i);
+
+    return downsample;
+}
+
+class DownsampleTrainingTransform : public Transform
+{
+    Q_OBJECT
+    Q_PROPERTY(br::Transform* transform READ get_transform WRITE set_transform RESET reset_transform STORED true)
+    Q_PROPERTY(int classes READ get_classes WRITE set_classes RESET reset_classes STORED false)
+    Q_PROPERTY(int instances READ get_instances WRITE set_instances RESET reset_instances STORED false)
+    Q_PROPERTY(float fraction READ get_fraction WRITE set_fraction RESET reset_fraction STORED false)
+    Q_PROPERTY(QString inputVariable READ get_inputVariable WRITE set_inputVariable RESET reset_inputVariable STORED false)
+    Q_PROPERTY(QStringList gallery READ get_gallery WRITE set_gallery RESET reset_gallery STORED false)
+    Q_PROPERTY(QStringList subjects READ get_subjects WRITE set_subjects RESET reset_subjects STORED false)
+    BR_PROPERTY(br::Transform*, transform, NULL)
+    BR_PROPERTY(int, classes, std::numeric_limits<int>::max())
+    BR_PROPERTY(int, instances, std::numeric_limits<int>::max())
+    BR_PROPERTY(float, fraction, 1)
+    BR_PROPERTY(QString, inputVariable, "Label")
+    BR_PROPERTY(QStringList, gallery, QStringList())
+    BR_PROPERTY(QStringList, subjects, QStringList())
+
+
+    Transform *simplify(bool &newTForm)
+    {
+        Transform *res = transform->simplify(newTForm);
+        return res;
+    }
+
+    void project(const Template &src, Template &dst) const
+    {
+       transform->project(src,dst);
+    }
+
+
+    void train(const TemplateList &data)
+    {
+        if (!transform || !transform->trainable)
+            return;
+
+        TemplateList downsampled = Downsample(data, classes, instances, fraction, inputVariable, gallery, subjects);
+
+        transform->train(downsampled);
+    }
+};
+
+BR_REGISTER(Transform, DownsampleTrainingTransform)
+
+} // namespace br
+
+#include "core/downsampletraining.moc"
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * Copyright 2012 The MITRE Corporation                                      *
+ *                                                                           *
+ * Licensed under the Apache License, Version 2.0 (the "License");           *
+ * you may not use this file except in compliance with the License.          *
+ * You may obtain a copy of the License at                                   *
+ *                                                                           *
+ *     http://www.apache.org/licenses/LICENSE-2.0                            *
+ *                                                                           *
+ * Unless required by applicable law or agreed to in writing, software       *
+ * distributed under the License is distributed on an "AS IS" BASIS,         *
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  *
+ * See the License for the specific language governing permissions and       *
+ * limitations under the License.                                            *
+ * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+
+#include <openbr/plugins/openbr_internal.h>
+
+namespace br
+{
+
+class EventTransform : public UntrainableMetaTransform
+{
+    Q_OBJECT
+    Q_PROPERTY(QString eventName READ get_eventName WRITE set_eventName RESET reset_eventName STORED false)
+    BR_PROPERTY(QString, eventName, "")
+
+    TemplateEvent event;
+
+    void project(const Template &src, Template &dst) const
+    {
+        dst = src;
+        event.pulseSignal(dst);
+    }
+
+    TemplateEvent *getEvent(const QString &name)
+    {
+        return name == eventName ? &event : NULL;
+    }
+};
+
+BR_REGISTER(Transform, EventTransform)
+
+} // namespace br
+
+#include "core/event.moc"
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * Copyright 2012 The MITRE Corporation                                      *
+ *                                                                           *
+ * Licensed under the Apache License, Version 2.0 (the "License");           *
+ * you may not use this file except in compliance with the License.          *
+ * You may obtain a copy of the License at                                   *
+ *                                                                           *
+ *     http://www.apache.org/licenses/LICENSE-2.0                            *
+ *                                                                           *
+ * Unless required by applicable law or agreed to in writing, software       *
+ * distributed under the License is distributed on an "AS IS" BASIS,         *
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  *
+ * See the License for the specific language governing permissions and       *
+ * limitations under the License.                                            *
+ * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+
+#include <openbr/plugins/openbr_internal.h>
+
+namespace br
+{
+
+static TemplateList Expanded(const TemplateList &templates)
+{
+    TemplateList expanded;
+    foreach (const Template &t, templates) {
+        const bool enrollAll = t.file.get<bool>("enrollAll");
+        if (t.isEmpty()) {
+            if (!enrollAll)
+                expanded.append(t);
+            continue;
+        }
+
+        const QList<QPointF> points = t.file.points();
+        const QList<QRectF> rects = t.file.rects();
+        if (points.size() % t.size() != 0) qFatal("Uneven point count.");
+        if (rects.size() % t.size() != 0) qFatal("Uneven rect count.");
+        const int pointStep = points.size() / t.size();
+        const int rectStep = rects.size() / t.size();
+
+        for (int i=0; i<t.size(); i++) {
+            expanded.append(Template(t.file, t[i]));
+            expanded.last().file.setRects(rects.mid(i*rectStep, rectStep));
+            expanded.last().file.setPoints(points.mid(i*pointStep, pointStep));
+        }
+    }
+    return expanded;
+}
+
+/*!
+ * \ingroup transforms
+ * \brief Performs an expansion step on input templatelists
+ * \author Josh Klontz \cite jklontz
+ *
+ * Each matrix in an input Template is expanded into its own template.
+ *
+ * \see PipeTransform
+ */
+class ExpandTransform : public UntrainableMetaTransform
+{
+    Q_OBJECT
+
+    virtual void project(const TemplateList &src, TemplateList &dst) const
+    {
+        dst = Expanded(src);
+    }
+
+    virtual void project(const Template &src, Template &dst) const
+    {
+        dst = src;
+        qDebug("Called Expand project(Template,Template), nothing will happen");
+    }
+};
+
+BR_REGISTER(Transform, ExpandTransform)
+
+} // namespace br
+
+#include "core/expand.moc"
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * Copyright 2012 The MITRE Corporation                                      *
+ *                                                                           *
+ * Licensed under the Apache License, Version 2.0 (the "License");           *
+ * you may not use this file except in compliance with the License.          *
+ * You may obtain a copy of the License at                                   *
+ *                                                                           *
+ *     http://www.apache.org/licenses/LICENSE-2.0                            *
+ *                                                                           *
+ * Unless required by applicable law or agreed to in writing, software       *
+ * distributed under the License is distributed on an "AS IS" BASIS,         *
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  *
+ * See the License for the specific language governing permissions and       *
+ * limitations under the License.                                            *
+ * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+
+#include <openbr/plugins/openbr_internal.h>
+
+namespace br
+{
+
+/*!
+ * \ingroup transforms
+ * \brief Removes all but the first matrix from the template.
+ * \see IdentityTransform DiscardTransform RestTransform RemoveTransform
+ * \author Josh Klontz \cite jklontz
+ */
+class FirstTransform : public UntrainableMetaTransform
+{
+    Q_OBJECT
+
+    void project(const Template &src, Template &dst) const
+    {
+        // AggregateFrames will leave the Template empty
+        // if it hasn't filled up the buffer
+        // so we gotta anticipate an empty Template
+        if (src.empty()) return;
+        dst.file = src.file;
+        dst = src.m();
+    }
+};
+
+BR_REGISTER(Transform, FirstTransform)
+
+} // namespace br
+
+#include "core/first.moc"
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * Copyright 2012 The MITRE Corporation                                      *
+ *                                                                           *
+ * Licensed under the Apache License, Version 2.0 (the "License");           *
+ * you may not use this file except in compliance with the License.          *
+ * You may obtain a copy of the License at                                   *
+ *                                                                           *
+ *     http://www.apache.org/licenses/LICENSE-2.0                            *
+ *                                                                           *
+ * Unless required by applicable law or agreed to in writing, software       *
+ * distributed under the License is distributed on an "AS IS" BASIS,         *
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  *
+ * See the License for the specific language governing permissions and       *
+ * limitations under the License.                                            *
+ * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+
+#include <QtConcurrent>
+
+#include <openbr/plugins/openbr_internal.h>
+
+namespace br
+{
+
+static void _train(Transform *transform, const QList<TemplateList> *data)
+{
+    transform->train(*data);
+}
+
+/*!
+ * \ingroup transforms
+ * \brief Transforms in parallel.
+ * \author Josh Klontz \cite jklontz
+ *
+ * The source br::Template is seperately given to each transform and the results are appended together.
+ *
+ * \see PipeTransform
+ */
+class ForkTransform : public CompositeTransform
+{
+    Q_OBJECT
+
+    void train(const QList<TemplateList> &data)
+    {
+        if (!trainable) return;
+        QFutureSynchronizer<void> futures;
+        for (int i=0; i<transforms.size(); i++)
+            futures.addFuture(QtConcurrent::run(_train, transforms[i], &data));
+        futures.waitForFinished();
+    }
+
+    // same as _project, but calls projectUpdate on sub-transforms
+    void projectupdate(const Template &src, Template &dst)
+    {
+        foreach (Transform *f, transforms) {
+            try {
+                Template res;
+                f->projectUpdate(src, res);
+                dst.merge(res);
+            } catch (...) {
+                qWarning("Exception triggered when processing %s with transform %s", qPrintable(src.file.flat()), qPrintable(f->objectName()));
+                dst = Template(src.file);
+                dst.file.fte = true;
+                break;
+            }
+        }
+    }
+
+    void projectUpdate(const TemplateList &src, TemplateList &dst)
+    {
+        dst.reserve(src.size());
+        for (int i=0; i<src.size(); i++) dst.append(Template(src[i].file));
+        foreach (Transform *f, transforms) {
+            TemplateList m;
+            f->projectUpdate(src, m);
+            if (m.size() != dst.size()) qFatal("TemplateList is of an unexpected size.");
+            for (int i=0; i<src.size(); i++) dst[i].merge(m[i]);
+        }
+    }
+
+    // this is probably going to go bad, fork transform probably won't work well in a variable
+    // input/output scenario
+    virtual void finalize(TemplateList &output)
+    {
+        output.clear();
+        // For each transform,
+        for (int i = 0; i < transforms.size(); i++)
+        {
+            // Collect any final templates
+            TemplateList last_set;
+            transforms[i]->finalize(last_set);
+            if (last_set.empty())
+                continue;
+
+            if (output.empty()) output = last_set;
+            else
+            {
+                // is the number of templates received from this transform consistent with the number
+                // received previously? If not we can't do anything coherent here.
+                if (last_set.size() != output.size())
+                    qFatal("mismatched template list sizes in ForkTransform");
+                for (int j = 0; j < output.size(); j++) {
+                    output[j].append(last_set[j]);
+                }
+            }
+        }
+    }
+
+protected:
+
+    // Apply each transform to src, concatenate the results
+    void _project(const Template &src, Template &dst) const
+    {
+        foreach (const Transform *f, transforms) {
+            try {
+                dst.merge((*f)(src));
+            } catch (...) {
+                qWarning("Exception triggered when processing %s with transform %s", qPrintable(src.file.flat()), qPrintable(f->objectName()));
+                dst = Template(src.file);
+                dst.file.fte = true;
+                break;
+            }
+        }
+    }
+
+    void _project(const TemplateList &src, TemplateList &dst) const
+    {
+        dst.reserve(src.size());
+        for (int i=0; i<src.size(); i++) dst.append(Template(src[i].file));
+        foreach (const Transform *f, transforms) {
+            TemplateList m;
+            f->project(src, m);
+            if (m.size() != dst.size()) qFatal("TemplateList is of an unexpected size.");
+            for (int i=0; i<src.size(); i++) dst[i].merge(m[i]);
+        }
+    }
+
+};
+
+BR_REGISTER(Transform, ForkTransform)
+
+} // namespace br
+
+#include "core/fork.moc"
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * Copyright 2012 The MITRE Corporation                                      *
+ *                                                                           *
+ * Licensed under the Apache License, Version 2.0 (the "License");           *
+ * you may not use this file except in compliance with the License.          *
+ * You may obtain a copy of the License at                                   *
+ *                                                                           *
+ *     http://www.apache.org/licenses/LICENSE-2.0                            *
+ *                                                                           *
+ * Unless required by applicable law or agreed to in writing, software       *
+ * distributed under the License is distributed on an "AS IS" BASIS,         *
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  *
+ * See the License for the specific language governing permissions and       *
+ * limitations under the License.                                            *
+ * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+
+#include <openbr/plugins/openbr_internal.h>
+#include <openbr/core/common.h>
+
+namespace br
+{
+
+/*!
+ * \ingroup transforms
+ * \brief Flags images that failed to enroll based on the specified transform.
+ * \author Josh Klontz \cite jklontz
+ */
+class FTETransform : public Transform
+{
+    Q_OBJECT
+    Q_PROPERTY(br::Transform* transform READ get_transform WRITE set_transform RESET reset_transform)
+    Q_PROPERTY(float min READ get_min WRITE set_min RESET reset_min)
+    Q_PROPERTY(float max READ get_max WRITE set_max RESET reset_max)
+    BR_PROPERTY(br::Transform*, transform, NULL)
+    BR_PROPERTY(float, min, -std::numeric_limits<float>::max())
+    BR_PROPERTY(float, max,  std::numeric_limits<float>::max())
+
+    void train(const TemplateList &data)
+    {
+        transform->train(data);
+
+        TemplateList projectedData;
+        transform->project(data, projectedData);
+
+        QList<float> vals;
+        foreach (const Template &t, projectedData) {
+            if (!t.file.contains(transform->objectName()))
+                qFatal("Matrix metadata missing key %s.", qPrintable(transform->objectName()));
+            vals.append(t.file.get<float>(transform->objectName()));
+        }
+        float q1, q3;
+        Common::Median(vals, &q1, &q3);
+        min = q1 - 1.5 * (q3 - q1);
+        max = q3 + 1.5 * (q3 - q1);
+    }
+
+    void project(const Template &src, Template &dst) const
+    {
+        Template projectedSrc;
+        transform->project(src, projectedSrc);
+        const float val = projectedSrc.file.get<float>(transform->objectName());
+
+        dst = src;
+        dst.file.set(transform->objectName(), val);
+        dst.file.set("PossibleFTE", (val < min) || (val > max));
+    }
+};
+
+BR_REGISTER(Transform, FTETransform)
+
+} // namespace br
+
+#include "core/fte.moc"
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * Copyright 2012 The MITRE Corporation                                      *
+ *                                                                           *
+ * Licensed under the Apache License, Version 2.0 (the "License");           *
+ * you may not use this file except in compliance with the License.          *
+ * You may obtain a copy of the License at                                   *
+ *                                                                           *
+ *     http://www.apache.org/licenses/LICENSE-2.0                            *
+ *                                                                           *
+ * Unless required by applicable law or agreed to in writing, software       *
+ * distributed under the License is distributed on an "AS IS" BASIS,         *
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  *
+ * See the License for the specific language governing permissions and       *
+ * limitations under the License.                                            *
+ * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+
+#include <openbr/plugins/openbr_internal.h>
+#include <openbr/core/opencvutils.h>
+
+namespace br
+{
+
+/*!
+ * \ingroup transforms
+ * \brief Compare each template to a fixed gallery (with name = galleryName), using the specified distance.
+ * dst will contain a 1 by n vector of scores.
+ * \author Charles Otto \cite caotto
+ */
+class GalleryCompareTransform : public Transform
+{
+    Q_OBJECT
+    Q_PROPERTY(br::Distance *distance READ get_distance WRITE set_distance RESET reset_distance STORED true)
+    Q_PROPERTY(QString galleryName READ get_galleryName WRITE set_galleryName RESET reset_galleryName STORED false)
+    BR_PROPERTY(br::Distance*, distance, NULL)
+    BR_PROPERTY(QString, galleryName, "")
+
+    TemplateList gallery;
+
+    void project(const Template &src, Template &dst) const
+    {
+        dst = src;
+        if (gallery.isEmpty())
+            return;
+
+        QList<float> line = distance->compare(gallery, src);
+        dst.m() = OpenCVUtils::toMat(line, 1);
+    }
+
+    void init()
+    {
+        if (!galleryName.isEmpty())
+            gallery = TemplateList::fromGallery(galleryName);
+    }
+
+    void train(const TemplateList &data)
+    {
+        gallery = data;
+    }
+
+    void store(QDataStream &stream) const
+    {
+        br::Object::store(stream);
+        stream << gallery;
+    }
+
+    void load(QDataStream &stream)
+    {
+        br::Object::load(stream);
+        stream >> gallery;
+    }
+
+public:
+    GalleryCompareTransform() : Transform(false, true) {}
+};
+
+BR_REGISTER(Transform, GalleryCompareTransform)
+
+} // namespace br
+
+#include "core/gallerycompare.moc"
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * Copyright 2012 The MITRE Corporation                                      *
+ *                                                                           *
+ * Licensed under the Apache License, Version 2.0 (the "License");           *
+ * you may not use this file except in compliance with the License.          *
+ * You may obtain a copy of the License at                                   *
+ *                                                                           *
+ *     http://www.apache.org/licenses/LICENSE-2.0                            *
+ *                                                                           *
+ * Unless required by applicable law or agreed to in writing, software       *
+ * distributed under the License is distributed on an "AS IS" BASIS,         *
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  *
+ * See the License for the specific language governing permissions and       *
+ * limitations under the License.                                            *
+ * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+
+#include <openbr/plugins/openbr_internal.h>
+
+namespace br
+{
+
+/*!
+ * \ingroup transforms
+ * \brief A no-op transform.
+ * \see DiscardTransform FirstTransform RestTransform RemoveTransform
+ * \author Josh Klontz \cite jklontz
+ */
+class IdentityTransform : public UntrainableMetaTransform
+{
+    Q_OBJECT
+
+    void project(const Template &src, Template &dst) const
+    {
+        dst = src;
+    }
+};
+
+BR_REGISTER(Transform, IdentityTransform)
+
+} // namespace br
+
+#include "core/identity.moc"
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * Copyright 2012 The MITRE Corporation                                      *
+ *                                                                           *
+ * Licensed under the Apache License, Version 2.0 (the "License");           *
+ * you may not use this file except in compliance with the License.          *
+ * You may obtain a copy of the License at                                   *
+ *                                                                           *
+ *     http://www.apache.org/licenses/LICENSE-2.0                            *
+ *                                                                           *
+ * Unless required by applicable law or agreed to in writing, software       *
+ * distributed under the License is distributed on an "AS IS" BASIS,         *
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  *
+ * See the License for the specific language governing permissions and       *
+ * limitations under the License.                                            *
+ * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+
+#include <QtConcurrent>
+
+#include <openbr/plugins/openbr_internal.h>
+
+using namespace cv;
+
+namespace br
+{
+
+/*!
+ * \ingroup transforms
+ * \brief Clones the transform so that it can be applied independently.
+ * \author Josh Klontz \cite jklontz
+ * \em Independent transforms expect single-matrix templates.
+ */
+class IndependentTransform : public MetaTransform
+{
+    Q_OBJECT
+    Q_PROPERTY(br::Transform* transform READ get_transform WRITE set_transform RESET reset_transform STORED false)
+    BR_PROPERTY(br::Transform*, transform, NULL)
+
+    QList<Transform*> transforms;
+
+    QString description(bool expanded) const
+    {
+        return transform->description(expanded);
+    }
+
+    // can't use general setPropertyRecursive because of transforms oddness
+    bool setPropertyRecursive(const QString &name, QVariant value)
+    {
+        if (br::Object::setExistingProperty(name, value))
+            return true;
+
+        if (!transform->setPropertyRecursive(name, value))
+            return false;
+
+        for (int i=0;i < transforms.size();i++)
+            transforms[i]->setPropertyRecursive(name, value);
+
+        return true;
+    }
+
+    Transform *simplify(bool &newTransform)
+    {
+        newTransform = false;
+        bool newChild = false;
+        Transform *temp = transform->simplify(newChild);
+        if (temp == transform) {
+            return this;
+        }
+        IndependentTransform* indep = new IndependentTransform();
+        indep->transform = temp;
+
+        IndependentTransform *test = dynamic_cast<IndependentTransform *> (temp);
+        if (test) {
+            // child was independent? this changes things...
+            indep->transform = test->transform;
+            for (int i=0; i < transforms.size(); i++) {
+                bool newThing = false;
+                IndependentTransform *probe = dynamic_cast<IndependentTransform *> (transforms[i]->simplify(newThing));
+                indep->transforms.append(probe->transform);
+                if (newThing)
+                    probe->setParent(indep);
+            }
+            indep->file = indep->transform->file;
+            indep->trainable = indep->transform->trainable;
+            indep->setObjectName(indep->transform->objectName());
+
+            return indep;
+        }
+
+        if (newChild)
+            indep->transform->setParent(indep);
+
+        for (int i=0; i < transforms.size();i++) {
+            bool subTform = false;
+            indep->transforms.append(transforms[i]->simplify(subTform));
+            if (subTform)
+                indep->transforms[i]->setParent(indep);
+        }
+
+        indep->file = indep->transform->file;
+        indep->trainable = indep->transform->trainable;
+        indep->setObjectName(indep->transform->objectName());
+
+        return indep;
+    }
+
+    void init()
+    {
+        transforms.clear();
+        if (transform == NULL)
+            return;
+
+        transform->setParent(this);
+        transforms.append(transform);
+        file = transform->file;
+        trainable = transform->trainable;
+        setObjectName(transform->objectName());
+    }
+
+    Transform *clone() const
+    {
+        IndependentTransform *independentTransform = new IndependentTransform();
+        independentTransform->transform = transform->clone();
+        independentTransform->init();
+        return independentTransform;
+    }
+
+    bool timeVarying() const { return transform->timeVarying(); }
+
+    static void _train(Transform *transform, const TemplateList *data)
+    {
+        transform->train(*data);
+    }
+
+    void train(const TemplateList &data)
+    {
+        // Don't bother if the transform is untrainable
+        if (!trainable) return;
+
+        QList<TemplateList> templatesList;
+        foreach (const Template &t, data) {
+            if ((templatesList.size() != t.size()) && !templatesList.isEmpty())
+                qWarning("Independent::train (%s) template %s of size %d differs from expected size %d.", qPrintable(objectName()), qPrintable(t.file.name), t.size(), templatesList.size());
+            while (templatesList.size() < t.size())
+                templatesList.append(TemplateList());
+            for (int i=0; i<t.size(); i++)
+                templatesList[i].append(Template(t.file, t[i]));
+        }
+
+        while (transforms.size() < templatesList.size())
+            transforms.append(transform->clone());
+
+        QFutureSynchronizer<void> futures;
+        for (int i=0; i<templatesList.size(); i++)
+            futures.addFuture(QtConcurrent::run(_train, transforms[i], &templatesList[i]));
+        futures.waitForFinished();
+    }
+
+    void project(const Template &src, Template &dst) const
+    {
+        dst.file = src.file;
+        QList<Mat> mats;
+        for (int i=0; i<src.size(); i++) {
+            transforms[i%transforms.size()]->project(Template(src.file, src[i]), dst);
+            mats.append(dst);
+            dst.clear();
+        }
+        dst.append(mats);
+    }
+
+    void projectUpdate(const Template &src, Template &dst)
+    {
+        dst.file = src.file;
+        QList<Mat> mats;
+        for (int i=0; i<src.size(); i++) {
+            transforms[i%transforms.size()]->projectUpdate(Template(src.file, src[i]), dst);
+            mats.append(dst);
+            dst.clear();
+        }
+        dst.append(mats);
+    }
+
+    void finalize(TemplateList &out)
+    {
+        if (transforms.empty())
+            return;
+
+        transforms[0]->finalize(out);
+        for (int i=1; i < transforms.size(); i++) {
+            TemplateList temp;
+            transforms[i]->finalize(temp);
+
+            for (int j=0; j < out.size(); j++)
+                out[j].append(temp[j]);
+        }
+    }
+
+    void projectUpdate(const TemplateList &src, TemplateList &dst)
+    {
+        dst.reserve(src.size());
+        foreach (const Template &t, src) {
+            dst.append(Template());
+            projectUpdate(t, dst.last());
+        }
+    }
+
+    void store(QDataStream &stream) const
+    {
+        const int size = transforms.size();
+        stream << size;
+        for (int i=0; i<size; i++)
+            transforms[i]->store(stream);
+    }
+
+    void load(QDataStream &stream)
+    {
+        int size;
+        stream >> size;
+        while (transforms.size() < size)
+            transforms.append(transform->clone());
+        for (int i=0; i<size; i++)
+            transforms[i]->load(stream);
+    }
+};
+
+BR_REGISTER(Transform, IndependentTransform)
+
+} // namespace br
+
+#include "core/independent.moc"
 //Need to include location of jvm.dll (jdk version) and its parent directory in the environment variables
 #include <limits>
-#include "openbr_internal.h"
-#include "openbr/core/resource.h"
+#include <openbr/plugins/openbr_internal.h>
+#include <openbr/core/resource.h>
 #include <jni.h>
 namespace br
-#include <likely.h>
-#include <likely/opencv.hpp>
-
-#include "openbr/core/opencvutils.h"
-#include "openbr_internal.h"
+#include <openbr/plugins/openbr_internal.h>
 namespace br
 {
@@ -57,68 +53,6 @@ public:
 BR_REGISTER(Transform, LikelyTransform)
-/*!
- * \ingroup formats
- * \brief Likely matrix format
- *
- * www.liblikely.org
- * \author Josh Klontz \cite jklontz
- */
-class lmatFormat : public Format
-{
-    Q_OBJECT
-
-    Template read() const
-    {
-        const likely_const_mat m = likely_read(qPrintable(file.name), likely_file_guess);
-        const Template result(likelyToOpenCVMat(m));
-        likely_release_mat(m);
-        return result;
-    }
-
-    void write(const Template &t) const
-    {
-        const likely_const_mat m = likelyFromOpenCVMat(t);
-        likely_write(m, qPrintable(file.name));
-        likely_release_mat(m);
-    }
-};
-
-BR_REGISTER(Format, lmatFormat)
-
-/*!
- * \ingroup formats
- * \brief Likely matrix format
- *
- * www.liblikely.org
- * \author Josh Klontz \cite jklontz
- */
-class lmatGallery : public Gallery
-{
-    Q_OBJECT
-    QList<cv::Mat> mats;
-
-    ~lmatGallery()
-    {
-        const likely_const_mat m = likelyFromOpenCVMat(OpenCVUtils::toMatByRow(mats));
-        likely_write(m, qPrintable(file.name));
-        likely_release_mat(m);
-    }
-
-    TemplateList readBlock(bool *done)
-    {
-        *done = true;
-        qFatal("Not supported.");
-    }
-
-    void write(const Template &t)
-    {
-        mats.append(t);
-    }
-};
-
-BR_REGISTER(Gallery, lmatGallery)
-
 } // namespace br
-#include "likely.moc"
+#include "core/likely.moc"
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * Copyright 2012 The MITRE Corporation                                      *
+ *                                                                           *
+ * Licensed under the Apache License, Version 2.0 (the "License");           *
+ * you may not use this file except in compliance with the License.          *
+ * You may obtain a copy of the License at                                   *
+ *                                                                           *
+ *     http://www.apache.org/licenses/LICENSE-2.0                            *
+ *                                                                           *
+ * Unless required by applicable law or agreed to in writing, software       *
+ * distributed under the License is distributed on an "AS IS" BASIS,         *
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  *
+ * See the License for the specific language governing permissions and       *
+ * limitations under the License.                                            *
+ * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+
+#include <openbr/plugins/openbr_internal.h>
+#include <openbr/core/qtutils.h>
+
+namespace br
+{
+
+/*!
+ * \ingroup transforms
+ * \brief Caches transform training.
+ * \author Josh Klontz \cite jklontz
+ */
+class LoadStoreTransform : public MetaTransform
+{
+    Q_OBJECT
+    Q_PROPERTY(QString transformString READ get_transformString WRITE set_transformString RESET reset_transformString STORED false)
+    Q_PROPERTY(QString fileName READ get_fileName WRITE set_fileName RESET reset_fileName STORED false)
+    BR_PROPERTY(QString, transformString, "Identity")
+    BR_PROPERTY(QString, fileName, QString())
+
+public:
+    Transform *transform;
+
+    LoadStoreTransform() : transform(NULL) {}
+
+    QString description(bool expanded = false) const
+    {
+        if (expanded) {
+            QString res = transform->description(expanded);
+            return res;
+        }
+        return br::Object::description(expanded);
+    }
+
+    Transform *simplify(bool &newTForm)
+    {
+        Transform *res = transform->simplify(newTForm);
+        return res;
+    }
+
+    QList<Object *> getChildren() const
+    {
+        QList<Object *> rval;
+        rval.append(transform);
+        return rval;
+    }
+private:
+
+    void init()
+    {
+        if (transform != NULL) return;
+        if (fileName.isEmpty()) fileName = QRegExp("^[_a-zA-Z0-9]+$").exactMatch(transformString) ? transformString : QtUtils::shortTextHash(transformString);
+
+        if (!tryLoad())
+            transform = make(transformString);
+        else
+            trainable = false;
+    }
+
+    bool timeVarying() const
+    {
+        return transform->timeVarying();
+    }
+
+    void train(const QList<TemplateList> &data)
+    {
+        if (QFileInfo(getFileName()).exists())
+            return;
+
+        transform->train(data);
+
+        qDebug("Storing %s", qPrintable(fileName));
+        QtUtils::BlockCompression compressedOut;
+        QFile fout(fileName);
+        QtUtils::touchDir(fout);
+        compressedOut.setBasis(&fout);
+
+        QDataStream stream(&compressedOut);
+        QString desc = transform->description();
+
+        if (!compressedOut.open(QFile::WriteOnly))
+            qFatal("Failed to open %s for writing.", qPrintable(file));
+
+        stream << desc;
+        transform->store(stream);
+        compressedOut.close();
+    }
+
+    void project(const Template &src, Template &dst) const
+    {
+        transform->project(src, dst);
+    }
+
+    void project(const TemplateList &src, TemplateList &dst) const
+    {
+        transform->project(src, dst);
+    }
+
+    void projectUpdate(const Template &src, Template &dst)
+    {
+        transform->projectUpdate(src, dst);
+    }
+
+    void projectUpdate(const TemplateList &src, TemplateList &dst)
+    {
+        transform->projectUpdate(src, dst);
+    }
+
+    void finalize(TemplateList &output)
+    {
+        transform->finalize(output);
+    }
+
+    QString getFileName() const
+    {
+        if (QFileInfo(fileName).exists()) return fileName;
+        const QString file = Globals->sdkPath + "/share/openbr/models/transforms/" + fileName;
+        return QFileInfo(file).exists() ? file : QString();
+    }
+
+    bool tryLoad()
+    {
+        const QString file = getFileName();
+        if (file.isEmpty()) return false;
+
+        qDebug("Loading %s", qPrintable(file));
+        QFile fin(file);
+        QtUtils::BlockCompression reader(&fin);
+        if (!reader.open(QIODevice::ReadOnly)) {
+            if (QFileInfo(file).exists()) qFatal("Unable to open %s for reading. Check file permissions.", qPrintable(file));
+            else            qFatal("Unable to open %s for reading. File does not exist.", qPrintable(file));
+        }
+
+        QDataStream stream(&reader);
+        stream >> transformString;
+
+        transform = Transform::make(transformString);
+        transform->load(stream);
+
+        return true;
+    }
+};
+
+BR_REGISTER(Transform, LoadStoreTransform)
+
+} // namespace br
+
+#include "core/loadstore.moc"
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * Copyright 2012 The MITRE Corporation                                      *
+ *                                                                           *
+ * Licensed under the Apache License, Version 2.0 (the "License");           *
+ * you may not use this file except in compliance with the License.          *
+ * You may obtain a copy of the License at                                   *
+ *                                                                           *
+ *     http://www.apache.org/licenses/LICENSE-2.0                            *
+ *                                                                           *
+ * Unless required by applicable law or agreed to in writing, software       *
+ * distributed under the License is distributed on an "AS IS" BASIS,         *
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  *
+ * See the License for the specific language governing permissions and       *
+ * limitations under the License.                                            *
+ * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+
+#include <QtConcurrent>
+
+#include <openbr/plugins/openbr_internal.h>
+
+namespace br
+{
+
+/*!
+ * \ingroup Transforms
+ * \brief Transforms in series.
+ * \author Josh Klontz \cite jklontz
+ *
+ * The source br::Template is given to the first transform and the resulting br::Template is passed to the next transform, etc.
+ *
+ * \see ExpandTransform
+ * \see ForkTransform
+ */
+class PipeTransform : public CompositeTransform
+{
+    Q_OBJECT
+
+    void _projectPartial(TemplateList *srcdst, int startIndex, int stopIndex)
+    {
+        TemplateList ftes;
+        for (int i=startIndex; i<stopIndex; i++) {
+            TemplateList res;
+            transforms[i]->project(*srcdst, res);
+
+            splitFTEs(res, ftes);
+            *srcdst = res;
+        }
+    }
+
+    void train(const QList<TemplateList> &data)
+    {
+        if (!trainable) return;
+
+        QList<TemplateList> dataLines(data);
+
+        int i = 0;
+        while (i < transforms.size()) {
+            // Conditional statement covers likely case that first transform is untrainable
+            if (transforms[i]->trainable) {
+                qDebug() << "Training " << transforms[i]->description() << "\n...";
+                transforms[i]->train(dataLines);
+            }
+
+            // if the transform is time varying, we can't project it in parallel
+            if (transforms[i]->timeVarying()) {
+                qDebug() << "Projecting " << transforms[i]->description() << "\n...";
+                for (int j=0; j < dataLines.size();j++) {
+                    TemplateList junk;
+                    splitFTEs(dataLines[j], junk);
+
+                    transforms[i]->projectUpdate(dataLines[j], dataLines[j]);
+                }
+
+                // advance i since we already projected for this stage.
+                i++;
+
+                // the next stage might be trainable, so continue to evaluate it.
+                continue;
+            }
+
+            // We project through any subsequent untrainable transforms at once
+            //   as a memory optimization in case any of these intermediate
+            //   transforms allocate a lot of memory (like OpenTransform)
+            //   then we don't want all the training templates to be processed
+            //   by that transform at once if we can avoid it.
+            int nextTrainableTransform = i+1;
+            while ((nextTrainableTransform < transforms.size()) &&
+                   !transforms[nextTrainableTransform]->trainable &&
+                   !transforms[nextTrainableTransform]->timeVarying())
+                nextTrainableTransform++;
+
+            // No more trainable transforms? Don't need any more projects then
+            if (nextTrainableTransform == transforms.size())
+                break;
+
+            fprintf(stderr, "Projecting %s", qPrintable(transforms[i]->description()));
+            for (int j=i+1; j < nextTrainableTransform; j++)
+                fprintf(stderr,"+%s", qPrintable(transforms[j]->description()));
+            fprintf(stderr, "\n...\n");
+            fflush(stderr);
+
+            QFutureSynchronizer<void> futures;
+            for (int j=0; j < dataLines.size(); j++)
+                futures.addFuture(QtConcurrent::run(this, &PipeTransform::_projectPartial, &dataLines[j], i, nextTrainableTransform));
+            futures.waitForFinished();
+
+            i = nextTrainableTransform;
+        }
+    }
+
+    void projectUpdate(const Template &src, Template &dst)
+    {
+        dst = src;
+        foreach (Transform *f, transforms) {
+            try {
+                f->projectUpdate(dst);
+                if (dst.file.fte)
+                    break;
+            } catch (...) {
+                qWarning("Exception triggered when processing %s with transform %s", qPrintable(src.file.flat()), qPrintable(f->objectName()));
+                dst = Template(src.file);
+                dst.file.fte = true;
+                break;
+            }
+        }
+    }
+
+    // For time varying transforms, parallel execution over individual templates
+    // won't work.
+    void projectUpdate(const TemplateList &src, TemplateList &dst)
+    {
+        TemplateList ftes;
+        dst = src;
+        foreach (Transform *f, transforms) {
+            TemplateList res;
+            f->projectUpdate(dst, res);
+            splitFTEs(res, ftes);
+            dst = res;
+        }
+        dst.append(ftes);
+    }
+
+    virtual void finalize(TemplateList &output)
+    {
+        output.clear();
+        // For each transform,
+        for (int i = 0; i < transforms.size(); i++)
+        {
+
+            // Collect any final templates
+            TemplateList last_set;
+            transforms[i]->finalize(last_set);
+            if (last_set.empty())
+                continue;
+            // Push any templates received through the remaining transforms in the sequence
+            for (int j = (i+1); j < transforms.size();j++)
+            {
+                transforms[j]->projectUpdate(last_set);
+            }
+            // append the result to the output set
+            output.append(last_set);
+        }
+    }
+
+    void init()
+    {
+        QList<Transform *> flattened;
+        for (int i=0;i < transforms.size(); i++)
+        {
+            PipeTransform *probe = dynamic_cast<PipeTransform *> (transforms[i]);
+            if (!probe) {
+                flattened.append(transforms[i]);
+                continue;
+            }
+            for (int j=0; j < probe->transforms.size(); j++)
+                flattened.append(probe->transforms[j]);
+        }
+        transforms = flattened;
+
+        CompositeTransform::init();
+    }
+
+protected:
+    // Template list project -- process templates in parallel through Transform::project
+    // or if parallelism is disabled, handle them sequentially
+   void _project(const TemplateList &src, TemplateList &dst) const
+    {
+        TemplateList ftes;
+        dst = src;
+        foreach (const Transform *f, transforms) {
+            TemplateList res;
+            f->project(dst, res);
+            splitFTEs(res, ftes);
+            dst = res;
+        }
+        dst.append(ftes);
+    }
+
+   // Single template const project, pass the template through each sub-transform, one after the other
+   virtual void _project(const Template &src, Template &dst) const
+   {
+       dst = src;
+       foreach (const Transform *f, transforms) {
+           try {
+               dst >> *f;
+               if (dst.file.fte)
+                   break;
+           } catch (...) {
+               qWarning("Exception triggered when processing %s with transform %s", qPrintable(src.file.flat()), qPrintable(f->objectName()));
+               dst = Template(src.file);
+               dst.file.fte = true;
+           }
+       }
+   }
+};
+
+BR_REGISTER(Transform, PipeTransform)
+
+} // namespace br
+
+#include "core/pipe.moc"
-
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * Copyright 2012 The MITRE Corporation                                      *
+ *                                                                           *
+ * Licensed under the Apache License, Version 2.0 (the "License");           *
+ * you may not use this file except in compliance with the License.          *
+ * You may obtain a copy of the License at                                   *
+ *                                                                           *
+ *     http://www.apache.org/licenses/LICENSE-2.0                            *
+ *                                                                           *
+ * Unless required by applicable law or agreed to in writing, software       *
+ * distributed under the License is distributed on an "AS IS" BASIS,         *
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  *
+ * See the License for the specific language governing permissions and       *
+ * limitations under the License.                                            *
+ * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
 #include <QBuffer>
 #include <QCoreApplication>
@@ -9,8 +23,8 @@
 #include <QUuid>
 #include <QWaitCondition>
-#include "openbr_internal.h"
-#include "openbr/core/opencvutils.h"
+#include <openbr/plugins/openbr_internal.h>
+#include <openbr/core/opencvutils.h>
 using namespace cv;
@@ -658,4 +672,4 @@ BR_REGISTER(Transform, ProcessWrapperTransform)
 }
-#include "process.moc"
+#include "core/processwrapper.moc"
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * Copyright 2012 The MITRE Corporation                                      *
+ *                                                                           *
+ * Licensed under the Apache License, Version 2.0 (the "License");           *
+ * you may not use this file except in compliance with the License.          *
+ * You may obtain a copy of the License at                                   *
+ *                                                                           *
+ *     http://www.apache.org/licenses/LICENSE-2.0                            *
+ *                                                                           *
+ * Unless required by applicable law or agreed to in writing, software       *
+ * distributed under the License is distributed on an "AS IS" BASIS,         *
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  *
+ * See the License for the specific language governing permissions and       *
+ * limitations under the License.                                            *
+ * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+
+#include <QElapsedTimer>
+
+#include <openbr/plugins/openbr_internal.h>
+#include <openbr/core/qtutils.h>
+
+namespace br
+{
+
+class ProgressCounterTransform : public TimeVaryingTransform
+{
+    Q_OBJECT
+
+    Q_PROPERTY(qint64 totalProgress READ get_totalProgress WRITE set_totalProgress RESET reset_totalProgress STORED false)
+    BR_PROPERTY(qint64, totalProgress, 1)
+
+    void projectUpdate(const TemplateList &src, TemplateList &dst)
+    {
+        dst = src;
+
+        qint64 elapsed = timer.elapsed();
+        int last_frame = -2;
+        if (!dst.empty()) {
+            for (int i=0;i < dst.size();i++) {
+                int frame = dst[i].file.get<int>("FrameNumber", -1);
+                if (frame == last_frame && frame != -1)
+                    continue;
+
+                // Use 1 as the starting index for progress output
+                Globals->currentProgress = dst[i].file.get<qint64>("progress",0)+1;
+                dst[i].file.remove("progress");
+                last_frame = frame;
+
+                Globals->currentStep++;
+            }
+        }
+
+        // updated every second
+        if (elapsed > 1000) {
+            Globals->printStatus();
+            timer.start();
+        }
+
+        return;
+    }
+
+    void train(const TemplateList& data)
+    {
+        (void) data;
+    }
+
+    void finalize(TemplateList &data)
+    {
+        (void) data;
+        float p = br_progress();
+        qDebug("\r%05.2f%%  ELAPSED=%s  REMAINING=%s  COUNT=%g", p*100, QtUtils::toTime(Globals->startTime.elapsed()/1000.0f).toStdString().c_str(), QtUtils::toTime(0).toStdString().c_str(), Globals->currentStep);
+        timer.start();
+        Globals->startTime.start();
+        Globals->currentStep = 0;
+        Globals->currentProgress = 0;
+        Globals->totalSteps = totalProgress;
+    }
+
+    void init()
+    {
+        timer.start();
+        Globals->startTime.start();
+        Globals->currentProgress = 0;
+        Globals->currentStep = 0;
+        Globals->totalSteps = totalProgress;
+    }
+
+public:
+    ProgressCounterTransform() : TimeVaryingTransform(false,false) {}
+    QElapsedTimer timer;
+};
+
+BR_REGISTER(Transform, ProgressCounterTransform)
+
+} // namespace br
+
+#include "core/progresscounter.moc"
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * Copyright 2012 The MITRE Corporation                                      *
+ *                                                                           *
+ * Licensed under the Apache License, Version 2.0 (the "License");           *
+ * you may not use this file except in compliance with the License.          *
+ * You may obtain a copy of the License at                                   *
+ *                                                                           *
+ *     http://www.apache.org/licenses/LICENSE-2.0                            *
+ *                                                                           *
+ * Unless required by applicable law or agreed to in writing, software       *
+ * distributed under the License is distributed on an "AS IS" BASIS,         *
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  *
+ * See the License for the specific language governing permissions and       *
+ * limitations under the License.                                            *
+ * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+
+#include <openbr/plugins/openbr_internal.h>
+
+namespace br
+{
+
+/*!
+ * \ingroup initializers
+ * \brief Register custom objects with Qt meta object system.
+ * \author Charles Otto \cite caotto
+ */
+class Registrar : public Initializer
+{
+    Q_OBJECT
+
+    void initialize() const
+    {
+        qRegisterMetaType<br::Neighbors>();
+    }
+};
+
+BR_REGISTER(Initializer, Registrar)
+
+} // namespace br
+
+#include "core/registrar.moc"
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * Copyright 2012 The MITRE Corporation                                      *
+ *                                                                           *
+ * Licensed under the Apache License, Version 2.0 (the "License");           *
+ * you may not use this file except in compliance with the License.          *
+ * You may obtain a copy of the License at                                   *
+ *                                                                           *
+ *     http://www.apache.org/licenses/LICENSE-2.0                            *
+ *                                                                           *
+ * Unless required by applicable law or agreed to in writing, software       *
+ * distributed under the License is distributed on an "AS IS" BASIS,         *
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  *
+ * See the License for the specific language governing permissions and       *
+ * limitations under the License.                                            *
+ * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+
+#include <openbr/plugins/openbr_internal.h>
+
+namespace br
+{
+
+/*!
+ * \ingroup transforms
+ * \brief Removes the matrix from the template at the specified index.
+ * \author Josh Klontz \cite jklontz
+ * \see IdentityTransform DiscardTransform FirstTransform RestTransform
+ */
+//! [example_transform]
+class RemoveTransform : public UntrainableMetaTransform
+{
+    Q_OBJECT
+    Q_PROPERTY(int index READ get_index WRITE set_index RESET reset_index STORED false)
+    BR_PROPERTY(int, index, 0)
+
+    void project(const Template &src, Template &dst) const
+    {
+        dst = src;
+        dst.removeAt(index);
+    }
+};
+
+BR_REGISTER(Transform, RemoveTransform)
+//! [example_transform]
+
+} // namespace br
+
+#include "core/remove.moc"
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * Copyright 2012 The MITRE Corporation                                      *
+ *                                                                           *
+ * Licensed under the Apache License, Version 2.0 (the "License");           *
+ * you may not use this file except in compliance with the License.          *
+ * You may obtain a copy of the License at                                   *
+ *                                                                           *
+ *     http://www.apache.org/licenses/LICENSE-2.0                            *
+ *                                                                           *
+ * Unless required by applicable law or agreed to in writing, software       *
+ * distributed under the License is distributed on an "AS IS" BASIS,         *
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  *
+ * See the License for the specific language governing permissions and       *
+ * limitations under the License.                                            *
+ * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+
+#include <openbr/plugins/openbr_internal.h>
+
+namespace br
+{
+
+/*!
+ * \ingroup transforms
+ * \brief Removes the first matrix from the template.
+ * \see IdentityTransform DiscardTransform FirstTransform RemoveTransform
+ * \author Josh Klontz \cite jklontz
+ */
+class RestTransform : public UntrainableMetaTransform
+{
+    Q_OBJECT
+
+    void project(const Template &src, Template &dst) const
+    {
+        dst = src;
+        dst.removeFirst();
+    }
+};
+
+BR_REGISTER(Transform, RestTransform)
+
+} // namespace br
+
+#include "core/rest.moc"
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * Copyright 2012 The MITRE Corporation                                      *
+ *                                                                           *
+ * Licensed under the Apache License, Version 2.0 (the "License");           *
+ * you may not use this file except in compliance with the License.          *
+ * You may obtain a copy of the License at                                   *
+ *                                                                           *
+ *     http://www.apache.org/licenses/LICENSE-2.0                            *
+ *                                                                           *
+ * Unless required by applicable law or agreed to in writing, software       *
+ * distributed under the License is distributed on an "AS IS" BASIS,         *
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  *
+ * See the License for the specific language governing permissions and       *
+ * limitations under the License.                                            *
+ * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+
+#include <openbr/plugins/openbr_internal.h>
+
+namespace br
+{
+
+/*!
+ * \ingroup transforms
+ * \brief Generates two templates, one of which is passed through a transform and the other
+ *        is not. No cats were harmed in the making of this transform.
+ * \author Scott Klum \cite sklum
+ */
+class SchrodingerTransform : public MetaTransform
+{
+    Q_OBJECT
+    Q_PROPERTY(br::Transform* transform READ get_transform WRITE set_transform RESET reset_transform)
+    BR_PROPERTY(br::Transform*, transform, NULL)
+
+public:
+    void train(const TemplateList &data)
+    {
+        transform->train(data);
+    }
+
+    void project(const TemplateList &src, TemplateList &dst) const
+    {
+        foreach(const Template &t, src) {
+            dst.append(t);
+            Template u;
+            transform->project(t,u);
+            dst.append(u);
+        }
+    }
+
+    void project(const Template &src, Template &dst) const {
+        TemplateList temp;
+        project(TemplateList() << src, temp);
+        if (!temp.isEmpty()) dst = temp.first();
+    }
+
+};
+BR_REGISTER(Transform, SchrodingerTransform)
+
+} // namespace br
+
+#include "core/schrodinger.moc"
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * Copyright 2012 The MITRE Corporation                                      *
+ *                                                                           *
+ * Licensed under the Apache License, Version 2.0 (the "License");           *
+ * you may not use this file except in compliance with the License.          *
+ * You may obtain a copy of the License at                                   *
+ *                                                                           *
+ *     http://www.apache.org/licenses/LICENSE-2.0                            *
+ *                                                                           *
+ * Unless required by applicable law or agreed to in writing, software       *
+ * distributed under the License is distributed on an "AS IS" BASIS,         *
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  *
+ * See the License for the specific language governing permissions and       *
+ * limitations under the License.                                            *
+ * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+
+#include <openbr/plugins/openbr_internal.h>
+
+namespace br
+{
+
+/*!
+ * \ingroup transforms
+ * \brief A globally shared transform.
+ * \author Josh Klontz \cite jklontz
+ */
+class SingletonTransform : public MetaTransform
+{
+    Q_OBJECT
+    Q_PROPERTY(QString description READ get_description WRITE set_description RESET reset_description STORED false)
+    BR_PROPERTY(QString, description, "Identity")
+
+    static QMutex mutex;
+    static QHash<QString,Transform*> transforms;
+    static QHash<QString,int> trainingReferenceCounts;
+    static QHash<QString,TemplateList> trainingData;
+
+    Transform *transform;
+
+    void init()
+    {
+        QMutexLocker locker(&mutex);
+        if (!transforms.contains(description)) {
+            transforms.insert(description, make(description));
+            trainingReferenceCounts.insert(description, 0);
+        }
+
+        transform = transforms[description];
+        trainingReferenceCounts[description]++;
+    }
+
+    void train(const TemplateList &data)
+    {
+        QMutexLocker locker(&mutex);
+        trainingData[description].append(data);
+        trainingReferenceCounts[description]--;
+        if (trainingReferenceCounts[description] > 0) return;
+        transform->train(trainingData[description]);
+        trainingData[description].clear();
+    }
+
+    void project(const Template &src, Template &dst) const
+    {
+        transform->project(src, dst);
+    }
+
+    void store(QDataStream &stream) const
+    {
+        if (transform->parent() == this)
+            transform->store(stream);
+    }
+
+    void load(QDataStream &stream)
+    {
+        if (transform->parent() == this)
+            transform->load(stream);
+    }
+};
+
+QMutex SingletonTransform::mutex;
+QHash<QString,Transform*> SingletonTransform::transforms;
+QHash<QString,int> SingletonTransform::trainingReferenceCounts;
+QHash<QString,TemplateList> SingletonTransform::trainingData;
+
+BR_REGISTER(Transform, SingletonTransform)
+
+} // namespace br
+
+#include "core/singleton.moc"
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * Copyright 2012 The MITRE Corporation                                      *
+ *                                                                           *
+ * Licensed under the Apache License, Version 2.0 (the "License");           *
+ * you may not use this file except in compliance with the License.          *
+ * You may obtain a copy of the License at                                   *
+ *                                                                           *
+ *     http://www.apache.org/licenses/LICENSE-2.0                            *
+ *                                                                           *
+ * Unless required by applicable law or agreed to in writing, software       *
+ * distributed under the License is distributed on an "AS IS" BASIS,         *
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  *
+ * See the License for the specific language governing permissions and       *
+ * limitations under the License.                                            *
+ * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+
 #include <fstream>
 #include <QReadWriteLock>
 #include <QWaitCondition>
@@ -8,10 +24,11 @@
 #include <QtConcurrent>
 #include <opencv/highgui.h>
 #include <opencv2/highgui/highgui.hpp>
-#include "openbr_internal.h"
-#include "openbr/core/common.h"
-#include "openbr/core/opencvutils.h"
-#include "openbr/core/qtutils.h"
+
+#include <openbr/plugins/openbr_internal.h>
+#include <openbr/core/common.h>
+#include <openbr/core/opencvutils.h>
+#include <openbr/core/qtutils.h>
 using namespace cv;
 using namespace std;
@@ -1360,5 +1377,5 @@ BR_REGISTER(Transform, StreamTransform)
 } // namespace br
-#include "stream.moc"
+#include "core/stream.moc"
-/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
- * Copyright 2012 The MITRE Corporation                                      *
- *                                                                           *
- * Licensed under the Apache License, Version 2.0 (the "License");           *
- * you may not use this file except in compliance with the License.          *
- * You may obtain a copy of the License at                                   *
- *                                                                           *
- *     http://www.apache.org/licenses/LICENSE-2.0                            *
- *                                                                           *
- * Unless required by applicable law or agreed to in writing, software       *
- * distributed under the License is distributed on an "AS IS" BASIS,         *
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  *
- * See the License for the specific language governing permissions and       *
- * limitations under the License.                                            *
- * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
-
-#include <opencv2/imgproc/imgproc.hpp>
-#include "openbr_internal.h"
-
-#include "openbr/core/opencvutils.h"
-
-using namespace cv;
-
-namespace br
-{
-
-/*!
- * \ingroup transforms
- * \brief Crops about the specified region of interest.
- * \author Josh Klontz \cite jklontz
- */
-class CropTransform : public UntrainableTransform
-{
-    Q_OBJECT
-    Q_PROPERTY(int x READ get_x WRITE set_x RESET reset_x STORED false)
-    Q_PROPERTY(int y READ get_y WRITE set_y RESET reset_y STORED false)
-    Q_PROPERTY(int width READ get_width WRITE set_width RESET reset_width STORED false)
-    Q_PROPERTY(int height READ get_height WRITE set_height RESET reset_height STORED false)
-    BR_PROPERTY(int, x, 0)
-    BR_PROPERTY(int, y, 0)
-    BR_PROPERTY(int, width, -1)
-    BR_PROPERTY(int, height, -1)
-
-    void project(const Template &src, Template &dst) const
-    {
-        dst = Mat(src, Rect(x, y, width < 1 ? src.m().cols-x-abs(width) : width, height < 1 ? src.m().rows-y-abs(height) : height));
-    }
-};
-
-BR_REGISTER(Transform, CropTransform)
-
-/*!
- * \ingroup transforms
- * \brief Crops the rectangular regions of interest.
- * \author Josh Klontz \cite jklontz
- */
-class ROITransform : public UntrainableTransform
-{
-    Q_OBJECT
-    Q_PROPERTY(QString propName READ get_propName WRITE set_propName RESET reset_propName STORED false)
-    BR_PROPERTY(QString, propName, "")
-
-    void project(const Template &src, Template &dst) const
-    {
-        if (!propName.isEmpty()) {
-            QRectF rect = src.file.get<QRectF>(propName);
-            dst += src.m()(OpenCVUtils::toRect(rect));
-        } else if (!src.file.rects().empty()) {
-            foreach (const QRectF &rect, src.file.rects())
-                dst += src.m()(OpenCVUtils::toRect(rect));
-        } else if (src.file.contains(QStringList() << "X" << "Y" << "Width" << "Height")) {
-            dst += src.m()(Rect(src.file.get<int>("X"),
-                                src.file.get<int>("Y"),
-                                src.file.get<int>("Width"),
-                                src.file.get<int>("Height")));
-        } else {
-            dst = src;
-            if (Globals->verbose)
-                qWarning("No rects present in file.");
-        }
-    }
-};
-
-BR_REGISTER(Transform, ROITransform)
-
-/*!
- * \ingroup transforms
- * \brief Crops the rectangular regions of interest from given points and sizes.
- * \author Austin Blanton \cite imaus10
- */
-class ROIFromPtsTransform : public UntrainableTransform
-{
-    Q_OBJECT
-    Q_PROPERTY(int width READ get_width WRITE set_width RESET reset_width STORED false)
-    Q_PROPERTY(int height READ get_height WRITE set_height RESET reset_height STORED false)
-    BR_PROPERTY(int, width, 1)
-    BR_PROPERTY(int, height, 1)
-
-    void project(const Template &src, Template &dst) const
-    {
-        foreach (const QPointF &pt, src.file.points()) {
-            int x = pt.x() - (width/2);
-            int y = pt.y() - (height/2);
-            dst += src.m()(Rect(x, y, width, height));
-        }
-    }
-};
-
-BR_REGISTER(Transform, ROIFromPtsTransform)
-
-/*!
- * \ingroup transforms
- * \brief Resize the template
- * \author Josh Klontz \cite jklontz
- * \note Method: Area should be used for shrinking an image, Cubic for slow but accurate enlargment, Bilin for fast enlargement.
- * \param preserveAspect If true, the image will be sized per specification, but
- * 	a border will be applied to preserve aspect ratio.
- */
-class ResizeTransform : public UntrainableTransform
-{
-    Q_OBJECT
-    Q_ENUMS(Method)
-
-public:
-    /*!< */
-    enum Method { Near = INTER_NEAREST,
-                  Area = INTER_AREA,
-                  Bilin = INTER_LINEAR,
-                  Cubic = INTER_CUBIC,
-                  Lanczo = INTER_LANCZOS4};
-
-private:
-    Q_PROPERTY(int rows READ get_rows WRITE set_rows RESET reset_rows STORED false)
-    Q_PROPERTY(int columns READ get_columns WRITE set_columns RESET reset_columns STORED false)
-    Q_PROPERTY(Method method READ get_method WRITE set_method RESET reset_method STORED false)
-    Q_PROPERTY(bool preserveAspect READ get_preserveAspect WRITE set_preserveAspect RESET reset_preserveAspect STORED false)
-    BR_PROPERTY(int, rows, -1)
-    BR_PROPERTY(int, columns, -1)
-    BR_PROPERTY(Method, method, Bilin)
-    BR_PROPERTY(bool, preserveAspect, false)
-
-    void project(const Template &src, Template &dst) const
-    {
-        if (!preserveAspect)
-            resize(src, dst, Size((columns == -1) ? src.m().cols*rows/src.m().rows : columns, rows), 0, 0, method);
-        else {
-            float inRatio = (float) src.m().rows / src.m().cols;
-            float outRatio = (float) rows / columns;
-            dst = Mat::zeros(rows, columns, src.m().type());
-            if (outRatio > inRatio) {
-                float heightAR = src.m().rows * inRatio / outRatio;
-                Mat buffer;
-                resize(src, buffer, Size(columns, heightAR), 0, 0, method);
-                buffer.copyTo(dst.m()(Rect(0, (rows - heightAR) / 2, columns, heightAR)));
-            } else {
-                float widthAR = src.m().cols / inRatio * outRatio;
-                Mat buffer;
-                resize(src, buffer, Size(widthAR, rows), 0, 0, method);
-                buffer.copyTo(dst.m()(Rect((columns - widthAR) / 2, 0, widthAR, rows)));
-            }
-        }
-    }
-};
-
-BR_REGISTER(Transform, ResizeTransform)
-
-/*!
- * \ingroup transforms
- * \brief Limit the size of the template
- * \author Josh Klontz \cite jklontz
- */
-class LimitSizeTransform : public UntrainableTransform
-{
-    Q_OBJECT
-    Q_PROPERTY(int max READ get_max WRITE set_max RESET reset_max STORED false)
-    BR_PROPERTY(int, max, -1)
-
-    void project(const Template &src, Template &dst) const
-    {
-        const Mat &m = src;
-        if (m.rows > m.cols)
-            if (m.rows > max) resize(m, dst, Size(std::max(1, m.cols * max / m.rows), max));
-            else              dst = m;
-        else
-            if (m.cols > max) resize(m, dst, Size(max, std::max(1, m.rows * max / m.cols)));
-            else              dst = m;
-    }
-};
-
-BR_REGISTER(Transform, LimitSizeTransform)
-
-/*!
- * \ingroup transforms
- * \brief Enforce a multiple of \em n columns.
- * \author Josh Klontz \cite jklontz
- */
-class DivTransform : public UntrainableTransform
-{
-    Q_OBJECT
-    Q_PROPERTY(int n READ get_n WRITE set_n RESET reset_n STORED false)
-    BR_PROPERTY(int, n, 1)
-
-    void project(const Template &src, Template &dst) const
-    {
-        dst = Mat(src, Rect(0,0,n*(src.m().cols/n),src.m().rows));
-    }
-};
-
-BR_REGISTER(Transform, DivTransform)
-
-/*!
- * \ingroup transforms
- * \brief Crop out black borders
- * \author Josh Klontz \cite jklontz
- */
-class CropBlackTransform : public UntrainableTransform
-{
-    Q_OBJECT
-
-    void project(const Template &src, Template &dst) const
-    {
-        Mat gray;
-        OpenCVUtils::cvtGray(src, gray);
-
-        int xStart = 0;
-        while (xStart < gray.cols) {
-            if (mean(gray.col(xStart))[0] >= 1) break;
-            xStart++;
-        }
-
-        int xEnd = gray.cols - 1;
-        while (xEnd >= 0) {
-            if (mean(gray.col(xEnd))[0] >= 1) break;
-            xEnd--;
-        }
-
-        int yStart = 0;
-        while (yStart < gray.rows) {
-            if (mean(gray.col(yStart))[0] >= 1) break;
-            yStart++;
-        }
-
-        int yEnd = gray.rows - 1;
-        while (yEnd >= 0) {
-            if (mean(gray.col(yEnd))[0] >= 1) break;
-            yEnd--;
-        }
-
-        dst = src.m()(Rect(xStart, yStart, xEnd-xStart, yEnd-yStart));
-    }
-};
-
-BR_REGISTER(Transform, CropBlackTransform)
-
-/*!
- * \ingroup transforms
- * \brief Divide the matrix into 4 smaller matricies of equal size.
- * \author Josh Klontz \cite jklontz
- */
-class SubdivideTransform : public UntrainableTransform
-{
-    Q_OBJECT
-
-    void project(const Template &src, Template &dst) const
-    {
-        const Mat &m = src;
-        const int subrows = m.rows/2;
-        const int subcolumns = m.cols/2;
-        dst.append(Mat(m,Rect(0,          0, subcolumns, subrows)).clone());
-        dst.append(Mat(m,Rect(subcolumns, 0, subcolumns, subrows)).clone());
-        dst.append(Mat(m,Rect(0,          subrows, subcolumns, subrows)).clone());
-        dst.append(Mat(m,Rect(subcolumns, subrows, subcolumns, subrows)).clone());
-    }
-};
-
-BR_REGISTER(Transform, SubdivideTransform)
-
-/*!
- * \ingroup transforms
- * \brief Trim the image so the width and the height are the same size.
- * \author Josh Klontz \cite jklontz
- */
-class CropSquareTransform : public UntrainableTransform
-{
-    Q_OBJECT
-
-    void project(const Template &src, Template &dst) const
-    {
-        const Mat &m = src;
-        const int newSize = min(m.rows, m.cols);
-        dst = Mat(m, Rect((m.cols-newSize)/2, (m.rows-newSize)/2, newSize, newSize));
-    }
-};
-
-BR_REGISTER(Transform, CropSquareTransform)
-
-} // namespace br
-
-#include "crop.moc"
-/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
- * Copyright 2012 The MITRE Corporation                                      *
- *                                                                           *
- * Licensed under the Apache License, Version 2.0 (the "License");           *
- * you may not use this file except in compliance with the License.          *
- * You may obtain a copy of the License at                                   *
- *                                                                           *
- *     http://www.apache.org/licenses/LICENSE-2.0                            *
- *                                                                           *
- * Unless required by applicable law or agreed to in writing, software       *
- * distributed under the License is distributed on an "AS IS" BASIS,         *
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  *
- * See the License for the specific language governing permissions and       *
- * limitations under the License.                                            *
- * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
-
-#include <opencv2/imgproc/imgproc_c.h>
-#include <opencv2/imgproc/imgproc.hpp>
-#include "openbr_internal.h"
-#include "openbr/core/opencvutils.h"
-
-using namespace cv;
-
-namespace br
-{
-
-/*!
- * \ingroup transforms
- * \brief Colorspace conversion.
- * \author Josh Klontz \cite jklontz
- */
-class CvtTransform : public UntrainableTransform
-{
-    Q_OBJECT
-    Q_ENUMS(ColorSpace)
-    Q_PROPERTY(ColorSpace colorSpace READ get_colorSpace WRITE set_colorSpace RESET reset_colorSpace STORED false)
-    Q_PROPERTY(int channel READ get_channel WRITE set_channel RESET reset_channel STORED false)
-
-public:
-    enum ColorSpace { Gray = CV_BGR2GRAY,
-                      RGBGray = CV_RGB2GRAY,
-                      HLS = CV_BGR2HLS,
-                      HSV = CV_BGR2HSV,
-                      Lab = CV_BGR2Lab,
-                      Luv = CV_BGR2Luv,
-                      RGB = CV_BGR2RGB,
-                      XYZ = CV_BGR2XYZ,
-                      YCrCb = CV_BGR2YCrCb,
-                      Color = CV_GRAY2BGR };
-
-private:
-    BR_PROPERTY(ColorSpace, colorSpace, Gray)
-    BR_PROPERTY(int, channel, -1)
-
-    void project(const Template &src, Template &dst) const
-    {
-        if (src.m().channels() > 1 || colorSpace == CV_GRAY2BGR) cvtColor(src, dst, colorSpace);
-        else dst = src;
-
-        if (channel != -1) {
-            std::vector<Mat> mv;
-            split(dst, mv);
-            dst = mv[channel % (int)mv.size()];
-        }
-    }
-};
-
-BR_REGISTER(Transform, CvtTransform)
-
-/*!
- * \ingroup transforms
- * \brief Convert to floating point format.
- * \author Josh Klontz \cite jklontz
- */
-class CvtFloatTransform : public UntrainableTransform
-{
-    Q_OBJECT
-
-    void project(const Template &src, Template &dst) const
-    {
-        src.m().convertTo(dst, CV_32F);
-    }
-};
-
-BR_REGISTER(Transform, CvtFloatTransform)
-
-/*!
- * \ingroup transforms
- * \brief Convert to uchar format
- * \author Josh Klontz \cite jklontz
- */
-class CvtUCharTransform : public UntrainableTransform
-{
-    Q_OBJECT
-
-    void project(const Template &src, Template &dst) const
-    {
-        OpenCVUtils::cvtUChar(src, dst);
-    }
-};
-
-BR_REGISTER(Transform, CvtUCharTransform)
-
-/*!
- * \ingroup transforms
- * \brief Scales using the given factor
- * \author Scott Klum \cite sklum
- */
-class ScaleTransform : public UntrainableTransform
-{
-    Q_OBJECT
-
-    Q_PROPERTY(float scaleFactor READ get_scaleFactor WRITE set_scaleFactor RESET reset_scaleFactor STORED false)
-    BR_PROPERTY(float, scaleFactor, 1.)
-
-    void project(const Template &src, Template &dst) const
-    {
-         resize(src, dst, Size(src.m().cols*scaleFactor,src.m().rows*scaleFactor));
-    }
-};
-
-BR_REGISTER(Transform, ScaleTransform)
-
-/*!
- * \ingroup transforms
- * \brief Split a multi-channel matrix into several single-channel matrices.
- * \author Josh Klontz \cite jklontz
- */
-class SplitChannelsTransform : public UntrainableTransform
-{
-    Q_OBJECT
-
-    void project(const Template &src, Template &dst) const
-    {
-        std::vector<Mat> mv;
-        split(src, mv);
-        foreach (const Mat &m, mv)
-            dst += m;
-    }
-};
-
-BR_REGISTER(Transform, SplitChannelsTransform)
-
-/*!
- * \ingroup transforms
- * \brief Enforce the matrix has a certain number of channels by adding or removing channels.
- * \author Josh Klontz \cite jklontz
- */
-class EnsureChannelsTransform : public UntrainableTransform
-{
-    Q_OBJECT
-    Q_PROPERTY(int n READ get_n WRITE set_n RESET reset_n STORED false)
-    BR_PROPERTY(int, n, 1)
-
-    void project(const Template &src, Template &dst) const
-    {
-        if (src.m().channels() == n) {
-            dst = src;
-        } else {
-            std::vector<Mat> mv;
-            split(src, mv);
-
-            // Add extra channels
-            while ((int)mv.size() < n) {
-                for (int i=0; i<src.m().channels(); i++) {
-                    mv.push_back(mv[i]);
-                    if ((int)mv.size() == n)
-                        break;
-                }
-            }
-
-            // Remove extra channels
-            while ((int)mv.size() > n)
-                mv.pop_back();
-
-            merge(mv, dst);
-        }
-    }
-};
-
-BR_REGISTER(Transform, EnsureChannelsTransform)
-
-/*!
- * \ingroup transforms
- * \brief Drop the alpha channel (if exists).
- * \author Austin Blanton \cite imaus10
- */
-class DiscardAlphaTransform : public UntrainableTransform
-{
-    Q_OBJECT
-
-    void project(const Template &src, Template &dst) const
-    {
-        if (src.m().channels() > 4 || src.m().channels() == 2) {
-            dst.file.fte = true;
-            return;
-        }
-
-        dst = src;
-        if (src.m().channels() == 4) {
-            std::vector<Mat> mv;
-            split(src, mv);
-            mv.pop_back();
-            merge(mv, dst);
-        }
-    }
-};
-
-BR_REGISTER(Transform, DiscardAlphaTransform)
-
-/*!
- * \ingroup transforms
- * \brief Normalized RG color space.
- * \author Josh Klontz \cite jklontz
- */
-class RGTransform : public UntrainableTransform
-{
-    Q_OBJECT
-
-    void project(const Template &src, Template &dst) const
-    {
-        if (src.m().type() != CV_8UC3)
-            qFatal("Expected CV_8UC3 images.");
-
-        const Mat &m = src.m();
-        Mat R(m.size(), CV_8UC1); // R / (R+G+B)
-        Mat G(m.size(), CV_8UC1); // G / (R+G+B)
-
-        for (int i=0; i<m.rows; i++)
-            for (int j=0; j<m.cols; j++) {
-                Vec3b v = m.at<Vec3b>(i,j);
-                const int b = v[0];
-                const int g = v[1];
-                const int r = v[2];
-                const int sum = b + g + r;
-                if (sum > 0) {
-                    R.at<uchar>(i, j) = saturate_cast<uchar>(255.0*r/(r+g+b));
-                    G.at<uchar>(i, j) = saturate_cast<uchar>(255.0*g/(r+g+b));
-                } else {
-                    R.at<uchar>(i, j) = 0;
-                    G.at<uchar>(i, j) = 0;
-                }
-            }
-
-        dst.append(R);
-        dst.append(G);
-    }
-};
-
-BR_REGISTER(Transform, RGTransform)
-
-/*!
- * \ingroup transforms
- * \brief dst = a*src+b
- * \author Josh Klontz \cite jklontz
- */
-class MAddTransform : public UntrainableTransform
-{
-    Q_OBJECT
-    Q_PROPERTY(double a READ get_a WRITE set_a RESET reset_a STORED false)
-    Q_PROPERTY(double b READ get_b WRITE set_b RESET reset_b STORED false)
-    BR_PROPERTY(double, a, 1)
-    BR_PROPERTY(double, b, 0)
-
-    void project(const Template &src, Template &dst) const
-    {
-        src.m().convertTo(dst.m(), src.m().depth(), a, b);
-    }
-};
-
-BR_REGISTER(Transform, MAddTransform)
-
-/*!
- * \ingroup transforms
- * \brief Computes the absolute value of each element.
- * \author Josh Klontz \cite jklontz
- */
-class AbsTransform : public UntrainableTransform
-{
-    Q_OBJECT
-
-    void project(const Template &src, Template &dst) const
-    {
-        dst = abs(src);
-    }
-};
-
-BR_REGISTER(Transform, AbsTransform)
-
-} // namespace br
-
-#include "cvt.moc"
-/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
- * Copyright 2012 The MITRE Corporation                                      *
- *                                                                           *
- * Licensed under the Apache License, Version 2.0 (the "License");           *
- * you may not use this file except in compliance with the License.          *
- * You may obtain a copy of the License at                                   *
- *                                                                           *
- *     http://www.apache.org/licenses/LICENSE-2.0                            *
- *                                                                           *
- * Unless required by applicable law or agreed to in writing, software       *
- * distributed under the License is distributed on an "AS IS" BASIS,         *
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  *
- * See the License for the specific language governing permissions and       *
- * limitations under the License.                                            *
- * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
-
-#include <QFutureSynchronizer>
-#include <QtConcurrentRun>
-#include <numeric>
-#include <opencv2/imgproc/imgproc.hpp>
-#include <opencv2/imgproc/imgproc_c.h>
-#include "openbr_internal.h"
-
-#include "openbr/core/distance_sse.h"
-#include "openbr/core/qtutils.h"
-#include "openbr/core/opencvutils.h"
-
-using namespace cv;
-
-namespace br
-{
-
-/*!
- * \ingroup distances
- * \brief Standard distance metrics
- * \author Josh Klontz \cite jklontz
- */
-class DistDistance : public UntrainableDistance
-{
-    Q_OBJECT
-    Q_ENUMS(Metric)
-    Q_PROPERTY(Metric metric READ get_metric WRITE set_metric RESET reset_metric STORED false)
-    Q_PROPERTY(bool negLogPlusOne READ get_negLogPlusOne WRITE set_negLogPlusOne RESET reset_negLogPlusOne STORED false)
-
-public:
-    /*!< */
-    enum Metric { Correlation,
-                  ChiSquared,
-                  Intersection,
-                  Bhattacharyya,
-                  INF,
-                  L1,
-                  L2,
-                  Cosine,
-                  Dot};
-
-private:
-    BR_PROPERTY(Metric, metric, L2)
-    BR_PROPERTY(bool, negLogPlusOne, true)
-
-    float compare(const Mat &a, const Mat &b) const
-    {
-        if ((a.size != b.size) ||
-            (a.type() != b.type()))
-                return -std::numeric_limits<float>::max();
-
-// TODO: this max value is never returned based on the switch / default 
-        float result = std::numeric_limits<float>::max();
-        switch (metric) {
-          case Correlation:
-            return compareHist(a, b, CV_COMP_CORREL);
-          case ChiSquared:
-            result = compareHist(a, b, CV_COMP_CHISQR);
-            break;
-          case Intersection:
-            result = compareHist(a, b, CV_COMP_INTERSECT);
-            break;
-          case Bhattacharyya:
-            result = compareHist(a, b, CV_COMP_BHATTACHARYYA);
-            break;
-          case INF:
-            result = norm(a, b, NORM_INF);
-            break;
-          case L1:
-            result = norm(a, b, NORM_L1);
-            break;
-          case L2:
-            result = norm(a, b, NORM_L2);
-            break;
-          case Cosine:
-            return cosine(a, b);
-          case Dot:
-            return a.dot(b);
-          default:
-            qFatal("Invalid metric");
-        }
-
-        if (result != result)
-            qFatal("NaN result.");
-
-        return negLogPlusOne ? -log(result+1) : result;
-    }
-
-    static float cosine(const Mat &a, const Mat &b)
-    {
-        float dot = 0;
-        float magA = 0;
-        float magB = 0;
-
-        for (int row=0; row<a.rows; row++) {
-            for (int col=0; col<a.cols; col++) {
-                const float target = a.at<float>(row,col);
-                const float query = b.at<float>(row,col);
-                dot += target * query;
-                magA += target * target;
-                magB += query * query;
-            }
-        }
-
-        return dot / (sqrt(magA)*sqrt(magB));
-    }
-};
-
-BR_REGISTER(Distance, DistDistance)
-
-/*!
- * \ingroup distances
- * \brief DistDistance wrapper.
- * \author Josh Klontz \cite jklontz
- */
-class DefaultDistance : public UntrainableDistance
-{
-    Q_OBJECT
-    Distance *distance;
-
-    void init()
-    {
-        distance = Distance::make("Dist("+file.suffix()+")");
-    }
-
-    float compare(const cv::Mat &a, const cv::Mat &b) const
-    {
-        return distance->compare(a, b);
-    }
-};
-
-BR_REGISTER(Distance, DefaultDistance)
-
-/*!
- * \ingroup distances
- * \brief Distances in series.
- * \author Josh Klontz \cite jklontz
- *
- * The templates are compared using each br::Distance in order.
- * If the result of the comparison with any given distance is -FLOAT_MAX then this result is returned early.
- * Otherwise the returned result is the value of comparing the templates using the last br::Distance.
- */
-class PipeDistance : public Distance
-{
-    Q_OBJECT
-    Q_PROPERTY(QList<br::Distance*> distances READ get_distances WRITE set_distances RESET reset_distances)
-    BR_PROPERTY(QList<br::Distance*>, distances, QList<br::Distance*>())
-
-    void train(const TemplateList &data)
-    {
-        QFutureSynchronizer<void> futures;
-        foreach (br::Distance *distance, distances)
-            futures.addFuture(QtConcurrent::run(distance, &Distance::train, data));
-        futures.waitForFinished();
-    }
-
-    float compare(const Template &a, const Template &b) const
-    {
-        float result = -std::numeric_limits<float>::max();
-        foreach (br::Distance *distance, distances) {
-            result = distance->compare(a, b);
-            if (result == -std::numeric_limits<float>::max())
-                return result;
-        }
-        return result;
-    }
-};
-
-BR_REGISTER(Distance, PipeDistance)
-
-/*!
- * \ingroup distances
- * \brief Fuses similarity scores across multiple matrices of compared templates
- * \author Scott Klum \cite sklum
- * \note Operation: Mean, sum, min, max are supported.
- */
-class FuseDistance : public Distance
-{
-    Q_OBJECT
-    Q_ENUMS(Operation)
-    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<float> weights READ get_weights WRITE set_weights RESET reset_weights STORED false)
-
-    QList<br::Distance*> distances;
-
-public:
-    /*!< */
-    enum Operation {Mean, Sum, Max, Min};
-
-private:
-    BR_PROPERTY(QString, description, "L2")
-    BR_PROPERTY(Operation, operation, Mean)
-    BR_PROPERTY(QList<float>, weights, QList<float>())
-
-    void train(const TemplateList &src)
-    {
-        // Partition the templates by matrix
-        QList<int> split;
-        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> scores;
-        for (int i=0; i<distances.size(); i++) {
-            float weight;
-            weights.isEmpty() ? weight = 1. : weight = weights[i];
-            scores.append(weight*distances[i]->compare(Template(a.file, a[i]),Template(b.file, b[i])));
-        }
-
-        switch (operation) {
-          case Mean:
-            return std::accumulate(scores.begin(),scores.end(),0.0)/(float)scores.size();
-            break;
-          case Sum:
-            return std::accumulate(scores.begin(),scores.end(),0.0);
-            break;
-          case Min:
-            return *std::min_element(scores.begin(),scores.end());
-            break;
-          case Max:
-            return *std::max_element(scores.begin(),scores.end());
-            break;
-          default:
-            qFatal("Invalid operation.");
-        }
-        return 0;
-    }
-
-    void store(QDataStream &stream) const
-    {
-        stream << distances.size();
-        foreach (Distance *distance, distances)
-            distance->store(stream);
-    }
-
-    void load(QDataStream &stream)
-    {
-        int numDistances;
-        stream >> numDistances;
-        while (distances.size() < numDistances)
-            distances.append(make(description));
-        foreach (Distance *distance, distances)
-            distance->load(stream);
-    }
-};
-
-BR_REGISTER(Distance, FuseDistance)
-
-/*!
- * \ingroup distances
- * \brief Fast 8-bit L1 distance
- * \author Josh Klontz \cite jklontz
- */
-class ByteL1Distance : public UntrainableDistance
-{
-    Q_OBJECT
-
-    float compare(const unsigned char *a, const unsigned char *b, size_t size) const
-    {
-        return l1(a, b, size);
-    }
-};
-
-BR_REGISTER(Distance, ByteL1Distance)
-
-/*!
- * \ingroup distances
- * \brief Fast 4-bit L1 distance
- * \author Josh Klontz \cite jklontz
- */
-class HalfByteL1Distance : public UntrainableDistance
-{
-    Q_OBJECT
-
-    float compare(const Mat &a, const Mat &b) const
-    {
-        return packed_l1(a.data, b.data, a.total());
-    }
-};
-
-BR_REGISTER(Distance, HalfByteL1Distance)
-
-/*!
- * \ingroup distances
- * \brief Returns -log(distance(a,b)+1)
- * \author Josh Klontz \cite jklontz
- */
-class NegativeLogPlusOneDistance : public UntrainableDistance
-{
-    Q_OBJECT
-    Q_PROPERTY(br::Distance* distance READ get_distance WRITE set_distance RESET reset_distance STORED false)
-    BR_PROPERTY(br::Distance*, distance, NULL)
-
-    void train(const TemplateList &src)
-    {
-        distance->train(src);
-    }
-
-    float compare(const Template &a, const Template &b) const
-    {
-        return -log(distance->compare(a,b)+1);
-    }
-
-    void store(QDataStream &stream) const
-    {
-        distance->store(stream);
-    }
-
-    void load(QDataStream &stream)
-    {
-        distance->load(stream);
-    }
-};
-
-BR_REGISTER(Distance, NegativeLogPlusOneDistance)
-
-/*!
- * \ingroup distances
- * \brief Returns \c true if the templates are identical, \c false otherwise.
- * \author Josh Klontz \cite jklontz
- */
-class IdenticalDistance : public UntrainableDistance
-{
-    Q_OBJECT
-
-    float compare(const Mat &a, const Mat &b) const
-    {
-        const size_t size = a.total() * a.elemSize();
-        if (size != b.total() * b.elemSize()) return 0;
-        for (size_t i=0; i<size; i++)
-            if (a.data[i] != b.data[i]) return 0;
-        return 1;
-    }
-};        
-
-BR_REGISTER(Distance, IdenticalDistance)
-
-/*!
- * \ingroup distances
- * \brief Online distance metric to attenuate match scores across multiple frames
- * \author Brendan klare \cite bklare
- */
-class OnlineDistance : public UntrainableDistance
-{
-    Q_OBJECT
-    Q_PROPERTY(br::Distance* distance READ get_distance WRITE set_distance RESET reset_distance STORED false)
-    Q_PROPERTY(float alpha READ get_alpha WRITE set_alpha RESET reset_alpha STORED false)
-    BR_PROPERTY(br::Distance*, distance, NULL)
-    BR_PROPERTY(float, alpha, 0.1f)
-
-    mutable QHash<QString,float> scoreHash;
-    mutable QMutex mutex;
-
-    float compare(const Template &target, const Template &query) const
-    {
-        float currentScore = distance->compare(target, query);
-
-        QMutexLocker mutexLocker(&mutex);
-        return scoreHash[target.file.name] = (1.0- alpha) * scoreHash[target.file.name] + alpha * currentScore;
-    }
-};
-
-BR_REGISTER(Distance, OnlineDistance)
-
-/*!
- * \ingroup distances
- * \brief Attenuation function based distance from attributes
- * \author Scott Klum \cite sklum
- */
-class AttributeDistance : public UntrainableDistance
-{
-    Q_OBJECT
-    Q_PROPERTY(QString attribute READ get_attribute WRITE set_attribute RESET reset_attribute STORED false)
-    BR_PROPERTY(QString, attribute, QString())
-
-    float compare(const Template &target, const Template &query) const
-    {
-        float queryValue = query.file.get<float>(attribute);
-        float targetValue = target.file.get<float>(attribute);
-
-        // TODO: Set this magic number to something meaningful
-        float stddev = 1;
-
-        if (queryValue == targetValue) return 1;
-        else return 1/(stddev*sqrt(2*CV_PI))*exp(-0.5*pow((targetValue-queryValue)/stddev, 2));
-    }
-};
-
-BR_REGISTER(Distance, AttributeDistance)
-
-/*!
- * \ingroup distances
- * \brief Sum match scores across multiple distances
- * \author Scott Klum \cite sklum
- */
-class SumDistance : public UntrainableDistance
-{
-    Q_OBJECT
-    Q_PROPERTY(QList<br::Distance*> distances READ get_distances WRITE set_distances RESET reset_distances)
-    BR_PROPERTY(QList<br::Distance*>, distances, QList<br::Distance*>())
-
-    void train(const TemplateList &data)
-    {
-        QFutureSynchronizer<void> futures;
-        foreach (br::Distance *distance, distances)
-            futures.addFuture(QtConcurrent::run(distance, &Distance::train, data));
-        futures.waitForFinished();
-    }
-
-    float compare(const Template &target, const Template &query) const
-    {
-        float result = 0;
-
-        foreach (br::Distance *distance, distances) {
-            result += distance->compare(target, query);
-
-            if (result == -std::numeric_limits<float>::max())
-                return result;
-        }
-
-        return result;
-    }
-};
-
-BR_REGISTER(Distance, SumDistance)
-
-/*!
- * \ingroup transforms
- * \brief Compare each template to a fixed gallery (with name = galleryName), using the specified distance.
- * dst will contain a 1 by n vector of scores.
- * \author Charles Otto \cite caotto
- */
-class GalleryCompareTransform : public Transform
-{
-    Q_OBJECT
-    Q_PROPERTY(br::Distance *distance READ get_distance WRITE set_distance RESET reset_distance STORED true)
-    Q_PROPERTY(QString galleryName READ get_galleryName WRITE set_galleryName RESET reset_galleryName STORED false)
-    BR_PROPERTY(br::Distance*, distance, NULL)
-    BR_PROPERTY(QString, galleryName, "")
-
-    TemplateList gallery;
-
-    void project(const Template &src, Template &dst) const
-    {
-        dst = src;
-        if (gallery.isEmpty())
-            return;
-
-        QList<float> line = distance->compare(gallery, src);
-        dst.m() = OpenCVUtils::toMat(line, 1);
-    }
-
-    void init()
-    {
-        if (!galleryName.isEmpty())
-            gallery = TemplateList::fromGallery(galleryName);
-    }
-
-    void train(const TemplateList &data)
-    {
-        gallery = data;
-    }
-
-    void store(QDataStream &stream) const
-    {
-        br::Object::store(stream);
-        stream << gallery;
-    }
-
-    void load(QDataStream &stream)
-    {
-        br::Object::load(stream);
-        stream >> gallery;
-    }
-
-public:
-    GalleryCompareTransform() : Transform(false, true) {}
-};
-
-BR_REGISTER(Transform, GalleryCompareTransform)
-
-
-} // namespace br
-#include "distance.moc"
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * Copyright 2012 The MITRE Corporation                                      *
+ *                                                                           *
+ * Licensed under the Apache License, Version 2.0 (the "License");           *
+ * you may not use this file except in compliance with the License.          *
+ * You may obtain a copy of the License at                                   *
+ *                                                                           *
+ *     http://www.apache.org/licenses/LICENSE-2.0                            *
+ *                                                                           *
+ * Unless required by applicable law or agreed to in writing, software       *
+ * distributed under the License is distributed on an "AS IS" BASIS,         *
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  *
+ * See the License for the specific language governing permissions and       *
+ * limitations under the License.                                            *
+ * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+
+#include <Eigen/Dense>
+
+#include <openbr/plugins/openbr_internal.h>
+
+namespace br
+{
+
+/*!
+ * \ingroup distances
+ * \brief L2 distance computed using eigen.
+ * \author Josh Klontz \cite jklontz
+ */
+class L2Distance : public UntrainableDistance
+{
+    Q_OBJECT
+
+    float compare(const cv::Mat &a, const cv::Mat &b) const
+    {
+        const int size = a.rows * a.cols;
+        Eigen::Map<Eigen::VectorXf> aMap((float*)a.data, size);
+        Eigen::Map<Eigen::VectorXf> bMap((float*)b.data, size);
+        return (aMap-bMap).squaredNorm();
+    }
+};
+
+BR_REGISTER(Distance, L2Distance)
+
+} // namespace br
+
+#include "distance/L2.moc"
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * Copyright 2012 The MITRE Corporation                                      *
+ *                                                                           *
+ * Licensed under the Apache License, Version 2.0 (the "License");           *
+ * you may not use this file except in compliance with the License.          *
+ * You may obtain a copy of the License at                                   *
+ *                                                                           *
+ *     http://www.apache.org/licenses/LICENSE-2.0                            *
+ *                                                                           *
+ * Unless required by applicable law or agreed to in writing, software       *
+ * distributed under the License is distributed on an "AS IS" BASIS,         *
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  *
+ * See the License for the specific language governing permissions and       *
+ * limitations under the License.                                            *
+ * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+
+#include <openbr/plugins/openbr_internal.h>
+
+namespace br
+{
+
+/*!
+ * \ingroup distances
+ * \brief Attenuation function based distance from attributes
+ * \author Scott Klum \cite sklum
+ */
+class AttributeDistance : public UntrainableDistance
+{
+    Q_OBJECT
+    Q_PROPERTY(QString attribute READ get_attribute WRITE set_attribute RESET reset_attribute STORED false)
+    BR_PROPERTY(QString, attribute, QString())
+
+    float compare(const Template &target, const Template &query) const
+    {
+        float queryValue = query.file.get<float>(attribute);
+        float targetValue = target.file.get<float>(attribute);
+
+        // TODO: Set this magic number to something meaningful
+        float stddev = 1;
+
+        if (queryValue == targetValue) return 1;
+        else return 1/(stddev*sqrt(2*CV_PI))*exp(-0.5*pow((targetValue-queryValue)/stddev, 2));
+    }
+};
+
+BR_REGISTER(Distance, AttributeDistance)
+
+} // namespace br
+
+#include "distance/attribute.moc"
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * Copyright 2012 The MITRE Corporation                                      *
+ *                                                                           *
+ * Licensed under the Apache License, Version 2.0 (the "License");           *
+ * you may not use this file except in compliance with the License.          *
+ * You may obtain a copy of the License at                                   *
+ *                                                                           *
+ *     http://www.apache.org/licenses/LICENSE-2.0                            *
+ *                                                                           *
+ * Unless required by applicable law or agreed to in writing, software       *
+ * distributed under the License is distributed on an "AS IS" BASIS,         *
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  *
+ * See the License for the specific language governing permissions and       *
+ * limitations under the License.                                            *
+ * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+
+#include <QtConcurrent>
+
+#include <openbr/plugins/openbr_internal.h>
+#include <openbr/core/opencvutils.h>
+
+using namespace cv;
+
+namespace br
+{
+
+/*!
+ * \ingroup distances
+ * \brief Bayesian quantization distance
+ * \author Josh Klontz \cite jklontz
+ */
+class BayesianQuantizationDistance : public Distance
+{
+    Q_OBJECT
+
+    Q_PROPERTY(QString inputVariable READ get_inputVariable WRITE set_inputVariable RESET reset_inputVariable STORED false)
+    BR_PROPERTY(QString, inputVariable, "Label")
+
+    QVector<float> loglikelihoods;
+
+    static void computeLogLikelihood(const Mat &data, const QList<int> &labels, float *loglikelihood)
+    {
+        const QList<uchar> vals = OpenCVUtils::matrixToVector<uchar>(data);
+        if (vals.size() != labels.size())
+            qFatal("Logic error.");
+
+        QVector<quint64> genuines(256, 0), impostors(256,0);
+        for (int i=0; i<vals.size(); i++)
+            for (int j=i+1; j<vals.size(); j++)
+                if (labels[i] == labels[j]) genuines[abs(vals[i]-vals[j])]++;
+                else                        impostors[abs(vals[i]-vals[j])]++;
+
+        quint64 totalGenuines(0), totalImpostors(0);
+        for (int i=0; i<256; i++) {
+            totalGenuines += genuines[i];
+            totalImpostors += impostors[i];
+        }
+
+        for (int i=0; i<256; i++)
+            loglikelihood[i] = log((float(genuines[i]+1)/totalGenuines)/(float(impostors[i]+1)/totalImpostors));
+    }
+
+    void train(const TemplateList &src)
+    {
+        if ((src.first().size() > 1) || (src.first().m().type() != CV_8UC1))
+            qFatal("Expected sigle matrix templates of type CV_8UC1!");
+
+        const Mat data = OpenCVUtils::toMat(src.data());
+        const QList<int> templateLabels = src.indexProperty(inputVariable);
+        loglikelihoods = QVector<float>(data.cols*256, 0);
+
+        QFutureSynchronizer<void> futures;
+        for (int i=0; i<data.cols; i++)
+            futures.addFuture(QtConcurrent::run(&BayesianQuantizationDistance::computeLogLikelihood, data.col(i), templateLabels, &loglikelihoods.data()[i*256]));
+        futures.waitForFinished();
+    }
+
+    float compare(const cv::Mat &a, const cv::Mat &b) const
+    {
+        const uchar *aData = a.data;
+        const uchar *bData = b.data;
+        const int size = a.rows * a.cols;
+        float likelihood = 0;
+        for (int i=0; i<size; i++)
+            likelihood += loglikelihoods[i*256+abs(aData[i]-bData[i])];
+        return likelihood;
+    }
+
+    void store(QDataStream &stream) const
+    {
+        stream << loglikelihoods;
+    }
+
+    void load(QDataStream &stream)
+    {
+        stream >> loglikelihoods;
+    }
+};
+
+BR_REGISTER(Distance, BayesianQuantizationDistance)
+
+} // namespace br
+
+#include "distance/bayesianquantization.moc"
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * Copyright 2012 The MITRE Corporation                                      *
+ *                                                                           *
+ * Licensed under the Apache License, Version 2.0 (the "License");           *
+ * you may not use this file except in compliance with the License.          *
+ * You may obtain a copy of the License at                                   *
+ *                                                                           *
+ *     http://www.apache.org/licenses/LICENSE-2.0                            *
+ *                                                                           *
+ * Unless required by applicable law or agreed to in writing, software       *
+ * distributed under the License is distributed on an "AS IS" BASIS,         *
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  *
+ * See the License for the specific language governing permissions and       *
+ * limitations under the License.                                            *
+ * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+
+#include <openbr/plugins/openbr_internal.h>
+#include <openbr/core/distance_sse.h>
+
+namespace br
+{
+
+/*!
+ * \ingroup distances
+ * \brief Fast 8-bit L1 distance
+ * \author Josh Klontz \cite jklontz
+ */
+class ByteL1Distance : public UntrainableDistance
+{
+    Q_OBJECT
+
+    float compare(const unsigned char *a, const unsigned char *b, size_t size) const
+    {
+        return l1(a, b, size);
+    }
+};
+
+BR_REGISTER(Distance, ByteL1Distance)
+
+} // namespace br
+
+#include "distance/byteL1.moc"
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * Copyright 2012 The MITRE Corporation                                      *
+ *                                                                           *
+ * Licensed under the Apache License, Version 2.0 (the "License");           *
+ * you may not use this file except in compliance with the License.          *
+ * You may obtain a copy of the License at                                   *
+ *                                                                           *
+ *     http://www.apache.org/licenses/LICENSE-2.0                            *
+ *                                                                           *
+ * Unless required by applicable law or agreed to in writing, software       *
+ * distributed under the License is distributed on an "AS IS" BASIS,         *
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  *
+ * See the License for the specific language governing permissions and       *
+ * limitations under the License.                                            *
+ * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+
+#include <openbr/plugins/openbr_internal.h>
+
+namespace br
+{
+
+/*!
+ * \ingroup distances
+ * \brief Cross validate a distance metric.
+ * \author Josh Klontz \cite jklontz
+ */
+class CrossValidateDistance : public UntrainableDistance
+{
+    Q_OBJECT
+
+    float compare(const Template &a, const Template &b) const
+    {
+        static const QString key("Partition"); // More efficient to preallocate this
+        const int partitionA = a.file.get<int>(key, 0);
+        const int partitionB = b.file.get<int>(key, 0);
+        return (partitionA != partitionB) ? -std::numeric_limits<float>::max() : 0;
+    }
+};
+
+BR_REGISTER(Distance, CrossValidateDistance)
+
+} // namespace br
+
+#include "distance/crossvalidate.moc"
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * Copyright 2012 The MITRE Corporation                                      *
+ *                                                                           *
+ * Licensed under the Apache License, Version 2.0 (the "License");           *
+ * you may not use this file except in compliance with the License.          *
+ * You may obtain a copy of the License at                                   *
+ *                                                                           *
+ *     http://www.apache.org/licenses/LICENSE-2.0                            *
+ *                                                                           *
+ * Unless required by applicable law or agreed to in writing, software       *
+ * distributed under the License is distributed on an "AS IS" BASIS,         *
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  *
+ * See the License for the specific language governing permissions and       *
+ * limitations under the License.                                            *
+ * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+
+#include <openbr/plugins/openbr_internal.h>
+
+namespace br
+{
+
+/*!
+ * \ingroup distances
+ * \brief DistDistance wrapper.
+ * \author Josh Klontz \cite jklontz
+ */
+class DefaultDistance : public UntrainableDistance
+{
+    Q_OBJECT
+    Distance *distance;
+
+    void init()
+    {
+        distance = Distance::make("Dist("+file.suffix()+")");
+    }
+
+    float compare(const cv::Mat &a, const cv::Mat &b) const
+    {
+        return distance->compare(a, b);
+    }
+};
+
+BR_REGISTER(Distance, DefaultDistance)
+
+} // namespace br
+
+#include "distance/default.moc"
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * Copyright 2012 The MITRE Corporation                                      *
+ *                                                                           *
+ * Licensed under the Apache License, Version 2.0 (the "License");           *
+ * you may not use this file except in compliance with the License.          *
+ * You may obtain a copy of the License at                                   *
+ *                                                                           *
+ *     http://www.apache.org/licenses/LICENSE-2.0                            *
+ *                                                                           *
+ * Unless required by applicable law or agreed to in writing, software       *
+ * distributed under the License is distributed on an "AS IS" BASIS,         *
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  *
+ * See the License for the specific language governing permissions and       *
+ * limitations under the License.                                            *
+ * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+
+#include <opencv2/imgproc/imgproc.hpp>
+#include <openbr/plugins/openbr_internal.h>
+
+using namespace cv;
+
+namespace br
+{
+
+/*!
+ * \ingroup distances
+ * \brief Standard distance metrics
+ * \author Josh Klontz \cite jklontz
+ */
+class DistDistance : public UntrainableDistance
+{
+    Q_OBJECT
+    Q_ENUMS(Metric)
+    Q_PROPERTY(Metric metric READ get_metric WRITE set_metric RESET reset_metric STORED false)
+    Q_PROPERTY(bool negLogPlusOne READ get_negLogPlusOne WRITE set_negLogPlusOne RESET reset_negLogPlusOne STORED false)
+
+public:
+    /*!< */
+    enum Metric { Correlation,
+                  ChiSquared,
+                  Intersection,
+                  Bhattacharyya,
+                  INF,
+                  L1,
+                  L2,
+                  Cosine,
+                  Dot};
+
+private:
+    BR_PROPERTY(Metric, metric, L2)
+    BR_PROPERTY(bool, negLogPlusOne, true)
+
+    float compare(const Mat &a, const Mat &b) const
+    {
+        if ((a.size != b.size) ||
+            (a.type() != b.type()))
+                return -std::numeric_limits<float>::max();
+
+// TODO: this max value is never returned based on the switch / default
+        float result = std::numeric_limits<float>::max();
+        switch (metric) {
+          case Correlation:
+            return compareHist(a, b, CV_COMP_CORREL);
+          case ChiSquared:
+            result = compareHist(a, b, CV_COMP_CHISQR);
+            break;
+          case Intersection:
+            result = compareHist(a, b, CV_COMP_INTERSECT);
+            break;
+          case Bhattacharyya:
+            result = compareHist(a, b, CV_COMP_BHATTACHARYYA);
+            break;
+          case INF:
+            result = norm(a, b, NORM_INF);
+            break;
+          case L1:
+            result = norm(a, b, NORM_L1);
+            break;
+          case L2:
+            result = norm(a, b, NORM_L2);
+            break;
+          case Cosine:
+            return cosine(a, b);
+          case Dot:
+            return a.dot(b);
+          default:
+            qFatal("Invalid metric");
+        }
+
+        if (result != result)
+            qFatal("NaN result.");
+
+        return negLogPlusOne ? -log(result+1) : result;
+    }
+
+    static float cosine(const Mat &a, const Mat &b)
+    {
+        float dot = 0;
+        float magA = 0;
+        float magB = 0;
+
+        for (int row=0; row<a.rows; row++) {
+            for (int col=0; col<a.cols; col++) {
+                const float target = a.at<float>(row,col);
+                const float query = b.at<float>(row,col);
+                dot += target * query;
+                magA += target * target;
+                magB += query * query;
+            }
+        }
+
+        return dot / (sqrt(magA)*sqrt(magB));
+    }
+};
+
+BR_REGISTER(Distance, DistDistance)
+
+} // namespace br
+
+#include "distance/dist.moc"
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * Copyright 2012 The MITRE Corporation                                      *
+ *                                                                           *
+ * Licensed under the Apache License, Version 2.0 (the "License");           *
+ * you may not use this file except in compliance with the License.          *
+ * You may obtain a copy of the License at                                   *
+ *                                                                           *
+ *     http://www.apache.org/licenses/LICENSE-2.0                            *
+ *                                                                           *
+ * Unless required by applicable law or agreed to in writing, software       *
+ * distributed under the License is distributed on an "AS IS" BASIS,         *
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  *
+ * See the License for the specific language governing permissions and       *
+ * limitations under the License.                                            *
+ * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+
+#include <openbr/plugins/openbr_internal.h>
+
+namespace br
+{
+
+/*!
+ * \ingroup distances
+ * \brief Checks target metadata against filters.
+ * \author Josh Klontz \cite jklontz
+ */
+class FilterDistance : public UntrainableDistance
+{
+    Q_OBJECT
+
+    float compare(const Template &a, const Template &b) const
+    {
+        (void) b; // Query template isn't checked
+        foreach (const QString &key, Globals->filters.keys()) {
+            bool keep = false;
+            const QString metadata = a.file.get<QString>(key, "");
+            if (Globals->filters[key].isEmpty()) continue;
+            if (metadata.isEmpty()) return -std::numeric_limits<float>::max();
+            foreach (const QString &value, Globals->filters[key]) {
+                if (metadata == value) {
+                    keep = true;
+                    break;
+                }
+            }
+            if (!keep) return -std::numeric_limits<float>::max();
+        }
+        return 0;
+    }
+};
+
+BR_REGISTER(Distance, FilterDistance)
+
+} // namespace br
+
+#include "distance/filter.moc"
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * Copyright 2012 The MITRE Corporation                                      *
+ *                                                                           *
+ * Licensed under the Apache License, Version 2.0 (the "License");           *
+ * you may not use this file except in compliance with the License.          *
+ * You may obtain a copy of the License at                                   *
+ *                                                                           *
+ *     http://www.apache.org/licenses/LICENSE-2.0                            *
+ *                                                                           *
+ * Unless required by applicable law or agreed to in writing, software       *
+ * distributed under the License is distributed on an "AS IS" BASIS,         *
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  *
+ * See the License for the specific language governing permissions and       *
+ * limitations under the License.                                            *
+ * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+
+#include <numeric>
+
+#include <openbr/plugins/openbr_internal.h>
+
+namespace br
+{
+
+/*!
+ * \ingroup distances
+ * \brief Fuses similarity scores across multiple matrices of compared templates
+ * \author Scott Klum \cite sklum
+ * \note Operation: Mean, sum, min, max are supported.
+ */
+class FuseDistance : public Distance
+{
+    Q_OBJECT
+    Q_ENUMS(Operation)
+    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<float> weights READ get_weights WRITE set_weights RESET reset_weights STORED false)
+
+    QList<br::Distance*> distances;
+
+public:
+    /*!< */
+    enum Operation {Mean, Sum, Max, Min};
+
+private:
+    BR_PROPERTY(QString, description, "L2")
+    BR_PROPERTY(Operation, operation, Mean)
+    BR_PROPERTY(QList<float>, weights, QList<float>())
+
+    void train(const TemplateList &src)
+    {
+        // Partition the templates by matrix
+        QList<int> split;
+        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> scores;
+        for (int i=0; i<distances.size(); i++) {
+            float weight;
+            weights.isEmpty() ? weight = 1. : weight = weights[i];
+            scores.append(weight*distances[i]->compare(Template(a.file, a[i]),Template(b.file, b[i])));
+        }
+
+        switch (operation) {
+          case Mean:
+            return std::accumulate(scores.begin(),scores.end(),0.0)/(float)scores.size();
+            break;
+          case Sum:
+            return std::accumulate(scores.begin(),scores.end(),0.0);
+            break;
+          case Min:
+            return *std::min_element(scores.begin(),scores.end());
+            break;
+          case Max:
+            return *std::max_element(scores.begin(),scores.end());
+            break;
+          default:
+            qFatal("Invalid operation.");
+        }
+        return 0;
+    }
+
+    void store(QDataStream &stream) const
+    {
+        stream << distances.size();
+        foreach (Distance *distance, distances)
+            distance->store(stream);
+    }
+
+    void load(QDataStream &stream)
+    {
+        int numDistances;
+        stream >> numDistances;
+        while (distances.size() < numDistances)
+            distances.append(make(description));
+        foreach (Distance *distance, distances)
+            distance->load(stream);
+    }
+};
+
+BR_REGISTER(Distance, FuseDistance)
+
+} // namespace br
+
+#include "distance/fuse.moc"
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * Copyright 2012 The MITRE Corporation                                      *
+ *                                                                           *
+ * Licensed under the Apache License, Version 2.0 (the "License");           *
+ * you may not use this file except in compliance with the License.          *
+ * You may obtain a copy of the License at                                   *
+ *                                                                           *
+ *     http://www.apache.org/licenses/LICENSE-2.0                            *
+ *                                                                           *
+ * Unless required by applicable law or agreed to in writing, software       *
+ * distributed under the License is distributed on an "AS IS" BASIS,         *
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  *
+ * See the License for the specific language governing permissions and       *
+ * limitations under the License.                                            *
+ * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+
+#include <openbr/plugins/openbr_internal.h>
+#include <openbr/core/distance_sse.h>
+
+using namespace cv;
+
+namespace br
+{
+
+/*!
+ * \ingroup distances
+ * \brief Fast 4-bit L1 distance
+ * \author Josh Klontz \cite jklontz
+ */
+class HalfByteL1Distance : public UntrainableDistance
+{
+    Q_OBJECT
+
+    float compare(const Mat &a, const Mat &b) const
+    {
+        return packed_l1(a.data, b.data, a.total());
+    }
+};
+
+BR_REGISTER(Distance, HalfByteL1Distance)
+
+
+} // namespace br
+
+#include "distance/halfbyteL1.moc"
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * Copyright 2012 The MITRE Corporation                                      *
+ *                                                                           *
+ * Licensed under the Apache License, Version 2.0 (the "License");           *
+ * you may not use this file except in compliance with the License.          *
+ * You may obtain a copy of the License at                                   *
+ *                                                                           *
+ *     http://www.apache.org/licenses/LICENSE-2.0                            *
+ *                                                                           *
+ * Unless required by applicable law or agreed to in writing, software       *
+ * distributed under the License is distributed on an "AS IS" BASIS,         *
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  *
+ * See the License for the specific language governing permissions and       *
+ * limitations under the License.                                            *
+ * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+
+#include <openbr/plugins/openbr_internal.h>
+
+namespace br
+{
+
+/*!
+ * \ingroup distances
+ * \brief 1v1 heat map comparison
+ * \author Scott Klum \cite sklum
+ */
+class HeatMapDistance : public Distance
+{
+    Q_OBJECT
+    Q_PROPERTY(QString description READ get_description WRITE set_description RESET reset_description STORED false)
+    Q_PROPERTY(int step READ get_step WRITE set_step RESET reset_step STORED false)
+    Q_PROPERTY(QString inputVariable READ get_inputVariable WRITE set_inputVariable RESET reset_inputVariable STORED false)
+    BR_PROPERTY(QString, description, "IdenticalDistance")
+    BR_PROPERTY(int, step, 1)
+    BR_PROPERTY(QString, inputVariable, "Label")
+
+    QList<br::Distance*> distances;
+
+    void train(const TemplateList &src)
+    {
+        QList<TemplateList> patches;
+
+        // Split src into list of TemplateLists of corresponding patches across all Templates
+        for (int i=0; i<step; i++) {
+            TemplateList patchBuffer;
+            for (int j=0; j<src.size(); j++)
+                patchBuffer.append(Template(src[j].file, src[j][i]));
+            patches.append(patchBuffer);
+            patchBuffer.clear();
+        }
+
+        while (distances.size() < patches.size())
+            distances.append(make(description));
+
+        // Train on a distance for each patch
+        for (int i=0; i<distances.size(); i++)
+            distances[i]->train(patches[i]);
+    }
+
+    float compare(const cv::Mat &target, const cv::Mat &query) const
+    {
+        (void) target;
+        (void) query;
+        qFatal("Heatmap Distance not compatible with Template to Template comparison.");
+
+        return 0;
+    }
+
+    void compare(const TemplateList &target, const TemplateList &query, Output *output) const
+    {
+        for (int i=0; i<target.size(); i++) {
+            if (target[i].size() != step || query[i].size() != step) qFatal("Heatmap step not equal to the number of patches.");
+            for (int j=0; j<step; j++)
+                output->setRelative(distances[j]->compare(target[i][j],query[i][j]), j, 0);
+        }
+     }
+
+    void store(QDataStream &stream) const
+    {
+        stream << distances.size();
+        foreach (Distance *distance, distances)
+            distance->store(stream);
+    }
+
+    void load(QDataStream &stream)
+    {
+        int numDistances;
+        stream >> numDistances;
+        while (distances.size() < numDistances)
+            distances.append(make(description));
+        foreach (Distance *distance, distances)
+            distance->load(stream);
+    }
+};
+
+BR_REGISTER(Distance, HeatMapDistance)
+
+} // namespace br
+
+#include "distance/heatmap.moc"
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * Copyright 2012 The MITRE Corporation                                      *
+ *                                                                           *
+ * Licensed under the Apache License, Version 2.0 (the "License");           *
+ * you may not use this file except in compliance with the License.          *
+ * You may obtain a copy of the License at                                   *
+ *                                                                           *
+ *     http://www.apache.org/licenses/LICENSE-2.0                            *
+ *                                                                           *
+ * Unless required by applicable law or agreed to in writing, software       *
+ * distributed under the License is distributed on an "AS IS" BASIS,         *
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  *
+ * See the License for the specific language governing permissions and       *
+ * limitations under the License.                                            *
+ * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+
+#include <openbr/plugins/openbr_internal.h>
+
+using namespace cv;
+
+namespace br
+{
+
+/*!
+ * \ingroup distances
+ * \brief Returns \c true if the templates are identical, \c false otherwise.
+ * \author Josh Klontz \cite jklontz
+ */
+class IdenticalDistance : public UntrainableDistance
+{
+    Q_OBJECT
+
+    float compare(const Mat &a, const Mat &b) const
+    {
+        const size_t size = a.total() * a.elemSize();
+        if (size != b.total() * b.elemSize()) return 0;
+        for (size_t i=0; i<size; i++)
+            if (a.data[i] != b.data[i]) return 0;
+        return 1;
+    }
+};
+
+BR_REGISTER(Distance, IdenticalDistance)
+
+} // namespace br
+
+#include "distance/identical.moc"
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * Copyright 2012 The MITRE Corporation                                      *
+ *                                                                           *
+ * Licensed under the Apache License, Version 2.0 (the "License");           *
+ * you may not use this file except in compliance with the License.          *
+ * You may obtain a copy of the License at                                   *
+ *                                                                           *
+ *     http://www.apache.org/licenses/LICENSE-2.0                            *
+ *                                                                           *
+ * Unless required by applicable law or agreed to in writing, software       *
+ * distributed under the License is distributed on an "AS IS" BASIS,         *
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  *
+ * See the License for the specific language governing permissions and       *
+ * limitations under the License.                                            *
+ * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+
+#include <opencv2/features2d/features2d.hpp>
+
+#include <openbr/plugins/openbr_internal.h>
+
+using namespace cv;
+
+namespace br
+{
+
+/*!
+ * \ingroup transforms
+ * \brief Wraps OpenCV Key Point Matcher
+ * \author Josh Klontz \cite jklontz
+ */
+class KeyPointMatcherDistance : public UntrainableDistance
+{
+    Q_OBJECT
+    Q_PROPERTY(QString matcher READ get_matcher WRITE set_matcher RESET reset_matcher STORED false)
+    Q_PROPERTY(float maxRatio READ get_maxRatio WRITE set_maxRatio RESET reset_maxRatio STORED false)
+    BR_PROPERTY(QString, matcher, "BruteForce")
+    BR_PROPERTY(float, maxRatio, 0.8)
+
+    Ptr<DescriptorMatcher> descriptorMatcher;
+
+    void init()
+    {
+        descriptorMatcher = DescriptorMatcher::create(matcher.toStdString());
+        if (descriptorMatcher.empty())
+            qFatal("Failed to create DescriptorMatcher: %s", qPrintable(matcher));
+    }
+
+    float compare(const Mat &a, const Mat &b) const
+    {
+        if ((a.rows < 2) || (b.rows < 2)) return 0;
+
+        std::vector< std::vector<DMatch> > matches;
+        if (a.rows < b.rows) descriptorMatcher->knnMatch(a, b, matches, 2);
+        else                 descriptorMatcher->knnMatch(b, a, matches, 2);
+
+        QList<float> distances;
+        foreach (const std::vector<DMatch> &match, matches) {
+            if (match[0].distance / match[1].distance > maxRatio) continue;
+            distances.append(match[0].distance);
+        }
+        qSort(distances);
+
+        float similarity = 0;
+        for (int i=0; i<distances.size(); i++)
+            similarity += 1.f/(1+distances[i])/(i+1);
+        return similarity;
+    }
+};
+
+BR_REGISTER(Distance, KeyPointMatcherDistance)
+
+} // namespace br
+
+#include "distance/keypointmatcher.moc"
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * Copyright 2012 The MITRE Corporation                                      *
+ *                                                                           *
+ * Licensed under the Apache License, Version 2.0 (the "License");           *
+ * you may not use this file except in compliance with the License.          *
+ * You may obtain a copy of the License at                                   *
+ *                                                                           *
+ *     http://www.apache.org/licenses/LICENSE-2.0                            *
+ *                                                                           *
+ * Unless required by applicable law or agreed to in writing, software       *
+ * distributed under the License is distributed on an "AS IS" BASIS,         *
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  *
+ * See the License for the specific language governing permissions and       *
+ * limitations under the License.                                            *
+ * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+
+#include <Eigen/Dense>
+
+#include <openbr/plugins/openbr_internal.h>
+
+namespace br
+{
+
+/*!
+ * \ingroup distances
+ * \brief L1 distance computed using eigen.
+ * \author Josh Klontz \cite jklontz
+ */
+class L1Distance : public UntrainableDistance
+{
+    Q_OBJECT
+
+    float compare(const cv::Mat &a, const cv::Mat &b) const
+    {
+        const int size = a.rows * a.cols;
+        Eigen::Map<Eigen::VectorXf> aMap((float*)a.data, size);
+        Eigen::Map<Eigen::VectorXf> bMap((float*)b.data, size);
+        return (aMap-bMap).cwiseAbs().sum();
+    }
+};
+
+BR_REGISTER(Distance, L1Distance)
+
+} // namespace br
+
+#include "distance/L1.moc"
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * Copyright 2012 The MITRE Corporation                                      *
+ *                                                                           *
+ * Licensed under the Apache License, Version 2.0 (the "License");           *
+ * you may not use this file except in compliance with the License.          *
+ * You may obtain a copy of the License at                                   *
+ *                                                                           *
+ *     http://www.apache.org/licenses/LICENSE-2.0                            *
+ *                                                                           *
+ * Unless required by applicable law or agreed to in writing, software       *
+ * distributed under the License is distributed on an "AS IS" BASIS,         *
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  *
+ * See the License for the specific language governing permissions and       *
+ * limitations under the License.                                            *
+ * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+
+#include <QtConcurrent>
+
+#include <openbr/plugins/openbr_internal.h>
+#include <openbr/core/common.h>
+
+namespace br
+{
+
+float KDEPointer(const QList<float> *scores, double x, double h)
+{
+    return Common::KernelDensityEstimation(*scores, x, h);
+}
+
+/* Kernel Density Estimator */
+struct KDE
+{
+    float min, max;
+    double mean, stddev;
+    QList<float> bins;
+
+    KDE() : min(0), max(1), mean(0), stddev(1) {}
+
+    KDE(const QList<float> &scores, bool trainKDE)
+    {
+        Common::MinMax(scores, &min, &max);
+        Common::MeanStdDev(scores, &mean, &stddev);
+
+        if (!trainKDE)
+            return;
+
+        double h = Common::KernelDensityBandwidth(scores);
+        const int size = 255;
+        bins.reserve(size);
+
+        QFutureSynchronizer<float> futures;
+
+        for (int i=0; i < size; i++)
+            futures.addFuture(QtConcurrent::run(KDEPointer, &scores, min + (max-min)*i/(size-1), h));
+        futures.waitForFinished();
+
+        foreach(const QFuture<float> & future, futures.futures())
+            bins.append(future.result());
+    }
+
+    float operator()(float score, bool gaussian = true) const
+    {
+        if (gaussian) return 1/(stddev*sqrt(2*CV_PI))*exp(-0.5*pow((score-mean)/stddev, 2));
+        if (bins.empty())
+            return -std::numeric_limits<float>::max();
+
+        if (score <= min) return bins.first();
+        if (score >= max) return bins.last();
+        const float x = (score-min)/(max-min)*bins.size();
+        const float y1 = bins[floor(x)];
+        const float y2 = bins[ceil(x)];
+        return y1 + (y2-y1)*(x-floor(x));
+    }
+};
+
+QDataStream &operator<<(QDataStream &stream, const KDE &kde)
+{
+    return stream << kde.min << kde.max << kde.mean << kde.stddev << kde.bins;
+}
+
+QDataStream &operator>>(QDataStream &stream, KDE &kde)
+{
+    return stream >> kde.min >> kde.max >> kde.mean >> kde.stddev >> kde.bins;
+}
+
+/* Match Probability */
+struct MP
+{
+    KDE genuine, impostor;
+    MP() {}
+    MP(const QList<float> &genuineScores, const QList<float> &impostorScores, bool trainKDE)
+        : genuine(genuineScores, trainKDE), impostor(impostorScores, trainKDE) {}
+    float operator()(float score, bool gaussian = true) const
+    {
+        const float g = genuine(score, gaussian);
+        const float s = g / (impostor(score, gaussian) + g);
+        return s;
+    }
+};
+
+QDataStream &operator<<(QDataStream &stream, const MP &nmp)
+{
+    return stream << nmp.genuine << nmp.impostor;
+}
+
+QDataStream &operator>>(QDataStream &stream, MP &nmp)
+{
+    return stream >> nmp.genuine >> nmp.impostor;
+}
+
+/*!
+ * \ingroup distances
+ * \brief Match Probability \cite klare12
+ * \author Josh Klontz \cite jklontz
+ */
+class MatchProbabilityDistance : public Distance
+{
+    Q_OBJECT
+    Q_PROPERTY(br::Distance* distance READ get_distance WRITE set_distance RESET reset_distance STORED false)
+    Q_PROPERTY(bool gaussian READ get_gaussian WRITE set_gaussian RESET reset_gaussian STORED false)
+    Q_PROPERTY(bool crossModality READ get_crossModality WRITE set_crossModality RESET reset_crossModality STORED false)
+    Q_PROPERTY(QString inputVariable READ get_inputVariable WRITE set_inputVariable RESET reset_inputVariable STORED false)
+
+    MP mp;
+
+    void train(const TemplateList &src)
+    {
+        distance->train(src);
+
+        const QList<int> labels = src.indexProperty(inputVariable);
+        QScopedPointer<MatrixOutput> matrixOutput(MatrixOutput::make(FileList(src.size()), FileList(src.size())));
+        distance->compare(src, src, matrixOutput.data());
+
+        QList<float> genuineScores, impostorScores;
+        genuineScores.reserve(labels.size());
+        impostorScores.reserve(labels.size()*labels.size());
+        for (int i=0; i<src.size(); i++) {
+            for (int j=0; j<i; j++) {
+                const float score = matrixOutput.data()->data.at<float>(i, j);
+                if (score == -std::numeric_limits<float>::max()) continue;
+                if (crossModality && src[i].file.get<QString>("MODALITY") == src[j].file.get<QString>("MODALITY")) continue;
+                if (labels[i] == labels[j]) genuineScores.append(score);
+                else                        impostorScores.append(score);
+            }
+        }
+
+        mp = MP(genuineScores, impostorScores, !gaussian);
+    }
+
+    float compare(const Template &target, const Template &query) const
+    {
+        return normalize(distance->compare(target, query));
+    }
+
+    float compare(const cv::Mat &target, const cv::Mat &query) const
+    {
+        return normalize(distance->compare(target, query));
+    }
+
+    float compare(const uchar *a, const uchar *b, size_t size) const
+    {
+        return normalize(distance->compare(a, b, size));
+    }
+
+    float normalize(float score) const
+    {
+        if (score == -std::numeric_limits<float>::max()) return score;
+        if (!Globals->scoreNormalization) return -log(score+1);
+        return mp(score, gaussian);
+    }
+
+    void store(QDataStream &stream) const
+    {
+        distance->store(stream);
+        stream << mp;
+    }
+
+    void load(QDataStream &stream)
+    {
+        distance->load(stream);
+        stream >> mp;
+    }
+
+protected:
+    BR_PROPERTY(br::Distance*, distance, make("Dist(L2)"))
+    BR_PROPERTY(bool, gaussian, true)
+    BR_PROPERTY(bool, crossModality, false)
+    BR_PROPERTY(QString, inputVariable, "Label")
+};
+
+BR_REGISTER(Distance, MatchProbabilityDistance)
+
+} // namespace br
+
+#include "distance/matchprobability.moc"
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * Copyright 2012 The MITRE Corporation                                      *
+ *                                                                           *
+ * Licensed under the Apache License, Version 2.0 (the "License");           *
+ * you may not use this file except in compliance with the License.          *
+ * You may obtain a copy of the License at                                   *
+ *                                                                           *
+ *     http://www.apache.org/licenses/LICENSE-2.0                            *
+ *                                                                           *
+ * Unless required by applicable law or agreed to in writing, software       *
+ * distributed under the License is distributed on an "AS IS" BASIS,         *
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  *
+ * See the License for the specific language governing permissions and       *
+ * limitations under the License.                                            *
+ * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+
+#include <openbr/plugins/openbr_internal.h>
+#include <openbr/core/qtutils.h>
+
+namespace br
+{
+
+/*!
+ * \ingroup distances
+ * \brief Checks target metadata against query metadata.
+ * \author Scott Klum \cite sklum
+ */
+class MetadataDistance : public UntrainableDistance
+{
+    Q_OBJECT
+
+    Q_PROPERTY(QStringList filters READ get_filters WRITE set_filters RESET reset_filters STORED false)
+    BR_PROPERTY(QStringList, filters, QStringList())
+
+    float compare(const Template &a, const Template &b) const
+    {
+        foreach (const QString &key, filters) {
+            QString aValue = a.file.get<QString>(key, QString());
+            QString bValue = b.file.get<QString>(key, QString());
+
+            // The query value may be a range. Let's check.
+            if (bValue.isEmpty()) bValue = QtUtils::toString(b.file.get<QPointF>(key, QPointF()));
+
+            if (aValue.isEmpty() || bValue.isEmpty()) continue;
+
+            bool keep = false;
+            bool ok;
+
+            QPointF range = QtUtils::toPoint(bValue,&ok);
+
+            if (ok) /* Range */ {
+                int value = range.x();
+                int upperBound = range.y();
+
+                while (value <= upperBound) {
+                    if (aValue == QString::number(value)) {
+                        keep = true;
+                        break;
+                    }
+                    value++;
+                }
+            }
+            else if (aValue == bValue) keep = true;
+
+            if (!keep) return -std::numeric_limits<float>::max();
+        }
+        return 0;
+    }
+};
+
+
+BR_REGISTER(Distance, MetadataDistance)
+
+} // namespace br
+
+#include "distance/metadata.moc"
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * Copyright 2012 The MITRE Corporation                                      *
+ *                                                                           *
+ * Licensed under the Apache License, Version 2.0 (the "License");           *
+ * you may not use this file except in compliance with the License.          *
+ * You may obtain a copy of the License at                                   *
+ *                                                                           *
+ *     http://www.apache.org/licenses/LICENSE-2.0                            *
+ *                                                                           *
+ * Unless required by applicable law or agreed to in writing, software       *
+ * distributed under the License is distributed on an "AS IS" BASIS,         *
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  *
+ * See the License for the specific language governing permissions and       *
+ * limitations under the License.                                            *
+ * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+
+#include <openbr/plugins/openbr_internal.h>
+
+namespace br
+{
+
+/*!
+ * \ingroup distances
+ * \brief Returns -log(distance(a,b)+1)
+ * \author Josh Klontz \cite jklontz
+ */
+class NegativeLogPlusOneDistance : public UntrainableDistance
+{
+    Q_OBJECT
+    Q_PROPERTY(br::Distance* distance READ get_distance WRITE set_distance RESET reset_distance STORED false)
+    BR_PROPERTY(br::Distance*, distance, NULL)
+
+    void train(const TemplateList &src)
+    {
+        distance->train(src);
+    }
+
+    float compare(const Template &a, const Template &b) const
+    {
+        return -log(distance->compare(a,b)+1);
+    }
+
+    void store(QDataStream &stream) const
+    {
+        distance->store(stream);
+    }
+
+    void load(QDataStream &stream)
+    {
+        distance->load(stream);
+    }
+};
+
+BR_REGISTER(Distance, NegativeLogPlusOneDistance)
+
+} // namespace br
+
+#include "distance/neglogplusone.moc"
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * Copyright 2012 The MITRE Corporation                                      *
+ *                                                                           *
+ * Licensed under the Apache License, Version 2.0 (the "License");           *
+ * you may not use this file except in compliance with the License.          *
+ * You may obtain a copy of the License at                                   *
+ *                                                                           *
+ *     http://www.apache.org/licenses/LICENSE-2.0                            *
+ *                                                                           *
+ * Unless required by applicable law or agreed to in writing, software       *
+ * distributed under the License is distributed on an "AS IS" BASIS,         *
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  *
+ * See the License for the specific language governing permissions and       *
+ * limitations under the License.                                            *
+ * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+
+#include <openbr/plugins/openbr_internal.h>
+
+namespace br
+{
+
+/*!
+ * \ingroup distances
+ * \brief Online distance metric to attenuate match scores across multiple frames
+ * \author Brendan klare \cite bklare
+ */
+class OnlineDistance : public UntrainableDistance
+{
+    Q_OBJECT
+    Q_PROPERTY(br::Distance* distance READ get_distance WRITE set_distance RESET reset_distance STORED false)
+    Q_PROPERTY(float alpha READ get_alpha WRITE set_alpha RESET reset_alpha STORED false)
+    BR_PROPERTY(br::Distance*, distance, NULL)
+    BR_PROPERTY(float, alpha, 0.1f)
+
+    mutable QHash<QString,float> scoreHash;
+    mutable QMutex mutex;
+
+    float compare(const Template &target, const Template &query) const
+    {
+        float currentScore = distance->compare(target, query);
+
+        QMutexLocker mutexLocker(&mutex);
+        return scoreHash[target.file.name] = (1.0- alpha) * scoreHash[target.file.name] + alpha * currentScore;
+    }
+};
+
+BR_REGISTER(Distance, OnlineDistance)
+
+} // namespace br
+
+#include "distance/online.moc"
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * Copyright 2012 The MITRE Corporation                                      *
+ *                                                                           *
+ * Licensed under the Apache License, Version 2.0 (the "License");           *
+ * you may not use this file except in compliance with the License.          *
+ * You may obtain a copy of the License at                                   *
+ *                                                                           *
+ *     http://www.apache.org/licenses/LICENSE-2.0                            *
+ *                                                                           *
+ * Unless required by applicable law or agreed to in writing, software       *
+ * distributed under the License is distributed on an "AS IS" BASIS,         *
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  *
+ * See the License for the specific language governing permissions and       *
+ * limitations under the License.                                            *
+ * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+
+#include <QtConcurrent>
+
+#include <openbr/plugins/openbr_internal.h>
+
+namespace br
+{
+
+/*!
+ * \ingroup distances
+ * \brief Distances in series.
+ * \author Josh Klontz \cite jklontz
+ *
+ * The templates are compared using each br::Distance in order.
+ * If the result of the comparison with any given distance is -FLOAT_MAX then this result is returned early.
+ * Otherwise the returned result is the value of comparing the templates using the last br::Distance.
+ */
+class PipeDistance : public Distance
+{
+    Q_OBJECT
+    Q_PROPERTY(QList<br::Distance*> distances READ get_distances WRITE set_distances RESET reset_distances)
+    BR_PROPERTY(QList<br::Distance*>, distances, QList<br::Distance*>())
+
+    void train(const TemplateList &data)
+    {
+        QFutureSynchronizer<void> futures;
+        foreach (br::Distance *distance, distances)
+            futures.addFuture(QtConcurrent::run(distance, &Distance::train, data));
+        futures.waitForFinished();
+    }
+
+    float compare(const Template &a, const Template &b) const
+    {
+        float result = -std::numeric_limits<float>::max();
+        foreach (br::Distance *distance, distances) {
+            result = distance->compare(a, b);
+            if (result == -std::numeric_limits<float>::max())
+                return result;
+        }
+        return result;
+    }
+};
+
+BR_REGISTER(Distance, PipeDistance)
+
+} // namespace br
+
+#include "distance/pipe.moc"
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * Copyright 2012 The MITRE Corporation                                      *
+ *                                                                           *
+ * Licensed under the Apache License, Version 2.0 (the "License");           *
+ * you may not use this file except in compliance with the License.          *
+ * You may obtain a copy of the License at                                   *
+ *                                                                           *
+ *     http://www.apache.org/licenses/LICENSE-2.0                            *
+ *                                                                           *
+ * Unless required by applicable law or agreed to in writing, software       *
+ * distributed under the License is distributed on an "AS IS" BASIS,         *
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  *
+ * See the License for the specific language governing permissions and       *
+ * limitations under the License.                                            *
+ * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+
+#include <openbr/plugins/openbr_internal.h>
+
+namespace br
+{
+
+/*!
+ * \ingroup distances
+ * \brief Sets distance to -FLOAT_MAX if a target template has/doesn't have a key.
+ * \author Scott Klum \cite sklum
+ */
+class RejectDistance : public UntrainableDistance
+{
+    Q_OBJECT
+
+    Q_PROPERTY(QStringList keys READ get_keys WRITE set_keys RESET reset_keys STORED false)
+    BR_PROPERTY(QStringList, keys, QStringList())
+    Q_PROPERTY(bool rejectIfContains READ get_rejectIfContains WRITE set_rejectIfContains RESET reset_rejectIfContains STORED false)
+    BR_PROPERTY(bool, rejectIfContains, false)
+
+    float compare(const Template &a, const Template &b) const
+    {
+        // We don't look at the query
+        (void) b;
+
+        foreach (const QString &key, keys)
+            if ((rejectIfContains && a.file.contains(key)) || (!rejectIfContains && !a.file.contains(key)))
+                return -std::numeric_limits<float>::max();
+
+        return 0;
+    }
+};
+
+
+BR_REGISTER(Distance, RejectDistance)
+
+} // namespace br
+
+#include "distance/reject.moc"
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * Copyright 2012 The MITRE Corporation                                      *
+ *                                                                           *
+ * Licensed under the Apache License, Version 2.0 (the "License");           *
+ * you may not use this file except in compliance with the License.          *
+ * You may obtain a copy of the License at                                   *
+ *                                                                           *
+ *     http://www.apache.org/licenses/LICENSE-2.0                            *
+ *                                                                           *
+ * Unless required by applicable law or agreed to in writing, software       *
+ * distributed under the License is distributed on an "AS IS" BASIS,         *
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  *
+ * See the License for the specific language governing permissions and       *
+ * limitations under the License.                                            *
+ * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+
+#include <QtConcurrent>
+
+#include <openbr/plugins/openbr_internal.h>
+
+namespace br
+{
+
+/*!
+ * \ingroup distances
+ * \brief Sum match scores across multiple distances
+ * \author Scott Klum \cite sklum
+ */
+class SumDistance : public UntrainableDistance
+{
+    Q_OBJECT
+    Q_PROPERTY(QList<br::Distance*> distances READ get_distances WRITE set_distances RESET reset_distances)
+    BR_PROPERTY(QList<br::Distance*>, distances, QList<br::Distance*>())
+
+    void train(const TemplateList &data)
+    {
+        QFutureSynchronizer<void> futures;
+        foreach (br::Distance *distance, distances)
+            futures.addFuture(QtConcurrent::run(distance, &Distance::train, data));
+        futures.waitForFinished();
+    }
+
+    float compare(const Template &target, const Template &query) const
+    {
+        float result = 0;
+
+        foreach (br::Distance *distance, distances) {
+            result += distance->compare(target, query);
+
+            if (result == -std::numeric_limits<float>::max())
+                return result;
+        }
+
+        return result;
+    }
+};
+
+BR_REGISTER(Distance, SumDistance)
+
+} // namespace br
+
+#include "distance/sum.moc"
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * Copyright 2012 The MITRE Corporation                                      *
+ *                                                                           *
+ * Licensed under the Apache License, Version 2.0 (the "License");           *
+ * you may not use this file except in compliance with the License.          *
+ * You may obtain a copy of the License at                                   *
+ *                                                                           *
+ *     http://www.apache.org/licenses/LICENSE-2.0                            *
+ *                                                                           *
+ * Unless required by applicable law or agreed to in writing, software       *
+ * distributed under the License is distributed on an "AS IS" BASIS,         *
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  *
+ * See the License for the specific language governing permissions and       *
+ * limitations under the License.                                            *
+ * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+
+#include <openbr/plugins/openbr_internal.h>
+#include <openbr/core/opencvutils.h>
+
+namespace br
+{
+
+/*!
+ * \ingroup distances
+ * \brief Unmaps Turk HITs to be compared against query mats
+ * \author Scott Klum \cite sklum
+ */
+class TurkDistance : public UntrainableDistance
+{
+    Q_OBJECT
+    Q_PROPERTY(QString key READ get_key WRITE set_key RESET reset_key)
+    Q_PROPERTY(QStringList values READ get_values WRITE set_values RESET reset_values STORED false)
+    BR_PROPERTY(QString, key, QString())
+    BR_PROPERTY(QStringList, values, QStringList())
+
+    bool targetHuman;
+    bool queryMachine;
+
+    void init()
+    {
+        targetHuman = Globals->property("TurkTargetHuman").toBool();
+        queryMachine = Globals->property("TurkQueryMachine").toBool();
+    }
+
+    cv::Mat getValues(const Template &t) const
+    {
+        QList<float> result;
+        foreach (const QString &value, values)
+            result.append(t.file.get<float>(key + "_" + value));
+        return OpenCVUtils::toMat(result, 1);
+    }
+
+    float compare(const Template &target, const Template &query) const
+    {
+        const cv::Mat a = targetHuman ? getValues(target) : target.m();
+        const cv::Mat b = queryMachine ? query.m() : getValues(query);
+        return -norm(a, b, cv::NORM_L1);
+    }
+};
+
+BR_REGISTER(Distance, TurkDistance)
+
+} // namespace br
+
+#include "distance/turk.moc"
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * Copyright 2012 The MITRE Corporation                                      *
+ *                                                                           *
+ * Licensed under the Apache License, Version 2.0 (the "License");           *
+ * you may not use this file except in compliance with the License.          *
+ * You may obtain a copy of the License at                                   *
+ *                                                                           *
+ *     http://www.apache.org/licenses/LICENSE-2.0                            *
+ *                                                                           *
+ * Unless required by applicable law or agreed to in writing, software       *
+ * distributed under the License is distributed on an "AS IS" BASIS,         *
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  *
+ * See the License for the specific language governing permissions and       *
+ * limitations under the License.                                            *
+ * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+
+#include <openbr/plugins/openbr_internal.h>
+
+namespace br
+{
+
+/*!
+ * \ingroup distances
+ * \brief Linear normalizes of a distance so the mean impostor score is 0 and the mean genuine score is 1.
+ * \author Josh Klontz \cite jklontz
+ */
+class UnitDistance : public Distance
+{
+    Q_OBJECT
+    Q_PROPERTY(br::Distance *distance READ get_distance WRITE set_distance RESET reset_distance)
+    Q_PROPERTY(float a READ get_a WRITE set_a RESET reset_a)
+    Q_PROPERTY(float b READ get_b WRITE set_b RESET reset_b)
+    Q_PROPERTY(QString inputVariable READ get_inputVariable WRITE set_inputVariable RESET reset_inputVariable STORED false)
+    BR_PROPERTY(br::Distance*, distance, make("Dist(L2)"))
+    BR_PROPERTY(float, a, 1)
+    BR_PROPERTY(float, b, 0)
+    BR_PROPERTY(QString, inputVariable, "Label")
+
+    void train(const TemplateList &templates)
+    {
+        const TemplateList samples = templates.mid(0, 2000);
+        const QList<int> sampleLabels = samples.indexProperty(inputVariable);
+        QScopedPointer<MatrixOutput> matrixOutput(MatrixOutput::make(FileList(samples.size()), FileList(samples.size())));
+        Distance::compare(samples, samples, matrixOutput.data());
+
+        double genuineAccumulator, impostorAccumulator;
+        int genuineCount, impostorCount;
+        genuineAccumulator = impostorAccumulator = genuineCount = impostorCount = 0;
+
+        for (int i=0; i<samples.size(); i++) {
+            for (int j=0; j<i; j++) {
+                const float val = matrixOutput.data()->data.at<float>(i, j);
+                if (sampleLabels[i] == sampleLabels[j]) {
+                    genuineAccumulator += val;
+                    genuineCount++;
+                } else {
+                    impostorAccumulator += val;
+                    impostorCount++;
+                }
+            }
+        }
+
+        if (genuineCount == 0) { qWarning("No genuine matches."); return; }
+        if (impostorCount == 0) { qWarning("No impostor matches."); return; }
+
+        double genuineMean = genuineAccumulator / genuineCount;
+        double impostorMean = impostorAccumulator / impostorCount;
+
+        if (genuineMean == impostorMean) { qWarning("Genuines and impostors are indistinguishable."); return; }
+
+        a = 1.0/(genuineMean-impostorMean);
+        b = impostorMean;
+
+        qDebug("a = %f, b = %f", a, b);
+    }
+
+    float compare(const Template &target, const Template &query) const
+    {
+        return a * (distance->compare(target, query) - b);
+    }
+};
+
+BR_REGISTER(Distance, UnitDistance)
+
+} // namespace br
+
+#include "distance/unit.moc"
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * Copyright 2012 The MITRE Corporation                                      *
+ *                                                                           *
+ * Licensed under the Apache License, Version 2.0 (the "License");           *
+ * you may not use this file except in compliance with the License.          *
+ * You may obtain a copy of the License at                                   *
+ *                                                                           *
+ *     http://www.apache.org/licenses/LICENSE-2.0                            *
+ *                                                                           *
+ * Unless required by applicable law or agreed to in writing, software       *
+ * distributed under the License is distributed on an "AS IS" BASIS,         *
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  *
+ * See the License for the specific language governing permissions and       *
+ * limitations under the License.                                            *
+ * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+
+#include <openbr/plugins/openbr_internal.h>
+#include <openbr/core/common.h>
+
+namespace br
+{
+
+class ZScoreDistance : public Distance
+{
+    Q_OBJECT
+    Q_PROPERTY(br::Distance* distance READ get_distance WRITE set_distance RESET reset_distance STORED false)
+    Q_PROPERTY(bool crossModality READ get_crossModality WRITE set_crossModality RESET reset_crossModality STORED false)
+    BR_PROPERTY(br::Distance*, distance, make("Dist(L2)"))
+    BR_PROPERTY(bool, crossModality, false)
+
+    float min, max;
+    double mean, stddev;
+
+    void train(const TemplateList &src)
+    {
+        distance->train(src);
+
+        QScopedPointer<MatrixOutput> matrixOutput(MatrixOutput::make(FileList(src.size()), FileList(src.size())));
+        distance->compare(src, src, matrixOutput.data());
+
+        QList<float> scores;
+        scores.reserve(src.size()*src.size());
+        for (int i=0; i<src.size(); i++) {
+            for (int j=0; j<i; j++) {
+                const float score = matrixOutput.data()->data.at<float>(i, j);
+                if (score == -std::numeric_limits<float>::max()) continue;
+                if (crossModality && src[i].file.get<QString>("MODALITY") == src[j].file.get<QString>("MODALITY")) continue;
+                scores.append(score);
+            }
+        }
+
+        Common::MinMax(scores, &min, &max);
+        Common::MeanStdDev(scores, &mean, &stddev);
+
+        if (stddev == 0) qFatal("Stddev is 0.");
+    }
+
+    float compare(const Template &target, const Template &query) const
+    {
+        float score = distance->compare(target,query);
+        if      (score == -std::numeric_limits<float>::max()) score = (min - mean) / stddev;
+        else if (score ==  std::numeric_limits<float>::max()) score = (max - mean) / stddev;
+        else                                                  score = (score - mean) / stddev;
+        return score;
+    }
+
+    void store(QDataStream &stream) const
+    {
+        distance->store(stream);
+        stream << min << max << mean << stddev;
+    }
+
+    void load(QDataStream &stream)
+    {
+        distance->load(stream);
+        stream >> min >> max >> mean >> stddev;
+    }
+};
+
+BR_REGISTER(Distance, ZScoreDistance)
+
+} // namespace br
+
+#include "distance/zscore.moc"
-/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
- * Copyright 2012 The MITRE Corporation                                      *
- *                                                                           *
- * Licensed under the Apache License, Version 2.0 (the "License");           *
- * you may not use this file except in compliance with the License.          *
- * You may obtain a copy of the License at                                   *
- *                                                                           *
- *     http://www.apache.org/licenses/LICENSE-2.0                            *
- *                                                                           *
- * Unless required by applicable law or agreed to in writing, software       *
- * distributed under the License is distributed on an "AS IS" BASIS,         *
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  *
- * See the License for the specific language governing permissions and       *
- * limitations under the License.                                            *
- * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
-
-#include <opencv2/highgui/highgui.hpp>
-#include <opencv2/highgui/highgui_c.h>
-#include <opencv2/imgproc/imgproc.hpp>
-#include <vector>
-#include "openbr_internal.h"
-#include "openbr/core/opencvutils.h"
-
-using namespace cv;
-
-namespace br
-{
-
-/*!
- * \ingroup transforms
- * \brief Renders metadata onto the image.
- *
- * The inPlace argument controls whether or not the image is cloned before the metadata is drawn.
- *
- * \author Josh Klontz \cite jklontz
- */
-class DrawTransform : public UntrainableTransform
-{
-    Q_OBJECT
-    Q_PROPERTY(bool verbose READ get_verbose WRITE set_verbose RESET reset_verbose STORED false)
-    Q_PROPERTY(bool points READ get_points WRITE set_points RESET reset_points STORED false)
-    Q_PROPERTY(bool rects READ get_rects WRITE set_rects RESET reset_rects STORED false)
-    Q_PROPERTY(bool inPlace READ get_inPlace WRITE set_inPlace RESET reset_inPlace STORED false)
-    Q_PROPERTY(int lineThickness READ get_lineThickness WRITE set_lineThickness RESET reset_lineThickness STORED false)
-    Q_PROPERTY(bool named READ get_named WRITE set_named RESET reset_named STORED false)
-    Q_PROPERTY(bool location READ get_location WRITE set_location RESET reset_location STORED false)
-    BR_PROPERTY(bool, verbose, false)
-    BR_PROPERTY(bool, points, true)
-    BR_PROPERTY(bool, rects, true)
-    BR_PROPERTY(bool, inPlace, false)
-    BR_PROPERTY(int, lineThickness, 1)
-    BR_PROPERTY(bool, named, true)
-    BR_PROPERTY(bool, location, true)
-
-    void project(const Template &src, Template &dst) const
-    {
-        const Scalar color(0,255,0);
-        const Scalar verboseColor(255, 255, 0);
-        dst.m() = inPlace ? src.m() : src.m().clone();
-
-        if (points) {
-            const QList<Point2f> pointsList = (named) ? OpenCVUtils::toPoints(src.file.points()+src.file.namedPoints()) : OpenCVUtils::toPoints(src.file.points());
-            for (int i=0; i<pointsList.size(); i++) {
-                const Point2f &point = pointsList[i];
-                circle(dst, point, 3, color, -1);
-                QString label = (location) ? QString("%1,(%2,%3)").arg(QString::number(i),QString::number(point.x),QString::number(point.y)) : QString("%1").arg(QString::number(i));
-                if (verbose) putText(dst, label.toStdString(), point, FONT_HERSHEY_SIMPLEX, 0.5, verboseColor, 1);
-            }
-        }
-        if (rects) {
-            foreach (const Rect &rect, OpenCVUtils::toRects(src.file.namedRects() + src.file.rects()))
-                rectangle(dst, rect, color, lineThickness);
-        }
-    }
-};
-
-BR_REGISTER(Transform, DrawTransform)
-
-
-/*!
- * \ingroup transforms
- * \brief Draw the value of the specified property at the specified point on the image
- *
- * The inPlace argument controls whether or not the image is cloned before it is drawn on.
- *
- * \author Charles Otto \cite caotto
- */
-class DrawPropertyPointTransform : public UntrainableTransform
-{
-    Q_OBJECT
-    Q_PROPERTY(QString propName READ get_propName WRITE set_propName RESET reset_propName STORED false)
-    Q_PROPERTY(QString pointName READ get_pointName WRITE set_pointName RESET reset_pointName STORED false)
-    Q_PROPERTY(bool inPlace READ get_inPlace WRITE set_inPlace RESET reset_inPlace STORED false)
-    BR_PROPERTY(QString, propName, "")
-    BR_PROPERTY(QString, pointName, "")
-    BR_PROPERTY(bool, inPlace, false)
-
-
-    void project(const Template &src, Template &dst) const
-    {
-        dst = src;
-        if (propName.isEmpty() || pointName.isEmpty())
-            return;
-
-        dst.m() = inPlace ? src.m() : src.m().clone();
-
-        const Scalar textColor(255, 255, 0);
-
-        QVariant prop = dst.file.value(propName);
-
-
-        if (!prop.canConvert(QVariant::String))
-            return;
-        QString propString = prop.toString();
-
-        QVariant point = dst.file.value(pointName);
-
-        if (!point.canConvert(QVariant::PointF))
-            return;
-
-        QPointF targetPoint = point.toPointF();
-
-        Point2f cvPoint =OpenCVUtils::toPoint(targetPoint);
-
-        std::string text = propName.toStdString() + ": " + propString.toStdString();
-        putText(dst, text, cvPoint, FONT_HERSHEY_SIMPLEX, 0.5, textColor, 1);
-    }
-
-};
-BR_REGISTER(Transform, DrawPropertyPointTransform)
-
-/*!
- * \ingroup transforms
- * \brief Draw the values of a list of properties at the specified point on the image
- *
- * The inPlace argument controls whether or not the image is cloned before it is drawn on.
- *
- * \author Charles Otto \cite caotto
- */
-class DrawPropertiesPointTransform : public UntrainableTransform
-{
-    Q_OBJECT
-    Q_PROPERTY(QStringList propNames READ get_propNames WRITE set_propNames RESET reset_propNames STORED false)
-    Q_PROPERTY(QString pointName READ get_pointName WRITE set_pointName RESET reset_pointName STORED false)
-    Q_PROPERTY(bool inPlace READ get_inPlace WRITE set_inPlace RESET reset_inPlace STORED false)
-    BR_PROPERTY(QStringList, propNames, QStringList())
-    BR_PROPERTY(QString, pointName, "")
-    BR_PROPERTY(bool, inPlace, false)
-
-    void project(const Template &src, Template &dst) const
-    {
-        dst = src;
-        if (propNames.isEmpty() || pointName.isEmpty())
-            return;
-
-        dst.m() = inPlace ? src.m() : src.m().clone();
-
-        QVariant point = dst.file.value(pointName);
-
-        if (!point.canConvert(QVariant::PointF))
-            return;
-
-        QPointF targetPoint = point.toPointF();
-
-        Point2f cvPoint =OpenCVUtils::toPoint(targetPoint);
-
-
-        const Scalar textColor(255, 255, 0);
-
-        std::string outString = "";
-        foreach (const QString &propName, propNames)
-        {
-            QVariant prop = dst.file.value(propName);
-
-            if (!prop.canConvert(QVariant::String))
-                continue;
-            QString propString = prop.toString();
-            outString += propName.toStdString() + ": " + propString.toStdString() + " ";
-
-        }
-        if (outString.empty())
-            return;
-
-        putText(dst, outString, cvPoint, FONT_HERSHEY_SIMPLEX, 0.5, textColor, 1);
-    }
-
-};
-BR_REGISTER(Transform, DrawPropertiesPointTransform)
-
-
-/*!
- * \ingroup transforms
- * \brief Draws a grid on the image
- * \author Josh Klontz \cite jklontz
- */
-class DrawGridTransform : public UntrainableTransform
-{
-    Q_OBJECT
-    Q_PROPERTY(int rows READ get_rows WRITE set_rows RESET reset_rows STORED false)
-    Q_PROPERTY(int columns READ get_columns WRITE set_columns RESET reset_columns STORED false)
-    Q_PROPERTY(int r READ get_r WRITE set_r RESET reset_r STORED false)
-    Q_PROPERTY(int g READ get_g WRITE set_g RESET reset_g STORED false)
-    Q_PROPERTY(int b READ get_b WRITE set_b RESET reset_b STORED false)
-    BR_PROPERTY(int, rows, 0)
-    BR_PROPERTY(int, columns, 0)
-    BR_PROPERTY(int, r, 196)
-    BR_PROPERTY(int, g, 196)
-    BR_PROPERTY(int, b, 196)
-
-    void project(const Template &src, Template &dst) const
-    {
-        Mat m = src.m().clone();
-        float rowStep = 1.f * m.rows / (rows+1);
-        float columnStep = 1.f * m.cols / (columns+1);
-        int thickness = qMin(m.rows, m.cols) / 256;
-        for (float row = rowStep/2; row < m.rows; row += rowStep)
-            line(m, Point(0, row), Point(m.cols, row), Scalar(r, g, b), thickness, CV_AA);
-        for (float column = columnStep/2; column < m.cols; column += columnStep)
-            line(m, Point(column, 0), Point(column, m.rows), Scalar(r, g, b), thickness, CV_AA);
-        dst = m;
-    }
-};
-
-BR_REGISTER(Transform, DrawGridTransform)
-
-/*!
- * \ingroup transforms
- * \brief Computes the mean of a set of templates.
- * \note Suitable for visualization only as it sets every projected template to the mean template.
- * \author Scott Klum \cite sklum
- */
-class MeanTransform : public Transform
-{
-    Q_OBJECT
-
-    Mat mean;
-
-    void train(const TemplateList &data)
-    {
-        mean = Mat::zeros(data[0].m().rows,data[0].m().cols,CV_32F);
-
-        for (int i = 0; i < data.size(); i++) {
-            Mat converted;
-            data[i].m().convertTo(converted, CV_32F);
-            mean += converted;
-        }
-
-        mean /= data.size();
-    }
-
-    void project(const Template &src, Template &dst) const
-    {
-        dst = src;
-        dst.m() = mean;
-    }
-
-};
-
-BR_REGISTER(Transform, MeanTransform)
-
-/*!
- * \ingroup transforms
- * \brief Load the image named in the specified property, draw it on the current matrix adjacent to the rect specified in the other property.
- * \author Charles Otto \cite caotto
- */
-class AdjacentOverlayTransform : public Transform
-{
-    Q_OBJECT
-
-    Q_PROPERTY(QString imgName READ get_imgName WRITE set_imgName RESET reset_imgName STORED false)
-    Q_PROPERTY(QString targetName READ get_targetName WRITE set_targetName RESET reset_targetName STORED false)
-    BR_PROPERTY(QString, imgName, "")
-    BR_PROPERTY(QString, targetName, "")
-
-    QSharedPointer<Transform> opener;
-    void project(const Template &src, Template &dst) const
-    {
-        dst = src;
-
-        if (imgName.isEmpty() || targetName.isEmpty() || !dst.file.contains(imgName) || !dst.file.contains(targetName))
-            return;
-
-        QVariant temp = src.file.value(imgName);
-        cv::Mat im;
-        // is this a filename?
-        if (temp.canConvert<QString>()) {
-            QString im_name = temp.toString();
-            Template temp_im;
-            opener->project(File(im_name), temp_im);
-            im = temp_im.m();
-        }
-        // a cv::Mat ?
-        else if (temp.canConvert<cv::Mat>())
-            im = src.file.get<cv::Mat>(imgName);
-        else
-            qDebug() << "Unrecognized property type " << imgName << "for" << src.file.name;
-
-        // Location of detected face in source image
-        QRectF target_location = src.file.get<QRectF>(targetName);
-
-        // match width with target region
-        qreal target_width = target_location.width();
-        qreal current_width = im.cols;
-        qreal current_height = im.rows;
-
-        qreal aspect_ratio = current_height / current_width;
-        qreal target_height = target_width * aspect_ratio;
-
-        cv::resize(im, im, cv::Size(target_width, target_height));
-
-        // ROI used to maybe crop the matched image
-        cv::Rect clip_roi;
-        clip_roi.x = 0;
-        clip_roi.y = 0;
-        clip_roi.width = im.cols;
-        clip_roi.height= im.rows <= dst.m().rows ? im.rows : dst.m().rows;
-
-        int half_width = src.m().cols / 2;
-        int out_x = 0;
-
-        // place in the source image we will copy the matched image to.
-        cv::Rect target_roi;
-        bool left_side = false;
-        int width_adjust = 0;
-        // Place left
-        if (target_location.center().rx() > half_width) {
-            out_x = target_location.left() - im.cols;
-            if (out_x < 0) {
-                width_adjust = abs(out_x);
-                out_x = 0;
-            }
-            left_side = true;
-        }
-        // place right
-        else {
-            out_x = target_location.right();
-            int high = out_x + im.cols;
-            if (high >= src.m().cols) {
-                width_adjust = abs(high - src.m().cols + 1);
-            }
-        }
-
-        cv::Mat outIm;
-        if (width_adjust)
-        {
-            outIm.create(dst.m().rows, dst.m().cols + width_adjust, CV_8UC3);
-            memset(outIm.data, 127, outIm.rows * outIm.cols * outIm.channels());
-
-            Rect temp;
-
-            if (left_side)
-                temp = Rect(abs(width_adjust), 0, dst.m().cols, dst.m().rows);
-
-            else
-                temp = Rect(0, 0, dst.m().cols, dst.m().rows);
-
-            dst.m().copyTo(outIm(temp));
-
-        }
-        else
-            outIm = dst.m();
-
-        if (clip_roi.height + target_location.top() >= outIm.rows)
-        {
-            clip_roi.height -= abs(outIm.rows - (clip_roi.height + target_location.top() ));
-        }
-        if (clip_roi.x + clip_roi.width >= im.cols) {
-            clip_roi.width -= abs(im.cols - (clip_roi.x + clip_roi.width + 1));
-            if (clip_roi.width < 0)
-                clip_roi.width = 1;
-        }
-
-        if (clip_roi.y + clip_roi.height >= im.rows) {
-            clip_roi.height -= abs(im.rows - (clip_roi.y + clip_roi.height + 1));
-        }
-        if (clip_roi.x < 0)
-            clip_roi.x = 0;
-        if (clip_roi.y < 0)
-            clip_roi.y = 0;
-
-        if (clip_roi.height < 0)
-            clip_roi.height = 0;
-
-        if (clip_roi.width < 0)
-            clip_roi.width = 0;
-
-
-        if (clip_roi.y + clip_roi.height >= im.rows)
-        {
-            qDebug() << "Bad clip y" << clip_roi.y + clip_roi.height << im.rows;
-        }
-        if (clip_roi.x + clip_roi.width >= im.cols)
-        {
-            qDebug() << "Bad clip x" << clip_roi.x + clip_roi.width << im.cols;
-        }
-
-        if (clip_roi.y < 0 || clip_roi.height < 0)
-        {
-            qDebug() << "bad clip y, low" << clip_roi.y << clip_roi.height;
-            qFatal("die");
-        }
-        if (clip_roi.x < 0 || clip_roi.width < 0)
-        {
-            qDebug() << "bad clip x, low" << clip_roi.x << clip_roi.width;
-            qFatal("die");
-        }
-
-        target_roi.x = out_x;
-        target_roi.width = clip_roi.width;
-        target_roi.y = target_location.top();
-        target_roi.height = clip_roi.height;
-
-
-        im = im(clip_roi);
-
-        if (target_roi.x < 0 || target_roi.x >= outIm.cols)
-        {
-            qDebug() << "Bad xdim in targetROI!" << target_roi.x << " out im x: " << outIm.cols;
-            qFatal("die");
-        }
-
-        if (target_roi.x + target_roi.width < 0 || (target_roi.x + target_roi.width) >= outIm.cols)
-        {
-            qDebug() << "Bad xdim in targetROI!" << target_roi.x + target_roi.width;
-            qFatal("die");
-        }
-
-        if (target_roi.y < 0 || target_roi.y >= outIm.rows)
-        {
-            qDebug() << "Bad ydim in targetROI!" << target_roi.y;
-            qFatal("die");
-        }
-
-        if ((target_roi.y + target_roi.height) < 0 || (target_roi.y + target_roi.height) > outIm.rows)
-        {
-            qDebug() << "Bad ydim in targetROI!" << target_roi.y + target_roi.height;
-            qDebug() << "target_roi.y: " << target_roi.y << " height: " << target_roi.height;
-            qFatal("die");
-        }
-
-        
-        std::vector<cv::Mat> channels;
-        cv::split(outIm, channels);
-
-        std::vector<cv::Mat> patch_channels;
-        cv::split(im, patch_channels);
-
-        for (size_t i=0; i < channels.size(); i++)
-        {
-            cv::addWeighted(channels[i](target_roi), 0, patch_channels[i % patch_channels.size()], 1, 0,channels[i](target_roi));
-        }
-        cv::merge(channels, outIm);
-        dst.m() = outIm;
-
-    }
-
-    void init()
-    {
-        opener = QSharedPointer<br::Transform>(br::Transform::make("Cache(Open)", NULL));
-    }
-
-};
-
-BR_REGISTER(Transform, AdjacentOverlayTransform)
-
-/*!
- * \ingroup transforms
- * \brief Draw a line representing the direction and magnitude of optical flow at the specified points.
- * \author Austin Blanton \cite imaus10
- */
-class DrawOpticalFlow : public UntrainableTransform
-{
-    Q_OBJECT
-    Q_PROPERTY(QString original READ get_original WRITE set_original RESET reset_original STORED false)
-    BR_PROPERTY(QString, original, "original")
-
-    void project(const Template &src, Template &dst) const
-    {
-        const Scalar color(0,255,0);
-        Mat flow = src.m();
-        dst = src;
-        if (!dst.file.contains(original)) qFatal("The original img must be saved in the metadata with SaveMat.");
-        dst.m() = dst.file.get<Mat>(original);
-        dst.file.remove(original);
-        foreach (const Point2f &pt, OpenCVUtils::toPoints(dst.file.points())) {
-            Point2f dxy = flow.at<Point2f>(pt.y, pt.x);
-            Point2f newPt(pt.x+dxy.x, pt.y+dxy.y);
-            line(dst, pt, newPt, color);
-        }
-    }
-};
-BR_REGISTER(Transform, DrawOpticalFlow)
-
-/*!
- * \ingroup transforms
- * \brief Fill in the segmentations or draw a line between intersecting segments.
- * \author Austin Blanton \cite imaus10
- */
-class DrawSegmentation : public UntrainableTransform
-{
-    Q_OBJECT
-    Q_PROPERTY(bool fillSegment READ get_fillSegment WRITE set_fillSegment RESET reset_fillSegment STORED false)
-    BR_PROPERTY(bool, fillSegment, true)
-
-    void project(const Template &src, Template &dst) const
-    {
-        if (!src.file.contains("SegmentsMask") || !src.file.contains("NumSegments")) qFatal("Must supply a Contours object in the metadata to drawContours.");
-        Mat segments = src.file.get<Mat>("SegmentsMask");
-        int numSegments = src.file.get<int>("NumSegments");
-
-        dst.file = src.file;
-        Mat drawn = fillSegment ? Mat(segments.size(), CV_8UC3, Scalar::all(0)) : src.m();
-
-        for (int i=1; i<numSegments+1; i++) {
-            Mat mask = segments == i;
-            if (fillSegment) { // color the whole segment
-                // set to a random color - get ready for a craaaazy acid trip
-                int b = theRNG().uniform(0, 255);
-                int g = theRNG().uniform(0, 255);
-                int r = theRNG().uniform(0, 255);
-                drawn.setTo(Scalar(r,g,b), mask);
-            } else { // draw lines where there's a color change
-                vector<vector<Point> > contours;
-                Scalar color(0,255,0);
-                findContours(mask, contours, CV_RETR_LIST, CV_CHAIN_APPROX_NONE);
-                drawContours(drawn, contours, -1, color);
-            }
-        }
-
-        dst.m() = drawn;
-    }
-};
-BR_REGISTER(Transform, DrawSegmentation)
-
-/*!
- * \ingroup transforms
- * \brief Write all mats to disk as images.
- * \author Brendan Klare \cite bklare
- */
-class WriteImageTransform : public TimeVaryingTransform
-{
-    Q_OBJECT
-    Q_PROPERTY(QString outputDirectory READ get_outputDirectory WRITE set_outputDirectory RESET reset_outputDirectory STORED false)
-    Q_PROPERTY(QString imageName READ get_imageName WRITE set_imageName RESET reset_imageName STORED false)
-    Q_PROPERTY(QString imgExtension READ get_imgExtension WRITE set_imgExtension RESET reset_imgExtension STORED false)
-    BR_PROPERTY(QString, outputDirectory, "Temp")
-    BR_PROPERTY(QString, imageName, "image")
-    BR_PROPERTY(QString, imgExtension, "jpg")
-
-    int cnt;
-
-    void init() {
-        cnt = 0;
-        if (! QDir(outputDirectory).exists())
-            QDir().mkdir(outputDirectory);
-    }
-
-    void projectUpdate(const Template &src, Template &dst)
-    {
-        dst = src;
-        OpenCVUtils::saveImage(dst.m(), QString("%1/%2_%3.%4").arg(outputDirectory).arg(imageName).arg(cnt++, 5, 10, QChar('0')).arg(imgExtension));
-    }
-
-};
-BR_REGISTER(Transform, WriteImageTransform)
-
-
-/**
- * @brief The MeanImageTransform class computes the average template/image
- * and save the result as an encoded image.
- */
-class MeanImageTransform : public TimeVaryingTransform
-{
-    Q_OBJECT
-
-    Q_PROPERTY(QString imgname READ get_imgname WRITE set_imgname RESET reset_imgname STORED false)
-    Q_PROPERTY(QString ext READ get_ext WRITE set_ext RESET reset_ext STORED false)
-
-    BR_PROPERTY(QString, imgname, "average")
-    BR_PROPERTY(QString, ext, "jpg")
-
-    Mat average;
-    int cnt;
-
-    void init()
-    {
-        cnt = 0;
-    }
-
-    void projectUpdate(const Template &src, Template &dst)
-    {
-        dst = src;
-        if (cnt == 0) {
-            if (src.m().channels() == 1)
-                average = Mat::zeros(dst.m().size(),CV_64FC1);
-            else if (src.m().channels() == 3)
-                average = Mat::zeros(dst.m().size(),CV_64FC3);
-            else
-                qFatal("Unsupported number of channels");
-        }
-
-        Mat temp;
-        if (src.m().channels() == 1) {
-            src.m().convertTo(temp, CV_64FC1);
-            average += temp;
-        } else if (src.m().channels() == 3) {
-            src.m().convertTo(temp, CV_64FC3);
-            average += temp;
-        } else
-            qFatal("Unsupported number of channels");
-
-        cnt++;
-    }
-
-    virtual void finalize(TemplateList &output)
-    {
-        average /= float(cnt);
-        imwrite(QString("%1.%2").arg(imgname).arg(ext).toStdString(), average);
-        output = TemplateList();
-    }
-
-
-public:
-    MeanImageTransform() : TimeVaryingTransform(false, false) {}
-};
-
-BR_REGISTER(Transform, MeanImageTransform)
-
-
-// TODO: re-implement EditTransform using Qt
-#if 0
-/*!
- * \ingroup transforms
- * \brief Remove landmarks.
- * \author Josh Klontz \cite jklontz
- */
-class EditTransform : public UntrainableTransform
-{
-    Q_OBJECT
-
-    Transform *draw;
-    static Template currentTemplate;
-    static QMutex currentTemplateLock;
-
-    void init()
-    {
-        draw = make("Draw");
-        Globals->setProperty("parallelism", "0"); // Can only work in single threaded mode
-    }
-
-    void project(const Template &src, Template &dst) const
-    {
-        dst = src;
-
-        if (Globals->parallelism) {
-            qWarning("Edit::project() only works in single threaded mode.");
-            return;
-        }
-
-        currentTemplateLock.lock();
-        currentTemplate = src;
-        OpenCVUtils::showImage(src, "Edit", false);
-        setMouseCallback("Edit", mouseCallback, (void*)this);
-        mouseEvent(0, 0, 0, 0);
-        waitKey(-1);
-        dst = currentTemplate;
-        currentTemplateLock.unlock();
-    }
-
-    static void mouseCallback(int event, int x, int y, int flags, void *userdata)
-    {
-        ((const EditTransform*)userdata)->mouseEvent(event, x, y, flags);
-    }
-
-    void mouseEvent(int event, int x, int y, int flags) const
-    {
-        (void) event;
-        if (flags) {
-            QList<QRectF> rects = currentTemplate.file.rects();
-            for (int i=rects.size()-1; i>=0; i--)
-                if (rects[i].contains(x,y))
-                    rects.removeAt(i);
-            currentTemplate.file.setRects(rects);
-        }
-
-        Template temp;
-        draw->project(currentTemplate, temp);
-        OpenCVUtils::showImage(temp, "Edit", false);
-    }
-};
-
-Template EditTransform::currentTemplate;
-QMutex EditTransform::currentTemplateLock;
-
-BR_REGISTER(Transform, EditTransform)
-#endif
-
-} // namespace br
-
-#include "draw.moc"
-set(BR_WITH_EIGEN3 ON CACHE BOOL "Build Eigen3 plugins")
-
-if(${BR_WITH_EIGEN3})
-  find_package(Eigen3 REQUIRED)
-  set(BR_THIRDPARTY_SRC ${BR_THIRDPARTY_SRC} plugins/eigen3.cpp)
-  install(FILES ${EIGEN3_LICENSE} RENAME Eigen3 DESTINATION share/openbr/licenses)
-endif()
-/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
- * Copyright 2012 The MITRE Corporation                                      *
- *                                                                           *
- * Licensed under the Apache License, Version 2.0 (the "License");           *
- * you may not use this file except in compliance with the License.          *
- * You may obtain a copy of the License at                                   *
- *                                                                           *
- *     http://www.apache.org/licenses/LICENSE-2.0                            *
- *                                                                           *
- * Unless required by applicable law or agreed to in writing, software       *
- * distributed under the License is distributed on an "AS IS" BASIS,         *
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  *
- * See the License for the specific language governing permissions and       *
- * limitations under the License.                                            *
- * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
-
-#include <opencv2/imgproc/imgproc.hpp>
-#include "openbr_internal.h"
-#include "openbr/core/tanh_sse.h"
-
-using namespace cv;
-
-namespace br
-{
-
-/*!
- * \ingroup transforms
- * \brief Gamma correction
- * \author Josh Klontz \cite jklontz
- */
-class GammaTransform : public UntrainableTransform
-{
-    Q_OBJECT
-    Q_PROPERTY(float gamma READ get_gamma WRITE set_gamma RESET reset_gamma STORED false)
-    BR_PROPERTY(float, gamma, 0.2)
-
-    Mat lut;
-
-    void init()
-    {
-        lut.create(256, 1, CV_32FC1);
-        if (gamma == 0) for (int i=0; i<256; i++) lut.at<float>(i,0) = log((float)i);
-        else            for (int i=0; i<256; i++) lut.at<float>(i,0) = pow(i, gamma);
-    }
-
-    void project(const Template &src, Template &dst) const
-    {
-        if (src.m().depth() == CV_8U) LUT(src, lut, dst);
-        else                          pow(src, gamma, dst);
-    }
-};
-
-BR_REGISTER(Transform, GammaTransform)
-
-/*!
- * \ingroup transforms
- * \brief Gaussian blur
- * \author Josh Klontz \cite jklontz
- */
-class BlurTransform : public UntrainableTransform
-{
-    Q_OBJECT
-    Q_PROPERTY(float sigma READ get_sigma WRITE set_sigma RESET reset_sigma STORED false)
-    Q_PROPERTY(bool ROI READ get_ROI WRITE set_ROI RESET reset_ROI STORED false)
-    BR_PROPERTY(float, sigma, 1)
-    BR_PROPERTY(bool, ROI, false)
-
-    void project(const Template &src, Template &dst) const
-    {
-        if (!ROI) GaussianBlur(src, dst, Size(0,0), sigma);
-        else {
-            dst.m() = src.m();
-            foreach (const QRectF &rect, src.file.rects()) {
-                Rect region(rect.x(), rect.y(), rect.width(), rect.height());
-                Mat input = dst.m();
-                Mat output = input.clone();
-                GaussianBlur(input(region), output(region), Size(0,0), sigma);
-                dst.m() = output;
-            }
-        }
-    }
-};
-
-BR_REGISTER(Transform, BlurTransform)
-
-/*!
- * \ingroup transforms
- * \brief Difference of gaussians
- * \author Josh Klontz \cite jklontz
- */
-class DoGTransform : public UntrainableTransform
-{
-    Q_OBJECT
-    Q_PROPERTY(float sigma0 READ get_sigma0 WRITE set_sigma0 RESET reset_sigma0 STORED false)
-    Q_PROPERTY(float sigma1 READ get_sigma1 WRITE set_sigma1 RESET reset_sigma1 STORED false)
-    BR_PROPERTY(float, sigma0, 1)
-    BR_PROPERTY(float, sigma1, 2)
-
-    Size ksize0, ksize1;
-
-    static Size getKernelSize(double sigma)
-    {
-        // Inverts OpenCV's conversion from kernel size to sigma:
-        // sigma = ((ksize-1)*0.5 - 1)*0.3 + 0.8
-        // See documentation for cv::getGaussianKernel()
-        int ksize = ((sigma - 0.8) / 0.3 + 1) * 2 + 1;
-        if (ksize % 2 == 0) ksize++;
-        return Size(ksize, ksize);
-    }
-
-    void init()
-    {
-        ksize0 = getKernelSize(sigma0);
-        ksize1 = getKernelSize(sigma1);
-    }
-
-    void project(const Template &src, Template &dst) const
-    {
-        Mat g0, g1;
-        GaussianBlur(src, g0, ksize0, 0);
-        GaussianBlur(src, g1, ksize1, 0);
-        subtract(g0, g1, dst);
-    }
-};
-
-BR_REGISTER(Transform, DoGTransform)
-
-/*!
- * \ingroup transforms
- * \brief Meyers, E.; Wolf, L.
- * “Using biologically inspired features for face processing,”
- * Int. Journal of Computer Vision, vol. 76, no. 1, pp 93–104, 2008.
- * \author Scott Klum \cite sklum
- */
-
-class CSDNTransform : public UntrainableTransform
-{
-    Q_OBJECT
-
-    Q_PROPERTY(float s READ get_s WRITE set_s RESET reset_s STORED false)
-    BR_PROPERTY(int, s, 16)
-
-    void project(const Template &src, Template &dst) const
-    {
-        if (src.m().channels() != 1) qFatal("Expected single channel source matrix.");
-
-        const int nRows = src.m().rows;
-        const int nCols = src.m().cols;
-
-        Mat m;
-        src.m().convertTo(m, CV_32FC1);
-
-        const int surround = s/2;
-
-        for ( int i = 0; i < nRows; i++ ) {
-            for ( int j = 0; j < nCols; j++ ) {
-                int width = min( j+surround, nCols ) - max( 0, j-surround );
-                int height = min( i+surround, nRows ) - max( 0, i-surround );
-
-                Rect_<int> ROI(max(0, j-surround), max(0, i-surround), width, height);
-
-                Scalar_<float> avg = mean(m(ROI));
-
-                m.at<float>(i,j) = m.at<float>(i,j) - avg[0];
-            }
-        }
-
-        dst = m;
-
-    }
-};
-
-BR_REGISTER(Transform, CSDNTransform)
-
-/*!
- * \ingroup transforms
- * \brief Xiaoyang Tan; Triggs, B.;
- * "Enhanced Local Texture Feature Sets for Face Recognition Under Difficult Lighting Conditions,"
- * Image Processing, IEEE Transactions on , vol.19, no.6, pp.1635-1650, June 2010
- * \author Josh Klontz \cite jklontz
- */
-class ContrastEqTransform : public UntrainableTransform
-{
-    Q_OBJECT
-    Q_PROPERTY(float a READ get_a WRITE set_a RESET reset_a STORED false)
-    Q_PROPERTY(float t READ get_t WRITE set_t RESET reset_t STORED false)
-    BR_PROPERTY(float, a, 1)
-    BR_PROPERTY(float, t, 0.1)
-
-    void project(const Template &src, Template &dst) const
-    {
-        if (src.m().channels() != 1) qFatal("Expected single channel source matrix.");
-
-        // Stage 1
-        Mat stage1;
-        {
-            Mat abs_dst;
-            absdiff(src, Scalar(0), abs_dst);
-            Mat pow_dst;
-            pow(abs_dst, a, pow_dst);
-            float denominator = pow((float)mean(pow_dst)[0], 1.f/a);
-            src.m().convertTo(stage1, CV_32F, 1/denominator);
-        }
-
-        // Stage 2
-        Mat stage2;
-        {
-            Mat abs_dst;
-            absdiff(stage1, Scalar(0), abs_dst);
-            Mat min_dst;
-            min(abs_dst, t, min_dst);
-            Mat pow_dst;
-            pow(min_dst, a, pow_dst);
-            float denominator = pow((float)mean(pow_dst)[0], 1.f/a);
-            stage1.convertTo(stage2, CV_32F, 1/denominator);
-        }
-
-        // Hyperbolic tangent
-        const int nRows = src.m().rows;
-        const int nCols = src.m().cols;
-        const float* p = (const float*)stage2.ptr();
-        Mat m(nRows, nCols, CV_32FC1);
-        for (int i=0; i<nRows; i++)
-            for (int j=0; j<nCols; j++)
-                m.at<float>(i, j) = fast_tanh(p[i*nCols+j]);
-                // TODO: m.at<float>(i, j) = t * fast_tanh(p[i*nCols+j] / t);
-
-        dst = m;
-    }
-};
-
-BR_REGISTER(Transform, ContrastEqTransform)
-
-/*!
- * \ingroup transforms
- * \brief Raise each element to the specified power.
- * \author Josh Klontz \cite jklontz
- */
-class PowTransform : public UntrainableTransform
-{
-    Q_OBJECT
-    Q_PROPERTY(float power READ get_power WRITE set_power RESET reset_power STORED false)
-    Q_PROPERTY(bool preserveSign READ get_preserveSign WRITE set_preserveSign RESET reset_preserveSign STORED false)
-    BR_PROPERTY(float, power, 2)
-    BR_PROPERTY(bool, preserveSign, false)
-
-    void project(const Template &src, Template &dst) const
-    {
-        pow(preserveSign ? abs(src) : src.m(), power, dst);
-        if (preserveSign) subtract(Scalar::all(0), dst, dst, src.m() < 0);
-    }
-};
-
-BR_REGISTER(Transform, PowTransform)
-
-} // namespace br
-
-#include "filter.moc"
-/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
- * Copyright 2012 The MITRE Corporation                                      *
- *                                                                           *
- * Licensed under the Apache License, Version 2.0 (the "License");           *
- * you may not use this file except in compliance with the License.          *
- * You may obtain a copy of the License at                                   *
- *                                                                           *
- *     http://www.apache.org/licenses/LICENSE-2.0                            *
- *                                                                           *
- * Unless required by applicable law or agreed to in writing, software       *
- * distributed under the License is distributed on an "AS IS" BASIS,         *
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  *
- * See the License for the specific language governing permissions and       *
- * limitations under the License.                                            *
- * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
-
-#include <QDate>
-#include <QSize>
-#include <QChar>
-#ifndef BR_EMBEDDED
-#include <QtXml>
-#endif // BR_EMBEDDED
-#include <QFile>
-#include <QFileInfo>
-
-#include <opencv2/highgui/highgui.hpp>
-#include <opencv2/highgui/highgui_c.h>
-#include "openbr_internal.h"
-
-#include "openbr/core/bee.h"
-#include "openbr/core/opencvutils.h"
-#include "openbr/core/qtutils.h"
-
-using namespace cv;
-
-namespace br
-{
-
- /*!
- * \ingroup formats
- * \brief Read all frames of a video using OpenCV
- * \author Charles Otto \cite caotto
- */
-class videoFormat : public Format
-{
-    Q_OBJECT
-
-public:
-    Template read() const
-    {
-        if (!file.exists() )
-            return Template();
-
-        VideoCapture videoSource(file.name.toStdString());
-        videoSource.open(file.name.toStdString() );
-
-
-        Template frames;
-        if (!videoSource.isOpened()) {
-            qWarning("video file open failed");
-            return frames;
-        }
-
-        bool open = true;
-        while (open) {
-            cv::Mat frame;
-            open = videoSource.read(frame);
-            if (!open) break;
-
-            frames.append(cv::Mat());
-            frames.back() = frame.clone();
-        }
-
-        return frames;
-    }
-
-    void write(const Template &t) const
-    {
-        int fourcc = OpenCVUtils::getFourcc();
-        VideoWriter videoSink(file.name.toStdString(), fourcc, 30, t.begin()->size());
-
-        // Did we successfully open the output file?
-        if (!videoSink.isOpened() ) qFatal("Failed to open output file");
-
-        for (Template::const_iterator it = t.begin(); it!= t.end(); ++it) {
-            videoSink << *it;
-        }
-    }
-};
-
-BR_REGISTER(Format, videoFormat)
-
-/*!
- * \ingroup formats
- * \brief A simple binary matrix format.
- * \author Josh Klontz \cite jklontz
- * First 4 bytes indicate the number of rows.
- * Second 4 bytes indicate the number of columns.
- * The rest of the bytes are 32-bit floating data elements in row-major order.
- */
-class binFormat : public Format
-{
-    Q_OBJECT
-    Q_PROPERTY(bool raw READ get_raw WRITE set_raw RESET reset_raw STORED false)
-    BR_PROPERTY(bool, raw, false)
-
-    Template read() const
-    {
-        QByteArray data;
-        QtUtils::readFile(file, data);
-        if (raw) {
-            return Template(file, Mat(1, data.size(), CV_8UC1, data.data()).clone());
-        } else {
-            return Template(file, Mat(((quint32*)data.data())[0],
-                                      ((quint32*)data.data())[1],
-                                      CV_32FC1,
-                                      data.data()+8).clone());
-        }
-    }
-
-    void write(const Template &t) const
-    {
-        QFile f(file);
-        QtUtils::touchDir(f);
-        if (!f.open(QFile::WriteOnly))
-            qFatal("Failed to open %s for writing.", qPrintable(file));
-
-        Mat m;
-        if (!raw) {
-            if (t.m().type() != CV_32FC1)
-                t.m().convertTo(m, CV_32F);
-            else m = t.m();
-
-            if (m.channels() != 1) qFatal("Only supports single channel matrices.");
-
-            f.write((const char *) &m.rows, 4);
-            f.write((const char *) &m.cols, 4);
-        }
-        else m =  t.m();
-
-        qint64 rowSize = m.cols * sizeof(float);
-        for (int i=0; i < m.rows; i++)
-        {
-            f.write((const char *) m.row(i).data, rowSize);
-        }
-        f.close();
-    }
-};
-
-BR_REGISTER(Format, binFormat)
-
-/*!
- * \ingroup formats
- * \brief Reads a comma separated value file.
- * \author Josh Klontz \cite jklontz
- */
-class csvFormat : public Format
-{
-    Q_OBJECT
-
-    Template read() const
-    {
-        QFile f(file.name);
-        f.open(QFile::ReadOnly);
-        QStringList lines(QString(f.readAll()).split(QRegularExpression("[\n|\r\n|\r]"), QString::SkipEmptyParts));
-        f.close();
-
-        bool isUChar = true;
-        QList< QList<float> > valsList;
-        foreach (const QString &line, lines) {
-            QList<float> vals;
-            foreach (const QString &word, line.split(QRegExp(" *, *"), QString::SkipEmptyParts)) {
-                bool ok;
-                const float val = word.toFloat(&ok);
-                vals.append(val);
-                isUChar = isUChar && (val == float(uchar(val)));
-            }
-            if (!vals.isEmpty())
-                valsList.append(vals);
-        }
-
-        Mat m(valsList.size(), valsList[0].size(), CV_32FC1);
-        for (int i=0; i<valsList.size(); i++)
-            for (int j=0; j<valsList[i].size(); j++)
-                m.at<float>(i,j) = valsList[i][j];
-
-        if (isUChar) m.convertTo(m, CV_8U);
-        return Template(m);
-    }
-
-    void write(const Template &t) const
-    {
-        const Mat &m = t.m();
-        if (t.size() != 1) qFatal("Only supports single matrix templates.");
-        if (m.channels() != 1) qFatal("Only supports single channel matrices.");
-
-        QStringList lines; lines.reserve(m.rows);
-        for (int r=0; r<m.rows; r++) {
-            QStringList elements; elements.reserve(m.cols);
-            for (int c=0; c<m.cols; c++)
-                elements.append(OpenCVUtils::elemToString(m, r, c));
-            lines.append(elements.join(","));
-        }
-
-        QtUtils::writeFile(file, lines);
-    }
-};
-
-BR_REGISTER(Format, csvFormat)
-
-/*!
- * \ingroup formats
- * \brief Reads image files.
- * \author Josh Klontz \cite jklontz
- */
-class DefaultFormat : public Format
-{
-    Q_OBJECT
-
-    Template read() const
-    {
-        Template t;
-
-        if (file.name.startsWith("http://") || file.name.startsWith("https://") || file.name.startsWith("www.")) {
-            if (Factory<Format>::names().contains("url")) {
-                File urlFile = file;
-                urlFile.name.append(".url");
-                QScopedPointer<Format> url(Factory<Format>::make(urlFile));
-                t = url->read();
-            }
-        } else {
-            Mat m = imread(file.resolved().toStdString());
-            if (m.data) {
-                t.append(m);
-            } else {
-                videoFormat videoReader;
-                videoReader.file = file;
-                t = videoReader.read();
-            }
-        }
-
-        return t;
-    }
-
-    void write(const Template &t) const
-    {
-        if (t.size() > 1) {
-            videoFormat videoWriter;
-            videoWriter.file = file;
-            videoWriter.write(t);
-        } else if (t.size() == 1) {
-            QtUtils::touchDir(QDir(file.path()));
-            imwrite(file.name.toStdString(), t);
-        }
-    }
-};
-
-BR_REGISTER(Format, DefaultFormat)
-
-/*!
- * \ingroup formats
- * \brief Reads a NIST LFFS file.
- * \author Josh Klontz \cite jklontz
- */
-class lffsFormat : public Format
-{
-    Q_OBJECT
-
-    Template read() const
-    {
-        QByteArray byteArray;
-        QtUtils::readFile(file.name, byteArray);
-        return Mat(1, byteArray.size(), CV_8UC1, byteArray.data()).clone();
-    }
-
-    void write(const Template &t) const
-    {
-        QByteArray byteArray((const char*)t.m().data, t.m().total()*t.m().elemSize());
-        QtUtils::writeFile(file.name, byteArray);
-    }
-};
-
-BR_REGISTER(Format, lffsFormat)
-
-/*!
- * \ingroup formats
- * \brief Reads a NIST BEE similarity matrix.
- * \author Josh Klontz \cite jklontz
- */
-class mtxFormat : public Format
-{
-    Q_OBJECT
-
-    Template read() const
-    {
-        QString target, query;
-        Template result = BEE::readMatrix(file, &target, &query);
-        result.file.set("Target", target);
-        result.file.set("Query", query);
-        return result;
-    }
-
-    void write(const Template &t) const
-    {
-        BEE::writeMatrix(t, file);
-    }
-};
-
-BR_REGISTER(Format, mtxFormat)
-
-/*!
- * \ingroup formats
- * \brief Reads a NIST BEE mask matrix.
- * \author Josh Klontz \cite jklontz
- */
-class maskFormat : public mtxFormat
-{
-    Q_OBJECT
-};
-
-BR_REGISTER(Format, maskFormat)
-
-/*!
- * \ingroup formats
- * \brief MATLAB <tt>.mat</tt> format.
- * \author Josh Klontz \cite jklontz
- * http://www.mathworks.com/help/pdf_doc/matlab/matfile_format.pdf
- * \note matFormat is known not to work with compressed matrices
- */
-class matFormat : public Format
-{
-    Q_OBJECT
-
-    struct Element
-    {
-        // It is always best to cast integers to a Qt integer type, such as qint16 or quint32, when reading and writing.
-        // This ensures that you always know exactly what size integers you are reading and writing, no matter what the
-        // underlying platform and architecture the application happens to be running on.
-        // http://qt-project.org/doc/qt-4.8/datastreamformat.html
-        quint32 type, bytes;
-        QByteArray data;
-        Element() : type(0), bytes(0) {}
-        Element(QDataStream &stream)
-            : type(0), bytes(0)
-        {
-            // Read first 4 bytes into type (32 bit integer),
-            // specifying the type of data used
-            if (stream.readRawData((char*)&type, 4) != 4)
-                qFatal("Unexpected end of file.");
-
-            if (type >= 1 << 16) {
-                // Small data format
-                bytes = type;
-                type = type & 0x0000FFFF;
-                bytes = bytes >> 16;
-            } else {
-                // Regular format
-                // Read 4 bytes into bytes (32 bit integer),
-                // specifying the size of the element
-                if (stream.readRawData((char*)&bytes, 4) != 4)
-                    qFatal("Unexpected end of file.");
-            }
-
-            // Set the size of data to bytes
-            data.resize(bytes);
-
-            // Read bytes amount of data from the file into data
-            if (int(bytes) != stream.readRawData(data.data(), bytes))
-                qFatal("Unexpected end of file.");
-
-            // Alignment
-            int skipBytes = (bytes < 4) ? (4 - bytes) : (8 - bytes%8)%8;
-            if (skipBytes != 0) stream.skipRawData(skipBytes);
-        }
-    };
-
-    Template read() const
-    {
-        QByteArray byteArray;
-        QtUtils::readFile(file, byteArray);
-        QDataStream f(byteArray);
-
-        { // Check header
-            QByteArray header(128, 0);
-            f.readRawData(header.data(), 128);
-            if (!header.startsWith("MATLAB 5.0 MAT-file"))
-                qFatal("Invalid MAT header.");
-        }
-
-        Template t(file);
-
-        while (!f.atEnd()) {
-            Element element(f);
-
-            // miCOMPRESSED
-            if (element.type == 15) {
-                // Prepend the number of bytes to element.data
-                element.data.prepend((char*)&element.bytes, 4); // Qt zlib wrapper requires this to preallocate the buffer
-                QDataStream uncompressed(qUncompress(element.data));
-                element = Element(uncompressed);
-            }
-
-            // miMATRIX
-            if (element.type == 14) {
-                QDataStream matrix(element.data);
-                qint32 rows = 0, columns = 0;
-                int matrixType = 0;
-                QByteArray matrixData;
-                while (!matrix.atEnd()) {
-                    Element subelement(matrix);
-                    if (subelement.type == 5) { // Dimensions array
-                        if (subelement.bytes == 8) {
-                            rows = ((qint32*)subelement.data.data())[0];
-                            columns = ((qint32*)subelement.data.data())[1];
-                        } else {
-                            qWarning("matFormat::read can only handle 2D arrays.");
-                        }
-                    } else if (subelement.type == 7) { //miSINGLE
-                        matrixType = CV_32FC1;
-                        matrixData = subelement.data;
-                    } else if (subelement.type == 9) { //miDOUBLE
-                        matrixType = CV_64FC1;
-                        matrixData = subelement.data;
-                    }
-                }
-
-                if ((rows > 0) && (columns > 0) && (matrixType != 0) && !matrixData.isEmpty()) {
-                    Mat transposed;
-                    transpose(Mat(columns, rows, matrixType, matrixData.data()), transposed);
-                    t.append(transposed);
-                }
-            }
-        }
-
-        return t;
-    }
-
-    void write(const Template &t) const
-    {
-        QByteArray data;
-        QDataStream stream(&data, QFile::WriteOnly);
-
-        { // Header
-            QByteArray header = "MATLAB 5.0 MAT-file; Made with OpenBR | www.openbiometrics.org\n";
-            QByteArray buffer(116-header.size(), 0);
-            stream.writeRawData(header.data(), header.size());
-            stream.writeRawData(buffer.data(), buffer.size());
-            quint64 subsystem = 0;
-            quint16 version = 0x0100;
-            const char *endianness = "IM";
-            stream.writeRawData((const char*)&subsystem, 8);
-            stream.writeRawData((const char*)&version, 2);
-            stream.writeRawData(endianness, 2);
-        }
-
-        for (int i=0; i<t.size(); i++) {
-            const Mat &m = t[i];
-            if (m.channels() != 1) qFatal("Only supports single channel matrices.");
-
-            QByteArray subdata;
-            QDataStream substream(&subdata, QFile::WriteOnly);
-
-            {  // Array Flags
-                quint32 type = 6;
-                quint32 bytes = 8;
-                quint64 arrayClass = 0;
-                switch (m.type()) {
-                  case CV_64FC1: arrayClass = 6; break;
-                  case CV_32FC1: arrayClass = 7; break;
-                  case CV_8UC1: arrayClass = 8; break;
-                  case CV_8SC1: arrayClass = 9; break;
-                  case CV_16UC1: arrayClass = 10; break;
-                  case CV_16SC1: arrayClass = 11; break;
-                  case CV_32SC1: arrayClass = 12; break;
-                  default: qFatal("Unsupported matrix class.");
-                }
-                substream.writeRawData((const char*)&type, 4);
-                substream.writeRawData((const char*)&bytes, 4);
-                substream.writeRawData((const char*)&arrayClass, 8);
-            }
-
-            { // Dimensions Array
-                quint32 type = 5;
-                quint32 bytes = 8;
-                substream.writeRawData((const char*)&type, 4);
-                substream.writeRawData((const char*)&bytes, 4);
-                substream.writeRawData((const char*)&m.rows, 4);
-                substream.writeRawData((const char*)&m.cols, 4);
-            }
-
-            { // Array Name
-                QByteArray name(qPrintable(QString("OpenBR_%1").arg(QString::number(i))));
-                quint32 type = 1;
-                quint32 bytes = name.size();
-                QByteArray buffer((8 - bytes%8)%8, 0);
-                substream.writeRawData((const char*)&type, 4);
-                substream.writeRawData((const char*)&bytes, 4);
-                substream.writeRawData(name.data(), name.size());
-                substream.writeRawData(buffer.data(), buffer.size());
-            }
-
-            { // Real part
-                quint32 type = 0;
-                switch (m.type()) {
-                  case CV_8SC1:  type = 1; break;
-                  case CV_8UC1:  type = 2; break;
-                  case CV_16SC1: type = 3; break;
-                  case CV_16UC1: type = 4; break;
-                  case CV_32SC1: type = 5; break;
-                  case CV_32FC1: type = 7; break;
-                  case CV_64FC1: type = 9; break;
-                  default: qFatal("Unsupported matrix type.");
-                }
-                quint32 bytes = m.elemSize() * m.rows * m.cols;
-                QByteArray buffer((8 - bytes%8)%8, 0);
-                Mat transposed;
-                transpose(m, transposed);
-                substream.writeRawData((const char*)&type, 4);
-                substream.writeRawData((const char*)&bytes, 4);
-                substream.writeRawData((const char*)transposed.data, bytes);
-                substream.writeRawData(buffer.data(), buffer.size());
-            }
-
-            { // Matrix
-                quint32 type = 14;
-                quint32 bytes = subdata.size();
-                stream.writeRawData((const char*)&type, 4);
-                stream.writeRawData((const char*)&bytes, 4);
-                stream.writeRawData(subdata.data(), subdata.size());
-            }
-        }
-
-        QtUtils::writeFile(file, data);
-    }
-};
-
-BR_REGISTER(Format, matFormat)
-
-/*!
- * \ingroup formats
- * \brief Returns an empty matrix.
- * \author Josh Klontz \cite jklontz
- */
-class nullFormat : public Format
-{
-    Q_OBJECT
-
-    Template read() const
-    {
-        return Template(file, Mat());
-    }
-
-    void write(const Template &t) const
-    {
-        (void)t;
-    }
-};
-
-BR_REGISTER(Format, nullFormat)
-
-/*!
- * \ingroup formats
- * \brief RAW format
- *
- * http://www.nist.gov/srd/nistsd27.cfm
- * \author Josh Klontz \cite jklontz
- */
-class rawFormat : public Format
-{
-    Q_OBJECT
-    static QHash<QString, QHash<QString,QSize> > imageSizes; // QHash<Path, QHash<File,Size> >
-
-    Template read() const
-    {
-        QString path = file.path();
-        if (!imageSizes.contains(path)) {
-            static QMutex mutex;
-            QMutexLocker locker(&mutex);
-
-            if (!imageSizes.contains(path)) {
-                const QString imageSize = path+"/ImageSize.txt";
-                QStringList lines;
-                if (QFileInfo(imageSize).exists()) {
-                    lines = QtUtils::readLines(imageSize);
-                    lines.removeFirst(); // Remove header
-                }
-
-                QHash<QString,QSize> sizes;
-                QRegExp whiteSpace("\\s+");
-                foreach (const QString &line, lines) {
-                    QStringList words = line.split(whiteSpace);
-                    if (words.size() != 3) continue;
-                    sizes.insert(words[0], QSize(words[2].toInt(), words[1].toInt()));
-                }
-
-                imageSizes.insert(path, sizes);
-            }
-        }
-
-        QByteArray data;
-        QtUtils::readFile(file, data);
-
-        QSize size = imageSizes[path][file.baseName()];
-        if (!size.isValid()) size = QSize(800,768);
-        if (data.size() != size.width() * size.height())
-            qFatal("Expected %d*%d bytes, got %d.", size.height(), size.width(), data.size());
-        return Template(file, Mat(size.height(), size.width(), CV_8UC1, data.data()).clone());
-    }
-
-    void write(const Template &t) const
-    {
-        QtUtils::writeFile(file, QByteArray().setRawData((const char*)t.m().data, t.m().total() * t.m().elemSize()));
-    }
-};
-
-QHash<QString, QHash<QString,QSize> > rawFormat::imageSizes;
-
-BR_REGISTER(Format, rawFormat)
-
-/*!
- * \ingroup formats
- * \brief Retrieves an image from a webcam.
- * \author Josh Klontz \cite jklontz
- */
-class webcamFormat : public Format
-{
-    Q_OBJECT
-
-    Template read() const
-    {
-        static QScopedPointer<VideoCapture> videoCapture;
-
-        if (videoCapture.isNull())
-            videoCapture.reset(new VideoCapture(0));
-
-        Mat m;
-        videoCapture->read(m);
-        return Template(m);
-    }
-
-    void write(const Template &t) const
-    {
-        (void) t;
-        qFatal("Not supported.");
-    }
-};
-
-BR_REGISTER(Format, webcamFormat)
-
-/*!
- * \ingroup formats
- * \brief Decodes images from Base64 xml
- * \author Scott Klum \cite sklum
- * \author Josh Klontz \cite jklontz
- */
-class xmlFormat : public Format
-{
-    Q_OBJECT
-
-    Template read() const
-    {
-        Template t;
-
-#ifndef BR_EMBEDDED
-        QString fileName = file.get<QString>("path") + file.name;
-
-        QDomDocument doc(fileName);
-        QFile f(fileName);
-
-        if (!f.open(QIODevice::ReadOnly)) qFatal("Unable to open %s for reading.", qPrintable(file.flat()));
-        if (!doc.setContent(&f)) qWarning("Unable to parse %s.", qPrintable(file.flat()));
-        f.close();
-
-        QDomElement docElem = doc.documentElement();
-        QDomNode subject = docElem.firstChild();
-        while (!subject.isNull()) {
-            QDomNode fileNode = subject.firstChild();
-
-            while (!fileNode.isNull()) {
-                QDomElement e = fileNode.toElement();
-
-                if (e.tagName() == "FORMAL_IMG") {
-                    QByteArray byteArray = QByteArray::fromBase64(qPrintable(e.text()));
-                    Mat m = imdecode(Mat(3, byteArray.size(), CV_8UC3, byteArray.data()), CV_LOAD_IMAGE_COLOR);
-                    if (!m.data) qWarning("xmlFormat::read failed to decode image data.");
-                    t.append(m);
-                } else if ((e.tagName() == "RELEASE_IMG") ||
-                           (e.tagName() == "PREBOOK_IMG") ||
-                           (e.tagName() == "LPROFILE") ||
-                           (e.tagName() == "RPROFILE")) {
-                    // Ignore these other image fields for now
-                } else {
-                    t.file.set(e.tagName(), e.text());
-                }
-
-                fileNode = fileNode.nextSibling();
-            }
-            subject = subject.nextSibling();
-        }
-
-        // Calculate age
-        if (t.file.contains("DOB")) {
-            const QDate dob = QDate::fromString(t.file.get<QString>("DOB").left(10), "yyyy-MM-dd");
-            const QDate current = QDate::currentDate();
-            int age = current.year() - dob.year();
-            if (current.month() < dob.month()) age--;
-            t.file.set("Age", age);
-        }
-#endif // BR_EMBEDDED
-
-        return t;
-    }
-
-    void write(const Template &t) const
-    {
-        QStringList lines;
-        lines.append("<?xml version=\"1.0\" standalone=\"yes\"?>");
-        lines.append("<openbr-xml-format>");
-        lines.append("\t<xml-data>");
-        foreach (const QString &key, t.file.localKeys()) {
-            if ((key == "Index") || (key == "Label")) continue;
-            lines.append("\t\t<"+key+">"+QtUtils::toString(t.file.value(key))+"</"+key+">");
-        }
-        std::vector<uchar> data;
-        imencode(".jpg",t.m(),data);
-        QByteArray byteArray = QByteArray::fromRawData((const char*)data.data(), data.size());
-        lines.append("\t\t<FORMAL_IMG>"+byteArray.toBase64()+"</FORMAL_IMG>");
-        lines.append("\t</xml-data>");
-        lines.append("</openbr-xml-format>");
-        QtUtils::writeFile(file, lines);
-    }
-};
-
-BR_REGISTER(Format, xmlFormat)
-
-/*!
- * \ingroup formats
- * \brief Reads in scores or ground truth from a text table.
- * \author Josh Klontz \cite jklontz
- *
- * Example of the format:
- * \code
- * 2.2531514    FALSE   99990377    99990164
- * 2.2549822    TRUE    99990101    99990101
- * \endcode
- */
-class scoresFormat : public Format
-{
-    Q_OBJECT
-    Q_PROPERTY(int column READ get_column WRITE set_column RESET reset_column STORED false)
-    Q_PROPERTY(bool groundTruth READ get_groundTruth WRITE set_groundTruth RESET reset_groundTruth STORED false)
-    Q_PROPERTY(QString delimiter READ get_delimiter WRITE set_delimiter RESET reset_delimiter STORED false)
-    BR_PROPERTY(int, column, 0)
-    BR_PROPERTY(bool, groundTruth, false)
-    BR_PROPERTY(QString, delimiter, "\t")
-
-    Template read() const
-    {
-        QFile f(file.name);
-        if (!f.open(QFile::ReadOnly | QFile::Text))
-            qFatal("Failed to open %s for reading.", qPrintable(f.fileName()));
-        QList<float> values;
-        while (!f.atEnd()) {
-            const QStringList words = QString(f.readLine()).split(delimiter);
-            if (words.size() <= column) qFatal("Expected file to have at least %d columns.", column+1);
-            const QString &word = words[column];
-            bool ok;
-            float value = word.toFloat(&ok);
-            if (!ok) value = (QtUtils::toBool(word) ? BEE::Match : BEE::NonMatch);
-            values.append(value);
-        }
-        if (values.size() == 1)
-            qWarning("Only one value read, double check file line endings.");
-        Mat result = OpenCVUtils::toMat(values);
-        if (groundTruth) result.convertTo(result, CV_8U);
-        return result;
-    }
-
-    void write(const Template &t) const
-    {
-        (void) t;
-        qFatal("Not implemented.");
-    }
-};
-
-BR_REGISTER(Format, scoresFormat)
-
-/*!
- * \ingroup formats
- * \brief Reads FBI EBTS transactions.
- * \author Scott Klum \cite sklum
- * https://www.fbibiospecs.org/ebts.html
- */
-class ebtsFormat : public Format
-{
-    Q_OBJECT
-
-    struct Field {
-        int type;
-        QList<QByteArray> data;
-    };
-
-    struct Record {
-        int type;
-        quint32 bytes;
-        int position; // Starting position of record
-
-        QHash<int,QList<QByteArray> > fields;
-    };
-
-    quint32 recordBytes(const QByteArray &byteArray, const float recordType, int from) const
-    {
-        bool ok;
-        quint32 size;
-
-        if (recordType == 4 || recordType == 7) {
-            // read first four bytes
-            ok = true;
-            size = qFromBigEndian<quint32>((const uchar*)byteArray.mid(from,4).constData());
-        } else {
-            int index = byteArray.indexOf(QChar(0x1D), from);
-            size = byteArray.mid(from, index-from).split(':').last().toInt(&ok);
-        }
-
-        return ok ? size : -1;
-    }
-
-    void parseRecord(const QByteArray &byteArray, Record &record) const
-    {
-        if (record.type == 4 || record.type == 7) {
-            // Just a binary blob
-            // Read everything after the first four bytes
-            // Not current supported
-        } else {
-            // Continue reading fields until we get all the data
-            unsigned int position = record.position;
-            while (position < record.position + record.bytes) {
-                int index = byteArray.indexOf(QChar(0x1D), position);
-                Field field = parseField(byteArray.mid(position, index-position),QChar(0x1F));
-                if (field.type == 999 ) {
-                    // Data begin after the field identifier and the colon
-                    int dataBegin = byteArray.indexOf(':', position)+1;
-                    field.data.clear();
-                    field.data.append(byteArray.mid(dataBegin, record.bytes-(dataBegin-record.position)));
-
-                    // Data fields are always last in the record
-                    record.fields.insert(field.type,field.data);
-                    break;
-                }
-                // Advance the position accounting for the separator
-                position += index-position+1;
-                record.fields.insert(field.type,field.data);
-            }
-        }
-    }
-
-    Field parseField(const QByteArray &byteArray, const QChar &sep) const
-    {
-        bool ok;
-        Field f;
-
-        QList<QByteArray> data = byteArray.split(':');
-
-        f.type = data.first().split('.').last().toInt(&ok);
-        f.data = data.last().split(sep.toLatin1());
-
-        return f;
-    }
-
-    Template read() const
-    {
-        QByteArray byteArray;
-        QtUtils::readFile(file, byteArray);
-
-        Template t;
-
-        Mat m;
-
-        QList<Record> records;
-
-        // Read the type one record (every EBTS file will have one of these)
-        Record r1;
-        r1.type = 1;
-        r1.position = 0;
-        r1.bytes = recordBytes(byteArray,r1.type,r1.position);
-
-        // The fields in a type 1 record are strictly defined
-        QList<QByteArray> data = byteArray.mid(r1.position,r1.bytes).split(QChar(0x1D).toLatin1());
-        foreach (const QByteArray &datum, data) {
-            Field f = parseField(datum,QChar(0x1F));
-            r1.fields.insert(f.type,f.data);
-        }
-
-        records.append(r1);
-
-        // Read the type two record (every EBTS file will have one of these)
-        Record r2;
-        r2.type = 2;
-        r2.position = r1.bytes;
-        r2.bytes = recordBytes(byteArray,r2.type,r2.position);
-
-        // The fields in a type 2 record are strictly defined
-        data = byteArray.mid(r2.position,r2.bytes).split(QChar(0x1D).toLatin1());
-        foreach (const QByteArray &datum, data) {
-            Field f = parseField(datum,QChar(0x1F));
-            r2.fields.insert(f.type,f.data);
-        }
-
-        // Demographics
-        if (r2.fields.contains(18)) {
-            QString name = r2.fields.value(18).first();
-            QStringList names = name.split(',');
-            t.file.set("FIRSTNAME", names.at(1));
-            t.file.set("LASTNAME", names.at(0));
-        }
-
-        if (r2.fields.contains(22)) t.file.set("DOB", r2.fields.value(22).first().toInt());
-        if (r2.fields.contains(24)) t.file.set("GENDER", QString(r2.fields.value(24).first()));
-        if (r2.fields.contains(25)) t.file.set("RACE", QString(r2.fields.value(25).first()));
-
-        if (t.file.contains("DOB")) {
-            const QDate dob = QDate::fromString(t.file.get<QString>("DOB"), "yyyyMMdd");
-            const QDate current = QDate::currentDate();
-            int age = current.year() - dob.year();
-            if (current.month() < dob.month()) age--;
-            t.file.set("Age", age);
-        }
-
-        records.append(r2);
-
-        // The third field of the first record contains informations about all the remaining records in the transaction
-        // We don't care about the first two and the final items
-        QList<QByteArray> recordTypes = r1.fields.value(3);
-        for (int i=2; i<recordTypes.size()-1; i++) {
-            // The first two bytes indicate the record index (and we don't want the separator), but we only care about the type
-            QByteArray recordType = recordTypes[i].mid(3);
-            Record r;
-            r.type = recordType.toInt();
-            records.append(r);
-        }
-
-        QList<int> frontalIdxs;
-        int position = r1.bytes + r2.bytes;
-        for (int i=2; i<records.size(); i++) {
-            records[i].position = position;
-            records[i].bytes = recordBytes(byteArray,records[i].type,position);
-
-            parseRecord(byteArray, records[i]);
-            if (records[i].type == 10) frontalIdxs.append(i);
-            position += records[i].bytes;
-        }
-
-        if (!frontalIdxs.isEmpty()) {
-            // We use the first type 10 record to get the frontal
-            QByteArray frontal = records[frontalIdxs.first()].fields.value(999).first();
-            m = imdecode(Mat(3, frontal.size(), CV_8UC3, frontal.data()), CV_LOAD_IMAGE_COLOR);
-            if (!m.data) qWarning("ebtsFormat::read failed to decode image data.");
-            t.m() = m;
-        } else qWarning("ebtsFormat::cannot find image data within file.");
-
-        return t;
-    }
-
-    void write(const Template &t) const
-    {
-        (void) t;
-        qFatal("Writing EBTS files is not supported.");
-    }
-};
-
-BR_REGISTER(Format, ebtsFormat)
-
-} // namespace br
-
-#include "format.moc"
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * Copyright 2012 The MITRE Corporation                                      *
+ *                                                                           *
+ * Licensed under the Apache License, Version 2.0 (the "License");           *
+ * you may not use this file except in compliance with the License.          *
+ * You may obtain a copy of the License at                                   *
+ *                                                                           *
+ *     http://www.apache.org/licenses/LICENSE-2.0                            *
+ *                                                                           *
+ * Unless required by applicable law or agreed to in writing, software       *
+ * distributed under the License is distributed on an "AS IS" BASIS,         *
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  *
+ * See the License for the specific language governing permissions and       *
+ * limitations under the License.                                            *
+ * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+
+#include <openbr/plugins/openbr_internal.h>
+#include <openbr/core/qtutils.h>
+
+using namespace cv;
+
+namespace br
+{
+
+/*!
+ * \ingroup formats
+ * \brief A simple binary matrix format.
+ * \author Josh Klontz \cite jklontz
+ * First 4 bytes indicate the number of rows.
+ * Second 4 bytes indicate the number of columns.
+ * The rest of the bytes are 32-bit floating data elements in row-major order.
+ */
+class binaryFormat : public Format
+{
+    Q_OBJECT
+    Q_PROPERTY(bool raw READ get_raw WRITE set_raw RESET reset_raw STORED false)
+    BR_PROPERTY(bool, raw, false)
+
+    Template read() const
+    {
+        QByteArray data;
+        QtUtils::readFile(file, data);
+        if (raw) {
+            return Template(file, Mat(1, data.size(), CV_8UC1, data.data()).clone());
+        } else {
+            return Template(file, Mat(((quint32*)data.data())[0],
+                                      ((quint32*)data.data())[1],
+                                      CV_32FC1,
+                                      data.data()+8).clone());
+        }
+    }
+
+    void write(const Template &t) const
+    {
+        QFile f(file);
+        QtUtils::touchDir(f);
+        if (!f.open(QFile::WriteOnly))
+            qFatal("Failed to open %s for writing.", qPrintable(file));
+
+        Mat m;
+        if (!raw) {
+            if (t.m().type() != CV_32FC1)
+                t.m().convertTo(m, CV_32F);
+            else m = t.m();
+
+            if (m.channels() != 1) qFatal("Only supports single channel matrices.");
+
+            f.write((const char *) &m.rows, 4);
+            f.write((const char *) &m.cols, 4);
+        }
+        else m =  t.m();
+
+        qint64 rowSize = m.cols * sizeof(float);
+        for (int i=0; i < m.rows; i++)
+        {
+            f.write((const char *) m.row(i).data, rowSize);
+        }
+        f.close();
+    }
+};
+
+BR_REGISTER(Format, binaryFormat)
+
+} // namespace br
+
+#include "format/binary.moc"
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * Copyright 2012 The MITRE Corporation                                      *
+ *                                                                           *
+ * Licensed under the Apache License, Version 2.0 (the "License");           *
+ * you may not use this file except in compliance with the License.          *
+ * You may obtain a copy of the License at                                   *
+ *                                                                           *
+ *     http://www.apache.org/licenses/LICENSE-2.0                            *
+ *                                                                           *
+ * Unless required by applicable law or agreed to in writing, software       *
+ * distributed under the License is distributed on an "AS IS" BASIS,         *
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  *
+ * See the License for the specific language governing permissions and       *
+ * limitations under the License.                                            *
+ * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+
+#include <QRegularExpression>
+
+#include <openbr/plugins/openbr_internal.h>
+#include <openbr/core/opencvutils.h>
+#include <openbr/core/qtutils.h>
+
+using namespace cv;
+
+namespace br
+{
+
+/*!
+ * \ingroup formats
+ * \brief Reads a comma separated value file.
+ * \author Josh Klontz \cite jklontz
+ */
+class csvFormat : public Format
+{
+    Q_OBJECT
+
+    Template read() const
+    {
+        QFile f(file.name);
+        f.open(QFile::ReadOnly);
+        QStringList lines(QString(f.readAll()).split(QRegularExpression("[\n|\r\n|\r]"), QString::SkipEmptyParts));
+        f.close();
+
+        bool isUChar = true;
+        QList< QList<float> > valsList;
+        foreach (const QString &line, lines) {
+            QList<float> vals;
+            foreach (const QString &word, line.split(QRegExp(" *, *"), QString::SkipEmptyParts)) {
+                bool ok;
+                const float val = word.toFloat(&ok);
+                vals.append(val);
+                isUChar = isUChar && (val == float(uchar(val)));
+            }
+            if (!vals.isEmpty())
+                valsList.append(vals);
+        }
+
+        Mat m(valsList.size(), valsList[0].size(), CV_32FC1);
+        for (int i=0; i<valsList.size(); i++)
+            for (int j=0; j<valsList[i].size(); j++)
+                m.at<float>(i,j) = valsList[i][j];
+
+        if (isUChar) m.convertTo(m, CV_8U);
+        return Template(m);
+    }
+
+    void write(const Template &t) const
+    {
+        const Mat &m = t.m();
+        if (t.size() != 1) qFatal("Only supports single matrix templates.");
+        if (m.channels() != 1) qFatal("Only supports single channel matrices.");
+
+        QStringList lines; lines.reserve(m.rows);
+        for (int r=0; r<m.rows; r++) {
+            QStringList elements; elements.reserve(m.cols);
+            for (int c=0; c<m.cols; c++)
+                elements.append(OpenCVUtils::elemToString(m, r, c));
+            lines.append(elements.join(","));
+        }
+
+        QtUtils::writeFile(file, lines);
+    }
+};
+
+BR_REGISTER(Format, csvFormat)
+
+} // namespace br
+
+#include "format/csv.moc"
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * Copyright 2012 The MITRE Corporation                                      *
+ *                                                                           *
+ * Licensed under the Apache License, Version 2.0 (the "License");           *
+ * you may not use this file except in compliance with the License.          *
+ * You may obtain a copy of the License at                                   *
+ *                                                                           *
+ *     http://www.apache.org/licenses/LICENSE-2.0                            *
+ *                                                                           *
+ * Unless required by applicable law or agreed to in writing, software       *
+ * distributed under the License is distributed on an "AS IS" BASIS,         *
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  *
+ * See the License for the specific language governing permissions and       *
+ * limitations under the License.                                            *
+ * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+
+#include <QtEndian>
+#include <opencv2/highgui/highgui.hpp>
+
+#include <openbr/plugins/openbr_internal.h>
+#include <openbr/core/qtutils.h>
+
+using namespace cv;
+
+namespace br
+{
+
+/*!
+ * \ingroup formats
+ * \brief Reads FBI EBTS transactions.
+ * \author Scott Klum \cite sklum
+ * https://www.fbibiospecs.org/ebts.html
+ */
+class ebtsFormat : public Format
+{
+    Q_OBJECT
+
+    struct Field {
+        int type;
+        QList<QByteArray> data;
+    };
+
+    struct Record {
+        int type;
+        quint32 bytes;
+        int position; // Starting position of record
+
+        QHash<int,QList<QByteArray> > fields;
+    };
+
+    quint32 recordBytes(const QByteArray &byteArray, const float recordType, int from) const
+    {
+        bool ok;
+        quint32 size;
+
+        if (recordType == 4 || recordType == 7) {
+            // read first four bytes
+            ok = true;
+            size = qFromBigEndian<quint32>((const uchar*)byteArray.mid(from,4).constData());
+        } else {
+            int index = byteArray.indexOf(QChar(0x1D), from);
+            size = byteArray.mid(from, index-from).split(':').last().toInt(&ok);
+        }
+
+        return ok ? size : -1;
+    }
+
+    void parseRecord(const QByteArray &byteArray, Record &record) const
+    {
+        if (record.type == 4 || record.type == 7) {
+            // Just a binary blob
+            // Read everything after the first four bytes
+            // Not current supported
+        } else {
+            // Continue reading fields until we get all the data
+            unsigned int position = record.position;
+            while (position < record.position + record.bytes) {
+                int index = byteArray.indexOf(QChar(0x1D), position);
+                Field field = parseField(byteArray.mid(position, index-position),QChar(0x1F));
+                if (field.type == 999 ) {
+                    // Data begin after the field identifier and the colon
+                    int dataBegin = byteArray.indexOf(':', position)+1;
+                    field.data.clear();
+                    field.data.append(byteArray.mid(dataBegin, record.bytes-(dataBegin-record.position)));
+
+                    // Data fields are always last in the record
+                    record.fields.insert(field.type,field.data);
+                    break;
+                }
+                // Advance the position accounting for the separator
+                position += index-position+1;
+                record.fields.insert(field.type,field.data);
+            }
+        }
+    }
+
+    Field parseField(const QByteArray &byteArray, const QChar &sep) const
+    {
+        bool ok;
+        Field f;
+
+        QList<QByteArray> data = byteArray.split(':');
+
+        f.type = data.first().split('.').last().toInt(&ok);
+        f.data = data.last().split(sep.toLatin1());
+
+        return f;
+    }
+
+    Template read() const
+    {
+        QByteArray byteArray;
+        QtUtils::readFile(file, byteArray);
+
+        Template t;
+
+        Mat m;
+
+        QList<Record> records;
+
+        // Read the type one record (every EBTS file will have one of these)
+        Record r1;
+        r1.type = 1;
+        r1.position = 0;
+        r1.bytes = recordBytes(byteArray,r1.type,r1.position);
+
+        // The fields in a type 1 record are strictly defined
+        QList<QByteArray> data = byteArray.mid(r1.position,r1.bytes).split(QChar(0x1D).toLatin1());
+        foreach (const QByteArray &datum, data) {
+            Field f = parseField(datum,QChar(0x1F));
+            r1.fields.insert(f.type,f.data);
+        }
+
+        records.append(r1);
+
+        // Read the type two record (every EBTS file will have one of these)
+        Record r2;
+        r2.type = 2;
+        r2.position = r1.bytes;
+        r2.bytes = recordBytes(byteArray,r2.type,r2.position);
+
+        // The fields in a type 2 record are strictly defined
+        data = byteArray.mid(r2.position,r2.bytes).split(QChar(0x1D).toLatin1());
+        foreach (const QByteArray &datum, data) {
+            Field f = parseField(datum,QChar(0x1F));
+            r2.fields.insert(f.type,f.data);
+        }
+
+        // Demographics
+        if (r2.fields.contains(18)) {
+            QString name = r2.fields.value(18).first();
+            QStringList names = name.split(',');
+            t.file.set("FIRSTNAME", names.at(1));
+            t.file.set("LASTNAME", names.at(0));
+        }
+
+        if (r2.fields.contains(22)) t.file.set("DOB", r2.fields.value(22).first().toInt());
+        if (r2.fields.contains(24)) t.file.set("GENDER", QString(r2.fields.value(24).first()));
+        if (r2.fields.contains(25)) t.file.set("RACE", QString(r2.fields.value(25).first()));
+
+        if (t.file.contains("DOB")) {
+            const QDate dob = QDate::fromString(t.file.get<QString>("DOB"), "yyyyMMdd");
+            const QDate current = QDate::currentDate();
+            int age = current.year() - dob.year();
+            if (current.month() < dob.month()) age--;
+            t.file.set("Age", age);
+        }
+
+        records.append(r2);
+
+        // The third field of the first record contains informations about all the remaining records in the transaction
+        // We don't care about the first two and the final items
+        QList<QByteArray> recordTypes = r1.fields.value(3);
+        for (int i=2; i<recordTypes.size()-1; i++) {
+            // The first two bytes indicate the record index (and we don't want the separator), but we only care about the type
+            QByteArray recordType = recordTypes[i].mid(3);
+            Record r;
+            r.type = recordType.toInt();
+            records.append(r);
+        }
+
+        QList<int> frontalIdxs;
+        int position = r1.bytes + r2.bytes;
+        for (int i=2; i<records.size(); i++) {
+            records[i].position = position;
+            records[i].bytes = recordBytes(byteArray,records[i].type,position);
+
+            parseRecord(byteArray, records[i]);
+            if (records[i].type == 10) frontalIdxs.append(i);
+            position += records[i].bytes;
+        }
+
+        if (!frontalIdxs.isEmpty()) {
+            // We use the first type 10 record to get the frontal
+            QByteArray frontal = records[frontalIdxs.first()].fields.value(999).first();
+            m = imdecode(Mat(3, frontal.size(), CV_8UC3, frontal.data()), CV_LOAD_IMAGE_COLOR);
+            if (!m.data) qWarning("ebtsFormat::read failed to decode image data.");
+            t.m() = m;
+        } else qWarning("ebtsFormat::cannot find image data within file.");
+
+        return t;
+    }
+
+    void write(const Template &t) const
+    {
+        (void) t;
+        qFatal("Writing EBTS files is not supported.");
+    }
+};
+
+BR_REGISTER(Format, ebtsFormat)
+
+} // namespace br
+
+#include "format/ebts.moc"
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * Copyright 2012 The MITRE Corporation                                      *
+ *                                                                           *
+ * Licensed under the Apache License, Version 2.0 (the "License");           *
+ * you may not use this file except in compliance with the License.          *
+ * You may obtain a copy of the License at                                   *
+ *                                                                           *
+ *     http://www.apache.org/licenses/LICENSE-2.0                            *
+ *                                                                           *
+ * Unless required by applicable law or agreed to in writing, software       *
+ * distributed under the License is distributed on an "AS IS" BASIS,         *
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  *
+ * See the License for the specific language governing permissions and       *
+ * limitations under the License.                                            *
+ * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+
+#include <openbr/plugins/openbr_internal.h>
+#include <openbr/core/qtutils.h>
+
+using namespace cv;
+
+namespace br
+{
+
+/*!
+ * \ingroup formats
+ * \brief Reads a NIST LFFS file.
+ * \author Josh Klontz \cite jklontz
+ */
+class lffsFormat : public Format
+{
+    Q_OBJECT
+
+    Template read() const
+    {
+        QByteArray byteArray;
+        QtUtils::readFile(file.name, byteArray);
+        return Mat(1, byteArray.size(), CV_8UC1, byteArray.data()).clone();
+    }
+
+    void write(const Template &t) const
+    {
+        QByteArray byteArray((const char*)t.m().data, t.m().total()*t.m().elemSize());
+        QtUtils::writeFile(file.name, byteArray);
+    }
+};
+
+BR_REGISTER(Format, lffsFormat)
+
+} // namespace br
+
+#include "format/lffs.moc"
+#include <openbr/plugins/openbr_internal.h>
+
+namespace br
+{
+
+/*!
+ * \ingroup formats
+ * \brief Likely matrix format
+ *
+ * www.liblikely.org
+ * \author Josh Klontz \cite jklontz
+ */
+class lmatFormat : public Format
+{
+    Q_OBJECT
+
+    Template read() const
+    {
+        const likely_const_mat m = likely_read(qPrintable(file.name), likely_file_guess);
+        const Template result(likelyToOpenCVMat(m));
+        likely_release_mat(m);
+        return result;
+    }
+
+    void write(const Template &t) const
+    {
+        const likely_const_mat m = likelyFromOpenCVMat(t);
+        likely_write(m, qPrintable(file.name));
+        likely_release_mat(m);
+    }
+};
+
+BR_REGISTER(Format, lmatFormat)
+
+} // namespace br
+
+#include "format/lmat.moc"
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * Copyright 2012 The MITRE Corporation                                      *
+ *                                                                           *
+ * Licensed under the Apache License, Version 2.0 (the "License");           *
+ * you may not use this file except in compliance with the License.          *
+ * You may obtain a copy of the License at                                   *
+ *                                                                           *
+ *     http://www.apache.org/licenses/LICENSE-2.0                            *
+ *                                                                           *
+ * Unless required by applicable law or agreed to in writing, software       *
+ * distributed under the License is distributed on an "AS IS" BASIS,         *
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  *
+ * See the License for the specific language governing permissions and       *
+ * limitations under the License.                                            *
+ * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+
+#include <openbr/plugins/openbr_internal.h>
+#include <openbr/core/qtutils.h>
+
+using namespace cv;
+
+namespace br
+{
+
+/*!
+ * \ingroup formats
+ * \brief MATLAB <tt>.mat</tt> format.
+ * \author Josh Klontz \cite jklontz
+ * http://www.mathworks.com/help/pdf_doc/matlab/matfile_format.pdf
+ * \note matFormat is known not to work with compressed matrices
+ */
+class matFormat : public Format
+{
+    Q_OBJECT
+
+    struct Element
+    {
+        // It is always best to cast integers to a Qt integer type, such as qint16 or quint32, when reading and writing.
+        // This ensures that you always know exactly what size integers you are reading and writing, no matter what the
+        // underlying platform and architecture the application happens to be running on.
+        // http://qt-project.org/doc/qt-4.8/datastreamformat.html
+        quint32 type, bytes;
+        QByteArray data;
+        Element() : type(0), bytes(0) {}
+        Element(QDataStream &stream)
+            : type(0), bytes(0)
+        {
+            // Read first 4 bytes into type (32 bit integer),
+            // specifying the type of data used
+            if (stream.readRawData((char*)&type, 4) != 4)
+                qFatal("Unexpected end of file.");
+
+            if (type >= 1 << 16) {
+                // Small data format
+                bytes = type;
+                type = type & 0x0000FFFF;
+                bytes = bytes >> 16;
+            } else {
+                // Regular format
+                // Read 4 bytes into bytes (32 bit integer),
+                // specifying the size of the element
+                if (stream.readRawData((char*)&bytes, 4) != 4)
+                    qFatal("Unexpected end of file.");
+            }
+
+            // Set the size of data to bytes
+            data.resize(bytes);
+
+            // Read bytes amount of data from the file into data
+            if (int(bytes) != stream.readRawData(data.data(), bytes))
+                qFatal("Unexpected end of file.");
+
+            // Alignment
+            int skipBytes = (bytes < 4) ? (4 - bytes) : (8 - bytes%8)%8;
+            if (skipBytes != 0) stream.skipRawData(skipBytes);
+        }
+    };
+
+    Template read() const
+    {
+        QByteArray byteArray;
+        QtUtils::readFile(file, byteArray);
+        QDataStream f(byteArray);
+
+        { // Check header
+            QByteArray header(128, 0);
+            f.readRawData(header.data(), 128);
+            if (!header.startsWith("MATLAB 5.0 MAT-file"))
+                qFatal("Invalid MAT header.");
+        }
+
+        Template t(file);
+
+        while (!f.atEnd()) {
+            Element element(f);
+
+            // miCOMPRESSED
+            if (element.type == 15) {
+                // Prepend the number of bytes to element.data
+                element.data.prepend((char*)&element.bytes, 4); // Qt zlib wrapper requires this to preallocate the buffer
+                QDataStream uncompressed(qUncompress(element.data));
+                element = Element(uncompressed);
+            }
+
+            // miMATRIX
+            if (element.type == 14) {
+                QDataStream matrix(element.data);
+                qint32 rows = 0, columns = 0;
+                int matrixType = 0;
+                QByteArray matrixData;
+                while (!matrix.atEnd()) {
+                    Element subelement(matrix);
+                    if (subelement.type == 5) { // Dimensions array
+                        if (subelement.bytes == 8) {
+                            rows = ((qint32*)subelement.data.data())[0];
+                            columns = ((qint32*)subelement.data.data())[1];
+                        } else {
+                            qWarning("matFormat::read can only handle 2D arrays.");
+                        }
+                    } else if (subelement.type == 7) { //miSINGLE
+                        matrixType = CV_32FC1;
+                        matrixData = subelement.data;
+                    } else if (subelement.type == 9) { //miDOUBLE
+                        matrixType = CV_64FC1;
+                        matrixData = subelement.data;
+                    }
+                }
+
+                if ((rows > 0) && (columns > 0) && (matrixType != 0) && !matrixData.isEmpty()) {
+                    Mat transposed;
+                    transpose(Mat(columns, rows, matrixType, matrixData.data()), transposed);
+                    t.append(transposed);
+                }
+            }
+        }
+
+        return t;
+    }
+
+    void write(const Template &t) const
+    {
+        QByteArray data;
+        QDataStream stream(&data, QFile::WriteOnly);
+
+        { // Header
+            QByteArray header = "MATLAB 5.0 MAT-file; Made with OpenBR | www.openbiometrics.org\n";
+            QByteArray buffer(116-header.size(), 0);
+            stream.writeRawData(header.data(), header.size());
+            stream.writeRawData(buffer.data(), buffer.size());
+            quint64 subsystem = 0;
+            quint16 version = 0x0100;
+            const char *endianness = "IM";
+            stream.writeRawData((const char*)&subsystem, 8);
+            stream.writeRawData((const char*)&version, 2);
+            stream.writeRawData(endianness, 2);
+        }
+
+        for (int i=0; i<t.size(); i++) {
+            const Mat &m = t[i];
+            if (m.channels() != 1) qFatal("Only supports single channel matrices.");
+
+            QByteArray subdata;
+            QDataStream substream(&subdata, QFile::WriteOnly);
+
+            {  // Array Flags
+                quint32 type = 6;
+                quint32 bytes = 8;
+                quint64 arrayClass = 0;
+                switch (m.type()) {
+                  case CV_64FC1: arrayClass = 6; break;
+                  case CV_32FC1: arrayClass = 7; break;
+                  case CV_8UC1: arrayClass = 8; break;
+                  case CV_8SC1: arrayClass = 9; break;
+                  case CV_16UC1: arrayClass = 10; break;
+                  case CV_16SC1: arrayClass = 11; break;
+                  case CV_32SC1: arrayClass = 12; break;
+                  default: qFatal("Unsupported matrix class.");
+                }
+                substream.writeRawData((const char*)&type, 4);
+                substream.writeRawData((const char*)&bytes, 4);
+                substream.writeRawData((const char*)&arrayClass, 8);
+            }
+
+            { // Dimensions Array
+                quint32 type = 5;
+                quint32 bytes = 8;
+                substream.writeRawData((const char*)&type, 4);
+                substream.writeRawData((const char*)&bytes, 4);
+                substream.writeRawData((const char*)&m.rows, 4);
+                substream.writeRawData((const char*)&m.cols, 4);
+            }
+
+            { // Array Name
+                QByteArray name(qPrintable(QString("OpenBR_%1").arg(QString::number(i))));
+                quint32 type = 1;
+                quint32 bytes = name.size();
+                QByteArray buffer((8 - bytes%8)%8, 0);
+                substream.writeRawData((const char*)&type, 4);
+                substream.writeRawData((const char*)&bytes, 4);
+                substream.writeRawData(name.data(), name.size());
+                substream.writeRawData(buffer.data(), buffer.size());
+            }
+
+            { // Real part
+                quint32 type = 0;
+                switch (m.type()) {
+                  case CV_8SC1:  type = 1; break;
+                  case CV_8UC1:  type = 2; break;
+                  case CV_16SC1: type = 3; break;
+                  case CV_16UC1: type = 4; break;
+                  case CV_32SC1: type = 5; break;
+                  case CV_32FC1: type = 7; break;
+                  case CV_64FC1: type = 9; break;
+                  default: qFatal("Unsupported matrix type.");
+                }
+                quint32 bytes = m.elemSize() * m.rows * m.cols;
+                QByteArray buffer((8 - bytes%8)%8, 0);
+                Mat transposed;
+                transpose(m, transposed);
+                substream.writeRawData((const char*)&type, 4);
+                substream.writeRawData((const char*)&bytes, 4);
+                substream.writeRawData((const char*)transposed.data, bytes);
+                substream.writeRawData(buffer.data(), buffer.size());
+            }
+
+            { // Matrix
+                quint32 type = 14;
+                quint32 bytes = subdata.size();
+                stream.writeRawData((const char*)&type, 4);
+                stream.writeRawData((const char*)&bytes, 4);
+                stream.writeRawData(subdata.data(), subdata.size());
+            }
+        }
+
+        QtUtils::writeFile(file, data);
+    }
+};
+
+BR_REGISTER(Format, matFormat)
+
+} // namespace br
+
+#include "format/mat.moc"
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * Copyright 2012 The MITRE Corporation                                      *
+ *                                                                           *
+ * Licensed under the Apache License, Version 2.0 (the "License");           *
+ * you may not use this file except in compliance with the License.          *
+ * You may obtain a copy of the License at                                   *
+ *                                                                           *
+ *     http://www.apache.org/licenses/LICENSE-2.0                            *
+ *                                                                           *
+ * Unless required by applicable law or agreed to in writing, software       *
+ * distributed under the License is distributed on an "AS IS" BASIS,         *
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  *
+ * See the License for the specific language governing permissions and       *
+ * limitations under the License.                                            *
+ * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+
+#include <openbr/plugins/openbr_internal.h>
+#include <openbr/core/bee.h>
+
+namespace br
+{
+
+/*!
+ * \ingroup formats
+ * \brief Reads a NIST BEE similarity matrix.
+ * \author Josh Klontz \cite jklontz
+ */
+class mtxFormat : public Format
+{
+    Q_OBJECT
+
+    Template read() const
+    {
+        QString target, query;
+        Template result = BEE::readMatrix(file, &target, &query);
+        result.file.set("Target", target);
+        result.file.set("Query", query);
+        return result;
+    }
+
+    void write(const Template &t) const
+    {
+        BEE::writeMatrix(t, file);
+    }
+};
+
+BR_REGISTER(Format, mtxFormat)
+
+/*!
+ * \ingroup formats
+ * \brief Reads a NIST BEE mask matrix.
+ * \author Josh Klontz \cite jklontz
+ */
+class maskFormat : public mtxFormat
+{
+    Q_OBJECT
+};
+
+BR_REGISTER(Format, maskFormat)
+
+} // namespace br
+
+#include "format/mtx.moc"
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * Copyright 2012 The MITRE Corporation                                      *
+ *                                                                           *
+ * Licensed under the Apache License, Version 2.0 (the "License");           *
+ * you may not use this file except in compliance with the License.          *
+ * You may obtain a copy of the License at                                   *
+ *                                                                           *
+ *     http://www.apache.org/licenses/LICENSE-2.0                            *
+ *                                                                           *
+ * Unless required by applicable law or agreed to in writing, software       *
+ * distributed under the License is distributed on an "AS IS" BASIS,         *
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  *
+ * See the License for the specific language governing permissions and       *
+ * limitations under the License.                                            *
+ * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+
+#include <openbr/plugins/openbr_internal.h>
+
+namespace br
+{
+
+/*!
+ * \ingroup formats
+ * \brief Returns an empty matrix.
+ * \author Josh Klontz \cite jklontz
+ */
+class nullFormat : public Format
+{
+    Q_OBJECT
+
+    Template read() const
+    {
+        return Template(file, cv::Mat());
+    }
+
+    void write(const Template &t) const
+    {
+        (void)t;
+    }
+};
+
+BR_REGISTER(Format, nullFormat)
+
+} // namespace br
+
+#include "format/null.moc"
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * Copyright 2012 The MITRE Corporation                                      *
+ *                                                                           *
+ * Licensed under the Apache License, Version 2.0 (the "License");           *
+ * you may not use this file except in compliance with the License.          *
+ * You may obtain a copy of the License at                                   *
+ *                                                                           *
+ *     http://www.apache.org/licenses/LICENSE-2.0                            *
+ *                                                                           *
+ * Unless required by applicable law or agreed to in writing, software       *
+ * distributed under the License is distributed on an "AS IS" BASIS,         *
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  *
+ * See the License for the specific language governing permissions and       *
+ * limitations under the License.                                            *
+ * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+
+#include <QTcpSocket>
+#include <opencv2/highgui/highgui.hpp>
+
+#include <openbr/plugins/openbr_internal.h>
+#include <http_parser.h>
+
+using namespace cv;
+
+namespace br
+{
+
+/*!
+ * \ingroup formats
+ * \brief Handle POST requests
+ * \author Josh Klontz \cite jklontz
+ */
+class postFormat : public Format
+{
+    Q_OBJECT
+
+    Template read() const
+    {
+        Template t(file);
+
+        // Read from socket
+        QTcpSocket *socket = new QTcpSocket();
+        socket->setSocketDescriptor(file.get<qintptr>("socketDescriptor"));
+        socket->write("HTTP/1.1 200 OK\r\n"
+                      "Content-Type: text/html; charset=UTF-8\r\n\r\n"
+                      "Hello World!\r\n");
+        socket->waitForBytesWritten();
+        socket->waitForReadyRead();
+        QByteArray data = socket->readAll();
+        socket->close();
+        delete socket;
+
+        qDebug() << data;
+
+        // Parse data
+        http_parser_settings settings;
+        settings.on_body = bodyCallback;
+        settings.on_headers_complete = NULL;
+        settings.on_header_field = NULL;
+        settings.on_header_value = NULL;
+        settings.on_message_begin = NULL;
+        settings.on_message_complete = NULL;
+        settings.on_status_complete = NULL;
+        settings.on_url = NULL;
+
+        {
+            QByteArray body;
+            http_parser parser;
+            http_parser_init(&parser, HTTP_REQUEST);
+            parser.data = &body;
+            http_parser_execute(&parser, &settings, data.data(), data.size());
+            data = body;
+        }
+
+        data.prepend("HTTP/1.1 200 OK");
+        QByteArray body;
+        { // Image data is two layers deep
+            http_parser parser;
+            http_parser_init(&parser, HTTP_BOTH);
+            parser.data = &body;
+            http_parser_execute(&parser, &settings, data.data(), data.size());
+        }
+
+        t.append(imdecode(Mat(1, body.size(), CV_8UC1, body.data()), 1));
+        return t;
+    }
+
+    void write(const Template &t) const
+    {
+        (void) t;
+        qFatal("Not supported!");
+    }
+
+    static int bodyCallback(http_parser *parser, const char *at, size_t length)
+    {
+        QByteArray *byteArray = (QByteArray*)parser->data;
+        *byteArray = QByteArray(at, length);
+        return 0;
+    }
+};
+
+BR_REGISTER(Format, postFormat)
+
+} // namespace br
+
+#include "format/post.moc"
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * Copyright 2012 The MITRE Corporation                                      *
+ *                                                                           *
+ * Licensed under the Apache License, Version 2.0 (the "License");           *
+ * you may not use this file except in compliance with the License.          *
+ * You may obtain a copy of the License at                                   *
+ *                                                                           *
+ *     http://www.apache.org/licenses/LICENSE-2.0                            *
+ *                                                                           *
+ * Unless required by applicable law or agreed to in writing, software       *
+ * distributed under the License is distributed on an "AS IS" BASIS,         *
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  *
+ * See the License for the specific language governing permissions and       *
+ * limitations under the License.                                            *
+ * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+
+#include <openbr/plugins/openbr_internal.h>
+#include <openbr/core/qtutils.h>
+
+using namespace cv;
+
+namespace br
+{
+
+/*!
+ * \ingroup formats
+ * \brief RAW format
+ *
+ * http://www.nist.gov/srd/nistsd27.cfm
+ * \author Josh Klontz \cite jklontz
+ */
+class rawFormat : public Format
+{
+    Q_OBJECT
+    static QHash<QString, QHash<QString,QSize> > imageSizes; // QHash<Path, QHash<File,Size> >
+
+    Template read() const
+    {
+        QString path = file.path();
+        if (!imageSizes.contains(path)) {
+            static QMutex mutex;
+            QMutexLocker locker(&mutex);
+
+            if (!imageSizes.contains(path)) {
+                const QString imageSize = path+"/ImageSize.txt";
+                QStringList lines;
+                if (QFileInfo(imageSize).exists()) {
+                    lines = QtUtils::readLines(imageSize);
+                    lines.removeFirst(); // Remove header
+                }
+
+                QHash<QString,QSize> sizes;
+                QRegExp whiteSpace("\\s+");
+                foreach (const QString &line, lines) {
+                    QStringList words = line.split(whiteSpace);
+                    if (words.size() != 3) continue;
+                    sizes.insert(words[0], QSize(words[2].toInt(), words[1].toInt()));
+                }
+
+                imageSizes.insert(path, sizes);
+            }
+        }
+
+        QByteArray data;
+        QtUtils::readFile(file, data);
+
+        QSize size = imageSizes[path][file.baseName()];
+        if (!size.isValid()) size = QSize(800,768);
+        if (data.size() != size.width() * size.height())
+            qFatal("Expected %d*%d bytes, got %d.", size.height(), size.width(), data.size());
+        return Template(file, Mat(size.height(), size.width(), CV_8UC1, data.data()).clone());
+    }
+
+    void write(const Template &t) const
+    {
+        QtUtils::writeFile(file, QByteArray().setRawData((const char*)t.m().data, t.m().total() * t.m().elemSize()));
+    }
+};
+
+QHash<QString, QHash<QString,QSize> > rawFormat::imageSizes;
+
+BR_REGISTER(Format, rawFormat)
+
+} // namespace br
+
+#include "format/raw.moc"
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * Copyright 2012 The MITRE Corporation                                      *
+ *                                                                           *
+ * Licensed under the Apache License, Version 2.0 (the "License");           *
+ * you may not use this file except in compliance with the License.          *
+ * You may obtain a copy of the License at                                   *
+ *                                                                           *
+ *     http://www.apache.org/licenses/LICENSE-2.0                            *
+ *                                                                           *
+ * Unless required by applicable law or agreed to in writing, software       *
+ * distributed under the License is distributed on an "AS IS" BASIS,         *
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  *
+ * See the License for the specific language governing permissions and       *
+ * limitations under the License.                                            *
+ * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+
+#include <openbr/plugins/openbr_internal.h>
+#include <openbr/core/qtutils.h>
+#include <openbr/core/opencvutils.h>
+#include <openbr/core/bee.h>
+
+using namespace cv;
+
+namespace br
+{
+
+/*!
+ * \ingroup formats
+ * \brief Reads in scores or ground truth from a text table.
+ * \author Josh Klontz \cite jklontz
+ *
+ * Example of the format:
+ * \code
+ * 2.2531514    FALSE   99990377    99990164
+ * 2.2549822    TRUE    99990101    99990101
+ * \endcode
+ */
+class scoresFormat : public Format
+{
+    Q_OBJECT
+    Q_PROPERTY(int column READ get_column WRITE set_column RESET reset_column STORED false)
+    Q_PROPERTY(bool groundTruth READ get_groundTruth WRITE set_groundTruth RESET reset_groundTruth STORED false)
+    Q_PROPERTY(QString delimiter READ get_delimiter WRITE set_delimiter RESET reset_delimiter STORED false)
+    BR_PROPERTY(int, column, 0)
+    BR_PROPERTY(bool, groundTruth, false)
+    BR_PROPERTY(QString, delimiter, "\t")
+
+    Template read() const
+    {
+        QFile f(file.name);
+        if (!f.open(QFile::ReadOnly | QFile::Text))
+            qFatal("Failed to open %s for reading.", qPrintable(f.fileName()));
+        QList<float> values;
+        while (!f.atEnd()) {
+            const QStringList words = QString(f.readLine()).split(delimiter);
+            if (words.size() <= column) qFatal("Expected file to have at least %d columns.", column+1);
+            const QString &word = words[column];
+            bool ok;
+            float value = word.toFloat(&ok);
+            if (!ok) value = (QtUtils::toBool(word) ? BEE::Match : BEE::NonMatch);
+            values.append(value);
+        }
+        if (values.size() == 1)
+            qWarning("Only one value read, double check file line endings.");
+        Mat result = OpenCVUtils::toMat(values);
+        if (groundTruth) result.convertTo(result, CV_8U);
+        return result;
+    }
+
+    void write(const Template &t) const
+    {
+        (void) t;
+        qFatal("Not implemented.");
+    }
+};
+
+BR_REGISTER(Format, scoresFormat)
+
+} // namespace br
+
+#include "format/scores.moc"