Merge branch 'dlib' of https://github.com/biometrics/openbr into dlib

Scott Klum
2 parents 085f6d41 a3465289
Showing 348 changed files with 22214 additions and 13804 deletions
3rdparty/stasm4.0.0/CMakeLists.txt
CMakeLists.txt
openbr/core/cluster.cpp
openbr/core/cluster.h
openbr/core/core.cpp
openbr/core/qtutils.cpp
openbr/core/qtutils.h
openbr/janus
openbr/openbr.cpp
openbr/openbr_plugin.h
openbr/plugins/classification/adaboost.cpp
openbr/plugins/dlib.cpp → openbr/plugins/classification/dlib.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
@@ -13,7 +13,7 @@ set(CPACK_PACKAGE_VERSION &quot;${CPACK_PACKAGE_VERSION_MAJOR}.${CPACK_PACKAGE_VERSIO
 set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} "${PROJECT_SOURCE_DIR}/cmake/Modules/")
  
 # Find Qt 5.0.2
-set(QT_DEPENDENCIES Concurrent Core Gui Network Sql Svg Widgets Xml)
+set(QT_DEPENDENCIES Concurrent Core Gui Network Sql Widgets Xml)
 foreach(QT_DEPENDENCY ${QT_DEPENDENCIES})
   find_package(Qt5${QT_DEPENDENCY})
 endforeach()
@@ -80,7 +80,7 @@ endif()
 set(QT_DEPENDENCIES Concurrent Core)
 option(BR_EMBEDDED "Limit software dependencies")
 if(NOT ${BR_EMBEDDED})
-  set(QT_DEPENDENCIES ${QT_DEPENDENCIES} Gui Network Sql Svg Widgets Xml)
+  set(QT_DEPENDENCIES ${QT_DEPENDENCIES} Gui Network Sql Widgets Xml)
 endif()
 foreach(QT_DEPENDENCY ${QT_DEPENDENCIES})
   find_package(Qt5${QT_DEPENDENCY})
@@ -89,7 +89,7 @@ set(BR_THIRDPARTY_LIBS ${BR_THIRDPARTY_LIBS} ${Qt5Core_QTMAIN_LIBRARIES})
  
 # Find OpenCV
 find_package(OpenCV 2.4.5 REQUIRED)
-set(OPENCV_DEPENDENCIES opencv_calib3d opencv_core opencv_features2d opencv_flann opencv_gpu opencv_highgui opencv_imgproc opencv_ml opencv_nonfree opencv_objdetect opencv_photo opencv_video)
+set(OPENCV_DEPENDENCIES opencv_calib3d opencv_core opencv_features2d opencv_flann opencv_gpu opencv_highgui opencv_imgproc opencv_ml opencv_nonfree opencv_objdetect opencv_photo opencv_video opencv_videostab opencv_superres opencv_stitching opencv_ocl opencv_legacy opencv_contrib)
 set(BR_THIRDPARTY_LIBS ${BR_THIRDPARTY_LIBS} ${OpenCV_LIBS})
  
 # Find Alphanum
@@ -82,7 +82,7 @@ float normalizedROD(const Neighborhood &amp;neighborhood, int a, int b)
     return 1.f * (distanceA + distanceB) / std::min(indexA+1, indexB+1);
 }
  
-Neighborhood getNeighborhood(const QStringList &simmats)
+Neighborhood br::knnFromSimmat(const QList<cv::Mat> &simmats, int k)
 {
     Neighborhood neighborhood;
  
@@ -99,9 +99,7 @@ Neighborhood getNeighborhood(const QStringList &amp;simmats)
         int currentRows = -1;
         int columnOffset = 0;
         for (int j=0; j<numGalleries; j++) {
-            QScopedPointer<br::Format> format(br::Factory<br::Format>::make(simmats[i*numGalleries+j]));
-            br::Template t = format->read();
-            cv::Mat m = t.m();
+            cv::Mat m = simmats[i * numGalleries + j];
             if (j==0) {
                 currentRows = m.rows;
                 allNeighbors.resize(currentRows);
@@ -132,37 +130,164 @@ Neighborhood getNeighborhood(const QStringList &amp;simmats)
         // Keep the top matches
         for (int j=0; j<allNeighbors.size(); j++) {
             Neighbors &val = allNeighbors[j];
-            const int cutoff = 20; // Somewhat arbitrary number of neighbors to keep
+            const int cutoff = k; // Number of neighbors to keep
             int keep = std::min(cutoff, val.size());
             std::partial_sort(val.begin(), val.begin()+keep, val.end(), compareNeighbors);
             neighborhood.append((Neighbors)val.mid(0, keep));
         }
     }
  
-    // Normalize scores
-    for (int i=0; i<neighborhood.size(); i++) {
-        Neighbors &neighbors = neighborhood[i];
-        for (int j=0; j<neighbors.size(); j++) {
-            Neighbor &neighbor = neighbors[j];
-            if (neighbor.second == -std::numeric_limits<float>::infinity())
-                neighbor.second = 0;
-            else if (neighbor.second == std::numeric_limits<float>::infinity())
-                neighbor.second = 1;
-            else
-                neighbor.second = (neighbor.second - globalMin) / (globalMax - globalMin);
-        }
+    return neighborhood;
+}
+
+// generate k-NN graph from pre-computed similarity matrices 
+Neighborhood br::knnFromSimmat(const QStringList &simmats, int k)
+{
+    QList<cv::Mat> mats;
+    foreach (const QString &simmat, simmats) {
+        QScopedPointer<br::Format> format(br::Factory<br::Format>::make(simmat));
+        br::Template t = format->read();
+        mats.append(t);
+    }
+    return knnFromSimmat(mats, k);
+}
+
+TemplateList knnFromGallery(const QString & galleryName, bool inMemory, const QString & outFile, int k)
+{
+    QSharedPointer<Transform> comparison = Transform::fromComparison(Globals->algorithm);
+
+    Gallery *tempG = Gallery::make(galleryName);
+    qint64 total = tempG->totalSize();
+    delete tempG;
+    comparison->setPropertyRecursive("galleryName", galleryName+"[dropMetadata=true]");
+
+    bool multiProcess = Globals->file.getBool("multiProcess", false);
+    if (multiProcess)
+        comparison = QSharedPointer<Transform> (br::wrapTransform(comparison.data(), "ProcessWrapper"));
+
+    QScopedPointer<Transform> collect(Transform::make("CollectNN+ProgressCounter+Discard", NULL));
+    collect->setPropertyRecursive("totalProgress", total);
+    collect->setPropertyRecursive("keep", k);
+
+    QList<Transform *> tforms;
+    tforms.append(comparison.data());
+    tforms.append(collect.data());
+
+    QScopedPointer<Transform> compareCollect(br::pipeTransforms(tforms));
+
+    QSharedPointer <Transform> projector;
+    if (inMemory)
+        projector = QSharedPointer<Transform> (br::wrapTransform(compareCollect.data(), "Stream(readMode=StreamGallery, endPoint=Discard"));
+    else
+        projector = QSharedPointer<Transform> (br::wrapTransform(compareCollect.data(), "Stream(readMode=StreamGallery, endPoint=LogNN("+outFile+")+DiscardTemplates)"));
+
+    TemplateList input;
+    input.append(Template(galleryName));
+    TemplateList output;
+
+    projector->init();
+    projector->projectUpdate(input, output);
+
+    return output;
+}
+ 
+// Generate k-NN graph from a gallery, using the current algorithm for comparison.
+// Direct serialization to file system, k-NN graph is not retained in memory
+void br::knnFromGallery(const QString &galleryName, const QString &outFile, int k)
+{
+    knnFromGallery(galleryName, false, outFile, k);
+}
+
+// In-memory graph construction
+Neighborhood br::knnFromGallery(const QString &gallery, int k)
+{
+    // Nearest neighbor data current stored as template metadata, so retrieve it
+    TemplateList res = knnFromGallery(gallery, true, "", k);
+
+    Neighborhood neighborhood;
+    foreach (const Template &t, res) {
+        Neighbors neighbors = t.file.get<Neighbors>("neighbors");
+        neighbors.append(neighbors);
     }
  
     return neighborhood;
 }
  
-// Zhu et al. "A Rank-Order Distance based Clustering Algorithm for Face Tagging", CVPR 2011
-br::Clusters br::ClusterGallery(const QStringList &simmats, float aggressiveness, const QString &csv)
+Neighborhood br::loadkNN(const QString &infile)
+{
+    Neighborhood neighborhood;
+    QFile file(infile);
+    bool success = file.open(QFile::ReadOnly);
+    if (!success) qFatal("Failed to open %s for reading.", qPrintable(infile));
+    QStringList lines = QString(file.readAll()).split("\n");
+    file.close();
+    int min_idx = INT_MAX;
+    int max_idx = -1;
+    int count = 0;
+
+    foreach (const QString &line, lines) {
+        Neighbors neighbors;
+        count++;
+        if (line.trimmed().isEmpty()) {
+            neighborhood.append(neighbors);
+            continue;
+        }
+        bool off = false;
+        QStringList list = line.trimmed().split(",", QString::SkipEmptyParts);
+        foreach (const QString &item, list) {
+            QStringList parts = item.trimmed().split(":", QString::SkipEmptyParts);
+            bool intOK = true;
+            bool floatOK = true;
+            int idx = parts[0].toInt(&intOK);
+            float score = parts[1].toFloat(&floatOK);
+
+            if (idx > max_idx)
+                max_idx = idx;
+            if (idx  <min_idx)
+                min_idx = idx;
+
+            if (idx >= lines.size()) {
+                off = true;
+                continue;
+            }
+            neighbors.append(qMakePair(idx, score));
+
+
+            if (!intOK && floatOK)
+                qFatal("Failed to parse word: %s", qPrintable(item));
+        }
+        neighborhood.append(neighbors);
+    }
+    return neighborhood;
+}
+
+bool br::savekNN(const Neighborhood &neighborhood, const QString &outfile)
+{
+    QFile file(outfile);
+    bool success = file.open(QFile::WriteOnly);
+    if (!success) qFatal("Failed to open %s for writing.", qPrintable(outfile));
+
+    foreach (Neighbors neighbors, neighborhood) {
+        QString aLine;
+        if (!neighbors.empty())
+        {
+            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));
+            }
+        }
+        aLine += "\n";
+        file.write(qPrintable(aLine));
+    }
+    file.close();
+    return true;
+}
+
+
+// Rank-order clustering on a pre-computed k-NN graph
+Clusters br::ClusterGraph(Neighborhood neighborhood, float aggressiveness, const QString &csv)
 {
-    qDebug("Clustering %d simmat(s), aggressiveness %f", simmats.size(), aggressiveness);
  
-    // Read in gallery parts, keeping top neighbors of each template
-    Neighborhood neighborhood = getNeighborhood(simmats);
     const int cutoff = neighborhood.first().size();
     const float threshold = 3*cutoff/4 * aggressiveness/5;
  
@@ -239,9 +364,39 @@ br::Clusters br::ClusterGallery(const QStringList &amp;simmats, float aggressiveness
         neighborhood = newNeighborhood;
     }
  
-    // Save clusters
     if (!csv.isEmpty())
         WriteClusters(clusters, csv);
+
+    return clusters;
+}
+
+Clusters br::ClusterGraph(const QString & knnName, float aggressiveness, const QString &csv)
+{
+    Neighborhood neighbors = loadkNN(knnName);
+    return ClusterGraph(neighbors, aggressiveness, csv);
+}
+
+// Zhu et al. "A Rank-Order Distance based Clustering Algorithm for Face Tagging", CVPR 2011
+br::Clusters br::ClusterSimmat(const QList<cv::Mat> &simmats, float aggressiveness, const QString &csv)
+{
+    qDebug("Clustering %d simmat(s), aggressiveness %f", simmats.size(), aggressiveness);
+
+    // Read in gallery parts, keeping top neighbors of each template
+    Neighborhood neighborhood = knnFromSimmat(simmats);
+
+    return ClusterGraph(neighborhood, aggressiveness, csv);
+}
+
+br::Clusters br::ClusterSimmat(const QStringList &simmats, float aggressiveness, const QString &csv)
+{
+    QList<cv::Mat> mats;
+    foreach (const QString &simmat, simmats) {
+        QScopedPointer<br::Format> format(br::Factory<br::Format>::make(simmat));
+        br::Template t = format->read();
+        mats.append(t);
+    }
+
+    Clusters clusters = ClusterSimmat(mats, aggressiveness, csv);
     return clusters;
 }
  
@@ -21,15 +21,46 @@
 #include <QString>
 #include <QStringList>
 #include <QVector>
+#include <openbr/openbr_plugin.h>
+#include <openbr/plugins/openbr_internal.h>
  
 namespace br
 {
     typedef QList<int> Cluster; // List of indices into galleries
     typedef QVector<Cluster> Clusters;
  
-    Clusters ClusterGallery(const QStringList &simmats, float aggressiveness, const QString &csv);
+    // generate k-NN graph from pre-computed similarity matrices 
+    Neighborhood knnFromSimmat(const QStringList &simmats, int k = 20);
+    Neighborhood knnFromSimmat(const QList<cv::Mat> &simmats, int k = 20);
+ 
+    // Generate k-NN graph from a gallery, using the current algorithm for comparison.
+    // direct serialization to file system.
+    void  knnFromGallery(const QString &galleryName, const QString & outFile, int k = 20);
+    // in memory graph computation
+    Neighborhood knnFromGallery(const QString &gallery, int k = 20);
+
+    // Load k-NN graph from a file with the following ascii format:
+    // One line per sample, each line lists the top k neighbors for the sample as follows:
+    // index1:score1,index2:score2,...,indexk:scorek
+    Neighborhood loadkNN(const QString &fname);
+
+    // Save k-NN graph to file
+    bool savekNN(const Neighborhood &neighborhood, const QString &outfile);
+
+    // Rank-order clustering on a pre-computed k-NN graph
+    Clusters ClusterGraph(Neighborhood neighbors, float aggresssiveness, const QString &csv = "");
+    Clusters ClusterGraph(const QString & knnName, float aggressiveness, const QString &csv = "");
+
+    // Given a similarity matrix, compute the k-NN graph, then perform rank-order clustering.
+    Clusters ClusterSimmat(const QList<cv::Mat> &simmats, float aggressiveness, const QString &csv = "");
+    Clusters ClusterSimmat(const QStringList &simmats, float aggressiveness, const QString &csv = "");
+
+    // evaluate clustering results in csv, reading ground truth data from gallery input, using truth_property
+    // as the key for ground truth labels.
     void EvalClustering(const QString &csv, const QString &input, QString truth_property);
  
+    // Read/write clusters from a text format, 1 line = 1 cluster, each line contains comma separated list
+    // of assigned indices.
     Clusters ReadClusters(const QString &csv);
     void WriteClusters(const Clusters &clusters, const QString &csv);
 }
@@ -138,6 +138,13 @@ struct AlgorithmCore
  
     void load(const QString &model)
     {
+        // since we are loading an existing model, add its path to the search list for submodels
+        // assuming it is not already present.
+        QFileInfo finfo(model);
+        QString path = finfo.absolutePath();
+        if (!Globals->modelSearch.contains(path))
+            Globals->modelSearch.append(path);
+
         QtUtils::BlockCompression compressedRead;
         QFile inFile(model);
         compressedRead.setBasis(&inFile);
@@ -762,5 +769,15 @@ QSharedPointer&lt;br::Distance&gt; br::Distance::fromAlgorithm(const QString &amp;algorith
     return AlgorithmManager::getAlgorithm(algorithm)->distance;
 }
  
+class pathInitializer : public Initializer
+{
+    Q_OBJECT
+    void initialize() const
+    {
+        Globals->modelSearch.append(Globals->sdkPath + "/share/openbr/models/transforms/");
+    }
+
+};
+BR_REGISTER(Initializer, pathInitializer)
  
 #include "core.moc"
@@ -500,14 +500,15 @@ QString getAbsolutePath(const QString &amp;filename)
     return QFileInfo(filename).absoluteFilePath();
 }
  
+const int base_block = 100000000;
+
 BlockCompression::BlockCompression(QIODevice *_basis)
 {
-    blockSize = 100000000;
+    blockSize = base_block;
     setBasis(_basis);
 }
  
-BlockCompression::BlockCompression() { blockSize = 100000000; };
-
+BlockCompression::BlockCompression() { blockSize = base_block;};
  
 bool BlockCompression::open(QIODevice::OpenMode mode)
 {
@@ -521,14 +522,22 @@ bool BlockCompression::open(QIODevice::OpenMode mode)
     blockWriter.setDevice(basis);
  
     if (mode & QIODevice::WriteOnly) {
-        precompressedBlockWriter = new QBuffer;
-        precompressedBlockWriter->open(QIODevice::ReadWrite);
+        precompressedBlockWriter.open(QIODevice::WriteOnly);
     }
     else if (mode & QIODevice::ReadOnly) {
+
+        // Read an initial compressed block from the underlying QIODevice,
+        // decompress, and set up a reader on it
         QByteArray compressedBlock;
-        blockReader >> compressedBlock;
+        quint32 block_size;
+        blockReader >> block_size;
+        compressedBlock.resize(block_size);
+        int read_count = blockReader.readRawData(compressedBlock.data(), block_size);
+        if (read_count != block_size)
+            qFatal("Failed to read initial block");
  
         decompressedBlock = qUncompress(compressedBlock);
+
         decompressedBlockReader.setBuffer(&decompressedBlock);
         decompressedBlockReader.open(QIODevice::ReadOnly);
     }
@@ -538,11 +547,17 @@ bool BlockCompression::open(QIODevice::OpenMode mode)
  
 void BlockCompression::close()
 {
-    // flush output buffer
-    if ((openMode() & QIODevice::WriteOnly) && precompressedBlockWriter) {
-        QByteArray compressedBlock = qCompress(precompressedBlockWriter->buffer(), -1);
-        blockWriter << compressedBlock;
+    // flush output buffer, since we may have a partial block which hasn't been 
+    // written to disk yet.
+    if ((openMode() & QIODevice::WriteOnly) && precompressedBlockWriter.isOpen()) {
+        QByteArray compressedBlock = qCompress(precompressedBlockWriter.buffer());
+        precompressedBlockWriter.close();
+
+        quint32 bsize=  compressedBlock.size();
+        blockWriter << bsize;
+        blockWriter.writeRawData(compressedBlock.data(), compressedBlock.size());
     }
+    // close the underlying device.
     basis->close();
 }
  
@@ -557,8 +572,10 @@ void BlockCompression::setBasis(QIODevice *_basis)
 // block from basis
 qint64 BlockCompression::readData(char *data, qint64 remaining)
 {
+    qint64 initial = remaining;
     qint64 read = 0;
     while (remaining > 0) {
+        // attempt to read the target amount of data
         qint64 single_read = decompressedBlockReader.read(data, remaining);
         if (single_read == -1)
             qFatal("miss read");
@@ -567,13 +584,21 @@ qint64 BlockCompression::readData(char *data, qint64 remaining)
         read += single_read;
         data += single_read;
  
-        // need a new block
+        // need a new block if we didn't get enough bytes from the previous read
         if (remaining > 0) {
             QByteArray compressedBlock;
-            blockReader >> compressedBlock;
-            if (compressedBlock.size() == 0) {
-                return read;
-            }
+
+            // read the size of the next block
+            quint32 block_size;
+            blockReader >> block_size;
+            if (block_size == 0)
+                break;
+
+            compressedBlock.resize(block_size);
+            int actualRead = blockReader.readRawData(compressedBlock.data(), block_size);
+            if (actualRead != block_size)
+                qFatal("Bad read on nominal block size: %d, only got %d", block_size, remaining);
+
             decompressedBlock = qUncompress(compressedBlock);
  
             decompressedBlockReader.close();
@@ -581,7 +606,12 @@ qint64 BlockCompression::readData(char *data, qint64 remaining)
             decompressedBlockReader.open(QIODevice::ReadOnly);
         }
     }
-    return blockReader.atEnd() && !basis->isReadable() ? -1 : read;
+
+    bool condition = blockReader.atEnd() && !basis->isReadable() ;
+    if (condition)
+        qWarning("Returning -1 from read");
+
+    return condition ? -1 : read;
 }
  
 bool BlockCompression::isSequential() const
@@ -591,36 +621,57 @@ bool BlockCompression::isSequential() const
  
 qint64 BlockCompression::writeData(const char *data, qint64 remaining)
 {
+    const char * endPoint = data + remaining;
+    qint64 initial = remaining;
+
     qint64 written = 0;
  
     while (remaining > 0) {
         // how much more can be put in this buffer?
-        qint64 capacity = blockSize - precompressedBlockWriter->pos();
+        qint64 capacity = blockSize - precompressedBlockWriter.pos();
+        if (capacity < 0)
+            qFatal("Negative capacity!!!");
  
         // don't try to write beyond capacity 
         qint64 write_size = qMin(capacity, remaining);
  
-        qint64 singleWrite = precompressedBlockWriter->write(data, write_size);
-        // ignore the error case here, we consdier basis's failure mode the real
-        // end case
+        qint64 singleWrite = precompressedBlockWriter.write(data, write_size);
+
         if (singleWrite == -1)
-            singleWrite = 0;
+            qFatal("matrix write failure?");
  
         remaining -= singleWrite;
         data += singleWrite;
         written += singleWrite;
+        if (data > endPoint)
+            qFatal("Wrote past the end");
  
         if (remaining > 0) {
-            QByteArray compressedBlock = qCompress(precompressedBlockWriter->buffer(), -1);
+            QByteArray compressedBlock = qCompress(precompressedBlockWriter.buffer(), -1);
  
-            if (compressedBlock.size() != 0)
-                blockWriter << compressedBlock;
+            if (precompressedBlockWriter.buffer().size() != 0) {
+                quint32 block_size = compressedBlock.size();
+                blockWriter << block_size;
  
-            delete precompressedBlockWriter;
-            precompressedBlockWriter = new QBuffer;
-            precompressedBlockWriter->open(QIODevice::ReadWrite);
+                int write_count = blockWriter.writeRawData(compressedBlock.data(), block_size);
+                if (write_count != block_size)
+                    qFatal("Didn't write enough data");
+            }
+            else
+                qFatal("serialized empty compressed block (?)");
+
+            precompressedBlockWriter.close();
+            precompressedBlockWriter.open(QIODevice::WriteOnly);
         }
     }
+
+    if (written != initial)
+        qFatal("didn't write enough bytes");
+
+    bool condition = basis->isWritable();
+    if (!condition)
+        qWarning("Returning -1 from write");
+
     return basis->isWritable() ? written : -1;
 }
  
@@ -122,7 +122,7 @@ namespace QtUtils
  
         // write to a QByteArray, when max block sized is reached, compress and write
         // it to basis
-        QBuffer * precompressedBlockWriter;
+        QBuffer precompressedBlockWriter;
         QDataStream blockWriter;
         qint64 writeData(const char *data, qint64 remaining);
     };
-Subproject commit e3aa915a5cfc3ee0332f566ae4f13370007964a1
+Subproject commit cd22014f9bd446f26c501e06b1170441bf872408
@@ -59,7 +59,7 @@ void br_cat(int num_input_galleries, const char *input_galleries[], const char *
  
 void br_cluster(int num_simmats, const char *simmats[], float aggressiveness, const char *csv)
 {
-    ClusterGallery(QtUtils::toStringList(num_simmats, simmats), aggressiveness, csv);
+    ClusterSimmat(QtUtils::toStringList(num_simmats, simmats), aggressiveness, csv);
 }
  
 void br_combine_masks(int num_input_masks, const char *input_masks[], const char *output_mask, const char *method)
@@ -754,6 +754,12 @@ public:
     Q_PROPERTY(int crossValidate READ get_crossValidate WRITE set_crossValidate RESET reset_crossValidate)
     BR_PROPERTY(int, crossValidate, 0)
  
+    /*!
+     * \brief List of paths sub-models will be searched for on
+     */
+    Q_PROPERTY(QList<QString> modelSearch READ get_modelSearch WRITE set_modelSearch RESET reset_modelSearch)
+    BR_PROPERTY(QList<QString>, modelSearch, QList<QString>() )
+
     QHash<QString,QString> abbreviations; /*!< \brief Used by br::Transform::make() to expand abbreviated algorithms into their complete definitions. */
     QTime startTime; /*!< \brief Used to estimate timeRemaining(). */
  
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * 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"
-#include "openbr_internal.h"
+#include "openbr/plugins/openbr_internal.h"
 #include "openbr/core/qtutils.h"
 #include "openbr/core/eigenutils.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/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;
@@ -15,12 +15,14 @@
  * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
  
 #include <Eigen/Dense>
+#include <opencv2/imgproc/imgproc.hpp>
+#include <opencv2/highgui/highgui.hpp>
  
-#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 +654,609 @@ class SparseLDATransform : public Transform
  
 BR_REGISTER(Transform, SparseLDATransform)
  
+using namespace Eigen;
+using namespace cv;
+
 /*!
- * \ingroup distances
- * \brief L1 distance computed using eigen.
+ * \ingroup transforms
+ * \brief Projects input into a within-class minimizing subspace.
+ *
+ * Like LDA but without the explicit between-class consideration.
+ *
+ * \par Compression
+ * Projection matricies can become quite large, resulting in proportionally large model files.
+ * WCDA automatically alleviates this issue with lossy compression of the projection matrix.
+ * Each element is stored as an 8-bit integer instead of a 32-bit float, resulting in a 75% reduction in the size of the projection matrix.
+ * A non-linear (sqrt) scaling is used because element values are distributed around 0, in affect allowing for higher precision storage of the more frequently occuring values.
+ *
  * \author Josh Klontz \cite jklontz
  */
-class L1Distance : public UntrainableDistance
+class WCDATransform : public Transform
 {
     Q_OBJECT
+    Q_PROPERTY(float keep READ get_keep WRITE set_keep RESET reset_keep STORED false)
+    BR_PROPERTY(float, keep, 0.98)
+
+    VectorXf mean;
+    MatrixXf projection;
+
+    typedef Matrix<quint8, Dynamic, Dynamic> CompressedMatrix;
+    CompressedMatrix compressed;
+    float a, b;
  
-    float compare(const cv::Mat &a, const cv::Mat &b) const
+    static CompressedMatrix compress(MatrixXf src, float &a, float &b)
     {
-        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();
+        for (int i=0; i<src.rows(); i++)
+            for (int j=0; j<src.cols(); j++) {
+                float &element = src(i, j);
+                element = sqrtf(fabsf(element)) * ((element >= 0) ? 1 : -1);
+            }
+        b = src.minCoeff();
+        a = (src.maxCoeff() - b) / 255;
+        return ((src.array() - b) / a).cast<quint8>();
     }
+
+    static MatrixXf decompress(const CompressedMatrix &src, float a, float b)
+    {
+        MatrixXf dst = src.cast<float>().array() * a + b;
+        for (int i=0; i<dst.rows(); i++)
+            for (int j=0; j<dst.cols(); j++) {
+                float &element = dst(i, j);
+                element = (element * element) * ((element >= 0) ? 1 : -1);
+            }
+        return dst;
+    }
+
+    void train(const TemplateList &_templates)
+    {
+        // Relabel ensures that class values range from 0 to numClasses-1.
+        const TemplateList templates = TemplateList::relabel(_templates, "Label", false);
+        const int instances = templates.size();
+        const int dimsIn = templates.first().m().rows * templates.first().m().cols;
+
+        // Map data into Eigen
+        MatrixXf data(dimsIn, instances);
+        for (int i=0; i<instances; i++)
+            data.col(i) = Map<const VectorXf>(templates[i].m().ptr<float>(), dimsIn);
+
+        // Perform PCA dimensionality reduction
+        VectorXf pcaEvals;
+        MatrixXf pcaEvecs;
+        trainCore(data, keep, mean, pcaEvals, pcaEvecs);
+        data = pcaEvecs.transpose() * (data.colwise() - mean);
+
+        // Get ground truth
+        const QList<int> classes = File::get<int>(templates, "Label");
+        const QMap<int, int> classCounts = templates.countValues<int>("Label");
+        const int numClasses = classCounts.size();
+
+        // Compute and remove the class means
+        MatrixXf classMeans = MatrixXf::Zero(data.rows(), numClasses);
+        for (int i=0; i<instances;  i++) classMeans.col(classes[i]) += data.col(i);
+        for (int i=0; i<numClasses; i++) classMeans.col(i) /= classCounts[i];
+        for (int i=0; i<instances;  i++) data.col(i) -= classMeans.col(classes[i]);
+
+        // Compute the within-class projection
+        VectorXf wcMean, wcEvals;
+        MatrixXf wcEvecs;
+        trainCore(data, keep, wcMean, wcEvals, wcEvecs);
+
+        // This has the effect of whitening the within-class scatter.
+        // In effect, this minimizes the within-class variation energy.
+        for (int i=0; i<keep; i++)
+            wcEvecs.col(i) /= sqrt(wcEvals(i));
+
+        projection = wcEvecs.transpose() * pcaEvecs.transpose();
+
+        // Compress and restore the projection matrix
+        compressed = compress(projection, a, b);
+        projection = decompress(compressed, a, b);
+    }
+
+    static void trainCore(MatrixXf data, float keep, VectorXf &mean, VectorXf &eVals, MatrixXf &eVecs)
+    {
+        const int dimsIn = data.rows();
+        const int instances = data.cols();
+        const bool dominantEigenEstimation = (dimsIn > instances);
+
+        // Compute and remove mean
+        mean = data.rowwise().sum() / instances;
+        data.colwise() -= mean;
+
+        // Calculate and normalize covariance matrix
+        MatrixXf cov;
+        if (dominantEigenEstimation) cov = data.transpose() * data;
+        else                         cov = data * data.transpose();
+        cov /= (instances-1);
+
+        // Compute eigendecomposition, returning eigenvectors/eigenvalues in increasing order by eigenvalue.
+        SelfAdjointEigenSolver<MatrixXf> eSolver(cov);
+        VectorXf allEVals = eSolver.eigenvalues();
+        MatrixXf allEVecs = eSolver.eigenvectors();
+        if (dominantEigenEstimation)
+            allEVecs = data * allEVecs;
+
+        if (keep < 1) {
+            // Keep eigenvectors that retain a certain energy percentage.
+            const float desiredEnergy = keep * allEVals.sum();
+            float currentEnergy = 0;
+            int i = 0;
+            while ((currentEnergy < desiredEnergy) && (i < allEVals.rows())) {
+                currentEnergy += allEVals(allEVals.rows()-(i+1));
+                i++;
+            }
+            keep = i;
+        } else {
+            if (keep > allEVals.rows()) {
+                qWarning("Insufficient samples, needed at least %d but only got %d.", (int)keep, (int)allEVals.rows());
+                keep = allEVals.rows();
+            }
+        }
+
+        // Keep highest energy vectors
+        eVals = VectorXf((int)keep);
+        eVecs = MatrixXf(allEVecs.rows(), (int)keep);
+        for (int i=0; i<keep; i++) {
+            const int index = allEVals.rows()-(i+1);
+            eVals(i) = allEVals(index);
+            eVecs.col(i) = allEVecs.col(index) / allEVecs.col(index).norm();
+        }
+    }
+
+    void project(const Template &src, Template &dst) const
+    {
+        dst = Mat(1, projection.rows(), CV_32FC1);
+        Map<const VectorXf> inMap(src.m().ptr<float>(), src.m().rows * src.m().cols);
+        Map<VectorXf> outMap(dst.m().ptr<float>(), projection.rows());
+        outMap = projection * (inMap - mean);
+    }
+
+    void store(QDataStream &stream) const
+    {
+        stream << mean << compressed << a << b;
+    }
+
+    void load(QDataStream &stream)
+    {
+        stream >> mean >> compressed >> a >> b;
+        projection = decompress(compressed, a, b);
+    }
+};
+
+BR_REGISTER(Transform, WCDATransform)
+
+// For use in BBLDAAlignmentTransform
+// A single decision boundary with gaussian distributed responses
+struct DecisionBoundary
+{
+    VectorXf function;
+    float positiveMean, negativeMean, positiveSD, negativeSD;
 };
  
-BR_REGISTER(Distance, L1Distance)
+QDataStream &operator<<(QDataStream &stream, const DecisionBoundary &db)
+{
+    return stream << db.function << db.positiveMean << db.negativeMean << db.positiveSD << db.negativeSD;
+}
+
+QDataStream &operator>>(QDataStream &stream, DecisionBoundary &db)
+{
+    return stream >> db.function >> db.positiveMean >> db.negativeMean >> db.positiveSD >> db.negativeSD;
+}
  
 /*!
- * \ingroup distances
- * \brief L2 distance computed using eigen.
- * \author Josh Klontz \cite jklontz
+ * \ingroup transforms
+ * \brief Boosted Binary LDA classifier for local alignment.
  */
-class L2Distance : public UntrainableDistance
+class BBLDAAlignmentTransform : public MetaTransform
 {
     Q_OBJECT
+    Q_PROPERTY(QList<int> anchors READ get_anchors WRITE set_anchors RESET reset_anchors STORED false) // A list of two indicies to provide initial rotation and scaling of training data
+    Q_PROPERTY(QString detectionKey READ get_detectionKey WRITE set_detectionKey RESET reset_detectionKey STORED false) // Metadata key containing the detection bounding box
+    Q_PROPERTY(int iad READ get_iad WRITE set_iad RESET reset_iad STORED false) // Inter-anchor distance in pixels
+    Q_PROPERTY(float radius READ get_radius WRITE set_radius RESET reset_radius STORED false) // Kernel size as a fraction of IAD
+    Q_PROPERTY(int resolution READ get_resolution WRITE set_resolution RESET reset_resolution STORED false) // Project resolution for sampling rotation and scale
+    BR_PROPERTY(QList<int>, anchors, QList<int>())
+    BR_PROPERTY(QString, detectionKey, "FrontalFace")
+    BR_PROPERTY(int, iad, 16)
+    BR_PROPERTY(float, radius, 2)
+    BR_PROPERTY(int, resolution, 20)
+
+    typedef Matrix<quint8, Dynamic, Dynamic> MatrixX8U;
+
+    struct RegistrationMatrix
+    {
+        Mat src;
+        Point2f center;
+        double angle, scale;
+
+        RegistrationMatrix(const Mat &src = Mat(), const Point2f &center = Point2f(), double angle = 0, double scale = 1)
+            : src(src)
+            , center(center)
+            , angle(angle)
+            , scale(scale)
+        {}
+
+        Mat calculateRotationMatrix2D(int size) const
+        {
+            Mat rotationMatrix2D = getRotationMatrix2D(center, angle, scale);
+            rotationMatrix2D.at<double>(0, 2) -= (center.x - size / 2.0); // Adjust the center to the middle of the dst image
+            rotationMatrix2D.at<double>(1, 2) -= (center.y - size / 2.0);
+            return rotationMatrix2D;
+        }
+
+        Point2f invert(double x, double y, int size) const
+        {
+            Mat m;
+            invertAffineTransform(calculateRotationMatrix2D(size), m);
+
+            Mat src(1, 1, CV_64FC2);
+            src.ptr<double>()[0] = y; // According to the docs these should be specified in the opposite order ...
+            src.ptr<double>()[1] = x; // ... however running it seems to suggest this is the correct way
+
+            Mat dst;
+            transform(src, dst, m);
+            return Point2f(dst.ptr<double>()[0], dst.ptr<double>()[1]);
+        }
+
+        MatrixX8U warp(int size) const
+        {
+            const Mat rotationMatrix2D = calculateRotationMatrix2D(size);
+            Mat dst;
+            warpAffine(src, dst, rotationMatrix2D, Size(size, size), INTER_LINEAR, BORDER_REFLECT);
+            return Map<MatrixX8U>(dst.ptr<quint8>(), size, size);
+        }
+    };
+
+    float rotationMax, scaleMin, scaleMax, xTranslationMax, yTranslationMin, yTranslationMax;
+    QList<DecisionBoundary> decisionBoundaries;
+
+    static void show(const char *name, const MatrixX8U &data)
+    {
+        const Mat mat(data.rows(), data.cols(), CV_8UC1, (void*) data.data());
+        imshow(name, mat);
+        waitKey(-1);
+    }
+
+    static void show(const char *name, MatrixXf data)
+    {
+        data.array() -= data.minCoeff();
+        data.array() *= (255 / data.maxCoeff());
+        show(name, MatrixX8U(data.cast<quint8>()));
+    }
+
+    static void show(const char *name, VectorXf data)
+    {
+        MatrixXf resized = data;
+        const int size = int(sqrtf(float(data.rows())));
+        resized.resize(size, size);
+        show(name, resized);
+    }
+
+    static MatrixXf getSample(const MatrixXf &registered, int j, int k, int kernelSize)
+    {
+        MatrixXf sample(registered.block(j, k, kernelSize, kernelSize));
+        const float norm = sample.norm();
+        if (norm > 0)
+            sample /= norm;
+        return sample;
+    }
+
+    static MatrixXf getSample(const QList<MatrixXf> &registered, int i, int j, int k, int kernelSize)
+    {
+        return getSample(registered[i], j, k, kernelSize);
+    }
+
+    static float IADError(const MatrixXf &responses, const MatrixXf &mask)
+    {
+        const int responseSize = sqrtf(responses.cols());
+        int numImages = 0;
+        float totalError = 0;
+        for (int i=0; i<responses.rows(); i++) {
+            float maxResponse = -std::numeric_limits<float>::max();
+            int maxX = -1;
+            int maxY = -1;
+            for (int j=0; j<responseSize; j++)
+                for (int k=0; k<responseSize; k++)
+                    if (mask(i, j*responseSize + k) > 0) {
+                        const float response = responses(i, j*responseSize+k);
+                        if (response > maxResponse) {
+                            maxResponse = response;
+                            maxY = j;
+                            maxX = k;
+                        }
+                    }
+            totalError += sqrtf(powf(maxX - responseSize/2, 2) + powf(maxY - responseSize/2, 2)) / responseSize;
+            numImages++;
+        }
+        return totalError / numImages;
+    }
+
+    static bool isPositive(int j, int k, int responseSize)
+    {
+        return (abs(j - responseSize/2) <= 0) && (abs(k - responseSize/2) <= 0);
+    }
  
-    float compare(const cv::Mat &a, const cv::Mat &b) const
+    static MatrixXf /* output responses */ computeBoundaryRecursive(const QList<MatrixXf> &registered, int kernelSize, const MatrixXf &prior /* input responses */, QList<DecisionBoundary> &boundaries)
+    {
+        const int numImages = registered.size();
+        const int responseSize = registered.first().cols() - kernelSize + 1;
+        int positiveSamples = 0;
+        int negativeSamples = 0;
+
+        // Compute weights, a weight of zero operates as a mask
+        MatrixXf weights(numImages, responseSize*responseSize);
+        float totalPositiveWeight = 0, totalNegativeWeight = 0;
+        for (int i=0; i<numImages; i++)
+            for (int j=0; j<responseSize; j++)
+                for (int k=0; k<responseSize; k++) {
+                    const float probability = prior(i, j*responseSize+k);
+                    const bool positive = isPositive(j, k, responseSize);
+                    // Weight by probability ...
+                    float weight = positive ? (2 - probability) // Subtracting from a number greater than 1 helps ensure that we don't overfit outliers
+                                            : probability;
+                    // ... and by distance
+                    const float distance = sqrtf(powf(j - responseSize/2, 2) + powf(k - responseSize/2, 2));
+                    if (positive) weight *= 1 / (distance + 1);
+                    else          weight *= distance;
+                    weights(i, j*responseSize+k) = weight;
+                    if (weight > 0) {
+                        if (positive) { totalPositiveWeight += weight; positiveSamples++; }
+                        else          { totalNegativeWeight += weight; negativeSamples++; }
+                    }
+                }
+
+        // Normalize weights to preserve class sample ratio
+        const float positiveWeightAdjustment = positiveSamples / totalPositiveWeight;
+        const float negativeWeightAdjustment = negativeSamples / totalNegativeWeight;
+        for (int i=0; i<numImages; i++)
+            for (int j=0; j<responseSize; j++)
+                for (int k=0; k<responseSize; k++)
+                    weights(i, j*responseSize+k) *= isPositive(j, k, responseSize) ? positiveWeightAdjustment : negativeWeightAdjustment;
+
+        // Compute weighted class means
+        MatrixXf positiveMean = MatrixXf::Zero(kernelSize, kernelSize);
+        MatrixXf negativeMean = MatrixXf::Zero(kernelSize, kernelSize);
+        for (int i=0; i<numImages; i++)
+            for (int j=0; j<responseSize; j++)
+                for (int k=0; k<responseSize; k++) {
+                    const MatrixXf sample(getSample(registered, i, j, k, kernelSize));
+                    const float weight = weights(i, j*responseSize+k);
+                    if (weight > 0) {
+                        if (isPositive(j, k, responseSize)) positiveMean += sample * weight;
+                        else                                negativeMean += sample * weight;
+                    }
+                }
+        positiveMean /= positiveSamples;
+        negativeMean /= negativeSamples;
+
+        // Compute weighted scatter matrix and decision boundary
+        MatrixXf scatter = MatrixXf::Zero(kernelSize*kernelSize, kernelSize*kernelSize);
+        for (int i=0; i<numImages; i++)
+            for (int j=0; j<responseSize; j++)
+                for (int k=0; k<responseSize; k++) {
+                    const float weight = weights(i, j*responseSize+k);
+                    if (weight > 0) {
+                        const MatrixXf &centeredSampleMatrix = getSample(registered, i, j, k, kernelSize) - (isPositive(j, k, responseSize) ? positiveMean : negativeMean);
+                        const Map<const VectorXf> centeredSample(centeredSampleMatrix.data(), kernelSize*kernelSize);
+                        scatter.noalias() += centeredSample * centeredSample.transpose() * weights(i, j*responseSize+k);
+                    }
+                }
+        scatter /= (positiveSamples + negativeSamples); // normalize for numerical stability
+        DecisionBoundary db;
+        db.function = scatter.inverse() * VectorXf(positiveMean - negativeMean); // fisher linear discriminant
+
+        // Compute response values to decision boundary
+        MatrixXf posterior(numImages, responseSize*responseSize);
+        for (int i=0; i<numImages; i++)
+            for (int j=0; j<responseSize; j++)
+                for (int k=0; k<responseSize; k++)
+                    if (weights(i, j*responseSize + k) > 0) {
+                        const MatrixXf sample(getSample(registered, i, j, k, kernelSize));
+                        posterior(i, j*responseSize + k) = db.function.transpose() * Map<const VectorXf>(sample.data(), kernelSize*kernelSize);
+                    }
+
+        // Compute class response means
+        db.positiveMean = 0;
+        db.negativeMean = 0;
+        for (int i=0; i<numImages; i++)
+            for (int j=0; j<responseSize; j++)
+                for (int k=0; k<responseSize; k++)
+                    if (weights(i, j*responseSize + k) > 0) {
+                        const float response = posterior(i, j*responseSize + k);
+                        if (isPositive(j, k, responseSize)) db.positiveMean += response;
+                        else                                db.negativeMean += response;
+                    }
+        db.positiveMean /= positiveSamples;
+        db.negativeMean /= negativeSamples;
+
+        // Compute class response standard deviations
+        db.positiveSD = 0;
+        db.negativeSD = 0;
+        for (int i=0; i<numImages; i++)
+            for (int j=0; j<responseSize; j++)
+                for (int k=0; k<responseSize; k++)
+                    if (weights(i, j*responseSize + k) > 0) {
+                        const float response = posterior(i, j*responseSize + k);
+                        if (isPositive(j, k, responseSize)) db.positiveSD += powf(response-db.positiveMean, 2.f);
+                        else                                db.negativeSD += powf(response-db.negativeMean, 2.f);
+                    }
+        db.positiveSD = sqrtf(db.positiveSD / positiveSamples);
+        db.negativeSD = sqrtf(db.negativeSD / negativeSamples);
+
+        // Normalize responses and propogating prior probabilities
+        for (int i=0; i<numImages; i++)
+            for (int j=0; j<responseSize; j++)
+                for (int k=0; k<responseSize; k++) {
+                    float &response = posterior(i, j*responseSize + k);
+                    if (weights(i, j*responseSize + k) > 0) {
+                        const float positiveDensity = 1 / (sqrtf(2 * CV_PI) * db.positiveSD) * expf(-0.5 * powf((response - db.positiveMean) / db.positiveSD, 2.f));
+                        const float negativeDensity = 1 / (sqrtf(2 * CV_PI) * db.negativeSD) * expf(-0.5 * powf((response - db.negativeMean) / db.negativeSD, 2.f));
+                        response = prior(i, j*responseSize+k) * positiveDensity / (positiveDensity + negativeDensity);
+                    } else {
+                        response = 0;
+                    }
+                }
+        const float previousMeanError = IADError(prior, weights);
+        const float meanError = IADError(posterior, weights);
+        qDebug() << "Samples positive & negative:" << positiveSamples << negativeSamples;
+        qDebug() << "Positive mean & stddev:" << db.positiveMean << db.positiveSD;
+        qDebug() << "Negative mean & stddev:" << db.negativeMean << db.negativeSD;
+        qDebug() << "Mean error before & after:" << previousMeanError << meanError;
+
+        if (meanError < previousMeanError) {
+            boundaries.append(db);
+            return computeBoundaryRecursive(registered, kernelSize, posterior, boundaries);
+        } else {
+            return prior;
+        }
+    }
+
+    void train(const TemplateList &data)
+    {
+        QList<RegistrationMatrix> registrationMatricies;
+        {
+            if (Globals->verbose)
+                qDebug("Preprocessing training data...");
+
+            rotationMax     = -std::numeric_limits<float>::max();
+            scaleMin        =  std::numeric_limits<float>::max();
+            scaleMax        = -std::numeric_limits<float>::max();
+            xTranslationMax = -std::numeric_limits<float>::max();
+            yTranslationMin =  std::numeric_limits<float>::max();
+            yTranslationMax = -std::numeric_limits<float>::max();
+
+            foreach (const Template &t, data) {
+                const QRectF detection = t.file.get<QRectF>(detectionKey);
+                const QList<QPointF> points = t.file.points();
+                const float length = sqrt(pow(points[anchors[1]].x() - points[anchors[0]].x(), 2) +
+                                          pow(points[anchors[1]].y() - points[anchors[0]].y(), 2));
+                const float rotation = atan2(points[anchors[1]].y() - points[anchors[0]].y(),
+                                             points[anchors[1]].x() - points[anchors[0]].x()) * 180 / CV_PI;
+                const float scale = length / detection.width();
+                const float xCenter = (points[anchors[0]].x() + points[anchors[1]].x()) / 2;
+                const float yCenter = (points[anchors[0]].y() + points[anchors[1]].y()) / 2;
+                const float xTranslation = (xCenter - detection.x() - detection.width() /2) / detection.width();
+                const float yTranslation = (yCenter - detection.y() - detection.height()/2) / detection.width();
+
+                if (detection.contains(xCenter, yCenter) /* Sometimes the face detector gets the wrong face */) {
+                    rotationMax = max(rotationMax, fabsf(rotation));
+                    scaleMin    = min(scaleMin, scale);
+                    scaleMax    = max(scaleMax, scale);
+                    xTranslationMax = max(xTranslationMax, fabsf(xTranslation));
+                    yTranslationMin = min(yTranslationMin, yTranslation);
+                    yTranslationMax = max(yTranslationMax, yTranslation);
+                }
+
+                registrationMatricies.append(RegistrationMatrix(t, Point2f(xCenter, yCenter), rotation, iad / length));
+            }
+        }
+
+        if (Globals->verbose)
+            qDebug("Learning affine model ...");
+
+        // Construct the registered training data for the landmark
+        const int regionSize = 2 * iad * radius; // Train on a search size that is twice to the kernel size
+        QList<MatrixXf> registered;
+        foreach (const RegistrationMatrix &registrationMatrix, registrationMatricies)
+            registered.append(registrationMatrix.warp(regionSize).cast<float>());
+
+        // Boosted LDA
+        const int numImages = registered.size();
+        const int kernelSize = iad * radius;
+        const int responseSize = regionSize - kernelSize + 1;
+        const MatrixXf prior = MatrixXf::Ones(numImages, responseSize*responseSize);
+        const MatrixXf responses = computeBoundaryRecursive(registered, kernelSize, prior, decisionBoundaries);
+
+//        for (int i=0; i<numImages; i++) {
+//            float maxResponse = -std::numeric_limits<float>::max();
+//            int maxX = -1;
+//            int maxY = -1;
+//            for (int j=0; j<responseSize; j++)
+//                for (int k=0; k<responseSize; k++) {
+//                    const float response = responses(i, j*responseSize+k);
+//                    if (response > maxResponse) {
+//                        maxResponse = response;
+//                        maxY = j;
+//                        maxX = k;
+//                    }
+//                }
+
+//            MatrixXf draw = registered[i];
+//            const int r = 3;
+//            maxX += kernelSize / 2;
+//            maxY += kernelSize / 2;
+//            for (int i=-r; i<=r; i++)
+//                draw(regionSize/2 + i, regionSize/2) *= 2;
+//            for (int i=-r; i<=r; i++)
+//                draw(regionSize/2, regionSize/2 + i) *= 2;
+//            for (int i=-r; i<=r; i++)
+//                draw(maxX + i, maxY) /= 2;
+//            for (int i=-r; i<=r; i++)
+//                draw(maxX, maxY + i) /= 2;
+//            show("draw", draw);
+//            show("responses", VectorXf(responses.row(i)));
+//        }
+
+        if (Globals->verbose)
+            qDebug("Learned %d function(s) with error %g", decisionBoundaries.size(), IADError(responses, prior));
+    }
+
+    void project(const Template &src, Template &dst) const
+    {
+        dst = src;
+        const QRectF detection = src.file.get<QRectF>(detectionKey);
+        RegistrationMatrix registrationMatrix(src, OpenCVUtils::toPoint(detection.center()));
+
+        const int regionSize = iad * (1 + radius);
+        const int kernelSize = iad * radius;
+        const int responseSize = regionSize - kernelSize + 1;
+        const float rotationStep = (2 * rotationMax) / (resolution - 1);
+        const float scaleStep = (scaleMax - scaleMin) / (resolution - 1);
+
+        float bestResponse = -std::numeric_limits<float>::max(), bestRotation = 0, bestScale = 0;
+        int bestX = 0, bestY =0;
+
+        for (float rotation = -rotationMax; rotation <= rotationMax; rotation += rotationStep) {
+            registrationMatrix.angle = rotation;
+            for (float scale = scaleMin; scale <= scaleMax; scale += scaleStep) {
+                registrationMatrix.scale = iad / (scale * detection.width());
+                const MatrixXf registered = registrationMatrix.warp(regionSize).cast<float>();
+
+                for (int j=0; j<responseSize; j++)
+                    for (int k=0; k<responseSize; k++) {
+                        const MatrixXf sample = getSample(registered, j, k, kernelSize);
+                        float posterior = 1;
+                        foreach (const DecisionBoundary &db, decisionBoundaries) {
+                            const float response = db.function.transpose() * Map<const VectorXf>(sample.data(), kernelSize*kernelSize);
+                            const float positiveDensity = 1 / (sqrtf(2 * CV_PI) * db.positiveSD) * expf(-0.5 * powf((response - db.positiveMean) / db.positiveSD, 2.f));
+                            const float negativeDensity = 1 / (sqrtf(2 * CV_PI) * db.negativeSD) * expf(-0.5 * powf((response - db.negativeMean) / db.negativeSD, 2.f));
+                            posterior *= positiveDensity / (positiveDensity + negativeDensity);
+                        }
+                        if (posterior > bestResponse) {
+                            bestResponse = posterior;
+                            bestX = k + kernelSize/2;
+                            bestY = j + kernelSize/2;
+                            bestRotation = rotation;
+                            bestScale = scale;
+                        }
+                    }
+            }
+        }
+    }
+
+    void store(QDataStream &stream) const
+    {
+        stream << rotationMax << scaleMin << scaleMax << xTranslationMax << yTranslationMin << yTranslationMax << decisionBoundaries;
+    }
+
+    void load(QDataStream &stream)
     {
-        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();
+        stream >> rotationMax >> scaleMin >> scaleMax >> xTranslationMax >> yTranslationMin >> yTranslationMax >> decisionBoundaries;
     }
 };
  
-BR_REGISTER(Distance, L2Distance)
+BR_REGISTER(Transform, BBLDAAlignmentTransform)
  
 } // 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"
@@ -20,8 +20,8 @@
 #include <Bmp.h>
 #include <NGrayscaleImage.h>
  
-#include "core/resource.h"
-#include "core/opencvutils.h"
+#include <openbr/core/resource.h>
+#include <openbr/core/opencvutils.h>
  
 using namespace cv;
 using namespace br;
@@ -457,4 +457,4 @@ class NT4Compare : public Distance
  
 BR_REGISTER(Distance, NT4Compare)
  
-#include "nt4.moc"
+#include "classification/nt4.moc"
@@ -6,7 +6,7 @@
 #include <pittpatt_raw_image_io.h>
 #include <pittpatt_license.h>
 #include <openbr/openbr_plugin.h>
-#include "openbr_internal.h"
+#include "openbr/plugins/openbr_internal.h"
 #include "openbr/core/resource.h"
  
 #define TRY(CC)                                                                                               \
@@ -11,7 +11,7 @@
 #include <pittpatt_raw_image_io.h>
 #include <pittpatt_sdk.h>
 #include <pittpatt_license.h>
-#include "openbr_internal.h"
+#include "openbr/plugins/openbr_internal.h"
 #include "openbr/core/resource.h"
  
 #define TRY(CC)                                                                                               \
@@ -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"
@@ -5,7 +5,7 @@ if(${BR_WITH_DLIB})
  
   add_definitions(-DDLIB_NO_GUI_SUPPORT)
  
-  set(BR_THIRDPARTY_SRC ${BR_THIRDPARTY_SRC} plugins/dlib.cpp)
+  set(BR_THIRDPARTY_SRC ${BR_THIRDPARTY_SRC} plugins/classification/dlib.cpp)
   set(BR_THIRDPARTY_SRC ${BR_THIRDPARTY_SRC} ${DLib_DIR}/dlib/all/source.cpp)
  
   #install(DIRECTORY ${DLib_DIR}/models/ DESTINATION share/openbr/models/dlib)
+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()
+set(BR_WITH_LIBAV OFF CACHE BOOL "Build with LibAV")
+
+if(${BR_WITH_LIBAV})
+  find_package(LibAV REQUIRED)
+  include_directories(${LIBAV_INCLUDE_DIR})
+  set(BR_THIRDPARTY_LIBS ${BR_THIRDPARTY_LIBS} ${LIBAV_LIBRARIES})
+  
+  foreach(LIBAV_LIB ${LIBAV_LIBRARIES})
+    install(FILES ${LIBAV_LIB} DESTINATION lib)
+  endforeach()
+else()
+  set(BR_EXCLUDED_PLUGINS ${BR_EXCLUDED_PLUGINS} plugins/gallery/keyframes.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/url.cpp)
+  set(BR_EXCLUDED_PLUGINS ${BR_EXCLUDED_PLUGINS} plugins/format/post.cpp)
+  set(BR_EXCLUDED_PLUGINS ${BR_EXCLUDED_PLUGINS} plugins/gallery/post.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()
@@ -2,14 +2,9 @@ set(BR_WITH_STASM4 ON CACHE BOOL &quot;Build with Stasm&quot;)
  
 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)
-    install(DIRECTORY ${Stasm_DIR}/build/ DESTINATION bin)
-  else()
-    install(DIRECTORY ${Stasm_DIR}/build/ DESTINATION lib)
-  endif()
-
+  set(BR_THIRDPARTY_SRC ${BR_THIRDPARTY_SRC} ${Stasm_SRC})
   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
 {
@@ -43,7 +43,7 @@ class AlgorithmsInitializer : public Initializer
         Globals->abbreviations.insert("OpenBR", "FaceRecognition");
         Globals->abbreviations.insert("GenderEstimation", "GenderClassification");
         Globals->abbreviations.insert("AgeEstimation", "AgeRegression");
-        Globals->abbreviations.insert("FaceRecognition2", "{PP5Register+Affine(128,128,0.25,0.35)+Cvt(Gray)}+(Gradient+Bin(0,360,9,true))/(Blur(1)+Gamma(0.2)+DoG(1,2)+ContrastEq(0.1,10)+LBP(1,2,true)+Bin(0,10,10,true))+Merge+Integral+RecursiveIntegralSampler(4,2,8,LDA(.98)+Normalize(L1))+Cat+PCA(768)+Normalize(L1)+Quantize:UCharL1");
+        Globals->abbreviations.insert("FaceRecognition2", "{PP5Register+Affine(128,128,0.25,0.35)+Cvt(Gray)}+(Gradient+HistBin(0,360,9,true))/(Blur(1)+Gamma(0.2)+DoG(1,2)+ContrastEq(0.1,10)+LBP(1,2,true)+HistBin(0,10,10,true))+Merge+Integral+RecursiveIntegralSampler(4,2,8,LDA(.98)+Normalize(L1))+Cat+PCA(768)+Normalize(L1)+Quantize:UCharL1");
         Globals->abbreviations.insert("CropFace", "Open+Cvt(Gray)+Cascade(FrontalFace)+ASEFEyes+Affine(128,128,0.25,0.35)");
         Globals->abbreviations.insert("4SF", "Open+Cvt(Gray)+Cascade(FrontalFace)+ASEFEyes+Affine(128,128,0.33,0.45)+(Grid(10,10)+SIFTDescriptor(12)+ByRow)/(Blur(1.1)+Gamma(0.2)+DoG(1,2)+ContrastEq(0.1,10)+LBP(1,2)+RectRegions(8,8,6,6)+Hist(59))+PCA(0.95)+Cat+Normalize(L2)+Dup(12)+RndSubspace(0.05,1)+LDA(0.98)+Cat+PCA(0.95)+Normalize(L1)+Quantize:NegativeLogPlusOne(ByteL1)");
  
@@ -55,9 +55,9 @@ class AlgorithmsInitializer : public Initializer
         Globals->abbreviations.insert("ShowOpticalFlowMagnitude", "AggregateFrames(2)+OpticalFlow+Normalize(Range,false,0,255)+Cvt(Color)+Draw+FPSLimit(30)+Show(false)+Discard");
         Globals->abbreviations.insert("ShowMotionSegmentation", "DropFrames(5)+AggregateFrames(2)+OpticalFlow+CvtUChar+WatershedSegmentation+DrawSegmentation+Draw+FPSLimit(30)+Show(false)+Discard");
  
-        Globals->abbreviations.insert("HOGVideo", "Stream(DropFrames(5)+Cvt(Gray)+Grid(5,5)+ROIFromPts(32,24)+Expand+Resize(32,32)+Gradient+RectRegions+Bin(0,360,8)+Hist(8)+Cat)+Contract+CatRows+KMeans(500)+Hist(500)+SVM");
-        Globals->abbreviations.insert("HOFVideo", "Stream(DropFrames(5)+Grid(5,5)+AggregateFrames(2)+OpticalFlow+ROIFromPts(32,24)+Expand+Resize(32,32)+Gradient+RectRegions+Bin(0,360,8)+Hist(8)+Cat)+Contract+CatRows+KMeans(500)+Hist(500)");
-        Globals->abbreviations.insert("HOGHOFVideo", "Stream(DropFrames(5)+Grid(5,5)+AggregateFrames(2)+(OpticalFlow+ROIFromPts(32,24)+Expand+Resize(32,32)+Gradient+RectRegions+Bin(0,360,8)+Hist(8)+Cat+Contract)/(First+Cvt(Gray)+ROIFromPts(32,24)+Expand+Resize(32,32)+Gradient+RectRegions+Bin(0,360,8)+Hist(8)+Cat+Contract)+CatCols)+Contract+CatRows+KMeans(500)+Hist(500)+SVM");
+        Globals->abbreviations.insert("HOGVideo", "Stream(DropFrames(5)+Cvt(Gray)+Grid(5,5)+ROIFromPts(32,24)+Expand+Resize(32,32)+Gradient+RectRegions+HistBin(0,360,8)+Hist(8)+Cat)+Contract+CatRows+KMeans(500)+Hist(500)+SVM");
+        Globals->abbreviations.insert("HOFVideo", "Stream(DropFrames(5)+Grid(5,5)+AggregateFrames(2)+OpticalFlow+ROIFromPts(32,24)+Expand+Resize(32,32)+Gradient+RectRegions+HistBin(0,360,8)+Hist(8)+Cat)+Contract+CatRows+KMeans(500)+Hist(500)");
+        Globals->abbreviations.insert("HOGHOFVideo", "Stream(DropFrames(5)+Grid(5,5)+AggregateFrames(2)+(OpticalFlow+ROIFromPts(32,24)+Expand+Resize(32,32)+Gradient+RectRegions+HistBin(0,360,8)+Hist(8)+Cat+Contract)/(First+Cvt(Gray)+ROIFromPts(32,24)+Expand+Resize(32,32)+Gradient+RectRegions+HistBin(0,360,8)+Hist(8)+Cat+Contract)+CatCols)+Contract+CatRows+KMeans(500)+Hist(500)+SVM");
  
         // Generic Image Processing
         Globals->abbreviations.insert("SIFT", "Open+KeyPointDetector(SIFT)+KeyPointDescriptor(SIFT):KeyPointMatcher(BruteForce)");
@@ -66,7 +66,7 @@ class AlgorithmsInitializer : public Initializer
         Globals->abbreviations.insert("SmallSURF", "Open+LimitSize(512)+KeyPointDetector(SURF)+KeyPointDescriptor(SURF):KeyPointMatcher(BruteForce)");
         Globals->abbreviations.insert("ColorHist", "Open+LimitSize(512)+Expand+EnsureChannels(3)+SplitChannels+Hist(256,0,8)+Cat+Normalize(L1):L2");
         Globals->abbreviations.insert("ImageSimilarity", "Open+EnsureChannels(3)+Resize(256,256)+SplitChannels+RectRegions(64,64,64,64)+Hist(256,0,8)+Cat:NegativeLogPlusOne(L2)");
-        Globals->abbreviations.insert("ImageClassification", "Open+CropSquare+LimitSize(256)+Cvt(Gray)+Gradient+Bin(0,360,9,true)+Merge+Integral+RecursiveIntegralSampler(4,2,8,Singleton(KMeans(256)))+Cat+CvtFloat+Hist(256)+KNN(5,Dist(L1),false,5)+Rename(KNN,Subject)");
+        Globals->abbreviations.insert("ImageClassification", "Open+CropSquare+LimitSize(256)+Cvt(Gray)+Gradient+HistBin(0,360,9,true)+Merge+Integral+RecursiveIntegralSampler(4,2,8,Singleton(KMeans(256)))+Cat+CvtFloat+Hist(256)+KNN(5,Dist(L1),false,5)+Rename(KNN,Subject)");
         Globals->abbreviations.insert("TanTriggs", "Blur(1.1)+Gamma(0.2)+DoG(1,2)+ContrastEq(0.1,10)");
  
         // Hash
@@ -89,7 +89,7 @@ class AlgorithmsInitializer : public Initializer
         // Transforms
         Globals->abbreviations.insert("FaceDetection", "Open+Cvt(Gray)+Cascade(FrontalFace)");
         Globals->abbreviations.insert("DenseLBP", "(Blur(1.1)+Gamma(0.2)+DoG(1,2)+ContrastEq(0.1,10)+LBP(1,2)+RectRegions(8,8,6,6)+Hist(59))");
-        Globals->abbreviations.insert("DenseHOG", "Gradient+RectRegions(8,8,6,6)+Bin(0,360,8)+Hist(8)");
+        Globals->abbreviations.insert("DenseHOG", "Gradient+RectRegions(8,8,6,6)+HistBin(0,360,8)+Hist(8)");
         Globals->abbreviations.insert("DenseSIFT", "(Grid(10,10)+SIFTDescriptor(12)+ByRow)");
         Globals->abbreviations.insert("DenseSIFT2", "(Grid(5,5)+SIFTDescriptor(12)+ByRow)");
         Globals->abbreviations.insert("FaceRecognitionRegistration", "ASEFEyes+Affine(88,88,0.25,0.35)");
@@ -108,4 +108,4 @@ BR_REGISTER(Initializer, AlgorithmsInitializer)
  
 } // namespace br
  
-#include "algorithms.moc"
+#include "core/algorithms.moc"
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * Copyright 2015 Noblis                                                     *
+ *                                                                           *
+ * 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/opencv.hpp>
+#include "openbr/plugins/openbr_internal.h"
+#include "openbr/core/qtutils.h"
+#include "openbr/core/opencvutils.h"
+#include "openbr/core/eigenutils.h"
+#include "openbr/core/common.h"
+#include <QString>
+#include <Eigen/SVD>
+#include <Eigen/Dense>
+
+using namespace std;
+using namespace cv;
+using namespace Eigen;
+
+namespace br
+{
+
+/*!
+ * \ingroup transforms
+ * \brief Improved procrustes alignment of points, to include a post processing scaling of points
+ * to faciliate subsequent texture mapping.
+ * \author Brendan Klare \cite bklare
+ * \param width Width of output coordinate space (before padding)
+ * \param padding Amount of padding around the coordinate space
+ * \param useFirst whether or not to use the first instance as the reference object
+ */
+class ProcrustesAlignTransform : public Transform
+{
+    Q_OBJECT
+
+    Q_PROPERTY(float width READ get_width WRITE set_width RESET reset_width STORED false)
+    Q_PROPERTY(float padding READ get_padding WRITE set_padding RESET reset_padding STORED false)
+    Q_PROPERTY(bool useFirst READ get_useFirst WRITE set_useFirst RESET reset_useFirst STORED false)
+    BR_PROPERTY(float, width, 80)
+    BR_PROPERTY(float, padding, 8)
+    BR_PROPERTY(bool, useFirst, false)
+
+
+    Eigen::MatrixXf referenceShape;
+    float minX;
+    float minY;
+    float maxX;
+    float maxY;
+    float aspectRatio;
+
+    void init() {
+        aspectRatio = 0;
+    }
+
+    static MatrixXf getRotation(MatrixXf ref, MatrixXf sample) {
+        MatrixXf R = sample.transpose() * ref;
+        JacobiSVD<MatrixXf> svd(R, ComputeFullU | ComputeFullV);
+        R = svd.matrixU() * svd.matrixV().transpose();
+        return R;
+    }
+
+    //Converts x y points in a single vector to two column matrix
+    static MatrixXf vectorToMatrix(MatrixXf vector) {
+        int n = vector.rows();
+        MatrixXf matrix(n / 2, 2);
+        for (int i = 0; i < n / 2; i++) {
+            for (int j = 0; j < 2; j++) {
+                matrix(i, j) = vector(i * 2 + j);
+            }
+        }
+        return matrix;
+    }
+
+    static MatrixXf matrixToVector(MatrixXf matrix) {
+        int n2 = matrix.rows();
+        MatrixXf vector(n2 * 2, 1);
+        for (int i = 0; i < n2; i++) {
+            for (int j = 0; j < 2; j++) {
+                vector(i * 2 + j) = matrix(i, j);
+            }
+        }
+        return vector;
+    }
+
+    void train(const TemplateList &data)
+    {
+        MatrixXf points(data[0].file.points().size() * 2, data.size());
+
+        // Normalize all sets of points
+        int skip = 0;
+        for (int j = 0; j < data.size(); j++) {
+            QList<QPointF> imagePoints = data[j].file.points();
+            if (imagePoints.size() == 0) {
+                skip++;
+                continue;
+            }
+
+            float meanX = 0,
+                  meanY = 0;
+            for (int i = 0; i < imagePoints.size(); i++) {
+                points(i * 2, j - skip) = imagePoints[i].x();
+                points(i * 2 + 1, j - skip) = imagePoints[i].y();
+
+                meanX += imagePoints[i].x();
+                meanY += imagePoints[i].y();
+            }
+
+            meanX /= imagePoints.size();
+            meanY /= imagePoints.size();
+
+            for (int i = 0; i < imagePoints.size(); i++) {
+                points(i * 2, j - skip) -= meanX;
+                points(i * 2 + 1, j - skip) -= meanY;
+            }
+        }
+       
+        points = MatrixXf(points.leftCols(data.size() - skip));
+         
+        //normalize scale
+        for (int i = 0; i < points.cols(); i++)
+            points.col(i) = points.col(i) / points.col(i).norm();
+
+        //Normalize rotation
+        if (!useFirst) {
+            referenceShape = vectorToMatrix(points.rowwise().sum() / points.cols());
+        } else {
+            referenceShape = vectorToMatrix(points.col(0));
+        }
+
+        for (int i = 0; i < points.cols(); i++) {
+            MatrixXf p = vectorToMatrix(points.col(i));
+            MatrixXf R = getRotation(referenceShape, p);
+            points.col(i) = matrixToVector(p * R);
+        }
+
+        //Choose crop boundaries and adjustments that captures most data
+        MatrixXf minXs(points.cols(),1);
+        MatrixXf minYs(points.cols(),1);
+        MatrixXf maxXs(points.cols(),1);
+        MatrixXf maxYs(points.cols(),1);
+        for (int j = 0; j < points.cols(); j++) {
+            minX = FLT_MAX,
+            minY = FLT_MAX,
+            maxX = -FLT_MAX,
+            maxY = -FLT_MAX;
+            for (int i = 0; i < points.rows(); i++) {
+                if (i % 2 == 0) {
+                    if (points(i,j) > maxX)
+                        maxX = points(i, j);
+                    if (points(i,j) < minX)
+                        minX = points(i, j);
+                } else {
+                    if (points(i,j) > maxY)
+                        maxY = points(i, j);
+                    if (points(i,j) < minY)
+                        minY = points(i, j);
+                }
+            }
+
+            minXs(j) = minX;
+            maxXs(j) = maxX;
+            minYs(j) = minY;
+            maxYs(j) = maxY;
+        }
+
+        minX = minXs.mean() - 0 * EigenUtils::stddev(minXs);
+        minY = minYs.mean() - 0 * EigenUtils::stddev(minYs);
+        maxX = maxXs.mean() + 0 * EigenUtils::stddev(maxXs);
+        maxY = maxYs.mean() + 0 * EigenUtils::stddev(maxYs);
+        aspectRatio = (maxX - minX) / (maxY - minY);
+    }
+
+    void project(const Template &src, Template &dst) const
+    {
+        QList<QPointF> imagePoints = src.file.points();
+        if (imagePoints.size() == 0) {
+            dst.file.fte = true;
+            qDebug() << "No points for file " << src.file.name;
+            return;
+        }
+
+        MatrixXf p(imagePoints.size() * 2, 1);
+        for (int i = 0; i < imagePoints.size(); i++) {
+            p(i * 2) = imagePoints[i].x();
+            p(i * 2 + 1) = imagePoints[i].y();
+        }
+        p = vectorToMatrix(p);
+
+        //Normalize translation
+        p.col(0) = p.col(0) - MatrixXf::Ones(p.rows(),1) * (p.col(0).sum() / p.rows());
+        p.col(1) = p.col(1) - MatrixXf::Ones(p.rows(),1) * (p.col(1).sum() / p.rows());
+
+        //Normalize scale
+        p /= matrixToVector(p).norm();
+
+        //Normalize rotation
+        MatrixXf R = getRotation(referenceShape, p);
+        p = p * R;
+
+        //Translate and scale into output space and store in output list
+        QList<QPointF> procrustesPoints;
+        for (int i = 0; i < p.rows(); i++)
+            procrustesPoints.append( QPointF(
+                (p(i, 0) - minX) / (maxX - minX) * (width - 1) + padding,
+                (p(i, 1) - minY) / (maxY - minY) * (qRound( width / aspectRatio) - 1) + padding));
+
+        dst = src;
+        dst.file.setList<QPointF>("ProcrustesPoints", procrustesPoints);
+        dst.file.set("ProcrustesBound", QRectF(0, 0, width + 2 * padding, (qRound(width / aspectRatio) + 2 * padding)));
+        dst.file.set("ProcrustesPadding", padding);
+    }
+
+    void store(QDataStream &stream) const
+    {
+        stream << referenceShape;
+        stream << minX;
+        stream << minY;
+        stream << maxX;
+        stream << maxY;
+        stream << aspectRatio;
+    }
+
+    void load(QDataStream &stream)
+    {
+        stream >> referenceShape;
+        stream >> minX;
+        stream >> minY;
+        stream >> maxX;
+        stream >> maxY;
+        stream >> aspectRatio;
+    }
+};
+BR_REGISTER(Transform, ProcrustesAlignTransform)
+
+/*!
+ * \ingroup transforms
+ * \brief  Maps texture from one set of points to another. Assumes that points are rigidly transformed
+ * \author Brendan Klare \cite bklare
+ * \author Scott Klum \cite sklum
+ */
+class TextureMapTransform : public UntrainableTransform
+{
+    Q_OBJECT
+
+public:
+    static QRectF getBounds(const QList<QPointF> &points, int dstPadding)
+    {
+        float srcMinX = FLT_MAX;
+        float srcMinY = FLT_MAX;
+        float srcMaxX = -FLT_MAX;
+        float srcMaxY = -FLT_MAX;
+        foreach (const QPointF &point, points) {
+            if (point.x() < srcMinX) srcMinX = point.x();
+            if (point.y() < srcMinY) srcMinY = point.y();
+            if (point.x() > srcMaxX) srcMaxX = point.x();
+            if (point.y() > srcMaxY) srcMaxY = point.y();
+        }
+
+        const float padding = (srcMaxX - srcMinX) / 80 * dstPadding;
+        return QRectF(qRound(srcMinX - padding), qRound(srcMinY - padding), qRound(srcMaxX - srcMinX + 2 * padding), qRound(srcMaxY - srcMinY + 2 * padding));
+    }
+
+    static int getVertexIndex(const QPointF &trianglePts, const QList<QPointF> &pts)
+    {
+        for (int i = 0; i < pts.size(); i++)
+            // Check points using single precision accuracy to avoid potential rounding error
+            if ((float(trianglePts.x()) == float(pts[i].x())) && (float(trianglePts.y()) == float(pts[i].y())))
+                return i;
+        qFatal("Couldn't identify index of requested point!");
+        return -1;
+    }
+
+    static QList<QPointF> addBounds(QList<QPointF> points, const QRectF &bound)
+    {
+        points.append(bound.topLeft());
+        points.append(QPointF(bound.right() - 1, bound.top()));
+        points.append(QPointF(bound.left(), bound.bottom() - 1));
+        points.append(QPointF(bound.right() - 1, bound.bottom() - 1));
+        return points;
+    }
+
+    static QList<QPointF> removeBounds(const QList<QPointF> &points)
+    {
+        return points.mid(0, points.size() - 4);
+    }
+
+    //Expand out bounds placed at end of point list by addBounds
+    static QList<QPointF> expandBounds(QList<QPointF> points, int pad)
+    {
+        const int n = points.size();
+        points[n-4] = QPointF(points[n-4].x() - pad, points[n-4].y() - pad);
+        points[n-3] = QPointF(points[n-3].x() + pad, points[n-3].y() - pad);
+        points[n-2] = QPointF(points[n-2].x() - pad, points[n-2].y() + pad);
+        points[n-1] = QPointF(points[n-1].x() + pad, points[n-1].y() + pad);
+        return points;
+    }
+
+    //Contract in bounds placed at end of point list by addBounds
+    static QList<QPointF> contractBounds(QList<QPointF> points, int pad)
+    {
+        const int n = points.size();
+        points[n-4] = QPointF(points[n-4].x() + pad, points[n-4].y() + pad);
+        points[n-3] = QPointF(points[n-3].x() - pad, points[n-3].y() + pad);
+        points[n-2] = QPointF(points[n-2].x() + pad, points[n-2].y() - pad);
+        points[n-1] = QPointF(points[n-1].x() - pad, points[n-1].y() - pad);
+        return points;
+    }
+
+    static QList<QList<int> > getTriangulation(const QList<QPointF> &points, const QRectF &bound)
+    {
+        Subdiv2D subdiv(OpenCVUtils::toRect(bound));
+        foreach (const QPointF &point, points) {
+            if (!bound.contains(point))  
+                return QList<QList<int> >();
+            subdiv.insert(OpenCVUtils::toPoint(point));
+        }
+
+
+        vector<Vec6f> triangleList;
+        subdiv.getTriangleList(triangleList);
+
+        QList<QList<int> > triangleIndices;
+        foreach (const Vec6f &triangle, triangleList) {
+            bool valid = true;
+            const QPointF vertices[3] = { QPointF(triangle[0], triangle[1]),
+                                          QPointF(triangle[2], triangle[3]),
+                                          QPointF(triangle[4], triangle[5]) };
+            for (int j = 0; j < 3; j++)
+                if (vertices[j].x() > bound.right() || vertices[j].y() > bound.bottom() || vertices[j].x() < bound.left() || vertices[j].y() < bound.top()) {
+                    valid = false;
+                    break;
+                }
+
+            if (valid) {
+                QList<int> tri;
+                for (int j = 0; j < 3; j++)
+                    tri.append(getVertexIndex(vertices[j], points));
+                triangleIndices.append(tri);
+            }
+        }
+
+        return triangleIndices;
+    }
+
+private:
+    void project(const Template &src, Template &dst) const
+    {
+        QList<QPointF> dstPoints = dst.file.getList<QPointF>("ProcrustesPoints");
+        QList<QPointF> srcPoints = dst.file.points();
+        if (dstPoints.empty() || srcPoints.empty()) {
+            dst = src;
+            if (Globals->verbose) {
+                qWarning("Delauney triangulation failed because points or rects are empty.");
+                dst.file.fte = true;
+            }
+            return;
+        }
+
+        QRectF dstBound  = dst.file.get<QRectF>("ProcrustesBound");
+        dstPoints = addBounds(dstPoints, dstBound);
+
+        /*Add a wider bound for triangulation to prevent border triangles from being missing*/
+        QRectF srcBound  = getBounds(srcPoints, dst.file.get<int>("ProcrustesPadding") + 20);
+        srcPoints = addBounds(srcPoints, srcBound);
+        QList<QList<int> > triIndices = getTriangulation(srcPoints, srcBound);
+
+        /*Remove wider bound for texture mapping*/
+        srcPoints = removeBounds(srcPoints);
+        srcBound  = getBounds(srcPoints, dst.file.get<int>("ProcrustesPadding"));
+        srcPoints = addBounds(srcPoints, srcBound);
+
+        int dstWidth = dstBound.width() + dstBound.x();
+        int dstHeight = dstBound.height() + dstBound.y();
+        dst.m() = Mat::zeros(dstHeight, dstWidth, src.m().type());
+        for (int i = 0; i < triIndices.size(); i++) {
+            Point2f srcPoint1[3];
+            Point2f dstPoint1[3];
+            for (int j = 0; j < 3; j++) {
+                srcPoint1[j] = OpenCVUtils::toPoint(srcPoints[triIndices[i][j]]);
+                dstPoint1[j] = OpenCVUtils::toPoint(dstPoints[triIndices[i][j]]);
+            }
+
+            Mat buffer(dstHeight, dstWidth, src.m().type());
+            warpAffine(src.m(), buffer, getAffineTransform(srcPoint1, dstPoint1), Size(dstBound.width(), dstBound.height()));
+
+            Mat mask = Mat::zeros(dstHeight, dstWidth, CV_8UC1);
+            Point maskPoints[1][3];
+            maskPoints[0][0] = dstPoint1[0];
+            maskPoints[0][1] = dstPoint1[1];
+            maskPoints[0][2] = dstPoint1[2];
+            const Point* ppt = { maskPoints[0] };
+            fillConvexPoly(mask, ppt, 3, Scalar(255, 255, 255), 8);
+
+            for (int i = 0; i < dstHeight; i++) {
+                for (int j = 0; j < dstWidth; j++) {
+                    if (mask.at<uchar>(i,j) == 255) {
+                        if (dst.m().type() == CV_32FC3 || dst.m().type() == CV_8UC3)
+                            dst.m().at<cv::Vec3b>(i,j) = buffer.at<cv::Vec3b>(i,j);
+                        else if (dst.m().type() == CV_32F)
+                            dst.m().at<float>(i,j) = buffer.at<float>(i,j);
+                        else if (dst.m().type() == CV_8U)
+                            dst.m().at<uchar>(i,j) = buffer.at<uchar>(i,j);
+                        else
+                            qFatal("Unsupported pixel format.");
+                    }
+                }
+            }
+
+        }
+
+        dst.file = src.file;
+        dst.file.clearPoints();
+        dst.file.clearRects();
+        dst.file.remove("ProcrustesPoints");
+        dst.file.remove("ProcrustesPadding");
+        dst.file.remove("ProcrustesBounds");
+    }
+};
+
+BR_REGISTER(Transform, TextureMapTransform)
+
+// SynthesizePointsTransform helper class
+struct TriangleIndicies
+{
+    int indicies[3];
+
+    TriangleIndicies()
+    {
+        indicies[0] = 0;
+        indicies[1] = 0;
+        indicies[2] = 0;
+    }
+
+    TriangleIndicies(QList<int> indexList)
+    {
+        assert(indexList.size() == 3);
+        qSort(indexList);
+        indicies[0] = indexList[0];
+        indicies[1] = indexList[1];
+        indicies[2] = indexList[2];
+    }
+};
+
+inline bool operator==(const TriangleIndicies &a, const TriangleIndicies &b)
+{
+    return (a.indicies[0] == b.indicies[0]) && (a.indicies[1] == b.indicies[1]) && (a.indicies[2] == b.indicies[2]);
+}
+
+inline uint qHash(const TriangleIndicies &key)
+{
+    return ::qHash(key.indicies[0]) ^ ::qHash(key.indicies[1]) ^ ::qHash(key.indicies[2]);
+}
+
+QDataStream &operator<<(QDataStream &stream, const TriangleIndicies &ti)
+{
+    return stream << ti.indicies[0] << ti.indicies[1] << ti.indicies[2];
+}
+
+QDataStream &operator>>(QDataStream &stream, TriangleIndicies &ti)
+{
+    return stream >> ti.indicies[0] >> ti.indicies[1] >> ti.indicies[2];
+}
+
+/*!
+ * \ingroup transforms
+ * \brief Synthesize additional points via triangulation.
+ * \author Josh Klontz \cite jklontz
+ */
+ class SynthesizePointsTransform : public MetadataTransform
+ {
+    Q_OBJECT
+    Q_PROPERTY(float minRelativeDistance READ get_minRelativeDistance WRITE set_minRelativeDistance RESET reset_minRelativeDistance STORED false)
+    BR_PROPERTY(float, minRelativeDistance, 0) // [0, 1] range controlling whether or not to nearby synthetic points.
+                                               // 0 = keep all points, 1 = keep only the most distance point.
+
+    QList<TriangleIndicies> triangles;
+
+    void train(const TemplateList &data)
+    {
+        // Because not all triangulations are the same, we have to decide on a canonical set of triangles at training time.
+        QHash<TriangleIndicies, int> counts;
+        foreach (const Template &datum, data) {
+
+            const QList<QPointF> points = datum.file.points();
+            if (points.size() == 0)
+                    continue;
+            const QList< QList<int> > triangulation = TextureMapTransform::getTriangulation(points, TextureMapTransform::getBounds(points, 10));
+            if (triangulation.empty())
+                continue;
+            
+            foreach (const QList<int> &indicies, triangulation)
+                counts[TriangleIndicies(indicies)]++;
+        }
+
+        triangles.clear();
+        QHash<TriangleIndicies, int>::const_iterator i = counts.constBegin();
+        while (i != counts.constEnd()) {
+            if (3 * i.value() > data.size())
+                triangles.append(i.key()); // Keep triangles that occur in at least a third of the training instances
+            ++i;
+        }
+
+        if (minRelativeDistance > 0) { // Discard relatively small triangles
+            QVector<float> averageMinDistances(triangles.size());
+            foreach (const Template &datum, data) {
+                File dst;
+                projectMetadata(datum.file, dst);
+                const QList<QPointF> points = dst.points();
+
+                QVector<float> minDistances(triangles.size());
+                for (int i=0; i<triangles.size(); i++) {
+                    // Work backwards so that we can also consider distances between synthetic points
+                    const QPointF &point = points[points.size()-1-i];
+                    float minDistance = std::numeric_limits<float>::max();
+                    for (int j=0; j<points.size()-1-i; j++)
+                        minDistance = min(minDistance, sqrtf(powf(point.x() - points[j].x(), 2.f) + powf(point.y() - points[j].y(), 2.f)));
+                    minDistances[triangles.size()-1-i] = minDistance;
+                }
+
+                const float maxMinDistance = Common::Max(minDistances);
+                for (int i=0; i<minDistances.size(); i++)
+                    averageMinDistances[i] += (minDistances[i] / maxMinDistance);
+            }
+
+            const float maxAverageMinDistance = Common::Max(averageMinDistances);
+            for (int i=averageMinDistances.size()-1; i>=0; i--)
+                if (averageMinDistances[i] / maxAverageMinDistance < minRelativeDistance)
+                    triangles.removeAt(i);
+        }
+
+        if (Globals->verbose)
+            qDebug() << "Kept" << triangles.size() << "of" << counts.size() << "triangles.";
+    }
+
+    void projectMetadata(const File &src, File &dst) const
+    {
+        QList<QPointF> points = src.points();
+        if (points.size() == 0) {
+            dst.fte = true;
+            return;
+        }
+
+        foreach (const TriangleIndicies &triangle, triangles) {
+            const QPointF &p0 = points[triangle.indicies[0]];
+            const QPointF &p1 = points[triangle.indicies[1]];
+            const QPointF &p2 = points[triangle.indicies[2]];
+            points.append((p0 + p1 + p2) / 3 /* append the centroid of the triangle */);
+        }
+        dst.setPoints(points);
+    }
+
+    void store(QDataStream &stream) const
+    {
+        stream << triangles;
+    }
+
+    void load(QDataStream &stream)
+    {
+        stream >> triangles;
+    }
+ };
+ BR_REGISTER(Transform, SynthesizePointsTransform)
+
+/*!
+ * \ingroup initializers
+ * \brief Initialize Procrustes croppings
+ * \author Brendan Klare \cite bklare
+ */
+class ProcrustesInitializer : public Initializer
+{
+    Q_OBJECT
+
+    void initialize() const
+    {
+        Globals->abbreviations.insert("ProcrustesStasmFace","SelectPoints([17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,64,65,66,67,68,69,70,71,72,73,74,75,76])+ProcrustesAlign(padding=6,width=120)+TextureMap+Resize(96,96)");
+        Globals->abbreviations.insert("ProcrustesStasmEyes","SelectPoints([28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47])+ProcrustesAlign(padding=8)+TextureMap+Resize(24,48)");
+        Globals->abbreviations.insert("ProcrustesStasmPeriocular","SelectPoints([28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47,16,17,18,19,20,21,22,23,24,25,26,27])+ProcrustesAlign(padding=10)+TextureMap+Resize(36,48)");
+        Globals->abbreviations.insert("ProcrustesStasmBrow","SelectPoints([16,17,18,19,20,21,22,23,24,25,26,27])+ProcrustesAlign(padding=8)+TextureMap+Resize(24,48)");
+        Globals->abbreviations.insert("ProcrustesStasmNose","SelectPoints([48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58])+ProcrustesAlign(padding=12)+TextureMap+Resize(36,48)");
+        Globals->abbreviations.insert("ProcrustesStasmMouth","SelectPoints([59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76])+ProcrustesAlign(padding=10)+TextureMap+Resize(36,48)");
+        Globals->abbreviations.insert("ProcrustesStasmJaw", "SelectPoints([2,3,4,5,6,7,8,9,10])+ProcrustesAlign(padding=8)+TextureMap+Resize(36,48)");
+
+        Globals->abbreviations.insert("ProcrustesEyes","SelectPoints([19,20,21,22,23,24,25,26,27,28,29,30])+ProcrustesAlign(padding=8)+TextureMap+Resize(24,48)");
+        Globals->abbreviations.insert("ProcrustesNose","SelectPoints([12,13,14,15,16,17,18])+ProcrustesAlign(padding=30)+TextureMap+Resize(36,48)");
+        Globals->abbreviations.insert("ProcrustesMouth","SelectPoints([31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50])+ProcrustesAlign(padding=6)+TextureMap+Resize(36,48)");
+        Globals->abbreviations.insert("ProcrustesBrow","SelectPoints([0,1,2,3,4,5,6,7,8,9])+ProcrustesAlign(padding=6)+TextureMap+Resize(24,48)");
+        Globals->abbreviations.insert("ProcrustesFace","ProcrustesAlign(padding=6,width=120)+TextureMap+Resize(96,96)");
+
+        Globals->abbreviations.insert("ProcrustesLargeStasmFace","ProcrustesAlign(padding=18)+TextureMap+Resize(480,480)");
+        Globals->abbreviations.insert("ProcrustesLargeStasmEyes","SelectPoints([28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47])+ProcrustesAlign(padding=8)+TextureMap+Resize(240,480)");
+        Globals->abbreviations.insert("ProcrustesLargeStasmPeriocular","SelectPoints([28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47,16,17,18,19,20,21,22,23,24,25,26,27])+ProcrustesAlign(padding=10)+TextureMap+Resize(360,480)");
+        Globals->abbreviations.insert("ProcrustesLargeStasmBrow","SelectPoints([16,17,18,19,20,21,22,23,24,25,26,27])+ProcrustesAlign(padding=8)+TextureMap+Resize(240,480)");
+        Globals->abbreviations.insert("ProcrustesLargeStasmNose","SelectPoints([48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58])+ProcrustesAlign(padding=12)+TextureMap+Resize(360,480)");
+        Globals->abbreviations.insert("ProcrustesLargeStasmMouth","SelectPoints([59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76])+ProcrustesAlign(padding=20)+TextureMap+Resize(360,480)");
+        Globals->abbreviations.insert("ProcrustesLargeStasmJaw", "SelectPoints([2,3,4,5,6,7,8,9,10])+ProcrustesAlign(padding=8)+TextureMap+Resize(360,480)");
+    }
+};
+BR_REGISTER(Initializer, ProcrustesInitializer)
+
+} // namespace br
+
+#include "align.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;
+
+        foreach(const QString &path, Globals->modelSearch) {
+            const QString file = path + "/" + fileName;
+            if (QFileInfo(file).exists())
+                return file;
+        }
+        return 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"
+#include <openbr/plugins/openbr_internal.h>
+
+namespace br
+{
+
+/*!
+ * \ingroup transforms
+ * \brief Ensures that a template will be propogated.
+ * \author Scott Klum \cite sklum
+ */
+class PropagateTransform : public UntrainableMetaTransform
+{
+    Q_OBJECT
+
+    Q_PROPERTY(br::Transform *transform READ get_transform WRITE set_transform RESET reset_transform STORED true)
+    BR_PROPERTY(br::Transform *, transform, NULL)
+
+    void project(const Template &src, Template &dst) const
+    {
+        transform->project(src,dst);
+        if (dst.isEmpty())
+            dst = src;
+    }
+};
+
+BR_REGISTER(Transform, PropagateTransform)
+
+} // namespace br
+
+#include "core/propagate.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));
-
-        QList<QRectF> rects = src.file.rects();
-        for (int i=0; i<rects.size(); i++)
-            rects[i] = QRectF(rects[i].topLeft()*scaleFactor,rects[i].bottomRight()*scaleFactor);
-        dst.file.setRects(rects);
-
-        QList<QPointF> points = src.file.points();
-        for (int i=0; i<points.size(); i++)
-            points[i] = points[i] * scaleFactor;
-        dst.file.setPoints(points);
-
-    }
-};
-
-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 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 <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 <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"