diff --git a/3rdparty/stasm4.0.0/CMakeLists.txt b/3rdparty/stasm4.0.0/CMakeLists.txt
index 1675828..e79d55a 100644
--- a/3rdparty/stasm4.0.0/CMakeLists.txt
+++ b/3rdparty/stasm4.0.0/CMakeLists.txt
@@ -13,7 +13,7 @@ set(CPACK_PACKAGE_VERSION "${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()
diff --git a/CMakeLists.txt b/CMakeLists.txt
index eda7b49..0deea75 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -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
diff --git a/openbr/core/cluster.cpp b/openbr/core/cluster.cpp
index 44f196a..a16a3e0 100644
--- a/openbr/core/cluster.cpp
+++ b/openbr/core/cluster.cpp
@@ -82,7 +82,7 @@ float normalizedROD(const Neighborhood &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 &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 &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 &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;
 }
 
diff --git a/openbr/core/cluster.h b/openbr/core/cluster.h
index 84bb9ba..3def28d 100644
--- a/openbr/core/cluster.h
+++ b/openbr/core/cluster.h
@@ -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);
 }
diff --git a/openbr/core/core.cpp b/openbr/core/core.cpp
index a6f68bf..070cab4 100644
--- a/openbr/core/core.cpp
+++ b/openbr/core/core.cpp
@@ -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<br::Distance> br::Distance::fromAlgorithm(const QString &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"
diff --git a/openbr/core/qtutils.cpp b/openbr/core/qtutils.cpp
index fdfd004..9203c71 100644
--- a/openbr/core/qtutils.cpp
+++ b/openbr/core/qtutils.cpp
@@ -500,14 +500,15 @@ QString getAbsolutePath(const QString &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;
 }
 
diff --git a/openbr/core/qtutils.h b/openbr/core/qtutils.h
index 257ccd8..fc93059 100644
--- a/openbr/core/qtutils.h
+++ b/openbr/core/qtutils.h
@@ -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);
     };
diff --git a/openbr/janus b/openbr/janus
index e3aa915..cd22014 160000
--- a/openbr/janus
+++ b/openbr/janus
@@ -1 +1 @@
-Subproject commit e3aa915a5cfc3ee0332f566ae4f13370007964a1
+Subproject commit cd22014f9bd446f26c501e06b1170441bf872408
diff --git a/openbr/openbr.cpp b/openbr/openbr.cpp
index 3162371..fd4814c 100644
--- a/openbr/openbr.cpp
+++ b/openbr/openbr.cpp
@@ -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)
diff --git a/openbr/openbr_plugin.h b/openbr/openbr_plugin.h
index ac99081..5b22901 100644
--- a/openbr/openbr_plugin.h
+++ b/openbr/openbr_plugin.h
@@ -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(). */
 
diff --git a/openbr/plugins/classification/adaboost.cpp b/openbr/plugins/classification/adaboost.cpp
new file mode 100644
index 0000000..04e094f
--- /dev/null
+++ b/openbr/plugins/classification/adaboost.cpp
@@ -0,0 +1,134 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * 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"
diff --git a/openbr/plugins/dlib.cpp b/openbr/plugins/classification/dlib.cpp
index 6517840..9448e90 100644
--- a/openbr/plugins/dlib.cpp
+++ b/openbr/plugins/classification/dlib.cpp
@@ -1,4 +1,4 @@
-#include "openbr_internal.h"
+#include "openbr/plugins/openbr_internal.h"
 #include "openbr/core/qtutils.h"
 #include "openbr/core/eigenutils.h"
 
diff --git a/openbr/plugins/ebif.cpp b/openbr/plugins/classification/ebif.cpp
index 718a3b9..19d79ba 100644
--- a/openbr/plugins/ebif.cpp
+++ b/openbr/plugins/classification/ebif.cpp
@@ -1,8 +1,24 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * 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"
diff --git a/openbr/plugins/tree.cpp b/openbr/plugins/classification/forest.cpp
index 8ecc39f..b717533 100644
--- a/openbr/plugins/tree.cpp
+++ b/openbr/plugins/classification/forest.cpp
@@ -1,7 +1,22 @@
-#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"
diff --git a/openbr/plugins/ipc2013.cpp b/openbr/plugins/classification/ipc2013.cpp
index 4f5ce59..d16958c 100644
--- a/openbr/plugins/ipc2013.cpp
+++ b/openbr/plugins/classification/ipc2013.cpp
@@ -1,9 +1,10 @@
-#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;
diff --git a/openbr/plugins/eigen3.cpp b/openbr/plugins/classification/lda.cpp
index dfe4ba8..bc90925 100644
--- a/openbr/plugins/eigen3.cpp
+++ b/openbr/plugins/classification/lda.cpp
@@ -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"
diff --git a/openbr/plugins/liblinear.cpp b/openbr/plugins/classification/liblinear.cpp
index 1b9649e..31b2137 100644
--- a/openbr/plugins/liblinear.cpp
+++ b/openbr/plugins/classification/liblinear.cpp
@@ -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>
 
diff --git a/openbr/plugins/nn.cpp b/openbr/plugins/classification/mlp.cpp
index 83fd93f..4295004 100644
--- a/openbr/plugins/nn.cpp
+++ b/openbr/plugins/classification/mlp.cpp
@@ -1,51 +1,29 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * 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"
diff --git a/openbr/plugins/nt4.cpp b/openbr/plugins/classification/nt4.cpp
index a3ded95..218ce0a 100644
--- a/openbr/plugins/nt4.cpp
+++ b/openbr/plugins/classification/nt4.cpp
@@ -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"
diff --git a/openbr/plugins/pp4.cpp b/openbr/plugins/classification/pp4.cpp
index 69bac4b..6276d08 100644
--- a/openbr/plugins/pp4.cpp
+++ b/openbr/plugins/classification/pp4.cpp
@@ -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)                                                                                               \
diff --git a/openbr/plugins/pp5.cpp b/openbr/plugins/classification/pp5.cpp
index 6c795a5..0305626 100644
--- a/openbr/plugins/pp5.cpp
+++ b/openbr/plugins/classification/pp5.cpp
@@ -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"
diff --git a/openbr/plugins/svm.cpp b/openbr/plugins/classification/svm.cpp
index 8acd3a7..e6f42d1 100644
--- a/openbr/plugins/svm.cpp
+++ b/openbr/plugins/classification/svm.cpp
@@ -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"
diff --git a/openbr/plugins/classification/turk.cpp b/openbr/plugins/classification/turk.cpp
new file mode 100644
index 0000000..79594b6
--- /dev/null
+++ b/openbr/plugins/classification/turk.cpp
@@ -0,0 +1,72 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * 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"
diff --git a/openbr/plugins/cluster/collectnn.cpp b/openbr/plugins/cluster/collectnn.cpp
new file mode 100644
index 0000000..a077a0a
--- /dev/null
+++ b/openbr/plugins/cluster/collectnn.cpp
@@ -0,0 +1,58 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * 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"
diff --git a/openbr/plugins/cluster/kmeans.cpp b/openbr/plugins/cluster/kmeans.cpp
new file mode 100644
index 0000000..cea7381
--- /dev/null
+++ b/openbr/plugins/cluster/kmeans.cpp
@@ -0,0 +1,81 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * 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"
diff --git a/openbr/plugins/cluster.cpp b/openbr/plugins/cluster/knn.cpp
index ab95f27..8284c78 100644
--- a/openbr/plugins/cluster.cpp
+++ b/openbr/plugins/cluster/knn.cpp
@@ -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"
diff --git a/openbr/plugins/cluster/lognn.cpp b/openbr/plugins/cluster/lognn.cpp
new file mode 100644
index 0000000..fc99f77
--- /dev/null
+++ b/openbr/plugins/cluster/lognn.cpp
@@ -0,0 +1,81 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * 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"
diff --git a/openbr/plugins/cluster/randomcentroids.cpp b/openbr/plugins/cluster/randomcentroids.cpp
new file mode 100644
index 0000000..b3a1a30
--- /dev/null
+++ b/openbr/plugins/cluster/randomcentroids.cpp
@@ -0,0 +1,84 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * 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"
diff --git a/openbr/plugins/dlib.cmake b/openbr/plugins/cmake/dlib.cmake
index 9c594ad..06ee3c6 100644
--- a/openbr/plugins/dlib.cmake
+++ b/openbr/plugins/cmake/dlib.cmake
@@ -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)
diff --git a/openbr/plugins/cmake/eigen3.cmake b/openbr/plugins/cmake/eigen3.cmake
new file mode 100644
index 0000000..73646fa
--- /dev/null
+++ b/openbr/plugins/cmake/eigen3.cmake
@@ -0,0 +1,16 @@
+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()
diff --git a/openbr/plugins/ipc2013.cmake b/openbr/plugins/cmake/ipc2013.cmake
index d764890..617ac4d 100644
--- a/openbr/plugins/ipc2013.cmake
+++ b/openbr/plugins/cmake/ipc2013.cmake
@@ -2,7 +2,8 @@ set(BR_WITH_IPC2013 OFF CACHE BOOL "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()
diff --git a/openbr/plugins/jni.cmake b/openbr/plugins/cmake/jni.cmake
index 0fc3f77..41cc5ba 100644
--- a/openbr/plugins/jni.cmake
+++ b/openbr/plugins/cmake/jni.cmake
@@ -3,10 +3,10 @@ set(BR_WITH_JAVA OFF CACHE BOOL "Use Java Code")
 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()
diff --git a/openbr/plugins/cmake/libav.cmake b/openbr/plugins/cmake/libav.cmake
new file mode 100644
index 0000000..c5cd622
--- /dev/null
+++ b/openbr/plugins/cmake/libav.cmake
@@ -0,0 +1,13 @@
+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()
diff --git a/openbr/plugins/liblinear.cmake b/openbr/plugins/cmake/liblinear.cmake
index 3845f08..431a64c 100644
--- a/openbr/plugins/liblinear.cmake
+++ b/openbr/plugins/cmake/liblinear.cmake
@@ -3,5 +3,6 @@ set(BR_WITH_LIBLINEAR OFF CACHE BOOL "Build with LibLinear")
 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()
diff --git a/openbr/plugins/likely.cmake b/openbr/plugins/cmake/likely.cmake
index 92ab602..ba894d6 100644
--- a/openbr/plugins/likely.cmake
+++ b/openbr/plugins/cmake/likely.cmake
@@ -2,6 +2,9 @@ set(BR_WITH_LIKELY OFF CACHE BOOL "Build with Likely")
 
 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()
diff --git a/openbr/plugins/mongoose.cmake b/openbr/plugins/cmake/mongoose.cmake
index a32ea7d..729365a 100644
--- a/openbr/plugins/mongoose.cmake
+++ b/openbr/plugins/cmake/mongoose.cmake
@@ -1,6 +1,8 @@
 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()
diff --git a/openbr/plugins/qtnetwork.cmake b/openbr/plugins/cmake/network.cmake
index 49e02e9..bab3dd2 100644
--- a/openbr/plugins/qtnetwork.cmake
+++ b/openbr/plugins/cmake/network.cmake
@@ -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()
diff --git a/openbr/plugins/nt4.cmake b/openbr/plugins/cmake/nt4.cmake
index 41fa42e..bdba899 100644
--- a/openbr/plugins/nt4.cmake
+++ b/openbr/plugins/cmake/nt4.cmake
@@ -2,7 +2,8 @@ set(BR_WITH_NT4 OFF CACHE BOOL "Build with Neurotec Biometric 4")
 
 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()
diff --git a/openbr/plugins/pp4.cmake b/openbr/plugins/cmake/pp4.cmake
index fd79240..95743a7 100644
--- a/openbr/plugins/pp4.cmake
+++ b/openbr/plugins/cmake/pp4.cmake
@@ -2,8 +2,9 @@ set(BR_WITH_PP4 OFF CACHE BOOL "Build with PittPatt 4")
 
 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()
diff --git a/openbr/plugins/pp5.cmake b/openbr/plugins/cmake/pp5.cmake
index 7fcebd9..2df45b6 100644
--- a/openbr/plugins/pp5.cmake
+++ b/openbr/plugins/cmake/pp5.cmake
@@ -2,7 +2,6 @@ set(BR_WITH_PP5 OFF CACHE BOOL "Build with PittPatt 5")
 
 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()
diff --git a/openbr/plugins/cmake/show.cmake b/openbr/plugins/cmake/show.cmake
new file mode 100644
index 0000000..54e924a
--- /dev/null
+++ b/openbr/plugins/cmake/show.cmake
@@ -0,0 +1,3 @@
+if(${BR_EMBEDDED})
+  set(BR_EXCLUDED_PLUGINS ${BR_EXCLUDED_PLUGINS} plugins/gui/show.cpp)
+endif()
diff --git a/openbr/plugins/stasm4.cmake b/openbr/plugins/cmake/stasm4.cmake
index 42c8de5..0ab4181 100644
--- a/openbr/plugins/stasm4.cmake
+++ b/openbr/plugins/cmake/stasm4.cmake
@@ -2,14 +2,9 @@ set(BR_WITH_STASM4 ON CACHE BOOL "Build with Stasm")
 
 if(${BR_WITH_STASM4})
   find_package(Stasm4 REQUIRED)
-  set(BR_THIRDPARTY_SRC ${BR_THIRDPARTY_SRC} plugins/stasm4.cpp)
-  set(BR_THIRDPARTY_LIBS ${BR_THIRDPARTY_LIBS} ${Stasm4_LIBS})
-
-  if(WIN32)
-    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()
diff --git a/openbr/plugins/algorithms.cpp b/openbr/plugins/core/algorithms.cpp
index 88ecaea..d58ff34 100644
--- a/openbr/plugins/algorithms.cpp
+++ b/openbr/plugins/core/algorithms.cpp
@@ -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"
diff --git a/openbr/plugins/core/align.cpp b/openbr/plugins/core/align.cpp
new file mode 100644
index 0000000..6445fa6
--- /dev/null
+++ b/openbr/plugins/core/align.cpp
@@ -0,0 +1,613 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * 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"
diff --git a/openbr/plugins/core/attributealgorithms.cpp b/openbr/plugins/core/attributealgorithms.cpp
new file mode 100644
index 0000000..05e255d
--- /dev/null
+++ b/openbr/plugins/core/attributealgorithms.cpp
@@ -0,0 +1,153 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * 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"
diff --git a/openbr/plugins/core/cache.cpp b/openbr/plugins/core/cache.cpp
new file mode 100644
index 0000000..ea43813
--- /dev/null
+++ b/openbr/plugins/core/cache.cpp
@@ -0,0 +1,95 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * 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"
diff --git a/openbr/plugins/core/contract.cpp b/openbr/plugins/core/contract.cpp
new file mode 100644
index 0000000..018a89c
--- /dev/null
+++ b/openbr/plugins/core/contract.cpp
@@ -0,0 +1,61 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * 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"
diff --git a/openbr/plugins/validate.cpp b/openbr/plugins/core/crossvalidate.cpp
index cb0e651..eb86143 100644
--- a/openbr/plugins/validate.cpp
+++ b/openbr/plugins/core/crossvalidate.cpp
@@ -1,8 +1,23 @@
-#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"
diff --git a/openbr/plugins/core/discard.cpp b/openbr/plugins/core/discard.cpp
new file mode 100644
index 0000000..553a5b2
--- /dev/null
+++ b/openbr/plugins/core/discard.cpp
@@ -0,0 +1,42 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * 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"
diff --git a/openbr/plugins/core/discardtemplates.cpp b/openbr/plugins/core/discardtemplates.cpp
new file mode 100644
index 0000000..baf89da
--- /dev/null
+++ b/openbr/plugins/core/discardtemplates.cpp
@@ -0,0 +1,42 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * 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"
diff --git a/openbr/plugins/core/distributetemplate.cpp b/openbr/plugins/core/distributetemplate.cpp
new file mode 100644
index 0000000..6a7e5cd
--- /dev/null
+++ b/openbr/plugins/core/distributetemplate.cpp
@@ -0,0 +1,142 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * 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"
diff --git a/openbr/plugins/core/downsampletraining.cpp b/openbr/plugins/core/downsampletraining.cpp
new file mode 100644
index 0000000..e6eecb2
--- /dev/null
+++ b/openbr/plugins/core/downsampletraining.cpp
@@ -0,0 +1,135 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * 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"
diff --git a/openbr/plugins/core/event.cpp b/openbr/plugins/core/event.cpp
new file mode 100644
index 0000000..b9f2568
--- /dev/null
+++ b/openbr/plugins/core/event.cpp
@@ -0,0 +1,46 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * 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"
diff --git a/openbr/plugins/core/expand.cpp b/openbr/plugins/core/expand.cpp
new file mode 100644
index 0000000..6c19dff
--- /dev/null
+++ b/openbr/plugins/core/expand.cpp
@@ -0,0 +1,78 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * 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"
diff --git a/openbr/plugins/core/first.cpp b/openbr/plugins/core/first.cpp
new file mode 100644
index 0000000..1d656f2
--- /dev/null
+++ b/openbr/plugins/core/first.cpp
@@ -0,0 +1,47 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * 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"
diff --git a/openbr/plugins/core/fork.cpp b/openbr/plugins/core/fork.cpp
new file mode 100644
index 0000000..1d82503
--- /dev/null
+++ b/openbr/plugins/core/fork.cpp
@@ -0,0 +1,143 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * 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"
diff --git a/openbr/plugins/core/fte.cpp b/openbr/plugins/core/fte.cpp
new file mode 100644
index 0000000..69186e2
--- /dev/null
+++ b/openbr/plugins/core/fte.cpp
@@ -0,0 +1,73 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * 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"
diff --git a/openbr/plugins/core/gallerycompare.cpp b/openbr/plugins/core/gallerycompare.cpp
new file mode 100644
index 0000000..d8c0f64
--- /dev/null
+++ b/openbr/plugins/core/gallerycompare.cpp
@@ -0,0 +1,80 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * 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"
diff --git a/openbr/plugins/core/identity.cpp b/openbr/plugins/core/identity.cpp
new file mode 100644
index 0000000..18b4c93
--- /dev/null
+++ b/openbr/plugins/core/identity.cpp
@@ -0,0 +1,42 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * 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"
diff --git a/openbr/plugins/core/independent.cpp b/openbr/plugins/core/independent.cpp
new file mode 100644
index 0000000..b0c9289
--- /dev/null
+++ b/openbr/plugins/core/independent.cpp
@@ -0,0 +1,229 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * 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"
diff --git a/openbr/plugins/jni.cpp b/openbr/plugins/core/jni.cpp
index 9aa6870..1b84bb9 100644
--- a/openbr/plugins/jni.cpp
+++ b/openbr/plugins/core/jni.cpp
@@ -1,8 +1,8 @@
 //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
diff --git a/openbr/plugins/likely.cpp b/openbr/plugins/core/likely.cpp
index f15f4b4..400b7e7 100644
--- a/openbr/plugins/likely.cpp
+++ b/openbr/plugins/core/likely.cpp
@@ -1,8 +1,4 @@
-#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"
diff --git a/openbr/plugins/core/loadstore.cpp b/openbr/plugins/core/loadstore.cpp
new file mode 100644
index 0000000..5657aa8
--- /dev/null
+++ b/openbr/plugins/core/loadstore.cpp
@@ -0,0 +1,168 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * 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"
diff --git a/openbr/plugins/core/pipe.cpp b/openbr/plugins/core/pipe.cpp
new file mode 100644
index 0000000..bebe445
--- /dev/null
+++ b/openbr/plugins/core/pipe.cpp
@@ -0,0 +1,221 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * 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"
diff --git a/openbr/plugins/process.cpp b/openbr/plugins/core/processwrapper.cpp
index ba3559b..5594fc8 100644
--- a/openbr/plugins/process.cpp
+++ b/openbr/plugins/core/processwrapper.cpp
@@ -1,4 +1,18 @@
-
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * 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"
diff --git a/openbr/plugins/core/progresscounter.cpp b/openbr/plugins/core/progresscounter.cpp
new file mode 100644
index 0000000..e27fbfd
--- /dev/null
+++ b/openbr/plugins/core/progresscounter.cpp
@@ -0,0 +1,97 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * 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"
diff --git a/openbr/plugins/core/propagate.cpp b/openbr/plugins/core/propagate.cpp
new file mode 100644
index 0000000..9146ad0
--- /dev/null
+++ b/openbr/plugins/core/propagate.cpp
@@ -0,0 +1,30 @@
+#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"
diff --git a/openbr/plugins/core/registrar.cpp b/openbr/plugins/core/registrar.cpp
new file mode 100644
index 0000000..aaaf573
--- /dev/null
+++ b/openbr/plugins/core/registrar.cpp
@@ -0,0 +1,41 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * 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"
diff --git a/openbr/plugins/core/remove.cpp b/openbr/plugins/core/remove.cpp
new file mode 100644
index 0000000..72a0fed
--- /dev/null
+++ b/openbr/plugins/core/remove.cpp
@@ -0,0 +1,47 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * 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"
diff --git a/openbr/plugins/core/rest.cpp b/openbr/plugins/core/rest.cpp
new file mode 100644
index 0000000..0cbcedf
--- /dev/null
+++ b/openbr/plugins/core/rest.cpp
@@ -0,0 +1,43 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * 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"
diff --git a/openbr/plugins/core/schrodinger.cpp b/openbr/plugins/core/schrodinger.cpp
new file mode 100644
index 0000000..3bb6ad6
--- /dev/null
+++ b/openbr/plugins/core/schrodinger.cpp
@@ -0,0 +1,61 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * 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"
diff --git a/openbr/plugins/core/singleton.cpp b/openbr/plugins/core/singleton.cpp
new file mode 100644
index 0000000..965750c
--- /dev/null
+++ b/openbr/plugins/core/singleton.cpp
@@ -0,0 +1,89 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * 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"
diff --git a/openbr/plugins/stream.cpp b/openbr/plugins/core/stream.cpp
index c2e5019..8920d6e 100644
--- a/openbr/plugins/stream.cpp
+++ b/openbr/plugins/core/stream.cpp
@@ -1,3 +1,19 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * 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"
 
diff --git a/openbr/plugins/crop.cpp b/openbr/plugins/crop.cpp
deleted file mode 100644
index 01b5167..0000000
--- a/openbr/plugins/crop.cpp
+++ /dev/null
@@ -1,299 +0,0 @@
-/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
- * 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"
diff --git a/openbr/plugins/cvt.cpp b/openbr/plugins/cvt.cpp
deleted file mode 100644
index e247ab7..0000000
--- a/openbr/plugins/cvt.cpp
+++ /dev/null
@@ -1,303 +0,0 @@
-/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
- * 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"
diff --git a/openbr/plugins/distance.cpp b/openbr/plugins/distance.cpp
deleted file mode 100644
index 4fd7014..0000000
--- a/openbr/plugins/distance.cpp
+++ /dev/null
@@ -1,512 +0,0 @@
-/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
- * 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"
diff --git a/openbr/plugins/distance/L1.cpp b/openbr/plugins/distance/L1.cpp
new file mode 100644
index 0000000..cd11cec
--- /dev/null
+++ b/openbr/plugins/distance/L1.cpp
@@ -0,0 +1,46 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * 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"
diff --git a/openbr/plugins/distance/L2.cpp b/openbr/plugins/distance/L2.cpp
new file mode 100644
index 0000000..a966c20
--- /dev/null
+++ b/openbr/plugins/distance/L2.cpp
@@ -0,0 +1,46 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * 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"
diff --git a/openbr/plugins/distance/attribute.cpp b/openbr/plugins/distance/attribute.cpp
new file mode 100644
index 0000000..29f2610
--- /dev/null
+++ b/openbr/plugins/distance/attribute.cpp
@@ -0,0 +1,50 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * 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"
diff --git a/openbr/plugins/distance/bayesianquantization.cpp b/openbr/plugins/distance/bayesianquantization.cpp
new file mode 100644
index 0000000..ea9836c
--- /dev/null
+++ b/openbr/plugins/distance/bayesianquantization.cpp
@@ -0,0 +1,104 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * 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"
diff --git a/openbr/plugins/distance/byteL1.cpp b/openbr/plugins/distance/byteL1.cpp
new file mode 100644
index 0000000..36a5970
--- /dev/null
+++ b/openbr/plugins/distance/byteL1.cpp
@@ -0,0 +1,42 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * 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"
diff --git a/openbr/plugins/distance/crossvalidate.cpp b/openbr/plugins/distance/crossvalidate.cpp
new file mode 100644
index 0000000..ef69a88
--- /dev/null
+++ b/openbr/plugins/distance/crossvalidate.cpp
@@ -0,0 +1,44 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * 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"
diff --git a/openbr/plugins/distance/default.cpp b/openbr/plugins/distance/default.cpp
new file mode 100644
index 0000000..e4bf121
--- /dev/null
+++ b/openbr/plugins/distance/default.cpp
@@ -0,0 +1,47 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * 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"
diff --git a/openbr/plugins/distance/dist.cpp b/openbr/plugins/distance/dist.cpp
new file mode 100644
index 0000000..f98196e
--- /dev/null
+++ b/openbr/plugins/distance/dist.cpp
@@ -0,0 +1,120 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * 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"
diff --git a/openbr/plugins/distance/filter.cpp b/openbr/plugins/distance/filter.cpp
new file mode 100644
index 0000000..3570289
--- /dev/null
+++ b/openbr/plugins/distance/filter.cpp
@@ -0,0 +1,55 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * 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"
diff --git a/openbr/plugins/distance/fuse.cpp b/openbr/plugins/distance/fuse.cpp
new file mode 100644
index 0000000..c02b411
--- /dev/null
+++ b/openbr/plugins/distance/fuse.cpp
@@ -0,0 +1,117 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * 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"
diff --git a/openbr/plugins/distance/halfbyteL1.cpp b/openbr/plugins/distance/halfbyteL1.cpp
new file mode 100644
index 0000000..d70c0cf
--- /dev/null
+++ b/openbr/plugins/distance/halfbyteL1.cpp
@@ -0,0 +1,45 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * 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"
diff --git a/openbr/plugins/distance/heatmap.cpp b/openbr/plugins/distance/heatmap.cpp
new file mode 100644
index 0000000..d25cf4b
--- /dev/null
+++ b/openbr/plugins/distance/heatmap.cpp
@@ -0,0 +1,100 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * 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"
diff --git a/openbr/plugins/distance/identical.cpp b/openbr/plugins/distance/identical.cpp
new file mode 100644
index 0000000..49cb36e
--- /dev/null
+++ b/openbr/plugins/distance/identical.cpp
@@ -0,0 +1,47 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * 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"
diff --git a/openbr/plugins/distance/keypointmatcher.cpp b/openbr/plugins/distance/keypointmatcher.cpp
new file mode 100644
index 0000000..2ef766f
--- /dev/null
+++ b/openbr/plugins/distance/keypointmatcher.cpp
@@ -0,0 +1,74 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * 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"
diff --git a/openbr/plugins/distance/matchprobability.cpp b/openbr/plugins/distance/matchprobability.cpp
new file mode 100644
index 0000000..e885151
--- /dev/null
+++ b/openbr/plugins/distance/matchprobability.cpp
@@ -0,0 +1,195 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * 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"
diff --git a/openbr/plugins/distance/metadata.cpp b/openbr/plugins/distance/metadata.cpp
new file mode 100644
index 0000000..11660f7
--- /dev/null
+++ b/openbr/plugins/distance/metadata.cpp
@@ -0,0 +1,76 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * 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"
diff --git a/openbr/plugins/distance/neglogplusone.cpp b/openbr/plugins/distance/neglogplusone.cpp
new file mode 100644
index 0000000..ae92db2
--- /dev/null
+++ b/openbr/plugins/distance/neglogplusone.cpp
@@ -0,0 +1,58 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * 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"
diff --git a/openbr/plugins/distance/online.cpp b/openbr/plugins/distance/online.cpp
new file mode 100644
index 0000000..e683c0a
--- /dev/null
+++ b/openbr/plugins/distance/online.cpp
@@ -0,0 +1,51 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * 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"
diff --git a/openbr/plugins/distance/pipe.cpp b/openbr/plugins/distance/pipe.cpp
new file mode 100644
index 0000000..523868f
--- /dev/null
+++ b/openbr/plugins/distance/pipe.cpp
@@ -0,0 +1,63 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * 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"
diff --git a/openbr/plugins/distance/reject.cpp b/openbr/plugins/distance/reject.cpp
new file mode 100644
index 0000000..c183513
--- /dev/null
+++ b/openbr/plugins/distance/reject.cpp
@@ -0,0 +1,54 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * 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"
diff --git a/openbr/plugins/distance/sum.cpp b/openbr/plugins/distance/sum.cpp
new file mode 100644
index 0000000..07a9853
--- /dev/null
+++ b/openbr/plugins/distance/sum.cpp
@@ -0,0 +1,62 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * 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"
diff --git a/openbr/plugins/distance/turk.cpp b/openbr/plugins/distance/turk.cpp
new file mode 100644
index 0000000..def8326
--- /dev/null
+++ b/openbr/plugins/distance/turk.cpp
@@ -0,0 +1,65 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * 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"
diff --git a/openbr/plugins/distance/unit.cpp b/openbr/plugins/distance/unit.cpp
new file mode 100644
index 0000000..f8f4b54
--- /dev/null
+++ b/openbr/plugins/distance/unit.cpp
@@ -0,0 +1,87 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * 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"
diff --git a/openbr/plugins/distance/zscore.cpp b/openbr/plugins/distance/zscore.cpp
new file mode 100644
index 0000000..ddaae48
--- /dev/null
+++ b/openbr/plugins/distance/zscore.cpp
@@ -0,0 +1,84 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * 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"
diff --git a/openbr/plugins/draw.cpp b/openbr/plugins/draw.cpp
deleted file mode 100644
index 3dc6a9b..0000000
--- a/openbr/plugins/draw.cpp
+++ /dev/null
@@ -1,700 +0,0 @@
-/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
- * Copyright 2012 The MITRE Corporation                                      *
- *                                                                           *
- * Licensed under the Apache License, Version 2.0 (the "License");           *
- * you may not use this file except in compliance with the License.          *
- * You may obtain a copy of the License at                                   *
- *                                                                           *
- *     http://www.apache.org/licenses/LICENSE-2.0                            *
- *                                                                           *
- * Unless required by applicable law or agreed to in writing, software       *
- * distributed under the License is distributed on an "AS IS" BASIS,         *
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  *
- * See the License for the specific language governing permissions and       *
- * limitations under the License.                                            *
- * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
-
-#include <opencv2/highgui/highgui.hpp>
-#include <opencv2/highgui/highgui_c.h>
-#include <opencv2/imgproc/imgproc.hpp>
-#include <vector>
-#include "openbr_internal.h"
-#include "openbr/core/opencvutils.h"
-
-using namespace cv;
-
-namespace br
-{
-
-/*!
- * \ingroup transforms
- * \brief Renders metadata onto the image.
- *
- * The inPlace argument controls whether or not the image is cloned before the metadata is drawn.
- *
- * \author Josh Klontz \cite jklontz
- */
-class DrawTransform : public UntrainableTransform
-{
-    Q_OBJECT
-    Q_PROPERTY(bool verbose READ get_verbose WRITE set_verbose RESET reset_verbose STORED false)
-    Q_PROPERTY(bool points READ get_points WRITE set_points RESET reset_points STORED false)
-    Q_PROPERTY(bool rects READ get_rects WRITE set_rects RESET reset_rects STORED false)
-    Q_PROPERTY(bool inPlace READ get_inPlace WRITE set_inPlace RESET reset_inPlace STORED false)
-    Q_PROPERTY(int lineThickness READ get_lineThickness WRITE set_lineThickness RESET reset_lineThickness STORED false)
-    Q_PROPERTY(bool named READ get_named WRITE set_named RESET reset_named STORED false)
-    Q_PROPERTY(bool location READ get_location WRITE set_location RESET reset_location STORED false)
-    BR_PROPERTY(bool, verbose, false)
-    BR_PROPERTY(bool, points, true)
-    BR_PROPERTY(bool, rects, true)
-    BR_PROPERTY(bool, inPlace, false)
-    BR_PROPERTY(int, lineThickness, 1)
-    BR_PROPERTY(bool, named, true)
-    BR_PROPERTY(bool, location, true)
-
-    void project(const Template &src, Template &dst) const
-    {
-        const Scalar color(0,255,0);
-        const Scalar verboseColor(255, 255, 0);
-        dst.m() = inPlace ? src.m() : src.m().clone();
-
-        if (points) {
-            const QList<Point2f> pointsList = (named) ? OpenCVUtils::toPoints(src.file.points()+src.file.namedPoints()) : OpenCVUtils::toPoints(src.file.points());
-            for (int i=0; i<pointsList.size(); i++) {
-                const Point2f &point = pointsList[i];
-                circle(dst, point, 3, color, -1);
-                QString label = (location) ? QString("%1,(%2,%3)").arg(QString::number(i),QString::number(point.x),QString::number(point.y)) : QString("%1").arg(QString::number(i));
-                if (verbose) putText(dst, label.toStdString(), point, FONT_HERSHEY_SIMPLEX, 0.5, verboseColor, 1);
-            }
-        }
-        if (rects) {
-            foreach (const Rect &rect, OpenCVUtils::toRects(src.file.namedRects() + src.file.rects()))
-                rectangle(dst, rect, color, lineThickness);
-        }
-    }
-};
-
-BR_REGISTER(Transform, DrawTransform)
-
-
-/*!
- * \ingroup transforms
- * \brief Draw the value of the specified property at the specified point on the image
- *
- * The inPlace argument controls whether or not the image is cloned before it is drawn on.
- *
- * \author Charles Otto \cite caotto
- */
-class DrawPropertyPointTransform : public UntrainableTransform
-{
-    Q_OBJECT
-    Q_PROPERTY(QString propName READ get_propName WRITE set_propName RESET reset_propName STORED false)
-    Q_PROPERTY(QString pointName READ get_pointName WRITE set_pointName RESET reset_pointName STORED false)
-    Q_PROPERTY(bool inPlace READ get_inPlace WRITE set_inPlace RESET reset_inPlace STORED false)
-    BR_PROPERTY(QString, propName, "")
-    BR_PROPERTY(QString, pointName, "")
-    BR_PROPERTY(bool, inPlace, false)
-
-
-    void project(const Template &src, Template &dst) const
-    {
-        dst = src;
-        if (propName.isEmpty() || pointName.isEmpty())
-            return;
-
-        dst.m() = inPlace ? src.m() : src.m().clone();
-
-        const Scalar textColor(255, 255, 0);
-
-        QVariant prop = dst.file.value(propName);
-
-
-        if (!prop.canConvert(QVariant::String))
-            return;
-        QString propString = prop.toString();
-
-        QVariant point = dst.file.value(pointName);
-
-        if (!point.canConvert(QVariant::PointF))
-            return;
-
-        QPointF targetPoint = point.toPointF();
-
-        Point2f cvPoint =OpenCVUtils::toPoint(targetPoint);
-
-        std::string text = propName.toStdString() + ": " + propString.toStdString();
-        putText(dst, text, cvPoint, FONT_HERSHEY_SIMPLEX, 0.5, textColor, 1);
-    }
-
-};
-BR_REGISTER(Transform, DrawPropertyPointTransform)
-
-/*!
- * \ingroup transforms
- * \brief Draw the values of a list of properties at the specified point on the image
- *
- * The inPlace argument controls whether or not the image is cloned before it is drawn on.
- *
- * \author Charles Otto \cite caotto
- */
-class DrawPropertiesPointTransform : public UntrainableTransform
-{
-    Q_OBJECT
-    Q_PROPERTY(QStringList propNames READ get_propNames WRITE set_propNames RESET reset_propNames STORED false)
-    Q_PROPERTY(QString pointName READ get_pointName WRITE set_pointName RESET reset_pointName STORED false)
-    Q_PROPERTY(bool inPlace READ get_inPlace WRITE set_inPlace RESET reset_inPlace STORED false)
-    BR_PROPERTY(QStringList, propNames, QStringList())
-    BR_PROPERTY(QString, pointName, "")
-    BR_PROPERTY(bool, inPlace, false)
-
-    void project(const Template &src, Template &dst) const
-    {
-        dst = src;
-        if (propNames.isEmpty() || pointName.isEmpty())
-            return;
-
-        dst.m() = inPlace ? src.m() : src.m().clone();
-
-        QVariant point = dst.file.value(pointName);
-
-        if (!point.canConvert(QVariant::PointF))
-            return;
-
-        QPointF targetPoint = point.toPointF();
-
-        Point2f cvPoint =OpenCVUtils::toPoint(targetPoint);
-
-
-        const Scalar textColor(255, 255, 0);
-
-        std::string outString = "";
-        foreach (const QString &propName, propNames)
-        {
-            QVariant prop = dst.file.value(propName);
-
-            if (!prop.canConvert(QVariant::String))
-                continue;
-            QString propString = prop.toString();
-            outString += propName.toStdString() + ": " + propString.toStdString() + " ";
-
-        }
-        if (outString.empty())
-            return;
-
-        putText(dst, outString, cvPoint, FONT_HERSHEY_SIMPLEX, 0.5, textColor, 1);
-    }
-
-};
-BR_REGISTER(Transform, DrawPropertiesPointTransform)
-
-
-/*!
- * \ingroup transforms
- * \brief Draws a grid on the image
- * \author Josh Klontz \cite jklontz
- */
-class DrawGridTransform : public UntrainableTransform
-{
-    Q_OBJECT
-    Q_PROPERTY(int rows READ get_rows WRITE set_rows RESET reset_rows STORED false)
-    Q_PROPERTY(int columns READ get_columns WRITE set_columns RESET reset_columns STORED false)
-    Q_PROPERTY(int r READ get_r WRITE set_r RESET reset_r STORED false)
-    Q_PROPERTY(int g READ get_g WRITE set_g RESET reset_g STORED false)
-    Q_PROPERTY(int b READ get_b WRITE set_b RESET reset_b STORED false)
-    BR_PROPERTY(int, rows, 0)
-    BR_PROPERTY(int, columns, 0)
-    BR_PROPERTY(int, r, 196)
-    BR_PROPERTY(int, g, 196)
-    BR_PROPERTY(int, b, 196)
-
-    void project(const Template &src, Template &dst) const
-    {
-        Mat m = src.m().clone();
-        float rowStep = 1.f * m.rows / (rows+1);
-        float columnStep = 1.f * m.cols / (columns+1);
-        int thickness = qMin(m.rows, m.cols) / 256;
-        for (float row = rowStep/2; row < m.rows; row += rowStep)
-            line(m, Point(0, row), Point(m.cols, row), Scalar(r, g, b), thickness, CV_AA);
-        for (float column = columnStep/2; column < m.cols; column += columnStep)
-            line(m, Point(column, 0), Point(column, m.rows), Scalar(r, g, b), thickness, CV_AA);
-        dst = m;
-    }
-};
-
-BR_REGISTER(Transform, DrawGridTransform)
-
-/*!
- * \ingroup transforms
- * \brief Computes the mean of a set of templates.
- * \note Suitable for visualization only as it sets every projected template to the mean template.
- * \author Scott Klum \cite sklum
- */
-class MeanTransform : public Transform
-{
-    Q_OBJECT
-
-    Mat mean;
-
-    void train(const TemplateList &data)
-    {
-        mean = Mat::zeros(data[0].m().rows,data[0].m().cols,CV_32F);
-
-        for (int i = 0; i < data.size(); i++) {
-            Mat converted;
-            data[i].m().convertTo(converted, CV_32F);
-            mean += converted;
-        }
-
-        mean /= data.size();
-    }
-
-    void project(const Template &src, Template &dst) const
-    {
-        dst = src;
-        dst.m() = mean;
-    }
-
-};
-
-BR_REGISTER(Transform, MeanTransform)
-
-/*!
- * \ingroup transforms
- * \brief Load the image named in the specified property, draw it on the current matrix adjacent to the rect specified in the other property.
- * \author Charles Otto \cite caotto
- */
-class AdjacentOverlayTransform : public Transform
-{
-    Q_OBJECT
-
-    Q_PROPERTY(QString imgName READ get_imgName WRITE set_imgName RESET reset_imgName STORED false)
-    Q_PROPERTY(QString targetName READ get_targetName WRITE set_targetName RESET reset_targetName STORED false)
-    BR_PROPERTY(QString, imgName, "")
-    BR_PROPERTY(QString, targetName, "")
-
-    QSharedPointer<Transform> opener;
-    void project(const Template &src, Template &dst) const
-    {
-        dst = src;
-
-        if (imgName.isEmpty() || targetName.isEmpty() || !dst.file.contains(imgName) || !dst.file.contains(targetName))
-            return;
-
-        QVariant temp = src.file.value(imgName);
-        cv::Mat im;
-        // is this a filename?
-        if (temp.canConvert<QString>()) {
-            QString im_name = temp.toString();
-            Template temp_im;
-            opener->project(File(im_name), temp_im);
-            im = temp_im.m();
-        }
-        // a cv::Mat ?
-        else if (temp.canConvert<cv::Mat>())
-            im = src.file.get<cv::Mat>(imgName);
-        else
-            qDebug() << "Unrecognized property type " << imgName << "for" << src.file.name;
-
-        // Location of detected face in source image
-        QRectF target_location = src.file.get<QRectF>(targetName);
-
-        // match width with target region
-        qreal target_width = target_location.width();
-        qreal current_width = im.cols;
-        qreal current_height = im.rows;
-
-        qreal aspect_ratio = current_height / current_width;
-        qreal target_height = target_width * aspect_ratio;
-
-        cv::resize(im, im, cv::Size(target_width, target_height));
-
-        // ROI used to maybe crop the matched image
-        cv::Rect clip_roi;
-        clip_roi.x = 0;
-        clip_roi.y = 0;
-        clip_roi.width = im.cols;
-        clip_roi.height= im.rows <= dst.m().rows ? im.rows : dst.m().rows;
-
-        int half_width = src.m().cols / 2;
-        int out_x = 0;
-
-        // place in the source image we will copy the matched image to.
-        cv::Rect target_roi;
-        bool left_side = false;
-        int width_adjust = 0;
-        // Place left
-        if (target_location.center().rx() > half_width) {
-            out_x = target_location.left() - im.cols;
-            if (out_x < 0) {
-                width_adjust = abs(out_x);
-                out_x = 0;
-            }
-            left_side = true;
-        }
-        // place right
-        else {
-            out_x = target_location.right();
-            int high = out_x + im.cols;
-            if (high >= src.m().cols) {
-                width_adjust = abs(high - src.m().cols + 1);
-            }
-        }
-
-        cv::Mat outIm;
-        if (width_adjust)
-        {
-            outIm.create(dst.m().rows, dst.m().cols + width_adjust, CV_8UC3);
-            memset(outIm.data, 127, outIm.rows * outIm.cols * outIm.channels());
-
-            Rect temp;
-
-            if (left_side)
-                temp = Rect(abs(width_adjust), 0, dst.m().cols, dst.m().rows);
-
-            else
-                temp = Rect(0, 0, dst.m().cols, dst.m().rows);
-
-            dst.m().copyTo(outIm(temp));
-
-        }
-        else
-            outIm = dst.m();
-
-        if (clip_roi.height + target_location.top() >= outIm.rows)
-        {
-            clip_roi.height -= abs(outIm.rows - (clip_roi.height + target_location.top() ));
-        }
-        if (clip_roi.x + clip_roi.width >= im.cols) {
-            clip_roi.width -= abs(im.cols - (clip_roi.x + clip_roi.width + 1));
-            if (clip_roi.width < 0)
-                clip_roi.width = 1;
-        }
-
-        if (clip_roi.y + clip_roi.height >= im.rows) {
-            clip_roi.height -= abs(im.rows - (clip_roi.y + clip_roi.height + 1));
-        }
-        if (clip_roi.x < 0)
-            clip_roi.x = 0;
-        if (clip_roi.y < 0)
-            clip_roi.y = 0;
-
-        if (clip_roi.height < 0)
-            clip_roi.height = 0;
-
-        if (clip_roi.width < 0)
-            clip_roi.width = 0;
-
-
-        if (clip_roi.y + clip_roi.height >= im.rows)
-        {
-            qDebug() << "Bad clip y" << clip_roi.y + clip_roi.height << im.rows;
-        }
-        if (clip_roi.x + clip_roi.width >= im.cols)
-        {
-            qDebug() << "Bad clip x" << clip_roi.x + clip_roi.width << im.cols;
-        }
-
-        if (clip_roi.y < 0 || clip_roi.height < 0)
-        {
-            qDebug() << "bad clip y, low" << clip_roi.y << clip_roi.height;
-            qFatal("die");
-        }
-        if (clip_roi.x < 0 || clip_roi.width < 0)
-        {
-            qDebug() << "bad clip x, low" << clip_roi.x << clip_roi.width;
-            qFatal("die");
-        }
-
-        target_roi.x = out_x;
-        target_roi.width = clip_roi.width;
-        target_roi.y = target_location.top();
-        target_roi.height = clip_roi.height;
-
-
-        im = im(clip_roi);
-
-        if (target_roi.x < 0 || target_roi.x >= outIm.cols)
-        {
-            qDebug() << "Bad xdim in targetROI!" << target_roi.x << " out im x: " << outIm.cols;
-            qFatal("die");
-        }
-
-        if (target_roi.x + target_roi.width < 0 || (target_roi.x + target_roi.width) >= outIm.cols)
-        {
-            qDebug() << "Bad xdim in targetROI!" << target_roi.x + target_roi.width;
-            qFatal("die");
-        }
-
-        if (target_roi.y < 0 || target_roi.y >= outIm.rows)
-        {
-            qDebug() << "Bad ydim in targetROI!" << target_roi.y;
-            qFatal("die");
-        }
-
-        if ((target_roi.y + target_roi.height) < 0 || (target_roi.y + target_roi.height) > outIm.rows)
-        {
-            qDebug() << "Bad ydim in targetROI!" << target_roi.y + target_roi.height;
-            qDebug() << "target_roi.y: " << target_roi.y << " height: " << target_roi.height;
-            qFatal("die");
-        }
-
-        
-        std::vector<cv::Mat> channels;
-        cv::split(outIm, channels);
-
-        std::vector<cv::Mat> patch_channels;
-        cv::split(im, patch_channels);
-
-        for (size_t i=0; i < channels.size(); i++)
-        {
-            cv::addWeighted(channels[i](target_roi), 0, patch_channels[i % patch_channels.size()], 1, 0,channels[i](target_roi));
-        }
-        cv::merge(channels, outIm);
-        dst.m() = outIm;
-
-    }
-
-    void init()
-    {
-        opener = QSharedPointer<br::Transform>(br::Transform::make("Cache(Open)", NULL));
-    }
-
-};
-
-BR_REGISTER(Transform, AdjacentOverlayTransform)
-
-/*!
- * \ingroup transforms
- * \brief Draw a line representing the direction and magnitude of optical flow at the specified points.
- * \author Austin Blanton \cite imaus10
- */
-class DrawOpticalFlow : public UntrainableTransform
-{
-    Q_OBJECT
-    Q_PROPERTY(QString original READ get_original WRITE set_original RESET reset_original STORED false)
-    BR_PROPERTY(QString, original, "original")
-
-    void project(const Template &src, Template &dst) const
-    {
-        const Scalar color(0,255,0);
-        Mat flow = src.m();
-        dst = src;
-        if (!dst.file.contains(original)) qFatal("The original img must be saved in the metadata with SaveMat.");
-        dst.m() = dst.file.get<Mat>(original);
-        dst.file.remove(original);
-        foreach (const Point2f &pt, OpenCVUtils::toPoints(dst.file.points())) {
-            Point2f dxy = flow.at<Point2f>(pt.y, pt.x);
-            Point2f newPt(pt.x+dxy.x, pt.y+dxy.y);
-            line(dst, pt, newPt, color);
-        }
-    }
-};
-BR_REGISTER(Transform, DrawOpticalFlow)
-
-/*!
- * \ingroup transforms
- * \brief Fill in the segmentations or draw a line between intersecting segments.
- * \author Austin Blanton \cite imaus10
- */
-class DrawSegmentation : public UntrainableTransform
-{
-    Q_OBJECT
-    Q_PROPERTY(bool fillSegment READ get_fillSegment WRITE set_fillSegment RESET reset_fillSegment STORED false)
-    BR_PROPERTY(bool, fillSegment, true)
-
-    void project(const Template &src, Template &dst) const
-    {
-        if (!src.file.contains("SegmentsMask") || !src.file.contains("NumSegments")) qFatal("Must supply a Contours object in the metadata to drawContours.");
-        Mat segments = src.file.get<Mat>("SegmentsMask");
-        int numSegments = src.file.get<int>("NumSegments");
-
-        dst.file = src.file;
-        Mat drawn = fillSegment ? Mat(segments.size(), CV_8UC3, Scalar::all(0)) : src.m();
-
-        for (int i=1; i<numSegments+1; i++) {
-            Mat mask = segments == i;
-            if (fillSegment) { // color the whole segment
-                // set to a random color - get ready for a craaaazy acid trip
-                int b = theRNG().uniform(0, 255);
-                int g = theRNG().uniform(0, 255);
-                int r = theRNG().uniform(0, 255);
-                drawn.setTo(Scalar(r,g,b), mask);
-            } else { // draw lines where there's a color change
-                vector<vector<Point> > contours;
-                Scalar color(0,255,0);
-                findContours(mask, contours, CV_RETR_LIST, CV_CHAIN_APPROX_NONE);
-                drawContours(drawn, contours, -1, color);
-            }
-        }
-
-        dst.m() = drawn;
-    }
-};
-BR_REGISTER(Transform, DrawSegmentation)
-
-/*!
- * \ingroup transforms
- * \brief Write all mats to disk as images.
- * \author Brendan Klare \cite bklare
- */
-class WriteImageTransform : public TimeVaryingTransform
-{
-    Q_OBJECT
-    Q_PROPERTY(QString outputDirectory READ get_outputDirectory WRITE set_outputDirectory RESET reset_outputDirectory STORED false)
-    Q_PROPERTY(QString imageName READ get_imageName WRITE set_imageName RESET reset_imageName STORED false)
-    Q_PROPERTY(QString imgExtension READ get_imgExtension WRITE set_imgExtension RESET reset_imgExtension STORED false)
-    BR_PROPERTY(QString, outputDirectory, "Temp")
-    BR_PROPERTY(QString, imageName, "image")
-    BR_PROPERTY(QString, imgExtension, "jpg")
-
-    int cnt;
-
-    void init() {
-        cnt = 0;
-        if (! QDir(outputDirectory).exists())
-            QDir().mkdir(outputDirectory);
-    }
-
-    void projectUpdate(const Template &src, Template &dst)
-    {
-        dst = src;
-        OpenCVUtils::saveImage(dst.m(), QString("%1/%2_%3.%4").arg(outputDirectory).arg(imageName).arg(cnt++, 5, 10, QChar('0')).arg(imgExtension));
-    }
-
-};
-BR_REGISTER(Transform, WriteImageTransform)
-
-
-/**
- * @brief The MeanImageTransform class computes the average template/image
- * and save the result as an encoded image.
- */
-class MeanImageTransform : public TimeVaryingTransform
-{
-    Q_OBJECT
-
-    Q_PROPERTY(QString imgname READ get_imgname WRITE set_imgname RESET reset_imgname STORED false)
-    Q_PROPERTY(QString ext READ get_ext WRITE set_ext RESET reset_ext STORED false)
-
-    BR_PROPERTY(QString, imgname, "average")
-    BR_PROPERTY(QString, ext, "jpg")
-
-    Mat average;
-    int cnt;
-
-    void init()
-    {
-        cnt = 0;
-    }
-
-    void projectUpdate(const Template &src, Template &dst)
-    {
-        dst = src;
-        if (cnt == 0) {
-            if (src.m().channels() == 1)
-                average = Mat::zeros(dst.m().size(),CV_64FC1);
-            else if (src.m().channels() == 3)
-                average = Mat::zeros(dst.m().size(),CV_64FC3);
-            else
-                qFatal("Unsupported number of channels");
-        }
-
-        Mat temp;
-        if (src.m().channels() == 1) {
-            src.m().convertTo(temp, CV_64FC1);
-            average += temp;
-        } else if (src.m().channels() == 3) {
-            src.m().convertTo(temp, CV_64FC3);
-            average += temp;
-        } else
-            qFatal("Unsupported number of channels");
-
-        cnt++;
-    }
-
-    virtual void finalize(TemplateList &output)
-    {
-        average /= float(cnt);
-        imwrite(QString("%1.%2").arg(imgname).arg(ext).toStdString(), average);
-        output = TemplateList();
-    }
-
-
-public:
-    MeanImageTransform() : TimeVaryingTransform(false, false) {}
-};
-
-BR_REGISTER(Transform, MeanImageTransform)
-
-
-// TODO: re-implement EditTransform using Qt
-#if 0
-/*!
- * \ingroup transforms
- * \brief Remove landmarks.
- * \author Josh Klontz \cite jklontz
- */
-class EditTransform : public UntrainableTransform
-{
-    Q_OBJECT
-
-    Transform *draw;
-    static Template currentTemplate;
-    static QMutex currentTemplateLock;
-
-    void init()
-    {
-        draw = make("Draw");
-        Globals->setProperty("parallelism", "0"); // Can only work in single threaded mode
-    }
-
-    void project(const Template &src, Template &dst) const
-    {
-        dst = src;
-
-        if (Globals->parallelism) {
-            qWarning("Edit::project() only works in single threaded mode.");
-            return;
-        }
-
-        currentTemplateLock.lock();
-        currentTemplate = src;
-        OpenCVUtils::showImage(src, "Edit", false);
-        setMouseCallback("Edit", mouseCallback, (void*)this);
-        mouseEvent(0, 0, 0, 0);
-        waitKey(-1);
-        dst = currentTemplate;
-        currentTemplateLock.unlock();
-    }
-
-    static void mouseCallback(int event, int x, int y, int flags, void *userdata)
-    {
-        ((const EditTransform*)userdata)->mouseEvent(event, x, y, flags);
-    }
-
-    void mouseEvent(int event, int x, int y, int flags) const
-    {
-        (void) event;
-        if (flags) {
-            QList<QRectF> rects = currentTemplate.file.rects();
-            for (int i=rects.size()-1; i>=0; i--)
-                if (rects[i].contains(x,y))
-                    rects.removeAt(i);
-            currentTemplate.file.setRects(rects);
-        }
-
-        Template temp;
-        draw->project(currentTemplate, temp);
-        OpenCVUtils::showImage(temp, "Edit", false);
-    }
-};
-
-Template EditTransform::currentTemplate;
-QMutex EditTransform::currentTemplateLock;
-
-BR_REGISTER(Transform, EditTransform)
-#endif
-
-} // namespace br
-
-#include "draw.moc"
diff --git a/openbr/plugins/eigen3.cmake b/openbr/plugins/eigen3.cmake
deleted file mode 100644
index ed6a3e2..0000000
--- a/openbr/plugins/eigen3.cmake
+++ /dev/null
@@ -1,7 +0,0 @@
-set(BR_WITH_EIGEN3 ON CACHE BOOL "Build Eigen3 plugins")
-
-if(${BR_WITH_EIGEN3})
-  find_package(Eigen3 REQUIRED)
-  set(BR_THIRDPARTY_SRC ${BR_THIRDPARTY_SRC} plugins/eigen3.cpp)
-  install(FILES ${EIGEN3_LICENSE} RENAME Eigen3 DESTINATION share/openbr/licenses)
-endif()
diff --git a/openbr/plugins/filter.cpp b/openbr/plugins/filter.cpp
deleted file mode 100644
index 48fbe75..0000000
--- a/openbr/plugins/filter.cpp
+++ /dev/null
@@ -1,258 +0,0 @@
-/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
- * Copyright 2012 The MITRE Corporation                                      *
- *                                                                           *
- * Licensed under the Apache License, Version 2.0 (the "License");           *
- * you may not use this file except in compliance with the License.          *
- * You may obtain a copy of the License at                                   *
- *                                                                           *
- *     http://www.apache.org/licenses/LICENSE-2.0                            *
- *                                                                           *
- * Unless required by applicable law or agreed to in writing, software       *
- * distributed under the License is distributed on an "AS IS" BASIS,         *
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  *
- * See the License for the specific language governing permissions and       *
- * limitations under the License.                                            *
- * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
-
-#include <opencv2/imgproc/imgproc.hpp>
-#include "openbr_internal.h"
-#include "openbr/core/tanh_sse.h"
-
-using namespace cv;
-
-namespace br
-{
-
-/*!
- * \ingroup transforms
- * \brief Gamma correction
- * \author Josh Klontz \cite jklontz
- */
-class GammaTransform : public UntrainableTransform
-{
-    Q_OBJECT
-    Q_PROPERTY(float gamma READ get_gamma WRITE set_gamma RESET reset_gamma STORED false)
-    BR_PROPERTY(float, gamma, 0.2)
-
-    Mat lut;
-
-    void init()
-    {
-        lut.create(256, 1, CV_32FC1);
-        if (gamma == 0) for (int i=0; i<256; i++) lut.at<float>(i,0) = log((float)i);
-        else            for (int i=0; i<256; i++) lut.at<float>(i,0) = pow(i, gamma);
-    }
-
-    void project(const Template &src, Template &dst) const
-    {
-        if (src.m().depth() == CV_8U) LUT(src, lut, dst);
-        else                          pow(src, gamma, dst);
-    }
-};
-
-BR_REGISTER(Transform, GammaTransform)
-
-/*!
- * \ingroup transforms
- * \brief Gaussian blur
- * \author Josh Klontz \cite jklontz
- */
-class BlurTransform : public UntrainableTransform
-{
-    Q_OBJECT
-    Q_PROPERTY(float sigma READ get_sigma WRITE set_sigma RESET reset_sigma STORED false)
-    Q_PROPERTY(bool ROI READ get_ROI WRITE set_ROI RESET reset_ROI STORED false)
-    BR_PROPERTY(float, sigma, 1)
-    BR_PROPERTY(bool, ROI, false)
-
-    void project(const Template &src, Template &dst) const
-    {
-        if (!ROI) GaussianBlur(src, dst, Size(0,0), sigma);
-        else {
-            dst.m() = src.m();
-            foreach (const QRectF &rect, src.file.rects()) {
-                Rect region(rect.x(), rect.y(), rect.width(), rect.height());
-                Mat input = dst.m();
-                Mat output = input.clone();
-                GaussianBlur(input(region), output(region), Size(0,0), sigma);
-                dst.m() = output;
-            }
-        }
-    }
-};
-
-BR_REGISTER(Transform, BlurTransform)
-
-/*!
- * \ingroup transforms
- * \brief Difference of gaussians
- * \author Josh Klontz \cite jklontz
- */
-class DoGTransform : public UntrainableTransform
-{
-    Q_OBJECT
-    Q_PROPERTY(float sigma0 READ get_sigma0 WRITE set_sigma0 RESET reset_sigma0 STORED false)
-    Q_PROPERTY(float sigma1 READ get_sigma1 WRITE set_sigma1 RESET reset_sigma1 STORED false)
-    BR_PROPERTY(float, sigma0, 1)
-    BR_PROPERTY(float, sigma1, 2)
-
-    Size ksize0, ksize1;
-
-    static Size getKernelSize(double sigma)
-    {
-        // Inverts OpenCV's conversion from kernel size to sigma:
-        // sigma = ((ksize-1)*0.5 - 1)*0.3 + 0.8
-        // See documentation for cv::getGaussianKernel()
-        int ksize = ((sigma - 0.8) / 0.3 + 1) * 2 + 1;
-        if (ksize % 2 == 0) ksize++;
-        return Size(ksize, ksize);
-    }
-
-    void init()
-    {
-        ksize0 = getKernelSize(sigma0);
-        ksize1 = getKernelSize(sigma1);
-    }
-
-    void project(const Template &src, Template &dst) const
-    {
-        Mat g0, g1;
-        GaussianBlur(src, g0, ksize0, 0);
-        GaussianBlur(src, g1, ksize1, 0);
-        subtract(g0, g1, dst);
-    }
-};
-
-BR_REGISTER(Transform, DoGTransform)
-
-/*!
- * \ingroup transforms
- * \brief Meyers, E.; Wolf, L.
- * “Using biologically inspired features for face processing,”
- * Int. Journal of Computer Vision, vol. 76, no. 1, pp 93–104, 2008.
- * \author Scott Klum \cite sklum
- */
-
-class CSDNTransform : public UntrainableTransform
-{
-    Q_OBJECT
-
-    Q_PROPERTY(float s READ get_s WRITE set_s RESET reset_s STORED false)
-    BR_PROPERTY(int, s, 16)
-
-    void project(const Template &src, Template &dst) const
-    {
-        if (src.m().channels() != 1) qFatal("Expected single channel source matrix.");
-
-        const int nRows = src.m().rows;
-        const int nCols = src.m().cols;
-
-        Mat m;
-        src.m().convertTo(m, CV_32FC1);
-
-        const int surround = s/2;
-
-        for ( int i = 0; i < nRows; i++ ) {
-            for ( int j = 0; j < nCols; j++ ) {
-                int width = min( j+surround, nCols ) - max( 0, j-surround );
-                int height = min( i+surround, nRows ) - max( 0, i-surround );
-
-                Rect_<int> ROI(max(0, j-surround), max(0, i-surround), width, height);
-
-                Scalar_<float> avg = mean(m(ROI));
-
-                m.at<float>(i,j) = m.at<float>(i,j) - avg[0];
-            }
-        }
-
-        dst = m;
-
-    }
-};
-
-BR_REGISTER(Transform, CSDNTransform)
-
-/*!
- * \ingroup transforms
- * \brief Xiaoyang Tan; Triggs, B.;
- * "Enhanced Local Texture Feature Sets for Face Recognition Under Difficult Lighting Conditions,"
- * Image Processing, IEEE Transactions on , vol.19, no.6, pp.1635-1650, June 2010
- * \author Josh Klontz \cite jklontz
- */
-class ContrastEqTransform : public UntrainableTransform
-{
-    Q_OBJECT
-    Q_PROPERTY(float a READ get_a WRITE set_a RESET reset_a STORED false)
-    Q_PROPERTY(float t READ get_t WRITE set_t RESET reset_t STORED false)
-    BR_PROPERTY(float, a, 1)
-    BR_PROPERTY(float, t, 0.1)
-
-    void project(const Template &src, Template &dst) const
-    {
-        if (src.m().channels() != 1) qFatal("Expected single channel source matrix.");
-
-        // Stage 1
-        Mat stage1;
-        {
-            Mat abs_dst;
-            absdiff(src, Scalar(0), abs_dst);
-            Mat pow_dst;
-            pow(abs_dst, a, pow_dst);
-            float denominator = pow((float)mean(pow_dst)[0], 1.f/a);
-            src.m().convertTo(stage1, CV_32F, 1/denominator);
-        }
-
-        // Stage 2
-        Mat stage2;
-        {
-            Mat abs_dst;
-            absdiff(stage1, Scalar(0), abs_dst);
-            Mat min_dst;
-            min(abs_dst, t, min_dst);
-            Mat pow_dst;
-            pow(min_dst, a, pow_dst);
-            float denominator = pow((float)mean(pow_dst)[0], 1.f/a);
-            stage1.convertTo(stage2, CV_32F, 1/denominator);
-        }
-
-        // Hyperbolic tangent
-        const int nRows = src.m().rows;
-        const int nCols = src.m().cols;
-        const float* p = (const float*)stage2.ptr();
-        Mat m(nRows, nCols, CV_32FC1);
-        for (int i=0; i<nRows; i++)
-            for (int j=0; j<nCols; j++)
-                m.at<float>(i, j) = fast_tanh(p[i*nCols+j]);
-                // TODO: m.at<float>(i, j) = t * fast_tanh(p[i*nCols+j] / t);
-
-        dst = m;
-    }
-};
-
-BR_REGISTER(Transform, ContrastEqTransform)
-
-/*!
- * \ingroup transforms
- * \brief Raise each element to the specified power.
- * \author Josh Klontz \cite jklontz
- */
-class PowTransform : public UntrainableTransform
-{
-    Q_OBJECT
-    Q_PROPERTY(float power READ get_power WRITE set_power RESET reset_power STORED false)
-    Q_PROPERTY(bool preserveSign READ get_preserveSign WRITE set_preserveSign RESET reset_preserveSign STORED false)
-    BR_PROPERTY(float, power, 2)
-    BR_PROPERTY(bool, preserveSign, false)
-
-    void project(const Template &src, Template &dst) const
-    {
-        pow(preserveSign ? abs(src) : src.m(), power, dst);
-        if (preserveSign) subtract(Scalar::all(0), dst, dst, src.m() < 0);
-    }
-};
-
-BR_REGISTER(Transform, PowTransform)
-
-} // namespace br
-
-#include "filter.moc"
diff --git a/openbr/plugins/format.cpp b/openbr/plugins/format.cpp
deleted file mode 100644
index 48eed7d..0000000
--- a/openbr/plugins/format.cpp
+++ /dev/null
@@ -1,975 +0,0 @@
-/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
- * Copyright 2012 The MITRE Corporation                                      *
- *                                                                           *
- * Licensed under the Apache License, Version 2.0 (the "License");           *
- * you may not use this file except in compliance with the License.          *
- * You may obtain a copy of the License at                                   *
- *                                                                           *
- *     http://www.apache.org/licenses/LICENSE-2.0                            *
- *                                                                           *
- * Unless required by applicable law or agreed to in writing, software       *
- * distributed under the License is distributed on an "AS IS" BASIS,         *
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  *
- * See the License for the specific language governing permissions and       *
- * limitations under the License.                                            *
- * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
-
-#include <QDate>
-#include <QSize>
-#include <QChar>
-#ifndef BR_EMBEDDED
-#include <QtXml>
-#endif // BR_EMBEDDED
-#include <QFile>
-#include <QFileInfo>
-
-#include <opencv2/highgui/highgui.hpp>
-#include <opencv2/highgui/highgui_c.h>
-#include "openbr_internal.h"
-
-#include "openbr/core/bee.h"
-#include "openbr/core/opencvutils.h"
-#include "openbr/core/qtutils.h"
-
-using namespace cv;
-
-namespace br
-{
-
- /*!
- * \ingroup formats
- * \brief Read all frames of a video using OpenCV
- * \author Charles Otto \cite caotto
- */
-class videoFormat : public Format
-{
-    Q_OBJECT
-
-public:
-    Template read() const
-    {
-        if (!file.exists() )
-            return Template();
-
-        VideoCapture videoSource(file.name.toStdString());
-        videoSource.open(file.name.toStdString() );
-
-
-        Template frames;
-        if (!videoSource.isOpened()) {
-            qWarning("video file open failed");
-            return frames;
-        }
-
-        bool open = true;
-        while (open) {
-            cv::Mat frame;
-            open = videoSource.read(frame);
-            if (!open) break;
-
-            frames.append(cv::Mat());
-            frames.back() = frame.clone();
-        }
-
-        return frames;
-    }
-
-    void write(const Template &t) const
-    {
-        int fourcc = OpenCVUtils::getFourcc();
-        VideoWriter videoSink(file.name.toStdString(), fourcc, 30, t.begin()->size());
-
-        // Did we successfully open the output file?
-        if (!videoSink.isOpened() ) qFatal("Failed to open output file");
-
-        for (Template::const_iterator it = t.begin(); it!= t.end(); ++it) {
-            videoSink << *it;
-        }
-    }
-};
-
-BR_REGISTER(Format, videoFormat)
-
-/*!
- * \ingroup formats
- * \brief A simple binary matrix format.
- * \author Josh Klontz \cite jklontz
- * First 4 bytes indicate the number of rows.
- * Second 4 bytes indicate the number of columns.
- * The rest of the bytes are 32-bit floating data elements in row-major order.
- */
-class binFormat : public Format
-{
-    Q_OBJECT
-    Q_PROPERTY(bool raw READ get_raw WRITE set_raw RESET reset_raw STORED false)
-    BR_PROPERTY(bool, raw, false)
-
-    Template read() const
-    {
-        QByteArray data;
-        QtUtils::readFile(file, data);
-        if (raw) {
-            return Template(file, Mat(1, data.size(), CV_8UC1, data.data()).clone());
-        } else {
-            return Template(file, Mat(((quint32*)data.data())[0],
-                                      ((quint32*)data.data())[1],
-                                      CV_32FC1,
-                                      data.data()+8).clone());
-        }
-    }
-
-    void write(const Template &t) const
-    {
-        QFile f(file);
-        QtUtils::touchDir(f);
-        if (!f.open(QFile::WriteOnly))
-            qFatal("Failed to open %s for writing.", qPrintable(file));
-
-        Mat m;
-        if (!raw) {
-            if (t.m().type() != CV_32FC1)
-                t.m().convertTo(m, CV_32F);
-            else m = t.m();
-
-            if (m.channels() != 1) qFatal("Only supports single channel matrices.");
-
-            f.write((const char *) &m.rows, 4);
-            f.write((const char *) &m.cols, 4);
-        }
-        else m =  t.m();
-
-        qint64 rowSize = m.cols * sizeof(float);
-        for (int i=0; i < m.rows; i++)
-        {
-            f.write((const char *) m.row(i).data, rowSize);
-        }
-        f.close();
-    }
-};
-
-BR_REGISTER(Format, binFormat)
-
-/*!
- * \ingroup formats
- * \brief Reads a comma separated value file.
- * \author Josh Klontz \cite jklontz
- */
-class csvFormat : public Format
-{
-    Q_OBJECT
-
-    Template read() const
-    {
-        QFile f(file.name);
-        f.open(QFile::ReadOnly);
-        QStringList lines(QString(f.readAll()).split(QRegularExpression("[\n|\r\n|\r]"), QString::SkipEmptyParts));
-        f.close();
-
-        bool isUChar = true;
-        QList< QList<float> > valsList;
-        foreach (const QString &line, lines) {
-            QList<float> vals;
-            foreach (const QString &word, line.split(QRegExp(" *, *"), QString::SkipEmptyParts)) {
-                bool ok;
-                const float val = word.toFloat(&ok);
-                vals.append(val);
-                isUChar = isUChar && (val == float(uchar(val)));
-            }
-            if (!vals.isEmpty())
-                valsList.append(vals);
-        }
-
-        Mat m(valsList.size(), valsList[0].size(), CV_32FC1);
-        for (int i=0; i<valsList.size(); i++)
-            for (int j=0; j<valsList[i].size(); j++)
-                m.at<float>(i,j) = valsList[i][j];
-
-        if (isUChar) m.convertTo(m, CV_8U);
-        return Template(m);
-    }
-
-    void write(const Template &t) const
-    {
-        const Mat &m = t.m();
-        if (t.size() != 1) qFatal("Only supports single matrix templates.");
-        if (m.channels() != 1) qFatal("Only supports single channel matrices.");
-
-        QStringList lines; lines.reserve(m.rows);
-        for (int r=0; r<m.rows; r++) {
-            QStringList elements; elements.reserve(m.cols);
-            for (int c=0; c<m.cols; c++)
-                elements.append(OpenCVUtils::elemToString(m, r, c));
-            lines.append(elements.join(","));
-        }
-
-        QtUtils::writeFile(file, lines);
-    }
-};
-
-BR_REGISTER(Format, csvFormat)
-
-/*!
- * \ingroup formats
- * \brief Reads image files.
- * \author Josh Klontz \cite jklontz
- */
-class DefaultFormat : public Format
-{
-    Q_OBJECT
-
-    Template read() const
-    {
-        Template t;
-
-        if (file.name.startsWith("http://") || file.name.startsWith("https://") || file.name.startsWith("www.")) {
-            if (Factory<Format>::names().contains("url")) {
-                File urlFile = file;
-                urlFile.name.append(".url");
-                QScopedPointer<Format> url(Factory<Format>::make(urlFile));
-                t = url->read();
-            }
-        } else {
-            Mat m = imread(file.resolved().toStdString());
-            if (m.data) {
-                t.append(m);
-            } else {
-                videoFormat videoReader;
-                videoReader.file = file;
-                t = videoReader.read();
-            }
-        }
-
-        return t;
-    }
-
-    void write(const Template &t) const
-    {
-        if (t.size() > 1) {
-            videoFormat videoWriter;
-            videoWriter.file = file;
-            videoWriter.write(t);
-        } else if (t.size() == 1) {
-            QtUtils::touchDir(QDir(file.path()));
-            imwrite(file.name.toStdString(), t);
-        }
-    }
-};
-
-BR_REGISTER(Format, DefaultFormat)
-
-/*!
- * \ingroup formats
- * \brief Reads a NIST LFFS file.
- * \author Josh Klontz \cite jklontz
- */
-class lffsFormat : public Format
-{
-    Q_OBJECT
-
-    Template read() const
-    {
-        QByteArray byteArray;
-        QtUtils::readFile(file.name, byteArray);
-        return Mat(1, byteArray.size(), CV_8UC1, byteArray.data()).clone();
-    }
-
-    void write(const Template &t) const
-    {
-        QByteArray byteArray((const char*)t.m().data, t.m().total()*t.m().elemSize());
-        QtUtils::writeFile(file.name, byteArray);
-    }
-};
-
-BR_REGISTER(Format, lffsFormat)
-
-/*!
- * \ingroup formats
- * \brief Reads a NIST BEE similarity matrix.
- * \author Josh Klontz \cite jklontz
- */
-class mtxFormat : public Format
-{
-    Q_OBJECT
-
-    Template read() const
-    {
-        QString target, query;
-        Template result = BEE::readMatrix(file, &target, &query);
-        result.file.set("Target", target);
-        result.file.set("Query", query);
-        return result;
-    }
-
-    void write(const Template &t) const
-    {
-        BEE::writeMatrix(t, file);
-    }
-};
-
-BR_REGISTER(Format, mtxFormat)
-
-/*!
- * \ingroup formats
- * \brief Reads a NIST BEE mask matrix.
- * \author Josh Klontz \cite jklontz
- */
-class maskFormat : public mtxFormat
-{
-    Q_OBJECT
-};
-
-BR_REGISTER(Format, maskFormat)
-
-/*!
- * \ingroup formats
- * \brief MATLAB <tt>.mat</tt> format.
- * \author Josh Klontz \cite jklontz
- * http://www.mathworks.com/help/pdf_doc/matlab/matfile_format.pdf
- * \note matFormat is known not to work with compressed matrices
- */
-class matFormat : public Format
-{
-    Q_OBJECT
-
-    struct Element
-    {
-        // It is always best to cast integers to a Qt integer type, such as qint16 or quint32, when reading and writing.
-        // This ensures that you always know exactly what size integers you are reading and writing, no matter what the
-        // underlying platform and architecture the application happens to be running on.
-        // http://qt-project.org/doc/qt-4.8/datastreamformat.html
-        quint32 type, bytes;
-        QByteArray data;
-        Element() : type(0), bytes(0) {}
-        Element(QDataStream &stream)
-            : type(0), bytes(0)
-        {
-            // Read first 4 bytes into type (32 bit integer),
-            // specifying the type of data used
-            if (stream.readRawData((char*)&type, 4) != 4)
-                qFatal("Unexpected end of file.");
-
-            if (type >= 1 << 16) {
-                // Small data format
-                bytes = type;
-                type = type & 0x0000FFFF;
-                bytes = bytes >> 16;
-            } else {
-                // Regular format
-                // Read 4 bytes into bytes (32 bit integer),
-                // specifying the size of the element
-                if (stream.readRawData((char*)&bytes, 4) != 4)
-                    qFatal("Unexpected end of file.");
-            }
-
-            // Set the size of data to bytes
-            data.resize(bytes);
-
-            // Read bytes amount of data from the file into data
-            if (int(bytes) != stream.readRawData(data.data(), bytes))
-                qFatal("Unexpected end of file.");
-
-            // Alignment
-            int skipBytes = (bytes < 4) ? (4 - bytes) : (8 - bytes%8)%8;
-            if (skipBytes != 0) stream.skipRawData(skipBytes);
-        }
-    };
-
-    Template read() const
-    {
-        QByteArray byteArray;
-        QtUtils::readFile(file, byteArray);
-        QDataStream f(byteArray);
-
-        { // Check header
-            QByteArray header(128, 0);
-            f.readRawData(header.data(), 128);
-            if (!header.startsWith("MATLAB 5.0 MAT-file"))
-                qFatal("Invalid MAT header.");
-        }
-
-        Template t(file);
-
-        while (!f.atEnd()) {
-            Element element(f);
-
-            // miCOMPRESSED
-            if (element.type == 15) {
-                // Prepend the number of bytes to element.data
-                element.data.prepend((char*)&element.bytes, 4); // Qt zlib wrapper requires this to preallocate the buffer
-                QDataStream uncompressed(qUncompress(element.data));
-                element = Element(uncompressed);
-            }
-
-            // miMATRIX
-            if (element.type == 14) {
-                QDataStream matrix(element.data);
-                qint32 rows = 0, columns = 0;
-                int matrixType = 0;
-                QByteArray matrixData;
-                while (!matrix.atEnd()) {
-                    Element subelement(matrix);
-                    if (subelement.type == 5) { // Dimensions array
-                        if (subelement.bytes == 8) {
-                            rows = ((qint32*)subelement.data.data())[0];
-                            columns = ((qint32*)subelement.data.data())[1];
-                        } else {
-                            qWarning("matFormat::read can only handle 2D arrays.");
-                        }
-                    } else if (subelement.type == 7) { //miSINGLE
-                        matrixType = CV_32FC1;
-                        matrixData = subelement.data;
-                    } else if (subelement.type == 9) { //miDOUBLE
-                        matrixType = CV_64FC1;
-                        matrixData = subelement.data;
-                    }
-                }
-
-                if ((rows > 0) && (columns > 0) && (matrixType != 0) && !matrixData.isEmpty()) {
-                    Mat transposed;
-                    transpose(Mat(columns, rows, matrixType, matrixData.data()), transposed);
-                    t.append(transposed);
-                }
-            }
-        }
-
-        return t;
-    }
-
-    void write(const Template &t) const
-    {
-        QByteArray data;
-        QDataStream stream(&data, QFile::WriteOnly);
-
-        { // Header
-            QByteArray header = "MATLAB 5.0 MAT-file; Made with OpenBR | www.openbiometrics.org\n";
-            QByteArray buffer(116-header.size(), 0);
-            stream.writeRawData(header.data(), header.size());
-            stream.writeRawData(buffer.data(), buffer.size());
-            quint64 subsystem = 0;
-            quint16 version = 0x0100;
-            const char *endianness = "IM";
-            stream.writeRawData((const char*)&subsystem, 8);
-            stream.writeRawData((const char*)&version, 2);
-            stream.writeRawData(endianness, 2);
-        }
-
-        for (int i=0; i<t.size(); i++) {
-            const Mat &m = t[i];
-            if (m.channels() != 1) qFatal("Only supports single channel matrices.");
-
-            QByteArray subdata;
-            QDataStream substream(&subdata, QFile::WriteOnly);
-
-            {  // Array Flags
-                quint32 type = 6;
-                quint32 bytes = 8;
-                quint64 arrayClass = 0;
-                switch (m.type()) {
-                  case CV_64FC1: arrayClass = 6; break;
-                  case CV_32FC1: arrayClass = 7; break;
-                  case CV_8UC1: arrayClass = 8; break;
-                  case CV_8SC1: arrayClass = 9; break;
-                  case CV_16UC1: arrayClass = 10; break;
-                  case CV_16SC1: arrayClass = 11; break;
-                  case CV_32SC1: arrayClass = 12; break;
-                  default: qFatal("Unsupported matrix class.");
-                }
-                substream.writeRawData((const char*)&type, 4);
-                substream.writeRawData((const char*)&bytes, 4);
-                substream.writeRawData((const char*)&arrayClass, 8);
-            }
-
-            { // Dimensions Array
-                quint32 type = 5;
-                quint32 bytes = 8;
-                substream.writeRawData((const char*)&type, 4);
-                substream.writeRawData((const char*)&bytes, 4);
-                substream.writeRawData((const char*)&m.rows, 4);
-                substream.writeRawData((const char*)&m.cols, 4);
-            }
-
-            { // Array Name
-                QByteArray name(qPrintable(QString("OpenBR_%1").arg(QString::number(i))));
-                quint32 type = 1;
-                quint32 bytes = name.size();
-                QByteArray buffer((8 - bytes%8)%8, 0);
-                substream.writeRawData((const char*)&type, 4);
-                substream.writeRawData((const char*)&bytes, 4);
-                substream.writeRawData(name.data(), name.size());
-                substream.writeRawData(buffer.data(), buffer.size());
-            }
-
-            { // Real part
-                quint32 type = 0;
-                switch (m.type()) {
-                  case CV_8SC1:  type = 1; break;
-                  case CV_8UC1:  type = 2; break;
-                  case CV_16SC1: type = 3; break;
-                  case CV_16UC1: type = 4; break;
-                  case CV_32SC1: type = 5; break;
-                  case CV_32FC1: type = 7; break;
-                  case CV_64FC1: type = 9; break;
-                  default: qFatal("Unsupported matrix type.");
-                }
-                quint32 bytes = m.elemSize() * m.rows * m.cols;
-                QByteArray buffer((8 - bytes%8)%8, 0);
-                Mat transposed;
-                transpose(m, transposed);
-                substream.writeRawData((const char*)&type, 4);
-                substream.writeRawData((const char*)&bytes, 4);
-                substream.writeRawData((const char*)transposed.data, bytes);
-                substream.writeRawData(buffer.data(), buffer.size());
-            }
-
-            { // Matrix
-                quint32 type = 14;
-                quint32 bytes = subdata.size();
-                stream.writeRawData((const char*)&type, 4);
-                stream.writeRawData((const char*)&bytes, 4);
-                stream.writeRawData(subdata.data(), subdata.size());
-            }
-        }
-
-        QtUtils::writeFile(file, data);
-    }
-};
-
-BR_REGISTER(Format, matFormat)
-
-/*!
- * \ingroup formats
- * \brief Returns an empty matrix.
- * \author Josh Klontz \cite jklontz
- */
-class nullFormat : public Format
-{
-    Q_OBJECT
-
-    Template read() const
-    {
-        return Template(file, Mat());
-    }
-
-    void write(const Template &t) const
-    {
-        (void)t;
-    }
-};
-
-BR_REGISTER(Format, nullFormat)
-
-/*!
- * \ingroup formats
- * \brief RAW format
- *
- * http://www.nist.gov/srd/nistsd27.cfm
- * \author Josh Klontz \cite jklontz
- */
-class rawFormat : public Format
-{
-    Q_OBJECT
-    static QHash<QString, QHash<QString,QSize> > imageSizes; // QHash<Path, QHash<File,Size> >
-
-    Template read() const
-    {
-        QString path = file.path();
-        if (!imageSizes.contains(path)) {
-            static QMutex mutex;
-            QMutexLocker locker(&mutex);
-
-            if (!imageSizes.contains(path)) {
-                const QString imageSize = path+"/ImageSize.txt";
-                QStringList lines;
-                if (QFileInfo(imageSize).exists()) {
-                    lines = QtUtils::readLines(imageSize);
-                    lines.removeFirst(); // Remove header
-                }
-
-                QHash<QString,QSize> sizes;
-                QRegExp whiteSpace("\\s+");
-                foreach (const QString &line, lines) {
-                    QStringList words = line.split(whiteSpace);
-                    if (words.size() != 3) continue;
-                    sizes.insert(words[0], QSize(words[2].toInt(), words[1].toInt()));
-                }
-
-                imageSizes.insert(path, sizes);
-            }
-        }
-
-        QByteArray data;
-        QtUtils::readFile(file, data);
-
-        QSize size = imageSizes[path][file.baseName()];
-        if (!size.isValid()) size = QSize(800,768);
-        if (data.size() != size.width() * size.height())
-            qFatal("Expected %d*%d bytes, got %d.", size.height(), size.width(), data.size());
-        return Template(file, Mat(size.height(), size.width(), CV_8UC1, data.data()).clone());
-    }
-
-    void write(const Template &t) const
-    {
-        QtUtils::writeFile(file, QByteArray().setRawData((const char*)t.m().data, t.m().total() * t.m().elemSize()));
-    }
-};
-
-QHash<QString, QHash<QString,QSize> > rawFormat::imageSizes;
-
-BR_REGISTER(Format, rawFormat)
-
-/*!
- * \ingroup formats
- * \brief Retrieves an image from a webcam.
- * \author Josh Klontz \cite jklontz
- */
-class webcamFormat : public Format
-{
-    Q_OBJECT
-
-    Template read() const
-    {
-        static QScopedPointer<VideoCapture> videoCapture;
-
-        if (videoCapture.isNull())
-            videoCapture.reset(new VideoCapture(0));
-
-        Mat m;
-        videoCapture->read(m);
-        return Template(m);
-    }
-
-    void write(const Template &t) const
-    {
-        (void) t;
-        qFatal("Not supported.");
-    }
-};
-
-BR_REGISTER(Format, webcamFormat)
-
-/*!
- * \ingroup formats
- * \brief Decodes images from Base64 xml
- * \author Scott Klum \cite sklum
- * \author Josh Klontz \cite jklontz
- */
-class xmlFormat : public Format
-{
-    Q_OBJECT
-
-    Template read() const
-    {
-        Template t;
-
-#ifndef BR_EMBEDDED
-        QString fileName = file.get<QString>("path") + file.name;
-
-        QDomDocument doc(fileName);
-        QFile f(fileName);
-
-        if (!f.open(QIODevice::ReadOnly)) qFatal("Unable to open %s for reading.", qPrintable(file.flat()));
-        if (!doc.setContent(&f)) qWarning("Unable to parse %s.", qPrintable(file.flat()));
-        f.close();
-
-        QDomElement docElem = doc.documentElement();
-        QDomNode subject = docElem.firstChild();
-        while (!subject.isNull()) {
-            QDomNode fileNode = subject.firstChild();
-
-            while (!fileNode.isNull()) {
-                QDomElement e = fileNode.toElement();
-
-                if (e.tagName() == "FORMAL_IMG") {
-                    QByteArray byteArray = QByteArray::fromBase64(qPrintable(e.text()));
-                    Mat m = imdecode(Mat(3, byteArray.size(), CV_8UC3, byteArray.data()), CV_LOAD_IMAGE_COLOR);
-                    if (!m.data) qWarning("xmlFormat::read failed to decode image data.");
-                    t.append(m);
-                } else if ((e.tagName() == "RELEASE_IMG") ||
-                           (e.tagName() == "PREBOOK_IMG") ||
-                           (e.tagName() == "LPROFILE") ||
-                           (e.tagName() == "RPROFILE")) {
-                    // Ignore these other image fields for now
-                } else {
-                    t.file.set(e.tagName(), e.text());
-                }
-
-                fileNode = fileNode.nextSibling();
-            }
-            subject = subject.nextSibling();
-        }
-
-        // Calculate age
-        if (t.file.contains("DOB")) {
-            const QDate dob = QDate::fromString(t.file.get<QString>("DOB").left(10), "yyyy-MM-dd");
-            const QDate current = QDate::currentDate();
-            int age = current.year() - dob.year();
-            if (current.month() < dob.month()) age--;
-            t.file.set("Age", age);
-        }
-#endif // BR_EMBEDDED
-
-        return t;
-    }
-
-    void write(const Template &t) const
-    {
-        QStringList lines;
-        lines.append("<?xml version=\"1.0\" standalone=\"yes\"?>");
-        lines.append("<openbr-xml-format>");
-        lines.append("\t<xml-data>");
-        foreach (const QString &key, t.file.localKeys()) {
-            if ((key == "Index") || (key == "Label")) continue;
-            lines.append("\t\t<"+key+">"+QtUtils::toString(t.file.value(key))+"</"+key+">");
-        }
-        std::vector<uchar> data;
-        imencode(".jpg",t.m(),data);
-        QByteArray byteArray = QByteArray::fromRawData((const char*)data.data(), data.size());
-        lines.append("\t\t<FORMAL_IMG>"+byteArray.toBase64()+"</FORMAL_IMG>");
-        lines.append("\t</xml-data>");
-        lines.append("</openbr-xml-format>");
-        QtUtils::writeFile(file, lines);
-    }
-};
-
-BR_REGISTER(Format, xmlFormat)
-
-/*!
- * \ingroup formats
- * \brief Reads in scores or ground truth from a text table.
- * \author Josh Klontz \cite jklontz
- *
- * Example of the format:
- * \code
- * 2.2531514    FALSE   99990377    99990164
- * 2.2549822    TRUE    99990101    99990101
- * \endcode
- */
-class scoresFormat : public Format
-{
-    Q_OBJECT
-    Q_PROPERTY(int column READ get_column WRITE set_column RESET reset_column STORED false)
-    Q_PROPERTY(bool groundTruth READ get_groundTruth WRITE set_groundTruth RESET reset_groundTruth STORED false)
-    Q_PROPERTY(QString delimiter READ get_delimiter WRITE set_delimiter RESET reset_delimiter STORED false)
-    BR_PROPERTY(int, column, 0)
-    BR_PROPERTY(bool, groundTruth, false)
-    BR_PROPERTY(QString, delimiter, "\t")
-
-    Template read() const
-    {
-        QFile f(file.name);
-        if (!f.open(QFile::ReadOnly | QFile::Text))
-            qFatal("Failed to open %s for reading.", qPrintable(f.fileName()));
-        QList<float> values;
-        while (!f.atEnd()) {
-            const QStringList words = QString(f.readLine()).split(delimiter);
-            if (words.size() <= column) qFatal("Expected file to have at least %d columns.", column+1);
-            const QString &word = words[column];
-            bool ok;
-            float value = word.toFloat(&ok);
-            if (!ok) value = (QtUtils::toBool(word) ? BEE::Match : BEE::NonMatch);
-            values.append(value);
-        }
-        if (values.size() == 1)
-            qWarning("Only one value read, double check file line endings.");
-        Mat result = OpenCVUtils::toMat(values);
-        if (groundTruth) result.convertTo(result, CV_8U);
-        return result;
-    }
-
-    void write(const Template &t) const
-    {
-        (void) t;
-        qFatal("Not implemented.");
-    }
-};
-
-BR_REGISTER(Format, scoresFormat)
-
-/*!
- * \ingroup formats
- * \brief Reads FBI EBTS transactions.
- * \author Scott Klum \cite sklum
- * https://www.fbibiospecs.org/ebts.html
- */
-class ebtsFormat : public Format
-{
-    Q_OBJECT
-
-    struct Field {
-        int type;
-        QList<QByteArray> data;
-    };
-
-    struct Record {
-        int type;
-        quint32 bytes;
-        int position; // Starting position of record
-
-        QHash<int,QList<QByteArray> > fields;
-    };
-
-    quint32 recordBytes(const QByteArray &byteArray, const float recordType, int from) const
-    {
-        bool ok;
-        quint32 size;
-
-        if (recordType == 4 || recordType == 7) {
-            // read first four bytes
-            ok = true;
-            size = qFromBigEndian<quint32>((const uchar*)byteArray.mid(from,4).constData());
-        } else {
-            int index = byteArray.indexOf(QChar(0x1D), from);
-            size = byteArray.mid(from, index-from).split(':').last().toInt(&ok);
-        }
-
-        return ok ? size : -1;
-    }
-
-    void parseRecord(const QByteArray &byteArray, Record &record) const
-    {
-        if (record.type == 4 || record.type == 7) {
-            // Just a binary blob
-            // Read everything after the first four bytes
-            // Not current supported
-        } else {
-            // Continue reading fields until we get all the data
-            unsigned int position = record.position;
-            while (position < record.position + record.bytes) {
-                int index = byteArray.indexOf(QChar(0x1D), position);
-                Field field = parseField(byteArray.mid(position, index-position),QChar(0x1F));
-                if (field.type == 999 ) {
-                    // Data begin after the field identifier and the colon
-                    int dataBegin = byteArray.indexOf(':', position)+1;
-                    field.data.clear();
-                    field.data.append(byteArray.mid(dataBegin, record.bytes-(dataBegin-record.position)));
-
-                    // Data fields are always last in the record
-                    record.fields.insert(field.type,field.data);
-                    break;
-                }
-                // Advance the position accounting for the separator
-                position += index-position+1;
-                record.fields.insert(field.type,field.data);
-            }
-        }
-    }
-
-    Field parseField(const QByteArray &byteArray, const QChar &sep) const
-    {
-        bool ok;
-        Field f;
-
-        QList<QByteArray> data = byteArray.split(':');
-
-        f.type = data.first().split('.').last().toInt(&ok);
-        f.data = data.last().split(sep.toLatin1());
-
-        return f;
-    }
-
-    Template read() const
-    {
-        QByteArray byteArray;
-        QtUtils::readFile(file, byteArray);
-
-        Template t;
-
-        Mat m;
-
-        QList<Record> records;
-
-        // Read the type one record (every EBTS file will have one of these)
-        Record r1;
-        r1.type = 1;
-        r1.position = 0;
-        r1.bytes = recordBytes(byteArray,r1.type,r1.position);
-
-        // The fields in a type 1 record are strictly defined
-        QList<QByteArray> data = byteArray.mid(r1.position,r1.bytes).split(QChar(0x1D).toLatin1());
-        foreach (const QByteArray &datum, data) {
-            Field f = parseField(datum,QChar(0x1F));
-            r1.fields.insert(f.type,f.data);
-        }
-
-        records.append(r1);
-
-        // Read the type two record (every EBTS file will have one of these)
-        Record r2;
-        r2.type = 2;
-        r2.position = r1.bytes;
-        r2.bytes = recordBytes(byteArray,r2.type,r2.position);
-
-        // The fields in a type 2 record are strictly defined
-        data = byteArray.mid(r2.position,r2.bytes).split(QChar(0x1D).toLatin1());
-        foreach (const QByteArray &datum, data) {
-            Field f = parseField(datum,QChar(0x1F));
-            r2.fields.insert(f.type,f.data);
-        }
-
-        // Demographics
-        if (r2.fields.contains(18)) {
-            QString name = r2.fields.value(18).first();
-            QStringList names = name.split(',');
-            t.file.set("FIRSTNAME", names.at(1));
-            t.file.set("LASTNAME", names.at(0));
-        }
-
-        if (r2.fields.contains(22)) t.file.set("DOB", r2.fields.value(22).first().toInt());
-        if (r2.fields.contains(24)) t.file.set("GENDER", QString(r2.fields.value(24).first()));
-        if (r2.fields.contains(25)) t.file.set("RACE", QString(r2.fields.value(25).first()));
-
-        if (t.file.contains("DOB")) {
-            const QDate dob = QDate::fromString(t.file.get<QString>("DOB"), "yyyyMMdd");
-            const QDate current = QDate::currentDate();
-            int age = current.year() - dob.year();
-            if (current.month() < dob.month()) age--;
-            t.file.set("Age", age);
-        }
-
-        records.append(r2);
-
-        // The third field of the first record contains informations about all the remaining records in the transaction
-        // We don't care about the first two and the final items
-        QList<QByteArray> recordTypes = r1.fields.value(3);
-        for (int i=2; i<recordTypes.size()-1; i++) {
-            // The first two bytes indicate the record index (and we don't want the separator), but we only care about the type
-            QByteArray recordType = recordTypes[i].mid(3);
-            Record r;
-            r.type = recordType.toInt();
-            records.append(r);
-        }
-
-        QList<int> frontalIdxs;
-        int position = r1.bytes + r2.bytes;
-        for (int i=2; i<records.size(); i++) {
-            records[i].position = position;
-            records[i].bytes = recordBytes(byteArray,records[i].type,position);
-
-            parseRecord(byteArray, records[i]);
-            if (records[i].type == 10) frontalIdxs.append(i);
-            position += records[i].bytes;
-        }
-
-        if (!frontalIdxs.isEmpty()) {
-            // We use the first type 10 record to get the frontal
-            QByteArray frontal = records[frontalIdxs.first()].fields.value(999).first();
-            m = imdecode(Mat(3, frontal.size(), CV_8UC3, frontal.data()), CV_LOAD_IMAGE_COLOR);
-            if (!m.data) qWarning("ebtsFormat::read failed to decode image data.");
-            t.m() = m;
-        } else qWarning("ebtsFormat::cannot find image data within file.");
-
-        return t;
-    }
-
-    void write(const Template &t) const
-    {
-        (void) t;
-        qFatal("Writing EBTS files is not supported.");
-    }
-};
-
-BR_REGISTER(Format, ebtsFormat)
-
-} // namespace br
-
-#include "format.moc"
diff --git a/openbr/plugins/format/binary.cpp b/openbr/plugins/format/binary.cpp
new file mode 100644
index 0000000..1438cb3
--- /dev/null
+++ b/openbr/plugins/format/binary.cpp
@@ -0,0 +1,86 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * Copyright 2012 The MITRE Corporation                                      *
+ *                                                                           *
+ * Licensed under the Apache License, Version 2.0 (the "License");           *
+ * you may not use this file except in compliance with the License.          *
+ * You may obtain a copy of the License at                                   *
+ *                                                                           *
+ *     http://www.apache.org/licenses/LICENSE-2.0                            *
+ *                                                                           *
+ * Unless required by applicable law or agreed to in writing, software       *
+ * distributed under the License is distributed on an "AS IS" BASIS,         *
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  *
+ * See the License for the specific language governing permissions and       *
+ * limitations under the License.                                            *
+ * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+
+#include <openbr/plugins/openbr_internal.h>
+#include <openbr/core/qtutils.h>
+
+using namespace cv;
+
+namespace br
+{
+
+/*!
+ * \ingroup formats
+ * \brief A simple binary matrix format.
+ * \author Josh Klontz \cite jklontz
+ * First 4 bytes indicate the number of rows.
+ * Second 4 bytes indicate the number of columns.
+ * The rest of the bytes are 32-bit floating data elements in row-major order.
+ */
+class binaryFormat : public Format
+{
+    Q_OBJECT
+    Q_PROPERTY(bool raw READ get_raw WRITE set_raw RESET reset_raw STORED false)
+    BR_PROPERTY(bool, raw, false)
+
+    Template read() const
+    {
+        QByteArray data;
+        QtUtils::readFile(file, data);
+        if (raw) {
+            return Template(file, Mat(1, data.size(), CV_8UC1, data.data()).clone());
+        } else {
+            return Template(file, Mat(((quint32*)data.data())[0],
+                                      ((quint32*)data.data())[1],
+                                      CV_32FC1,
+                                      data.data()+8).clone());
+        }
+    }
+
+    void write(const Template &t) const
+    {
+        QFile f(file);
+        QtUtils::touchDir(f);
+        if (!f.open(QFile::WriteOnly))
+            qFatal("Failed to open %s for writing.", qPrintable(file));
+
+        Mat m;
+        if (!raw) {
+            if (t.m().type() != CV_32FC1)
+                t.m().convertTo(m, CV_32F);
+            else m = t.m();
+
+            if (m.channels() != 1) qFatal("Only supports single channel matrices.");
+
+            f.write((const char *) &m.rows, 4);
+            f.write((const char *) &m.cols, 4);
+        }
+        else m =  t.m();
+
+        qint64 rowSize = m.cols * sizeof(float);
+        for (int i=0; i < m.rows; i++)
+        {
+            f.write((const char *) m.row(i).data, rowSize);
+        }
+        f.close();
+    }
+};
+
+BR_REGISTER(Format, binaryFormat)
+
+} // namespace br
+
+#include "format/binary.moc"
diff --git a/openbr/plugins/format/csv.cpp b/openbr/plugins/format/csv.cpp
new file mode 100644
index 0000000..6bcad6e
--- /dev/null
+++ b/openbr/plugins/format/csv.cpp
@@ -0,0 +1,89 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * Copyright 2012 The MITRE Corporation                                      *
+ *                                                                           *
+ * Licensed under the Apache License, Version 2.0 (the "License");           *
+ * you may not use this file except in compliance with the License.          *
+ * You may obtain a copy of the License at                                   *
+ *                                                                           *
+ *     http://www.apache.org/licenses/LICENSE-2.0                            *
+ *                                                                           *
+ * Unless required by applicable law or agreed to in writing, software       *
+ * distributed under the License is distributed on an "AS IS" BASIS,         *
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  *
+ * See the License for the specific language governing permissions and       *
+ * limitations under the License.                                            *
+ * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+
+#include <QRegularExpression>
+
+#include <openbr/plugins/openbr_internal.h>
+#include <openbr/core/opencvutils.h>
+#include <openbr/core/qtutils.h>
+
+using namespace cv;
+
+namespace br
+{
+
+/*!
+ * \ingroup formats
+ * \brief Reads a comma separated value file.
+ * \author Josh Klontz \cite jklontz
+ */
+class csvFormat : public Format
+{
+    Q_OBJECT
+
+    Template read() const
+    {
+        QFile f(file.name);
+        f.open(QFile::ReadOnly);
+        QStringList lines(QString(f.readAll()).split(QRegularExpression("[\n|\r\n|\r]"), QString::SkipEmptyParts));
+        f.close();
+
+        bool isUChar = true;
+        QList< QList<float> > valsList;
+        foreach (const QString &line, lines) {
+            QList<float> vals;
+            foreach (const QString &word, line.split(QRegExp(" *, *"), QString::SkipEmptyParts)) {
+                bool ok;
+                const float val = word.toFloat(&ok);
+                vals.append(val);
+                isUChar = isUChar && (val == float(uchar(val)));
+            }
+            if (!vals.isEmpty())
+                valsList.append(vals);
+        }
+
+        Mat m(valsList.size(), valsList[0].size(), CV_32FC1);
+        for (int i=0; i<valsList.size(); i++)
+            for (int j=0; j<valsList[i].size(); j++)
+                m.at<float>(i,j) = valsList[i][j];
+
+        if (isUChar) m.convertTo(m, CV_8U);
+        return Template(m);
+    }
+
+    void write(const Template &t) const
+    {
+        const Mat &m = t.m();
+        if (t.size() != 1) qFatal("Only supports single matrix templates.");
+        if (m.channels() != 1) qFatal("Only supports single channel matrices.");
+
+        QStringList lines; lines.reserve(m.rows);
+        for (int r=0; r<m.rows; r++) {
+            QStringList elements; elements.reserve(m.cols);
+            for (int c=0; c<m.cols; c++)
+                elements.append(OpenCVUtils::elemToString(m, r, c));
+            lines.append(elements.join(","));
+        }
+
+        QtUtils::writeFile(file, lines);
+    }
+};
+
+BR_REGISTER(Format, csvFormat)
+
+} // namespace br
+
+#include "format/csv.moc"
diff --git a/openbr/plugins/format/ebts.cpp b/openbr/plugins/format/ebts.cpp
new file mode 100644
index 0000000..b22f62b
--- /dev/null
+++ b/openbr/plugins/format/ebts.cpp
@@ -0,0 +1,215 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * Copyright 2012 The MITRE Corporation                                      *
+ *                                                                           *
+ * Licensed under the Apache License, Version 2.0 (the "License");           *
+ * you may not use this file except in compliance with the License.          *
+ * You may obtain a copy of the License at                                   *
+ *                                                                           *
+ *     http://www.apache.org/licenses/LICENSE-2.0                            *
+ *                                                                           *
+ * Unless required by applicable law or agreed to in writing, software       *
+ * distributed under the License is distributed on an "AS IS" BASIS,         *
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  *
+ * See the License for the specific language governing permissions and       *
+ * limitations under the License.                                            *
+ * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+
+#include <QtEndian>
+#include <opencv2/highgui/highgui.hpp>
+
+#include <openbr/plugins/openbr_internal.h>
+#include <openbr/core/qtutils.h>
+
+using namespace cv;
+
+namespace br
+{
+
+/*!
+ * \ingroup formats
+ * \brief Reads FBI EBTS transactions.
+ * \author Scott Klum \cite sklum
+ * https://www.fbibiospecs.org/ebts.html
+ */
+class ebtsFormat : public Format
+{
+    Q_OBJECT
+
+    struct Field {
+        int type;
+        QList<QByteArray> data;
+    };
+
+    struct Record {
+        int type;
+        quint32 bytes;
+        int position; // Starting position of record
+
+        QHash<int,QList<QByteArray> > fields;
+    };
+
+    quint32 recordBytes(const QByteArray &byteArray, const float recordType, int from) const
+    {
+        bool ok;
+        quint32 size;
+
+        if (recordType == 4 || recordType == 7) {
+            // read first four bytes
+            ok = true;
+            size = qFromBigEndian<quint32>((const uchar*)byteArray.mid(from,4).constData());
+        } else {
+            int index = byteArray.indexOf(QChar(0x1D), from);
+            size = byteArray.mid(from, index-from).split(':').last().toInt(&ok);
+        }
+
+        return ok ? size : -1;
+    }
+
+    void parseRecord(const QByteArray &byteArray, Record &record) const
+    {
+        if (record.type == 4 || record.type == 7) {
+            // Just a binary blob
+            // Read everything after the first four bytes
+            // Not current supported
+        } else {
+            // Continue reading fields until we get all the data
+            unsigned int position = record.position;
+            while (position < record.position + record.bytes) {
+                int index = byteArray.indexOf(QChar(0x1D), position);
+                Field field = parseField(byteArray.mid(position, index-position),QChar(0x1F));
+                if (field.type == 999 ) {
+                    // Data begin after the field identifier and the colon
+                    int dataBegin = byteArray.indexOf(':', position)+1;
+                    field.data.clear();
+                    field.data.append(byteArray.mid(dataBegin, record.bytes-(dataBegin-record.position)));
+
+                    // Data fields are always last in the record
+                    record.fields.insert(field.type,field.data);
+                    break;
+                }
+                // Advance the position accounting for the separator
+                position += index-position+1;
+                record.fields.insert(field.type,field.data);
+            }
+        }
+    }
+
+    Field parseField(const QByteArray &byteArray, const QChar &sep) const
+    {
+        bool ok;
+        Field f;
+
+        QList<QByteArray> data = byteArray.split(':');
+
+        f.type = data.first().split('.').last().toInt(&ok);
+        f.data = data.last().split(sep.toLatin1());
+
+        return f;
+    }
+
+    Template read() const
+    {
+        QByteArray byteArray;
+        QtUtils::readFile(file, byteArray);
+
+        Template t;
+
+        Mat m;
+
+        QList<Record> records;
+
+        // Read the type one record (every EBTS file will have one of these)
+        Record r1;
+        r1.type = 1;
+        r1.position = 0;
+        r1.bytes = recordBytes(byteArray,r1.type,r1.position);
+
+        // The fields in a type 1 record are strictly defined
+        QList<QByteArray> data = byteArray.mid(r1.position,r1.bytes).split(QChar(0x1D).toLatin1());
+        foreach (const QByteArray &datum, data) {
+            Field f = parseField(datum,QChar(0x1F));
+            r1.fields.insert(f.type,f.data);
+        }
+
+        records.append(r1);
+
+        // Read the type two record (every EBTS file will have one of these)
+        Record r2;
+        r2.type = 2;
+        r2.position = r1.bytes;
+        r2.bytes = recordBytes(byteArray,r2.type,r2.position);
+
+        // The fields in a type 2 record are strictly defined
+        data = byteArray.mid(r2.position,r2.bytes).split(QChar(0x1D).toLatin1());
+        foreach (const QByteArray &datum, data) {
+            Field f = parseField(datum,QChar(0x1F));
+            r2.fields.insert(f.type,f.data);
+        }
+
+        // Demographics
+        if (r2.fields.contains(18)) {
+            QString name = r2.fields.value(18).first();
+            QStringList names = name.split(',');
+            t.file.set("FIRSTNAME", names.at(1));
+            t.file.set("LASTNAME", names.at(0));
+        }
+
+        if (r2.fields.contains(22)) t.file.set("DOB", r2.fields.value(22).first().toInt());
+        if (r2.fields.contains(24)) t.file.set("GENDER", QString(r2.fields.value(24).first()));
+        if (r2.fields.contains(25)) t.file.set("RACE", QString(r2.fields.value(25).first()));
+
+        if (t.file.contains("DOB")) {
+            const QDate dob = QDate::fromString(t.file.get<QString>("DOB"), "yyyyMMdd");
+            const QDate current = QDate::currentDate();
+            int age = current.year() - dob.year();
+            if (current.month() < dob.month()) age--;
+            t.file.set("Age", age);
+        }
+
+        records.append(r2);
+
+        // The third field of the first record contains informations about all the remaining records in the transaction
+        // We don't care about the first two and the final items
+        QList<QByteArray> recordTypes = r1.fields.value(3);
+        for (int i=2; i<recordTypes.size()-1; i++) {
+            // The first two bytes indicate the record index (and we don't want the separator), but we only care about the type
+            QByteArray recordType = recordTypes[i].mid(3);
+            Record r;
+            r.type = recordType.toInt();
+            records.append(r);
+        }
+
+        QList<int> frontalIdxs;
+        int position = r1.bytes + r2.bytes;
+        for (int i=2; i<records.size(); i++) {
+            records[i].position = position;
+            records[i].bytes = recordBytes(byteArray,records[i].type,position);
+
+            parseRecord(byteArray, records[i]);
+            if (records[i].type == 10) frontalIdxs.append(i);
+            position += records[i].bytes;
+        }
+
+        if (!frontalIdxs.isEmpty()) {
+            // We use the first type 10 record to get the frontal
+            QByteArray frontal = records[frontalIdxs.first()].fields.value(999).first();
+            m = imdecode(Mat(3, frontal.size(), CV_8UC3, frontal.data()), CV_LOAD_IMAGE_COLOR);
+            if (!m.data) qWarning("ebtsFormat::read failed to decode image data.");
+            t.m() = m;
+        } else qWarning("ebtsFormat::cannot find image data within file.");
+
+        return t;
+    }
+
+    void write(const Template &t) const
+    {
+        (void) t;
+        qFatal("Writing EBTS files is not supported.");
+    }
+};
+
+BR_REGISTER(Format, ebtsFormat)
+
+} // namespace br
+
+#include "format/ebts.moc"
diff --git a/openbr/plugins/format/lffs.cpp b/openbr/plugins/format/lffs.cpp
new file mode 100644
index 0000000..240fe2b
--- /dev/null
+++ b/openbr/plugins/format/lffs.cpp
@@ -0,0 +1,52 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * Copyright 2012 The MITRE Corporation                                      *
+ *                                                                           *
+ * Licensed under the Apache License, Version 2.0 (the "License");           *
+ * you may not use this file except in compliance with the License.          *
+ * You may obtain a copy of the License at                                   *
+ *                                                                           *
+ *     http://www.apache.org/licenses/LICENSE-2.0                            *
+ *                                                                           *
+ * Unless required by applicable law or agreed to in writing, software       *
+ * distributed under the License is distributed on an "AS IS" BASIS,         *
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  *
+ * See the License for the specific language governing permissions and       *
+ * limitations under the License.                                            *
+ * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+
+#include <openbr/plugins/openbr_internal.h>
+#include <openbr/core/qtutils.h>
+
+using namespace cv;
+
+namespace br
+{
+
+/*!
+ * \ingroup formats
+ * \brief Reads a NIST LFFS file.
+ * \author Josh Klontz \cite jklontz
+ */
+class lffsFormat : public Format
+{
+    Q_OBJECT
+
+    Template read() const
+    {
+        QByteArray byteArray;
+        QtUtils::readFile(file.name, byteArray);
+        return Mat(1, byteArray.size(), CV_8UC1, byteArray.data()).clone();
+    }
+
+    void write(const Template &t) const
+    {
+        QByteArray byteArray((const char*)t.m().data, t.m().total()*t.m().elemSize());
+        QtUtils::writeFile(file.name, byteArray);
+    }
+};
+
+BR_REGISTER(Format, lffsFormat)
+
+} // namespace br
+
+#include "format/lffs.moc"
diff --git a/openbr/plugins/format/lmat.cpp b/openbr/plugins/format/lmat.cpp
new file mode 100644
index 0000000..7bb4e62
--- /dev/null
+++ b/openbr/plugins/format/lmat.cpp
@@ -0,0 +1,37 @@
+#include <openbr/plugins/openbr_internal.h>
+
+namespace br
+{
+
+/*!
+ * \ingroup formats
+ * \brief Likely matrix format
+ *
+ * www.liblikely.org
+ * \author Josh Klontz \cite jklontz
+ */
+class lmatFormat : public Format
+{
+    Q_OBJECT
+
+    Template read() const
+    {
+        const likely_const_mat m = likely_read(qPrintable(file.name), likely_file_guess);
+        const Template result(likelyToOpenCVMat(m));
+        likely_release_mat(m);
+        return result;
+    }
+
+    void write(const Template &t) const
+    {
+        const likely_const_mat m = likelyFromOpenCVMat(t);
+        likely_write(m, qPrintable(file.name));
+        likely_release_mat(m);
+    }
+};
+
+BR_REGISTER(Format, lmatFormat)
+
+} // namespace br
+
+#include "format/lmat.moc"
diff --git a/openbr/plugins/format/mat.cpp b/openbr/plugins/format/mat.cpp
new file mode 100644
index 0000000..f118daf
--- /dev/null
+++ b/openbr/plugins/format/mat.cpp
@@ -0,0 +1,243 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * Copyright 2012 The MITRE Corporation                                      *
+ *                                                                           *
+ * Licensed under the Apache License, Version 2.0 (the "License");           *
+ * you may not use this file except in compliance with the License.          *
+ * You may obtain a copy of the License at                                   *
+ *                                                                           *
+ *     http://www.apache.org/licenses/LICENSE-2.0                            *
+ *                                                                           *
+ * Unless required by applicable law or agreed to in writing, software       *
+ * distributed under the License is distributed on an "AS IS" BASIS,         *
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  *
+ * See the License for the specific language governing permissions and       *
+ * limitations under the License.                                            *
+ * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+
+#include <openbr/plugins/openbr_internal.h>
+#include <openbr/core/qtutils.h>
+
+using namespace cv;
+
+namespace br
+{
+
+/*!
+ * \ingroup formats
+ * \brief MATLAB <tt>.mat</tt> format.
+ * \author Josh Klontz \cite jklontz
+ * http://www.mathworks.com/help/pdf_doc/matlab/matfile_format.pdf
+ * \note matFormat is known not to work with compressed matrices
+ */
+class matFormat : public Format
+{
+    Q_OBJECT
+
+    struct Element
+    {
+        // It is always best to cast integers to a Qt integer type, such as qint16 or quint32, when reading and writing.
+        // This ensures that you always know exactly what size integers you are reading and writing, no matter what the
+        // underlying platform and architecture the application happens to be running on.
+        // http://qt-project.org/doc/qt-4.8/datastreamformat.html
+        quint32 type, bytes;
+        QByteArray data;
+        Element() : type(0), bytes(0) {}
+        Element(QDataStream &stream)
+            : type(0), bytes(0)
+        {
+            // Read first 4 bytes into type (32 bit integer),
+            // specifying the type of data used
+            if (stream.readRawData((char*)&type, 4) != 4)
+                qFatal("Unexpected end of file.");
+
+            if (type >= 1 << 16) {
+                // Small data format
+                bytes = type;
+                type = type & 0x0000FFFF;
+                bytes = bytes >> 16;
+            } else {
+                // Regular format
+                // Read 4 bytes into bytes (32 bit integer),
+                // specifying the size of the element
+                if (stream.readRawData((char*)&bytes, 4) != 4)
+                    qFatal("Unexpected end of file.");
+            }
+
+            // Set the size of data to bytes
+            data.resize(bytes);
+
+            // Read bytes amount of data from the file into data
+            if (int(bytes) != stream.readRawData(data.data(), bytes))
+                qFatal("Unexpected end of file.");
+
+            // Alignment
+            int skipBytes = (bytes < 4) ? (4 - bytes) : (8 - bytes%8)%8;
+            if (skipBytes != 0) stream.skipRawData(skipBytes);
+        }
+    };
+
+    Template read() const
+    {
+        QByteArray byteArray;
+        QtUtils::readFile(file, byteArray);
+        QDataStream f(byteArray);
+
+        { // Check header
+            QByteArray header(128, 0);
+            f.readRawData(header.data(), 128);
+            if (!header.startsWith("MATLAB 5.0 MAT-file"))
+                qFatal("Invalid MAT header.");
+        }
+
+        Template t(file);
+
+        while (!f.atEnd()) {
+            Element element(f);
+
+            // miCOMPRESSED
+            if (element.type == 15) {
+                // Prepend the number of bytes to element.data
+                element.data.prepend((char*)&element.bytes, 4); // Qt zlib wrapper requires this to preallocate the buffer
+                QDataStream uncompressed(qUncompress(element.data));
+                element = Element(uncompressed);
+            }
+
+            // miMATRIX
+            if (element.type == 14) {
+                QDataStream matrix(element.data);
+                qint32 rows = 0, columns = 0;
+                int matrixType = 0;
+                QByteArray matrixData;
+                while (!matrix.atEnd()) {
+                    Element subelement(matrix);
+                    if (subelement.type == 5) { // Dimensions array
+                        if (subelement.bytes == 8) {
+                            rows = ((qint32*)subelement.data.data())[0];
+                            columns = ((qint32*)subelement.data.data())[1];
+                        } else {
+                            qWarning("matFormat::read can only handle 2D arrays.");
+                        }
+                    } else if (subelement.type == 7) { //miSINGLE
+                        matrixType = CV_32FC1;
+                        matrixData = subelement.data;
+                    } else if (subelement.type == 9) { //miDOUBLE
+                        matrixType = CV_64FC1;
+                        matrixData = subelement.data;
+                    }
+                }
+
+                if ((rows > 0) && (columns > 0) && (matrixType != 0) && !matrixData.isEmpty()) {
+                    Mat transposed;
+                    transpose(Mat(columns, rows, matrixType, matrixData.data()), transposed);
+                    t.append(transposed);
+                }
+            }
+        }
+
+        return t;
+    }
+
+    void write(const Template &t) const
+    {
+        QByteArray data;
+        QDataStream stream(&data, QFile::WriteOnly);
+
+        { // Header
+            QByteArray header = "MATLAB 5.0 MAT-file; Made with OpenBR | www.openbiometrics.org\n";
+            QByteArray buffer(116-header.size(), 0);
+            stream.writeRawData(header.data(), header.size());
+            stream.writeRawData(buffer.data(), buffer.size());
+            quint64 subsystem = 0;
+            quint16 version = 0x0100;
+            const char *endianness = "IM";
+            stream.writeRawData((const char*)&subsystem, 8);
+            stream.writeRawData((const char*)&version, 2);
+            stream.writeRawData(endianness, 2);
+        }
+
+        for (int i=0; i<t.size(); i++) {
+            const Mat &m = t[i];
+            if (m.channels() != 1) qFatal("Only supports single channel matrices.");
+
+            QByteArray subdata;
+            QDataStream substream(&subdata, QFile::WriteOnly);
+
+            {  // Array Flags
+                quint32 type = 6;
+                quint32 bytes = 8;
+                quint64 arrayClass = 0;
+                switch (m.type()) {
+                  case CV_64FC1: arrayClass = 6; break;
+                  case CV_32FC1: arrayClass = 7; break;
+                  case CV_8UC1: arrayClass = 8; break;
+                  case CV_8SC1: arrayClass = 9; break;
+                  case CV_16UC1: arrayClass = 10; break;
+                  case CV_16SC1: arrayClass = 11; break;
+                  case CV_32SC1: arrayClass = 12; break;
+                  default: qFatal("Unsupported matrix class.");
+                }
+                substream.writeRawData((const char*)&type, 4);
+                substream.writeRawData((const char*)&bytes, 4);
+                substream.writeRawData((const char*)&arrayClass, 8);
+            }
+
+            { // Dimensions Array
+                quint32 type = 5;
+                quint32 bytes = 8;
+                substream.writeRawData((const char*)&type, 4);
+                substream.writeRawData((const char*)&bytes, 4);
+                substream.writeRawData((const char*)&m.rows, 4);
+                substream.writeRawData((const char*)&m.cols, 4);
+            }
+
+            { // Array Name
+                QByteArray name(qPrintable(QString("OpenBR_%1").arg(QString::number(i))));
+                quint32 type = 1;
+                quint32 bytes = name.size();
+                QByteArray buffer((8 - bytes%8)%8, 0);
+                substream.writeRawData((const char*)&type, 4);
+                substream.writeRawData((const char*)&bytes, 4);
+                substream.writeRawData(name.data(), name.size());
+                substream.writeRawData(buffer.data(), buffer.size());
+            }
+
+            { // Real part
+                quint32 type = 0;
+                switch (m.type()) {
+                  case CV_8SC1:  type = 1; break;
+                  case CV_8UC1:  type = 2; break;
+                  case CV_16SC1: type = 3; break;
+                  case CV_16UC1: type = 4; break;
+                  case CV_32SC1: type = 5; break;
+                  case CV_32FC1: type = 7; break;
+                  case CV_64FC1: type = 9; break;
+                  default: qFatal("Unsupported matrix type.");
+                }
+                quint32 bytes = m.elemSize() * m.rows * m.cols;
+                QByteArray buffer((8 - bytes%8)%8, 0);
+                Mat transposed;
+                transpose(m, transposed);
+                substream.writeRawData((const char*)&type, 4);
+                substream.writeRawData((const char*)&bytes, 4);
+                substream.writeRawData((const char*)transposed.data, bytes);
+                substream.writeRawData(buffer.data(), buffer.size());
+            }
+
+            { // Matrix
+                quint32 type = 14;
+                quint32 bytes = subdata.size();
+                stream.writeRawData((const char*)&type, 4);
+                stream.writeRawData((const char*)&bytes, 4);
+                stream.writeRawData(subdata.data(), subdata.size());
+            }
+        }
+
+        QtUtils::writeFile(file, data);
+    }
+};
+
+BR_REGISTER(Format, matFormat)
+
+} // namespace br
+
+#include "format/mat.moc"
diff --git a/openbr/plugins/format/mtx.cpp b/openbr/plugins/format/mtx.cpp
new file mode 100644
index 0000000..7afea0e
--- /dev/null
+++ b/openbr/plugins/format/mtx.cpp
@@ -0,0 +1,63 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * Copyright 2012 The MITRE Corporation                                      *
+ *                                                                           *
+ * Licensed under the Apache License, Version 2.0 (the "License");           *
+ * you may not use this file except in compliance with the License.          *
+ * You may obtain a copy of the License at                                   *
+ *                                                                           *
+ *     http://www.apache.org/licenses/LICENSE-2.0                            *
+ *                                                                           *
+ * Unless required by applicable law or agreed to in writing, software       *
+ * distributed under the License is distributed on an "AS IS" BASIS,         *
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  *
+ * See the License for the specific language governing permissions and       *
+ * limitations under the License.                                            *
+ * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+
+#include <openbr/plugins/openbr_internal.h>
+#include <openbr/core/bee.h>
+
+namespace br
+{
+
+/*!
+ * \ingroup formats
+ * \brief Reads a NIST BEE similarity matrix.
+ * \author Josh Klontz \cite jklontz
+ */
+class mtxFormat : public Format
+{
+    Q_OBJECT
+
+    Template read() const
+    {
+        QString target, query;
+        Template result = BEE::readMatrix(file, &target, &query);
+        result.file.set("Target", target);
+        result.file.set("Query", query);
+        return result;
+    }
+
+    void write(const Template &t) const
+    {
+        BEE::writeMatrix(t, file);
+    }
+};
+
+BR_REGISTER(Format, mtxFormat)
+
+/*!
+ * \ingroup formats
+ * \brief Reads a NIST BEE mask matrix.
+ * \author Josh Klontz \cite jklontz
+ */
+class maskFormat : public mtxFormat
+{
+    Q_OBJECT
+};
+
+BR_REGISTER(Format, maskFormat)
+
+} // namespace br
+
+#include "format/mtx.moc"
diff --git a/openbr/plugins/format/null.cpp b/openbr/plugins/format/null.cpp
new file mode 100644
index 0000000..97caa99
--- /dev/null
+++ b/openbr/plugins/format/null.cpp
@@ -0,0 +1,46 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * Copyright 2012 The MITRE Corporation                                      *
+ *                                                                           *
+ * Licensed under the Apache License, Version 2.0 (the "License");           *
+ * you may not use this file except in compliance with the License.          *
+ * You may obtain a copy of the License at                                   *
+ *                                                                           *
+ *     http://www.apache.org/licenses/LICENSE-2.0                            *
+ *                                                                           *
+ * Unless required by applicable law or agreed to in writing, software       *
+ * distributed under the License is distributed on an "AS IS" BASIS,         *
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  *
+ * See the License for the specific language governing permissions and       *
+ * limitations under the License.                                            *
+ * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+
+#include <openbr/plugins/openbr_internal.h>
+
+namespace br
+{
+
+/*!
+ * \ingroup formats
+ * \brief Returns an empty matrix.
+ * \author Josh Klontz \cite jklontz
+ */
+class nullFormat : public Format
+{
+    Q_OBJECT
+
+    Template read() const
+    {
+        return Template(file, cv::Mat());
+    }
+
+    void write(const Template &t) const
+    {
+        (void)t;
+    }
+};
+
+BR_REGISTER(Format, nullFormat)
+
+} // namespace br
+
+#include "format/null.moc"
diff --git a/openbr/plugins/format/post.cpp b/openbr/plugins/format/post.cpp
new file mode 100644
index 0000000..31ee504
--- /dev/null
+++ b/openbr/plugins/format/post.cpp
@@ -0,0 +1,106 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * Copyright 2012 The MITRE Corporation                                      *
+ *                                                                           *
+ * Licensed under the Apache License, Version 2.0 (the "License");           *
+ * you may not use this file except in compliance with the License.          *
+ * You may obtain a copy of the License at                                   *
+ *                                                                           *
+ *     http://www.apache.org/licenses/LICENSE-2.0                            *
+ *                                                                           *
+ * Unless required by applicable law or agreed to in writing, software       *
+ * distributed under the License is distributed on an "AS IS" BASIS,         *
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  *
+ * See the License for the specific language governing permissions and       *
+ * limitations under the License.                                            *
+ * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+
+#include <QTcpSocket>
+#include <opencv2/highgui/highgui.hpp>
+
+#include <openbr/plugins/openbr_internal.h>
+#include <http_parser.h>
+
+using namespace cv;
+
+namespace br
+{
+
+/*!
+ * \ingroup formats
+ * \brief Handle POST requests
+ * \author Josh Klontz \cite jklontz
+ */
+class postFormat : public Format
+{
+    Q_OBJECT
+
+    Template read() const
+    {
+        Template t(file);
+
+        // Read from socket
+        QTcpSocket *socket = new QTcpSocket();
+        socket->setSocketDescriptor(file.get<qintptr>("socketDescriptor"));
+        socket->write("HTTP/1.1 200 OK\r\n"
+                      "Content-Type: text/html; charset=UTF-8\r\n\r\n"
+                      "Hello World!\r\n");
+        socket->waitForBytesWritten();
+        socket->waitForReadyRead();
+        QByteArray data = socket->readAll();
+        socket->close();
+        delete socket;
+
+        qDebug() << data;
+
+        // Parse data
+        http_parser_settings settings;
+        settings.on_body = bodyCallback;
+        settings.on_headers_complete = NULL;
+        settings.on_header_field = NULL;
+        settings.on_header_value = NULL;
+        settings.on_message_begin = NULL;
+        settings.on_message_complete = NULL;
+        settings.on_status_complete = NULL;
+        settings.on_url = NULL;
+
+        {
+            QByteArray body;
+            http_parser parser;
+            http_parser_init(&parser, HTTP_REQUEST);
+            parser.data = &body;
+            http_parser_execute(&parser, &settings, data.data(), data.size());
+            data = body;
+        }
+
+        data.prepend("HTTP/1.1 200 OK");
+        QByteArray body;
+        { // Image data is two layers deep
+            http_parser parser;
+            http_parser_init(&parser, HTTP_BOTH);
+            parser.data = &body;
+            http_parser_execute(&parser, &settings, data.data(), data.size());
+        }
+
+        t.append(imdecode(Mat(1, body.size(), CV_8UC1, body.data()), 1));
+        return t;
+    }
+
+    void write(const Template &t) const
+    {
+        (void) t;
+        qFatal("Not supported!");
+    }
+
+    static int bodyCallback(http_parser *parser, const char *at, size_t length)
+    {
+        QByteArray *byteArray = (QByteArray*)parser->data;
+        *byteArray = QByteArray(at, length);
+        return 0;
+    }
+};
+
+BR_REGISTER(Format, postFormat)
+
+} // namespace br
+
+#include "format/post.moc"
diff --git a/openbr/plugins/format/raw.cpp b/openbr/plugins/format/raw.cpp
new file mode 100644
index 0000000..14ee263
--- /dev/null
+++ b/openbr/plugins/format/raw.cpp
@@ -0,0 +1,86 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * Copyright 2012 The MITRE Corporation                                      *
+ *                                                                           *
+ * Licensed under the Apache License, Version 2.0 (the "License");           *
+ * you may not use this file except in compliance with the License.          *
+ * You may obtain a copy of the License at                                   *
+ *                                                                           *
+ *     http://www.apache.org/licenses/LICENSE-2.0                            *
+ *                                                                           *
+ * Unless required by applicable law or agreed to in writing, software       *
+ * distributed under the License is distributed on an "AS IS" BASIS,         *
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  *
+ * See the License for the specific language governing permissions and       *
+ * limitations under the License.                                            *
+ * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+
+#include <openbr/plugins/openbr_internal.h>
+#include <openbr/core/qtutils.h>
+
+using namespace cv;
+
+namespace br
+{
+
+/*!
+ * \ingroup formats
+ * \brief RAW format
+ *
+ * http://www.nist.gov/srd/nistsd27.cfm
+ * \author Josh Klontz \cite jklontz
+ */
+class rawFormat : public Format
+{
+    Q_OBJECT
+    static QHash<QString, QHash<QString,QSize> > imageSizes; // QHash<Path, QHash<File,Size> >
+
+    Template read() const
+    {
+        QString path = file.path();
+        if (!imageSizes.contains(path)) {
+            static QMutex mutex;
+            QMutexLocker locker(&mutex);
+
+            if (!imageSizes.contains(path)) {
+                const QString imageSize = path+"/ImageSize.txt";
+                QStringList lines;
+                if (QFileInfo(imageSize).exists()) {
+                    lines = QtUtils::readLines(imageSize);
+                    lines.removeFirst(); // Remove header
+                }
+
+                QHash<QString,QSize> sizes;
+                QRegExp whiteSpace("\\s+");
+                foreach (const QString &line, lines) {
+                    QStringList words = line.split(whiteSpace);
+                    if (words.size() != 3) continue;
+                    sizes.insert(words[0], QSize(words[2].toInt(), words[1].toInt()));
+                }
+
+                imageSizes.insert(path, sizes);
+            }
+        }
+
+        QByteArray data;
+        QtUtils::readFile(file, data);
+
+        QSize size = imageSizes[path][file.baseName()];
+        if (!size.isValid()) size = QSize(800,768);
+        if (data.size() != size.width() * size.height())
+            qFatal("Expected %d*%d bytes, got %d.", size.height(), size.width(), data.size());
+        return Template(file, Mat(size.height(), size.width(), CV_8UC1, data.data()).clone());
+    }
+
+    void write(const Template &t) const
+    {
+        QtUtils::writeFile(file, QByteArray().setRawData((const char*)t.m().data, t.m().total() * t.m().elemSize()));
+    }
+};
+
+QHash<QString, QHash<QString,QSize> > rawFormat::imageSizes;
+
+BR_REGISTER(Format, rawFormat)
+
+} // namespace br
+
+#include "format/raw.moc"
diff --git a/openbr/plugins/format/scores.cpp b/openbr/plugins/format/scores.cpp
new file mode 100644
index 0000000..c674991
--- /dev/null
+++ b/openbr/plugins/format/scores.cpp
@@ -0,0 +1,81 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * Copyright 2012 The MITRE Corporation                                      *
+ *                                                                           *
+ * Licensed under the Apache License, Version 2.0 (the "License");           *
+ * you may not use this file except in compliance with the License.          *
+ * You may obtain a copy of the License at                                   *
+ *                                                                           *
+ *     http://www.apache.org/licenses/LICENSE-2.0                            *
+ *                                                                           *
+ * Unless required by applicable law or agreed to in writing, software       *
+ * distributed under the License is distributed on an "AS IS" BASIS,         *
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  *
+ * See the License for the specific language governing permissions and       *
+ * limitations under the License.                                            *
+ * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+
+#include <openbr/plugins/openbr_internal.h>
+#include <openbr/core/qtutils.h>
+#include <openbr/core/opencvutils.h>
+#include <openbr/core/bee.h>
+
+using namespace cv;
+
+namespace br
+{
+
+/*!
+ * \ingroup formats
+ * \brief Reads in scores or ground truth from a text table.
+ * \author Josh Klontz \cite jklontz
+ *
+ * Example of the format:
+ * \code
+ * 2.2531514    FALSE   99990377    99990164
+ * 2.2549822    TRUE    99990101    99990101
+ * \endcode
+ */
+class scoresFormat : public Format
+{
+    Q_OBJECT
+    Q_PROPERTY(int column READ get_column WRITE set_column RESET reset_column STORED false)
+    Q_PROPERTY(bool groundTruth READ get_groundTruth WRITE set_groundTruth RESET reset_groundTruth STORED false)
+    Q_PROPERTY(QString delimiter READ get_delimiter WRITE set_delimiter RESET reset_delimiter STORED false)
+    BR_PROPERTY(int, column, 0)
+    BR_PROPERTY(bool, groundTruth, false)
+    BR_PROPERTY(QString, delimiter, "\t")
+
+    Template read() const
+    {
+        QFile f(file.name);
+        if (!f.open(QFile::ReadOnly | QFile::Text))
+            qFatal("Failed to open %s for reading.", qPrintable(f.fileName()));
+        QList<float> values;
+        while (!f.atEnd()) {
+            const QStringList words = QString(f.readLine()).split(delimiter);
+            if (words.size() <= column) qFatal("Expected file to have at least %d columns.", column+1);
+            const QString &word = words[column];
+            bool ok;
+            float value = word.toFloat(&ok);
+            if (!ok) value = (QtUtils::toBool(word) ? BEE::Match : BEE::NonMatch);
+            values.append(value);
+        }
+        if (values.size() == 1)
+            qWarning("Only one value read, double check file line endings.");
+        Mat result = OpenCVUtils::toMat(values);
+        if (groundTruth) result.convertTo(result, CV_8U);
+        return result;
+    }
+
+    void write(const Template &t) const
+    {
+        (void) t;
+        qFatal("Not implemented.");
+    }
+};
+
+BR_REGISTER(Format, scoresFormat)
+
+} // namespace br
+
+#include "format/scores.moc"
diff --git a/openbr/plugins/format/url.cpp b/openbr/plugins/format/url.cpp
new file mode 100644
index 0000000..24b1dbd
--- /dev/null
+++ b/openbr/plugins/format/url.cpp
@@ -0,0 +1,68 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * 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 <QtNetwork>
+#include <opencv2/highgui/highgui.hpp>
+
+#include <openbr/plugins/openbr_internal.h>
+
+using namespace cv;
+
+namespace br
+{
+
+/*!
+ * \ingroup formats
+ * \brief Reads image files from the web.
+ * \author Josh Klontz \cite jklontz
+ */
+class urlFormat : public Format
+{
+    Q_OBJECT
+
+    Template read() const
+    {
+        Template t;
+
+        QNetworkAccessManager networkAccessManager;
+        QNetworkRequest request(QString(file.name).remove(".url"));
+        request.setAttribute(QNetworkRequest::CacheLoadControlAttribute, QNetworkRequest::AlwaysNetwork);
+        QNetworkReply *reply = networkAccessManager.get(request);
+
+        while (!reply->isFinished()) QCoreApplication::processEvents();
+        if (reply->error()) qWarning("%s (%s)", qPrintable(reply->errorString()), qPrintable(QString::number(reply->error())));
+
+        QByteArray data = reply->readAll();
+        delete reply;
+
+        Mat m = imdecode(Mat(1, data.size(), CV_8UC1, data.data()), 1);
+        if (m.data) t.append(m);
+
+        return t;
+    }
+
+    void write(const Template &t) const
+    {
+        (void) t;
+        qFatal("Not supported.");
+    }
+};
+
+BR_REGISTER(Format, urlFormat)
+
+} // namespace br
+
+#include "format/url.moc"
diff --git a/openbr/plugins/format/video.cpp b/openbr/plugins/format/video.cpp
new file mode 100644
index 0000000..fdf659d
--- /dev/null
+++ b/openbr/plugins/format/video.cpp
@@ -0,0 +1,163 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * Copyright 2012 The MITRE Corporation                                      *
+ *                                                                           *
+ * Licensed under the Apache License, Version 2.0 (the "License");           *
+ * you may not use this file except in compliance with the License.          *
+ * You may obtain a copy of the License at                                   *
+ *                                                                           *
+ *     http://www.apache.org/licenses/LICENSE-2.0                            *
+ *                                                                           *
+ * Unless required by applicable law or agreed to in writing, software       *
+ * distributed under the License is distributed on an "AS IS" BASIS,         *
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  *
+ * See the License for the specific language governing permissions and       *
+ * limitations under the License.                                            *
+ * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+
+#include <opencv2/highgui/highgui.hpp>
+
+#include <openbr/plugins/openbr_internal.h>
+#include <openbr/core/qtutils.h>
+#include <openbr/core/opencvutils.h>
+
+using namespace cv;
+
+namespace br
+{
+
+/*!
+ * \ingroup formats
+ * \brief Read all frames of a video using OpenCV
+ * \author Charles Otto \cite caotto
+ */
+class videoFormat : public Format
+{
+    Q_OBJECT
+
+public:
+    Template read() const
+    {
+        if (!file.exists() )
+            return Template();
+
+        VideoCapture videoSource(file.name.toStdString());
+        videoSource.open(file.name.toStdString() );
+
+
+        Template frames;
+        if (!videoSource.isOpened()) {
+            qWarning("video file open failed");
+            return frames;
+        }
+
+        bool open = true;
+        while (open) {
+            cv::Mat frame;
+            open = videoSource.read(frame);
+            if (!open) break;
+
+            frames.append(cv::Mat());
+            frames.back() = frame.clone();
+        }
+
+        return frames;
+    }
+
+    void write(const Template &t) const
+    {
+        int fourcc = OpenCVUtils::getFourcc();
+        VideoWriter videoSink(file.name.toStdString(), fourcc, 30, t.begin()->size());
+
+        // Did we successfully open the output file?
+        if (!videoSink.isOpened() ) qFatal("Failed to open output file");
+
+        for (Template::const_iterator it = t.begin(); it!= t.end(); ++it) {
+            videoSink << *it;
+        }
+    }
+};
+
+BR_REGISTER(Format, videoFormat)
+
+/*!
+ * \ingroup formats
+ * \brief Retrieves an image from a webcam.
+ * \author Josh Klontz \cite jklontz
+ */
+class webcamFormat : public Format
+{
+    Q_OBJECT
+
+    Template read() const
+    {
+        static QScopedPointer<VideoCapture> videoCapture;
+
+        if (videoCapture.isNull())
+            videoCapture.reset(new VideoCapture(0));
+
+        Mat m;
+        videoCapture->read(m);
+        return Template(m);
+    }
+
+    void write(const Template &t) const
+    {
+        (void) t;
+        qFatal("Not supported.");
+    }
+};
+
+BR_REGISTER(Format, webcamFormat)
+
+/*!
+ * \ingroup formats
+ * \brief Reads image files.
+ * \author Josh Klontz \cite jklontz
+ */
+class DefaultFormat : public Format
+{
+    Q_OBJECT
+
+    Template read() const
+    {
+        Template t;
+
+        if (file.name.startsWith("http://") || file.name.startsWith("https://") || file.name.startsWith("www.")) {
+            if (Factory<Format>::names().contains("url")) {
+                File urlFile = file;
+                urlFile.name.append(".url");
+                QScopedPointer<Format> url(Factory<Format>::make(urlFile));
+                t = url->read();
+            }
+        } else {
+            Mat m = imread(file.resolved().toStdString());
+            if (m.data) {
+                t.append(m);
+            } else {
+                videoFormat videoReader;
+                videoReader.file = file;
+                t = videoReader.read();
+            }
+        }
+
+        return t;
+    }
+
+    void write(const Template &t) const
+    {
+        if (t.size() > 1) {
+            videoFormat videoWriter;
+            videoWriter.file = file;
+            videoWriter.write(t);
+        } else if (t.size() == 1) {
+            QtUtils::touchDir(QDir(file.path()));
+            imwrite(file.name.toStdString(), t);
+        }
+    }
+};
+
+BR_REGISTER(Format, DefaultFormat)
+
+} // namespace br
+
+#include "format/video.moc"
diff --git a/openbr/plugins/format/xml.cpp b/openbr/plugins/format/xml.cpp
new file mode 100644
index 0000000..9757619
--- /dev/null
+++ b/openbr/plugins/format/xml.cpp
@@ -0,0 +1,118 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * 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.                                            *
+ * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+
+#ifndef BR_EMBEDDED
+#include <QtXml>
+#endif // BR_EMBEDDED
+#include <opencv2/highgui/highgui.hpp>
+
+#include <openbr/plugins/openbr_internal.h>
+#include <openbr/core/qtutils.h>
+
+using namespace cv;
+
+namespace br
+{
+
+/*!
+ * \ingroup formats
+ * \brief Decodes images from Base64 xml
+ * \author Scott Klum \cite sklum
+ * \author Josh Klontz \cite jklontz
+ */
+class xmlFormat : public Format
+{
+    Q_OBJECT
+
+    Template read() const
+    {
+        Template t;
+
+#ifndef BR_EMBEDDED
+        QString fileName = file.get<QString>("path") + file.name;
+
+        QDomDocument doc(fileName);
+        QFile f(fileName);
+
+        if (!f.open(QIODevice::ReadOnly)) qFatal("Unable to open %s for reading.", qPrintable(file.flat()));
+        if (!doc.setContent(&f)) qWarning("Unable to parse %s.", qPrintable(file.flat()));
+        f.close();
+
+        QDomElement docElem = doc.documentElement();
+        QDomNode subject = docElem.firstChild();
+        while (!subject.isNull()) {
+            QDomNode fileNode = subject.firstChild();
+
+            while (!fileNode.isNull()) {
+                QDomElement e = fileNode.toElement();
+
+                if (e.tagName() == "FORMAL_IMG") {
+                    QByteArray byteArray = QByteArray::fromBase64(qPrintable(e.text()));
+                    Mat m = imdecode(Mat(3, byteArray.size(), CV_8UC3, byteArray.data()), CV_LOAD_IMAGE_COLOR);
+                    if (!m.data) qWarning("xmlFormat::read failed to decode image data.");
+                    t.append(m);
+                } else if ((e.tagName() == "RELEASE_IMG") ||
+                           (e.tagName() == "PREBOOK_IMG") ||
+                           (e.tagName() == "LPROFILE") ||
+                           (e.tagName() == "RPROFILE")) {
+                    // Ignore these other image fields for now
+                } else {
+                    t.file.set(e.tagName(), e.text());
+                }
+
+                fileNode = fileNode.nextSibling();
+            }
+            subject = subject.nextSibling();
+        }
+
+        // Calculate age
+        if (t.file.contains("DOB")) {
+            const QDate dob = QDate::fromString(t.file.get<QString>("DOB").left(10), "yyyy-MM-dd");
+            const QDate current = QDate::currentDate();
+            int age = current.year() - dob.year();
+            if (current.month() < dob.month()) age--;
+            t.file.set("Age", age);
+        }
+#endif // BR_EMBEDDED
+
+        return t;
+    }
+
+    void write(const Template &t) const
+    {
+        QStringList lines;
+        lines.append("<?xml version=\"1.0\" standalone=\"yes\"?>");
+        lines.append("<openbr-xml-format>");
+        lines.append("\t<xml-data>");
+        foreach (const QString &key, t.file.localKeys()) {
+            if ((key == "Index") || (key == "Label")) continue;
+            lines.append("\t\t<"+key+">"+QtUtils::toString(t.file.value(key))+"</"+key+">");
+        }
+        std::vector<uchar> data;
+        imencode(".jpg",t.m(),data);
+        QByteArray byteArray = QByteArray::fromRawData((const char*)data.data(), data.size());
+        lines.append("\t\t<FORMAL_IMG>"+byteArray.toBase64()+"</FORMAL_IMG>");
+        lines.append("\t</xml-data>");
+        lines.append("</openbr-xml-format>");
+        QtUtils::writeFile(file, lines);
+    }
+};
+
+BR_REGISTER(Format, xmlFormat)
+
+} // namespace br
+
+#include "format/xml.moc"
diff --git a/openbr/plugins/gallery.cpp b/openbr/plugins/gallery.cpp
deleted file mode 100644
index 5036aec..0000000
--- a/openbr/plugins/gallery.cpp
+++ /dev/null
@@ -1,2075 +0,0 @@
-/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
- * 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 <QtCore>
-#include <QtConcurrentRun>
-#ifndef BR_EMBEDDED
-#include <QNetworkAccessManager>
-#include <QNetworkReply>
-#include <QSqlDatabase>
-#include <QSqlError>
-#include <QSqlQuery>
-#include <QSqlRecord>
-#include <QXmlStreamReader>
-#endif // BR_EMBEDDED
-#include <opencv2/highgui/highgui.hpp>
-#include "openbr_internal.h"
-
-#include "openbr/universal_template.h"
-#include "openbr/core/bee.h"
-#include "openbr/core/common.h"
-#include "openbr/core/opencvutils.h"
-#include "openbr/core/qtutils.h"
-
-#include <fstream>
-
-#ifdef CVMATIO
-#include "MatlabIO.hpp"
-#include "MatlabIOContainer.hpp"
-#endif
-
-#ifdef _WIN32
-#include <io.h>
-#include <fcntl.h>
-#endif // _WIN32
-
-namespace br
-{
-
-/*!
- * \ingroup galleries
- * \brief Weka ARFF file format.
- * \author Josh Klontz \cite jklontz
- * http://weka.wikispaces.com/ARFF+%28stable+version%29
- */
-class arffGallery : public Gallery
-{
-    Q_OBJECT
-    QFile arffFile;
-
-    TemplateList readBlock(bool *done)
-    {
-        (void) done;
-        qFatal("Not implemented.");
-        return TemplateList();
-    }
-
-    void write(const Template &t)
-    {
-        if (!arffFile.isOpen()) {
-            arffFile.setFileName(file.name);
-            arffFile.open(QFile::WriteOnly);
-            arffFile.write("% OpenBR templates\n"
-                           "@RELATION OpenBR\n"
-                           "\n");
-
-            const int dimensions = t.m().rows * t.m().cols;
-            for (int i=0; i<dimensions; i++)
-                arffFile.write(qPrintable("@ATTRIBUTE v" + QString::number(i) + " REAL\n"));
-            arffFile.write(qPrintable("@ATTRIBUTE class string\n"));
-
-            arffFile.write("\n@DATA\n");
-        }
-
-        arffFile.write(qPrintable(OpenCVUtils::matrixToStringList(t).join(',')));
-        arffFile.write(qPrintable(",'" + t.file.get<QString>("Label") + "'\n"));
-    }
-
-    void init()
-    {
-        //
-    }
-};
-
-BR_REGISTER(Gallery, arffGallery)
-
-class BinaryGallery : public Gallery
-{
-    Q_OBJECT
-
-    void init()
-    {
-        const QString baseName = file.baseName();
-
-        if (baseName == "stdin") {
-#ifdef _WIN32
-            if(_setmode(_fileno(stdin), _O_BINARY) == -1)
-                qFatal("Failed to set stdin to binary mode!");
-#endif // _WIN32
-
-            gallery.open(stdin, QFile::ReadOnly);
-        } else if (baseName == "stdout") {
-#ifdef _WIN32
-            if(_setmode(_fileno(stdout), _O_BINARY) == -1)
-                qFatal("Failed to set stdout to binary mode!");
-#endif // _WIN32
-
-            gallery.open(stdout, QFile::WriteOnly);
-        } else if (baseName == "stderr") {
-#ifdef _WIN32
-            if(_setmode(_fileno(stderr), _O_BINARY) == -1)
-                qFatal("Failed to set stderr to binary mode!");
-#endif // _WIN32
-
-            gallery.open(stderr, QFile::WriteOnly);
-        } else {
-            // Defer opening the file, in the general case we don't know if we 
-            // need read or write mode yet
-            return;
-        }
-        stream.setDevice(&gallery);
-    }
-
-    void readOpen()
-    {
-        if (!gallery.isOpen()) {
-            gallery.setFileName(file);
-            if (!gallery.exists())
-                qFatal("File %s does not exist", qPrintable(gallery.fileName()));
-
-            QFile::OpenMode mode = QFile::ReadOnly;
-            if (!gallery.open(mode))
-                qFatal("Can't open gallery: %s for reading", qPrintable(gallery.fileName()));
-            stream.setDevice(&gallery);
-        }
-    }
-
-    void writeOpen()
-    {
-        if (!gallery.isOpen()) {
-            gallery.setFileName(file);
-
-            // Do we remove the pre-existing gallery?
-            if (file.get<bool>("remove"))
-                gallery.remove();
-            QtUtils::touchDir(gallery);
-            QFile::OpenMode mode = QFile::WriteOnly;
-
-            // Do we append? 
-            if (file.get<bool>("append"))
-                mode |= QFile::Append;
-
-            if (!gallery.open(mode))
-                qFatal("Can't open gallery: %s for writing", qPrintable(gallery.fileName()));
-            stream.setDevice(&gallery);
-        }
-    }
-
-    TemplateList readBlock(bool *done)
-    {
-        readOpen();
-        if (gallery.atEnd())
-            gallery.seek(0);
-
-        TemplateList templates;
-        while ((templates.size() < readBlockSize) && !gallery.atEnd()) {
-            const Template t = readTemplate();
-            if (!t.isEmpty() || !t.file.isNull()) {
-                templates.append(t);
-                templates.last().file.set("progress", position());
-            }
-
-            // Special case for pipes where we want to process data as soon as it is available
-            if (gallery.isSequential())
-                break;
-        }
-
-        *done = gallery.atEnd();
-        return templates;
-    }
-
-    void write(const Template &t)
-    {
-        writeOpen();
-        writeTemplate(t);
-        if (gallery.isSequential())
-            gallery.flush();
-    }
-
-protected:
-    QFile gallery;
-    QDataStream stream;
-
-    qint64 totalSize()
-    {
-        readOpen();
-        return gallery.size();
-    }
-
-    qint64 position()
-    {
-        return gallery.pos();
-    }
-
-    virtual Template readTemplate() = 0;
-    virtual void writeTemplate(const Template &t) = 0;
-};
-
-/*!
- * \ingroup galleries
- * \brief A binary gallery.
- *
- * Designed to be a literal translation of templates to disk.
- * Compatible with TemplateList::fromBuffer.
- * \author Josh Klontz \cite jklontz
- */
-class galGallery : public BinaryGallery
-{
-    Q_OBJECT
-
-    Template readTemplate()
-    {
-        Template t;
-        stream >> t;
-        return t;
-    }
-
-    void writeTemplate(const Template &t)
-    {
-        if (t.isEmpty() && t.file.isNull())
-            return;
-        else if (t.file.fte)
-            stream << Template(t.file); // only write metadata for failure to enroll
-        else
-            stream << t;
-    }
-};
-
-BR_REGISTER(Gallery, galGallery)
-
-/*!
- * \ingroup galleries
- * \brief A contiguous array of br_universal_template.
- * \author Josh Klontz \cite jklontz
- */
-class utGallery : public BinaryGallery
-{
-    Q_OBJECT
-
-    Template readTemplate()
-    {
-        Template t;
-        br_universal_template ut;
-        if (gallery.read((char*)&ut, sizeof(br_universal_template)) == sizeof(br_universal_template)) {
-            QByteArray data(ut.urlSize + ut.fvSize, Qt::Uninitialized);
-            char *dst = data.data();
-            qint64 bytesNeeded = ut.urlSize + ut.fvSize;
-            while (bytesNeeded > 0) {
-                qint64 bytesRead = gallery.read(dst, bytesNeeded);
-                if (bytesRead <= 0) {
-                    qDebug() << gallery.errorString();
-                    qFatal("Unexepected EOF while reading universal template data, needed: %d more of: %d bytes.", int(bytesNeeded), int(ut.urlSize + ut.fvSize));
-                }
-                bytesNeeded -= bytesRead;
-                dst += bytesRead;
-            }
-
-            t.file.set("ImageID", QVariant(QByteArray((const char*)ut.imageID, 16).toHex()));
-            t.file.set("AlgorithmID", ut.algorithmID);
-            t.file.set("URL", QString(data.data()));
-            char *dataStart = data.data() + ut.urlSize;
-            uint32_t dataSize = ut.fvSize;
-            if ((ut.algorithmID <= -1) && (ut.algorithmID >= -3)) {
-                t.file.set("FrontalFace", QRectF(ut.x, ut.y, ut.width, ut.height));
-                uint32_t *rightEyeX = reinterpret_cast<uint32_t*>(dataStart);
-                dataStart += sizeof(uint32_t);
-                uint32_t *rightEyeY = reinterpret_cast<uint32_t*>(dataStart);
-                dataStart += sizeof(uint32_t);
-                uint32_t *leftEyeX = reinterpret_cast<uint32_t*>(dataStart);
-                dataStart += sizeof(uint32_t);
-                uint32_t *leftEyeY = reinterpret_cast<uint32_t*>(dataStart);
-                dataStart += sizeof(uint32_t);
-                dataSize -= sizeof(uint32_t)*4;
-                t.file.set("First_Eye", QPointF(*rightEyeX, *rightEyeY));
-                t.file.set("Second_Eye", QPointF(*leftEyeX, *leftEyeY));
-            } else {
-                t.file.set("X", ut.x);
-                t.file.set("Y", ut.y);
-                t.file.set("Width", ut.width);
-                t.file.set("Height", ut.height);
-            }
-            t.file.set("Label", ut.label);
-            t.append(cv::Mat(1, dataSize, CV_8UC1, dataStart).clone() /* We don't want a shallow copy! */);
-        } else {
-            if (!gallery.atEnd())
-                qFatal("Failed to read universal template header!");
-        }
-        return t;
-    }
-
-    void writeTemplate(const Template &t)
-    {
-        const QByteArray imageID = QByteArray::fromHex(t.file.get<QByteArray>("ImageID", QByteArray(32, '0')));
-        if (imageID.size() != 16)
-            qFatal("Expected 16-byte ImageID, got: %d bytes.", imageID.size());
-
-        const int32_t algorithmID = (t.isEmpty() || t.file.fte) ? 0 : t.file.get<int32_t>("AlgorithmID");
-        const QByteArray url = t.file.get<QString>("URL", t.file.name).toLatin1();
-
-        uint32_t x = 0, y = 0, width = 0, height = 0;
-        QByteArray header;
-        if ((algorithmID <= -1) && (algorithmID >= -3)) {
-            const QRectF frontalFace = t.file.get<QRectF>("FrontalFace");
-            x      = frontalFace.x();
-            y      = frontalFace.y();
-            width  = frontalFace.width();
-            height = frontalFace.height();
-
-            const QPointF firstEye   = t.file.get<QPointF>("First_Eye");
-            const QPointF secondEye  = t.file.get<QPointF>("Second_Eye");
-            const uint32_t rightEyeX = firstEye.x();
-            const uint32_t rightEyeY = firstEye.y();
-            const uint32_t leftEyeX  = secondEye.x();
-            const uint32_t leftEyeY  = secondEye.y();
-
-            header.append((const char*)&rightEyeX, sizeof(uint32_t));
-            header.append((const char*)&rightEyeY, sizeof(uint32_t));
-            header.append((const char*)&leftEyeX , sizeof(uint32_t));
-            header.append((const char*)&leftEyeY , sizeof(uint32_t));
-        } else {
-            x = t.file.get<uint32_t>("X", 0);
-            y = t.file.get<uint32_t>("Y", 0);
-            width = t.file.get<uint32_t>("Width", 0);
-            height = t.file.get<uint32_t>("Height", 0);
-        }
-        const uint32_t label = t.file.get<uint32_t>("Label", 0);
-
-        gallery.write(imageID);
-        gallery.write((const char*) &algorithmID, sizeof(int32_t));
-        gallery.write((const char*) &x          , sizeof(uint32_t));
-        gallery.write((const char*) &y          , sizeof(uint32_t));
-        gallery.write((const char*) &width      , sizeof(uint32_t));
-        gallery.write((const char*) &height     , sizeof(uint32_t));
-        gallery.write((const char*) &label      , sizeof(uint32_t));
-
-        const uint32_t urlSize = url.size() + 1;
-        gallery.write((const char*) &urlSize, sizeof(uint32_t));
-
-        const uint32_t signatureSize = (algorithmID == 0) ? 0 : t.m().rows * t.m().cols * t.m().elemSize();
-        const uint32_t fvSize = header.size() + signatureSize;
-        gallery.write((const char*) &fvSize, sizeof(uint32_t));
-
-        gallery.write((const char*) url.data(), urlSize);
-        if (algorithmID != 0) {
-            gallery.write(header);
-            gallery.write((const char*) t.m().data, signatureSize);
-        }
-    }
-};
-
-BR_REGISTER(Gallery, utGallery)
-
-/*!
- * \ingroup galleries
- * \brief Newline-separated URLs.
- * \author Josh Klontz \cite jklontz
- */
-class urlGallery : public BinaryGallery
-{
-    Q_OBJECT
-
-    Template readTemplate()
-    {
-        Template t;
-        const QString url = QString::fromLocal8Bit(gallery.readLine()).simplified();
-        if (!url.isEmpty())
-            t.file.set("URL", url);
-        return t;
-    }
-
-    void writeTemplate(const Template &t)
-    {
-        const QString url = t.file.get<QString>("URL", t.file.name);
-        if (!url.isEmpty()) {
-            gallery.write(qPrintable(url));
-            gallery.write("\n");
-        }
-    }
-};
-
-BR_REGISTER(Gallery, urlGallery)
-
-/*!
- * \ingroup galleries
- * \brief Newline-separated JSON objects.
- * \author Josh Klontz \cite jklontz
- */
-class jsonGallery : public BinaryGallery
-{
-    Q_OBJECT
-
-    Template readTemplate()
-    {
-        QJsonParseError error;
-        const QByteArray line = gallery.readLine().simplified();
-        if (line.isEmpty())
-            return Template();
-        File file = QJsonDocument::fromJson(line, &error).object().toVariantMap();
-        if (error.error != QJsonParseError::NoError) {
-            qWarning("Couldn't parse: %s\n", line.data());
-            qFatal("%s\n", qPrintable(error.errorString()));
-        }
-        return file;
-    }
-
-    void writeTemplate(const Template &t)
-    {
-        const QByteArray json = QJsonDocument(QJsonObject::fromVariantMap(t.file.localMetadata())).toJson().replace('\n', "");
-        if (!json.isEmpty()) {
-            gallery.write(json);
-            gallery.write("\n");
-        }
-    }
-};
-
-BR_REGISTER(Gallery, jsonGallery)
-
-/*!
- * \ingroup galleries
- * \brief Reads/writes templates to/from folders.
- * \author Josh Klontz \cite jklontz
- * \param regexp An optional regular expression to match against the files extension.
- */
-class EmptyGallery : public Gallery
-{
-    Q_OBJECT
-    Q_PROPERTY(QString regexp READ get_regexp WRITE set_regexp RESET reset_regexp STORED false)
-    BR_PROPERTY(QString, regexp, QString())
-
-    qint64 gallerySize;
-
-    void init()
-    {
-        QDir dir(file.name);
-        QtUtils::touchDir(dir);
-        gallerySize = dir.count();
-    }
-
-    TemplateList readBlock(bool *done)
-    {
-        TemplateList templates;
-        *done = true;
-
-        // Enrolling a null file is used as an idiom to initialize an algorithm
-        if (file.isNull()) return templates;
-
-        // Add immediate subfolders
-        QDir dir(file);
-        QList< QFuture<TemplateList> > futures;
-        foreach (const QString &folder, QtUtils::naturalSort(dir.entryList(QDir::Dirs | QDir::NoDotAndDotDot))) {
-            const QDir subdir = dir.absoluteFilePath(folder);
-            futures.append(QtConcurrent::run(&EmptyGallery::getTemplates, subdir));
-        }
-        foreach (const QFuture<TemplateList> &future, futures)
-            templates.append(future.result());
-
-        // Add root folder
-        foreach (const QString &fileName, QtUtils::getFiles(file.name, false))
-            templates.append(File(fileName, dir.dirName()));
-
-        if (!regexp.isEmpty()) {
-            QRegExp re(regexp);
-            re.setPatternSyntax(QRegExp::Wildcard);
-            for (int i=templates.size()-1; i>=0; i--) {
-                if (!re.exactMatch(templates[i].file.fileName())) {
-                    templates.removeAt(i);
-                }
-            }
-        }
-
-        for (int i = 0; i < templates.size(); i++) templates[i].file.set("progress", i);
-
-        return templates;
-    }
-
-    void write(const Template &t)
-    {
-        static QMutex diskLock;
-
-        // Enrolling a null file is used as an idiom to initialize an algorithm
-        if (file.name.isEmpty()) return;
-
-        const QString newFormat = file.get<QString>("newFormat",QString());
-        QString destination = file.name + "/" + (file.getBool("preservePath") ? t.file.path()+"/" : QString());
-        destination += (newFormat.isEmpty() ? t.file.fileName() : t.file.baseName()+newFormat);
-
-        QMutexLocker diskLocker(&diskLock); // Windows prefers to crash when writing to disk in parallel
-        if (t.isNull()) {
-            QtUtils::copyFile(t.file.resolved(), destination);
-        } else {
-            QScopedPointer<Format> format(Factory<Format>::make(destination));
-            format->write(t);
-        }
-    }
-
-    qint64 totalSize()
-    {
-        return gallerySize;
-    }
-
-    static TemplateList getTemplates(const QDir &dir)
-    {
-        const QStringList files = QtUtils::getFiles(dir, true);
-        TemplateList templates; templates.reserve(files.size());
-        foreach (const QString &file, files)
-            templates.append(File(file, dir.dirName()));
-        return templates;
-    }
-};
-
-BR_REGISTER(Gallery, EmptyGallery)
-
-/*!
- * \ingroup galleries
- * \brief Crawl a root location for image files.
- * \author Josh Klontz \cite jklontz
- */
-class crawlGallery : public Gallery
-{
-    Q_OBJECT
-    Q_PROPERTY(bool autoRoot READ get_autoRoot WRITE set_autoRoot RESET reset_autoRoot STORED false)
-    Q_PROPERTY(int depth READ get_depth WRITE set_depth RESET reset_depth STORED false)
-    Q_PROPERTY(bool depthFirst READ get_depthFirst WRITE set_depthFirst RESET reset_depthFirst STORED false)
-    Q_PROPERTY(int images READ get_images WRITE set_images RESET reset_images STORED false)
-    Q_PROPERTY(bool json READ get_json WRITE set_json RESET reset_json STORED false)
-    Q_PROPERTY(int timeLimit READ get_timeLimit WRITE set_timeLimit RESET reset_timeLimit STORED false)
-    BR_PROPERTY(bool, autoRoot, false)
-    BR_PROPERTY(int, depth, INT_MAX)
-    BR_PROPERTY(bool, depthFirst, false)
-    BR_PROPERTY(int, images, INT_MAX)
-    BR_PROPERTY(bool, json, false)
-    BR_PROPERTY(int, timeLimit, INT_MAX)
-
-    QTime elapsed;
-    TemplateList templates;
-
-    void crawl(QFileInfo url, int currentDepth = 0)
-    {
-        if ((templates.size() >= images) || (currentDepth >= depth) || (elapsed.elapsed()/1000 >= timeLimit))
-            return;
-
-        if (url.filePath().startsWith("file://"))
-            url = QFileInfo(url.filePath().mid(7));
-
-        if (url.isDir()) {
-            const QDir dir(url.absoluteFilePath());
-            const QFileInfoList files = dir.entryInfoList(QDir::Files);
-            const QFileInfoList subdirs = dir.entryInfoList(QDir::Dirs | QDir::NoDotAndDotDot);
-            foreach (const QFileInfo &first, depthFirst ? subdirs : files)
-                crawl(first, currentDepth + 1);
-            foreach (const QFileInfo &second, depthFirst ? files : subdirs)
-                crawl(second, currentDepth + 1);
-        } else if (url.isFile()) {
-            const QString suffix = url.suffix();
-            if ((suffix == "bmp") || (suffix == "jpg") || (suffix == "jpeg") || (suffix == "png") || (suffix == "tiff")) {
-                File f;
-                if (json) f.set("URL", "file://"+url.canonicalFilePath());
-                else      f.name = "file://"+url.canonicalFilePath();
-                templates.append(f);
-            }
-        }
-    }
-
-    void init()
-    {
-        elapsed.start();
-        const QString root = file.name.mid(0, file.name.size()-6); // Remove .crawl suffix";
-        if (!root.isEmpty()) {
-            crawl(root);
-        } else {
-            if (autoRoot) {
-                foreach (const QString &path, QStandardPaths::standardLocations(QStandardPaths::HomeLocation))
-                    crawl(path);
-            } else {
-                QFile file;
-                file.open(stdin, QFile::ReadOnly);
-                while (!file.atEnd()) {
-                    const QString url = QString::fromLocal8Bit(file.readLine()).simplified();
-                    if (!url.isEmpty())
-                        crawl(url);
-                }
-            }
-        }
-    }
-
-    TemplateList readBlock(bool *done)
-    {
-        *done = true;
-        return templates;
-    }
-
-    void write(const Template &)
-    {
-        qFatal("Not supported");
-    }
-};
-
-BR_REGISTER(Gallery, crawlGallery)
-
-/*!
- * \ingroup galleries
- * \brief Treats the gallery as a br::Format.
- * \author Josh Klontz \cite jklontz
- */
-class DefaultGallery : public Gallery
-{
-    Q_OBJECT
-
-    TemplateList readBlock(bool *done)
-    {
-        *done = true;
-        return TemplateList() << file;
-    }
-
-    void write(const Template &t)
-    {
-        QScopedPointer<Format> format(Factory<Format>::make(file));
-        format->write(t);
-    }
-
-    qint64 totalSize()
-    {
-        return 1;
-    }
-};
-
-BR_REGISTER(Gallery, DefaultGallery)
-
-/*!
- * \ingroup galleries
- * \brief Combine all templates into one large matrix and process it as a br::Format
- * \author Josh Klontz \cite jklontz
- */
-class matrixGallery : public Gallery
-{
-    Q_OBJECT
-    Q_PROPERTY(const QString extension READ get_extension WRITE set_extension RESET reset_extension STORED false)
-    BR_PROPERTY(QString, extension, "mtx")
-
-    TemplateList templates;
-
-    ~matrixGallery()
-    {
-        if (templates.isEmpty())
-            return;
-
-        QScopedPointer<Format> format(Factory<Format>::make(getFormat()));
-        format->write(Template(file, OpenCVUtils::toMat(templates.data())));
-    }
-
-    File getFormat() const
-    {
-        return file.name.left(file.name.size() - file.suffix().size()) + extension;
-    }
-
-    TemplateList readBlock(bool *done)
-    {
-        *done = true;
-        return TemplateList() << getFormat();
-    }
-
-    void write(const Template &t)
-    {
-        templates.append(t);
-    }
-};
-
-BR_REGISTER(Gallery, matrixGallery)
-
-/*!
- * \ingroup initializers
- * \brief Initialization support for memGallery.
- * \author Josh Klontz \cite jklontz
- */
-class MemoryGalleries : public Initializer
-{
-    Q_OBJECT
-
-    void initialize() const {}
-
-    void finalize() const
-    {
-        galleries.clear();
-    }
-
-public:
-    static QHash<File, TemplateList> galleries; /*!< TODO */
-};
-
-QHash<File, TemplateList> MemoryGalleries::galleries;
-
-BR_REGISTER(Initializer, MemoryGalleries)
-
-/*!
- * \ingroup galleries
- * \brief A gallery held in memory.
- * \author Josh Klontz \cite jklontz
- */
-class memGallery : public Gallery
-{
-    Q_OBJECT
-    int block;
-    qint64 gallerySize;
-
-    void init()
-    {
-        block = 0;
-        File galleryFile = file.name.mid(0, file.name.size()-4);
-        if ((galleryFile.suffix() == "gal") && galleryFile.exists() && !MemoryGalleries::galleries.contains(file)) {
-            QSharedPointer<Gallery> gallery(Factory<Gallery>::make(galleryFile));
-            MemoryGalleries::galleries[file] = gallery->read();
-            gallerySize = MemoryGalleries::galleries[file].size();
-        }
-    }
-
-    TemplateList readBlock(bool *done)
-    {
-        TemplateList templates = MemoryGalleries::galleries[file].mid(block*readBlockSize, readBlockSize);
-        for (qint64 i = 0; i < templates.size();i++) {
-            templates[i].file.set("progress", i + block * readBlockSize);
-        }
-
-        *done = (templates.size() < readBlockSize);
-        block = *done ? 0 : block+1;
-        return templates;
-    }
-
-    void write(const Template &t)
-    {
-        MemoryGalleries::galleries[file].append(t);
-    }
-
-    qint64 totalSize()
-    {
-        return gallerySize;
-    }
-
-    qint64 position()
-    {
-        return block * readBlockSize;
-    }
-
-};
-
-BR_REGISTER(Gallery, memGallery)
-
-FileList FileList::fromGallery(const File &rFile, bool cache)
-{
-    File file = rFile;
-    file.remove("append");
-
-    File targetMeta = file;
-    targetMeta.name = targetMeta.path() + targetMeta.baseName() + "_meta" + targetMeta.hash() + ".mem";
-
-    FileList fileData;
-
-    // Did we already read the data?
-    if (MemoryGalleries::galleries.contains(targetMeta))
-    {
-        return MemoryGalleries::galleries[targetMeta].files();
-    }
-
-    TemplateList templates;
-    // OK we read the data in some form, does the gallery type containing matrices?
-    if ((QStringList() << "gal" << "mem" << "template" << "ut").contains(file.suffix())) {
-        // Retrieve it block by block, dropping matrices from read templates.
-        QScopedPointer<Gallery> gallery(Gallery::make(file));
-        gallery->set_readBlockSize(10);
-        bool done = false;
-        while (!done)
-        {
-            TemplateList tList = gallery->readBlock(&done);
-            for (int i=0; i < tList.size();i++)
-            {
-                tList[i].clear();
-                templates.append(tList[i].file);
-            }
-        }
-    }
-    else {
-        // this is a gallery format that doesn't include matrices, so we can just read it
-        QScopedPointer<Gallery> gallery(Gallery::make(file));
-        templates= gallery->read();
-    }
-
-    if (cache)
-    {
-        QScopedPointer<Gallery> memOutput(Gallery::make(targetMeta));
-        memOutput->writeBlock(templates);
-    }
-    fileData = templates.files();
-    return fileData;
-}
-
-/*!
- * \ingroup galleries
- * \brief Treats each line as a file.
- * \author Josh Klontz \cite jklontz
- *
- * Columns should be comma separated with first row containing headers.
- * The first column in the file should be the path to the file to enroll.
- * Other columns will be treated as file metadata.
- *
- * \see txtGallery
- */
-class csvGallery : public FileGallery
-{
-    Q_OBJECT
-    Q_PROPERTY(int fileIndex READ get_fileIndex WRITE set_fileIndex RESET reset_fileIndex)
-    BR_PROPERTY(int, fileIndex, 0)
-
-    FileList files;
-    QStringList headers;
-
-    ~csvGallery()
-    {
-        f.close();
-
-        if (files.isEmpty()) return;
-
-        QMap<QString,QVariant> samples;
-        foreach (const File &file, files)
-            foreach (const QString &key, file.localKeys())
-                if (!samples.contains(key))
-                    samples.insert(key, file.value(key));
-
-        // Don't create columns in the CSV for these special fields
-        samples.remove("Points");
-        samples.remove("Rects");
-
-        QStringList lines;
-        lines.reserve(files.size()+1);
-
-        QMap<QString, int> columnCounts;
-        
-        { // Make header
-            QStringList words;
-            words.append("File");
-            foreach (const QString &key, samples.keys()) {
-                int count = 0;
-                words.append(getCSVElement(key, samples[key], true, count));
-                columnCounts.insert(key, count);
-            }
-            lines.append(words.join(","));
-        }
-        
-        // Make table
-        foreach (const File &file, files) {
-            QStringList words;
-            words.append(file.name);
-            foreach (const QString &key, samples.keys()) {
-                int count = columnCounts[key];
-                words.append(getCSVElement(key, file.value(key), false, count));
-            }
-            lines.append(words.join(","));
-        }
-
-        QtUtils::writeFile(file, lines);
-    }
-
-    TemplateList readBlock(bool *done)
-    {
-        readOpen();
-        *done = false;
-        TemplateList templates;
-        if (!file.exists()) {
-            *done = true;
-            return templates;
-        }
-        QRegExp regexp("\\s*,\\s*");
-
-        if (f.pos() == 0)
-        {
-            // read a line
-            QByteArray lineBytes = f.readLine();
-            QString line = QString::fromLocal8Bit(lineBytes).trimmed();
-            headers = line.split(regexp);
-        }
-
-        for (qint64 i = 0; i < this->readBlockSize && !f.atEnd(); i++){
-            QByteArray lineBytes = f.readLine();
-            QString line = QString::fromLocal8Bit(lineBytes).trimmed();
-
-            QStringList words = line.split(regexp);
-            if (words.size() != headers.size()) continue;
-            File fi;
-            for (int j=0; j<words.size(); j++) {
-                if (j == 0) fi.name = words[j];
-                else        fi.set(headers[j], words[j]);
-            }
-            templates.append(fi);
-            templates.last().file.set("progress", f.pos());
-        }
-        *done = f.atEnd();
-
-        return templates;
-    }
-
-    void write(const Template &t)
-    {
-        files.append(t.file);
-    }
-
-    static QString getCSVElement(const QString &key, const QVariant &value, bool header, int & columnCount)
-    {
-        if (header)
-            columnCount = 1;
-
-        if (value.canConvert<QString>()) {
-            if (header) return key;
-            else {
-                if (columnCount != 1)
-                    qFatal("Inconsistent datatype for key %s, csv file cannot be generated", qPrintable(key));
-                return value.value<QString>();
-            }
-        } else if (value.canConvert<QPointF>()) {
-            const QPointF point = value.value<QPointF>();
-            if (header) {
-                columnCount = 2;
-                return key+"_X,"+key+"_Y";
-            }
-            else {
-                if (columnCount != 2)
-                    qFatal("Inconsistent datatype for key %s, csv file cannot be generated", qPrintable(key));
-
-                return QString::number(point.x())+","+QString::number(point.y());
-            }
-        } else if (value.canConvert<QRectF>()) {
-            const QRectF rect = value.value<QRectF>();
-            if (header) {
-                columnCount = 4;
-                return key+"_X,"+key+"_Y,"+key+"_Width,"+key+"_Height";
-            }
-            else {
-                if (columnCount != 4)
-                    qFatal("Inconsistent datatype for key %s, csv file cannot be generated", qPrintable(key));
-
-                return QString::number(rect.x())+","+QString::number(rect.y())+","+QString::number(rect.width())+","+QString::number(rect.height());
-            }
-        } else {
-            if (header) return key;
-            else {
-                QString output = QString::number(std::numeric_limits<float>::quiet_NaN());
-                for (int i = 1; i < columnCount; i++)
-                    output += "," + QString::number(std::numeric_limits<float>::quiet_NaN());
-                return output;
-            }
-        }
-    }
-};
-
-BR_REGISTER(Gallery, csvGallery)
-
-/*!
- * \ingroup galleries
- * \brief Treats each line as a file.
- * \author Josh Klontz \cite jklontz
- *
- * The entire line is treated as the file path. An optional label may be specified using a space ' ' separator:
- *
-\verbatim
-<FILE>
-<FILE>
-...
-<FILE>
-\endverbatim
- * or
-\verbatim
-<FILE> <LABEL>
-<FILE> <LABEL>
-...
-<FILE> <LABEL>
-\endverbatim
- * \see csvGallery
- */
-class txtGallery : public FileGallery
-{
-    Q_OBJECT
-    Q_PROPERTY(QString label READ get_label WRITE set_label RESET reset_label STORED false)
-    BR_PROPERTY(QString, label, "")
-
-    TemplateList readBlock(bool *done)
-    {
-        readOpen();
-        *done = false;
-        if (f.atEnd())
-            f.seek(0);
-
-        TemplateList templates;
-
-        for (qint64 i = 0; i < readBlockSize; i++)
-        {
-            QByteArray lineBytes = f.readLine();
-            QString line = QString::fromLocal8Bit(lineBytes).trimmed();
-
-            if (!line.isEmpty()){
-                int splitIndex = line.lastIndexOf(' ');
-                if (splitIndex == -1) templates.append(File(line));
-                else                  templates.append(File(line.mid(0, splitIndex), line.mid(splitIndex+1)));
-                templates.last().file.set("progress", this->position());
-            }
-
-            if (f.atEnd()) {
-                *done=true;
-                break;
-            }
-        }
-
-        return templates;
-    }
-
-    void write(const Template &t)
-    {
-        writeOpen();
-        QString line = t.file.name;
-        if (!label.isEmpty())
-            line += " " + t.file.get<QString>(label);
-
-        f.write((line+"\n").toLocal8Bit() );
-    }
-};
-
-BR_REGISTER(Gallery, txtGallery)
-
-/*!
- * \ingroup galleries
- * \brief Treats each line as a call to File::flat()
- * \author Josh Klontz \cite jklontz
- */
-class flatGallery : public FileGallery
-{
-    Q_OBJECT
-
-    TemplateList readBlock(bool *done)
-    {
-        readOpen();
-        *done = false;
-        if (f.atEnd())
-            f.seek(0);
-
-        TemplateList templates;
-
-        for (qint64 i = 0; i < readBlockSize; i++)
-        {
-            QByteArray line = f.readLine();
-
-            if (!line.isEmpty()) {
-                templates.append(File(QString::fromLocal8Bit(line).trimmed()));
-                templates.last().file.set("progress", this->position());
-            }
-
-            if (f.atEnd()) {
-                *done=true;
-                break;
-            }
-        }
-
-        return templates;
-    }
-
-    void write(const Template &t)
-    {
-        writeOpen();
-        f.write((t.file.flat()+"\n").toLocal8Bit() );
-    }
-};
-
-BR_REGISTER(Gallery, flatGallery)
-
-/*!
- * \ingroup galleries
- * \brief A \ref sigset input.
- * \author Josh Klontz \cite jklontz
- */
-class xmlGallery : public FileGallery
-{
-    Q_OBJECT
-    Q_PROPERTY(bool ignoreMetadata READ get_ignoreMetadata WRITE set_ignoreMetadata RESET reset_ignoreMetadata STORED false)
-    BR_PROPERTY(bool, ignoreMetadata, false)
-    FileList files;
-
-    QXmlStreamReader reader;
-
-    QString currentSignatureName;
-    bool signatureActive;
-
-    ~xmlGallery()
-    {
-        f.close();
-        if (!files.isEmpty())
-            BEE::writeSigset(file, files, ignoreMetadata);
-    }
-
-    TemplateList readBlock(bool *done)
-    {
-        if (readOpen())
-            reader.setDevice(&f);
-
-        if (reader.atEnd())
-            f.seek(0);
-
-        TemplateList templates;
-        qint64 count = 0;
-
-        while (!reader.atEnd())
-        {
-            // if an identity is active we try to read presentations
-            if (signatureActive)
-            {
-                while (signatureActive)
-                {
-                    QXmlStreamReader::TokenType signatureToken = reader.readNext();
-
-                    // did the signature end?
-                    if (signatureToken == QXmlStreamReader::EndElement && reader.name() == "biometric-signature") {
-                        signatureActive = false;
-                        break;
-                    }
-
-                    // did we reach the end of the document? Theoretically this shoudln't happen without reaching the end of
-                    if (signatureToken == QXmlStreamReader::EndDocument)
-                        break;
-
-                    // a presentation!
-                    if (signatureToken == QXmlStreamReader::StartElement && reader.name() == "presentation") {
-                        templates.append(Template(File("",currentSignatureName)));
-                        foreach (const QXmlStreamAttribute &attribute, reader.attributes()) {
-                            // file-name is stored directly on file, not as a key/value pair
-                            if (attribute.name() == "file-name")
-                                templates.last().file.name = attribute.value().toString();
-                            // other values are directly set as metadata
-                            else if (!ignoreMetadata) templates.last().file.set(attribute.name().toString(), attribute.value().toString());
-                        }
-
-                        // a presentation can have bounding boxes as child elements
-                        QList<QRectF> rects = templates.last().file.rects();
-                        while (true)
-                        {
-                            QXmlStreamReader::TokenType pToken = reader.readNext();
-                            if (pToken == QXmlStreamReader::EndElement && reader.name() == "presentation")
-                                break;
-
-                            if (pToken == QXmlStreamReader::StartElement)
-                            {
-                                if (reader.attributes().hasAttribute("x")
-                                    && reader.attributes().hasAttribute("y")
-                                    && reader.attributes().hasAttribute("width")
-                                    && reader.attributes().hasAttribute("height") )
-                                {
-                                    // get bounding box properties as attributes, just going to assume this all works
-                                    qreal x = reader.attributes().value("x").string()->toDouble();
-                                    qreal y = reader.attributes().value("y").string()->toDouble();
-                                    qreal width =  reader.attributes().value("width").string()->toDouble();
-                                    qreal height = reader.attributes().value("height").string()->toDouble();
-                                    rects += QRectF(x, y, width, height);
-                                }
-                            }
-                        }
-                        templates.last().file.setRects(rects);
-                        templates.last().file.set("progress", f.pos());
-
-                        // we read another complete template
-                        count++;
-                    }
-                }
-            }
-            // otherwise, keep reading elements until the next identity is reacehed
-            else
-            {
-                QXmlStreamReader::TokenType token = reader.readNext();
-
-                // end of file?
-                if (token == QXmlStreamReader::EndDocument)
-                    break;
-
-                // we are only interested in new elements
-                if (token != QXmlStreamReader::StartElement)
-                    continue;
-
-                QStringRef elName = reader.name();
-
-                // biometric-signature-set is the root element
-                if (elName == "biometric-signature-set")
-                    continue;
-
-                // biometric-signature -- an identity
-                if (elName == "biometric-signature")
-                {
-                    // read the name associated with the current signature
-                    if (!reader.attributes().hasAttribute("name"))
-                    {
-                        qDebug() << "Biometric signature missing name";
-                        continue;
-                    }
-                    currentSignatureName = reader.attributes().value("name").toString();
-                    signatureActive = true;
-
-                    // If we've already read enough templates for this block, then break here.
-                    // We wait untill the start of the next signature to be sure that done should
-                    // actually be false (i.e. there are actually items left in this file)
-                    if (count >= this->readBlockSize) {
-                        *done = false;
-                        return templates;
-                    }
-
-                }
-            }
-        }
-        *done = true;
-
-        return templates;
-    }
-
-    void write(const Template &t)
-    {
-        files.append(t.file);
-    }
-
-    void init()
-    {
-        FileGallery::init();
-    }
-};
-
-BR_REGISTER(Gallery, xmlGallery)
-
-/*!
- * \ingroup galleries
- * \brief Treat the file as a single binary template.
- * \author Josh Klontz \cite jklontz
- */
-class templateGallery : public Gallery
-{
-    Q_OBJECT
-
-    TemplateList readBlock(bool *done)
-    {
-        *done = true;
-        QByteArray data;
-        QtUtils::readFile(file.name.left(file.name.size()-QString(".template").size()), data);
-        return TemplateList() << Template(file, cv::Mat(1, data.size(), CV_8UC1, data.data()).clone());
-    }
-
-    void write(const Template &t)
-    {
-        (void) t;
-        qFatal("No supported.");
-    }
-
-    void init()
-    {
-        //
-    }
-};
-
-BR_REGISTER(Gallery, templateGallery)
-
-/*!
- * \ingroup galleries
- * \brief Database input.
- * \author Josh Klontz \cite jklontz
- */
-class dbGallery : public Gallery
-{
-    Q_OBJECT
-
-    TemplateList readBlock(bool *done)
-    {
-        TemplateList templates;
-        br::File import = file.get<QString>("import", "");
-        QString query = file.get<QString>("query");
-        QString subset = file.get<QString>("subset", "");
-
-#ifndef BR_EMBEDDED
-        QSqlDatabase db = QSqlDatabase::addDatabase("QSQLITE");
-        db.setDatabaseName(file);
-        if (!db.open()) qFatal("Failed to open SQLite database %s.", qPrintable(file.name));
-
-        if (!import.isNull()) {
-            qDebug("Parsing %s", qPrintable(import.name));
-            QStringList lines = QtUtils::readLines(import);
-            QList<QStringList> cells; cells.reserve(lines.size());
-            const QRegExp re("\\s*,\\s*");
-            foreach (const QString &line, lines) {
-                cells.append(line.split(re));
-                if (cells.last().size() != cells.first().size()) qFatal("Column count mismatch.");
-            }
-
-            QStringList columns, qMarks;
-            QList<QVariantList> variantLists;
-            for (int i=0; i<cells[0].size(); i++) {
-                bool isNumeric;
-                cells[1][i].toInt(&isNumeric);
-                columns.append(cells[0][i] + (isNumeric ? " INTEGER" : " STRING"));
-                qMarks.append("?");
-
-                QVariantList variantList; variantList.reserve(lines.size()-1);
-                for (int j=1; j<lines.size(); j++) {
-                    if (isNumeric) variantList << cells[j][i].toInt();
-                    else           variantList << cells[j][i];
-                }
-                variantLists.append(variantList);
-            }
-
-            const QString &table = import.baseName();
-            qDebug("Creating table %s", qPrintable(table));
-            QSqlQuery q(db);
-            if (!q.exec("CREATE TABLE " + table + " (" + columns.join(", ") + ");"))
-                qFatal("%s.", qPrintable(q.lastError().text()));
-            if (!q.prepare("insert into " + table + " values (" + qMarks.join(", ") + ")"))
-                qFatal("%s.", qPrintable(q.lastError().text()));
-            foreach (const QVariantList &vl, variantLists)
-                q.addBindValue(vl);
-            if (!q.execBatch()) qFatal("%s.", qPrintable(q.lastError().text()));
-        }
-
-        QSqlQuery q(db);
-        if (query.startsWith('\'') && query.endsWith('\''))
-            query = query.mid(1, query.size()-2);
-        if (!q.exec(query))
-            qFatal("%s.", qPrintable(q.lastError().text()));
-
-        if ((q.record().count() == 0) || (q.record().count() > 3))
-            qFatal("Query record expected one to three fields, got %d.", q.record().count());
-        const bool hasMetadata = (q.record().count() >= 2);
-        const bool hasFilter = (q.record().count() >= 3);
-
-        QString labelName = "Label";
-        if (q.record().count() >= 2)
-            labelName = q.record().fieldName(1);
-
-        // subset = seed:subjectMaxSize:numSubjects:subjectMinSize or
-        // subset = seed:{Metadata,...,Metadata}:numSubjects
-        int seed = 0, subjectMaxSize = std::numeric_limits<int>::max(), numSubjects = std::numeric_limits<int>::max(), subjectMinSize = 0;
-        QList<QRegExp> metadataFields;
-        if (!subset.isEmpty()) {
-            const QStringList &words = subset.split(":");
-            QtUtils::checkArgsSize("Input", words, 2, 4);
-            if      (words[0] == "train") seed = 0;
-            else if (words[0] == "test" ) seed = 1;
-            else                          seed = QtUtils::toInt(words[0]);
-            if (words[1].startsWith('{') && words[1].endsWith('}')) {
-                foreach (const QString &regexp, words[1].mid(1, words[1].size()-2).split(","))
-                    metadataFields.append(QRegExp(regexp));
-                subjectMaxSize = metadataFields.size();
-            } else {
-                subjectMaxSize = QtUtils::toInt(words[1]);
-            }
-            numSubjects = words.size() >= 3 ? QtUtils::toInt(words[2]) : std::numeric_limits<int>::max();
-            subjectMinSize = words.size() >= 4 ? QtUtils::toInt(words[3]) : subjectMaxSize;
-        }
-
-        srand(seed);
-
-        typedef QPair<QString,QString> Entry; // QPair<File,Metadata>
-        QHash<QString, QList<Entry> > entries; // QHash<Label, QList<Entry> >
-        while (q.next()) {
-            if (hasFilter && (seed >= 0) && (qHash(q.value(2).toString()) % 2 != (uint)seed % 2)) continue; // Ensures training and testing filters don't overlap
-
-            if (metadataFields.isEmpty())
-                entries[hasMetadata ? q.value(1).toString() : ""].append(QPair<QString,QString>(q.value(0).toString(), hasFilter ? q.value(2).toString() : ""));
-            else
-                entries[hasFilter ? q.value(2).toString() : ""].append(QPair<QString,QString>(q.value(0).toString(), hasMetadata ? q.value(1).toString() : ""));
-        }
-
-        QStringList labels = entries.keys();
-        qSort(labels);
-
-        if (hasFilter && ((labels.size() > numSubjects) || (numSubjects == std::numeric_limits<int>::max())))
-            std::random_shuffle(labels.begin(), labels.end());
-
-        foreach (const QString &label, labels) {
-            QList<Entry> entryList = entries[label];
-            if ((entryList.size() >= subjectMinSize) && (numSubjects > 0)) {
-
-                if (!metadataFields.isEmpty()) {
-                    QList<Entry> subEntryList;
-                    foreach (const QRegExp &metadata, metadataFields) {
-                        for (int i=0; i<entryList.size(); i++) {
-                            if (metadata.exactMatch(entryList[i].second)) {
-                                subEntryList.append(entryList.takeAt(i));
-                                break;
-                            }
-                        }
-                    }
-                    if (subEntryList.size() == metadataFields.size())
-                        entryList = subEntryList;
-                    else
-                        continue;
-                }
-
-                if (entryList.size() > subjectMaxSize)
-                    std::random_shuffle(entryList.begin(), entryList.end());
-                foreach (const Entry &entry, entryList.mid(0, subjectMaxSize)) {
-                    templates.append(File(entry.first));
-                    templates.last().file.set(labelName, label);
-                }
-                numSubjects--;
-            }
-        }
-
-        db.close();
-#endif // BR_EMBEDDED
-
-        *done = true;
-        return templates;
-    }
-
-    void write(const Template &t)
-    {
-        (void) t;
-        qFatal("Not supported.");
-    }
-
-    void init()
-    {
-        //
-    }
-};
-
-BR_REGISTER(Gallery, dbGallery)
-
-/*!
- * \ingroup inputs
- * \brief Input from a google image search.
- * \author Josh Klontz \cite jklontz
- */
-class googleGallery : public Gallery
-{
-    Q_OBJECT
-
-    TemplateList readBlock(bool *done)
-    {
-        TemplateList templates;
-
-        static const QString search = "http://images.google.com/images?q=%1&start=%2";
-        QString query = file.name.left(file.name.size()-7); // remove ".google"
-
-#ifndef BR_EMBEDDED
-        QNetworkAccessManager networkAccessManager;
-        for (int i=0; i<100; i+=20) { // Retrieve 100 images
-            QNetworkRequest request(search.arg(query, QString::number(i)));
-            QNetworkReply *reply = networkAccessManager.get(request);
-
-            while (!reply->isFinished())
-                QThread::yieldCurrentThread();
-
-            QString data(reply->readAll());
-            delete reply;
-
-            QStringList words = data.split("imgurl=");
-            words.takeFirst(); // Remove header
-            foreach (const QString &word, words) {
-                QString url = word.left(word.indexOf("&amp"));
-                url = url.replace("%2520","%20");
-                int junk = url.indexOf('%', url.lastIndexOf('.'));
-                if (junk != -1) url = url.left(junk);
-                templates.append(File(url,query));
-            }
-        }
-#endif // BR_EMBEDDED
-
-        *done = true;
-        return templates;
-    }
-
-    void write(const Template &)
-    {
-        qFatal("Not supported.");
-    }
-};
-
-BR_REGISTER(Gallery, googleGallery)
-
-/*!
- * \ingroup galleries
- * \brief Print template statistics.
- * \author Josh Klontz \cite jklontz
- */
-class statGallery : public Gallery
-{
-    Q_OBJECT
-    QSet<QString> subjects;
-    QList<int> bytes;
-
-    ~statGallery()
-    {
-        int emptyTemplates = 0;
-        for (int i=bytes.size()-1; i>=0; i--)
-            if (bytes[i] == 0) {
-                bytes.removeAt(i);
-                emptyTemplates++;
-            }
-
-        double bytesMean, bytesStdDev;
-        Common::MeanStdDev(bytes, &bytesMean, &bytesStdDev);
-        printf("Subjects: %d\nEmpty Templates: %d/%d\nBytes/Template: %.4g +/- %.4g\n",
-               subjects.size(), emptyTemplates, emptyTemplates+bytes.size(), bytesMean, bytesStdDev);
-    }
-
-    TemplateList readBlock(bool *done)
-    {
-        *done = true;
-        return TemplateList() << file;
-    }
-
-    void write(const Template &t)
-    {
-        subjects.insert(t.file.get<QString>("Label"));
-        bytes.append(t.bytes());
-    }
-};
-
-BR_REGISTER(Gallery, statGallery)
-
-/*!
- * \ingroup galleries
- * \brief Implements the FDDB detection format.
- * \author Josh Klontz \cite jklontz
- *
- * http://vis-www.cs.umass.edu/fddb/README.txt
- */
-class FDDBGallery : public Gallery
-{
-    Q_OBJECT
-
-    TemplateList readBlock(bool *done)
-    {
-        *done = true;
-        QStringList lines = QtUtils::readLines(file);
-        TemplateList templates;
-        while (!lines.empty()) {
-            const QString fileName = lines.takeFirst();
-            int numDetects = lines.takeFirst().toInt();
-            for (int i=0; i<numDetects; i++) {
-                const QStringList detect = lines.takeFirst().split(' ');
-                Template t(fileName);
-                QList<QVariant> faceList; //to be consistent with slidingWindow
-                if (detect.size() == 5) { //rectangle
-                    faceList.append(QRectF(detect[0].toFloat(), detect[1].toFloat(), detect[2].toFloat(), detect[3].toFloat()));
-                    t.file.set("Confidence", detect[4].toFloat());
-                } else if (detect.size() == 6) { //ellipse
-                    float x = detect[3].toFloat(),  
-                          y = detect[4].toFloat(),
-                          radius = detect[1].toFloat();
-                    faceList.append(QRectF(x - radius,y - radius,radius * 2.0, radius * 2.0));
-                    t.file.set("Confidence", detect[5].toFloat());
-                } else {
-                    qFatal("Unknown FDDB annotation format.");
-                }
-                t.file.set("Face", faceList);
-                t.file.set("Label",QString("face"));
-                templates.append(t);
-            }
-        }
-        return templates;
-    }
-
-    void write(const Template &t)
-    {
-        (void) t;
-        qFatal("Not implemented.");
-    }
-
-    void init()
-    {
-        //
-    }
-};
-
-BR_REGISTER(Gallery, FDDBGallery)
-
-/*!
- * \ingroup galleries
- * \brief Text format for associating anonymous landmarks with images.
- * \author Josh Klontz \cite jklontz
- *
- * \code
- * file_name:x1,y1,x2,y2,...,xn,yn
- * file_name:x1,y1,x2,y2,...,xn,yn
- * ...
- * file_name:x1,y1,x2,y2,...,xn,yn
- * \endcode
- */
-class landmarksGallery : public Gallery
-{
-    Q_OBJECT
-
-    TemplateList readBlock(bool *done)
-    {
-        *done = true;
-        TemplateList templates;
-        foreach (const QString &line, QtUtils::readLines(file)) {
-            const QStringList words = line.split(':');
-            if (words.size() != 2) qFatal("Expected exactly one ':' in: %s.", qPrintable(line));
-            File file(words[0]);
-            const QList<float> vals = QtUtils::toFloats(words[1].split(','));
-            if (vals.size() % 2 != 0) qFatal("Expected an even number of comma-separated values.");
-            QList<QPointF> points; points.reserve(vals.size()/2);
-            for (int i=0; i<vals.size(); i+=2)
-                points.append(QPointF(vals[i], vals[i+1]));
-            file.setPoints(points);
-            templates.append(file);
-        }
-        return templates;
-    }
-
-    void write(const Template &t)
-    {
-        (void) t;
-        qFatal("Not implemented.");
-    }
-
-    void init()
-    {
-        //
-    }
-};
-
-BR_REGISTER(Gallery, landmarksGallery)
-
-#ifdef CVMATIO
-
-using namespace cv;
-
-class vbbGallery : public Gallery
-{
-    Q_OBJECT
-
-    void init()
-    {
-        MatlabIO matio;
-        QString filename = (Globals->path.isEmpty() ? "" : Globals->path + "/") + file.name;
-        bool ok = matio.open(filename.toStdString(), "r");
-        if (!ok) qFatal("Couldn't open the vbb file");
-
-        vector<MatlabIOContainer> variables;
-        variables = matio.read();
-        matio.close();
-
-        double vers = variables[1].data<Mat>().at<double>(0,0);
-        if (vers != 1.4) qFatal("This is an old vbb version, we don't mess with that.");
-
-        A = variables[0].data<vector<vector<MatlabIOContainer> > >().at(0);
-        objLists = A.at(1).data<vector<MatlabIOContainer> >();
-
-        // start at the first frame (duh!)
-        currFrame = 0;
-    }
-
-    TemplateList readBlock(bool *done)
-    {
-        *done = false;
-        Template rects(file);
-        if (objLists[currFrame].typeEquals<vector<vector<MatlabIOContainer> > >()) {
-            vector<vector<MatlabIOContainer> > bbs = objLists[currFrame].data<vector<vector<MatlabIOContainer> > >();
-            for (unsigned int i=0; i<bbs.size(); i++) {
-                vector<MatlabIOContainer> bb = bbs[i];
-                Mat pos = bb[1].data<Mat>();
-                double left = pos.at<double>(0,0);
-                double top = pos.at<double>(0,1);
-                double width = pos.at<double>(0,2);
-                double height = pos.at<double>(0,3);
-                rects.file.appendRect(QRectF(left, top, width, height));
-            }
-        }
-        TemplateList tl;
-        tl.append(rects);
-        if (++currFrame == (int)objLists.size()) *done = true;
-        return tl;
-    }
-
-    void write(const Template &t)
-    {
-        (void)t; qFatal("Not implemented");
-    }
-
-private:
-    // this holds a bunch of stuff, maybe we'll use it all later
-    vector<MatlabIOContainer> A;
-    // this, a field in A, holds bounding boxes for each frame
-    vector<MatlabIOContainer> objLists;
-    int currFrame;
-};
-
-BR_REGISTER(Gallery, vbbGallery)
-
-#endif
-
-
-// Read a video frame by frame using cv::VideoCapture
-class videoGallery : public Gallery
-{
-    Q_OBJECT
-public:
-    qint64 idx;
-    ~videoGallery()
-    {
-        video.release();
-    }
-
-    static QMutex openLock;
-
-    virtual void deferredInit()
-    {
-        bool status = video.open(QtUtils::getAbsolutePath(file.name).toStdString());
-
-        if (!status)
-            qFatal("Failed to open file %s with path %s", qPrintable(file.name), qPrintable(QtUtils::getAbsolutePath(file.name)));
-    }
-
-    TemplateList readBlock(bool *done)
-    {
-        if (!video.isOpened()) {
-            // opening videos appears to not be thread safe on windows
-            QMutexLocker lock(&openLock);
-
-            deferredInit();
-            idx = 0;
-        }
-
-        Template output;
-        output.file = file;
-        output.m() = cv::Mat();
-
-        cv::Mat temp;
-        bool res = video.read(temp);
-
-        if (!res) {
-            // The video capture broke, return an empty list.
-            output.m() = cv::Mat();
-            video.release();
-            *done = true;
-            return TemplateList();
-        }
-
-        // This clone is critical, if we don't do it then the output matrix will
-        // be an alias of an internal buffer of the video source, leading to various
-        // problems later.
-        output.m() = temp.clone();
-
-        output.file.set("progress", idx);
-        idx++;
-
-        TemplateList rVal;
-        rVal.append(temp);
-        *done = false;
-        return rVal;
-    }
-
-    void write(const Template &t)
-    {
-        (void)t; qFatal("Not implemented");
-    }
-
-protected:
-    cv::VideoCapture video;
-};
-BR_REGISTER(Gallery,videoGallery)
-
-QMutex videoGallery::openLock;
-
-class aviGallery : public videoGallery
-{
-    Q_OBJECT
-};
-BR_REGISTER(Gallery, aviGallery)
-
-class wmvGallery : public videoGallery
-{
-    Q_OBJECT
-};
-BR_REGISTER(Gallery, wmvGallery)
-
-// Mostly the same as videoGallery, but we open the VideoCapture with an integer index
-// rather than file name/web address
-class webcamGallery : public videoGallery
-{
-public:
-    Q_OBJECT
-
-    void deferredInit()
-    {
-        bool intOK = false;
-        int anInt = file.baseName().toInt(&intOK);
-
-        if (!intOK)
-            qFatal("Expected integer basename, got %s", qPrintable(file.baseName()));
-
-        bool rc = video.open(anInt);
-
-        if (!rc)
-            qFatal("Failed to open webcam with index: %s", qPrintable(file.baseName()));
-    }
-
-};
-BR_REGISTER(Gallery,webcamGallery)
-
-class seqGallery : public Gallery
-{
-public:
-    Q_OBJECT
-
-    bool open()
-    {
-        seqFile.open(QtUtils::getAbsolutePath(file.name).toStdString().c_str(), std::ios::in | std::ios::binary | std::ios::ate);
-        if (!isOpen()) {
-            qDebug("Failed to open file %s for reading", qPrintable(file.name));
-            return false;
-        }
-
-        int headSize = 1024;
-        // start at end of file to get full size
-        int fileSize = seqFile.tellg();
-        if (fileSize < headSize) {
-            qDebug("No header in seq file");
-            return false;
-        }
-
-        // first 4 bytes store 0xEDFE, next 24 store 'Norpix seq  '
-        char firstFour[4];
-        seqFile.seekg(0, std::ios::beg);
-        seqFile.read(firstFour, 4);
-        char nextTwentyFour[24];
-        readText(24, nextTwentyFour);
-        if (firstFour[0] != (char)0xED || firstFour[1] != (char)0xFE || strncmp(nextTwentyFour, "Norpix seq", 10) != 0) {
-            qDebug("Invalid header in seq file");
-            return false;
-        }
-
-        // next 8 bytes for version (skipped below) and header size (1024), then 512 for descr
-        seqFile.seekg(4, std::ios::cur);
-        int hSize = readInt();
-        if (hSize != headSize) {
-            qDebug("Invalid header size");
-            return false;
-        }
-        char desc[512];
-        readText(512, desc);
-        file.set("Description", QString(desc));
-
-        width = readInt();
-        height = readInt();
-        // get # channels from bit depth
-        numChan = readInt()/8;
-        int imageBitDepthReal = readInt();
-        if (imageBitDepthReal != 8) {
-            qDebug("Invalid bit depth");
-            return false;
-        }
-        // the size of just the image part of a raw img
-        imgSizeBytes = readInt();
-
-        int imgFormatInt = readInt();
-        if (imgFormatInt == 100 || imgFormatInt == 200 || imgFormatInt == 101) {
-            imgFormat = "raw";
-        } else if (imgFormatInt == 102 || imgFormatInt == 201 || imgFormatInt == 103 ||
-                   imgFormatInt == 1 || imgFormatInt == 2) {
-            imgFormat = "compressed";
-        } else {
-            qFatal("unsupported image format");
-        }
-
-        numFrames = readInt();
-        // skip empty int
-        seqFile.seekg(4, std::ios::cur);
-        // the size of a full raw file, with extra crap after img data
-        trueImgSizeBytes = readInt();
-
-        // gather all the frame positions in an array
-        seekPos.reserve(numFrames);
-        // start at end of header
-        seekPos.append(headSize);
-        // extra 8 bytes at end of img
-        int extra = 8;
-        for (int i=1; i<numFrames; i++) {
-            int s;
-            // compressed images have different sizes
-            // the first byte at the beginning of the file
-            // says how big the current img is
-            if (imgFormat == "compressed") {
-                int lastPos = seekPos[i-1];
-                seqFile.seekg(lastPos, std::ios::beg);
-                int currSize = readInt();
-                s = lastPos + currSize + extra;
-
-                // but there might be 16 extra bytes instead of 8...
-                if (i == 1) {
-                    seqFile.seekg(s, std::ios::beg);
-                    char zero;
-                    seqFile.read(&zero, 1);
-                    if (zero == 0) {
-                        s += 8;
-                        extra += 8;
-                    }
-                }
-            }
-            // raw images are all the same size
-            else {
-                s = headSize + (i*trueImgSizeBytes);
-            }
-
-            seekPos.enqueue(s);
-        }
-
-#ifdef CVMATIO
-        if (basis.file.contains("vbb")) {
-            QString vbb = basis.file.get<QString>("vbb");
-            annotations = TemplateList::fromGallery(File(vbb));
-        }
-#else
-        qWarning("cvmatio not installed, bounding boxes will not be available. Add -DBR_WITH_CVMATIO cmake flag to install.");
-#endif
-
-        return true;
-    }
-
-    bool isOpen()
-    {
-        return seqFile.is_open();
-    }
-
-    void close()
-    {
-        seqFile.close();
-    }
-
-    TemplateList readBlock(bool *done)
-    {
-        if (!isOpen()) {
-            if (!open())
-                qFatal("Failed to open file %s for reading", qPrintable(file.name));
-            else
-                idx = 0;
-        }
-
-        // if we've reached the last frame, we're done
-        if (seekPos.size() == 0) {
-            *done = true;
-            return TemplateList();
-        }
-
-        seqFile.seekg(seekPos.dequeue(), std::ios::beg);
-
-        cv::Mat temp;
-        // let imdecode do all the work to decode the compressed img
-        if (imgFormat == "compressed") {
-            int imgSize = readInt() - 4;
-            std::vector<char> imgBuf(imgSize);
-            seqFile.read(&imgBuf[0], imgSize);
-            // flags < 0 means load image as-is (keep color info if available)
-            cv::imdecode(imgBuf, -1, &temp);
-        }
-        // raw images can be loaded straight into a Mat
-        else {
-            char *imgBuf = new char[imgSizeBytes];
-            seqFile.read(imgBuf, imgSizeBytes);
-            int type = (numChan == 1 ? CV_8UC1 : CV_8UC3);
-            temp = cv::Mat(height, width, type, imgBuf);
-        }
-        Template output;
-        output.file = file;
-        if (!annotations.empty()) {
-            output.file.setRects(annotations.first().file.rects());
-            annotations.removeFirst();
-        }
-        output.m() = temp;
-        output.file.set("position",idx);
-        idx++;
-
-        *done = false;
-        TemplateList rVal;
-        rVal.append(output);
-
-        return rVal;
-    }
-
-    void write(const Template &t)
-    {
-        (void) t;
-        qFatal("Not implemented.");
-    }
-
-private:
-    qint64 idx;
-    int readInt()
-    {
-        int num;
-        seqFile.read((char*)&num, 4);
-        return num;
-    }
-
-    // apparently the text in seq files is 16 bit characters (UTF-16?)
-    // since we don't really need the last byte, snad since it gets interpreted as
-    // a terminating char, let's just grab the first byte for storage
-    void readText(int bytes, char *buffer)
-    {
-        seqFile.read(buffer, bytes);
-        for (int i=0; i<bytes; i+=2) {
-            buffer[i/2] = buffer[i];
-        }
-        buffer[bytes/2] = '\0';
-    }
-
-protected:
-    std::ifstream seqFile;
-    QQueue<int> seekPos;
-    int width, height, numChan, imgSizeBytes, trueImgSizeBytes, numFrames;
-    QString imgFormat;
-    TemplateList annotations;
-};
-BR_REGISTER(Gallery, seqGallery)
-
-void FileGallery::init()
-{
-    f.setFileName(file);
-
-    Gallery::init();
-}
-
-void FileGallery::writeOpen()
-{
-    if (!f.isOpen() ) {
-        QtUtils::touchDir(f);
-        if (!f.open(QFile::WriteOnly))
-            qFatal("Failed to open %s for writing.", qPrintable(file));
-    }
-}
-
-bool FileGallery::readOpen()
-{
-    if (!f.isOpen() ) {
-        if (!f.exists() ) {
-            qFatal("File %s does not exist.", qPrintable(file));
-        }
-
-        if (!f.open(QFile::ReadOnly))
-            qFatal("Failed to open %s for reading.", qPrintable(file));
-        return true;
-    }
-    return false;
-}
-
-qint64 FileGallery::totalSize()
-{
-    readOpen();
-    return f.size();
-}
-
-
-} // namespace br
-
-#include "gallery.moc"
diff --git a/openbr/plugins/gallery/arff.cpp b/openbr/plugins/gallery/arff.cpp
new file mode 100644
index 0000000..a2d5c41
--- /dev/null
+++ b/openbr/plugins/gallery/arff.cpp
@@ -0,0 +1,67 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * 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 galleries
+ * \brief Weka ARFF file format.
+ * \author Josh Klontz \cite jklontz
+ * http://weka.wikispaces.com/ARFF+%28stable+version%29
+ */
+class arffGallery : public Gallery
+{
+    Q_OBJECT
+    QFile arffFile;
+
+    TemplateList readBlock(bool *done)
+    {
+        (void) done;
+        qFatal("Not implemented.");
+        return TemplateList();
+    }
+
+    void write(const Template &t)
+    {
+        if (!arffFile.isOpen()) {
+            arffFile.setFileName(file.name);
+            arffFile.open(QFile::WriteOnly);
+            arffFile.write("% OpenBR templates\n"
+                           "@RELATION OpenBR\n"
+                           "\n");
+
+            const int dimensions = t.m().rows * t.m().cols;
+            for (int i=0; i<dimensions; i++)
+                arffFile.write(qPrintable("@ATTRIBUTE v" + QString::number(i) + " REAL\n"));
+            arffFile.write(qPrintable("@ATTRIBUTE class string\n"));
+
+            arffFile.write("\n@DATA\n");
+        }
+
+        arffFile.write(qPrintable(OpenCVUtils::matrixToStringList(t).join(',')));
+        arffFile.write(qPrintable(",'" + t.file.get<QString>("Label") + "'\n"));
+    }
+};
+
+BR_REGISTER(Gallery, arffGallery)
+
+} // namespace br
+
+#include "gallery/arff.moc"
diff --git a/openbr/plugins/gallery/binary.cpp b/openbr/plugins/gallery/binary.cpp
new file mode 100644
index 0000000..b92c4d0
--- /dev/null
+++ b/openbr/plugins/gallery/binary.cpp
@@ -0,0 +1,415 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * 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 <QJsonObject>
+#include <QJsonParseError>
+#include <QUrl>
+
+#ifdef _WIN32
+#include <io.h>
+#include <fcntl.h>
+#endif // _WIN32
+
+#include <openbr/plugins/openbr_internal.h>
+#include <openbr/core/qtutils.h>
+#include <openbr/universal_template.h>
+
+namespace br
+{
+
+class BinaryGallery : public Gallery
+{
+    Q_OBJECT
+
+    void init()
+    {
+        const QString baseName = file.baseName();
+
+        if (baseName == "stdin") {
+#ifdef _WIN32
+            if(_setmode(_fileno(stdin), _O_BINARY) == -1)
+                qFatal("Failed to set stdin to binary mode!");
+#endif // _WIN32
+
+            gallery.open(stdin, QFile::ReadOnly);
+        } else if (baseName == "stdout") {
+#ifdef _WIN32
+            if(_setmode(_fileno(stdout), _O_BINARY) == -1)
+                qFatal("Failed to set stdout to binary mode!");
+#endif // _WIN32
+
+            gallery.open(stdout, QFile::WriteOnly);
+        } else if (baseName == "stderr") {
+#ifdef _WIN32
+            if(_setmode(_fileno(stderr), _O_BINARY) == -1)
+                qFatal("Failed to set stderr to binary mode!");
+#endif // _WIN32
+
+            gallery.open(stderr, QFile::WriteOnly);
+        } else {
+            // Defer opening the file, in the general case we don't know if we
+            // need read or write mode yet
+            return;
+        }
+        stream.setDevice(&gallery);
+    }
+
+    void readOpen()
+    {
+        if (!gallery.isOpen()) {
+            gallery.setFileName(file);
+            if (!gallery.exists())
+                qFatal("File %s does not exist", qPrintable(gallery.fileName()));
+
+            QFile::OpenMode mode = QFile::ReadOnly;
+            if (!gallery.open(mode))
+                qFatal("Can't open gallery: %s for reading", qPrintable(gallery.fileName()));
+            stream.setDevice(&gallery);
+        }
+    }
+
+    void writeOpen()
+    {
+        if (!gallery.isOpen()) {
+            gallery.setFileName(file);
+
+            // Do we remove the pre-existing gallery?
+            if (file.get<bool>("remove"))
+                gallery.remove();
+            QtUtils::touchDir(gallery);
+            QFile::OpenMode mode = QFile::WriteOnly;
+
+            // Do we append?
+            if (file.get<bool>("append"))
+                mode |= QFile::Append;
+
+            if (!gallery.open(mode))
+                qFatal("Can't open gallery: %s for writing", qPrintable(gallery.fileName()));
+            stream.setDevice(&gallery);
+        }
+    }
+
+    TemplateList readBlock(bool *done)
+    {
+        readOpen();
+        if (gallery.atEnd())
+            gallery.seek(0);
+
+        TemplateList templates;
+        while ((templates.size() < readBlockSize) && !gallery.atEnd()) {
+            const Template t = readTemplate();
+            if (!t.isEmpty() || !t.file.isNull()) {
+                templates.append(t);
+                templates.last().file.set("progress", position());
+            }
+
+            // Special case for pipes where we want to process data as soon as it is available
+            if (gallery.isSequential())
+                break;
+        }
+
+        *done = gallery.atEnd();
+        return templates;
+    }
+
+    void write(const Template &t)
+    {
+        writeOpen();
+        writeTemplate(t);
+        if (gallery.isSequential())
+            gallery.flush();
+    }
+
+protected:
+    QFile gallery;
+    QDataStream stream;
+
+    qint64 totalSize()
+    {
+        readOpen();
+        return gallery.size();
+    }
+
+    qint64 position()
+    {
+        return gallery.pos();
+    }
+
+    virtual Template readTemplate() = 0;
+    virtual void writeTemplate(const Template &t) = 0;
+};
+
+/*!
+ * \ingroup galleries
+ * \brief A binary gallery.
+ *
+ * Designed to be a literal translation of templates to disk.
+ * Compatible with TemplateList::fromBuffer.
+ * \author Josh Klontz \cite jklontz
+ */
+class galGallery : public BinaryGallery
+{
+    Q_OBJECT
+
+    Template readTemplate()
+    {
+        Template t;
+        stream >> t;
+        return t;
+    }
+
+    void writeTemplate(const Template &t)
+    {
+        if (t.isEmpty() && t.file.isNull())
+            return;
+        else if (t.file.fte)
+            stream << Template(t.file); // only write metadata for failure to enroll
+        else
+            stream << t;
+    }
+};
+
+BR_REGISTER(Gallery, galGallery)
+
+/*!
+ * \ingroup galleries
+ * \brief A contiguous array of br_universal_template.
+ * \author Josh Klontz \cite jklontz
+ */
+class utGallery : public BinaryGallery
+{
+    Q_OBJECT
+
+    Template readTemplate()
+    {
+        Template t;
+        br_universal_template ut;
+        if (gallery.read((char*)&ut, sizeof(br_universal_template)) == sizeof(br_universal_template)) {
+            QByteArray data(ut.urlSize + ut.fvSize, Qt::Uninitialized);
+            char *dst = data.data();
+            qint64 bytesNeeded = ut.urlSize + ut.fvSize;
+            while (bytesNeeded > 0) {
+                qint64 bytesRead = gallery.read(dst, bytesNeeded);
+                if (bytesRead <= 0) {
+                    qDebug() << gallery.errorString();
+                    qFatal("Unexepected EOF while reading universal template data, needed: %d more of: %d bytes.", int(bytesNeeded), int(ut.urlSize + ut.fvSize));
+                }
+                bytesNeeded -= bytesRead;
+                dst += bytesRead;
+            }
+
+            t.file.set("ImageID", QVariant(QByteArray((const char*)ut.imageID, 16).toHex()));
+            t.file.set("AlgorithmID", ut.algorithmID);
+            t.file.set("URL", QString(data.data()));
+            char *dataStart = data.data() + ut.urlSize;
+            uint32_t dataSize = ut.fvSize;
+            if ((ut.algorithmID <= -1) && (ut.algorithmID >= -3)) {
+                t.file.set("FrontalFace", QRectF(ut.x, ut.y, ut.width, ut.height));
+                uint32_t *rightEyeX = reinterpret_cast<uint32_t*>(dataStart);
+                dataStart += sizeof(uint32_t);
+                uint32_t *rightEyeY = reinterpret_cast<uint32_t*>(dataStart);
+                dataStart += sizeof(uint32_t);
+                uint32_t *leftEyeX = reinterpret_cast<uint32_t*>(dataStart);
+                dataStart += sizeof(uint32_t);
+                uint32_t *leftEyeY = reinterpret_cast<uint32_t*>(dataStart);
+                dataStart += sizeof(uint32_t);
+                dataSize -= sizeof(uint32_t)*4;
+                t.file.set("First_Eye", QPointF(*rightEyeX, *rightEyeY));
+                t.file.set("Second_Eye", QPointF(*leftEyeX, *leftEyeY));
+            }
+            else if (ut.algorithmID == 7) {
+                // binary data consisting of a single channel matrix, of a supported type.
+                // 4 element header:
+                // uint16 datatype (single channel opencv datatype code)
+                // uint32 matrix rows
+                // uint32 matrix cols
+                // uint16 matrix depth (max 512)
+                // Followed by serialized data, in row-major order (in r/c), with depth values
+                // for each layer listed in order (i.e. rgb, rgb etc.)
+                // #### NOTE! matlab's default order is col-major, so some work should
+                // be done on the matlab side to make sure that the initial serialization is correct.
+                uint16_t dataType = *reinterpret_cast<uint32_t*>(dataStart);
+                dataStart += sizeof(uint16_t);
+
+                uint32_t matrixRows = *reinterpret_cast<uint32_t*>(dataStart);
+                dataStart += sizeof(uint32_t);
+
+                uint32_t matrixCols = *reinterpret_cast<uint32_t*>(dataStart);
+                dataStart += sizeof(uint32_t);
+
+                uint16_t matrixDepth= *reinterpret_cast<uint16_t*>(dataStart);
+                dataStart += sizeof(uint16_t);
+
+                // Set metadata
+                t.file.set("Label", ut.label);
+                t.file.set("X", ut.x);
+                t.file.set("Y", ut.y);
+                t.file.set("Width", ut.width);
+                t.file.set("Height", ut.height);
+
+                t.append(cv::Mat(matrixRows, matrixCols, CV_MAKETYPE(dataType, matrixDepth), dataStart).clone() /* We don't want a shallow copy! */);
+                return t;
+            }
+            else {
+                t.file.set("X", ut.x);
+                t.file.set("Y", ut.y);
+                t.file.set("Width", ut.width);
+                t.file.set("Height", ut.height);
+            }
+            t.file.set("Label", ut.label);
+            t.append(cv::Mat(1, dataSize, CV_8UC1, dataStart).clone() /* We don't want a shallow copy! */);
+        } else {
+            if (!gallery.atEnd())
+                qWarning("Failed to read universal template header!");
+            gallery.close();
+        }
+        return t;
+    }
+
+    void writeTemplate(const Template &t)
+    {
+        const QByteArray imageID = QByteArray::fromHex(t.file.get<QByteArray>("ImageID", QByteArray(32, '0')));
+        if (imageID.size() != 16)
+            qFatal("Expected 16-byte ImageID, got: %d bytes.", imageID.size());
+
+        const int32_t algorithmID = (t.isEmpty() || t.file.fte) ? 0 : t.file.get<int32_t>("AlgorithmID");
+
+        // QUrl::fromUserInput provides some nice functionality in terms of completing URLs
+        // e.g. C:/test.jpg -> file://C:/test.jpg and google.com/image.jpg -> http://google.com/image.jpg
+        const QByteArray url = QUrl::fromUserInput(t.file.get<QString>("URL", t.file.name)).toEncoded();
+
+        int32_t x = 0, y = 0;
+        uint32_t width = 0, height = 0;
+        QByteArray header;
+        if ((algorithmID <= -1) && (algorithmID >= -3)) {
+            const QRectF frontalFace = t.file.get<QRectF>("FrontalFace");
+            x      = frontalFace.x();
+            y      = frontalFace.y();
+            width  = frontalFace.width();
+            height = frontalFace.height();
+
+            const QPointF firstEye   = t.file.get<QPointF>("First_Eye");
+            const QPointF secondEye  = t.file.get<QPointF>("Second_Eye");
+            const uint32_t rightEyeX = firstEye.x();
+            const uint32_t rightEyeY = firstEye.y();
+            const uint32_t leftEyeX  = secondEye.x();
+            const uint32_t leftEyeY  = secondEye.y();
+
+            header.append((const char*)&rightEyeX, sizeof(uint32_t));
+            header.append((const char*)&rightEyeY, sizeof(uint32_t));
+            header.append((const char*)&leftEyeX , sizeof(uint32_t));
+            header.append((const char*)&leftEyeY , sizeof(uint32_t));
+        } else {
+            x = t.file.get<int32_t>("X", 0);
+            y = t.file.get<int32_t>("Y", 0);
+            width = t.file.get<uint32_t>("Width", 0);
+            height = t.file.get<uint32_t>("Height", 0);
+        }
+        const uint32_t label = t.file.get<uint32_t>("Label", 0);
+
+        gallery.write(imageID);
+        gallery.write((const char*) &algorithmID, sizeof(int32_t));
+        gallery.write((const char*) &x          , sizeof(int32_t));
+        gallery.write((const char*) &y          , sizeof(int32_t));
+        gallery.write((const char*) &width      , sizeof(uint32_t));
+        gallery.write((const char*) &height     , sizeof(uint32_t));
+        gallery.write((const char*) &label      , sizeof(uint32_t));
+
+        const uint32_t urlSize = url.size() + 1;
+        gallery.write((const char*) &urlSize, sizeof(uint32_t));
+
+        const uint32_t signatureSize = (algorithmID == 0) ? 0 : t.m().rows * t.m().cols * t.m().elemSize();
+        const uint32_t fvSize = header.size() + signatureSize;
+        gallery.write((const char*) &fvSize, sizeof(uint32_t));
+
+        gallery.write((const char*) url.data(), urlSize);
+        if (algorithmID != 0) {
+            gallery.write(header);
+            gallery.write((const char*) t.m().data, signatureSize);
+        }
+    }
+};
+
+BR_REGISTER(Gallery, utGallery)
+
+/*!
+ * \ingroup galleries
+ * \brief Newline-separated URLs.
+ * \author Josh Klontz \cite jklontz
+ */
+class urlGallery : public BinaryGallery
+{
+    Q_OBJECT
+
+    Template readTemplate()
+    {
+        Template t;
+        const QString url = QString::fromLocal8Bit(gallery.readLine()).simplified();
+        if (!url.isEmpty())
+            t.file.set("URL", url);
+        return t;
+    }
+
+    void writeTemplate(const Template &t)
+    {
+        const QString url = t.file.get<QString>("URL", t.file.name);
+        if (!url.isEmpty()) {
+            gallery.write(qPrintable(url));
+            gallery.write("\n");
+        }
+    }
+};
+
+BR_REGISTER(Gallery, urlGallery)
+
+/*!
+ * \ingroup galleries
+ * \brief Newline-separated JSON objects.
+ * \author Josh Klontz \cite jklontz
+ */
+class jsonGallery : public BinaryGallery
+{
+    Q_OBJECT
+
+    Template readTemplate()
+    {
+        QJsonParseError error;
+        const QByteArray line = gallery.readLine().simplified();
+        if (line.isEmpty())
+            return Template();
+        File file = QJsonDocument::fromJson(line, &error).object().toVariantMap();
+        if (error.error != QJsonParseError::NoError) {
+            qWarning("Couldn't parse: %s\n", line.data());
+            qFatal("%s\n", qPrintable(error.errorString()));
+        }
+        return file;
+    }
+
+    void writeTemplate(const Template &t)
+    {
+        const QByteArray json = QJsonDocument(QJsonObject::fromVariantMap(t.file.localMetadata())).toJson().replace('\n', "");
+        if (!json.isEmpty()) {
+            gallery.write(json);
+            gallery.write("\n");
+        }
+    }
+};
+
+BR_REGISTER(Gallery, jsonGallery)
+
+} // namespace br
+
+#include "gallery/binary.moc"
diff --git a/openbr/plugins/gallery/crawl.cpp b/openbr/plugins/gallery/crawl.cpp
new file mode 100644
index 0000000..ae6e319
--- /dev/null
+++ b/openbr/plugins/gallery/crawl.cpp
@@ -0,0 +1,113 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * 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 <QStandardPaths>
+
+#include <openbr/plugins/openbr_internal.h>
+
+namespace br
+{
+
+/*!
+ * \ingroup galleries
+ * \brief Crawl a root location for image files.
+ * \author Josh Klontz \cite jklontz
+ */
+class crawlGallery : public Gallery
+{
+    Q_OBJECT
+    Q_PROPERTY(bool autoRoot READ get_autoRoot WRITE set_autoRoot RESET reset_autoRoot STORED false)
+    Q_PROPERTY(int depth READ get_depth WRITE set_depth RESET reset_depth STORED false)
+    Q_PROPERTY(bool depthFirst READ get_depthFirst WRITE set_depthFirst RESET reset_depthFirst STORED false)
+    Q_PROPERTY(int images READ get_images WRITE set_images RESET reset_images STORED false)
+    Q_PROPERTY(bool json READ get_json WRITE set_json RESET reset_json STORED false)
+    Q_PROPERTY(int timeLimit READ get_timeLimit WRITE set_timeLimit RESET reset_timeLimit STORED false)
+    BR_PROPERTY(bool, autoRoot, false)
+    BR_PROPERTY(int, depth, INT_MAX)
+    BR_PROPERTY(bool, depthFirst, false)
+    BR_PROPERTY(int, images, INT_MAX)
+    BR_PROPERTY(bool, json, false)
+    BR_PROPERTY(int, timeLimit, INT_MAX)
+
+    QTime elapsed;
+    TemplateList templates;
+
+    void crawl(QFileInfo url, int currentDepth = 0)
+    {
+        if ((templates.size() >= images) || (currentDepth >= depth) || (elapsed.elapsed()/1000 >= timeLimit))
+            return;
+
+        if (url.filePath().startsWith("file://"))
+            url = QFileInfo(url.filePath().mid(7));
+
+        if (url.isDir()) {
+            const QDir dir(url.absoluteFilePath());
+            const QFileInfoList files = dir.entryInfoList(QDir::Files);
+            const QFileInfoList subdirs = dir.entryInfoList(QDir::Dirs | QDir::NoDotAndDotDot);
+            foreach (const QFileInfo &first, depthFirst ? subdirs : files)
+                crawl(first, currentDepth + 1);
+            foreach (const QFileInfo &second, depthFirst ? files : subdirs)
+                crawl(second, currentDepth + 1);
+        } else if (url.isFile()) {
+            const QString suffix = url.suffix();
+            if ((suffix == "bmp") || (suffix == "jpg") || (suffix == "jpeg") || (suffix == "png") || (suffix == "tiff")) {
+                File f;
+                if (json) f.set("URL", "file://"+url.canonicalFilePath());
+                else      f.name = "file://"+url.canonicalFilePath();
+                templates.append(f);
+            }
+        }
+    }
+
+    void init()
+    {
+        elapsed.start();
+        const QString root = file.name.mid(0, file.name.size()-6); // Remove .crawl suffix";
+        if (!root.isEmpty()) {
+            crawl(root);
+        } else {
+            if (autoRoot) {
+                foreach (const QString &path, QStandardPaths::standardLocations(QStandardPaths::HomeLocation))
+                    crawl(path);
+            } else {
+                QFile file;
+                file.open(stdin, QFile::ReadOnly);
+                while (!file.atEnd()) {
+                    const QString url = QString::fromLocal8Bit(file.readLine()).simplified();
+                    if (!url.isEmpty())
+                        crawl(url);
+                }
+            }
+        }
+    }
+
+    TemplateList readBlock(bool *done)
+    {
+        *done = true;
+        return templates;
+    }
+
+    void write(const Template &)
+    {
+        qFatal("Not supported");
+    }
+};
+
+BR_REGISTER(Gallery, crawlGallery)
+
+} // namespace br
+
+#include "gallery/crawl.moc"
diff --git a/openbr/plugins/gallery/csv.cpp b/openbr/plugins/gallery/csv.cpp
new file mode 100644
index 0000000..cb65521
--- /dev/null
+++ b/openbr/plugins/gallery/csv.cpp
@@ -0,0 +1,184 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * 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 galleries
+ * \brief Treats each line as a file.
+ * \author Josh Klontz \cite jklontz
+ *
+ * Columns should be comma separated with first row containing headers.
+ * The first column in the file should be the path to the file to enroll.
+ * Other columns will be treated as file metadata.
+ *
+ * \see txtGallery
+ */
+class csvGallery : public FileGallery
+{
+    Q_OBJECT
+    Q_PROPERTY(int fileIndex READ get_fileIndex WRITE set_fileIndex RESET reset_fileIndex)
+    BR_PROPERTY(int, fileIndex, 0)
+
+    FileList files;
+    QStringList headers;
+
+    ~csvGallery()
+    {
+        f.close();
+
+        if (files.isEmpty()) return;
+
+        QMap<QString,QVariant> samples;
+        foreach (const File &file, files)
+            foreach (const QString &key, file.localKeys())
+                if (!samples.contains(key))
+                    samples.insert(key, file.value(key));
+
+        // Don't create columns in the CSV for these special fields
+        samples.remove("Points");
+        samples.remove("Rects");
+
+        QStringList lines;
+        lines.reserve(files.size()+1);
+
+        QMap<QString, int> columnCounts;
+
+        { // Make header
+            QStringList words;
+            words.append("File");
+            foreach (const QString &key, samples.keys()) {
+                int count = 0;
+                words.append(getCSVElement(key, samples[key], true, count));
+                columnCounts.insert(key, count);
+            }
+            lines.append(words.join(","));
+        }
+
+        // Make table
+        foreach (const File &file, files) {
+            QStringList words;
+            words.append(file.name);
+            foreach (const QString &key, samples.keys()) {
+                int count = columnCounts[key];
+                words.append(getCSVElement(key, file.value(key), false, count));
+            }
+            lines.append(words.join(","));
+        }
+
+        QtUtils::writeFile(file, lines);
+    }
+
+    TemplateList readBlock(bool *done)
+    {
+        readOpen();
+        *done = false;
+        TemplateList templates;
+        if (!file.exists()) {
+            *done = true;
+            return templates;
+        }
+        QRegExp regexp("\\s*,\\s*");
+
+        if (f.pos() == 0)
+        {
+            // read a line
+            QByteArray lineBytes = f.readLine();
+            QString line = QString::fromLocal8Bit(lineBytes).trimmed();
+            headers = line.split(regexp);
+        }
+
+        for (qint64 i = 0; i < this->readBlockSize && !f.atEnd(); i++){
+            QByteArray lineBytes = f.readLine();
+            QString line = QString::fromLocal8Bit(lineBytes).trimmed();
+
+            QStringList words = line.split(regexp);
+            if (words.size() != headers.size()) continue;
+            File fi;
+            for (int j=0; j<words.size(); j++) {
+                if (j == 0) fi.name = words[j];
+                else        fi.set(headers[j], words[j]);
+            }
+            templates.append(fi);
+            templates.last().file.set("progress", f.pos());
+        }
+        *done = f.atEnd();
+
+        return templates;
+    }
+
+    void write(const Template &t)
+    {
+        files.append(t.file);
+    }
+
+    static QString getCSVElement(const QString &key, const QVariant &value, bool header, int & columnCount)
+    {
+        if (header)
+            columnCount = 1;
+
+        if (value.canConvert<QString>()) {
+            if (header) return key;
+            else {
+                if (columnCount != 1)
+                    qFatal("Inconsistent datatype for key %s, csv file cannot be generated", qPrintable(key));
+                return value.value<QString>();
+            }
+        } else if (value.canConvert<QPointF>()) {
+            const QPointF point = value.value<QPointF>();
+            if (header) {
+                columnCount = 2;
+                return key+"_X,"+key+"_Y";
+            }
+            else {
+                if (columnCount != 2)
+                    qFatal("Inconsistent datatype for key %s, csv file cannot be generated", qPrintable(key));
+
+                return QString::number(point.x())+","+QString::number(point.y());
+            }
+        } else if (value.canConvert<QRectF>()) {
+            const QRectF rect = value.value<QRectF>();
+            if (header) {
+                columnCount = 4;
+                return key+"_X,"+key+"_Y,"+key+"_Width,"+key+"_Height";
+            }
+            else {
+                if (columnCount != 4)
+                    qFatal("Inconsistent datatype for key %s, csv file cannot be generated", qPrintable(key));
+
+                return QString::number(rect.x())+","+QString::number(rect.y())+","+QString::number(rect.width())+","+QString::number(rect.height());
+            }
+        } else {
+            if (header) return key;
+            else {
+                QString output = QString::number(std::numeric_limits<float>::quiet_NaN());
+                for (int i = 1; i < columnCount; i++)
+                    output += "," + QString::number(std::numeric_limits<float>::quiet_NaN());
+                return output;
+            }
+        }
+    }
+};
+
+BR_REGISTER(Gallery, csvGallery)
+
+} // namespace br
+
+#include "gallery/csv.moc"
diff --git a/openbr/plugins/gallery/db.cpp b/openbr/plugins/gallery/db.cpp
new file mode 100644
index 0000000..9b7d5b5
--- /dev/null
+++ b/openbr/plugins/gallery/db.cpp
@@ -0,0 +1,192 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * 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 <QtSql>
+
+#include <openbr/plugins/openbr_internal.h>
+#include <openbr/core/qtutils.h>
+
+namespace br
+{
+
+/*!
+ * \ingroup galleries
+ * \brief Database input.
+ * \author Josh Klontz \cite jklontz
+ */
+class dbGallery : public Gallery
+{
+    Q_OBJECT
+
+    TemplateList readBlock(bool *done)
+    {
+        TemplateList templates;
+        br::File import = file.get<QString>("import", "");
+        QString query = file.get<QString>("query");
+        QString subset = file.get<QString>("subset", "");
+
+#ifndef BR_EMBEDDED
+        QSqlDatabase db = QSqlDatabase::addDatabase("QSQLITE");
+        db.setDatabaseName(file);
+        if (!db.open()) qFatal("Failed to open SQLite database %s.", qPrintable(file.name));
+
+        if (!import.isNull()) {
+            qDebug("Parsing %s", qPrintable(import.name));
+            QStringList lines = QtUtils::readLines(import);
+            QList<QStringList> cells; cells.reserve(lines.size());
+            const QRegExp re("\\s*,\\s*");
+            foreach (const QString &line, lines) {
+                cells.append(line.split(re));
+                if (cells.last().size() != cells.first().size()) qFatal("Column count mismatch.");
+            }
+
+            QStringList columns, qMarks;
+            QList<QVariantList> variantLists;
+            for (int i=0; i<cells[0].size(); i++) {
+                bool isNumeric;
+                cells[1][i].toInt(&isNumeric);
+                columns.append(cells[0][i] + (isNumeric ? " INTEGER" : " STRING"));
+                qMarks.append("?");
+
+                QVariantList variantList; variantList.reserve(lines.size()-1);
+                for (int j=1; j<lines.size(); j++) {
+                    if (isNumeric) variantList << cells[j][i].toInt();
+                    else           variantList << cells[j][i];
+                }
+                variantLists.append(variantList);
+            }
+
+            const QString &table = import.baseName();
+            qDebug("Creating table %s", qPrintable(table));
+            QSqlQuery q(db);
+            if (!q.exec("CREATE TABLE " + table + " (" + columns.join(", ") + ");"))
+                qFatal("%s.", qPrintable(q.lastError().text()));
+            if (!q.prepare("insert into " + table + " values (" + qMarks.join(", ") + ")"))
+                qFatal("%s.", qPrintable(q.lastError().text()));
+            foreach (const QVariantList &vl, variantLists)
+                q.addBindValue(vl);
+            if (!q.execBatch()) qFatal("%s.", qPrintable(q.lastError().text()));
+        }
+
+        QSqlQuery q(db);
+        if (query.startsWith('\'') && query.endsWith('\''))
+            query = query.mid(1, query.size()-2);
+        if (!q.exec(query))
+            qFatal("%s.", qPrintable(q.lastError().text()));
+
+        if ((q.record().count() == 0) || (q.record().count() > 3))
+            qFatal("Query record expected one to three fields, got %d.", q.record().count());
+        const bool hasMetadata = (q.record().count() >= 2);
+        const bool hasFilter = (q.record().count() >= 3);
+
+        QString labelName = "Label";
+        if (q.record().count() >= 2)
+            labelName = q.record().fieldName(1);
+
+        // subset = seed:subjectMaxSize:numSubjects:subjectMinSize or
+        // subset = seed:{Metadata,...,Metadata}:numSubjects
+        int seed = 0, subjectMaxSize = std::numeric_limits<int>::max(), numSubjects = std::numeric_limits<int>::max(), subjectMinSize = 0;
+        QList<QRegExp> metadataFields;
+        if (!subset.isEmpty()) {
+            const QStringList &words = subset.split(":");
+            QtUtils::checkArgsSize("Input", words, 2, 4);
+            if      (words[0] == "train") seed = 0;
+            else if (words[0] == "test" ) seed = 1;
+            else                          seed = QtUtils::toInt(words[0]);
+            if (words[1].startsWith('{') && words[1].endsWith('}')) {
+                foreach (const QString &regexp, words[1].mid(1, words[1].size()-2).split(","))
+                    metadataFields.append(QRegExp(regexp));
+                subjectMaxSize = metadataFields.size();
+            } else {
+                subjectMaxSize = QtUtils::toInt(words[1]);
+            }
+            numSubjects = words.size() >= 3 ? QtUtils::toInt(words[2]) : std::numeric_limits<int>::max();
+            subjectMinSize = words.size() >= 4 ? QtUtils::toInt(words[3]) : subjectMaxSize;
+        }
+
+        srand(seed);
+
+        typedef QPair<QString,QString> Entry; // QPair<File,Metadata>
+        QHash<QString, QList<Entry> > entries; // QHash<Label, QList<Entry> >
+        while (q.next()) {
+            if (hasFilter && (seed >= 0) && (qHash(q.value(2).toString()) % 2 != (uint)seed % 2)) continue; // Ensures training and testing filters don't overlap
+
+            if (metadataFields.isEmpty())
+                entries[hasMetadata ? q.value(1).toString() : ""].append(QPair<QString,QString>(q.value(0).toString(), hasFilter ? q.value(2).toString() : ""));
+            else
+                entries[hasFilter ? q.value(2).toString() : ""].append(QPair<QString,QString>(q.value(0).toString(), hasMetadata ? q.value(1).toString() : ""));
+        }
+
+        QStringList labels = entries.keys();
+        qSort(labels);
+
+        if (hasFilter && ((labels.size() > numSubjects) || (numSubjects == std::numeric_limits<int>::max())))
+            std::random_shuffle(labels.begin(), labels.end());
+
+        foreach (const QString &label, labels) {
+            QList<Entry> entryList = entries[label];
+            if ((entryList.size() >= subjectMinSize) && (numSubjects > 0)) {
+
+                if (!metadataFields.isEmpty()) {
+                    QList<Entry> subEntryList;
+                    foreach (const QRegExp &metadata, metadataFields) {
+                        for (int i=0; i<entryList.size(); i++) {
+                            if (metadata.exactMatch(entryList[i].second)) {
+                                subEntryList.append(entryList.takeAt(i));
+                                break;
+                            }
+                        }
+                    }
+                    if (subEntryList.size() == metadataFields.size())
+                        entryList = subEntryList;
+                    else
+                        continue;
+                }
+
+                if (entryList.size() > subjectMaxSize)
+                    std::random_shuffle(entryList.begin(), entryList.end());
+                foreach (const Entry &entry, entryList.mid(0, subjectMaxSize)) {
+                    templates.append(File(entry.first));
+                    templates.last().file.set(labelName, label);
+                }
+                numSubjects--;
+            }
+        }
+
+        db.close();
+#endif // BR_EMBEDDED
+
+        *done = true;
+        return templates;
+    }
+
+    void write(const Template &t)
+    {
+        (void) t;
+        qFatal("Not supported.");
+    }
+
+    void init()
+    {
+        //
+    }
+};
+
+BR_REGISTER(Gallery, dbGallery)
+
+} // namespace br
+
+#include "gallery/db.moc"
diff --git a/openbr/plugins/gallery/default.cpp b/openbr/plugins/gallery/default.cpp
new file mode 100644
index 0000000..0552a86
--- /dev/null
+++ b/openbr/plugins/gallery/default.cpp
@@ -0,0 +1,53 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * 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 galleries
+ * \brief Treats the gallery as a br::Format.
+ * \author Josh Klontz \cite jklontz
+ */
+class DefaultGallery : public Gallery
+{
+    Q_OBJECT
+
+    TemplateList readBlock(bool *done)
+    {
+        *done = true;
+        return TemplateList() << file;
+    }
+
+    void write(const Template &t)
+    {
+        QScopedPointer<Format> format(Factory<Format>::make(file));
+        format->write(t);
+    }
+
+    qint64 totalSize()
+    {
+        return 1;
+    }
+};
+
+BR_REGISTER(Gallery, DefaultGallery)
+
+} //  namespace br
+
+#include "gallery/default.moc"
diff --git a/openbr/plugins/gallery/empty.cpp b/openbr/plugins/gallery/empty.cpp
new file mode 100644
index 0000000..a361e3e
--- /dev/null
+++ b/openbr/plugins/gallery/empty.cpp
@@ -0,0 +1,127 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * 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/qtutils.h>
+
+namespace br
+{
+
+/*!
+ * \ingroup galleries
+ * \brief Reads/writes templates to/from folders.
+ * \author Josh Klontz \cite jklontz
+ * \param regexp An optional regular expression to match against the files extension.
+ */
+class EmptyGallery : public Gallery
+{
+    Q_OBJECT
+    Q_PROPERTY(QString regexp READ get_regexp WRITE set_regexp RESET reset_regexp STORED false)
+    BR_PROPERTY(QString, regexp, QString())
+
+    qint64 gallerySize;
+
+    void init()
+    {
+        QDir dir(file.name);
+        QtUtils::touchDir(dir);
+        QDirIterator it(dir.absolutePath(), QDir::Files | QDir::NoDotAndDotDot, QDirIterator::Subdirectories);
+        gallerySize = 0;
+        while (it.hasNext()) {
+            it.next();
+            gallerySize++;
+        }
+    }
+
+    TemplateList readBlock(bool *done)
+    {
+        TemplateList templates;
+        *done = true;
+
+        // Enrolling a null file is used as an idiom to initialize an algorithm
+        if (file.isNull()) return templates;
+
+        // Add immediate subfolders
+        QDir dir(file);
+        QList< QFuture<TemplateList> > futures;
+        foreach (const QString &folder, QtUtils::naturalSort(dir.entryList(QDir::Dirs | QDir::NoDotAndDotDot))) {
+            const QDir subdir = dir.absoluteFilePath(folder);
+            futures.append(QtConcurrent::run(&EmptyGallery::getTemplates, subdir));
+        }
+        foreach (const QFuture<TemplateList> &future, futures)
+            templates.append(future.result());
+
+        // Add root folder
+        foreach (const QString &fileName, QtUtils::getFiles(file.name, false))
+            templates.append(File(fileName, dir.dirName()));
+
+        if (!regexp.isEmpty()) {
+            QRegExp re(regexp);
+            re.setPatternSyntax(QRegExp::Wildcard);
+            for (int i=templates.size()-1; i>=0; i--) {
+                if (!re.exactMatch(templates[i].file.fileName())) {
+                    templates.removeAt(i);
+                }
+            }
+        }
+
+        for (int i = 0; i < templates.size(); i++) templates[i].file.set("progress", i);
+
+        return templates;
+    }
+
+    void write(const Template &t)
+    {
+        static QMutex diskLock;
+
+        // Enrolling a null file is used as an idiom to initialize an algorithm
+        if (file.name.isEmpty()) return;
+
+        const QString newFormat = file.get<QString>("newFormat",QString());
+        QString destination = file.name + "/" + (file.getBool("preservePath") ? t.file.path()+"/" : QString());
+        destination += (newFormat.isEmpty() ? t.file.fileName() : t.file.baseName()+newFormat);
+
+        QMutexLocker diskLocker(&diskLock); // Windows prefers to crash when writing to disk in parallel
+        if (t.isNull()) {
+            QtUtils::copyFile(t.file.resolved(), destination);
+        } else {
+            QScopedPointer<Format> format(Factory<Format>::make(destination));
+            format->write(t);
+        }
+    }
+
+    qint64 totalSize()
+    {
+        return gallerySize;
+    }
+
+    static TemplateList getTemplates(const QDir &dir)
+    {
+        const QStringList files = QtUtils::getFiles(dir, true);
+        TemplateList templates; templates.reserve(files.size());
+        foreach (const QString &file, files)
+            templates.append(File(file, dir.dirName()));
+        return templates;
+    }
+};
+
+BR_REGISTER(Gallery, EmptyGallery)
+
+} // namespace br
+
+#include "gallery/empty.moc"
diff --git a/openbr/plugins/gallery/fddb.cpp b/openbr/plugins/gallery/fddb.cpp
new file mode 100644
index 0000000..c84e730
--- /dev/null
+++ b/openbr/plugins/gallery/fddb.cpp
@@ -0,0 +1,82 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * 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 galleries
+ * \brief Implements the FDDB detection format.
+ * \author Josh Klontz \cite jklontz
+ *
+ * http://vis-www.cs.umass.edu/fddb/README.txt
+ */
+class FDDBGallery : public Gallery
+{
+    Q_OBJECT
+
+    TemplateList readBlock(bool *done)
+    {
+        *done = true;
+        QStringList lines = QtUtils::readLines(file);
+        TemplateList templates;
+        while (!lines.empty()) {
+            const QString fileName = lines.takeFirst();
+            int numDetects = lines.takeFirst().toInt();
+            for (int i=0; i<numDetects; i++) {
+                const QStringList detect = lines.takeFirst().split(' ');
+                Template t(fileName);
+                QList<QVariant> faceList; //to be consistent with slidingWindow
+                if (detect.size() == 5) { //rectangle
+                    faceList.append(QRectF(detect[0].toFloat(), detect[1].toFloat(), detect[2].toFloat(), detect[3].toFloat()));
+                    t.file.set("Confidence", detect[4].toFloat());
+                } else if (detect.size() == 6) { //ellipse
+                    float x = detect[3].toFloat(),
+                          y = detect[4].toFloat(),
+                          radius = detect[1].toFloat();
+                    faceList.append(QRectF(x - radius,y - radius,radius * 2.0, radius * 2.0));
+                    t.file.set("Confidence", detect[5].toFloat());
+                } else {
+                    qFatal("Unknown FDDB annotation format.");
+                }
+                t.file.set("Face", faceList);
+                t.file.set("Label",QString("face"));
+                templates.append(t);
+            }
+        }
+        return templates;
+    }
+
+    void write(const Template &t)
+    {
+        (void) t;
+        qFatal("Not implemented.");
+    }
+
+    void init()
+    {
+        //
+    }
+};
+
+BR_REGISTER(Gallery, FDDBGallery)
+
+} // namespace br
+
+#include "gallery/fddb.moc"
diff --git a/openbr/plugins/gallery/flat.cpp b/openbr/plugins/gallery/flat.cpp
new file mode 100644
index 0000000..09c0ec5
--- /dev/null
+++ b/openbr/plugins/gallery/flat.cpp
@@ -0,0 +1,69 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * 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 galleries
+ * \brief Treats each line as a call to File::flat()
+ * \author Josh Klontz \cite jklontz
+ */
+class flatGallery : public FileGallery
+{
+    Q_OBJECT
+
+    TemplateList readBlock(bool *done)
+    {
+        readOpen();
+        *done = false;
+        if (f.atEnd())
+            f.seek(0);
+
+        TemplateList templates;
+
+        for (qint64 i = 0; i < readBlockSize; i++)
+        {
+            QByteArray line = f.readLine();
+
+            if (!line.isEmpty()) {
+                templates.append(File(QString::fromLocal8Bit(line).trimmed()));
+                templates.last().file.set("progress", this->position());
+            }
+
+            if (f.atEnd()) {
+                *done=true;
+                break;
+            }
+        }
+
+        return templates;
+    }
+
+    void write(const Template &t)
+    {
+        writeOpen();
+        f.write((t.file.flat()+"\n").toLocal8Bit() );
+    }
+};
+
+BR_REGISTER(Gallery, flatGallery)
+
+} // namespace br
+
+#include "gallery/flat.moc"
diff --git a/openbr/plugins/gallery/galleryutil.cpp b/openbr/plugins/gallery/galleryutil.cpp
new file mode 100644
index 0000000..4b3b0c7
--- /dev/null
+++ b/openbr/plugins/gallery/galleryutil.cpp
@@ -0,0 +1,59 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * 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
+{
+
+void FileGallery::init()
+{
+    f.setFileName(file);
+
+    Gallery::init();
+}
+
+void FileGallery::writeOpen()
+{
+    if (!f.isOpen() ) {
+        QtUtils::touchDir(f);
+        if (!f.open(QFile::WriteOnly))
+            qFatal("Failed to open %s for writing.", qPrintable(file));
+    }
+}
+
+bool FileGallery::readOpen()
+{
+    if (!f.isOpen() ) {
+        if (!f.exists() ) {
+            qFatal("File %s does not exist.", qPrintable(file));
+        }
+
+        if (!f.open(QFile::ReadOnly))
+            qFatal("Failed to open %s for reading.", qPrintable(file));
+        return true;
+    }
+    return false;
+}
+
+qint64 FileGallery::totalSize()
+{
+    readOpen();
+    return f.size();
+}
+
+} // namespace br
diff --git a/openbr/plugins/gallery/google.cpp b/openbr/plugins/gallery/google.cpp
new file mode 100644
index 0000000..fc5ab0f
--- /dev/null
+++ b/openbr/plugins/gallery/google.cpp
@@ -0,0 +1,78 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * 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 <QtNetwork>
+
+#include <openbr/plugins/openbr_internal.h>
+
+namespace br
+{
+
+/*!
+ * \ingroup inputs
+ * \brief Input from a google image search.
+ * \author Josh Klontz \cite jklontz
+ */
+class googleGallery : public Gallery
+{
+    Q_OBJECT
+
+    TemplateList readBlock(bool *done)
+    {
+        TemplateList templates;
+
+        static const QString search = "http://images.google.com/images?q=%1&start=%2";
+        QString query = file.name.left(file.name.size()-7); // remove ".google"
+
+#ifndef BR_EMBEDDED
+        QNetworkAccessManager networkAccessManager;
+        for (int i=0; i<100; i+=20) { // Retrieve 100 images
+            QNetworkRequest request(search.arg(query, QString::number(i)));
+            QNetworkReply *reply = networkAccessManager.get(request);
+
+            while (!reply->isFinished())
+                QThread::yieldCurrentThread();
+
+            QString data(reply->readAll());
+            delete reply;
+
+            QStringList words = data.split("imgurl=");
+            words.takeFirst(); // Remove header
+            foreach (const QString &word, words) {
+                QString url = word.left(word.indexOf("&amp"));
+                url = url.replace("%2520","%20");
+                int junk = url.indexOf('%', url.lastIndexOf('.'));
+                if (junk != -1) url = url.left(junk);
+                templates.append(File(url,query));
+            }
+        }
+#endif // BR_EMBEDDED
+
+        *done = true;
+        return templates;
+    }
+
+    void write(const Template &)
+    {
+        qFatal("Not supported.");
+    }
+};
+
+BR_REGISTER(Gallery, googleGallery)
+
+} // namespace br
+
+#include "gallery/google.moc"
diff --git a/openbr/plugins/gallery/keyframes.cpp b/openbr/plugins/gallery/keyframes.cpp
new file mode 100644
index 0000000..0dfc144
--- /dev/null
+++ b/openbr/plugins/gallery/keyframes.cpp
@@ -0,0 +1,230 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * Copyright 2012 The MITRE Corporation                                      *
+ *                                                                           *
+ * Licensed under the Apache License, Version 2.0 (the "License");           *
+ * you may not use this file except in compliance with the License.          *
+ * You may obtain a copy of the License at                                   *
+ *                                                                           *
+ *     http://www.apache.org/licenses/LICENSE-2.0                            *
+ *                                                                           *
+ * Unless required by applicable law or agreed to in writing, software       *
+ * distributed under the License is distributed on an "AS IS" BASIS,         *
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  *
+ * See the License for the specific language governing permissions and       *
+ * limitations under the License.                                            *
+ * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+
+#include <openbr/plugins/openbr_internal.h>
+#include <openbr/core/qtutils.h>
+#include <openbr/core/opencvutils.h>
+
+extern "C"
+{
+#include <libavcodec/avcodec.h>
+#include <libavformat/avformat.h>
+#include <libavutil/avutil.h>
+#include <libswscale/swscale.h>
+}
+
+using namespace cv;
+
+namespace br
+{
+
+/*!
+ * \ingroup galleries
+ * \brief Read key frames of a video with LibAV
+ * \author Ben Klein \cite bhklein
+ */
+class keyframesGallery : public Gallery
+{
+    Q_OBJECT
+
+public:
+    int64_t idx;
+
+    keyframesGallery()
+    {
+        av_register_all();
+        avformat_network_init();
+        avFormatCtx = NULL;
+        avCodecCtx = NULL;
+        avSwsCtx = NULL;
+        avCodec = NULL;
+        frame = NULL;
+        cvt_frame = NULL;
+        buffer = NULL;
+        opened = false;
+        streamID = -1;
+        fps = 0.f;
+        time_base = 0.f;
+        idx = 0;
+    }
+
+    ~keyframesGallery()
+    {
+        release();
+    }
+
+    virtual void deferredInit()
+    {
+        if (avformat_open_input(&avFormatCtx, QtUtils::getAbsolutePath(file.name).toStdString().c_str(), NULL, NULL) != 0) {
+            qFatal("Failed to open %s for reading.", qPrintable(file.name));
+        } else if (avformat_find_stream_info(avFormatCtx, NULL) < 0) {
+            qFatal("Failed to read stream info for %s.", qPrintable(file.name));
+        } else {
+            for (unsigned int i=0; i<avFormatCtx->nb_streams; i++) {
+                if (avFormatCtx->streams[i]->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
+                    streamID = i;
+                    break;
+                }
+            }
+        }
+
+        if (streamID == -1)
+            qFatal("Failed to find video stream for %s", qPrintable(file.name));
+
+        avCodecCtx = avFormatCtx->streams[streamID]->codec;
+        avCodec = avcodec_find_decoder(avCodecCtx->codec_id);
+        if (avCodec == NULL)
+            qFatal("Unsupported codec for %s!", qPrintable(file.name));
+
+        if (avcodec_open2(avCodecCtx, avCodec, NULL) < 0)
+            qFatal("Could not open codec for file %s", qPrintable(file.name));
+
+        frame = av_frame_alloc();
+        cvt_frame = av_frame_alloc();
+
+        // Get fps, stream time_base and allocate space for frame buffer with av_malloc.
+        fps = (float)avFormatCtx->streams[streamID]->avg_frame_rate.num /
+              (float)avFormatCtx->streams[streamID]->avg_frame_rate.den;
+        time_base = (float)avFormatCtx->streams[streamID]->time_base.num /
+                    (float)avFormatCtx->streams[streamID]->time_base.den;
+        int framebytes = avpicture_get_size(AV_PIX_FMT_BGR24, avCodecCtx->width, avCodecCtx->height);
+        buffer = (uint8_t*)av_malloc(framebytes*sizeof(uint8_t));
+        avpicture_fill((AVPicture*)cvt_frame, buffer, AV_PIX_FMT_BGR24, avCodecCtx->width, avCodecCtx->height);
+
+        avSwsCtx = sws_getContext(avCodecCtx->width, avCodecCtx->height,
+                                  avCodecCtx->pix_fmt,
+                                  avCodecCtx->width, avCodecCtx->height,
+                                  AV_PIX_FMT_BGR24,
+                                  SWS_BICUBIC,
+                                  NULL, NULL, NULL);
+
+        // attempt to seek to first keyframe
+        if (av_seek_frame(avFormatCtx, streamID, avFormatCtx->streams[streamID]->start_time, 0) < 0)
+            qFatal("Could not seek to beginning keyframe for %s!", qPrintable(file.name));
+        avcodec_flush_buffers(avCodecCtx);
+
+        opened = true;
+    }
+
+    TemplateList readBlock(bool *done)
+    {
+        if (!opened) {
+            deferredInit();
+        }
+
+        Template output;
+        output.file = file;
+
+        AVPacket packet;
+        av_init_packet(&packet);
+        int ret = 0;
+        while (!ret) {
+            if (av_read_frame(avFormatCtx, &packet) >= 0) {
+                if (packet.stream_index == streamID) {
+                    avcodec_decode_video2(avCodecCtx, frame, &ret, &packet);
+                    idx = packet.dts; // decompression timestamp
+                    av_free_packet(&packet);
+                } else {
+                    av_free_packet(&packet);
+                }
+            } else {
+                av_free_packet(&packet);
+                release();
+                *done = true;
+                return TemplateList();
+            }
+        }
+
+        // Convert from native format
+        sws_scale(avSwsCtx,
+                  frame->data,
+                  frame->linesize,
+                  0, avCodecCtx->height,
+                  cvt_frame->data,
+                  cvt_frame->linesize);
+
+        // Write AVFrame to cv::Mat
+        output.m() = Mat(avCodecCtx->height, avCodecCtx->width, CV_8UC3, cvt_frame->data[0]).clone();
+        if (output.m().data) {
+            if (av_seek_frame(avFormatCtx, streamID, idx+1, 0) < 0)
+                *done = true;
+            avcodec_flush_buffers(avCodecCtx);
+
+            QString URL = file.get<QString>("URL", file.name);
+            output.file.set("URL", URL + "#t=" + QString::number((int)(idx * time_base)) + "s");
+            output.file.set("timestamp", QString::number((int)(idx * time_base * 1000)));
+            output.file.set("frame", QString::number(idx * time_base * fps));
+            TemplateList dst;
+            dst.append(output);
+            return dst;
+        }
+        *done = true;
+        return TemplateList();
+    }
+
+    void release()
+    {
+        if (avSwsCtx)     sws_freeContext(avSwsCtx);
+        if (frame)        av_free(frame);
+        if (cvt_frame)    av_free(cvt_frame);
+        if (avCodecCtx)   avcodec_close(avCodecCtx);
+        if (avFormatCtx)  avformat_close_input(&avFormatCtx);
+        if (buffer)       av_free(buffer);
+        avFormatCtx = NULL;
+        avCodecCtx = NULL;
+        avSwsCtx = NULL;
+        avCodec = NULL;
+        frame = NULL;
+        cvt_frame = NULL;
+        buffer = NULL;
+    }
+
+    void write(const Template &t)
+    {
+        (void)t; qFatal("Not implemented");
+    }
+
+protected:
+    AVFormatContext *avFormatCtx;
+    AVCodecContext *avCodecCtx;
+    SwsContext *avSwsCtx;
+    AVCodec *avCodec;
+    AVFrame *frame;
+    AVFrame *cvt_frame;
+    uint8_t *buffer;
+    bool opened;
+    int streamID;
+    float fps;
+    float time_base;
+};
+
+BR_REGISTER(Gallery,keyframesGallery)
+
+/*!
+ * \ingroup galleries
+ * \brief Read key frames of a .mp4 video file with LibAV
+ * \author Ben Klein \cite bhklein
+ */
+class mp4Gallery : public keyframesGallery
+{
+    Q_OBJECT
+};
+
+BR_REGISTER(Gallery, mp4Gallery)
+
+} // namespace br
+
+#include "gallery/keyframes.moc"
diff --git a/openbr/plugins/gallery/landmarks.cpp b/openbr/plugins/gallery/landmarks.cpp
new file mode 100644
index 0000000..59b901d
--- /dev/null
+++ b/openbr/plugins/gallery/landmarks.cpp
@@ -0,0 +1,74 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * 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 galleries
+ * \brief Text format for associating anonymous landmarks with images.
+ * \author Josh Klontz \cite jklontz
+ *
+ * \code
+ * file_name:x1,y1,x2,y2,...,xn,yn
+ * file_name:x1,y1,x2,y2,...,xn,yn
+ * ...
+ * file_name:x1,y1,x2,y2,...,xn,yn
+ * \endcode
+ */
+class landmarksGallery : public Gallery
+{
+    Q_OBJECT
+
+    TemplateList readBlock(bool *done)
+    {
+        *done = true;
+        TemplateList templates;
+        foreach (const QString &line, QtUtils::readLines(file)) {
+            const QStringList words = line.split(':');
+            if (words.size() != 2) qFatal("Expected exactly one ':' in: %s.", qPrintable(line));
+            File file(words[0]);
+            const QList<float> vals = QtUtils::toFloats(words[1].split(','));
+            if (vals.size() % 2 != 0) qFatal("Expected an even number of comma-separated values.");
+            QList<QPointF> points; points.reserve(vals.size()/2);
+            for (int i=0; i<vals.size(); i+=2)
+                points.append(QPointF(vals[i], vals[i+1]));
+            file.setPoints(points);
+            templates.append(file);
+        }
+        return templates;
+    }
+
+    void write(const Template &t)
+    {
+        (void) t;
+        qFatal("Not implemented.");
+    }
+
+    void init()
+    {
+        //
+    }
+};
+
+BR_REGISTER(Gallery, landmarksGallery)
+
+} // namespace br
+
+#include "gallery/landmarks.moc"
diff --git a/openbr/plugins/gallery/lmat.cpp b/openbr/plugins/gallery/lmat.cpp
new file mode 100644
index 0000000..cb952db
--- /dev/null
+++ b/openbr/plugins/gallery/lmat.cpp
@@ -0,0 +1,42 @@
+#include <openbr/plugins/openbr_internal.h>
+#include <openbr/core/opencvutils.h>
+
+namespace br
+{
+
+/*!
+ * \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 "gallery/lmat.moc"
diff --git a/openbr/plugins/gallery/matrix.cpp b/openbr/plugins/gallery/matrix.cpp
new file mode 100644
index 0000000..79492f4
--- /dev/null
+++ b/openbr/plugins/gallery/matrix.cpp
@@ -0,0 +1,66 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * 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 galleries
+ * \brief Combine all templates into one large matrix and process it as a br::Format
+ * \author Josh Klontz \cite jklontz
+ */
+class matrixGallery : public Gallery
+{
+    Q_OBJECT
+    Q_PROPERTY(const QString extension READ get_extension WRITE set_extension RESET reset_extension STORED false)
+    BR_PROPERTY(QString, extension, "mtx")
+
+    TemplateList templates;
+
+    ~matrixGallery()
+    {
+        if (templates.isEmpty())
+            return;
+
+        QScopedPointer<Format> format(Factory<Format>::make(getFormat()));
+        format->write(Template(file, OpenCVUtils::toMat(templates.data())));
+    }
+
+    File getFormat() const
+    {
+        return file.name.left(file.name.size() - file.suffix().size()) + extension;
+    }
+
+    TemplateList readBlock(bool *done)
+    {
+        *done = true;
+        return TemplateList() << getFormat();
+    }
+
+    void write(const Template &t)
+    {
+        templates.append(t);
+    }
+};
+
+BR_REGISTER(Gallery, matrixGallery)
+
+} // namespace br
+
+#include "gallery/matrix.moc"
diff --git a/openbr/plugins/gallery/mem.cpp b/openbr/plugins/gallery/mem.cpp
new file mode 100644
index 0000000..ff8e6eb
--- /dev/null
+++ b/openbr/plugins/gallery/mem.cpp
@@ -0,0 +1,149 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * 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 Initialization support for memGallery.
+ * \author Josh Klontz \cite jklontz
+ */
+class MemoryGalleries : public Initializer
+{
+    Q_OBJECT
+
+    void initialize() const {}
+
+    void finalize() const
+    {
+        galleries.clear();
+    }
+
+public:
+    static QHash<File, TemplateList> galleries; /*!< TODO */
+};
+
+QHash<File, TemplateList> MemoryGalleries::galleries;
+
+BR_REGISTER(Initializer, MemoryGalleries)
+
+/*!
+ * \ingroup galleries
+ * \brief A gallery held in memory.
+ * \author Josh Klontz \cite jklontz
+ */
+class memGallery : public Gallery
+{
+    Q_OBJECT
+    int block;
+    qint64 gallerySize;
+
+    void init()
+    {
+        block = 0;
+        File galleryFile = file.name.mid(0, file.name.size()-4);
+        if ((galleryFile.suffix() == "gal") && galleryFile.exists() && !MemoryGalleries::galleries.contains(file)) {
+            QSharedPointer<Gallery> gallery(Factory<Gallery>::make(galleryFile));
+            MemoryGalleries::galleries[file] = gallery->read();
+            gallerySize = MemoryGalleries::galleries[file].size();
+        }
+    }
+
+    TemplateList readBlock(bool *done)
+    {
+        TemplateList templates = MemoryGalleries::galleries[file].mid(block*readBlockSize, readBlockSize);
+        for (qint64 i = 0; i < templates.size();i++) {
+            templates[i].file.set("progress", i + block * readBlockSize);
+        }
+
+        *done = (templates.size() < readBlockSize);
+        block = *done ? 0 : block+1;
+        return templates;
+    }
+
+    void write(const Template &t)
+    {
+        MemoryGalleries::galleries[file].append(t);
+    }
+
+    qint64 totalSize()
+    {
+        return gallerySize;
+    }
+
+    qint64 position()
+    {
+        return block * readBlockSize;
+    }
+
+};
+
+BR_REGISTER(Gallery, memGallery)
+
+FileList FileList::fromGallery(const File &rFile, bool cache)
+{
+    File file = rFile;
+    file.remove("append");
+
+    File targetMeta = file;
+    targetMeta.name = targetMeta.path() + targetMeta.baseName() + "_meta" + targetMeta.hash() + ".mem";
+
+    FileList fileData;
+
+    // Did we already read the data?
+    if (MemoryGalleries::galleries.contains(targetMeta))
+    {
+        return MemoryGalleries::galleries[targetMeta].files();
+    }
+
+    TemplateList templates;
+    // OK we read the data in some form, does the gallery type containing matrices?
+    if ((QStringList() << "gal" << "mem" << "template" << "ut").contains(file.suffix())) {
+        // Retrieve it block by block, dropping matrices from read templates.
+        QScopedPointer<Gallery> gallery(Gallery::make(file));
+        gallery->set_readBlockSize(10);
+        bool done = false;
+        while (!done)
+        {
+            TemplateList tList = gallery->readBlock(&done);
+            for (int i=0; i < tList.size();i++)
+            {
+                tList[i].clear();
+                templates.append(tList[i].file);
+            }
+        }
+    }
+    else {
+        // this is a gallery format that doesn't include matrices, so we can just read it
+        QScopedPointer<Gallery> gallery(Gallery::make(file));
+        templates= gallery->read();
+    }
+
+    if (cache)
+    {
+        QScopedPointer<Gallery> memOutput(Gallery::make(targetMeta));
+        memOutput->writeBlock(templates);
+    }
+    fileData = templates.files();
+    return fileData;
+}
+
+} // namespace br
+
+#include "gallery/mem.moc"
diff --git a/openbr/plugins/qtnetwork.cpp b/openbr/plugins/gallery/post.cpp
index cf80390..40197f7 100644
--- a/openbr/plugins/qtnetwork.cpp
+++ b/openbr/plugins/gallery/post.cpp
@@ -1,57 +1,28 @@
-#include <QCoreApplication>
-#include <QNetworkAccessManager>
-#include <QNetworkReply>
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * 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 <QTcpServer>
-#include <QTcpSocket>
-#include <opencv2/highgui/highgui.hpp>
-#include <http_parser.h>
-#include "openbr_internal.h"
+#include <QCoreApplication>
 
-using namespace cv;
+#include <openbr/plugins/openbr_internal.h>
 
 namespace br
 {
 
 /*!
- * \ingroup formats
- * \brief Reads image files from the web.
- * \author Josh Klontz \cite jklontz
- */
-class urlFormat : public Format
-{
-    Q_OBJECT
-
-    Template read() const
-    {
-        Template t;
-
-        QNetworkAccessManager networkAccessManager;
-        QNetworkRequest request(QString(file.name).remove(".url"));
-        request.setAttribute(QNetworkRequest::CacheLoadControlAttribute, QNetworkRequest::AlwaysNetwork);
-        QNetworkReply *reply = networkAccessManager.get(request);
-
-        while (!reply->isFinished()) QCoreApplication::processEvents();
-        if (reply->error()) qWarning("%s (%s)", qPrintable(reply->errorString()), qPrintable(QString::number(reply->error())));
-
-        QByteArray data = reply->readAll();
-        delete reply;
-
-        Mat m = imdecode(Mat(1, data.size(), CV_8UC1, data.data()), 1);
-        if (m.data) t.append(m);
-
-        return t;
-    }
-
-    void write(const Template &t) const
-    {
-        (void) t;
-        qFatal("Not supported.");
-    }
-};
-
-BR_REGISTER(Format, urlFormat)
-
-/*!
  * \ingroup galleries
  * \brief Handle POST requests
  * \author Josh Klontz \cite jklontz
@@ -126,82 +97,6 @@ QScopedPointer<postGallery::TcpServer> postGallery::server;
 
 BR_REGISTER(Gallery, postGallery)
 
-/*!
- * \ingroup formats
- * \brief Handle POST requests
- * \author Josh Klontz \cite jklontz
- */
-class postFormat : public Format
-{
-    Q_OBJECT
-
-    Template read() const
-    {
-        Template t(file);
-
-        // Read from socket
-        QTcpSocket *socket = new QTcpSocket();
-        socket->setSocketDescriptor(file.get<qintptr>("socketDescriptor"));
-        socket->write("HTTP/1.1 200 OK\r\n"
-                      "Content-Type: text/html; charset=UTF-8\r\n\r\n"
-                      "Hello World!\r\n");
-        socket->waitForBytesWritten();
-        socket->waitForReadyRead();
-        QByteArray data = socket->readAll();
-        socket->close();
-        delete socket;
-
-        qDebug() << data;
-
-        // Parse data
-        http_parser_settings settings;
-        settings.on_body = bodyCallback;
-        settings.on_headers_complete = NULL;
-        settings.on_header_field = NULL;
-        settings.on_header_value = NULL;
-        settings.on_message_begin = NULL;
-        settings.on_message_complete = NULL;
-        settings.on_status_complete = NULL;
-        settings.on_url = NULL;
-
-        {
-            QByteArray body;
-            http_parser parser;
-            http_parser_init(&parser, HTTP_REQUEST);
-            parser.data = &body;
-            http_parser_execute(&parser, &settings, data.data(), data.size());
-            data = body;
-        }
-
-        data.prepend("HTTP/1.1 200 OK");
-        QByteArray body;
-        { // Image data is two layers deep
-            http_parser parser;
-            http_parser_init(&parser, HTTP_BOTH);
-            parser.data = &body;
-            http_parser_execute(&parser, &settings, data.data(), data.size());
-        }
-
-        t.append(imdecode(Mat(1, body.size(), CV_8UC1, body.data()), 1));
-        return t;
-    }
-
-    void write(const Template &t) const
-    {
-        (void) t;
-        qFatal("Not supported!");
-    }
-
-    static int bodyCallback(http_parser *parser, const char *at, size_t length)
-    {
-        QByteArray *byteArray = (QByteArray*)parser->data;
-        *byteArray = QByteArray(at, length);
-        return 0;
-    }
-};
-
-BR_REGISTER(Format, postFormat)
-
 } // namespace br
 
-#include "qtnetwork.moc"
+#include "gallery/post.moc"
diff --git a/openbr/plugins/gallery/seq.cpp b/openbr/plugins/gallery/seq.cpp
new file mode 100644
index 0000000..f2dccf6
--- /dev/null
+++ b/openbr/plugins/gallery/seq.cpp
@@ -0,0 +1,245 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * 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 <QQueue>
+#include <opencv2/highgui/highgui.hpp>
+
+#include <openbr/plugins/openbr_internal.h>
+#include <openbr/core/qtutils.h>
+
+namespace br
+{
+
+class seqGallery : public Gallery
+{
+public:
+    Q_OBJECT
+
+    bool open()
+    {
+        seqFile.open(QtUtils::getAbsolutePath(file.name).toStdString().c_str(), std::ios::in | std::ios::binary | std::ios::ate);
+        if (!isOpen()) {
+            qDebug("Failed to open file %s for reading", qPrintable(file.name));
+            return false;
+        }
+
+        int headSize = 1024;
+        // start at end of file to get full size
+        int fileSize = seqFile.tellg();
+        if (fileSize < headSize) {
+            qDebug("No header in seq file");
+            return false;
+        }
+
+        // first 4 bytes store 0xEDFE, next 24 store 'Norpix seq  '
+        char firstFour[4];
+        seqFile.seekg(0, std::ios::beg);
+        seqFile.read(firstFour, 4);
+        char nextTwentyFour[24];
+        readText(24, nextTwentyFour);
+        if (firstFour[0] != (char)0xED || firstFour[1] != (char)0xFE || strncmp(nextTwentyFour, "Norpix seq", 10) != 0) {
+            qDebug("Invalid header in seq file");
+            return false;
+        }
+
+        // next 8 bytes for version (skipped below) and header size (1024), then 512 for descr
+        seqFile.seekg(4, std::ios::cur);
+        int hSize = readInt();
+        if (hSize != headSize) {
+            qDebug("Invalid header size");
+            return false;
+        }
+        char desc[512];
+        readText(512, desc);
+        file.set("Description", QString(desc));
+
+        width = readInt();
+        height = readInt();
+        // get # channels from bit depth
+        numChan = readInt()/8;
+        int imageBitDepthReal = readInt();
+        if (imageBitDepthReal != 8) {
+            qDebug("Invalid bit depth");
+            return false;
+        }
+        // the size of just the image part of a raw img
+        imgSizeBytes = readInt();
+
+        int imgFormatInt = readInt();
+        if (imgFormatInt == 100 || imgFormatInt == 200 || imgFormatInt == 101) {
+            imgFormat = "raw";
+        } else if (imgFormatInt == 102 || imgFormatInt == 201 || imgFormatInt == 103 ||
+                   imgFormatInt == 1 || imgFormatInt == 2) {
+            imgFormat = "compressed";
+        } else {
+            qFatal("unsupported image format");
+        }
+
+        numFrames = readInt();
+        // skip empty int
+        seqFile.seekg(4, std::ios::cur);
+        // the size of a full raw file, with extra crap after img data
+        trueImgSizeBytes = readInt();
+
+        // gather all the frame positions in an array
+        seekPos.reserve(numFrames);
+        // start at end of header
+        seekPos.append(headSize);
+        // extra 8 bytes at end of img
+        int extra = 8;
+        for (int i=1; i<numFrames; i++) {
+            int s;
+            // compressed images have different sizes
+            // the first byte at the beginning of the file
+            // says how big the current img is
+            if (imgFormat == "compressed") {
+                int lastPos = seekPos[i-1];
+                seqFile.seekg(lastPos, std::ios::beg);
+                int currSize = readInt();
+                s = lastPos + currSize + extra;
+
+                // but there might be 16 extra bytes instead of 8...
+                if (i == 1) {
+                    seqFile.seekg(s, std::ios::beg);
+                    char zero;
+                    seqFile.read(&zero, 1);
+                    if (zero == 0) {
+                        s += 8;
+                        extra += 8;
+                    }
+                }
+            }
+            // raw images are all the same size
+            else {
+                s = headSize + (i*trueImgSizeBytes);
+            }
+
+            seekPos.enqueue(s);
+        }
+
+#ifdef CVMATIO
+        if (basis.file.contains("vbb")) {
+            QString vbb = basis.file.get<QString>("vbb");
+            annotations = TemplateList::fromGallery(File(vbb));
+        }
+#else
+        qWarning("cvmatio not installed, bounding boxes will not be available. Add -DBR_WITH_CVMATIO cmake flag to install.");
+#endif
+
+        return true;
+    }
+
+    bool isOpen()
+    {
+        return seqFile.is_open();
+    }
+
+    void close()
+    {
+        seqFile.close();
+    }
+
+    TemplateList readBlock(bool *done)
+    {
+        if (!isOpen()) {
+            if (!open())
+                qFatal("Failed to open file %s for reading", qPrintable(file.name));
+            else
+                idx = 0;
+        }
+
+        // if we've reached the last frame, we're done
+        if (seekPos.size() == 0) {
+            *done = true;
+            return TemplateList();
+        }
+
+        seqFile.seekg(seekPos.dequeue(), std::ios::beg);
+
+        cv::Mat temp;
+        // let imdecode do all the work to decode the compressed img
+        if (imgFormat == "compressed") {
+            int imgSize = readInt() - 4;
+            std::vector<char> imgBuf(imgSize);
+            seqFile.read(&imgBuf[0], imgSize);
+            // flags < 0 means load image as-is (keep color info if available)
+            cv::imdecode(imgBuf, -1, &temp);
+        }
+        // raw images can be loaded straight into a Mat
+        else {
+            char *imgBuf = new char[imgSizeBytes];
+            seqFile.read(imgBuf, imgSizeBytes);
+            int type = (numChan == 1 ? CV_8UC1 : CV_8UC3);
+            temp = cv::Mat(height, width, type, imgBuf);
+        }
+        Template output;
+        output.file = file;
+        if (!annotations.empty()) {
+            output.file.setRects(annotations.first().file.rects());
+            annotations.removeFirst();
+        }
+        output.m() = temp;
+        output.file.set("position",idx);
+        idx++;
+
+        *done = false;
+        TemplateList rVal;
+        rVal.append(output);
+
+        return rVal;
+    }
+
+    void write(const Template &t)
+    {
+        (void) t;
+        qFatal("Not implemented.");
+    }
+
+private:
+    qint64 idx;
+    int readInt()
+    {
+        int num;
+        seqFile.read((char*)&num, 4);
+        return num;
+    }
+
+    // apparently the text in seq files is 16 bit characters (UTF-16?)
+    // since we don't really need the last byte, snad since it gets interpreted as
+    // a terminating char, let's just grab the first byte for storage
+    void readText(int bytes, char *buffer)
+    {
+        seqFile.read(buffer, bytes);
+        for (int i=0; i<bytes; i+=2) {
+            buffer[i/2] = buffer[i];
+        }
+        buffer[bytes/2] = '\0';
+    }
+
+protected:
+    std::ifstream seqFile;
+    QQueue<int> seekPos;
+    int width, height, numChan, imgSizeBytes, trueImgSizeBytes, numFrames;
+    QString imgFormat;
+    TemplateList annotations;
+};
+
+BR_REGISTER(Gallery, seqGallery)
+
+} // namespace br
+
+#include "gallery/seq.moc"
diff --git a/openbr/plugins/gallery/stat.cpp b/openbr/plugins/gallery/stat.cpp
new file mode 100644
index 0000000..3b1b0d3
--- /dev/null
+++ b/openbr/plugins/gallery/stat.cpp
@@ -0,0 +1,66 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * 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 galleries
+ * \brief Print template statistics.
+ * \author Josh Klontz \cite jklontz
+ */
+class statGallery : public Gallery
+{
+    Q_OBJECT
+    QSet<QString> subjects;
+    QList<int> bytes;
+
+    ~statGallery()
+    {
+        int emptyTemplates = 0;
+        for (int i=bytes.size()-1; i>=0; i--)
+            if (bytes[i] == 0) {
+                bytes.removeAt(i);
+                emptyTemplates++;
+            }
+
+        double bytesMean, bytesStdDev;
+        Common::MeanStdDev(bytes, &bytesMean, &bytesStdDev);
+        printf("Subjects: %d\nEmpty Templates: %d/%d\nBytes/Template: %.4g +/- %.4g\n",
+               subjects.size(), emptyTemplates, emptyTemplates+bytes.size(), bytesMean, bytesStdDev);
+    }
+
+    TemplateList readBlock(bool *done)
+    {
+        *done = true;
+        return TemplateList() << file;
+    }
+
+    void write(const Template &t)
+    {
+        subjects.insert(t.file.get<QString>("Label"));
+        bytes.append(t.bytes());
+    }
+};
+
+BR_REGISTER(Gallery, statGallery)
+
+} // namespace br
+
+#include "gallery/stat.moc"
diff --git a/openbr/plugins/gallery/template.cpp b/openbr/plugins/gallery/template.cpp
new file mode 100644
index 0000000..d7efd47
--- /dev/null
+++ b/openbr/plugins/gallery/template.cpp
@@ -0,0 +1,56 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * 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 galleries
+ * \brief Treat the file as a single binary template.
+ * \author Josh Klontz \cite jklontz
+ */
+class templateGallery : public Gallery
+{
+    Q_OBJECT
+
+    TemplateList readBlock(bool *done)
+    {
+        *done = true;
+        QByteArray data;
+        QtUtils::readFile(file.name.left(file.name.size()-QString(".template").size()), data);
+        return TemplateList() << Template(file, cv::Mat(1, data.size(), CV_8UC1, data.data()).clone());
+    }
+
+    void write(const Template &t)
+    {
+        (void) t;
+        qFatal("Not supported.");
+    }
+
+    void init()
+    {
+        //
+    }
+};
+
+BR_REGISTER(Gallery, templateGallery)
+
+} // namespace br
+
+#include "gallery/template.moc"
diff --git a/openbr/plugins/gallery/turk.cpp b/openbr/plugins/gallery/turk.cpp
new file mode 100644
index 0000000..a9b7d9c
--- /dev/null
+++ b/openbr/plugins/gallery/turk.cpp
@@ -0,0 +1,105 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * 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>
+#include <openbr/core/qtutils.h>
+
+namespace br
+{
+
+/*!
+ * \ingroup galleries
+ * \brief For Amazon Mechanical Turk datasets
+ * \author Scott Klum \cite sklum
+ */
+class turkGallery : public Gallery
+{
+    Q_OBJECT
+
+    struct Attribute : public QStringList
+    {
+        QString name;
+        Attribute(const QString &str = QString())
+        {
+            const int i = str.indexOf('[');
+            name = str.mid(0, i);
+            if (i != -1)
+                append(str.mid(i+1, str.length()-i-2).split(","));
+        }
+
+        Attribute normalized() const
+        {
+            bool ok;
+            QList<float> values;
+            foreach (const QString &value, *this) {
+                values.append(value.toFloat(&ok));
+                if (!ok)
+                    qFatal("Can't normalize non-numeric vector!");
+            }
+
+            Attribute normal(name);
+            float sum = Common::Sum(values);
+            if (sum == 0) sum = 1;
+            for (int i=0; i<values.size(); i++)
+                normal.append(QString::number(values[i] / sum));
+            return normal;
+        }
+    };
+
+    TemplateList readBlock(bool *done)
+    {
+        *done = true;
+        QStringList lines = QtUtils::readLines(file);
+        QList<Attribute> headers;
+        if (!lines.isEmpty())
+            foreach (const QString &header, parse(lines.takeFirst()))
+                headers.append(header);
+
+        TemplateList templates;
+        foreach (const QString &line, lines) {
+            QStringList words = parse(line);
+            if (words.size() != headers.size())
+                qFatal("turkGallery invalid column count");
+
+            File f;
+            f.name = words[0];
+            f.set("Label", words[0].mid(0,5));
+
+            for (int i=1; i<words.size(); i++) {
+                Attribute ratings = Attribute(words[i]).normalized();
+                if (headers[i].size() != ratings.size())
+                    qFatal("turkGallery invalid attribute count");
+                for (int j=0; j<ratings.size(); j++)
+                    f.set(headers[i].name + "_" + headers[i][j], ratings[j]);
+            }
+            templates.append(f);
+        }
+
+        return templates;
+    }
+
+    void write(const Template &)
+    {
+        qFatal("turkGallery write not implemented.");
+    }
+};
+
+BR_REGISTER(Gallery, turkGallery)
+
+} // namespace br
+
+#include "gallery/turk.moc"
diff --git a/openbr/plugins/gallery/txt.cpp b/openbr/plugins/gallery/txt.cpp
new file mode 100644
index 0000000..d243fb7
--- /dev/null
+++ b/openbr/plugins/gallery/txt.cpp
@@ -0,0 +1,95 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * 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 galleries
+ * \brief Treats each line as a file.
+ * \author Josh Klontz \cite jklontz
+ *
+ * The entire line is treated as the file path. An optional label may be specified using a space ' ' separator:
+ *
+\verbatim
+<FILE>
+<FILE>
+...
+<FILE>
+\endverbatim
+ * or
+\verbatim
+<FILE> <LABEL>
+<FILE> <LABEL>
+...
+<FILE> <LABEL>
+\endverbatim
+ * \see csvGallery
+ */
+class txtGallery : public FileGallery
+{
+    Q_OBJECT
+    Q_PROPERTY(QString label READ get_label WRITE set_label RESET reset_label STORED false)
+    BR_PROPERTY(QString, label, "")
+
+    TemplateList readBlock(bool *done)
+    {
+        readOpen();
+        *done = false;
+        if (f.atEnd())
+            f.seek(0);
+
+        TemplateList templates;
+
+        for (qint64 i = 0; i < readBlockSize; i++)
+        {
+            QByteArray lineBytes = f.readLine();
+            QString line = QString::fromLocal8Bit(lineBytes).trimmed();
+
+            if (!line.isEmpty()){
+                int splitIndex = line.lastIndexOf(' ');
+                if (splitIndex == -1) templates.append(File(line));
+                else                  templates.append(File(line.mid(0, splitIndex), line.mid(splitIndex+1)));
+                templates.last().file.set("progress", this->position());
+            }
+
+            if (f.atEnd()) {
+                *done=true;
+                break;
+            }
+        }
+
+        return templates;
+    }
+
+    void write(const Template &t)
+    {
+        writeOpen();
+        QString line = t.file.name;
+        if (!label.isEmpty())
+            line += " " + t.file.get<QString>(label);
+
+        f.write((line+"\n").toLocal8Bit() );
+    }
+};
+
+BR_REGISTER(Gallery, txtGallery)
+
+} // namespace br
+
+#include "gallery/txt.moc"
diff --git a/openbr/plugins/gallery/vbb.cpp b/openbr/plugins/gallery/vbb.cpp
new file mode 100644
index 0000000..151c1a3
--- /dev/null
+++ b/openbr/plugins/gallery/vbb.cpp
@@ -0,0 +1,92 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * 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.                                            *
+ * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+
+#ifdef CVMATIO
+
+#include <openbr/plugins/openbr_internal.h>
+
+namespace br
+{
+
+using namespace cv;
+
+class vbbGallery : public Gallery
+{
+    Q_OBJECT
+
+    void init()
+    {
+        MatlabIO matio;
+        QString filename = (Globals->path.isEmpty() ? "" : Globals->path + "/") + file.name;
+        bool ok = matio.open(filename.toStdString(), "r");
+        if (!ok) qFatal("Couldn't open the vbb file");
+
+        vector<MatlabIOContainer> variables;
+        variables = matio.read();
+        matio.close();
+
+        double vers = variables[1].data<Mat>().at<double>(0,0);
+        if (vers != 1.4) qFatal("This is an old vbb version, we don't mess with that.");
+
+        A = variables[0].data<vector<vector<MatlabIOContainer> > >().at(0);
+        objLists = A.at(1).data<vector<MatlabIOContainer> >();
+
+        // start at the first frame (duh!)
+        currFrame = 0;
+    }
+
+    TemplateList readBlock(bool *done)
+    {
+        *done = false;
+        Template rects(file);
+        if (objLists[currFrame].typeEquals<vector<vector<MatlabIOContainer> > >()) {
+            vector<vector<MatlabIOContainer> > bbs = objLists[currFrame].data<vector<vector<MatlabIOContainer> > >();
+            for (unsigned int i=0; i<bbs.size(); i++) {
+                vector<MatlabIOContainer> bb = bbs[i];
+                Mat pos = bb[1].data<Mat>();
+                double left = pos.at<double>(0,0);
+                double top = pos.at<double>(0,1);
+                double width = pos.at<double>(0,2);
+                double height = pos.at<double>(0,3);
+                rects.file.appendRect(QRectF(left, top, width, height));
+            }
+        }
+        TemplateList tl;
+        tl.append(rects);
+        if (++currFrame == (int)objLists.size()) *done = true;
+        return tl;
+    }
+
+    void write(const Template &t)
+    {
+        (void)t; qFatal("Not implemented");
+    }
+
+private:
+    // this holds a bunch of stuff, maybe we'll use it all later
+    vector<MatlabIOContainer> A;
+    // this, a field in A, holds bounding boxes for each frame
+    vector<MatlabIOContainer> objLists;
+    int currFrame;
+};
+
+BR_REGISTER(Gallery, vbbGallery)
+
+} // namespace br
+
+#include "gallery/vbb.moc"
+
+#endif
diff --git a/openbr/plugins/gallery/video.cpp b/openbr/plugins/gallery/video.cpp
new file mode 100644
index 0000000..90fb2ff
--- /dev/null
+++ b/openbr/plugins/gallery/video.cpp
@@ -0,0 +1,139 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * Copyright 2012 The MITRE Corporation                                      *
+ *                                                                           *
+ * Licensed under the Apache License, Version 2.0 (the "License");           *
+ * you may not use this file except in compliance with the License.          *
+ * You may obtain a copy of the License at                                   *
+ *                                                                           *
+ *     http://www.apache.org/licenses/LICENSE-2.0                            *
+ *                                                                           *
+ * Unless required by applicable law or agreed to in writing, software       *
+ * distributed under the License is distributed on an "AS IS" BASIS,         *
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  *
+ * See the License for the specific language governing permissions and       *
+ * limitations under the License.                                            *
+ * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+
+#include <opencv2/highgui/highgui.hpp>
+
+#include <openbr/plugins/openbr_internal.h>
+#include <openbr/core/qtutils.h>
+
+namespace br
+{
+
+// Read a video frame by frame using cv::VideoCapture
+class videoGallery : public Gallery
+{
+    Q_OBJECT
+public:
+    qint64 idx;
+    ~videoGallery()
+    {
+        video.release();
+    }
+
+    static QMutex openLock;
+
+    virtual void deferredInit()
+    {
+        bool status = video.open(QtUtils::getAbsolutePath(file.name).toStdString());
+
+        if (!status)
+            qFatal("Failed to open file %s with path %s", qPrintable(file.name), qPrintable(QtUtils::getAbsolutePath(file.name)));
+    }
+
+    TemplateList readBlock(bool *done)
+    {
+        if (!video.isOpened()) {
+            // opening videos appears to not be thread safe on windows
+            QMutexLocker lock(&openLock);
+
+            deferredInit();
+            idx = 0;
+        }
+
+        Template output;
+        output.file = file;
+        output.m() = cv::Mat();
+
+        cv::Mat temp;
+        bool res = video.read(temp);
+
+        if (!res) {
+            // The video capture broke, return an empty list.
+            output.m() = cv::Mat();
+            video.release();
+            *done = true;
+            return TemplateList();
+        }
+
+        // This clone is critical, if we don't do it then the output matrix will
+        // be an alias of an internal buffer of the video source, leading to various
+        // problems later.
+        output.m() = temp.clone();
+
+        output.file.set("progress", idx);
+        idx++;
+
+        TemplateList rVal;
+        rVal.append(temp);
+        *done = false;
+        return rVal;
+    }
+
+    void write(const Template &t)
+    {
+        (void)t; qFatal("Not implemented");
+    }
+
+protected:
+    cv::VideoCapture video;
+};
+
+BR_REGISTER(Gallery,videoGallery)
+
+QMutex videoGallery::openLock;
+
+class aviGallery : public videoGallery
+{
+    Q_OBJECT
+};
+
+BR_REGISTER(Gallery, aviGallery)
+
+class wmvGallery : public videoGallery
+{
+    Q_OBJECT
+};
+
+BR_REGISTER(Gallery, wmvGallery)
+
+// Mostly the same as videoGallery, but we open the VideoCapture with an integer index
+// rather than file name/web address
+class webcamGallery : public videoGallery
+{
+public:
+    Q_OBJECT
+
+    void deferredInit()
+    {
+        bool intOK = false;
+        int anInt = file.baseName().toInt(&intOK);
+
+        if (!intOK)
+            qFatal("Expected integer basename, got %s", qPrintable(file.baseName()));
+
+        bool rc = video.open(anInt);
+
+        if (!rc)
+            qFatal("Failed to open webcam with index: %s", qPrintable(file.baseName()));
+    }
+
+};
+
+BR_REGISTER(Gallery,webcamGallery)
+
+} // namespace br
+
+#include "gallery/video.moc"
diff --git a/openbr/plugins/gallery/xml.cpp b/openbr/plugins/gallery/xml.cpp
new file mode 100644
index 0000000..4d6bcec
--- /dev/null
+++ b/openbr/plugins/gallery/xml.cpp
@@ -0,0 +1,184 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * 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 <QtXml>
+
+#include <openbr/plugins/openbr_internal.h>
+#include <openbr/core/bee.h>
+
+namespace br
+{
+
+/*!
+ * \ingroup galleries
+ * \brief A \ref sigset input.
+ * \author Josh Klontz \cite jklontz
+ */
+class xmlGallery : public FileGallery
+{
+    Q_OBJECT
+    Q_PROPERTY(bool ignoreMetadata READ get_ignoreMetadata WRITE set_ignoreMetadata RESET reset_ignoreMetadata STORED false)
+    BR_PROPERTY(bool, ignoreMetadata, false)
+    FileList files;
+
+    QXmlStreamReader reader;
+
+    QString currentSignatureName;
+    bool signatureActive;
+
+    ~xmlGallery()
+    {
+        f.close();
+        if (!files.isEmpty())
+            BEE::writeSigset(file, files, ignoreMetadata);
+    }
+
+    TemplateList readBlock(bool *done)
+    {
+        if (readOpen())
+            reader.setDevice(&f);
+
+        if (reader.atEnd())
+            f.seek(0);
+
+        TemplateList templates;
+        qint64 count = 0;
+
+        while (!reader.atEnd())
+        {
+            // if an identity is active we try to read presentations
+            if (signatureActive)
+            {
+                while (signatureActive)
+                {
+                    QXmlStreamReader::TokenType signatureToken = reader.readNext();
+
+                    // did the signature end?
+                    if (signatureToken == QXmlStreamReader::EndElement && reader.name() == "biometric-signature") {
+                        signatureActive = false;
+                        break;
+                    }
+
+                    // did we reach the end of the document? Theoretically this shoudln't happen without reaching the end of
+                    if (signatureToken == QXmlStreamReader::EndDocument)
+                        break;
+
+                    // a presentation!
+                    if (signatureToken == QXmlStreamReader::StartElement && reader.name() == "presentation") {
+                        templates.append(Template(File("",currentSignatureName)));
+                        foreach (const QXmlStreamAttribute &attribute, reader.attributes()) {
+                            // file-name is stored directly on file, not as a key/value pair
+                            if (attribute.name() == "file-name")
+                                templates.last().file.name = attribute.value().toString();
+                            // other values are directly set as metadata
+                            else if (!ignoreMetadata) templates.last().file.set(attribute.name().toString(), attribute.value().toString());
+                        }
+
+                        // a presentation can have bounding boxes as child elements
+                        QList<QRectF> rects = templates.last().file.rects();
+                        while (true)
+                        {
+                            QXmlStreamReader::TokenType pToken = reader.readNext();
+                            if (pToken == QXmlStreamReader::EndElement && reader.name() == "presentation")
+                                break;
+
+                            if (pToken == QXmlStreamReader::StartElement)
+                            {
+                                if (reader.attributes().hasAttribute("x")
+                                    && reader.attributes().hasAttribute("y")
+                                    && reader.attributes().hasAttribute("width")
+                                    && reader.attributes().hasAttribute("height") )
+                                {
+                                    // get bounding box properties as attributes, just going to assume this all works
+                                    qreal x = reader.attributes().value("x").string()->toDouble();
+                                    qreal y = reader.attributes().value("y").string()->toDouble();
+                                    qreal width =  reader.attributes().value("width").string()->toDouble();
+                                    qreal height = reader.attributes().value("height").string()->toDouble();
+                                    rects += QRectF(x, y, width, height);
+                                }
+                            }
+                        }
+                        templates.last().file.setRects(rects);
+                        templates.last().file.set("progress", f.pos());
+
+                        // we read another complete template
+                        count++;
+                    }
+                }
+            }
+            // otherwise, keep reading elements until the next identity is reacehed
+            else
+            {
+                QXmlStreamReader::TokenType token = reader.readNext();
+
+                // end of file?
+                if (token == QXmlStreamReader::EndDocument)
+                    break;
+
+                // we are only interested in new elements
+                if (token != QXmlStreamReader::StartElement)
+                    continue;
+
+                QStringRef elName = reader.name();
+
+                // biometric-signature-set is the root element
+                if (elName == "biometric-signature-set")
+                    continue;
+
+                // biometric-signature -- an identity
+                if (elName == "biometric-signature")
+                {
+                    // read the name associated with the current signature
+                    if (!reader.attributes().hasAttribute("name"))
+                    {
+                        qDebug() << "Biometric signature missing name";
+                        continue;
+                    }
+                    currentSignatureName = reader.attributes().value("name").toString();
+                    signatureActive = true;
+
+                    // If we've already read enough templates for this block, then break here.
+                    // We wait untill the start of the next signature to be sure that done should
+                    // actually be false (i.e. there are actually items left in this file)
+                    if (count >= this->readBlockSize) {
+                        *done = false;
+                        return templates;
+                    }
+
+                }
+            }
+        }
+        *done = true;
+
+        return templates;
+    }
+
+    void write(const Template &t)
+    {
+        files.append(t.file);
+    }
+
+    void init()
+    {
+        FileGallery::init();
+    }
+};
+
+BR_REGISTER(Gallery, xmlGallery)
+
+} // namespace br
+
+#include "gallery/xml.moc"
diff --git a/openbr/plugins/gui.cmake b/openbr/plugins/gui.cmake
deleted file mode 100644
index af09d1b..0000000
--- a/openbr/plugins/gui.cmake
+++ /dev/null
@@ -1,3 +0,0 @@
-if(NOT ${BR_EMBEDDED})
-  set(BR_THIRDPARTY_SRC ${BR_THIRDPARTY_SRC} plugins/gui.cpp)
-endif()
diff --git a/openbr/plugins/gui/adjacentoverlay.cpp b/openbr/plugins/gui/adjacentoverlay.cpp
new file mode 100644
index 0000000..308fd8a
--- /dev/null
+++ b/openbr/plugins/gui/adjacentoverlay.cpp
@@ -0,0 +1,233 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * 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 transforms
+ * \brief Load the image named in the specified property, draw it on the current matrix adjacent to the rect specified in the other property.
+ * \author Charles Otto \cite caotto
+ */
+class AdjacentOverlayTransform : public Transform
+{
+    Q_OBJECT
+
+    Q_PROPERTY(QString imgName READ get_imgName WRITE set_imgName RESET reset_imgName STORED false)
+    Q_PROPERTY(QString targetName READ get_targetName WRITE set_targetName RESET reset_targetName STORED false)
+    BR_PROPERTY(QString, imgName, "")
+    BR_PROPERTY(QString, targetName, "")
+
+    QSharedPointer<Transform> opener;
+    void project(const Template &src, Template &dst) const
+    {
+        dst = src;
+
+        if (imgName.isEmpty() || targetName.isEmpty() || !dst.file.contains(imgName) || !dst.file.contains(targetName))
+            return;
+
+        QVariant temp = src.file.value(imgName);
+        cv::Mat im;
+        // is this a filename?
+        if (temp.canConvert<QString>()) {
+            QString im_name = temp.toString();
+            Template temp_im;
+            opener->project(File(im_name), temp_im);
+            im = temp_im.m();
+        }
+        // a cv::Mat ?
+        else if (temp.canConvert<cv::Mat>())
+            im = src.file.get<cv::Mat>(imgName);
+        else
+            qDebug() << "Unrecognized property type " << imgName << "for" << src.file.name;
+
+        // Location of detected face in source image
+        QRectF target_location = src.file.get<QRectF>(targetName);
+
+        // match width with target region
+        qreal target_width = target_location.width();
+        qreal current_width = im.cols;
+        qreal current_height = im.rows;
+
+        qreal aspect_ratio = current_height / current_width;
+        qreal target_height = target_width * aspect_ratio;
+
+        cv::resize(im, im, cv::Size(target_width, target_height));
+
+        // ROI used to maybe crop the matched image
+        cv::Rect clip_roi;
+        clip_roi.x = 0;
+        clip_roi.y = 0;
+        clip_roi.width = im.cols;
+        clip_roi.height= im.rows <= dst.m().rows ? im.rows : dst.m().rows;
+
+        int half_width = src.m().cols / 2;
+        int out_x = 0;
+
+        // place in the source image we will copy the matched image to.
+        cv::Rect target_roi;
+        bool left_side = false;
+        int width_adjust = 0;
+        // Place left
+        if (target_location.center().rx() > half_width) {
+            out_x = target_location.left() - im.cols;
+            if (out_x < 0) {
+                width_adjust = abs(out_x);
+                out_x = 0;
+            }
+            left_side = true;
+        }
+        // place right
+        else {
+            out_x = target_location.right();
+            int high = out_x + im.cols;
+            if (high >= src.m().cols) {
+                width_adjust = abs(high - src.m().cols + 1);
+            }
+        }
+
+        cv::Mat outIm;
+        if (width_adjust)
+        {
+            outIm.create(dst.m().rows, dst.m().cols + width_adjust, CV_8UC3);
+            memset(outIm.data, 127, outIm.rows * outIm.cols * outIm.channels());
+
+            Rect temp;
+
+            if (left_side)
+                temp = Rect(abs(width_adjust), 0, dst.m().cols, dst.m().rows);
+
+            else
+                temp = Rect(0, 0, dst.m().cols, dst.m().rows);
+
+            dst.m().copyTo(outIm(temp));
+
+        }
+        else
+            outIm = dst.m();
+
+        if (clip_roi.height + target_location.top() >= outIm.rows)
+        {
+            clip_roi.height -= abs(outIm.rows - (clip_roi.height + target_location.top() ));
+        }
+        if (clip_roi.x + clip_roi.width >= im.cols) {
+            clip_roi.width -= abs(im.cols - (clip_roi.x + clip_roi.width + 1));
+            if (clip_roi.width < 0)
+                clip_roi.width = 1;
+        }
+
+        if (clip_roi.y + clip_roi.height >= im.rows) {
+            clip_roi.height -= abs(im.rows - (clip_roi.y + clip_roi.height + 1));
+        }
+        if (clip_roi.x < 0)
+            clip_roi.x = 0;
+        if (clip_roi.y < 0)
+            clip_roi.y = 0;
+
+        if (clip_roi.height < 0)
+            clip_roi.height = 0;
+
+        if (clip_roi.width < 0)
+            clip_roi.width = 0;
+
+
+        if (clip_roi.y + clip_roi.height >= im.rows)
+        {
+            qDebug() << "Bad clip y" << clip_roi.y + clip_roi.height << im.rows;
+        }
+        if (clip_roi.x + clip_roi.width >= im.cols)
+        {
+            qDebug() << "Bad clip x" << clip_roi.x + clip_roi.width << im.cols;
+        }
+
+        if (clip_roi.y < 0 || clip_roi.height < 0)
+        {
+            qDebug() << "bad clip y, low" << clip_roi.y << clip_roi.height;
+            qFatal("die");
+        }
+        if (clip_roi.x < 0 || clip_roi.width < 0)
+        {
+            qDebug() << "bad clip x, low" << clip_roi.x << clip_roi.width;
+            qFatal("die");
+        }
+
+        target_roi.x = out_x;
+        target_roi.width = clip_roi.width;
+        target_roi.y = target_location.top();
+        target_roi.height = clip_roi.height;
+
+
+        im = im(clip_roi);
+
+        if (target_roi.x < 0 || target_roi.x >= outIm.cols)
+        {
+            qDebug() << "Bad xdim in targetROI!" << target_roi.x << " out im x: " << outIm.cols;
+            qFatal("die");
+        }
+
+        if (target_roi.x + target_roi.width < 0 || (target_roi.x + target_roi.width) >= outIm.cols)
+        {
+            qDebug() << "Bad xdim in targetROI!" << target_roi.x + target_roi.width;
+            qFatal("die");
+        }
+
+        if (target_roi.y < 0 || target_roi.y >= outIm.rows)
+        {
+            qDebug() << "Bad ydim in targetROI!" << target_roi.y;
+            qFatal("die");
+        }
+
+        if ((target_roi.y + target_roi.height) < 0 || (target_roi.y + target_roi.height) > outIm.rows)
+        {
+            qDebug() << "Bad ydim in targetROI!" << target_roi.y + target_roi.height;
+            qDebug() << "target_roi.y: " << target_roi.y << " height: " << target_roi.height;
+            qFatal("die");
+        }
+
+
+        std::vector<cv::Mat> channels;
+        cv::split(outIm, channels);
+
+        std::vector<cv::Mat> patch_channels;
+        cv::split(im, patch_channels);
+
+        for (size_t i=0; i < channels.size(); i++)
+        {
+            cv::addWeighted(channels[i](target_roi), 0, patch_channels[i % patch_channels.size()], 1, 0,channels[i](target_roi));
+        }
+        cv::merge(channels, outIm);
+        dst.m() = outIm;
+
+    }
+
+    void init()
+    {
+        opener = QSharedPointer<br::Transform>(br::Transform::make("Cache(Open)", NULL));
+    }
+
+};
+
+BR_REGISTER(Transform, AdjacentOverlayTransform)
+
+} // namespace br
+
+#include "gui/adjacentoverlay.moc"
diff --git a/openbr/plugins/gui/draw.cpp b/openbr/plugins/gui/draw.cpp
new file mode 100644
index 0000000..69177ec
--- /dev/null
+++ b/openbr/plugins/gui/draw.cpp
@@ -0,0 +1,77 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * 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 Renders metadata onto the image.
+ *
+ * The inPlace argument controls whether or not the image is cloned before the metadata is drawn.
+ *
+ * \author Josh Klontz \cite jklontz
+ */
+class DrawTransform : public UntrainableTransform
+{
+    Q_OBJECT
+    Q_PROPERTY(bool verbose READ get_verbose WRITE set_verbose RESET reset_verbose STORED false)
+    Q_PROPERTY(bool points READ get_points WRITE set_points RESET reset_points STORED false)
+    Q_PROPERTY(bool rects READ get_rects WRITE set_rects RESET reset_rects STORED false)
+    Q_PROPERTY(bool inPlace READ get_inPlace WRITE set_inPlace RESET reset_inPlace STORED false)
+    Q_PROPERTY(int lineThickness READ get_lineThickness WRITE set_lineThickness RESET reset_lineThickness STORED false)
+    Q_PROPERTY(bool named READ get_named WRITE set_named RESET reset_named STORED false)
+    Q_PROPERTY(bool location READ get_location WRITE set_location RESET reset_location STORED false)
+    BR_PROPERTY(bool, verbose, false)
+    BR_PROPERTY(bool, points, true)
+    BR_PROPERTY(bool, rects, true)
+    BR_PROPERTY(bool, inPlace, false)
+    BR_PROPERTY(int, lineThickness, 1)
+    BR_PROPERTY(bool, named, true)
+    BR_PROPERTY(bool, location, true)
+
+    void project(const Template &src, Template &dst) const
+    {
+        const Scalar color(0,255,0);
+        const Scalar verboseColor(255, 255, 0);
+        dst.m() = inPlace ? src.m() : src.m().clone();
+
+        if (points) {
+            const QList<Point2f> pointsList = (named) ? OpenCVUtils::toPoints(src.file.points()+src.file.namedPoints()) : OpenCVUtils::toPoints(src.file.points());
+            for (int i=0; i<pointsList.size(); i++) {
+                const Point2f &point = pointsList[i];
+                circle(dst, point, 3, color, -1);
+                QString label = (location) ? QString("%1,(%2,%3)").arg(QString::number(i),QString::number(point.x),QString::number(point.y)) : QString("%1").arg(QString::number(i));
+                if (verbose) putText(dst, label.toStdString(), point, FONT_HERSHEY_SIMPLEX, 0.5, verboseColor, 1);
+            }
+        }
+        if (rects) {
+            foreach (const Rect &rect, OpenCVUtils::toRects(src.file.namedRects() + src.file.rects()))
+                rectangle(dst, rect, color, lineThickness);
+        }
+    }
+};
+
+BR_REGISTER(Transform, DrawTransform)
+
+} // namespace br
+
+#include "gui/draw.moc"
diff --git a/openbr/plugins/gui/drawdelaunay.cpp b/openbr/plugins/gui/drawdelaunay.cpp
new file mode 100644
index 0000000..dc86c6c
--- /dev/null
+++ b/openbr/plugins/gui/drawdelaunay.cpp
@@ -0,0 +1,55 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * 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 Creates a Delaunay triangulation based on a set of points
+ * \author Scott Klum \cite sklum
+ */
+class DrawDelaunayTransform : public UntrainableTransform
+{
+    Q_OBJECT
+
+    void project(const Template &src, Template &dst) const
+    {
+        dst = src;
+
+        if (src.file.contains("DelaunayTriangles")) {
+            QList<Point2f> validTriangles = OpenCVUtils::toPoints(src.file.getList<QPointF>("DelaunayTriangles"));
+
+            // Clone the matrix do draw on it
+            for (int i = 0; i < validTriangles.size(); i+=3) {
+                line(dst, validTriangles[i], validTriangles[i+1], Scalar(0,0,0), 1);
+                line(dst, validTriangles[i+1], validTriangles[i+2], Scalar(0,0,0), 1);
+                line(dst, validTriangles[i+2], validTriangles[i], Scalar(0,0,0), 1);
+            }
+        } else qWarning("Template does not contain Delaunay triangulation.");
+    }
+};
+
+BR_REGISTER(Transform, DrawDelaunayTransform)
+
+} // namespace br
+
+#include "gui/drawdelaunay.moc"
diff --git a/openbr/plugins/gui/drawgridlines.cpp b/openbr/plugins/gui/drawgridlines.cpp
new file mode 100644
index 0000000..5f8129a
--- /dev/null
+++ b/openbr/plugins/gui/drawgridlines.cpp
@@ -0,0 +1,63 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * Copyright 2012 The MITRE Corporation                                      *
+ *                                                                           *
+ * Licensed under the Apache License, Version 2.0 (the "License");           *
+ * you may not use this file except in compliance with the License.          *
+ * You may obtain a copy of the License at                                   *
+ *                                                                           *
+ *     http://www.apache.org/licenses/LICENSE-2.0                            *
+ *                                                                           *
+ * Unless required by applicable law or agreed to in writing, software       *
+ * distributed under the License is distributed on an "AS IS" BASIS,         *
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  *
+ * See the License for the specific language governing permissions and       *
+ * limitations under the License.                                            *
+ * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+
+#include <opencv2/highgui/highgui.hpp>
+
+#include <openbr/plugins/openbr_internal.h>
+
+using namespace cv;
+
+namespace br
+{
+
+/*!
+ * \ingroup transforms
+ * \brief Draws a grid on the image
+ * \author Josh Klontz \cite jklontz
+ */
+class DrawGridLinesTransform : public UntrainableTransform
+{
+    Q_OBJECT
+    Q_PROPERTY(int rows READ get_rows WRITE set_rows RESET reset_rows STORED false)
+    Q_PROPERTY(int columns READ get_columns WRITE set_columns RESET reset_columns STORED false)
+    Q_PROPERTY(int r READ get_r WRITE set_r RESET reset_r STORED false)
+    Q_PROPERTY(int g READ get_g WRITE set_g RESET reset_g STORED false)
+    Q_PROPERTY(int b READ get_b WRITE set_b RESET reset_b STORED false)
+    BR_PROPERTY(int, rows, 0)
+    BR_PROPERTY(int, columns, 0)
+    BR_PROPERTY(int, r, 196)
+    BR_PROPERTY(int, g, 196)
+    BR_PROPERTY(int, b, 196)
+
+    void project(const Template &src, Template &dst) const
+    {
+        Mat m = src.m().clone();
+        float rowStep = 1.f * m.rows / (rows+1);
+        float columnStep = 1.f * m.cols / (columns+1);
+        int thickness = qMin(m.rows, m.cols) / 256;
+        for (float row = rowStep/2; row < m.rows; row += rowStep)
+            line(m, Point(0, row), Point(m.cols, row), Scalar(r, g, b), thickness, CV_AA);
+        for (float column = columnStep/2; column < m.cols; column += columnStep)
+            line(m, Point(column, 0), Point(column, m.rows), Scalar(r, g, b), thickness, CV_AA);
+        dst = m;
+    }
+};
+
+BR_REGISTER(Transform, DrawGridLinesTransform)
+
+} // namespace br
+
+#include "gui/drawgridlines.moc"
diff --git a/openbr/plugins/gui/drawopticalflow.cpp b/openbr/plugins/gui/drawopticalflow.cpp
new file mode 100644
index 0000000..fb271d8
--- /dev/null
+++ b/openbr/plugins/gui/drawopticalflow.cpp
@@ -0,0 +1,56 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * 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 Draw a line representing the direction and magnitude of optical flow at the specified points.
+ * \author Austin Blanton \cite imaus10
+ */
+class DrawOpticalFlow : public UntrainableTransform
+{
+    Q_OBJECT
+    Q_PROPERTY(QString original READ get_original WRITE set_original RESET reset_original STORED false)
+    BR_PROPERTY(QString, original, "original")
+
+    void project(const Template &src, Template &dst) const
+    {
+        const Scalar color(0,255,0);
+        Mat flow = src.m();
+        dst = src;
+        if (!dst.file.contains(original)) qFatal("The original img must be saved in the metadata with SaveMat.");
+        dst.m() = dst.file.get<Mat>(original);
+        dst.file.remove(original);
+        foreach (const Point2f &pt, OpenCVUtils::toPoints(dst.file.points())) {
+            Point2f dxy = flow.at<Point2f>(pt.y, pt.x);
+            Point2f newPt(pt.x+dxy.x, pt.y+dxy.y);
+            line(dst, pt, newPt, color);
+        }
+    }
+};
+
+BR_REGISTER(Transform, DrawOpticalFlow)
+
+} // namespace br
+
+#include "gui/drawopticalflow.moc"
diff --git a/openbr/plugins/gui/drawpropertiespoint.cpp b/openbr/plugins/gui/drawpropertiespoint.cpp
new file mode 100644
index 0000000..5234807
--- /dev/null
+++ b/openbr/plugins/gui/drawpropertiespoint.cpp
@@ -0,0 +1,86 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * 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 Draw the values of a list of properties at the specified point on the image
+ *
+ * The inPlace argument controls whether or not the image is cloned before it is drawn on.
+ *
+ * \author Charles Otto \cite caotto
+ */
+class DrawPropertiesPointTransform : public UntrainableTransform
+{
+    Q_OBJECT
+    Q_PROPERTY(QStringList propNames READ get_propNames WRITE set_propNames RESET reset_propNames STORED false)
+    Q_PROPERTY(QString pointName READ get_pointName WRITE set_pointName RESET reset_pointName STORED false)
+    Q_PROPERTY(bool inPlace READ get_inPlace WRITE set_inPlace RESET reset_inPlace STORED false)
+    BR_PROPERTY(QStringList, propNames, QStringList())
+    BR_PROPERTY(QString, pointName, "")
+    BR_PROPERTY(bool, inPlace, false)
+
+    void project(const Template &src, Template &dst) const
+    {
+        dst = src;
+        if (propNames.isEmpty() || pointName.isEmpty())
+            return;
+
+        dst.m() = inPlace ? src.m() : src.m().clone();
+
+        QVariant point = dst.file.value(pointName);
+
+        if (!point.canConvert(QVariant::PointF))
+            return;
+
+        QPointF targetPoint = point.toPointF();
+
+        Point2f cvPoint = OpenCVUtils::toPoint(targetPoint);
+
+
+        const Scalar textColor(255, 255, 0);
+
+        std::string outString = "";
+        foreach (const QString &propName, propNames)
+        {
+            QVariant prop = dst.file.value(propName);
+
+            if (!prop.canConvert(QVariant::String))
+                continue;
+            QString propString = prop.toString();
+            outString += propName.toStdString() + ": " + propString.toStdString() + " ";
+
+        }
+        if (outString.empty())
+            return;
+
+        putText(dst, outString, cvPoint, FONT_HERSHEY_SIMPLEX, 0.5, textColor, 1);
+    }
+
+};
+
+BR_REGISTER(Transform, DrawPropertiesPointTransform)
+
+} // namespace br
+
+#include "gui/drawpropertiespoint.moc"
diff --git a/openbr/plugins/gui/drawpropertypoint.cpp b/openbr/plugins/gui/drawpropertypoint.cpp
new file mode 100644
index 0000000..6027cb3
--- /dev/null
+++ b/openbr/plugins/gui/drawpropertypoint.cpp
@@ -0,0 +1,79 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * 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 Draw the value of the specified property at the specified point on the image
+ *
+ * The inPlace argument controls whether or not the image is cloned before it is drawn on.
+ *
+ * \author Charles Otto \cite caotto
+ */
+class DrawPropertyPointTransform : public UntrainableTransform
+{
+    Q_OBJECT
+    Q_PROPERTY(QString propName READ get_propName WRITE set_propName RESET reset_propName STORED false)
+    Q_PROPERTY(QString pointName READ get_pointName WRITE set_pointName RESET reset_pointName STORED false)
+    Q_PROPERTY(bool inPlace READ get_inPlace WRITE set_inPlace RESET reset_inPlace STORED false)
+    BR_PROPERTY(QString, propName, "")
+    BR_PROPERTY(QString, pointName, "")
+    BR_PROPERTY(bool, inPlace, false)
+
+
+    void project(const Template &src, Template &dst) const
+    {
+        dst = src;
+        if (propName.isEmpty() || pointName.isEmpty())
+            return;
+
+        dst.m() = inPlace ? src.m() : src.m().clone();
+
+        const Scalar textColor(255, 255, 0);
+
+        QVariant prop = dst.file.value(propName);
+
+
+        if (!prop.canConvert(QVariant::String))
+            return;
+        QString propString = prop.toString();
+
+        QVariant point = dst.file.value(pointName);
+
+        if (!point.canConvert(QVariant::PointF))
+            return;
+
+        QPointF targetPoint = point.toPointF();
+
+        Point2f cvPoint = OpenCVUtils::toPoint(targetPoint);
+
+        std::string text = propName.toStdString() + ": " + propString.toStdString();
+        putText(dst, text, cvPoint, FONT_HERSHEY_SIMPLEX, 0.5, textColor, 1);
+    }
+
+};
+BR_REGISTER(Transform, DrawPropertyPointTransform)
+
+} // namespace br
+
+#include "gui/drawpropertypoint.moc"
diff --git a/openbr/plugins/gui/drawsegmentation.cpp b/openbr/plugins/gui/drawsegmentation.cpp
new file mode 100644
index 0000000..3e84de8
--- /dev/null
+++ b/openbr/plugins/gui/drawsegmentation.cpp
@@ -0,0 +1,71 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * 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 std;
+using namespace cv;
+
+namespace br
+{
+
+/*!
+ * \ingroup transforms
+ * \brief Fill in the segmentations or draw a line between intersecting segments.
+ * \author Austin Blanton \cite imaus10
+ */
+class DrawSegmentation : public UntrainableTransform
+{
+    Q_OBJECT
+    Q_PROPERTY(bool fillSegment READ get_fillSegment WRITE set_fillSegment RESET reset_fillSegment STORED false)
+    BR_PROPERTY(bool, fillSegment, true)
+
+    void project(const Template &src, Template &dst) const
+    {
+        if (!src.file.contains("SegmentsMask") || !src.file.contains("NumSegments")) qFatal("Must supply a Contours object in the metadata to drawContours.");
+        Mat segments = src.file.get<Mat>("SegmentsMask");
+        int numSegments = src.file.get<int>("NumSegments");
+
+        dst.file = src.file;
+        Mat drawn = fillSegment ? Mat(segments.size(), CV_8UC3, Scalar::all(0)) : src.m();
+
+        for (int i=1; i<numSegments+1; i++) {
+            Mat mask = segments == i;
+            if (fillSegment) { // color the whole segment
+                // set to a random color - get ready for a craaaazy acid trip
+                int b = theRNG().uniform(0, 255);
+                int g = theRNG().uniform(0, 255);
+                int r = theRNG().uniform(0, 255);
+                drawn.setTo(Scalar(r,g,b), mask);
+            } else { // draw lines where there's a color change
+                vector<vector<Point> > contours;
+                Scalar color(0,255,0);
+                findContours(mask, contours, CV_RETR_LIST, CV_CHAIN_APPROX_NONE);
+                drawContours(drawn, contours, -1, color);
+            }
+        }
+
+        dst.m() = drawn;
+    }
+};
+
+BR_REGISTER(Transform, DrawSegmentation)
+
+} // namespace br
+
+#include "gui/drawsegmentation.moc"
diff --git a/openbr/plugins/gui.cpp b/openbr/plugins/gui/show.cpp
index 3aab218..f7b322e 100644
--- a/openbr/plugins/gui.cpp
+++ b/openbr/plugins/gui/show.cpp
@@ -1,3 +1,19 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * 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 <QApplication>
 #include <QLabel>
 #include <QElapsedTimer>
@@ -14,8 +30,9 @@
 
 #include <opencv2/imgproc/imgproc.hpp>
 #include <opencv2/imgproc/imgproc_c.h>
-#include "openbr_internal.h"
-#include "openbr/gui/utility.h"
+
+#include <openbr/plugins/openbr_internal.h>
+#include <openbr/gui/utility.h>
 
 using namespace cv;
 
@@ -928,6 +945,54 @@ public:
 
 BR_REGISTER(Transform, SurveyTransform)
 
+class FilterTransform : public ShowTransform
+{
+    Q_OBJECT
+
+    void projectUpdate(const TemplateList &src, TemplateList &dst)
+    {
+        if (Globals->parallelism > 1)
+            qFatal("FilterTransform cannot execute in parallel.");
+
+        if (src.empty())
+            return;
+
+        foreach (const Template &t, src) {
+            Template u(t.file);
+            foreach (const cv::Mat &m, t) {
+                qImageBuffer = toQImage(m);
+                displayBuffer->convertFromImage(qImageBuffer);
+
+                emit updateImage(displayBuffer->copy(displayBuffer->rect()));
+
+                // Blocking wait for a key-press
+                if (this->waitInput) {
+                    QString answer = p_window->waitForKeyPress();
+                    qDebug() << answer;
+                    if (answer == "y")
+                        u.append(m);
+                }
+            }
+            if (!u.empty())
+                dst.append(u);
+        }
+    }
+    PromptWindow *p_window;
+
+
+    void init()
+    {
+        if (!Globals->useGui)
+            return;
+
+        initActual<PromptWindow>();
+        p_window = (PromptWindow *) window;
+
+        emit changeTitle("Keep: y Discard: n");
+    }
+};
+
+BR_REGISTER(Transform, FilterTransform)
 
 /*!
  * \ingroup transforms
@@ -1041,8 +1106,9 @@ protected:
     QElapsedTimer timer;
     qint64 framesSeen;
 };
+
 BR_REGISTER(Transform, FPSCalc)
 
 } // namespace br
 
-#include "gui.moc"
+#include "gui/show.moc"
diff --git a/openbr/plugins/imgproc/abs.cpp b/openbr/plugins/imgproc/abs.cpp
new file mode 100644
index 0000000..24b85af
--- /dev/null
+++ b/openbr/plugins/imgproc/abs.cpp
@@ -0,0 +1,41 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * 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 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 = cv::abs(src);
+    }
+};
+
+BR_REGISTER(Transform, AbsTransform)
+
+} // namespace br
+
+#include "imgproc/abs.moc"
diff --git a/openbr/plugins/imgproc/absdiff.cpp b/openbr/plugins/imgproc/absdiff.cpp
new file mode 100644
index 0000000..b7dc23f
--- /dev/null
+++ b/openbr/plugins/imgproc/absdiff.cpp
@@ -0,0 +1,43 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * 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 Take the absolute difference of two matrices.
+ * \author Josh Klontz \cite jklontz
+ */
+class AbsDiffTransform : public UntrainableMetaTransform
+{
+    Q_OBJECT
+
+    void project(const Template &src, Template &dst) const
+    {
+        if (src.size() != 2) qFatal("Expected exactly two source images, got %d.", src.size());
+        dst.file = src.file;
+        cv::absdiff(src[0], src[1], dst);
+    }
+};
+
+BR_REGISTER(Transform, AbsDiffTransform)
+
+} // namespace br
+
+#include "imgproc/absdiff.moc"
diff --git a/openbr/plugins/imgproc/adaptivethreshold.cpp b/openbr/plugins/imgproc/adaptivethreshold.cpp
new file mode 100644
index 0000000..2087849
--- /dev/null
+++ b/openbr/plugins/imgproc/adaptivethreshold.cpp
@@ -0,0 +1,56 @@
+#include <opencv2/imgproc/imgproc.hpp>
+
+#include <openbr/plugins/openbr_internal.h>
+
+using namespace cv;
+
+namespace br
+{
+
+/*!
+ * \ingroup transforms
+ * \brief Wraps OpenCV's adaptive thresholding.
+ * \author Scott Klum \cite sklum
+ */
+class AdaptiveThresholdTransform : public UntrainableTransform
+{
+    Q_OBJECT
+
+    Q_ENUMS(Method)
+    Q_ENUMS(Type)
+    Q_PROPERTY(int maxValue READ get_maxValue WRITE set_maxValue RESET reset_maxValue STORED false)
+    Q_PROPERTY(Method method READ get_method WRITE set_method RESET reset_method STORED false)
+    Q_PROPERTY(Type type READ get_type WRITE set_type RESET reset_type STORED false)
+    Q_PROPERTY(int blockSize READ get_blockSize WRITE set_blockSize RESET reset_blockSize STORED false)
+    Q_PROPERTY(int C READ get_C WRITE set_C RESET reset_C STORED false)
+
+    public:
+    enum Method { Mean = ADAPTIVE_THRESH_MEAN_C,
+                  Gaussian = ADAPTIVE_THRESH_GAUSSIAN_C };
+
+    enum Type { Binary = THRESH_BINARY,
+                BinaryInv = THRESH_BINARY_INV };
+
+private:
+    BR_PROPERTY(int, maxValue, 255)
+    BR_PROPERTY(Method, method, Mean)
+    BR_PROPERTY(Type, type, Binary)
+    BR_PROPERTY(int, blockSize, 3)
+    BR_PROPERTY(int, C, 0)
+
+    void project(const Template &src, Template &dst) const
+    {
+        dst = src;
+
+        Mat mask;
+        adaptiveThreshold(src, mask, maxValue, method, type, blockSize, C);
+
+        dst.file.set("Mask",QVariant::fromValue(mask));
+    }
+};
+
+BR_REGISTER(Transform, AdaptiveThresholdTransform)
+
+} // namespace br
+
+#include "imgproc/adaptivethreshold.moc"
diff --git a/openbr/plugins/register.cpp b/openbr/plugins/imgproc/affine.cpp
index 110f363..0cf7213 100644
--- a/openbr/plugins/register.cpp
+++ b/openbr/plugins/imgproc/affine.cpp
@@ -15,9 +15,9 @@
  * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
 
 #include <opencv2/imgproc/imgproc.hpp>
-#include "openbr_internal.h"
 
-#include "openbr/core/opencvutils.h"
+#include <openbr/plugins/openbr_internal.h>
+#include <openbr/core/opencvutils.h>
 
 using namespace cv;
 
@@ -118,107 +118,9 @@ private:
         }
     }
 };
-BR_REGISTER(Transform, AffineTransform)
-
-/*!
- * \ingroup transforms
- * \brief Flips the image about an axis.
- * \author Josh Klontz \cite jklontz
- */
-class FlipTransform : public UntrainableTransform
-{
-    Q_OBJECT
-    Q_ENUMS(Axis)
-    Q_PROPERTY(Axis axis READ get_axis WRITE set_axis RESET reset_axis STORED false)
 
-public:
-    /*!< */
-    enum Axis { X = 0,
-                Y = 1,
-                Both = -1 };
-
-private:
-    BR_PROPERTY(Axis, axis, Y)
-
-    void project(const Template &src, Template &dst) const
-    {
-        flip(src, dst, axis);
-
-        QList<QPointF> flippedPoints;
-        foreach(const QPointF &point, src.file.points()) {
-            // Check for missing data using the QPointF(-1,-1) convention
-            if (point != QPointF(-1,-1)) {
-                if (axis == Y) {
-                    flippedPoints.append(QPointF(src.m().cols-point.x(),point.y()));
-                } else if (axis == X) {
-                    flippedPoints.append(QPointF(point.x(),src.m().rows-point.y()));
-                } else {
-                    flippedPoints.append(QPointF(src.m().cols-point.x(),src.m().rows-point.y()));
-                }
-            }
-        }
-
-        QList<QRectF> flippedRects;
-        foreach(const QRectF &rect, src.file.rects()) {
-            if (axis == Y) {
-                flippedRects.append(QRectF(src.m().cols-rect.right(),
-                                           rect.y(),
-                                           rect.width(),
-                                           rect.height()));
-            } else if (axis == X) {
-                flippedRects.append(QRectF(rect.x(),
-                                           src.m().rows-rect.bottom(),
-                                           rect.width(),
-                                           rect.height()));
-            } else {
-                flippedRects.append(QRectF(src.m().cols-rect.right(),
-                                           src.m().rows-rect.bottom(),
-                                           rect.width(),
-                                           rect.height()));
-            }
-        }
-
-        dst.file.setPoints(flippedPoints);
-        dst.file.setRects(flippedRects);
-    }
-};
-BR_REGISTER(Transform, FlipTransform)
-
-/*!
- * \ingroup transforms
- * \brief Randomly rotates an image in a specified range.
- * \author Scott Klum \cite sklum
- */
-class RandRotateTransform : public UntrainableTransform
-{
-    Q_OBJECT
-
-    Q_PROPERTY(QList<int> range READ get_range WRITE set_range RESET reset_range STORED false)
-    BR_PROPERTY(QList<int>, range, QList<int>() << -15 << 15)
-
-    void project(const Template &src, Template &dst) const {
-        int span = range.first() - range.last();
-        int angle = (rand() % span) + range.first();
-        Mat rotMatrix = getRotationMatrix2D(Point2f(src.m().rows/2,src.m().cols/2),angle,1.0);
-        warpAffine(src,dst,rotMatrix,Size(src.m().cols,src.m().rows));
-
-        QList<QPointF> points = src.file.points();
-        QList<QPointF> rotatedPoints;
-        for (int i=0; i<points.size(); i++) {
-            rotatedPoints.append(QPointF(points.at(i).x()*rotMatrix.at<double>(0,0)+
-                                         points.at(i).y()*rotMatrix.at<double>(0,1)+
-                                         rotMatrix.at<double>(0,2),
-                                         points.at(i).x()*rotMatrix.at<double>(1,0)+
-                                         points.at(i).y()*rotMatrix.at<double>(1,1)+
-                                         rotMatrix.at<double>(1,2)));
-        }
-
-        dst.file.setPoints(rotatedPoints);
-    }
-};
-
-BR_REGISTER(Transform, RandRotateTransform)
+BR_REGISTER(Transform, AffineTransform)
 
 } // namespace br
 
-#include "register.moc"
+#include "imgproc/affine.moc"
diff --git a/openbr/plugins/imgproc/and.cpp b/openbr/plugins/imgproc/and.cpp
new file mode 100644
index 0000000..afe0c34
--- /dev/null
+++ b/openbr/plugins/imgproc/and.cpp
@@ -0,0 +1,44 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * 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 Logical AND of two matrices.
+ * \author Josh Klontz \cite jklontz
+ */
+class AndTransform : public UntrainableMetaTransform
+{
+    Q_OBJECT
+
+    void project(const Template &src, Template &dst) const
+    {
+        dst.file = src.file;
+        dst.m() = src.first();
+        for (int i=1; i<src.size(); i++)
+            cv::bitwise_and(src[i], dst, dst);
+    }
+};
+
+BR_REGISTER(Transform, AndTransform)
+
+} // namespace br
+
+#include "imgproc/and.moc"
diff --git a/openbr/plugins/imgproc/applymask.cpp b/openbr/plugins/imgproc/applymask.cpp
new file mode 100644
index 0000000..065beef
--- /dev/null
+++ b/openbr/plugins/imgproc/applymask.cpp
@@ -0,0 +1,46 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * 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 transforms
+ * \brief Applies a mask from the metadata.
+ * \author Austin Blanton \cite imaus10
+ */
+class ApplyMaskTransform : public UntrainableTransform
+{
+    Q_OBJECT
+
+    void project(const Template &src, Template &dst) const
+    {
+        if (src.file.contains("Mask"))
+            src.m().copyTo(dst, src.file.get<Mat>("Mask"));
+        else
+            dst = src;
+    }
+};
+
+BR_REGISTER(Transform, ApplyMaskTransform)
+
+} // namespace br
+
+#include "imgproc/applymask.moc"
diff --git a/openbr/plugins/quantize2.cpp b/openbr/plugins/imgproc/bayesianquantization.cpp
index 8d05523..91a64a5 100644
--- a/openbr/plugins/quantize2.cpp
+++ b/openbr/plugins/imgproc/bayesianquantization.cpp
@@ -1,10 +1,25 @@
-#include <QFutureSynchronizer>
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * 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_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;
 
@@ -119,4 +134,4 @@ BR_REGISTER(Transform, BayesianQuantizationTransform)
 
 } // namespace br
 
-#include "quantize2.moc"
+#include "imgproc/bayesianquantization.moc"
diff --git a/openbr/plugins/imgproc/binarize.cpp b/openbr/plugins/imgproc/binarize.cpp
new file mode 100644
index 0000000..c2ef58c
--- /dev/null
+++ b/openbr/plugins/imgproc/binarize.cpp
@@ -0,0 +1,57 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * 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 transforms
+ * \brief Approximate floats as signed bit.
+ * \author Josh Klontz \cite jklontz
+ */
+class BinarizeTransform : public UntrainableTransform
+{
+    Q_OBJECT
+
+    void project(const Template &src, Template &dst) const
+    {
+        const Mat &m = src;
+        if ((m.cols % 8 != 0) || (m.type() != CV_32FC1))
+            qFatal("Expected CV_32FC1 matrix with a multiple of 8 columns.");
+        Mat n(m.rows, m.cols/8, CV_8UC1);
+        for (int i=0; i<m.rows; i++)
+            for (int j=0; j<m.cols-7; j+=8)
+                n.at<uchar>(i,j) = ((m.at<float>(i,j+0) > 0) << 0) +
+                                   ((m.at<float>(i,j+1) > 0) << 1) +
+                                   ((m.at<float>(i,j+2) > 0) << 2) +
+                                   ((m.at<float>(i,j+3) > 0) << 3) +
+                                   ((m.at<float>(i,j+4) > 0) << 4) +
+                                   ((m.at<float>(i,j+5) > 0) << 5) +
+                                   ((m.at<float>(i,j+6) > 0) << 6) +
+                                   ((m.at<float>(i,j+7) > 0) << 7);
+        dst = n;
+    }
+};
+
+BR_REGISTER(Transform, BinarizeTransform)
+
+} // namespace br
+
+#include "imgproc/binarize.moc"
diff --git a/openbr/plugins/imgproc/blend.cpp b/openbr/plugins/imgproc/blend.cpp
new file mode 100644
index 0000000..f1f7dc6
--- /dev/null
+++ b/openbr/plugins/imgproc/blend.cpp
@@ -0,0 +1,46 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * 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 transforms
+ * \brief Alpha-blend two matrices
+ * \author Josh Klontz \cite jklontz
+ */
+class BlendTransform : public UntrainableMetaTransform
+{
+    Q_OBJECT
+    Q_PROPERTY(float alpha READ get_alpha WRITE set_alpha RESET reset_alpha STORED false)
+    BR_PROPERTY(float, alpha, 0.5)
+
+    void project(const Template &src, Template &dst) const
+    {
+        if (src.size() != 2) qFatal("Expected two source matrices.");
+        addWeighted(src[0], alpha, src[1], 1-alpha, 0, dst);
+    }
+};
+
+BR_REGISTER(Transform, BlendTransform)
+
+} // namespace br
+
+#include "imgproc/blend.moc"
diff --git a/openbr/plugins/imgproc/blur.cpp b/openbr/plugins/imgproc/blur.cpp
new file mode 100644
index 0000000..e04f233
--- /dev/null
+++ b/openbr/plugins/imgproc/blur.cpp
@@ -0,0 +1,59 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * 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 transforms
+ * \brief Gaussian blur
+ * \author Josh Klontz \cite jklontz
+ */
+class BlurTransform : public UntrainableTransform
+{
+    Q_OBJECT
+    Q_PROPERTY(float sigma READ get_sigma WRITE set_sigma RESET reset_sigma STORED false)
+    Q_PROPERTY(bool ROI READ get_ROI WRITE set_ROI RESET reset_ROI STORED false)
+    BR_PROPERTY(float, sigma, 1)
+    BR_PROPERTY(bool, ROI, false)
+
+    void project(const Template &src, Template &dst) const
+    {
+        if (!ROI) GaussianBlur(src, dst, Size(0,0), sigma);
+        else {
+            dst.m() = src.m();
+            foreach (const QRectF &rect, src.file.rects()) {
+                Rect region(rect.x(), rect.y(), rect.width(), rect.height());
+                Mat input = dst.m();
+                Mat output = input.clone();
+                GaussianBlur(input(region), output(region), Size(0,0), sigma);
+                dst.m() = output;
+            }
+        }
+    }
+};
+
+BR_REGISTER(Transform, BlurTransform)
+
+} // namespace br
+
+#include "imgproc/blur.moc"
diff --git a/openbr/plugins/imgproc/byrow.cpp b/openbr/plugins/imgproc/byrow.cpp
new file mode 100644
index 0000000..e61a716
--- /dev/null
+++ b/openbr/plugins/imgproc/byrow.cpp
@@ -0,0 +1,42 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * 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 Turns each row into its own matrix.
+ * \author Josh Klontz \cite jklontz
+ */
+class ByRowTransform : public UntrainableTransform
+{
+    Q_OBJECT
+
+    void project(const Template &src, Template &dst) const
+    {
+        for (int i=0; i<src.m().rows; i++)
+            dst += src.m().row(i);
+    }
+};
+
+BR_REGISTER(Transform, ByRowTransform)
+
+} // namespace br
+
+#include "imgproc/byrow.moc"
diff --git a/openbr/plugins/edge.cpp b/openbr/plugins/imgproc/canny.cpp
index a17e5f5..fad139a 100644
--- a/openbr/plugins/edge.cpp
+++ b/openbr/plugins/imgproc/canny.cpp
@@ -1,7 +1,7 @@
-#include "openbr_internal.h"
-
 #include "opencv2/imgproc/imgproc.hpp"
 
+#include <openbr/plugins/openbr_internal.h>
+
 using namespace cv;
 
 namespace br
@@ -32,4 +32,4 @@ BR_REGISTER(Transform, CannyTransform)
 
 } // namespace br
 
-#include "edge.moc"
+#include "imgproc/canny.moc"
diff --git a/openbr/plugins/imgproc/cat.cpp b/openbr/plugins/imgproc/cat.cpp
new file mode 100644
index 0000000..597239e
--- /dev/null
+++ b/openbr/plugins/imgproc/cat.cpp
@@ -0,0 +1,63 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * 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 transforms
+ * \brief Concatenates all input matrices into a single matrix.
+ * \author Josh Klontz \cite jklontz
+ */
+class CatTransform : public UntrainableMetaTransform
+{
+    Q_OBJECT
+    Q_PROPERTY(int partitions READ get_partitions WRITE set_partitions RESET reset_partitions)
+    BR_PROPERTY(int, partitions, 1)
+
+    void project(const Template &src, Template &dst) const
+    {
+        dst.file = src.file;
+
+        if (src.size() % partitions != 0)
+            qFatal("%d partitions does not evenly divide %d matrices.", partitions, src.size());
+        QVector<int> sizes(partitions, 0);
+        for (int i=0; i<src.size(); i++)
+            sizes[i%partitions] += src[i].total();
+
+        if (!src.empty())
+            foreach (int size, sizes)
+                dst.append(Mat(1, size, src.m().type()));
+
+        QVector<int> offsets(partitions, 0);
+        for (int i=0; i<src.size(); i++) {
+            size_t size = src[i].total() * src[i].elemSize();
+            int j = i % partitions;
+            memcpy(&dst[j].data[offsets[j]], src[i].ptr(), size);
+            offsets[j] += size;
+        }
+    }
+};
+
+BR_REGISTER(Transform, CatTransform)
+
+} // namespace br
+
+#include "imgproc/cat.moc"
diff --git a/openbr/plugins/imgproc/catcols.cpp b/openbr/plugins/imgproc/catcols.cpp
new file mode 100644
index 0000000..27535ce
--- /dev/null
+++ b/openbr/plugins/imgproc/catcols.cpp
@@ -0,0 +1,52 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * 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 transforms
+ * \brief Concatenates all input matrices by column into a single matrix.
+ * Use after a fork to concatenate two feature matrices by column.
+ * \author Austin Blanton \cite imaus10
+ */
+class CatColsTransform : public UntrainableMetaTransform
+{
+    Q_OBJECT
+
+    void project(const Template &src, Template &dst) const
+    {
+        int half = src.size()/2;
+        for (int i=0; i<half; i++) {
+            Mat first = src[i];
+            Mat second = src[half+i];
+            Mat both;
+            hconcat(first, second, both);
+            dst.append(both);
+        }
+        dst.file = src.file;
+    }
+};
+
+BR_REGISTER(Transform, CatColsTransform)
+
+} // namespace br
+
+#include "imgproc/catcols.moc"
diff --git a/openbr/plugins/imgproc/catrows.cpp b/openbr/plugins/imgproc/catrows.cpp
new file mode 100644
index 0000000..d0f2770
--- /dev/null
+++ b/openbr/plugins/imgproc/catrows.cpp
@@ -0,0 +1,43 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * 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 Concatenates all input matrices by row into a single matrix.
+ * All matricies must have the same column counts.
+ * \author Josh Klontz \cite jklontz
+ */
+class CatRowsTransform : public UntrainableMetaTransform
+{
+    Q_OBJECT
+
+    void project(const Template &src, Template &dst) const
+    {
+        dst = Template(src.file, OpenCVUtils::toMatByRow(src));
+    }
+};
+
+BR_REGISTER(Transform, CatRowsTransform)
+
+} // namespace br
+
+#include "imgproc/catrows.moc"
diff --git a/openbr/plugins/normalize.cpp b/openbr/plugins/imgproc/center.cpp
index 8eb40df..b7edbb8 100644
--- a/openbr/plugins/normalize.cpp
+++ b/openbr/plugins/imgproc/center.cpp
@@ -14,16 +14,11 @@
  * limitations under the License.                                            *
  * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
 
-#include <QFutureSynchronizer>
-#include <QtConcurrentRun>
-#include <opencv2/imgproc/imgproc.hpp>
-#include <opencv2/highgui/highgui.hpp>
-#include <Eigen/Core>
-#include "openbr_internal.h"
+#include <QtConcurrent>
 
-#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>
 
 using namespace cv;
 
@@ -32,86 +27,6 @@ namespace br
 
 /*!
  * \ingroup transforms
- * \brief Histogram equalization
- * \author Josh Klontz \cite jklontz
- */
-class EqualizeHistTransform : public UntrainableTransform
-{
-    Q_OBJECT
-
-    void project(const Template &src, Template &dst) const
-    {
-        equalizeHist(src, dst);
-    }
-};
-
-BR_REGISTER(Transform, EqualizeHistTransform)
-
-/*!
- * \ingroup transforms
- * \brief Normalize matrix to unit length
- * \author Josh Klontz \cite jklontz
- */
-class NormalizeTransform : public UntrainableTransform
-{
-    Q_OBJECT
-    Q_ENUMS(NormType)
-    Q_PROPERTY(NormType normType READ get_normType WRITE set_normType RESET reset_normType STORED false)
-
-    Q_PROPERTY(bool ByRow READ get_ByRow WRITE set_ByRow RESET reset_ByRow STORED false)
-    BR_PROPERTY(bool, ByRow, false)
-    Q_PROPERTY(int alpha READ get_alpha WRITE set_alpha RESET reset_alpha STORED false)
-    BR_PROPERTY(int, alpha, 1)
-    Q_PROPERTY(int beta READ get_beta WRITE set_beta RESET reset_beta STORED false)
-    BR_PROPERTY(int, beta, 0)
-    Q_PROPERTY(bool squareRoot READ get_squareRoot WRITE set_squareRoot RESET reset_squareRoot STORED false)
-    BR_PROPERTY(bool, squareRoot, false)
-
-public:
-    /*!< */
-    enum NormType { Inf = NORM_INF,
-                    L1 = NORM_L1,
-                    L2 = NORM_L2,
-                    Range = NORM_MINMAX };
-
-private:
-    BR_PROPERTY(NormType, normType, L2)
-
-    static void signedSquareRoot(Mat &m)
-    {
-        for (int i=0; i<m.rows; i++)
-            for (int j=0; j<m.cols; j++) {
-                float &val = m.at<float>(i, j);
-                val = sqrtf(fabsf(val)) * (val >= 0 ? 1 : -1);
-            }
-    }
-
-    void project(const Template &src, Template &dst) const
-    {
-        if (!ByRow) {
-            normalize(src, dst, alpha, beta, normType, CV_32F);
-            if (squareRoot)
-                signedSquareRoot(dst);
-        }
-
-        else {
-            dst = src;
-            for (int i=0; i<dst.m().rows; i++) {
-                Mat temp;
-                cv::normalize(dst.m().row(i), temp, alpha, beta, normType);
-                if (squareRoot)
-                    signedSquareRoot(temp);
-                temp.copyTo(dst.m().row(i));
-            }
-        }
-
-    }
-};
-
-BR_REGISTER(Transform, NormalizeTransform)
-
-/*!
- * \ingroup transforms
  * \brief Normalize each dimension based on training data.
  * \author Josh Klontz \cite jklontz
  */
@@ -248,69 +163,6 @@ private:
 
 BR_REGISTER(Transform, CenterTransform)
 
-/*!
- * \ingroup transforms
- * \brief Remove the row-wise training set average.
- * \author Josh Klontz \cite jklontz
- */
-class RowWiseMeanCenterTransform : public Transform
-{
-    Q_OBJECT
-    Mat mean;
-
-    void train(const TemplateList &data)
-    {
-        Mat m = OpenCVUtils::toMatByRow(data.data());
-        mean = Mat(1, m.cols, m.type());
-        for (int i=0; i<m.cols; i++)
-            mean.col(i) = cv::mean(m.col(i));
-    }
-
-    void project(const Template &src, Template &dst) const
-    {
-        Mat m = src.m().clone();
-        for (int i=0; i<m.rows; i++)
-            m.row(i) -= mean;
-        dst = m;
-    }
-
-    void store(QDataStream &stream) const
-    {
-        stream << mean;
-    }
-
-    void load(QDataStream &stream)
-    {
-        stream >> mean;
-    }
-};
-
-BR_REGISTER(Transform, RowWiseMeanCenterTransform)
-
-/*!
- * \ingroup transforms
- * \brief dst=sqrt(norm_L1(src)) proposed as RootSIFT in \cite Arandjelovic12
- * \author Josh Klontz \cite jklontz
- */
-class RootNormTransform : public UntrainableTransform
-{
-    Q_OBJECT
-
-    void project(const Template &src, Template &dst) const
-    {
-        const Mat &m = src;
-        dst.m() = Mat(m.rows, m.cols, m.type());
-        for (int i=0; i<m.rows; i++) {
-            Mat temp;
-            cv::normalize(m.row(i), temp, 1, 0, NORM_L1);
-            cv::sqrt(temp, temp);
-            temp.copyTo(dst.m().row(i));
-        }
-    }
-};
-
-BR_REGISTER(Transform, RootNormTransform)
-
 } // namespace br
 
-#include "normalize.moc"
+#include "imgproc/center.moc"
diff --git a/openbr/plugins/imgproc/contrasteq.cpp b/openbr/plugins/imgproc/contrasteq.cpp
new file mode 100644
index 0000000..f595972
--- /dev/null
+++ b/openbr/plugins/imgproc/contrasteq.cpp
@@ -0,0 +1,70 @@
+#include <openbr/plugins/openbr_internal.h>
+#include <openbr/core/tanh_sse.h>
+
+using namespace cv;
+
+namespace br
+{
+
+/*!
+ * \ingroup transforms
+ * \brief Xiaoyang Tan; Triggs, B.;
+ * "Enhanced Local Texture Feature Sets for Face Recognition Under Difficult Lighting Conditions,"
+ * Image Processing, IEEE Transactions on , vol.19, no.6, pp.1635-1650, June 2010
+ * \author Josh Klontz \cite jklontz
+ */
+class ContrastEqTransform : public UntrainableTransform
+{
+    Q_OBJECT
+    Q_PROPERTY(float a READ get_a WRITE set_a RESET reset_a STORED false)
+    Q_PROPERTY(float t READ get_t WRITE set_t RESET reset_t STORED false)
+    BR_PROPERTY(float, a, 1)
+    BR_PROPERTY(float, t, 0.1)
+
+    void project(const Template &src, Template &dst) const
+    {
+        if (src.m().channels() != 1) qFatal("Expected single channel source matrix.");
+
+        // Stage 1
+        Mat stage1;
+        {
+            Mat abs_dst;
+            absdiff(src, Scalar(0), abs_dst);
+            Mat pow_dst;
+            pow(abs_dst, a, pow_dst);
+            float denominator = pow((float)mean(pow_dst)[0], 1.f/a);
+            src.m().convertTo(stage1, CV_32F, 1/denominator);
+        }
+
+        // Stage 2
+        Mat stage2;
+        {
+            Mat abs_dst;
+            absdiff(stage1, Scalar(0), abs_dst);
+            Mat min_dst;
+            min(abs_dst, t, min_dst);
+            Mat pow_dst;
+            pow(min_dst, a, pow_dst);
+            float denominator = pow((float)mean(pow_dst)[0], 1.f/a);
+            stage1.convertTo(stage2, CV_32F, 1/denominator);
+        }
+
+        // Hyperbolic tangent
+        const int nRows = src.m().rows;
+        const int nCols = src.m().cols;
+        const float* p = (const float*)stage2.ptr();
+        Mat m(nRows, nCols, CV_32FC1);
+        for (int i=0; i<nRows; i++)
+            for (int j=0; j<nCols; j++)
+                m.at<float>(i, j) = fast_tanh(p[i*nCols+j]);
+                // TODO: m.at<float>(i, j) = t * fast_tanh(p[i*nCols+j] / t);
+
+        dst = m;
+    }
+};
+
+BR_REGISTER(Transform, ContrastEqTransform)
+
+} // namespace br
+
+#include "imgproc/contrasteq.moc"
diff --git a/openbr/plugins/imgproc/crop.cpp b/openbr/plugins/imgproc/crop.cpp
new file mode 100644
index 0000000..1bbeb3c
--- /dev/null
+++ b/openbr/plugins/imgproc/crop.cpp
@@ -0,0 +1,51 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * 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 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)
+
+} // namespace br
+
+#include "imgproc/crop.moc"
diff --git a/openbr/plugins/imgproc/cropblack.cpp b/openbr/plugins/imgproc/cropblack.cpp
new file mode 100644
index 0000000..03b9180
--- /dev/null
+++ b/openbr/plugins/imgproc/cropblack.cpp
@@ -0,0 +1,71 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * 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 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)
+
+} // namespace br
+
+#include "imgproc/cropblack.moc"
diff --git a/openbr/plugins/imgproc/cropfrommask.cpp b/openbr/plugins/imgproc/cropfrommask.cpp
new file mode 100644
index 0000000..1682d3b
--- /dev/null
+++ b/openbr/plugins/imgproc/cropfrommask.cpp
@@ -0,0 +1,71 @@
+#include <openbr/plugins/openbr_internal.h>
+
+using namespace cv;
+
+namespace br
+{
+
+/*!
+ * \ingroup transforms
+ * \brief Crops image based on mask metadata
+ * \author Brendan Klare \cite bklare
+ */
+class CropFromMaskTransform : public UntrainableTransform
+{
+    Q_OBJECT
+    Q_PROPERTY(bool fixedAspectRatio READ get_fixedAspectRatio WRITE set_fixedAspectRatio RESET reset_fixedAspectRatio STORED false)
+    BR_PROPERTY(bool, fixedAspectRatio, true)
+
+private:
+
+    void project(const Template &src, Template &dst) const
+    {
+        dst = src;
+
+        Mat mask = dst.file.get<Mat>("Mask");
+
+        int w = mask.rows;
+        int h = mask.cols;
+        int left = w;
+        int right = 0;
+        int top = h;
+        int bottom = 0;
+        for (int i = 0 ; i < w; i++) {
+            for (int j = 0 ; j < h; j++) {
+                if (mask.at<unsigned char>(i,j)) {
+                    if (i < left)
+                        left = i;
+                    if (i > right)
+                        right = i;
+                    if (j < top)
+                        top = j;
+                    if (j > bottom)
+                        bottom = j;
+                }
+            }
+        }
+
+        if (fixedAspectRatio) {
+            h = bottom - top + 1;
+            w = right - left + 1;
+            if (h > w) {
+                int h2 = (h - w) / 2;
+                right += h2;
+                left -= h2;
+            } else {
+                int w2 = (w - h) / 2;
+                bottom += w2;
+                top -= w2;
+            }
+        }
+
+        dst.m() = Mat(src.m(), Rect(top, left, bottom - top + 1, right - left + 1));
+
+    }
+};
+
+BR_REGISTER(Transform, CropFromMaskTransform)
+
+} // namespace br
+
+#include "imgproc/cropfrommask.moc"
diff --git a/openbr/plugins/imgproc/cropsquare.cpp b/openbr/plugins/imgproc/cropsquare.cpp
new file mode 100644
index 0000000..2df04e9
--- /dev/null
+++ b/openbr/plugins/imgproc/cropsquare.cpp
@@ -0,0 +1,45 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * 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 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 "imgproc/cropsquare.moc"
diff --git a/openbr/plugins/hash.cpp b/openbr/plugins/imgproc/cryptographichash.cpp
index df2a548..a799c75 100644
--- a/openbr/plugins/hash.cpp
+++ b/openbr/plugins/imgproc/cryptographichash.cpp
@@ -15,10 +15,8 @@
  * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
 
 #include <QCryptographicHash>
-#include "openbr_internal.h"
-#include "openbr/core/qtutils.h"
 
-using namespace cv;
+#include <openbr/plugins/openbr_internal.h>
 
 namespace br
 {
@@ -56,40 +54,6 @@ private:
 
 BR_REGISTER(Transform, CryptographicHashTransform)
 
-/*!
- * \ingroup transforms
- * \brief Kernel hash
- * \author Josh Klontz \cite jklontz
- */
-class KernelHashTransform : public UntrainableTransform
-{
-    Q_OBJECT
-    Q_PROPERTY(uchar dimsIn READ get_dimsIn WRITE set_dimsIn RESET reset_dimsIn STORED false)
-    Q_PROPERTY(uchar dimsOut READ get_dimsOut WRITE set_dimsOut RESET reset_dimsOut STORED false)
-    BR_PROPERTY(uchar, dimsIn, 8)
-    BR_PROPERTY(uchar, dimsOut, 7)
-
-    void project(const Template &src, Template &dst) const
-    {
-        if (src.m().type() != CV_8UC1)
-            qFatal("Expected 8UC1 input.");
-
-        dst = Mat::zeros(src.m().rows, src.m().cols, CV_8UC1);
-        const uchar *srcData = src.m().data;
-        uchar *dstData = dst.m().data;
-        const int step = src.m().cols;
-        for (int i=0; i<src.m().rows-1; i++)
-            for (int j=0; j<src.m().cols-1; j++) {
-                dstData[i*step+j] = (uint(pow(float(dimsIn),1.f))*srcData[i    *step+j]
-                                   + uint(pow(float(dimsIn),2.f))*srcData[(i+1)*step+j]
-                                   + uint(pow(float(dimsIn),0.f))*srcData[i    *step+(j+1)]
-                                   /*+ uint(pow(float(dimsIn),0.f))*srcData[(i+1)*step+(j+1)]*/) % dimsOut;
-            }
-    }
-};
-
-BR_REGISTER(Transform, KernelHashTransform)
-
 } // namespace br
 
-#include "hash.moc"
+#include "imgproc/cryptographichash.moc"
diff --git a/openbr/plugins/imgproc/csdn.cpp b/openbr/plugins/imgproc/csdn.cpp
new file mode 100644
index 0000000..724ad98
--- /dev/null
+++ b/openbr/plugins/imgproc/csdn.cpp
@@ -0,0 +1,74 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * 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 std;
+using namespace cv;
+
+namespace br
+{
+
+/*!
+ * \ingroup transforms
+ * \brief Meyers, E.; Wolf, L.
+ * “Using biologically inspired features for face processing,”
+ * Int. Journal of Computer Vision, vol. 76, no. 1, pp 93–104, 2008.
+ * \author Scott Klum \cite sklum
+ */
+
+class CSDNTransform : public UntrainableTransform
+{
+    Q_OBJECT
+
+    Q_PROPERTY(float s READ get_s WRITE set_s RESET reset_s STORED false)
+    BR_PROPERTY(int, s, 16)
+
+    void project(const Template &src, Template &dst) const
+    {
+        if (src.m().channels() != 1) qFatal("Expected single channel source matrix.");
+
+        const int nRows = src.m().rows;
+        const int nCols = src.m().cols;
+
+        Mat m;
+        src.m().convertTo(m, CV_32FC1);
+
+        const int surround = s/2;
+
+        for ( int i = 0; i < nRows; i++ ) {
+            for ( int j = 0; j < nCols; j++ ) {
+                int width = min( j+surround, nCols ) - max( 0, j-surround );
+                int height = min( i+surround, nRows ) - max( 0, i-surround );
+
+                Rect_<int> ROI(max(0, j-surround), max(0, i-surround), width, height);
+
+                Scalar_<float> avg = mean(m(ROI));
+
+                m.at<float>(i,j) = m.at<float>(i,j) - avg[0];
+            }
+        }
+
+        dst = m;
+
+    }
+};
+
+BR_REGISTER(Transform, CSDNTransform)
+
+} // namespace br
+
+#include "imgproc/csdn.moc"
diff --git a/openbr/plugins/imgproc/custom_sift.cpp b/openbr/plugins/imgproc/custom_sift.cpp
new file mode 100644
index 0000000..b508120
--- /dev/null
+++ b/openbr/plugins/imgproc/custom_sift.cpp
@@ -0,0 +1,466 @@
+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                          License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2000-2008, Intel Corporation, all rights reserved.
+// Copyright (C) 2009, Willow Garage Inc., all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of the copyright holders may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// or tort (including negligence or otherwise) arising in any way out of
+// the use of this software, even if advised of the possibility of such damage.
+//
+//M*/
+
+/**********************************************************************************************\
+ Implementation of SIFT is based on the code from http://blogs.oregonstate.edu/hess/code/sift/
+ Below is the original copyright.
+
+//    Copyright (c) 2006-2010, Rob Hess <hess@eecs.oregonstate.edu>
+//    All rights reserved.
+
+//    The following patent has been issued for methods embodied in this
+//    software: "Method and apparatus for identifying scale invariant features
+//    in an image and use of same for locating an object in an image," David
+//    G. Lowe, US Patent 6,711,293 (March 23, 2004). Provisional application
+//    filed March 8, 1999. Asignee: The University of British Columbia. For
+//    further details, contact David Lowe (lowe@cs.ubc.ca) or the
+//    University-Industry Liaison Office of the University of British
+//    Columbia.
+
+//    Note that restrictions imposed by this patent (and possibly others)
+//    exist independently of and may be in conflict with the freedoms granted
+//    in this license, which refers to copyright of the program, not patents
+//    for any methods that it implements.  Both copyright and patent law must
+//    be obeyed to legally use and redistribute this program and it is not the
+//    purpose of this license to induce you to infringe any patents or other
+//    property right claims or to contest validity of any such claims.  If you
+//    redistribute or use the program, then this license merely protects you
+//    from committing copyright infringement.  It does not protect you from
+//    committing patent infringement.  So, before you do anything with this
+//    program, make sure that you have permission to do so not merely in terms
+//    of copyright, but also in terms of patent law.
+
+//    Please note that this license is not to be understood as a guarantee
+//    either.  If you use the program according to this license, but in
+//    conflict with patent law, it does not mean that the licensor will refund
+//    you for any losses that you incur if you are sued for your patent
+//    infringement.
+
+//    Redistribution and use in source and binary forms, with or without
+//    modification, are permitted provided that the following conditions are
+//    met:
+//        * Redistributions of source code must retain the above copyright and
+//          patent notices, this list of conditions and the following
+//          disclaimer.
+//        * Redistributions in binary form must reproduce the above copyright
+//          notice, this list of conditions and the following disclaimer in
+//          the documentation and/or other materials provided with the
+//          distribution.
+//        * Neither the name of Oregon State University nor the names of its
+//          contributors may be used to endorse or promote products derived
+//          from this software without specific prior written permission.
+
+//    THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
+//    IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
+//    TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
+//    PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+//    HOLDER BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+//    EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+//    PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+//    PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+//    LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+//    NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+//    SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+\**********************************************************************************************/
+
+#include <iostream>
+#include <stdarg.h>
+#include <opencv2/imgproc/imgproc.hpp>
+#include <opencv2/nonfree/features2d.hpp>
+
+using namespace cv;
+
+/******************************* Defs and macros *****************************/
+
+// determines the size of a single descriptor orientation histogram
+static const float SIFT_DESCR_SCL_FCTR = 3.f;
+
+// threshold on magnitude of elements of descriptor vector
+static const float SIFT_DESCR_MAG_THR = 0.2f;
+
+// factor used to convert floating-point descriptor to unsigned char
+static const float SIFT_INT_DESCR_FCTR = 512.f;
+
+// intermediate type used for DoG pyramids
+typedef short sift_wt;
+static const int SIFT_FIXPT_SCALE = 48;
+
+static inline void unpackOctave(const KeyPoint &kpt, int &octave, int &layer, float &scale)
+{
+    octave = kpt.octave & 255;
+    layer = (kpt.octave >> 8) & 255;
+    octave = octave < 128 ? octave : (-128 | octave);
+    scale = octave >= 0 ? 1.f/(1 << octave) : (float)(1 << -octave);
+}
+
+static Mat createInitialImage( const Mat& img, bool doubleImageSize, float sigma, float initSigma )
+{
+    Mat gray, gray_fpt;
+    if( img.channels() == 3 || img.channels() == 4 )
+        cvtColor(img, gray, COLOR_BGR2GRAY);
+    else
+        img.copyTo(gray);
+    gray.convertTo(gray_fpt, DataType<sift_wt>::type, SIFT_FIXPT_SCALE, 0);
+
+    float sig_diff;
+
+    if( doubleImageSize )
+    {
+        sig_diff = sqrtf( std::max(sigma * sigma - initSigma * initSigma * 4, 0.01f) );
+        Mat dbl;
+        resize(gray_fpt, dbl, Size(gray.cols*2, gray.rows*2), 0, 0, INTER_LINEAR);
+        GaussianBlur(dbl, dbl, Size(), sig_diff, sig_diff);
+        return dbl;
+    }
+    else
+    {
+        sig_diff = sqrtf( std::max(sigma * sigma - initSigma * initSigma, 0.01f) );
+        GaussianBlur(gray_fpt, gray_fpt, Size(), sig_diff, sig_diff);
+        return gray_fpt;
+    }
+}
+
+
+static void buildGaussianPyramid( const Mat& base, vector<Mat>& pyr, int nOctaves, int nOctaveLayers, double sigma )
+{
+    vector<double> sig(nOctaveLayers + 3);
+    pyr.resize(nOctaves*(nOctaveLayers + 3));
+
+    // precompute Gaussian sigmas using the following formula:
+    //  \sigma_{total}^2 = \sigma_{i}^2 + \sigma_{i-1}^2
+    sig[0] = sigma;
+    double k = pow( 2., 1. / nOctaveLayers );
+    for( int i = 1; i < nOctaveLayers + 3; i++ )
+    {
+        double sig_prev = pow(k, (double)(i-1))*sigma;
+        double sig_total = sig_prev*k;
+        sig[i] = std::sqrt(sig_total*sig_total - sig_prev*sig_prev);
+    }
+
+    for( int o = 0; o < nOctaves; o++ )
+    {
+        for( int i = 0; i < nOctaveLayers + 3; i++ )
+        {
+            Mat& dst = pyr[o*(nOctaveLayers + 3) + i];
+            if( o == 0  &&  i == 0 )
+                dst = base;
+            // base of new octave is halved image from end of previous octave
+            else if( i == 0 )
+            {
+                const Mat& src = pyr[(o-1)*(nOctaveLayers + 3) + nOctaveLayers];
+                resize(src, dst, Size(src.cols/2, src.rows/2),
+                       0, 0, INTER_NEAREST);
+            }
+            else
+            {
+                const Mat& src = pyr[o*(nOctaveLayers + 3) + i-1];
+                GaussianBlur(src, dst, Size(), sig[i], sig[i]);
+            }
+        }
+    }
+}
+
+
+static void buildDoGPyramid( const vector<Mat>& gpyr, vector<Mat>& dogpyr, int nOctaveLayers )
+{
+    int nOctaves = (int)gpyr.size()/(nOctaveLayers + 3);
+    dogpyr.resize( nOctaves*(nOctaveLayers + 2) );
+
+    for( int o = 0; o < nOctaves; o++ )
+    {
+        for( int i = 0; i < nOctaveLayers + 2; i++ )
+        {
+            const Mat& src1 = gpyr[o*(nOctaveLayers + 3) + i];
+            const Mat& src2 = gpyr[o*(nOctaveLayers + 3) + i + 1];
+            Mat& dst = dogpyr[o*(nOctaveLayers + 2) + i];
+            subtract(src2, src1, dst, noArray(), DataType<sift_wt>::type);
+        }
+    }
+}
+
+static void calcSIFTDescriptor( const Mat& img, Point2f ptf, float ori, float scl,
+                               int d, int n, float* dst )
+{
+    Point pt(cvRound(ptf.x), cvRound(ptf.y));
+    float cos_t = cosf(ori*(float)(CV_PI/180));
+    float sin_t = sinf(ori*(float)(CV_PI/180));
+    float bins_per_rad = n / 360.f;
+    float exp_scale = -1.f/(d * d * 0.5f);
+    float hist_width = SIFT_DESCR_SCL_FCTR * scl;
+    int radius = cvRound(hist_width * 1.4142135623730951f * (d + 1) * 0.5f);
+    // Clip the radius to the diagonal of the image to avoid autobuffer too large exception
+    radius = std::min(radius, (int) sqrt((double) img.cols*img.cols + img.rows*img.rows));
+    cos_t /= hist_width;
+    sin_t /= hist_width;
+
+    int i, j, k, len = (radius*2+1)*(radius*2+1), histlen = (d+2)*(d+2)*(n+2);
+    int rows = img.rows, cols = img.cols;
+
+    AutoBuffer<float> buf(len*6 + histlen);
+    float *X = buf, *Y = X + len, *Mag = Y, *Ori = Mag + len, *W = Ori + len;
+    float *RBin = W + len, *CBin = RBin + len, *hist = CBin + len;
+
+    for( i = 0; i < d+2; i++ )
+    {
+        for( j = 0; j < d+2; j++ )
+            for( k = 0; k < n+2; k++ )
+                hist[(i*(d+2) + j)*(n+2) + k] = 0.;
+    }
+
+    for( i = -radius, k = 0; i <= radius; i++ )
+        for( j = -radius; j <= radius; j++ )
+        {
+            // Calculate sample's histogram array coords rotated relative to ori.
+            // Subtract 0.5 so samples that fall e.g. in the center of row 1 (i.e.
+            // r_rot = 1.5) have full weight placed in row 1 after interpolation.
+            float c_rot = j * cos_t - i * sin_t;
+            float r_rot = j * sin_t + i * cos_t;
+            float rbin = r_rot + d/2 - 0.5f;
+            float cbin = c_rot + d/2 - 0.5f;
+            int r = pt.y + i, c = pt.x + j;
+
+            if( rbin > -1 && rbin < d && cbin > -1 && cbin < d &&
+                r > 0 && r < rows - 1 && c > 0 && c < cols - 1 )
+            {
+                float dx = (float)(img.at<sift_wt>(r, c+1) - img.at<sift_wt>(r, c-1));
+                float dy = (float)(img.at<sift_wt>(r-1, c) - img.at<sift_wt>(r+1, c));
+                X[k] = dx; Y[k] = dy; RBin[k] = rbin; CBin[k] = cbin;
+                W[k] = (c_rot * c_rot + r_rot * r_rot)*exp_scale;
+                k++;
+            }
+        }
+
+    len = k;
+    fastAtan2(Y, X, Ori, len, true);
+    magnitude(X, Y, Mag, len);
+    exp(W, W, len);
+
+    for( k = 0; k < len; k++ )
+    {
+        float rbin = RBin[k], cbin = CBin[k];
+        float obin = (Ori[k] - ori)*bins_per_rad;
+        float mag = Mag[k]*W[k];
+
+        int r0 = cvFloor( rbin );
+        int c0 = cvFloor( cbin );
+        int o0 = cvFloor( obin );
+        rbin -= r0;
+        cbin -= c0;
+        obin -= o0;
+
+        if( o0 < 0 )
+            o0 += n;
+        if( o0 >= n )
+            o0 -= n;
+
+        // histogram update using tri-linear interpolation
+        float v_r1 = mag*rbin, v_r0 = mag - v_r1;
+        float v_rc11 = v_r1*cbin, v_rc10 = v_r1 - v_rc11;
+        float v_rc01 = v_r0*cbin, v_rc00 = v_r0 - v_rc01;
+        float v_rco111 = v_rc11*obin, v_rco110 = v_rc11 - v_rco111;
+        float v_rco101 = v_rc10*obin, v_rco100 = v_rc10 - v_rco101;
+        float v_rco011 = v_rc01*obin, v_rco010 = v_rc01 - v_rco011;
+        float v_rco001 = v_rc00*obin, v_rco000 = v_rc00 - v_rco001;
+
+        int idx = ((r0+1)*(d+2) + c0+1)*(n+2) + o0;
+        hist[idx] += v_rco000;
+        hist[idx+1] += v_rco001;
+        hist[idx+(n+2)] += v_rco010;
+        hist[idx+(n+3)] += v_rco011;
+        hist[idx+(d+2)*(n+2)] += v_rco100;
+        hist[idx+(d+2)*(n+2)+1] += v_rco101;
+        hist[idx+(d+3)*(n+2)] += v_rco110;
+        hist[idx+(d+3)*(n+2)+1] += v_rco111;
+    }
+
+    // finalize histogram, since the orientation histograms are circular
+    for( i = 0; i < d; i++ )
+        for( j = 0; j < d; j++ )
+        {
+            int idx = ((i+1)*(d+2) + (j+1))*(n+2);
+            hist[idx] += hist[idx+n];
+            hist[idx+1] += hist[idx+n+1];
+            for( k = 0; k < n; k++ )
+                dst[(i*d + j)*n + k] = hist[idx+k];
+        }
+    // copy histogram to the descriptor,
+    // apply hysteresis thresholding
+    // and scale the result, so that it can be easily converted
+    // to byte array
+    float nrm2 = 0;
+    len = d*d*n;
+    for( k = 0; k < len; k++ )
+        nrm2 += dst[k]*dst[k];
+    float thr = std::sqrt(nrm2)*SIFT_DESCR_MAG_THR;
+    for( i = 0, nrm2 = 0; i < k; i++ )
+    {
+        float val = std::min(dst[i], thr);
+        dst[i] = val;
+        nrm2 += val*val;
+    }
+    nrm2 = SIFT_INT_DESCR_FCTR/std::max(std::sqrt(nrm2), FLT_EPSILON);
+
+#if 1
+    for( k = 0; k < len; k++ )
+    {
+        dst[k] = saturate_cast<uchar>(dst[k]*nrm2);
+    }
+#else
+    float nrm1 = 0;
+    for( k = 0; k < len; k++ )
+    {
+        dst[k] *= nrm2;
+        nrm1 += dst[k];
+    }
+    nrm1 = 1.f/std::max(nrm1, FLT_EPSILON);
+    for( k = 0; k < len; k++ )
+    {
+        dst[k] = std::sqrt(dst[k] * nrm1);//saturate_cast<uchar>(std::sqrt(dst[k] * nrm1)*SIFT_INT_DESCR_FCTR);
+    }
+#endif
+}
+
+static void calcDescriptors(const vector<Mat>& gpyr, const vector<KeyPoint>& keypoints,
+                            Mat& descriptors, int nOctaveLayers, int firstOctave, int n /* bins */, int d /* width */)
+{
+    for( size_t i = 0; i < keypoints.size(); i++ )
+    {
+        KeyPoint kpt = keypoints[i];
+        int octave, layer;
+        float scale;
+        unpackOctave(kpt, octave, layer, scale);
+        CV_Assert(octave >= firstOctave && layer <= nOctaveLayers+2);
+        float size=kpt.size*scale;
+        Point2f ptf(kpt.pt.x*scale, kpt.pt.y*scale);
+        const Mat& img = gpyr[(octave - firstOctave)*(nOctaveLayers + 3) + layer];
+
+        float angle = 360.f - kpt.angle;
+        if(std::abs(angle - 360.f) < FLT_EPSILON)
+            angle = 0.f;
+        calcSIFTDescriptor(img, ptf, angle, size*0.5f, d, n, descriptors.ptr<float>((int)i));
+    }
+}
+
+static int descriptorSize(int bins, int width)
+{
+    return width*width*bins;
+}
+
+static void extractSIFT(const Mat &image, vector<KeyPoint> &keypoints, Mat &descriptors, int nOctaveLayers, double sigma, int bins, int width, float initSigma)
+{
+    if( image.empty() || image.depth() != CV_8U )
+        CV_Error( CV_StsBadArg, "image is empty or has incorrect depth (!=CV_8U)" );
+
+    int firstOctave = 0, actualNOctaves = 0, actualNLayers = 0, maxOctave = INT_MIN;
+    for (size_t i=0; i<keypoints.size(); i++) {
+        int octave, layer;
+        float scale;
+        unpackOctave(keypoints[i], octave, layer, scale);
+        firstOctave = std::min(firstOctave, octave);
+        maxOctave = std::max(maxOctave, octave);
+        actualNLayers = std::max(actualNLayers, layer-2);
+    }
+
+    firstOctave = std::min(firstOctave, 0);
+    CV_Assert( firstOctave >= -1 && actualNLayers <= nOctaveLayers );
+    actualNOctaves = maxOctave - firstOctave + 1;
+
+    const Mat base = createInitialImage(image, firstOctave < 0, (float)sigma, initSigma);
+    const int nOctaves = actualNOctaves > 0 ? actualNOctaves : cvRound(log( (double)std::min( base.cols, base.rows ) ) / log(2.) - 2) - firstOctave;
+
+    vector<Mat> gpyr, dogpyr;
+    buildGaussianPyramid(base, gpyr, nOctaves, nOctaveLayers, sigma);
+    buildDoGPyramid(gpyr, dogpyr, nOctaveLayers);
+
+    descriptors.create((int)keypoints.size(), descriptorSize(bins, width), CV_32F);
+    calcDescriptors(gpyr, keypoints, descriptors, nOctaveLayers, firstOctave, bins, width);
+}
+
+#include "openbr/plugins/openbr_internal.h"
+
+namespace br
+{
+
+/*!
+ * \ingroup transforms
+ * \brief Specialize wrapper OpenCV SIFT wrapper
+ * \author Josh Klontz \cite jklontz
+ */
+class CustomSIFTTransform : public UntrainableTransform
+{
+    Q_OBJECT
+    Q_PROPERTY(int size READ get_size WRITE set_size RESET reset_size STORED false)
+    Q_PROPERTY(QList<int> sizes READ get_sizes WRITE set_sizes RESET reset_sizes STORED false)
+    Q_PROPERTY(int bins READ get_bins WRITE set_bins RESET reset_bins STORED false)
+    Q_PROPERTY(int width READ get_width WRITE set_width RESET reset_width STORED false)
+    Q_PROPERTY(float initSigma READ get_initSigma WRITE set_initSigma RESET reset_initSigma STORED false)
+    BR_PROPERTY(int, size, 1)
+    BR_PROPERTY(QList<int>, sizes, QList<int>())
+    BR_PROPERTY(int, bins, 8)
+    BR_PROPERTY(int, width, 4)
+    BR_PROPERTY(float, initSigma, 0.5f)
+
+    void init()
+    {
+        if (sizes.empty())
+            sizes.append(size);
+    }
+
+    void project(const Template &src, Template &dst) const
+    {
+        std::vector<KeyPoint> keyPoints;
+        foreach (const QPointF &val, src.file.points())
+            foreach (const int sz, sizes)
+                keyPoints.push_back(KeyPoint(val.x(), val.y(), sz));
+
+        Mat m;
+        extractSIFT(src, keyPoints, m, 3, 1.6f, bins, width, initSigma);
+        m.setTo(0, m<0); // SIFT returns large negative values when it goes off the edge of the image.
+        dst += m;
+    }
+};
+
+BR_REGISTER(Transform, CustomSIFTTransform)
+
+}
+
+#include "custom_sift.moc"
diff --git a/openbr/plugins/imgproc/cvt.cpp b/openbr/plugins/imgproc/cvt.cpp
new file mode 100644
index 0000000..5078669
--- /dev/null
+++ b/openbr/plugins/imgproc/cvt.cpp
@@ -0,0 +1,71 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * 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 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)
+
+} // namespace br
+
+#include "imgproc/cvt.moc"
diff --git a/openbr/plugins/imgproc/cvtfloat.cpp b/openbr/plugins/imgproc/cvtfloat.cpp
new file mode 100644
index 0000000..9933928
--- /dev/null
+++ b/openbr/plugins/imgproc/cvtfloat.cpp
@@ -0,0 +1,43 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * 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 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)
+
+} // namespace br
+
+#include "imgproc/cvtfloat.moc"
diff --git a/openbr/plugins/imgproc/cvtuchar.cpp b/openbr/plugins/imgproc/cvtuchar.cpp
new file mode 100644
index 0000000..dc98ef5
--- /dev/null
+++ b/openbr/plugins/imgproc/cvtuchar.cpp
@@ -0,0 +1,42 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * 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 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)
+
+} // namespace br
+
+#include "imgproc/cvtuchar.moc"
diff --git a/openbr/plugins/denoising.cpp b/openbr/plugins/imgproc/denoising.cpp
index 03ac646..f716209 100644
--- a/openbr/plugins/denoising.cpp
+++ b/openbr/plugins/imgproc/denoising.cpp
@@ -15,7 +15,8 @@
  * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
 
 #include <opencv2/photo/photo.hpp>
-#include "openbr_internal.h"
+
+#include <openbr/plugins/openbr_internal.h>
 
 using namespace cv;
 
@@ -47,4 +48,4 @@ BR_REGISTER(Transform, NLMeansDenoisingTransform)
 
 } // namespace br
 
-#include "denoising.moc"
+#include "imgproc/denoising.moc"
diff --git a/openbr/plugins/imgproc/discardalpha.cpp b/openbr/plugins/imgproc/discardalpha.cpp
new file mode 100644
index 0000000..9f26a9f
--- /dev/null
+++ b/openbr/plugins/imgproc/discardalpha.cpp
@@ -0,0 +1,56 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * 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 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)
+
+} // namespace br
+
+#include "imgproc/discardalpha.moc"
diff --git a/openbr/plugins/imgproc/div.cpp b/openbr/plugins/imgproc/div.cpp
new file mode 100644
index 0000000..43c730f
--- /dev/null
+++ b/openbr/plugins/imgproc/div.cpp
@@ -0,0 +1,45 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * 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 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)
+
+} // namespace br
+
+#include "imgproc/div.moc"
diff --git a/openbr/plugins/imgproc/dog.cpp b/openbr/plugins/imgproc/dog.cpp
new file mode 100644
index 0000000..e509941
--- /dev/null
+++ b/openbr/plugins/imgproc/dog.cpp
@@ -0,0 +1,70 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * 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 transforms
+ * \brief Difference of gaussians
+ * \author Josh Klontz \cite jklontz
+ */
+class DoGTransform : public UntrainableTransform
+{
+    Q_OBJECT
+    Q_PROPERTY(float sigma0 READ get_sigma0 WRITE set_sigma0 RESET reset_sigma0 STORED false)
+    Q_PROPERTY(float sigma1 READ get_sigma1 WRITE set_sigma1 RESET reset_sigma1 STORED false)
+    BR_PROPERTY(float, sigma0, 1)
+    BR_PROPERTY(float, sigma1, 2)
+
+    Size ksize0, ksize1;
+
+    static Size getKernelSize(double sigma)
+    {
+        // Inverts OpenCV's conversion from kernel size to sigma:
+        // sigma = ((ksize-1)*0.5 - 1)*0.3 + 0.8
+        // See documentation for cv::getGaussianKernel()
+        int ksize = ((sigma - 0.8) / 0.3 + 1) * 2 + 1;
+        if (ksize % 2 == 0) ksize++;
+        return Size(ksize, ksize);
+    }
+
+    void init()
+    {
+        ksize0 = getKernelSize(sigma0);
+        ksize1 = getKernelSize(sigma1);
+    }
+
+    void project(const Template &src, Template &dst) const
+    {
+        Mat g0, g1;
+        GaussianBlur(src, g0, ksize0, 0);
+        GaussianBlur(src, g1, ksize1, 0);
+        subtract(g0, g1, dst);
+    }
+};
+
+BR_REGISTER(Transform, DoGTransform)
+
+} // namespace br
+
+#include "imgproc/dog.moc"
diff --git a/openbr/plugins/imgproc/downsample.cpp b/openbr/plugins/imgproc/downsample.cpp
new file mode 100644
index 0000000..396b04e
--- /dev/null
+++ b/openbr/plugins/imgproc/downsample.cpp
@@ -0,0 +1,54 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * 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 transforms
+ * \brief Downsample the rows and columns of a matrix.
+ * \author Lacey Best-Rowden \cite lbestrowden
+ */
+class DownsampleTransform : public UntrainableTransform
+{
+    Q_OBJECT
+    Q_PROPERTY(int k READ get_k WRITE set_k RESET reset_k STORED false)
+    BR_PROPERTY(int, k, 1)
+
+    void project(const Template &src, Template &dst) const
+    {
+        if (src.m().channels() != 1)
+            qFatal("Expected 1 channel matrix.");
+        Mat input = src.m();
+        Mat output(ceil((double)input.rows/k), ceil((double)input.cols/k), CV_32FC1);
+        for (int r=0; r<output.rows; r++) {
+            for (int c=0; c<output.cols; c++) {
+                output.at<float>(r,c) = input.at<float>(r*k,c*k);
+            }
+        }
+        dst.m() = output;
+    }
+};
+
+BR_REGISTER(Transform, DownsampleTransform)
+
+} // namespace br
+
+#include "imgproc/downsample.moc"
diff --git a/openbr/plugins/imgproc/dup.cpp b/openbr/plugins/imgproc/dup.cpp
new file mode 100644
index 0000000..c4dc477
--- /dev/null
+++ b/openbr/plugins/imgproc/dup.cpp
@@ -0,0 +1,56 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * 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 Duplicates the template data.
+ * \author Josh Klontz \cite jklontz
+ */
+class DupTransform : public UntrainableMetaTransform
+{
+    Q_OBJECT
+    Q_PROPERTY(int n READ get_n WRITE set_n RESET reset_n STORED false)
+    Q_PROPERTY(bool dupLandmarks READ get_dupLandmarks WRITE set_dupLandmarks RESET reset_dupLandmarks STORED false)
+    BR_PROPERTY(int, n, 1)
+    BR_PROPERTY(bool, dupLandmarks, false)
+
+    void project(const Template &src, Template &dst) const
+    {
+        for (int i=0; i<n; i++)
+            dst.merge(src);
+
+        if (dupLandmarks) {
+            QList<QPointF> points = src.file.points();
+            QList<QRectF> rects = src.file.rects();
+
+            for (int i=1; i<n; i++) {
+                dst.file.appendPoints(points);
+                dst.file.appendRects(rects);
+            }
+        }
+    }
+};
+
+BR_REGISTER(Transform, DupTransform)
+
+} // namespace br
+
+#include "imgproc/dup.moc"
diff --git a/openbr/plugins/imgproc/ensurechannels.cpp b/openbr/plugins/imgproc/ensurechannels.cpp
new file mode 100644
index 0000000..f525f12
--- /dev/null
+++ b/openbr/plugins/imgproc/ensurechannels.cpp
@@ -0,0 +1,67 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * 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 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)
+
+} // namespace br
+
+#include "imgproc/ensurechannels.moc"
diff --git a/openbr/plugins/imgproc/equalizehist.cpp b/openbr/plugins/imgproc/equalizehist.cpp
new file mode 100644
index 0000000..50b4894
--- /dev/null
+++ b/openbr/plugins/imgproc/equalizehist.cpp
@@ -0,0 +1,43 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * 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>
+
+namespace br
+{
+
+/*!
+ * \ingroup transforms
+ * \brief Histogram equalization
+ * \author Josh Klontz \cite jklontz
+ */
+class EqualizeHistTransform : public UntrainableTransform
+{
+    Q_OBJECT
+
+    void project(const Template &src, Template &dst) const
+    {
+        cv::equalizeHist(src, dst);
+    }
+};
+
+BR_REGISTER(Transform, EqualizeHistTransform)
+
+} // namespace br
+
+#include "imgproc/equalizehist.moc"
diff --git a/openbr/plugins/imgproc/flip.cpp b/openbr/plugins/imgproc/flip.cpp
new file mode 100644
index 0000000..b84c08b
--- /dev/null
+++ b/openbr/plugins/imgproc/flip.cpp
@@ -0,0 +1,89 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * 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 Flips the image about an axis.
+ * \author Josh Klontz \cite jklontz
+ */
+class FlipTransform : public UntrainableTransform
+{
+    Q_OBJECT
+    Q_ENUMS(Axis)
+    Q_PROPERTY(Axis axis READ get_axis WRITE set_axis RESET reset_axis STORED false)
+
+public:
+    /*!< */
+    enum Axis { X = 0,
+                Y = 1,
+                Both = -1 };
+
+private:
+    BR_PROPERTY(Axis, axis, Y)
+
+    void project(const Template &src, Template &dst) const
+    {
+        cv::flip(src, dst, axis);
+
+        QList<QPointF> flippedPoints;
+        foreach(const QPointF &point, src.file.points()) {
+            // Check for missing data using the QPointF(-1,-1) convention
+            if (point != QPointF(-1,-1)) {
+                if (axis == Y) {
+                    flippedPoints.append(QPointF(src.m().cols-point.x(),point.y()));
+                } else if (axis == X) {
+                    flippedPoints.append(QPointF(point.x(),src.m().rows-point.y()));
+                } else {
+                    flippedPoints.append(QPointF(src.m().cols-point.x(),src.m().rows-point.y()));
+                }
+            }
+        }
+
+        QList<QRectF> flippedRects;
+        foreach(const QRectF &rect, src.file.rects()) {
+            if (axis == Y) {
+                flippedRects.append(QRectF(src.m().cols-rect.right(),
+                                           rect.y(),
+                                           rect.width(),
+                                           rect.height()));
+            } else if (axis == X) {
+                flippedRects.append(QRectF(rect.x(),
+                                           src.m().rows-rect.bottom(),
+                                           rect.width(),
+                                           rect.height()));
+            } else {
+                flippedRects.append(QRectF(src.m().cols-rect.right(),
+                                           src.m().rows-rect.bottom(),
+                                           rect.width(),
+                                           rect.height()));
+            }
+        }
+
+        dst.file.setPoints(flippedPoints);
+        dst.file.setRects(flippedRects);
+    }
+};
+
+BR_REGISTER(Transform, FlipTransform)
+
+} // namespace br
+
+#include "imgproc/flip.moc"
diff --git a/openbr/plugins/imgproc/flood.cpp b/openbr/plugins/imgproc/flood.cpp
new file mode 100644
index 0000000..d56e5b3
--- /dev/null
+++ b/openbr/plugins/imgproc/flood.cpp
@@ -0,0 +1,52 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * 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 transforms
+ * \brief Fill black pixels with the specified color.
+ * \author Josh Klontz \cite jklontz
+ */
+class FloodTransform : public UntrainableTransform
+{
+    Q_OBJECT
+    Q_PROPERTY(int r READ get_r WRITE set_r RESET reset_r STORED false)
+    Q_PROPERTY(int g READ get_g WRITE set_g RESET reset_g STORED false)
+    Q_PROPERTY(int b READ get_b WRITE set_b RESET reset_b STORED false)
+    Q_PROPERTY(bool all READ get_all WRITE set_all RESET reset_all STORED false)
+    BR_PROPERTY(int, r, 0)
+    BR_PROPERTY(int, g, 0)
+    BR_PROPERTY(int, b, 0)
+    BR_PROPERTY(bool, all, false)
+
+    void project(const Template &src, Template &dst) const
+    {
+        dst = src.m().clone();
+        dst.m().setTo(Scalar(r, g, b), all ? Mat() : dst.m()==0);
+    }
+};
+
+BR_REGISTER(Transform, FloodTransform)
+
+} // namespace br
+
+#include "imgproc/flood.moc"
diff --git a/openbr/plugins/wavelet.cpp b/openbr/plugins/imgproc/gabor.cpp
index 25c6511..4080700 100644
--- a/openbr/plugins/wavelet.cpp
+++ b/openbr/plugins/imgproc/gabor.cpp
@@ -15,7 +15,8 @@
  * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
 
 #include <opencv2/imgproc/imgproc.hpp>
-#include "openbr_internal.h"
+
+#include <openbr/plugins/openbr_internal.h>
 
 using namespace cv;
 
@@ -201,4 +202,4 @@ BR_REGISTER(Transform, GaborJetTransform)
 
 } // namespace br
 
-#include "wavelet.moc"
+#include "imgproc/gabor.moc"
diff --git a/openbr/plugins/imgproc/gamma.cpp b/openbr/plugins/imgproc/gamma.cpp
new file mode 100644
index 0000000..775f0b0
--- /dev/null
+++ b/openbr/plugins/imgproc/gamma.cpp
@@ -0,0 +1,55 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * 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 transforms
+ * \brief Gamma correction
+ * \author Josh Klontz \cite jklontz
+ */
+class GammaTransform : public UntrainableTransform
+{
+    Q_OBJECT
+    Q_PROPERTY(float gamma READ get_gamma WRITE set_gamma RESET reset_gamma STORED false)
+    BR_PROPERTY(float, gamma, 0.2)
+
+    Mat lut;
+
+    void init()
+    {
+        lut.create(256, 1, CV_32FC1);
+        if (gamma == 0) for (int i=0; i<256; i++) lut.at<float>(i,0) = log((float)i);
+        else            for (int i=0; i<256; i++) lut.at<float>(i,0) = pow(i, gamma);
+    }
+
+    void project(const Template &src, Template &dst) const
+    {
+        if (src.m().depth() == CV_8U) LUT(src, lut, dst);
+        else                          pow(src, gamma, dst);
+    }
+};
+
+BR_REGISTER(Transform, GammaTransform)
+
+} // namespace br
+
+#include "imgproc/gamma.moc"
diff --git a/openbr/plugins/imgproc/gradient.cpp b/openbr/plugins/imgproc/gradient.cpp
new file mode 100644
index 0000000..7586319
--- /dev/null
+++ b/openbr/plugins/imgproc/gradient.cpp
@@ -0,0 +1,66 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * 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 transforms
+ * \brief Computes magnitude and/or angle of image.
+ * \author Josh Klontz \cite jklontz
+ */
+class GradientTransform : public UntrainableTransform
+{
+    Q_OBJECT
+    Q_ENUMS(Channel)
+    Q_PROPERTY(Channel channel READ get_channel WRITE set_channel RESET reset_channel STORED false)
+
+public:
+    enum Channel { Magnitude, Angle, MagnitudeAndAngle };
+
+private:
+    BR_PROPERTY(Channel, channel, Angle)
+
+    void project(const Template &src, Template &dst) const
+    {
+        Mat dx, dy, magnitude, angle;
+        Sobel(src, dx, CV_32F, 1, 0, CV_SCHARR);
+        Sobel(src, dy, CV_32F, 0, 1, CV_SCHARR);
+        cartToPolar(dx, dy, magnitude, angle, true);
+        std::vector<Mat> mv;
+        if ((channel == Magnitude) || (channel == MagnitudeAndAngle)) {
+            const float theoreticalMaxMagnitude = sqrt(2*pow(float(2*(3+10+3)*255), 2.f));
+            mv.push_back(magnitude / theoreticalMaxMagnitude);
+        }
+        if ((channel == Angle) || (channel == MagnitudeAndAngle))
+            mv.push_back(angle);
+        Mat result;
+        merge(mv, result);
+        dst.append(result);
+    }
+};
+
+BR_REGISTER(Transform, GradientTransform)
+
+} // namespace br
+
+#include "imgproc/gradient.moc"
diff --git a/openbr/plugins/mask.cpp b/openbr/plugins/imgproc/gradientmask.cpp
index 6898c70..5f7064f 100644
--- a/openbr/plugins/mask.cpp
+++ b/openbr/plugins/imgproc/gradientmask.cpp
@@ -14,9 +14,7 @@
  * limitations under the License.                                            *
  * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
 
-#include <opencv2/imgproc/imgproc.hpp>
-#include <opencv2/imgproc/imgproc_c.h>
-#include "openbr_internal.h"
+#include <openbr/plugins/openbr_internal.h>
 
 using namespace cv;
 
@@ -25,29 +23,6 @@ namespace br
 
 /*!
  * \ingroup transforms
- * \brief Applies an eliptical mask
- * \author Josh Klontz \cite jklontz
- */
-class MaskTransform : public UntrainableTransform
-{
-    Q_OBJECT
-
-    void project(const Template &src, Template &dst) const
-    {
-        const Mat &m = src;
-        Mat mask(m.size(), CV_8UC1);
-        mask.setTo(1);
-        const float SCALE = 1.1;
-        ellipse(mask, RotatedRect(Point2f(m.cols/2, m.rows/2), Size2f(SCALE*m.cols, SCALE*m.rows), 0), 0, -1);
-        dst = m.clone();
-        dst.m().setTo(0, mask);
-    }
-};
-
-BR_REGISTER(Transform, MaskTransform)
-
-/*!
- * \ingroup transforms
  * \brief Masks image according to pixel change.
  * \author Josh Klontz \cite jklontz
  */
@@ -77,130 +52,6 @@ class GradientMaskTransform : public UntrainableTransform
 
 BR_REGISTER(Transform, GradientMaskTransform)
 
-/*!
- * \ingroup transforms
- * \brief http://worldofcameras.wordpress.com/tag/skin-detection-opencv/
- * \author Josh Klontz \cite jklontz
- */
-class SkinMaskTransform : public UntrainableTransform
-{
-    Q_OBJECT
-
-    void project(const Template &src, Template &dst) const
-    {
-        Mat m;
-        cvtColor(src, m, CV_BGR2YCrCb);
-        std::vector<Mat> mv;
-        split(m, mv);
-        Mat mask = Mat(m.rows, m.cols, CV_8UC1);
-
-        for (int i=0; i<m.rows; i++) {
-            for (int j=0; j<m.cols; j++) {
-                int Cr= mv[1].at<quint8>(i,j);
-                int Cb =mv[2].at<quint8>(i,j);
-                mask.at<quint8>(i, j) = (Cr>130 && Cr<170) && (Cb>70 && Cb<125) ? 255 : 0;
-            }
-        }
-
-        dst = mask;
-    }
-};
-
-BR_REGISTER(Transform, SkinMaskTransform)
-
-/*!
- * \ingroup transforms
- * \brief Morphological operator
- * \author Josh Klontz \cite jklontz
- */
-class MorphTransform : public UntrainableTransform
-{
-    Q_OBJECT
-    Q_ENUMS(Op)
-    Q_PROPERTY(Op op READ get_op WRITE set_op RESET reset_op STORED false)
-    Q_PROPERTY(int radius READ get_radius WRITE set_radius RESET reset_radius STORED false)
-
-public:
-    /*!< */
-    enum Op { Erode = MORPH_ERODE,
-              Dilate = MORPH_DILATE,
-              Open = MORPH_OPEN,
-              Close = MORPH_CLOSE,
-              Gradient = MORPH_GRADIENT,
-              TopHat = MORPH_TOPHAT,
-              BlackHat = MORPH_BLACKHAT };
-
-private:
-    BR_PROPERTY(Op, op, Close)
-    BR_PROPERTY(int, radius, 1)
-
-    Mat kernel;
-
-    void init()
-    {
-        Mat kernel = Mat(radius, radius, CV_8UC1);
-        kernel.setTo(255);
-    }
-
-    void project(const Template &src, Template &dst) const
-    {
-        morphologyEx(src, dst, op, kernel);
-    }
-};
-
-BR_REGISTER(Transform, MorphTransform)
-
-/*!
- * \ingroup transforms
- * \brief Set the template's label to the area of the largest convex hull.
- * \author Josh Klontz \cite jklontz
- */
-class LargestConvexAreaTransform : public UntrainableTransform
-{
-    Q_OBJECT
-
-    Q_PROPERTY(QString outputVariable READ get_outputVariable WRITE set_outputVariable RESET reset_outputVariable STORED false)
-    BR_PROPERTY(QString, outputVariable, "Label")
-
-    void project(const Template &src, Template &dst) const
-    {
-        std::vector< std::vector<Point> > contours;
-        findContours(src.m().clone(), contours, CV_RETR_EXTERNAL, CV_CHAIN_APPROX_SIMPLE);
-        double maxArea = 0;
-        foreach (const std::vector<Point> &contour, contours) {
-            std::vector<Point> hull;
-            convexHull(contour, hull);
-            double area = contourArea(contour);
-            double hullArea = contourArea(hull);
-            if (area / hullArea > 0.98)
-                maxArea = std::max(maxArea, area);
-        }
-        dst.file.set(outputVariable, maxArea);
-    }
-};
-
-BR_REGISTER(Transform, LargestConvexAreaTransform)
-
-/*!
- * \ingroup transforms
- * \brief Applies a mask from the metadata.
- * \author Austin Blanton \cite imaus10
- */
-class ApplyMaskTransform : public UntrainableTransform
-{
-    Q_OBJECT
-
-    void project(const Template &src, Template &dst) const
-    {
-        if (src.file.contains("Mask"))
-            src.m().copyTo(dst, src.file.get<Mat>("Mask"));
-        else
-            dst = src;
-    }
-};
-
-BR_REGISTER(Transform, ApplyMaskTransform)
-
 } // namespace br
 
-#include "mask.moc"
+#include "imgproc/gradientmask.moc"
diff --git a/openbr/plugins/imgproc/group.cpp b/openbr/plugins/imgproc/group.cpp
new file mode 100644
index 0000000..c598995
--- /dev/null
+++ b/openbr/plugins/imgproc/group.cpp
@@ -0,0 +1,65 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * 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 transforms
+ * \brief Group all input matrices into a single matrix.
+ *
+ * Similar to CatTransfrom but groups every _size_ adjacent matricies.
+ * \author Josh Klontz \cite jklontz
+ */
+class GroupTransform : public UntrainableMetaTransform
+{
+    Q_OBJECT
+    Q_PROPERTY(int size READ get_size WRITE set_size RESET reset_size STORED false)
+    BR_PROPERTY(int, size, 1)
+
+    void project(const Template &src, Template &dst) const
+    {
+        dst.file = src.file;
+
+        if (src.size() % size != 0)
+            qFatal("%d size does not evenly divide %d matrices.", size, src.size());
+        QVector<int> sizes(src.size() / size, 0);
+        for (int i=0; i<src.size(); i++)
+            sizes[i/size] += src[i].total();
+
+        if (!src.empty())
+            foreach (int size_, sizes)
+                dst.append(Mat(1, size_, src.m().type()));
+
+        QVector<int> offsets(src.size() / size, 0);
+        for (int i=0; i<src.size(); i++) {
+            const size_t bytes = src[i].total() * src[i].elemSize();
+            const int j = i / size;
+            memcpy(&dst[j].data[offsets[j]], src[i].ptr(), bytes);
+            offsets[j] += bytes;
+        }
+    }
+};
+
+BR_REGISTER(Transform, GroupTransform)
+
+} // namespace br
+
+#include "imgproc/group.moc"
diff --git a/openbr/plugins/imgproc/heatmap.cpp b/openbr/plugins/imgproc/heatmap.cpp
new file mode 100644
index 0000000..66623ba
--- /dev/null
+++ b/openbr/plugins/imgproc/heatmap.cpp
@@ -0,0 +1,38 @@
+#include "openbr/plugins/openbr_internal.h"
+#include "openbr/core/opencvutils.h"
+
+#include <opencv2/contrib/contrib.hpp>
+
+using namespace cv;
+
+namespace br
+{
+
+class HeatmapTransform : public UntrainableTransform
+{
+    Q_OBJECT
+
+    Q_PROPERTY(float alpha READ get_alpha WRITE set_alpha RESET reset_alpha STORED false)
+    BR_PROPERTY(float, alpha, .5)
+
+    void project(const Template &src, Template &dst) const
+    {
+        dst = src;
+
+        const float beta = 1-alpha;
+
+        Mat buffer;
+        applyColorMap(src,buffer,COLORMAP_JET);
+
+        Mat colored;
+        cvtColor(src, colored, CV_GRAY2BGR);
+
+        addWeighted(colored,alpha,buffer,beta,0.0,dst);
+    }
+};
+
+BR_REGISTER(Transform, HeatmapTransform)
+
+} // namespace br
+
+#include "imgproc/heatmap.moc"
diff --git a/openbr/plugins/imgproc/hist.cpp b/openbr/plugins/imgproc/hist.cpp
new file mode 100644
index 0000000..4a11522
--- /dev/null
+++ b/openbr/plugins/imgproc/hist.cpp
@@ -0,0 +1,70 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * 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 transforms
+ * \brief Histograms the matrix
+ * \author Josh Klontz \cite jklontz
+ */
+class HistTransform : public UntrainableTransform
+{
+    Q_OBJECT
+    Q_PROPERTY(float max READ get_max WRITE set_max RESET reset_max STORED false)
+    Q_PROPERTY(float min READ get_min WRITE set_min RESET reset_min STORED false)
+    Q_PROPERTY(int dims READ get_dims WRITE set_dims RESET reset_dims STORED false)
+    BR_PROPERTY(float, max, 256)
+    BR_PROPERTY(float, min, 0)
+    BR_PROPERTY(int, dims, -1)
+
+    void project(const Template &src, Template &dst) const
+    {
+        const int dims = this->dims == -1 ? max - min : this->dims;
+
+        std::vector<Mat> mv;
+        split(src, mv);
+        Mat m(mv.size(), dims, CV_32FC1);
+
+        for (size_t i=0; i<mv.size(); i++) {
+            int channels[] = {0};
+            int histSize[] = {dims};
+            float range[] = {min, max};
+            const float* ranges[] = {range};
+            Mat hist, chan = mv[i];
+            // calcHist requires F or U, might as well convert just in case
+            if (mv[i].depth() != CV_8U && mv[i].depth() != CV_32F)
+                mv[i].convertTo(chan, CV_32F);
+            calcHist(&chan, 1, channels, Mat(), hist, 1, histSize, ranges);
+            memcpy(m.ptr(i), hist.ptr(), dims * sizeof(float));
+        }
+
+        dst += m;
+    }
+};
+
+BR_REGISTER(Transform, HistTransform)
+
+} // namespace br
+
+#include "imgproc/hist.moc"
diff --git a/openbr/plugins/hist.cpp b/openbr/plugins/imgproc/histbin.cpp
index d9f0a05..6b3c757 100644
--- a/openbr/plugins/hist.cpp
+++ b/openbr/plugins/imgproc/histbin.cpp
@@ -14,10 +14,7 @@
  * 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>
 
 using namespace cv;
 
@@ -26,52 +23,10 @@ namespace br
 
 /*!
  * \ingroup transforms
- * \brief Histograms the matrix
- * \author Josh Klontz \cite jklontz
- */
-class HistTransform : public UntrainableTransform
-{
-    Q_OBJECT
-    Q_PROPERTY(float max READ get_max WRITE set_max RESET reset_max STORED false)
-    Q_PROPERTY(float min READ get_min WRITE set_min RESET reset_min STORED false)
-    Q_PROPERTY(int dims READ get_dims WRITE set_dims RESET reset_dims STORED false)
-    BR_PROPERTY(float, max, 256)
-    BR_PROPERTY(float, min, 0)
-    BR_PROPERTY(int, dims, -1)
-
-    void project(const Template &src, Template &dst) const
-    {
-        const int dims = this->dims == -1 ? max - min : this->dims;
-
-        std::vector<Mat> mv;
-        split(src, mv);
-        Mat m(mv.size(), dims, CV_32FC1);
-
-        for (size_t i=0; i<mv.size(); i++) {
-            int channels[] = {0};
-            int histSize[] = {dims};
-            float range[] = {min, max};
-            const float* ranges[] = {range};
-            Mat hist, chan = mv[i];
-            // calcHist requires F or U, might as well convert just in case
-            if (mv[i].depth() != CV_8U && mv[i].depth() != CV_32F)
-                mv[i].convertTo(chan, CV_32F);
-            calcHist(&chan, 1, channels, Mat(), hist, 1, histSize, ranges);
-            memcpy(m.ptr(i), hist.ptr(), dims * sizeof(float));
-        }
-
-        dst += m;
-    }
-};
-
-BR_REGISTER(Transform, HistTransform)
-
-/*!
- * \ingroup transforms
  * \brief Quantizes the values into bins.
  * \author Josh Klontz \cite jklontz
  */
-class BinTransform : public UntrainableTransform
+class HistBinTransform : public UntrainableTransform
 {
     Q_OBJECT
     Q_PROPERTY(float min READ get_min WRITE set_min RESET reset_min STORED false)
@@ -120,76 +75,8 @@ class BinTransform : public UntrainableTransform
     }
 };
 
-BR_REGISTER(Transform, BinTransform)
-
-/*!
- * \ingroup transforms
- * \brief Converts each element to its rank-ordered value.
- * \author Josh Klontz \cite jklontz
- */
-class RankTransform : public UntrainableTransform
-{
-    Q_OBJECT
-
-    void project(const Template &src, Template &dst) const
-    {
-        const Mat &m = src;
-        assert(m.channels() == 1);
-        dst = Mat(m.rows, m.cols, CV_32FC1);
-        typedef QPair<float,int> Tuple;
-        QList<Tuple> tuples = Common::Sort(OpenCVUtils::matrixToVector<float>(m));
-
-        float prevValue = 0;
-        int prevRank = 0;
-        for (int i=0; i<tuples.size(); i++) {
-            int rank;
-            if (tuples[i].first == prevValue) rank = prevRank;
-            else                              rank = i;
-            dst.m().at<float>(tuples[i].second / m.cols, tuples[i].second % m.cols) = rank;
-            prevValue = tuples[i].first;
-            prevRank = rank;
-        }
-    }
-};
-
-BR_REGISTER(Transform, RankTransform)
-
-/*!
- * \ingroup transforms
- * \brief An integral histogram
- * \author Josh Klontz \cite jklontz
- */
-class IntegralHistTransform : public UntrainableTransform
-{
-    Q_OBJECT
-    Q_PROPERTY(int bins READ get_bins WRITE set_bins RESET reset_bins STORED false)
-    Q_PROPERTY(int radius READ get_radius WRITE set_radius RESET reset_radius STORED false)
-    BR_PROPERTY(int, bins, 256)
-    BR_PROPERTY(int, radius, 16)
-
-    void project(const Template &src, Template &dst) const
-    {
-        const Mat &m = src.m();
-        if (m.type() != CV_8UC1) qFatal("IntegralHist requires 8UC1 matrices.");
-
-        Mat integral(m.rows/radius+1, (m.cols/radius+1)*bins, CV_32SC1);
-        integral.setTo(0);
-        for (int i=1; i<integral.rows; i++) {
-            for (int j=1; j<integral.cols; j+=bins) {
-                for (int k=0; k<bins; k++) integral.at<qint32>(i, j+k) += integral.at<qint32>(i-1, j     +k);
-                for (int k=0; k<bins; k++) integral.at<qint32>(i, j+k) += integral.at<qint32>(i  , j-bins+k);
-                for (int k=0; k<bins; k++) integral.at<qint32>(i, j+k) -= integral.at<qint32>(i-1, j-bins+k);
-                for (int k=0; k<radius; k++)
-                    for (int l=0; l<radius; l++)
-                        integral.at<qint32>(i, j+m.at<quint8>((i-1)*radius+k,(j/bins-1)*radius+l))++;
-            }
-        }
-        dst = integral;
-    }
-};
-
-BR_REGISTER(Transform, IntegralHistTransform)
+BR_REGISTER(Transform, HistBinTransform)
 
 } // namespace br
 
-#include "hist.moc"
+#include "imgproc/histbin.moc"
diff --git a/openbr/plugins/imgproc/histeqquantization.cpp b/openbr/plugins/imgproc/histeqquantization.cpp
new file mode 100644
index 0000000..9c60642
--- /dev/null
+++ b/openbr/plugins/imgproc/histeqquantization.cpp
@@ -0,0 +1,85 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * 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 transforms
+ * \brief Approximate floats as uchar with different scalings for each dimension.
+ * \author Josh Klontz \cite jklontz
+ */
+class HistEqQuantizationTransform : public Transform
+{
+    Q_OBJECT
+    QVector<float> thresholds;
+
+    static void computeThresholds(const Mat &data, float *thresholds)
+    {
+        QList<float> vals = OpenCVUtils::matrixToVector<float>(data);
+        std::sort(vals.begin(), vals.end());
+        for (int i=0; i<255; i++)
+            thresholds[i] = vals[(i+1)*vals.size()/256];
+        thresholds[255] = std::numeric_limits<float>::max();
+    }
+
+    void train(const TemplateList &src)
+    {
+        const Mat data = OpenCVUtils::toMat(src.data());
+        thresholds = QVector<float>(256*data.cols);
+
+        QFutureSynchronizer<void> futures;
+        for (int i=0; i<data.cols; i++)
+            futures.addFuture(QtConcurrent::run(&HistEqQuantizationTransform::computeThresholds, data.col(i), &thresholds.data()[i*256]));
+        futures.waitForFinished();
+    }
+
+    void project(const Template &src, Template &dst) const
+    {
+        const QList<float> vals = OpenCVUtils::matrixToVector<float>(src);
+        dst = Mat(1, vals.size(), CV_8UC1);
+        for (int i=0; i<vals.size(); i++) {
+            const float *t = &thresholds.data()[i*256];
+            const float val = vals[i];
+            uchar j = 0;
+            while (val > t[j]) j++;
+            dst.m().at<uchar>(0,i) = j;
+        }
+    }
+
+    void store(QDataStream &stream) const
+    {
+        stream << thresholds;
+    }
+
+    void load(QDataStream &stream)
+    {
+        stream >> thresholds;
+    }
+};
+
+BR_REGISTER(Transform, HistEqQuantizationTransform)
+
+} // namespace br
+
+#include "imgproc/histeqquantization.moc"
diff --git a/openbr/plugins/imgproc/hog.cpp b/openbr/plugins/imgproc/hog.cpp
new file mode 100644
index 0000000..671a540
--- /dev/null
+++ b/openbr/plugins/imgproc/hog.cpp
@@ -0,0 +1,55 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * 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/objdetect/objdetect.hpp>
+
+#include <openbr/plugins/openbr_internal.h>
+
+using namespace cv;
+
+namespace br
+{
+
+/*!
+ * \ingroup transforms
+ * \brief OpenCV HOGDescriptor wrapper
+ * \author Austin Blanton \cite imaus10
+ */
+class HoGDescriptorTransform : public UntrainableTransform
+{
+    Q_OBJECT
+
+    HOGDescriptor hog;
+
+    void project(const Template &src, Template &dst) const
+    {
+        std::vector<float> descriptorVals;
+        std::vector<Point> locations;
+        Size winStride = Size(0,0);
+        Size padding = Size(0,0);
+        foreach (const Mat &rect, src) {
+            hog.compute(rect, descriptorVals, winStride, padding, locations);
+            Mat HoGFeats(descriptorVals, true);
+            dst += HoGFeats;
+        }
+    }
+};
+
+BR_REGISTER(Transform, HoGDescriptorTransform)
+
+} // namespace br
+
+#include "imgproc/hog.moc"
diff --git a/openbr/plugins/fill.cpp b/openbr/plugins/imgproc/inpaint.cpp
index 1614337..5083986 100644
--- a/openbr/plugins/fill.cpp
+++ b/openbr/plugins/imgproc/inpaint.cpp
@@ -15,7 +15,8 @@
  * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
 
 #include <opencv2/photo/photo.hpp>
-#include "openbr_internal.h"
+
+#include <openbr/plugins/openbr_internal.h>
 
 using namespace cv;
 
@@ -55,72 +56,6 @@ private:
     }
 };
 
-BR_REGISTER(Transform, InpaintTransform)
-
-/*!
- * \ingroup transforms
- * \brief Fill 0 pixels with the mean of non-0 pixels.
- * \author Josh Klontz \cite jklontz
- */
-class MeanFillTransform : public UntrainableTransform
-{
-    Q_OBJECT
-
-    void project(const Template &src, Template &dst) const
-    {
-        dst = src.m().clone();
-        dst.m().setTo(mean(dst, dst.m()!=0), dst.m()==0);
-    }
-};
-
-BR_REGISTER(Transform, MeanFillTransform)
-
-/*!
- * \ingroup transforms
- * \brief Fill black pixels with the specified color.
- * \author Josh Klontz \cite jklontz
- */
-class FloodTransform : public UntrainableTransform
-{
-    Q_OBJECT
-    Q_PROPERTY(int r READ get_r WRITE set_r RESET reset_r STORED false)
-    Q_PROPERTY(int g READ get_g WRITE set_g RESET reset_g STORED false)
-    Q_PROPERTY(int b READ get_b WRITE set_b RESET reset_b STORED false)
-    Q_PROPERTY(bool all READ get_all WRITE set_all RESET reset_all STORED false)
-    BR_PROPERTY(int, r, 0)
-    BR_PROPERTY(int, g, 0)
-    BR_PROPERTY(int, b, 0)
-    BR_PROPERTY(bool, all, false)
-
-    void project(const Template &src, Template &dst) const
-    {
-        dst = src.m().clone();
-        dst.m().setTo(Scalar(r, g, b), all ? Mat() : dst.m()==0);
-    }
-};
-
-BR_REGISTER(Transform, FloodTransform)
-
-/*!
- * \ingroup transforms
- * \brief Alpha-blend two matrices
- * \author Josh Klontz \cite jklontz
- */
-class BlendTransform : public UntrainableMetaTransform
-{
-    Q_OBJECT
-    Q_PROPERTY(float alpha READ get_alpha WRITE set_alpha RESET reset_alpha STORED false)
-    BR_PROPERTY(float, alpha, 0.5)
-
-    void project(const Template &src, Template &dst) const
-    {
-        if (src.size() != 2) qFatal("Expected two source matrices.");
-        addWeighted(src[0], alpha, src[1], 1-alpha, 0, dst);
-    }
-};
-
-BR_REGISTER(Transform, BlendTransform)
-
 } // namespace br
 
-#include "fill.moc"
+#include "imgproc/inpaint.moc"
diff --git a/openbr/plugins/imgproc/integral.cpp b/openbr/plugins/imgproc/integral.cpp
new file mode 100644
index 0000000..7d0a551
--- /dev/null
+++ b/openbr/plugins/imgproc/integral.cpp
@@ -0,0 +1,43 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * 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>
+
+namespace br
+{
+
+/*!
+ * \ingroup transforms
+ * \brief Computes integral image.
+ * \author Josh Klontz \cite jklontz
+ */
+class IntegralTransform : public UntrainableTransform
+{
+    Q_OBJECT
+
+    void project(const Template &src, Template &dst) const
+    {
+        cv::integral(src, dst);
+    }
+};
+
+BR_REGISTER(Transform, IntegralTransform)
+
+} // namespace br
+
+#include "imgproc/integral.moc"
diff --git a/openbr/plugins/imgproc/integralhist.cpp b/openbr/plugins/imgproc/integralhist.cpp
new file mode 100644
index 0000000..c90b0b3
--- /dev/null
+++ b/openbr/plugins/imgproc/integralhist.cpp
@@ -0,0 +1,62 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * 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 transforms
+ * \brief An integral histogram
+ * \author Josh Klontz \cite jklontz
+ */
+class IntegralHistTransform : public UntrainableTransform
+{
+    Q_OBJECT
+    Q_PROPERTY(int bins READ get_bins WRITE set_bins RESET reset_bins STORED false)
+    Q_PROPERTY(int radius READ get_radius WRITE set_radius RESET reset_radius STORED false)
+    BR_PROPERTY(int, bins, 256)
+    BR_PROPERTY(int, radius, 16)
+
+    void project(const Template &src, Template &dst) const
+    {
+        const Mat &m = src.m();
+        if (m.type() != CV_8UC1) qFatal("IntegralHist requires 8UC1 matrices.");
+
+        Mat integral(m.rows/radius+1, (m.cols/radius+1)*bins, CV_32SC1);
+        integral.setTo(0);
+        for (int i=1; i<integral.rows; i++) {
+            for (int j=1; j<integral.cols; j+=bins) {
+                for (int k=0; k<bins; k++) integral.at<qint32>(i, j+k) += integral.at<qint32>(i-1, j     +k);
+                for (int k=0; k<bins; k++) integral.at<qint32>(i, j+k) += integral.at<qint32>(i  , j-bins+k);
+                for (int k=0; k<bins; k++) integral.at<qint32>(i, j+k) -= integral.at<qint32>(i-1, j-bins+k);
+                for (int k=0; k<radius; k++)
+                    for (int l=0; l<radius; l++)
+                        integral.at<qint32>(i, j+m.at<quint8>((i-1)*radius+k,(j/bins-1)*radius+l))++;
+            }
+        }
+        dst = integral;
+    }
+};
+
+BR_REGISTER(Transform, IntegralHistTransform)
+
+} // namespace br
+
+#include "imgproc/integralhist.moc"
diff --git a/openbr/plugins/imgproc/integralsampler.cpp b/openbr/plugins/imgproc/integralsampler.cpp
new file mode 100644
index 0000000..94fafa1
--- /dev/null
+++ b/openbr/plugins/imgproc/integralsampler.cpp
@@ -0,0 +1,122 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * 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>
+
+using namespace cv;
+
+namespace br
+{
+
+/*!
+ * \ingroup transforms
+ * \brief Sliding window feature extraction from a multi-channel integral image.
+ * \author Josh Klontz \cite jklontz
+ */
+class IntegralSamplerTransform : public UntrainableTransform
+{
+    Q_OBJECT
+    Q_PROPERTY(int scales READ get_scales WRITE set_scales RESET reset_scales STORED false)
+    Q_PROPERTY(float scaleFactor READ get_scaleFactor WRITE set_scaleFactor RESET reset_scaleFactor STORED false)
+    Q_PROPERTY(float stepFactor READ get_stepFactor WRITE set_stepFactor RESET reset_stepFactor STORED false)
+    Q_PROPERTY(int minSize READ get_minSize WRITE set_minSize RESET reset_minSize STORED false)
+    Q_PROPERTY(bool secondOrder READ get_secondOrder WRITE set_secondOrder RESET reset_secondOrder STORED false)
+    BR_PROPERTY(int, scales, 6)
+    BR_PROPERTY(float, scaleFactor, 2)
+    BR_PROPERTY(float, stepFactor, 0.75)
+    BR_PROPERTY(int, minSize, 8)
+    BR_PROPERTY(bool, secondOrder, false)
+
+    void project(const Template &src, Template &dst) const
+    {
+        typedef Eigen::Map< const Eigen::Matrix<qint32,Eigen::Dynamic,1> > InputDescriptor;
+        typedef Eigen::Map< const Eigen::Matrix<float,Eigen::Dynamic,1> > SecondOrderInputDescriptor;
+        typedef Eigen::Map< Eigen::Matrix<float,Eigen::Dynamic,1> > OutputDescriptor;
+
+        const Mat &m = src.m();
+        if (m.depth() != CV_32S) qFatal("Expected CV_32S matrix depth.");
+        const int channels = m.channels();
+        const int rowStep = channels * m.cols;
+
+        int descriptors = 0;
+        float idealSize = min(m.rows, m.cols)-1;
+        for (int scale=0; scale<scales; scale++) {
+            const int currentSize(idealSize);
+            const int numDown = 1+(m.rows-currentSize-1)/int(idealSize*stepFactor);
+            const int numAcross = 1+(m.cols-currentSize-1)/int(idealSize*stepFactor);
+            descriptors += numDown*numAcross;
+            if (secondOrder) descriptors += numDown*(numAcross-1) + (numDown-1)*numAcross;
+            idealSize /= scaleFactor;
+            if (idealSize < minSize) break;
+        }
+        Mat n(descriptors, channels, CV_32FC1);
+
+        const qint32 *dataIn = (qint32*)m.data;
+        float *dataOut = (float*)n.data;
+        idealSize = min(m.rows, m.cols)-1;
+        int index = 0;
+        for (int scale=0; scale<scales; scale++) {
+            const int currentSize(idealSize);
+            const int currentStep(idealSize*stepFactor);
+            for (int i=currentSize; i<m.rows; i+=currentStep) {
+                for (int j=currentSize; j<m.cols; j+=currentStep) {
+                    InputDescriptor a(dataIn+((i-currentSize)*rowStep+(j-currentSize)*channels), channels, 1);
+                    InputDescriptor b(dataIn+((i-currentSize)*rowStep+ j             *channels), channels, 1);
+                    InputDescriptor c(dataIn+(i              *rowStep+(j-currentSize)*channels), channels, 1);
+                    InputDescriptor d(dataIn+(i              *rowStep+ j             *channels), channels, 1);
+                    OutputDescriptor y(dataOut+(index*channels), channels, 1);
+                    y = (d-b-c+a).cast<float>()/(currentSize*currentSize);
+                    index++;
+                }
+            }
+            if (secondOrder) {
+                const int numDown = 1+(m.rows-currentSize-1)/currentStep;
+                const int numAcross = 1+(m.cols-currentSize-1)/currentStep;
+                const float *dataIn = n.ptr<float>(index - numDown*numAcross);
+                for (int i=0; i<numDown; i++) {
+                    for (int j=0; j<numAcross; j++) {
+                        SecondOrderInputDescriptor a(dataIn + (i*numAcross+j)*channels, channels, 1);
+                        if (j < numAcross-1) {
+                            OutputDescriptor y(dataOut+(index*channels), channels, 1);
+                            y = a - SecondOrderInputDescriptor(dataIn + (i*numAcross+j+1)*channels, channels, 1);
+                            index++;
+                        }
+                        if (i < numDown-1) {
+                            OutputDescriptor y(dataOut+(index*channels), channels, 1);
+                            y = a - SecondOrderInputDescriptor(dataIn + ((i+1)*numAcross+j)*channels, channels, 1);
+                            index++;
+                        }
+                    }
+                }
+            }
+            idealSize /= scaleFactor;
+            if (idealSize < minSize) break;
+        }
+
+        if (descriptors != index)
+            qFatal("Allocated %d descriptors but computed %d.", descriptors, index);
+
+        dst.m() = n;
+    }
+};
+
+BR_REGISTER(Transform, IntegralSamplerTransform)
+
+} // namespace br
+
+#include "imgproc/integralsampler.moc"
diff --git a/openbr/plugins/imgproc/kernelhash.cpp b/openbr/plugins/imgproc/kernelhash.cpp
new file mode 100644
index 0000000..5696492
--- /dev/null
+++ b/openbr/plugins/imgproc/kernelhash.cpp
@@ -0,0 +1,58 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * 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 Kernel hash
+ * \author Josh Klontz \cite jklontz
+ */
+class KernelHashTransform : public UntrainableTransform
+{
+    Q_OBJECT
+    Q_PROPERTY(uchar dimsIn READ get_dimsIn WRITE set_dimsIn RESET reset_dimsIn STORED false)
+    Q_PROPERTY(uchar dimsOut READ get_dimsOut WRITE set_dimsOut RESET reset_dimsOut STORED false)
+    BR_PROPERTY(uchar, dimsIn, 8)
+    BR_PROPERTY(uchar, dimsOut, 7)
+
+    void project(const Template &src, Template &dst) const
+    {
+        if (src.m().type() != CV_8UC1)
+            qFatal("Expected 8UC1 input.");
+
+        dst = cv::Mat::zeros(src.m().rows, src.m().cols, CV_8UC1);
+        const uchar *srcData = src.m().data;
+        uchar *dstData = dst.m().data;
+        const int step = src.m().cols;
+        for (int i=0; i<src.m().rows-1; i++)
+            for (int j=0; j<src.m().cols-1; j++) {
+                dstData[i*step+j] = (uint(pow(float(dimsIn),1.f))*srcData[i    *step+j]
+                                   + uint(pow(float(dimsIn),2.f))*srcData[(i+1)*step+j]
+                                   + uint(pow(float(dimsIn),0.f))*srcData[i    *step+(j+1)]
+                                   /*+ uint(pow(float(dimsIn),0.f))*srcData[(i+1)*step+(j+1)]*/) % dimsOut;
+            }
+    }
+};
+
+BR_REGISTER(Transform, KernelHashTransform)
+
+} // namespace br
+
+#include "imgproc/kernelhash.moc"
diff --git a/openbr/plugins/imgproc/keypointdescriptor.cpp b/openbr/plugins/imgproc/keypointdescriptor.cpp
new file mode 100644
index 0000000..003a81d
--- /dev/null
+++ b/openbr/plugins/imgproc/keypointdescriptor.cpp
@@ -0,0 +1,66 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * 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 Descriptor
+ * \author Josh Klontz \cite jklontz
+ */
+class KeyPointDescriptorTransform : public UntrainableTransform
+{
+    Q_OBJECT
+    Q_PROPERTY(QString descriptor READ get_descriptor WRITE set_descriptor RESET reset_descriptor STORED false)
+    Q_PROPERTY(int size READ get_size WRITE set_size RESET reset_size STORED false)
+    BR_PROPERTY(QString, descriptor, "SIFT")
+    BR_PROPERTY(int, size, -1)
+
+    Ptr<DescriptorExtractor> descriptorExtractor;
+
+    void init()
+    {
+        descriptorExtractor = DescriptorExtractor::create(descriptor.toStdString());
+        if (descriptorExtractor.empty())
+            qFatal("Failed to create DescriptorExtractor: %s", qPrintable(descriptor));
+    }
+
+    void project(const Template &src, Template &dst) const
+    {
+        std::vector<KeyPoint> keyPoints;
+        if (size == -1)
+            foreach (const QRectF &ROI, src.file.rects())
+                keyPoints.push_back(KeyPoint(ROI.x()+ROI.width()/2, ROI.y()+ROI.height()/2, (ROI.width() + ROI.height())/2));
+        else
+            foreach (const QPointF &landmark, src.file.points())
+                keyPoints.push_back(KeyPoint(landmark.x(), landmark.y(), size));
+        if (keyPoints.empty()) return;
+        descriptorExtractor->compute(src, keyPoints, dst);
+    }
+};
+
+BR_REGISTER(Transform, KeyPointDescriptorTransform)
+
+} // namespace br
+
+#include "imgproc/keypointdescriptor.moc"
diff --git a/openbr/plugins/imgproc/largestconvexarea.cpp b/openbr/plugins/imgproc/largestconvexarea.cpp
new file mode 100644
index 0000000..a28427c
--- /dev/null
+++ b/openbr/plugins/imgproc/largestconvexarea.cpp
@@ -0,0 +1,59 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * 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 transforms
+ * \brief Set the template's label to the area of the largest convex hull.
+ * \author Josh Klontz \cite jklontz
+ */
+class LargestConvexAreaTransform : public UntrainableTransform
+{
+    Q_OBJECT
+
+    Q_PROPERTY(QString outputVariable READ get_outputVariable WRITE set_outputVariable RESET reset_outputVariable STORED false)
+    BR_PROPERTY(QString, outputVariable, "Label")
+
+    void project(const Template &src, Template &dst) const
+    {
+        std::vector< std::vector<Point> > contours;
+        findContours(src.m().clone(), contours, CV_RETR_EXTERNAL, CV_CHAIN_APPROX_SIMPLE);
+        double maxArea = 0;
+        foreach (const std::vector<Point> &contour, contours) {
+            std::vector<Point> hull;
+            convexHull(contour, hull);
+            double area = contourArea(contour);
+            double hullArea = contourArea(hull);
+            if (area / hullArea > 0.98)
+                maxArea = std::max(maxArea, area);
+        }
+        dst.file.set(outputVariable, maxArea);
+    }
+};
+
+BR_REGISTER(Transform, LargestConvexAreaTransform)
+
+} // namespace br
+
+#include "imgproc/largestconvexarea.moc"
diff --git a/openbr/plugins/lbp.cpp b/openbr/plugins/imgproc/lbp.cpp
index b295286..ba96c65 100644
--- a/openbr/plugins/lbp.cpp
+++ b/openbr/plugins/imgproc/lbp.cpp
@@ -19,7 +19,8 @@
 #include <opencv2/highgui/highgui.hpp>
 #include <opencv2/highgui/highgui_c.h>
 #include <limits>
-#include "openbr_internal.h"
+
+#include <openbr/plugins/openbr_internal.h>
 
 using namespace cv;
 
@@ -46,8 +47,6 @@ class LBPTransform : public UntrainableTransform
     uchar lut[256];
     uchar null;
 
-    friend class ColoredU2Transform;
-
     /* Returns the number of 0->1 or 1->0 transitions in i */
     static int numTransitions(int i)
     {
@@ -125,74 +124,6 @@ class LBPTransform : public UntrainableTransform
 
 BR_REGISTER(Transform, LBPTransform)
 
-/*!
- * \ingroup transforms
- * \brief For visualization of LBP patterns.
- * \author Josh Klontz \cite jklontz
- */
-class ColoredU2Transform : public UntrainableTransform
-{
-    Q_OBJECT
-
-    /* Returns the number of 1 bits in i */
-    static int bitCount(int i)
-    {
-        int count = 0;
-        for (int j=0; j<8; j++)
-            count += (i>>j)%2;
-        return count;
-    }
-
-    void project(const Template &src, Template &dst) const
-    {
-        static Mat hueLUT, saturationLUT, valueLUT;
-
-        if (!hueLUT.data) {
-            const int NUM_COLORS = 10;
-            hueLUT.create(1, 256, CV_8UC1);
-            hueLUT.setTo(0);
-
-            uchar uid = 0;
-            for (int i=0; i<256; i++) {
-                const int transitions = LBPTransform::numTransitions(i);
-                int u2;
-                if   (transitions <= 2) u2 = uid++;
-                else                    u2 = 58;
-
-                // Assign hue based on bit count
-                int color = bitCount(i);
-                if (transitions > 2) color = NUM_COLORS-1;
-                hueLUT.at<uchar>(0, u2) = 255*color/NUM_COLORS;
-            }
-
-            saturationLUT.create(1, 256, CV_8UC1);
-            saturationLUT.setTo(255);
-
-            valueLUT.create(1, 256, CV_8UC1);
-            valueLUT.setTo(255*3/4);
-        }
-
-        if (src.m().type() != CV_8UC1)
-            qFatal("Expected 8UC1 source type.");
-
-        Mat hue, saturation, value;
-        LUT(src, hueLUT, hue);
-        LUT(src, saturationLUT, saturation);
-        LUT(src, valueLUT, value);
-
-        std::vector<Mat> mv;
-        mv.push_back(hue);
-        mv.push_back(saturation);
-        mv.push_back(value);
-
-        Mat coloredU2;
-        merge(mv, coloredU2);
-        cvtColor(coloredU2, dst, CV_HSV2BGR);
-    }
-};
-
-BR_REGISTER(Transform, ColoredU2Transform)
-
 } // namespace br
 
-#include "lbp.moc"
+#include "imgproc/lbp.moc"
diff --git a/openbr/plugins/imgproc/limitsize.cpp b/openbr/plugins/imgproc/limitsize.cpp
new file mode 100644
index 0000000..6e7bc49
--- /dev/null
+++ b/openbr/plugins/imgproc/limitsize.cpp
@@ -0,0 +1,53 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * 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 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)
+
+} // namespace br
+
+#include "imgproc/limitsize.moc"
diff --git a/openbr/plugins/ltp.cpp b/openbr/plugins/imgproc/ltp.cpp
index df34070..ac1a634 100644
--- a/openbr/plugins/ltp.cpp
+++ b/openbr/plugins/imgproc/ltp.cpp
@@ -17,7 +17,8 @@
 #include <opencv2/imgproc/imgproc.hpp>
 #include <opencv2/imgproc/imgproc_c.h>
 #include <limits>
-#include "openbr_internal.h"
+
+#include <openbr/plugins/openbr_internal.h>
 
 using namespace cv;
 
@@ -113,7 +114,6 @@ class LTPTransform : public UntrainableTransform
 
 BR_REGISTER(Transform, LTPTransform)
 
-
 } // namespace br
 
-#include "ltp.moc"
+#include "imgproc/ltp.moc"
diff --git a/openbr/plugins/imgproc/madd.cpp b/openbr/plugins/imgproc/madd.cpp
new file mode 100644
index 0000000..20b14e8
--- /dev/null
+++ b/openbr/plugins/imgproc/madd.cpp
@@ -0,0 +1,45 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * 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 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)
+
+} // namespace br
+
+#include "imgproc/madd.moc"
diff --git a/openbr/plugins/imgproc/mask.cpp b/openbr/plugins/imgproc/mask.cpp
new file mode 100644
index 0000000..b4408b0
--- /dev/null
+++ b/openbr/plugins/imgproc/mask.cpp
@@ -0,0 +1,49 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * 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 transforms
+ * \brief Applies an eliptical mask
+ * \author Josh Klontz \cite jklontz
+ */
+class MaskTransform : public UntrainableTransform
+{
+    Q_OBJECT
+
+    void project(const Template &src, Template &dst) const
+    {
+        const Mat &m = src;
+        Mat mask(m.size(), CV_8UC1);
+        mask.setTo(1);
+        const float SCALE = 1.1;
+        ellipse(mask, RotatedRect(Point2f(m.cols/2, m.rows/2), Size2f(SCALE*m.cols, SCALE*m.rows), 0), 0, -1);
+        dst = m.clone();
+        dst.m().setTo(0, mask);
+    }
+};
+
+BR_REGISTER(Transform, MaskTransform)
+
+} // namespace br
+
+#include "imgproc/mask.moc"
diff --git a/openbr/plugins/reduce.cpp b/openbr/plugins/imgproc/matstats.cpp
index 70b968e..0c979da 100644
--- a/openbr/plugins/reduce.cpp
+++ b/openbr/plugins/imgproc/matstats.cpp
@@ -14,7 +14,7 @@
  * limitations under the License.                                            *
  * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
 
-#include "openbr_internal.h"
+#include <openbr/plugins/openbr_internal.h>
 
 using namespace cv;
 
@@ -23,68 +23,10 @@ namespace br
 
 /*!
  * \ingroup transforms
- * \brief Subtract two matrices.
- * \author Josh Klontz \cite jklontz
- */
-class SubtractTransform : public UntrainableMetaTransform
-{
-    Q_OBJECT
-
-    void project(const Template &src, Template &dst) const
-    {
-        if (src.size() != 2) qFatal("Expected exactly two source images, got %d.", src.size());
-        dst.file = src.file;
-        subtract(src[0], src[1], dst);
-    }
-};
-
-BR_REGISTER(Transform, SubtractTransform)
-
-/*!
- * \ingroup transforms
- * \brief Take the absolute difference of two matrices.
- * \author Josh Klontz \cite jklontz
- */
-class AbsDiffTransform : public UntrainableMetaTransform
-{
-    Q_OBJECT
-
-    void project(const Template &src, Template &dst) const
-    {
-        if (src.size() != 2) qFatal("Expected exactly two source images, got %d.", src.size());
-        dst.file = src.file;
-        absdiff(src[0], src[1], dst);
-    }
-};
-
-BR_REGISTER(Transform, AbsDiffTransform)
-
-/*!
- * \ingroup transforms
- * \brief Logical AND of two matrices.
- * \author Josh Klontz \cite jklontz
- */
-class AndTransform : public UntrainableMetaTransform
-{
-    Q_OBJECT
-
-    void project(const Template &src, Template &dst) const
-    {
-        dst.file = src.file;
-        dst.m() = src.first();
-        for (int i=1; i<src.size(); i++)
-            bitwise_and(src[i], dst, dst);
-    }
-};
-
-BR_REGISTER(Transform, AndTransform)
-
-/*!
- * \ingroup transforms
  * \brief Statistics
  * \author Josh Klontz \cite jklontz
  */
-class StatTransform : public UntrainableTransform
+class MatStatsTransform : public UntrainableTransform
 {
     Q_OBJECT
     Q_ENUMS(Statistic)
@@ -117,36 +59,8 @@ private:
     }
 };
 
-BR_REGISTER(Transform, StatTransform)
-
-/*!
- * \ingroup transforms
- * \brief Downsample the rows and columns of a matrix.
- * \author Lacey Best-Rowden \cite lbestrowden
- */
-class DownsampleTransform : public UntrainableTransform
-{
-    Q_OBJECT
-    Q_PROPERTY(int k READ get_k WRITE set_k RESET reset_k STORED false)
-    BR_PROPERTY(int, k, 1)
-
-    void project(const Template &src, Template &dst) const
-    {
-        if (src.m().channels() != 1)
-            qFatal("Expected 1 channel matrix.");
-        Mat input = src.m();
-        Mat output(ceil((double)input.rows/k), ceil((double)input.cols/k), CV_32FC1);
-        for (int r=0; r<output.rows; r++) {
-            for (int c=0; c<output.cols; c++) {
-                output.at<float>(r,c) = input.at<float>(r*k,c*k);
-            }
-        }
-        dst.m() = output;
-    }
-};
-
-BR_REGISTER(Transform, DownsampleTransform)
+BR_REGISTER(Transform, MatStatsTransform)
 
 } // namespace br
 
-#include "reduce.moc"
+#include "imgproc/matstats.moc"
diff --git a/openbr/plugins/imgproc/mean.cpp b/openbr/plugins/imgproc/mean.cpp
new file mode 100644
index 0000000..3ee3351
--- /dev/null
+++ b/openbr/plugins/imgproc/mean.cpp
@@ -0,0 +1,61 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * 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 transforms
+ * \brief Computes the mean of a set of templates.
+ * \note Suitable for visualization only as it sets every projected template to the mean template.
+ * \author Scott Klum \cite sklum
+ */
+class MeanTransform : public Transform
+{
+    Q_OBJECT
+
+    Mat mean;
+
+    void train(const TemplateList &data)
+    {
+        mean = Mat::zeros(data[0].m().rows,data[0].m().cols,CV_32F);
+
+        for (int i = 0; i < data.size(); i++) {
+            Mat converted;
+            data[i].m().convertTo(converted, CV_32F);
+            mean += converted;
+        }
+
+        mean /= data.size();
+    }
+
+    void project(const Template &src, Template &dst) const
+    {
+        dst = src;
+        dst.m() = mean;
+    }
+
+};
+
+BR_REGISTER(Transform, MeanTransform)
+
+} // namespace br
+
+#include "imgproc/mean.moc"
diff --git a/openbr/plugins/imgproc/meanfill.cpp b/openbr/plugins/imgproc/meanfill.cpp
new file mode 100644
index 0000000..9e04090
--- /dev/null
+++ b/openbr/plugins/imgproc/meanfill.cpp
@@ -0,0 +1,44 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * 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 transforms
+ * \brief Fill 0 pixels with the mean of non-0 pixels.
+ * \author Josh Klontz \cite jklontz
+ */
+class MeanFillTransform : public UntrainableTransform
+{
+    Q_OBJECT
+
+    void project(const Template &src, Template &dst) const
+    {
+        dst = src.m().clone();
+        dst.m().setTo(mean(dst, dst.m()!=0), dst.m()==0);
+    }
+};
+
+BR_REGISTER(Transform, MeanFillTransform)
+
+} // namespace br
+
+#include "imgproc/meanfill.moc"
diff --git a/openbr/plugins/imgproc/merge.cpp b/openbr/plugins/imgproc/merge.cpp
new file mode 100644
index 0000000..ccd8110
--- /dev/null
+++ b/openbr/plugins/imgproc/merge.cpp
@@ -0,0 +1,47 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * 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 transforms
+ * \brief Wraps OpenCV merge
+ * \author Josh Klontz \cite jklontz
+ */
+class MergeTransform : public UntrainableMetaTransform
+{
+    Q_OBJECT
+
+    void project(const Template &src, Template &dst) const
+    {
+        dst.file = src.file;
+        std::vector<Mat> mv;
+        foreach (const Mat &m, src)
+            mv.push_back(m);
+        merge(mv, dst);
+    }
+};
+
+BR_REGISTER(Transform, MergeTransform)
+
+} // namespace br
+
+#include "imgproc/merge.moc"
diff --git a/openbr/plugins/imgproc/morph.cpp b/openbr/plugins/imgproc/morph.cpp
new file mode 100644
index 0000000..c563842
--- /dev/null
+++ b/openbr/plugins/imgproc/morph.cpp
@@ -0,0 +1,70 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * 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 transforms
+ * \brief Morphological operator
+ * \author Josh Klontz \cite jklontz
+ */
+class MorphTransform : public UntrainableTransform
+{
+    Q_OBJECT
+    Q_ENUMS(Op)
+    Q_PROPERTY(Op op READ get_op WRITE set_op RESET reset_op STORED false)
+    Q_PROPERTY(int radius READ get_radius WRITE set_radius RESET reset_radius STORED false)
+
+public:
+    /*!< */
+    enum Op { Erode = MORPH_ERODE,
+              Dilate = MORPH_DILATE,
+              Open = MORPH_OPEN,
+              Close = MORPH_CLOSE,
+              Gradient = MORPH_GRADIENT,
+              TopHat = MORPH_TOPHAT,
+              BlackHat = MORPH_BLACKHAT };
+
+private:
+    BR_PROPERTY(Op, op, Close)
+    BR_PROPERTY(int, radius, 1)
+
+    Mat kernel;
+
+    void init()
+    {
+        Mat kernel = Mat(radius, radius, CV_8UC1);
+        kernel.setTo(255);
+    }
+
+    void project(const Template &src, Template &dst) const
+    {
+        morphologyEx(src, dst, op, kernel);
+    }
+};
+
+BR_REGISTER(Transform, MorphTransform)
+
+} // namespace br
+
+#include "imgproc/morph.moc"
diff --git a/openbr/plugins/imgproc/multiscale.cpp b/openbr/plugins/imgproc/multiscale.cpp
new file mode 100644
index 0000000..35dd4dd
--- /dev/null
+++ b/openbr/plugins/imgproc/multiscale.cpp
@@ -0,0 +1,199 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * 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>
+#include <openbr/core/opencvutils.h>
+
+using namespace cv;
+
+namespace br
+{
+
+// Find avg aspect ratio
+static float getAspectRatio(const TemplateList &data)
+{
+    double tempRatio = 0;
+    int ratioCnt = 0;
+
+    foreach (const Template &tmpl, data) {
+        QList<Rect> posRects = OpenCVUtils::toRects(tmpl.file.rects());
+        foreach (const Rect &posRect, posRects) {
+            if (posRect.x + posRect.width >= tmpl.m().cols || posRect.y + posRect.height >= tmpl.m().rows || posRect.x < 0 || posRect.y < 0) {
+                continue;
+            }
+            tempRatio += (float)posRect.width / (float)posRect.height;
+            ratioCnt += 1;
+        }
+    }
+    return tempRatio / (double)ratioCnt;
+}
+
+static TemplateList cropTrainingSamples(const TemplateList &data, const float aspectRatio, const int minSize = 32, const float maxOverlap = 0.5, const int negToPosRatio = 1)
+{
+    TemplateList result;
+    foreach (const Template &tmpl, data) {
+        QList<Rect> posRects = OpenCVUtils::toRects(tmpl.file.rects());
+        QList<Rect> negRects;
+        for (int i=0; i<posRects.size(); i++) {
+            Rect &posRect = posRects[i];
+
+            // Adjust for training samples that have different aspect ratios
+            const int diff = int(posRect.height * aspectRatio) - posRect.width;
+            posRect.x -= diff / 2;
+            posRect.width += diff;
+
+            // Ignore samples larger than the image
+            if ((posRect.x + posRect.width >= tmpl.m().cols) ||
+                (posRect.y + posRect.height >= tmpl.m().rows) ||
+                (posRect.x < 0) ||
+                (posRect.y < 0))
+                continue;
+
+            result += Template(tmpl.file, Mat(tmpl, posRect));
+            result.last().file.set("Label", QString("pos"));
+
+            // Add random negative samples
+            Mat m = tmpl.m();
+            int sample = 0;
+            while (sample < negToPosRatio) {
+                const int x = rand() % m.cols;
+                const int y = rand() % m.rows;
+                const int maxWidth = m.cols - x;
+                const int maxHeight = m.rows - y;
+                if (maxWidth <= minSize || maxHeight <= minSize)
+                    continue;
+
+                int height;
+                int width;
+                if (aspectRatio > (float) maxWidth / (float) maxHeight) {
+                    width = rand() % (maxWidth - minSize) + minSize;
+                    height = qRound(width / aspectRatio);
+                } else {
+                    height = rand() % (maxHeight - minSize) + minSize;
+                    width = qRound(height * aspectRatio);
+                }
+                Rect negRect(x, y, width, height);
+
+                // The negative samples cannot overlap the positive samples at
+                // all, but they may partially overlap with other negatives.
+                if (OpenCVUtils::overlaps(posRects, negRect, 0) ||
+                    OpenCVUtils::overlaps(negRects, negRect, maxOverlap))
+                    continue;
+
+                result += Template(tmpl.file, Mat(tmpl, negRect));
+                result.last().file.set("Label", QString("neg"));
+                sample++;
+            }
+        }
+    }
+
+    return result;
+}
+
+/*!
+ * \ingroup transforms
+ * \brief Document me
+ * \author Austin Blanton \cite imaus10
+ */
+class BuildScalesTransform : public Transform
+{
+    Q_OBJECT
+    Q_PROPERTY(br::Transform *transform READ get_transform WRITE set_transform RESET reset_transform STORED false)
+    Q_PROPERTY(double scaleFactor READ get_scaleFactor WRITE set_scaleFactor RESET reset_scaleFactor STORED false)
+    Q_PROPERTY(bool takeLargestScale READ get_takeLargestScale WRITE set_takeLargestScale RESET reset_takeLargestScale STORED false)
+    Q_PROPERTY(int windowWidth READ get_windowWidth WRITE set_windowWidth RESET reset_windowWidth STORED false)
+    Q_PROPERTY(int negToPosRatio READ get_negToPosRatio WRITE set_negToPosRatio RESET reset_negToPosRatio STORED false)
+    Q_PROPERTY(int minSize READ get_minSize WRITE set_minSize RESET reset_minSize STORED false)
+    Q_PROPERTY(double maxOverlap READ get_maxOverlap WRITE set_maxOverlap RESET reset_maxOverlap STORED false)
+    Q_PROPERTY(float minScale READ get_minScale WRITE set_minScale RESET reset_minScale STORED false)
+    BR_PROPERTY(br::Transform *, transform, NULL)
+    BR_PROPERTY(double, scaleFactor, 0.75)
+    BR_PROPERTY(bool, takeLargestScale, false)
+    BR_PROPERTY(int, windowWidth, 24)
+    BR_PROPERTY(int, negToPosRatio, 1)
+    BR_PROPERTY(int, minSize, 8)
+    BR_PROPERTY(double, maxOverlap, 0)
+    BR_PROPERTY(float, minScale, 1.0)
+
+private:
+    float aspectRatio;
+    int windowHeight;
+    bool skipProject;
+
+    void train(const TemplateList &data)
+    {
+        skipProject = true;
+        aspectRatio = getAspectRatio(data);
+        windowHeight = qRound(windowWidth / aspectRatio);
+        if (transform->trainable) {
+            TemplateList full;
+            foreach (const Template &roi, cropTrainingSamples(data, aspectRatio, minSize, maxOverlap, negToPosRatio)) {
+                Mat resized;
+                resize(roi, resized, Size(windowWidth, windowHeight));
+                full += Template(roi.file, resized);
+            }
+            full.first().file.set("aspectRatio", aspectRatio);
+            transform->train(full);
+        }
+    }
+
+    void project(const Template &src, Template &dst) const
+    {
+        dst = src;
+        if (skipProject) {
+            dst = src;
+            return;
+        }
+
+        int rows = src.m().rows;
+        int cols = src.m().cols;
+        int windowHeight = (int) qRound((float) windowWidth / aspectRatio);
+
+        float startScale;
+        if ((cols / rows) > aspectRatio)
+            startScale = qRound((float) rows / (float) windowHeight);
+        else
+            startScale = qRound((float) cols / (float) windowWidth);
+
+        for (float scale = startScale; scale >= minScale; scale -= (1.0 - scaleFactor)) {
+            Template scaleImg(dst.file, Mat());
+            scaleImg.file.set("scale", scale);
+            resize(src, scaleImg, Size(qRound(cols / scale), qRound(rows / scale)));
+            transform->project(scaleImg, dst);
+            if (takeLargestScale && !dst.file.rects().empty())
+                return;
+        }
+    }
+
+    void store(QDataStream &stream) const
+    {
+        transform->store(stream);
+        stream << aspectRatio << windowHeight;
+    }
+    void load(QDataStream &stream)
+    {
+        transform->load(stream);
+        stream >> aspectRatio >> windowHeight;
+    }
+};
+
+BR_REGISTER(Transform, BuildScalesTransform)
+
+} // namespace br
+
+#include "imgproc/multiscale.moc"
diff --git a/openbr/plugins/imgproc/normalize.cpp b/openbr/plugins/imgproc/normalize.cpp
new file mode 100644
index 0000000..f319cac
--- /dev/null
+++ b/openbr/plugins/imgproc/normalize.cpp
@@ -0,0 +1,89 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * 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 transforms
+ * \brief Normalize matrix to unit length
+ * \author Josh Klontz \cite jklontz
+ */
+class NormalizeTransform : public UntrainableTransform
+{
+    Q_OBJECT
+    Q_ENUMS(NormType)
+    Q_PROPERTY(NormType normType READ get_normType WRITE set_normType RESET reset_normType STORED false)
+
+    Q_PROPERTY(bool ByRow READ get_ByRow WRITE set_ByRow RESET reset_ByRow STORED false)
+    BR_PROPERTY(bool, ByRow, false)
+    Q_PROPERTY(int alpha READ get_alpha WRITE set_alpha RESET reset_alpha STORED false)
+    BR_PROPERTY(int, alpha, 1)
+    Q_PROPERTY(int beta READ get_beta WRITE set_beta RESET reset_beta STORED false)
+    BR_PROPERTY(int, beta, 0)
+    Q_PROPERTY(bool squareRoot READ get_squareRoot WRITE set_squareRoot RESET reset_squareRoot STORED false)
+    BR_PROPERTY(bool, squareRoot, false)
+
+public:
+    /*!< */
+    enum NormType { Inf = NORM_INF,
+                    L1 = NORM_L1,
+                    L2 = NORM_L2,
+                    Range = NORM_MINMAX };
+
+private:
+    BR_PROPERTY(NormType, normType, L2)
+
+    static void signedSquareRoot(Mat &m)
+    {
+        for (int i=0; i<m.rows; i++)
+            for (int j=0; j<m.cols; j++) {
+                float &val = m.at<float>(i, j);
+                val = sqrtf(fabsf(val)) * (val >= 0 ? 1 : -1);
+            }
+    }
+
+    void project(const Template &src, Template &dst) const
+    {
+        if (!ByRow) {
+            normalize(src, dst, alpha, beta, normType, CV_32F);
+            if (squareRoot)
+                signedSquareRoot(dst);
+        }
+
+        else {
+            dst = src;
+            for (int i=0; i<dst.m().rows; i++) {
+                Mat temp;
+                normalize(dst.m().row(i), temp, alpha, beta, normType);
+                if (squareRoot)
+                    signedSquareRoot(temp);
+                temp.copyTo(dst.m().row(i));
+            }
+        }
+
+    }
+};
+
+BR_REGISTER(Transform, NormalizeTransform)
+
+} // namespace br
+
+#include "imgproc/normalize.moc"
diff --git a/openbr/plugins/synthetic.cpp b/openbr/plugins/imgproc/origlinearregression.cpp
index 96af658..eec1063 100644
--- a/openbr/plugins/synthetic.cpp
+++ b/openbr/plugins/imgproc/origlinearregression.cpp
@@ -14,10 +14,7 @@
  * limitations under the License.                                            *
  * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
 
-#include <opencv2/imgproc/imgproc.hpp>
-#include "openbr_internal.h"
-
-#include "openbr/core/opencvutils.h"
+#include <openbr/plugins/openbr_internal.h>
 
 using namespace cv;
 
@@ -26,42 +23,6 @@ namespace br
 
 /*!
  * \ingroup transforms
- * \brief Prediction using only the red wavelength; magic numbers from jmp
- * \author E. Taborsky \cite mmtaborsky
- */
-class RedLinearRegressionTransform : public UntrainableTransform
-{
-    Q_OBJECT
-
-    void project(const Template &src, Template &dst) const
-    {
-        Mat m; src[0].convertTo(m, CV_32F); assert(m.isContinuous() && (m.channels() == 1));
-
-        const float rmult = .6533673;
-        const float add = 41.268;
-
-        Mat dst1(m.size(), CV_32F);
-        int rows = m.rows;
-        int cols = m.cols;
-
-        const float *rsrc = (const float*) m.ptr();
-        float *p = (float*)dst1.ptr();
-
-        for (int r = 0; r < rows; r++){
-            for (int c = 0; c < cols; c++){
-                int index = r*cols+c;
-                const float rval = rsrc[index];
-                p[index] = rval*rmult+add;
-            }
-        }
-        dst = dst1;
-    }
-};
-
-BR_REGISTER(Transform, RedLinearRegressionTransform)
-
-/*!
- * \ingroup transforms
  * \brief Prediction with magic numbers from jmp; must get input as blue;green;red
  * \author E. Taborsky \cite mmtaborsky
  */
@@ -100,4 +61,4 @@ BR_REGISTER(Transform, OrigLinearRegressionTransform)
 
 } // namespace br
 
-#include "synthetic.moc"
+#include "imgproc/origlinearregression.moc"
diff --git a/openbr/plugins/imgproc/pack.cpp b/openbr/plugins/imgproc/pack.cpp
new file mode 100644
index 0000000..9954af3
--- /dev/null
+++ b/openbr/plugins/imgproc/pack.cpp
@@ -0,0 +1,52 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * 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 transforms
+ * \brief Compress two uchar into one uchar.
+ * \author Josh Klontz \cite jklontz
+ */
+class PackTransform : public UntrainableTransform
+{
+    Q_OBJECT
+
+    void project(const Template &src, Template &dst) const
+    {
+        const Mat &m = src;
+        if ((m.cols % 2 != 0) || (m.type() != CV_8UC1))
+            qFatal("Invalid template format.");
+
+        Mat n(m.rows, m.cols/2, CV_8UC1);
+        for (int i=0; i<m.rows; i++)
+            for (int j=0; j<m.cols/2; j++)
+                n.at<uchar>(i,j) = ((m.at<uchar>(i,2*j+0) >> 4) << 4) +
+                                   ((m.at<uchar>(i,2*j+1) >> 4) << 0);
+        dst = n;
+    }
+};
+
+BR_REGISTER(Transform, PackTransform)
+
+} // namespace br
+
+#include "imgproc/pack.moc"
diff --git a/openbr/plugins/imgproc/pow.cpp b/openbr/plugins/imgproc/pow.cpp
new file mode 100644
index 0000000..bac409a
--- /dev/null
+++ b/openbr/plugins/imgproc/pow.cpp
@@ -0,0 +1,48 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * 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 transforms
+ * \brief Raise each element to the specified power.
+ * \author Josh Klontz \cite jklontz
+ */
+class PowTransform : public UntrainableTransform
+{
+    Q_OBJECT
+    Q_PROPERTY(float power READ get_power WRITE set_power RESET reset_power STORED false)
+    Q_PROPERTY(bool preserveSign READ get_preserveSign WRITE set_preserveSign RESET reset_preserveSign STORED false)
+    BR_PROPERTY(float, power, 2)
+    BR_PROPERTY(bool, preserveSign, false)
+
+    void project(const Template &src, Template &dst) const
+    {
+        pow(preserveSign ? abs(src) : src.m(), power, dst);
+        if (preserveSign) subtract(Scalar::all(0), dst, dst, src.m() < 0);
+    }
+};
+
+BR_REGISTER(Transform, PowTransform)
+
+} // namespace br
+
+#include "imgproc/pow.moc"
diff --git a/openbr/plugins/imgproc/productquantization.cpp b/openbr/plugins/imgproc/productquantization.cpp
new file mode 100644
index 0000000..6cc1b4b
--- /dev/null
+++ b/openbr/plugins/imgproc/productquantization.cpp
@@ -0,0 +1,279 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * 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>
+#include <openbr/core/opencvutils.h>
+
+using namespace cv;
+
+namespace br
+{
+
+QVector<Mat> ProductQuantizationLUTs;
+
+/*!
+ * \ingroup distances
+ * \brief Distance in a product quantized space \cite jegou11
+ * \author Josh Klontz \cite jklontz
+ */
+class ProductQuantizationDistance : public UntrainableDistance
+{
+    Q_OBJECT
+    Q_PROPERTY(bool bayesian READ get_bayesian WRITE set_bayesian RESET reset_bayesian STORED false)
+    BR_PROPERTY(bool, bayesian, false)
+
+    float compare(const Template &a, const Template &b) const
+    {
+        float distance = 0;
+        for (int i=0; i<a.size(); i++) {
+            const int elements = a[i].total()-sizeof(quint16);
+            uchar *aData = a[i].data;
+            uchar *bData = b[i].data;
+            quint16 index = *reinterpret_cast<quint16*>(aData);
+            aData += sizeof(quint16);
+            bData += sizeof(quint16);
+
+            const float *lut = (const float*)ProductQuantizationLUTs[index].data;
+            for (int j=0; j<elements; j++)
+            {
+                const int aj = aData[j];
+                const int bj = bData[j];
+                // http://stackoverflow.com/questions/4803180/mapping-elements-in-2d-upper-triangle-and-lower-triangle-to-linear-structure
+                const int y = max(aj, bj);
+                const int x = min(aj, bj);
+                distance += lut[j*256*(256+1)/2 + x + (y+1)*y/2];
+            }
+        }
+        if (!bayesian) distance = -log(distance+1);
+        return distance;
+    }
+};
+
+BR_REGISTER(Distance, ProductQuantizationDistance)
+
+/*!
+ * \ingroup transforms
+ * \brief Product quantization \cite jegou11
+ * \author Josh Klontz \cite jklontz
+ */
+class ProductQuantizationTransform : public Transform
+{
+    Q_OBJECT
+    Q_PROPERTY(int n READ get_n WRITE set_n RESET reset_n STORED false)
+    Q_PROPERTY(br::Distance *distance READ get_distance WRITE set_distance RESET reset_distance STORED false)
+    Q_PROPERTY(bool bayesian READ get_bayesian WRITE set_bayesian RESET reset_bayesian STORED false)
+    Q_PROPERTY(QString inputVariable READ get_inputVariable WRITE set_inputVariable RESET reset_inputVariable STORED false)
+    BR_PROPERTY(int, n, 2)
+    BR_PROPERTY(br::Distance*, distance, Distance::make("L2", this))
+    BR_PROPERTY(bool, bayesian, false)
+    BR_PROPERTY(QString, inputVariable, "Label")
+
+    quint16 index;
+    QList<Mat> centers;
+
+public:
+    ProductQuantizationTransform()
+    {
+        if (ProductQuantizationLUTs.size() > std::numeric_limits<quint16>::max())
+            qFatal("Out of LUT space!"); // Unlikely
+
+        static QMutex mutex;
+        QMutexLocker locker(&mutex);
+        index = ProductQuantizationLUTs.size();
+        ProductQuantizationLUTs.append(Mat());
+    }
+
+private:
+//    static double denseKernelDensityBandwidth(const Mat &lut, const Mat &occurences)
+//    {
+//        double total = 0;
+//        int n = 0;
+//        const qint32 *occurencesData = (qint32*)occurences.data;
+//        const float *lutData = (float*)lut.data;
+//        for (int i=0; i<256; i++)
+//            for (int j=i; j<256; j++) {
+//                total += occurencesData[i*256+j] * lutData[i*256+j];
+//                n += occurencesData[i*256+j];
+//            }
+//        const double mean = total/n;
+
+//        double variance = 0;
+//        for (int i=0; i<lut.rows; i++)
+//            for (int j=i; j<lut.cols; j++)
+//                variance += occurencesData[i*256+j] * pow(lutData[i*256+j]-mean, 2.0);
+
+//        return pow(4 * pow(sqrt(variance/n), 5.0) / (3*n), 0.2);
+//    }
+
+//    static double denseKernelDensityEstimation(const Mat &lut, const Mat &occurences, const float x, const float h)
+//    {
+//        double y = 0;
+//        int n = 0;
+//        const qint32 *occurencesData = (qint32*)occurences.data;
+//        const float *lutData = (float*)lut.data;
+//        for (int i=0; i<256; i++)
+//            for (int j=i; j<256; j++) {
+//                const int n_ij = occurencesData[i*256+j];
+//                if (n_ij > 0) {
+//                    y += n_ij * exp(-pow((lutData[i*256+j]-x)/h,2)/2)/2.50662826737 /*sqrt(2*3.1415926353898)*/;
+//                    n += n_ij;
+//                }
+//            }
+//        return y / (n*h);
+//    }
+
+    void _train(const Mat &data, const QList<int> &labels, Mat *lut, Mat *center)
+    {
+        Mat clusterLabels;
+        kmeans(data, 256, clusterLabels, TermCriteria(TermCriteria::MAX_ITER, 10, 0), 3, KMEANS_PP_CENTERS, *center);
+
+        Mat fullLUT(1, 256*256, CV_32FC1);
+        for (int i=0; i<256; i++)
+            for (int j=0; j<256; j++)
+                fullLUT.at<float>(0,i*256+j) = distance->compare(center->row(i), center->row(j));
+
+        if (bayesian) {
+            QList<int> indicies = OpenCVUtils::matrixToVector<int>(clusterLabels);
+            QVector<float> genuineScores, impostorScores;
+            genuineScores.reserve(indicies.size());
+            impostorScores.reserve(indicies.size()*indicies.size()/2);
+            for (int i=0; i<indicies.size(); i++)
+                for (int j=i+1; j<indicies.size(); j++) {
+                    const float score = fullLUT.at<float>(0, indicies[i]*256+indicies[j]);
+                    if (labels[i] == labels[j]) genuineScores.append(score);
+                    else                        impostorScores.append(score);
+                }
+
+            genuineScores = Common::Downsample(genuineScores, 256);
+            impostorScores = Common::Downsample(impostorScores, 256);
+            const double hGenuine = Common::KernelDensityBandwidth(genuineScores);
+            const double hImpostor = Common::KernelDensityBandwidth(impostorScores);
+
+            for (int i=0; i<256; i++)
+                for (int j=i; j<256; j++) {
+                    const float loglikelihood = log(Common::KernelDensityEstimation(genuineScores, fullLUT.at<float>(0,i*256+j), hGenuine) /
+                                                    Common::KernelDensityEstimation(impostorScores, fullLUT.at<float>(0,i*256+j), hImpostor));
+                    fullLUT.at<float>(0,i*256+j) = loglikelihood;
+                    fullLUT.at<float>(0,j*256+i) = loglikelihood;
+                }
+        }
+
+        // Compress LUT into one dimensional array
+        int index = 0;
+        for (int i=0; i<256; i++)
+            for (int j=0; j<=i; j++) {
+                lut->at<float>(0,index) = fullLUT.at<float>(0,i*256+j);
+                index++;
+            }
+        if (index != lut->cols)
+            qFatal("Logic error.");
+    }
+
+    int getStep(int cols) const
+    {
+        if (n > 0) return n;
+        if (n == 0) return cols;
+        return ceil(float(cols)/abs(n));
+    }
+
+    int getOffset(int cols) const
+    {
+        if (n >= 0) return 0;
+        const int step = getStep(cols);
+        return (step - cols%step) % step;
+    }
+
+    int getDims(int cols) const
+    {
+        const int step = getStep(cols);
+        if (n >= 0) return cols/step;
+        return ceil(float(cols)/step);
+    }
+
+    void train(const TemplateList &src)
+    {
+        Mat data = OpenCVUtils::toMat(src.data());
+        const int step = getStep(data.cols);
+
+        const QList<int> labels = src.indexProperty(inputVariable);
+
+        Mat &lut = ProductQuantizationLUTs[index];
+        lut = Mat(getDims(data.cols), 256*(256+1)/2, CV_32FC1);
+
+        QList<Mat> subdata, subluts;
+        const int offset = getOffset(data.cols);
+        for (int i=0; i<lut.rows; i++) {
+            centers.append(Mat());
+            subdata.append(data.colRange(max(0, i*step-offset), (i+1)*step-offset));
+            subluts.append(lut.row(i));
+        }
+
+        QFutureSynchronizer<void> futures;
+        for (int i=0; i<lut.rows; i++) {
+            if (Globals->parallelism) futures.addFuture(QtConcurrent::run(this, &ProductQuantizationTransform::_train, subdata[i], labels, &subluts[i], &centers[i]));
+            else                                                                                               _train (subdata[i], labels, &subluts[i], &centers[i]);
+        }
+        futures.waitForFinished();
+    }
+
+    int getIndex(const Mat &m, const Mat &center) const
+    {
+        int bestIndex = 0;
+        double bestDistance = std::numeric_limits<double>::max();
+        for (int j=0; j<256; j++) {
+            double distance = norm(m, center.row(j), NORM_L2);
+            if (distance < bestDistance) {
+                bestDistance = distance;
+                bestIndex = j;
+            }
+        }
+        return bestIndex;
+    }
+
+    void project(const Template &src, Template &dst) const
+    {
+        Mat m = src.m().reshape(1, 1);
+        const int step = getStep(m.cols);
+        const int offset = getOffset(m.cols);
+        const int dims = getDims(m.cols);
+        dst = Mat(1, sizeof(quint16)+dims, CV_8UC1);
+        memcpy(dst.m().data, &index, sizeof(quint16));
+        for (int i=0; i<dims; i++)
+            dst.m().at<uchar>(0,sizeof(quint16)+i) = getIndex(m.colRange(max(0, i*step-offset), (i+1)*step-offset), centers[i]);
+    }
+
+    void store(QDataStream &stream) const
+    {
+        stream << index << centers << ProductQuantizationLUTs[index];
+    }
+
+    void load(QDataStream &stream)
+    {
+        stream >> index >> centers;
+        while (ProductQuantizationLUTs.size() <= index)
+            ProductQuantizationLUTs.append(Mat());
+        stream >> ProductQuantizationLUTs[index];
+    }
+};
+
+BR_REGISTER(Transform, ProductQuantizationTransform)
+
+} // namespace br
+
+#include "imgproc/productquantization.moc"
diff --git a/openbr/plugins/imgproc/quantize.cpp b/openbr/plugins/imgproc/quantize.cpp
new file mode 100644
index 0000000..9ae313f
--- /dev/null
+++ b/openbr/plugins/imgproc/quantize.cpp
@@ -0,0 +1,56 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * 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 Approximate floats as uchar.
+ * \author Josh Klontz \cite jklontz
+ */
+class QuantizeTransform : public Transform
+{
+    Q_OBJECT
+    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)
+    BR_PROPERTY(float, a, 1)
+    BR_PROPERTY(float, b, 0)
+
+    void train(const TemplateList &data)
+    {
+        double minVal, maxVal;
+        minMaxLoc(OpenCVUtils::toMat(data.data()), &minVal, &maxVal);
+        a = 255.0/(maxVal-minVal);
+        b = -a*minVal;
+    }
+
+    void project(const Template &src, Template &dst) const
+    {
+        src.m().convertTo(dst, CV_8U, a, b);
+    }
+};
+
+BR_REGISTER(Transform, QuantizeTransform)
+
+} // namespace br
+
+#include "imgproc/quantize.moc"
diff --git a/openbr/plugins/imgproc/rank.cpp b/openbr/plugins/imgproc/rank.cpp
new file mode 100644
index 0000000..0e32dec
--- /dev/null
+++ b/openbr/plugins/imgproc/rank.cpp
@@ -0,0 +1,60 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * 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>
+#include <openbr/core/opencvutils.h>
+
+using namespace cv;
+
+namespace br
+{
+
+/*!
+ * \ingroup transforms
+ * \brief Converts each element to its rank-ordered value.
+ * \author Josh Klontz \cite jklontz
+ */
+class RankTransform : public UntrainableTransform
+{
+    Q_OBJECT
+
+    void project(const Template &src, Template &dst) const
+    {
+        const Mat &m = src;
+        assert(m.channels() == 1);
+        dst = Mat(m.rows, m.cols, CV_32FC1);
+        typedef QPair<float,int> Tuple;
+        QList<Tuple> tuples = Common::Sort(OpenCVUtils::matrixToVector<float>(m));
+
+        float prevValue = 0;
+        int prevRank = 0;
+        for (int i=0; i<tuples.size(); i++) {
+            int rank;
+            if (tuples[i].first == prevValue) rank = prevRank;
+            else                              rank = i;
+            dst.m().at<float>(tuples[i].second / m.cols, tuples[i].second % m.cols) = rank;
+            prevValue = tuples[i].first;
+            prevRank = rank;
+        }
+    }
+};
+
+BR_REGISTER(Transform, RankTransform)
+
+} // namespace br
+
+#include "imgproc/rank.moc"
diff --git a/openbr/plugins/imgproc/rectregions.cpp b/openbr/plugins/imgproc/rectregions.cpp
new file mode 100644
index 0000000..7a41eed
--- /dev/null
+++ b/openbr/plugins/imgproc/rectregions.cpp
@@ -0,0 +1,58 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * 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 transforms
+ * \brief Subdivide matrix into rectangular subregions.
+ * \author Josh Klontz \cite jklontz
+ */
+class RectRegionsTransform : 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)
+    Q_PROPERTY(int widthStep READ get_widthStep WRITE set_widthStep RESET reset_widthStep STORED false)
+    Q_PROPERTY(int heightStep READ get_heightStep WRITE set_heightStep RESET reset_heightStep STORED false)
+    BR_PROPERTY(int, width, 8)
+    BR_PROPERTY(int, height, 8)
+    BR_PROPERTY(int, widthStep, -1)
+    BR_PROPERTY(int, heightStep, -1)
+
+    void project(const Template &src, Template &dst) const
+    {
+        const int widthStep = this->widthStep == -1 ? width : this->widthStep;
+        const int heightStep = this->heightStep == -1 ? height : this->heightStep;
+        const Mat &m = src;
+        const int xMax = m.cols - width;
+        const int yMax = m.rows - height;
+        for (int x=0; x <= xMax; x += widthStep)
+            for (int y=0; y <= yMax; y += heightStep)
+                dst += m(Rect(x, y, width, height));
+    }
+};
+
+BR_REGISTER(Transform, RectRegionsTransform)
+
+} // namespace br
+
+#include "imgproc/rectregions.moc"
diff --git a/openbr/plugins/imgproc/recursiveintegralsampler.cpp b/openbr/plugins/imgproc/recursiveintegralsampler.cpp
new file mode 100644
index 0000000..24703f4
--- /dev/null
+++ b/openbr/plugins/imgproc/recursiveintegralsampler.cpp
@@ -0,0 +1,178 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * 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>
+
+using namespace cv;
+
+namespace br
+{
+
+/*!
+ * \ingroup transforms
+ * \brief Construct template in a recursive decent manner.
+ * \author Josh Klontz \cite jklontz
+ */
+class RecursiveIntegralSamplerTransform : public Transform
+{
+    Q_OBJECT
+    Q_PROPERTY(int scales READ get_scales WRITE set_scales RESET reset_scales STORED false)
+    Q_PROPERTY(float scaleFactor READ get_scaleFactor WRITE set_scaleFactor RESET reset_scaleFactor STORED false)
+    Q_PROPERTY(int minSize READ get_minSize WRITE set_minSize RESET reset_minSize STORED false)
+    Q_PROPERTY(br::Transform *transform READ get_transform WRITE set_transform RESET reset_transform)
+    BR_PROPERTY(int, scales, 6)
+    BR_PROPERTY(float, scaleFactor, 2)
+    BR_PROPERTY(int, minSize, 8)
+    BR_PROPERTY(br::Transform*, transform, NULL)
+
+    Transform *subTransform;
+
+    typedef Eigen::Map< const Eigen::Matrix<qint32,Eigen::Dynamic,1> > InputDescriptor;
+    typedef Eigen::Map< Eigen::Matrix<float,Eigen::Dynamic,1> > OutputDescriptor;
+    typedef Eigen::Map< const Eigen::Matrix<float,Eigen::Dynamic,1> > SecondOrderInputDescriptor;
+
+    void init()
+    {
+        if (scales >= 2) {
+            File subFile = file;
+            subFile.set("scales", scales-1);
+            subTransform = make(subFile.flat());
+        } else {
+            subTransform = NULL;
+        }
+    }
+
+    static void integralHistogram(const Mat &src, const int x, const int y, const int width, const int height, Mat &dst, int index)
+    {
+        const int channels = src.channels();
+        OutputDescriptor(dst.ptr<float>(index), channels, 1) =
+            (  InputDescriptor(src.ptr<qint32>(y+height, x+width), channels, 1)
+             - InputDescriptor(src.ptr<qint32>(y,        x+width), channels, 1)
+             - InputDescriptor(src.ptr<qint32>(y+height, x),       channels, 1)
+             + InputDescriptor(src.ptr<qint32>(y,        x),       channels, 1)).cast<float>()/(height*width);
+    }
+
+    void computeDescriptor(const Mat &src, Mat &dst) const
+    {
+        const int channels = src.channels();
+        const int rows = src.rows-1; // Integral images have an extra row and column
+        const int columns = src.cols-1;
+
+        Mat tmp(5, channels, CV_32FC1);
+        integralHistogram(src,         0,      0, columns/2, rows/2, tmp, 0);
+        integralHistogram(src, columns/2,      0, columns/2, rows/2, tmp, 1);
+        integralHistogram(src,         0, rows/2, columns/2, rows/2, tmp, 2);
+        integralHistogram(src, columns/2, rows/2, columns/2, rows/2, tmp, 3);
+        integralHistogram(src, columns/4, rows/4, columns/2, rows/2, tmp, 4);
+        const SecondOrderInputDescriptor a(tmp.ptr<float>(0), channels, 1);
+        const SecondOrderInputDescriptor b(tmp.ptr<float>(1), channels, 1);
+        const SecondOrderInputDescriptor c(tmp.ptr<float>(2), channels, 1);
+        const SecondOrderInputDescriptor d(tmp.ptr<float>(3), channels, 1);
+        const SecondOrderInputDescriptor e(tmp.ptr<float>(4), channels, 1);
+
+        dst = Mat(5, channels, CV_32FC1);
+        OutputDescriptor(dst.ptr<float>(0), channels, 1) = (a+b+c+d)/4.f;
+        OutputDescriptor(dst.ptr<float>(1), channels, 1) = ((a+b+c+d)/4.f-e);
+        OutputDescriptor(dst.ptr<float>(2), channels, 1) = ((a+b)-(c+d))/2.f;
+        OutputDescriptor(dst.ptr<float>(3), channels, 1) = ((a+c)-(b+d))/2.f;
+        OutputDescriptor(dst.ptr<float>(4), channels, 1) = ((a+d)-(b+c))/2.f;
+        dst = dst.reshape(1, 1);
+    }
+
+    Template subdivide(const Template &src) const
+    {
+        // Integral images have an extra row and column
+        int subWidth = (src.m().cols-1) / scaleFactor + 1;
+        int subHeight = (src.m().rows-1) / scaleFactor + 1;
+        return Template(src.file, QList<Mat>() << Mat(src, Rect(0,                     0, subWidth, subHeight))
+                                               << Mat(src, Rect(src.m().cols-subWidth, 0, subWidth, subHeight))
+                                               << Mat(src, Rect(0,                     src.m().rows-subHeight, subWidth, subHeight))
+                                               << Mat(src, Rect(src.m().cols-subWidth, src.m().rows-subHeight, subWidth, subHeight)));
+    }
+
+    bool canSubdivide(const Template &t) const
+    {
+        // Integral images have an extra row and column
+        const int subWidth = (t.m().cols-1) / scaleFactor;
+        const int subHeight = (t.m().rows-1) / scaleFactor;
+        return ((subWidth >= minSize) && (subHeight >= minSize));
+    }
+
+    void train(const TemplateList &src)
+    {
+        if (src.first().m().depth() != CV_32S)
+            qFatal("Expected CV_32S depth!");
+
+        if (subTransform != NULL) {
+            TemplateList subSrc; subSrc.reserve(src.size());
+            foreach (const Template &t, src)
+                if (canSubdivide(t))
+                    subSrc.append(subdivide(t));
+
+            if (subSrc.isEmpty()) {
+                delete subTransform;
+                subTransform = NULL;
+            } else {
+                subTransform->train(subSrc);
+            }
+        }
+
+        TemplateList dst; dst.reserve(src.size());
+        foreach (const Template &t, src) {
+            Template u(t.file);
+            computeDescriptor(t, u);
+            dst.append(u);
+        }
+        transform->train(dst);
+    }
+
+    void project(const Template &src, Template &dst) const
+    {
+        computeDescriptor(src, dst);
+        transform->project(dst, dst);
+
+        if ((subTransform != NULL) && canSubdivide(src)) {
+            Template subDst;
+            subTransform->project(subdivide(src), subDst);
+            dst.append(subDst);
+        }
+    }
+
+    void store(QDataStream &stream) const
+    {
+        transform->store(stream);
+        stream << (subTransform != NULL);
+        if (subTransform != NULL)
+            subTransform->store(stream);
+    }
+
+    void load(QDataStream &stream)
+    {
+        transform->load(stream);
+        bool hasSubTransform;
+        stream >> hasSubTransform;
+        if (hasSubTransform) subTransform->load(stream);
+        else                 { delete subTransform; subTransform = NULL; }
+    }
+};
+
+BR_REGISTER(Transform, RecursiveIntegralSamplerTransform)
+
+} // namespace br
+
+#include "imgproc/recursiveintegralsampler.moc"
diff --git a/openbr/plugins/imgproc/redlinearregression.cpp b/openbr/plugins/imgproc/redlinearregression.cpp
new file mode 100644
index 0000000..e49674d
--- /dev/null
+++ b/openbr/plugins/imgproc/redlinearregression.cpp
@@ -0,0 +1,62 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * 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 transforms
+ * \brief Prediction using only the red wavelength; magic numbers from jmp
+ * \author E. Taborsky \cite mmtaborsky
+ */
+class RedLinearRegressionTransform : public UntrainableTransform
+{
+    Q_OBJECT
+
+    void project(const Template &src, Template &dst) const
+    {
+        Mat m; src[0].convertTo(m, CV_32F); assert(m.isContinuous() && (m.channels() == 1));
+
+        const float rmult = .6533673;
+        const float add = 41.268;
+
+        Mat dst1(m.size(), CV_32F);
+        int rows = m.rows;
+        int cols = m.cols;
+
+        const float *rsrc = (const float*) m.ptr();
+        float *p = (float*)dst1.ptr();
+
+        for (int r = 0; r < rows; r++){
+            for (int c = 0; c < cols; c++){
+                int index = r*cols+c;
+                const float rval = rsrc[index];
+                p[index] = rval*rmult+add;
+            }
+        }
+        dst = dst1;
+    }
+};
+
+BR_REGISTER(Transform, RedLinearRegressionTransform)
+
+} // namespace br
+
+#include "imgproc/redlinearregression.moc"
diff --git a/openbr/plugins/imgproc/reshape.cpp b/openbr/plugins/imgproc/reshape.cpp
new file mode 100644
index 0000000..d544d3f
--- /dev/null
+++ b/openbr/plugins/imgproc/reshape.cpp
@@ -0,0 +1,43 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * 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 Reshape the each matrix to the specified number of rows.
+ * \author Josh Klontz \cite jklontz
+ */
+class ReshapeTransform : public UntrainableTransform
+{
+    Q_OBJECT
+    Q_PROPERTY(int rows READ get_rows WRITE set_rows RESET reset_rows STORED false)
+    BR_PROPERTY(int, rows, 1)
+
+    void project(const Template &src, Template &dst) const
+    {
+        dst = src.m().reshape(src.m().channels(), rows);
+    }
+};
+
+BR_REGISTER(Transform, ReshapeTransform)
+
+} // namespace br;
+
+#include "imgproc/reshape.moc"
diff --git a/openbr/plugins/imgproc/resize.cpp b/openbr/plugins/imgproc/resize.cpp
new file mode 100644
index 0000000..d241ff7
--- /dev/null
+++ b/openbr/plugins/imgproc/resize.cpp
@@ -0,0 +1,84 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * 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 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)
+
+} // namespace br
+
+#include "imgproc/resize.moc"
diff --git a/openbr/plugins/imgproc/revertaffine.cpp b/openbr/plugins/imgproc/revertaffine.cpp
new file mode 100644
index 0000000..868fa3b
--- /dev/null
+++ b/openbr/plugins/imgproc/revertaffine.cpp
@@ -0,0 +1,46 @@
+#include <Eigen/Dense>
+
+#include <openbr/plugins/openbr_internal.h>
+#include <openbr/core/eigenutils.h>
+
+namespace br
+{
+
+/*!
+ * \ingroup transforms
+ * \brief Designed for use after eye detection + Stasm, this will
+ * revert the detected landmarks to the original coordinate space
+ * before affine alignment to the stasm mean shape. The storeAffine
+ * parameter must be set to true when calling AffineTransform before this.
+ * \author Brendan Klare \cite bklare
+ */
+class RevertAffineTransform : public UntrainableTransform
+{
+    Q_OBJECT
+
+private:
+
+    void project(const Template &src, Template &dst) const
+    {
+        QList<float> paramList = src.file.getList<float>("affineParameters");
+        Eigen::MatrixXf points = EigenUtils::pointsToMatrix(src.file.points(), true);
+        Eigen::MatrixXf affine = Eigen::MatrixXf::Zero(3, 3);
+        for (int i = 0, cnt = 0; i < 2; i++)
+            for (int j = 0; j < 3; j++, cnt++)
+                affine(i, j) = paramList[cnt];
+        affine(2, 2) = 1;
+        affine = affine.inverse();
+        Eigen::MatrixXf affineInv = affine.block(0, 0, 2, 3);
+        Eigen::MatrixXf pointsT = points.transpose();
+        points =  affineInv * pointsT;
+        dst = src;
+        dst.file.clearPoints();
+        dst.file.setPoints(EigenUtils::matrixToPoints(points.transpose()));
+    }
+};
+
+BR_REGISTER(Transform, RevertAffineTransform)
+
+} // namespace br
+
+#include "imgproc/revertaffine.moc"
diff --git a/openbr/plugins/imgproc/rg.cpp b/openbr/plugins/imgproc/rg.cpp
new file mode 100644
index 0000000..401d8f0
--- /dev/null
+++ b/openbr/plugins/imgproc/rg.cpp
@@ -0,0 +1,67 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * 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 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)
+
+} // namespace br
+
+#include "imgproc/rg.moc"
diff --git a/openbr/plugins/imgproc/rndpoint.cpp b/openbr/plugins/imgproc/rndpoint.cpp
new file mode 100644
index 0000000..40b439a
--- /dev/null
+++ b/openbr/plugins/imgproc/rndpoint.cpp
@@ -0,0 +1,57 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * 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 transforms
+ * \brief Generates a random landmark.
+ * \author Josh Klontz \cite jklontz
+ */
+class RndPointTransform : public Transform
+{
+    Q_OBJECT
+    Q_PROPERTY(float x READ get_x WRITE set_x RESET reset_x)
+    Q_PROPERTY(float y READ get_y WRITE set_y RESET reset_y)
+    BR_PROPERTY(float, x, -1)
+    BR_PROPERTY(float, y, -1)
+
+    void train(const TemplateList &data)
+    {
+        (void) data;
+
+        RNG &rng = theRNG();
+        x = rng.uniform(0.f, 1.f);
+        y = rng.uniform(0.f, 1.f);
+    }
+
+    void project(const Template &src, Template &dst) const
+    {
+        dst = src;
+        dst.file.appendPoint(QPointF(src.m().cols * x, src.m().rows * y));
+    }
+};
+
+BR_REGISTER(Transform, RndPointTransform)
+
+} // namespace br
+
+#include "imgproc/rndpoint.moc"
diff --git a/openbr/plugins/imgproc/rndregion.cpp b/openbr/plugins/imgproc/rndregion.cpp
new file mode 100644
index 0000000..3a27518
--- /dev/null
+++ b/openbr/plugins/imgproc/rndregion.cpp
@@ -0,0 +1,51 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * 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 transforms
+ * \brief Selects a random region.
+ * \author Josh Klontz \cite jklontz
+ */
+class RndRegionTransform : public UntrainableTransform
+{
+    Q_OBJECT
+
+    void project(const Template &src, Template &dst) const
+    {
+        RNG &rng = theRNG();
+        float size = rng.uniform(0.2f, 1.f);
+        float x = rng.uniform(0.f, 1.f-size);
+        float y = rng.uniform(0.f, 1.f-size);
+
+        dst = src.m()(Rect(src.m().cols * x,
+                           src.m().rows * y,
+                           src.m().cols * size,
+                           src.m().rows * size));
+    }
+};
+
+BR_REGISTER(Transform, RndRegionTransform)
+
+} // namespace br
+
+#include "imgproc/rndregion.moc"
diff --git a/openbr/plugins/imgproc/rndrotate.cpp b/openbr/plugins/imgproc/rndrotate.cpp
new file mode 100644
index 0000000..12d125d
--- /dev/null
+++ b/openbr/plugins/imgproc/rndrotate.cpp
@@ -0,0 +1,63 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * 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 transforms
+ * \brief Randomly rotates an image in a specified range.
+ * \author Scott Klum \cite sklum
+ */
+class RndRotateTransform : public UntrainableTransform
+{
+    Q_OBJECT
+
+    Q_PROPERTY(QList<int> range READ get_range WRITE set_range RESET reset_range STORED false)
+    BR_PROPERTY(QList<int>, range, QList<int>() << -15 << 15)
+
+    void project(const Template &src, Template &dst) const {
+        int span = range.first() - range.last();
+        int angle = (rand() % span) + range.first();
+        Mat rotMatrix = getRotationMatrix2D(Point2f(src.m().rows/2,src.m().cols/2),angle,1.0);
+        warpAffine(src,dst,rotMatrix,Size(src.m().cols,src.m().rows));
+
+        QList<QPointF> points = src.file.points();
+        QList<QPointF> rotatedPoints;
+        for (int i=0; i<points.size(); i++) {
+            rotatedPoints.append(QPointF(points.at(i).x()*rotMatrix.at<double>(0,0)+
+                                         points.at(i).y()*rotMatrix.at<double>(0,1)+
+                                         rotMatrix.at<double>(0,2),
+                                         points.at(i).x()*rotMatrix.at<double>(1,0)+
+                                         points.at(i).y()*rotMatrix.at<double>(1,1)+
+                                         rotMatrix.at<double>(1,2)));
+        }
+
+        dst.file.setPoints(rotatedPoints);
+    }
+};
+
+BR_REGISTER(Transform, RndRotateTransform)
+
+} // namespace br
+
+#include "imgproc/rndrotate.moc"
diff --git a/openbr/plugins/imgproc/rndsample.cpp b/openbr/plugins/imgproc/rndsample.cpp
new file mode 100644
index 0000000..260d297
--- /dev/null
+++ b/openbr/plugins/imgproc/rndsample.cpp
@@ -0,0 +1,115 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * 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>
+#include <openbr/core/opencvutils.h>
+#include <openbr/core/qtutils.h>
+
+using namespace cv;
+
+namespace br
+{
+
+/*!
+ * \ingroup transforms
+ * \brief Selects a random region about a point to use for training.
+ * \author Scott Klum \cite sklum
+ */
+
+class RndSampleTransform : public UntrainableMetaTransform
+{
+    Q_OBJECT
+    Q_PROPERTY(int pointIndex READ get_pointIndex WRITE set_pointIndex RESET reset_pointIndex)
+    Q_PROPERTY(int sampleRadius READ get_sampleRadius WRITE set_sampleRadius RESET reset_sampleRadius)
+    Q_PROPERTY(int sampleFactor READ get_sampleFactor WRITE set_sampleFactor RESET reset_sampleFactor)
+    Q_PROPERTY(bool duplicatePositiveSamples READ get_duplicatePositiveSamples WRITE set_duplicatePositiveSamples RESET reset_duplicatePositiveSamples STORED true)
+    Q_PROPERTY(QList<float> sampleOverlapBands READ get_sampleOverlapBands WRITE set_sampleOverlapBands RESET reset_sampleOverlapBands STORED true)
+    Q_PROPERTY(int samplesPerOverlapBand READ get_samplesPerOverlapBand WRITE set_samplesPerOverlapBand RESET reset_samplesPerOverlapBand STORED true)
+    Q_PROPERTY(bool classification READ get_classification WRITE set_classification RESET reset_classification STORED true)
+    Q_PROPERTY(float overlapPower READ get_overlapPower WRITE set_overlapPower RESET reset_overlapPower STORED true)
+    Q_PROPERTY(QString inputVariable READ get_inputVariable WRITE set_inputVariable RESET reset_inputVariable STORED true)
+    BR_PROPERTY(int, pointIndex, 0)
+    BR_PROPERTY(int, sampleRadius, 6)
+    BR_PROPERTY(int, sampleFactor, 4)
+    BR_PROPERTY(bool, duplicatePositiveSamples, true)
+    BR_PROPERTY(QList<float>, sampleOverlapBands, QList<float>() << .1 << .5 << .7 << .9 << 1.0)
+    BR_PROPERTY(int, samplesPerOverlapBand, 2)
+    BR_PROPERTY(bool, classification, true)
+    BR_PROPERTY(float, overlapPower, 1)
+    BR_PROPERTY(QString, inputVariable, "Label")
+
+    void project(const TemplateList &src, TemplateList &dst) const
+    {
+        foreach(const Template &t, src) {
+            QPointF point = t.file.points()[pointIndex];
+            QRectF region(point.x()-sampleRadius, point.y()-sampleRadius, sampleRadius*2, sampleRadius*2);
+
+            if (region.x() < 0 ||
+                region.y() < 0 ||
+                region.x() + region.width() >= t.m().cols ||
+                region.y() + region.height() >= t.m().rows)
+                continue;
+
+            int positiveSamples = duplicatePositiveSamples ? (sampleOverlapBands.size()-1)*samplesPerOverlapBand : 1;
+            for (int k=0; k<positiveSamples; k++) {
+                dst.append(Template(t.file, Mat(t.m(), OpenCVUtils::toRect(region))));
+                dst.last().file.set(inputVariable, 1);
+            }
+
+            QList<int> labelCount;
+            for (int k=0; k<sampleOverlapBands.size()-1; k++)
+                labelCount << 0;
+
+            while (std::accumulate(labelCount.begin(),labelCount.end(),0.0) < (sampleOverlapBands.size()-1)*samplesPerOverlapBand) {
+
+                float x = rand() % (sampleFactor*sampleRadius) + region.x() - sampleFactor/2*sampleRadius;
+                float y = rand() % (sampleFactor*sampleRadius) + region.y() - sampleFactor/2*sampleRadius;
+
+                if (x < 0 || y < 0 || x+2*sampleRadius > t.m().cols || y+2*sampleRadius > t.m().rows)
+                    continue;
+
+                QRectF negativeLocation = QRectF(x, y, sampleRadius*2, sampleRadius*2);
+
+                float overlap = pow(QtUtils::overlap(region, negativeLocation),overlapPower);
+
+                for (int k = 0; k<sampleOverlapBands.size()-1; k++) {
+                    if (overlap >= sampleOverlapBands.at(k) && overlap < sampleOverlapBands.at(k+1) && labelCount[k] < samplesPerOverlapBand) {
+                        Mat m(t.m(),OpenCVUtils::toRect(negativeLocation));
+                        dst.append(Template(t.file,  m));
+                        float label = classification ? 0 : overlap;
+                        dst.last().file.set(inputVariable, label);
+                        labelCount[k]++;
+                    }
+                }
+            }
+        }
+    }
+
+    void project(const Template &src, Template &dst) const {
+        TemplateList temp;
+        project(TemplateList() << src, temp);
+        if (!temp.isEmpty()) dst = temp.first();
+    }
+
+};
+
+BR_REGISTER(Transform, RndSampleTransform)
+
+} // namespace br
+
+#include "imgproc/rndsample.moc"
diff --git a/openbr/plugins/random.cpp b/openbr/plugins/imgproc/rndsubspace.cpp
index 9a0d397..e6f6972 100644
--- a/openbr/plugins/random.cpp
+++ b/openbr/plugins/imgproc/rndsubspace.cpp
@@ -14,15 +14,11 @@
  * limitations under the License.                                            *
  * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
 
-#include <numeric>
-
 #include <opencv2/imgproc/imgproc.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>
 
 using namespace cv;
 
@@ -95,161 +91,6 @@ class RndSubspaceTransform : public Transform
 
 BR_REGISTER(Transform, RndSubspaceTransform)
 
-/*!
- * \ingroup transforms
- * \brief Selects a random region.
- * \author Josh Klontz \cite jklontz
- */
-class RndRegionTransform : public Transform
-{
-    Q_OBJECT
-    Q_PROPERTY(float x READ get_x WRITE set_x RESET reset_x)
-    Q_PROPERTY(float y READ get_y WRITE set_y RESET reset_y)
-    Q_PROPERTY(float width READ get_width WRITE set_width RESET reset_width)
-    Q_PROPERTY(float height READ get_height WRITE set_height RESET reset_height)
-    BR_PROPERTY(float, x, -1)
-    BR_PROPERTY(float, y, -1)
-    BR_PROPERTY(float, width, -1)
-    BR_PROPERTY(float, height, -1)
-
-    void train(const TemplateList &data)
-    {
-        (void) data;
-
-        RNG &rng = theRNG();
-        width = rng.uniform(0.f, 1.f);
-        height = rng.uniform(0.f, 1.f);
-        x = rng.uniform(0.f, 1.f-width);
-        y = rng.uniform(0.f, 1.f-height);
-    }
-
-    void project(const Template &src, Template &dst) const
-    {
-        dst = src.m()(Rect(src.m().cols * x,
-                           src.m().rows * y,
-                           src.m().cols * width,
-                           src.m().rows * height));
-    }
-};
-
-BR_REGISTER(Transform, RndRegionTransform)
-
-/*!
- * \ingroup transforms
- * \brief Selects a random region about a point to use for training.
- * \author Scott Klum \cite sklum
- */
-
-class RndSampleTransform : public UntrainableMetaTransform
-{
-    Q_OBJECT
-    Q_PROPERTY(int pointIndex READ get_pointIndex WRITE set_pointIndex RESET reset_pointIndex)
-    Q_PROPERTY(int sampleRadius READ get_sampleRadius WRITE set_sampleRadius RESET reset_sampleRadius)
-    Q_PROPERTY(int sampleFactor READ get_sampleFactor WRITE set_sampleFactor RESET reset_sampleFactor)
-    Q_PROPERTY(bool duplicatePositiveSamples READ get_duplicatePositiveSamples WRITE set_duplicatePositiveSamples RESET reset_duplicatePositiveSamples STORED true)
-    Q_PROPERTY(QList<float> sampleOverlapBands READ get_sampleOverlapBands WRITE set_sampleOverlapBands RESET reset_sampleOverlapBands STORED true)
-    Q_PROPERTY(int samplesPerOverlapBand READ get_samplesPerOverlapBand WRITE set_samplesPerOverlapBand RESET reset_samplesPerOverlapBand STORED true)
-    Q_PROPERTY(bool classification READ get_classification WRITE set_classification RESET reset_classification STORED true)
-    Q_PROPERTY(float overlapPower READ get_overlapPower WRITE set_overlapPower RESET reset_overlapPower STORED true)
-    Q_PROPERTY(QString inputVariable READ get_inputVariable WRITE set_inputVariable RESET reset_inputVariable STORED true)
-    BR_PROPERTY(int, pointIndex, 0)
-    BR_PROPERTY(int, sampleRadius, 6)
-    BR_PROPERTY(int, sampleFactor, 4)
-    BR_PROPERTY(bool, duplicatePositiveSamples, true)
-    BR_PROPERTY(QList<float>, sampleOverlapBands, QList<float>() << .1 << .5 << .7 << .9 << 1.0)
-    BR_PROPERTY(int, samplesPerOverlapBand, 2)
-    BR_PROPERTY(bool, classification, true)
-    BR_PROPERTY(float, overlapPower, 1)
-    BR_PROPERTY(QString, inputVariable, "Label")
-
-    void project(const TemplateList &src, TemplateList &dst) const
-    {
-        foreach(const Template &t, src) {
-            QPointF point = t.file.points()[pointIndex];
-            QRectF region(point.x()-sampleRadius, point.y()-sampleRadius, sampleRadius*2, sampleRadius*2);
-
-            if (region.x() < 0 ||
-                region.y() < 0 ||
-                region.x() + region.width() >= t.m().cols ||
-                region.y() + region.height() >= t.m().rows)
-                continue;
-
-            int positiveSamples = duplicatePositiveSamples ? (sampleOverlapBands.size()-1)*samplesPerOverlapBand : 1;
-            for (int k=0; k<positiveSamples; k++) {
-                dst.append(Template(t.file, Mat(t.m(), OpenCVUtils::toRect(region))));
-                dst.last().file.set(inputVariable, 1);
-            }
-
-            QList<int> labelCount;
-            for (int k=0; k<sampleOverlapBands.size()-1; k++)
-                labelCount << 0;
-
-            while (std::accumulate(labelCount.begin(),labelCount.end(),0.0) < (sampleOverlapBands.size()-1)*samplesPerOverlapBand) {
-
-                float x = rand() % (sampleFactor*sampleRadius) + region.x() - sampleFactor/2*sampleRadius;
-                float y = rand() % (sampleFactor*sampleRadius) + region.y() - sampleFactor/2*sampleRadius;
-
-                if (x < 0 || y < 0 || x+2*sampleRadius > t.m().cols || y+2*sampleRadius > t.m().rows)
-                    continue;
-
-                QRectF negativeLocation = QRectF(x, y, sampleRadius*2, sampleRadius*2);
-
-                float overlap = pow(QtUtils::overlap(region, negativeLocation),overlapPower);
-
-                for (int k = 0; k<sampleOverlapBands.size()-1; k++) {
-                    if (overlap >= sampleOverlapBands.at(k) && overlap < sampleOverlapBands.at(k+1) && labelCount[k] < samplesPerOverlapBand) {
-                        Mat m(t.m(),OpenCVUtils::toRect(negativeLocation));
-                        dst.append(Template(t.file,  m));
-                        float label = classification ? 0 : overlap;
-                        dst.last().file.set(inputVariable, label);
-                        labelCount[k]++;
-                    }
-                }
-            }
-        }
-    }
-
-    void project(const Template &src, Template &dst) const {
-        TemplateList temp;
-        project(TemplateList() << src, temp);
-        if (!temp.isEmpty()) dst = temp.first();
-    }
-
-};
-
-BR_REGISTER(Transform, RndSampleTransform)
-
-/*!
- * \ingroup transforms
- * \brief Generates a random landmark.
- * \author Josh Klontz \cite jklontz
- */
-class RndPointTransform : public Transform
-{
-    Q_OBJECT
-    Q_PROPERTY(float x READ get_x WRITE set_x RESET reset_x)
-    Q_PROPERTY(float y READ get_y WRITE set_y RESET reset_y)
-    BR_PROPERTY(float, x, -1)
-    BR_PROPERTY(float, y, -1)
-
-    void train(const TemplateList &data)
-    {
-        (void) data;
-
-        RNG &rng = theRNG();
-        x = rng.uniform(0.f, 1.f);
-        y = rng.uniform(0.f, 1.f);
-    }
-
-    void project(const Template &src, Template &dst) const
-    {
-        dst = src;
-        dst.file.appendPoint(QPointF(src.m().cols * x, src.m().rows * y));
-    }
-};
-
-BR_REGISTER(Transform, RndPointTransform)
-
 } // namespace br
 
-#include "random.moc"
+#include "imgproc/rndsubspace.moc"
diff --git a/openbr/plugins/imgproc/roi.cpp b/openbr/plugins/imgproc/roi.cpp
new file mode 100644
index 0000000..0da96c8
--- /dev/null
+++ b/openbr/plugins/imgproc/roi.cpp
@@ -0,0 +1,62 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * 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 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.");
+        }
+        dst.file.clearRects();
+    }
+};
+
+BR_REGISTER(Transform, ROITransform)
+
+} // namespace br
+
+#include "imgproc/roi.moc"
diff --git a/openbr/plugins/imgproc/roifrompoints.cpp b/openbr/plugins/imgproc/roifrompoints.cpp
new file mode 100644
index 0000000..cb1602f
--- /dev/null
+++ b/openbr/plugins/imgproc/roifrompoints.cpp
@@ -0,0 +1,51 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * 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 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)
+
+} // namespace br
+
+#include "imgproc/roifrompoints.moc"
diff --git a/openbr/plugins/imgproc/rootnorm.cpp b/openbr/plugins/imgproc/rootnorm.cpp
new file mode 100644
index 0000000..24b3f1d
--- /dev/null
+++ b/openbr/plugins/imgproc/rootnorm.cpp
@@ -0,0 +1,50 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * 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 transforms
+ * \brief dst=sqrt(norm_L1(src)) proposed as RootSIFT in \cite Arandjelovic12
+ * \author Josh Klontz \cite jklontz
+ */
+class RootNormTransform : public UntrainableTransform
+{
+    Q_OBJECT
+
+    void project(const Template &src, Template &dst) const
+    {
+        const Mat &m = src;
+        dst.m() = Mat(m.rows, m.cols, m.type());
+        for (int i=0; i<m.rows; i++) {
+            Mat temp;
+            cv::normalize(m.row(i), temp, 1, 0, NORM_L1);
+            cv::sqrt(temp, temp);
+            temp.copyTo(dst.m().row(i));
+        }
+    }
+};
+
+BR_REGISTER(Transform, RootNormTransform)
+
+} // namespace br
+
+#include "imgproc/rootnorm.moc"
diff --git a/openbr/plugins/imgproc/rowwisemeancenter.cpp b/openbr/plugins/imgproc/rowwisemeancenter.cpp
new file mode 100644
index 0000000..6a4a08b
--- /dev/null
+++ b/openbr/plugins/imgproc/rowwisemeancenter.cpp
@@ -0,0 +1,66 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * 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 Remove the row-wise training set average.
+ * \author Josh Klontz \cite jklontz
+ */
+class RowWiseMeanCenterTransform : public Transform
+{
+    Q_OBJECT
+    Mat mean;
+
+    void train(const TemplateList &data)
+    {
+        Mat m = OpenCVUtils::toMatByRow(data.data());
+        mean = Mat(1, m.cols, m.type());
+        for (int i=0; i<m.cols; i++)
+            mean.col(i) = cv::mean(m.col(i));
+    }
+
+    void project(const Template &src, Template &dst) const
+    {
+        Mat m = src.m().clone();
+        for (int i=0; i<m.rows; i++)
+            m.row(i) -= mean;
+        dst = m;
+    }
+
+    void store(QDataStream &stream) const
+    {
+        stream << mean;
+    }
+
+    void load(QDataStream &stream)
+    {
+        stream >> mean;
+    }
+};
+
+BR_REGISTER(Transform, RowWiseMeanCenterTransform)
+
+} // namespace br
+
+#include "imgproc/rowwisemeancenter.moc"
diff --git a/openbr/plugins/imgproc/samplefrommask.cpp b/openbr/plugins/imgproc/samplefrommask.cpp
new file mode 100644
index 0000000..a2b4557
--- /dev/null
+++ b/openbr/plugins/imgproc/samplefrommask.cpp
@@ -0,0 +1,38 @@
+#include <openbr/plugins/openbr_internal.h>
+
+using namespace cv;
+
+namespace br
+{
+
+/*!
+ * \ingroup transforms
+ * \brief Samples pixels from a mask.
+ * \author Scott Klum \cite sklum
+ */
+class SampleFromMaskTransform : public UntrainableTransform
+{
+    Q_OBJECT
+
+    void project(const Template &src, Template &dst) const
+    {
+        Mat mask = src.file.get<Mat>("Mask");
+        const int count = countNonZero(mask);
+        dst.m() = Mat(1,count,src.m().type());
+
+        Mat masked;
+        src.m().copyTo(masked, mask);
+
+        Mat indices;
+        findNonZero(masked,indices);
+
+        for (size_t j=0; j<indices.total(); j++)
+            dst.m().at<uchar>(0,j) = masked.at<uchar>(indices.at<Point>(j).y,indices.at<Point>(j).x);
+    }
+};
+
+BR_REGISTER(Transform, SampleFromMaskTransform)
+
+} // namespace br
+
+#include "imgproc/samplefrommask.moc"
diff --git a/openbr/plugins/imgproc/scale.cpp b/openbr/plugins/imgproc/scale.cpp
new file mode 100644
index 0000000..aa18d26
--- /dev/null
+++ b/openbr/plugins/imgproc/scale.cpp
@@ -0,0 +1,59 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * 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 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)
+
+} // namespace br
+
+#include "imgproc/scale.moc"
diff --git a/openbr/plugins/imgproc/sift.cpp b/openbr/plugins/imgproc/sift.cpp
new file mode 100644
index 0000000..32f8e07
--- /dev/null
+++ b/openbr/plugins/imgproc/sift.cpp
@@ -0,0 +1,76 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * 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/nonfree/nonfree.hpp>
+
+#include <openbr/plugins/openbr_internal.h>
+
+using namespace cv;
+
+namespace br
+{
+
+/*!
+ * \ingroup transforms
+ * \brief Specialize wrapper OpenCV SIFT wrapper
+ * \author Josh Klontz \cite jklontz
+ */
+class SIFTDescriptorTransform : public UntrainableTransform
+{
+    Q_OBJECT
+    Q_PROPERTY(int size READ get_size WRITE set_size RESET reset_size STORED false)
+    Q_PROPERTY(QList<int> sizes READ get_sizes WRITE set_sizes RESET reset_sizes STORED false)
+    Q_PROPERTY(int nFeatures READ get_nFeatures WRITE set_nFeatures RESET reset_nFeatures STORED false)
+    Q_PROPERTY(int nOctaveLayers READ get_nOctaveLayers WRITE set_nOctaveLayers RESET reset_nOctaveLayers STORED false)
+    Q_PROPERTY(double contrastThreshold READ get_contrastThreshold WRITE set_contrastThreshold RESET reset_contrastThreshold STORED false)
+    Q_PROPERTY(double edgeThreshold READ get_edgeThreshold WRITE set_edgeThreshold RESET reset_edgeThreshold STORED false)
+    Q_PROPERTY(double sigma READ get_sigma WRITE set_sigma RESET reset_sigma STORED false)
+    BR_PROPERTY(int, size, 1)
+    BR_PROPERTY(QList<int>, sizes, QList<int>())
+    BR_PROPERTY(int, nFeatures, 0)
+    BR_PROPERTY(int, nOctaveLayers, 3)
+    BR_PROPERTY(double, contrastThreshold, 0.04)
+    BR_PROPERTY(double, edgeThreshold, 10)
+    BR_PROPERTY(double, sigma, 1.6)
+
+    SIFT sift;
+
+    void init()
+    {
+        if (sizes.empty())
+            sizes.append(size);
+        sift = SIFT(nFeatures, nOctaveLayers, contrastThreshold, edgeThreshold, sigma);
+    }
+
+    void project(const Template &src, Template &dst) const
+    {
+        std::vector<KeyPoint> keyPoints;
+        foreach (const QPointF &val, src.file.points())
+            foreach (const int r, sizes)
+                keyPoints.push_back(KeyPoint(val.x(), val.y(), r));
+
+        Mat m;
+        sift(src, Mat(), keyPoints, m, true);
+        m.setTo(0, m<0); // SIFT returns large negative values when it goes off the edge of the image.
+        dst += m;
+    }
+};
+
+BR_REGISTER(Transform, SIFTDescriptorTransform)
+
+} // namespace br
+
+#include "imgproc/sift.moc"
diff --git a/openbr/plugins/imgproc/skinmask.cpp b/openbr/plugins/imgproc/skinmask.cpp
new file mode 100644
index 0000000..3af967d
--- /dev/null
+++ b/openbr/plugins/imgproc/skinmask.cpp
@@ -0,0 +1,59 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * 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 transforms
+ * \brief http://worldofcameras.wordpress.com/tag/skin-detection-opencv/
+ * \author Josh Klontz \cite jklontz
+ */
+class SkinMaskTransform : public UntrainableTransform
+{
+    Q_OBJECT
+
+    void project(const Template &src, Template &dst) const
+    {
+        Mat m;
+        cvtColor(src, m, CV_BGR2YCrCb);
+        std::vector<Mat> mv;
+        split(m, mv);
+        Mat mask = Mat(m.rows, m.cols, CV_8UC1);
+
+        for (int i=0; i<m.rows; i++) {
+            for (int j=0; j<m.cols; j++) {
+                int Cr= mv[1].at<quint8>(i,j);
+                int Cb =mv[2].at<quint8>(i,j);
+                mask.at<quint8>(i, j) = (Cr>130 && Cr<170) && (Cb>70 && Cb<125) ? 255 : 0;
+            }
+        }
+
+        dst = mask;
+    }
+};
+
+BR_REGISTER(Transform, SkinMaskTransform)
+
+} // namespace br
+
+#include "imgproc/skinmask.moc"
diff --git a/openbr/plugins/imgproc/slidingwindow.cpp b/openbr/plugins/imgproc/slidingwindow.cpp
new file mode 100644
index 0000000..f3538b9
--- /dev/null
+++ b/openbr/plugins/imgproc/slidingwindow.cpp
@@ -0,0 +1,166 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * 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
+{
+
+// Find avg aspect ratio
+static float getAspectRatio(const TemplateList &data)
+{
+    double tempRatio = 0;
+    int ratioCnt = 0;
+
+    foreach (const Template &tmpl, data) {
+        QList<Rect> posRects = OpenCVUtils::toRects(tmpl.file.rects());
+        foreach (const Rect &posRect, posRects) {
+            if (posRect.x + posRect.width >= tmpl.m().cols || posRect.y + posRect.height >= tmpl.m().rows || posRect.x < 0 || posRect.y < 0) {
+                continue;
+            }
+            tempRatio += (float)posRect.width / (float)posRect.height;
+            ratioCnt += 1;
+        }
+    }
+    return tempRatio / (double)ratioCnt;
+}
+
+/*!
+ * \ingroup transforms
+ * \brief Applies a transform to a sliding window.
+ *        Discards negative detections.
+ * \author Austin Blanton \cite imaus10
+ */
+class SlidingWindowTransform : public Transform
+{
+    Q_OBJECT
+    Q_PROPERTY(br::Transform *transform READ get_transform WRITE set_transform RESET reset_transform STORED false)
+    Q_PROPERTY(int windowWidth READ get_windowWidth WRITE set_windowWidth RESET reset_windowWidth STORED false)
+    Q_PROPERTY(bool takeFirst READ get_takeFirst WRITE set_takeFirst RESET reset_takeFirst STORED false)
+    Q_PROPERTY(float threshold READ get_threshold WRITE set_threshold RESET reset_threshold STORED false)
+    Q_PROPERTY(float stepFraction READ get_stepFraction WRITE set_stepFraction RESET reset_stepFraction STORED false)
+    Q_PROPERTY(int ignoreBorder READ get_ignoreBorder WRITE set_ignoreBorder RESET reset_ignoreBorder STORED true)
+    BR_PROPERTY(br::Transform *, transform, NULL)
+    BR_PROPERTY(int, windowWidth, 24)
+    BR_PROPERTY(bool, takeFirst, false)
+    BR_PROPERTY(float, threshold, 0)
+    BR_PROPERTY(float, stepFraction, 0.25)
+    BR_PROPERTY(int, ignoreBorder, 0)
+
+private:
+    int windowHeight;
+    bool skipProject;
+
+    void train(const TemplateList &data)
+    {
+        skipProject = true;
+        float aspectRatio = data.first().file.get<float>("aspectRatio", -1);
+        if (aspectRatio == -1)
+            aspectRatio = getAspectRatio(data);
+        windowHeight = qRound(windowWidth / aspectRatio);
+
+        if (transform->trainable) {
+            TemplateList dataOut = data;
+            if (ignoreBorder > 0) {
+                for (int i = 0; i < dataOut.size(); i++) {
+                    Template t = dataOut[i];
+                    Mat m = t.m();
+                    dataOut.replace(i,Template(t.file, Mat(m,Rect(ignoreBorder,ignoreBorder,m.cols - ignoreBorder * 2, m.rows - ignoreBorder * 2))));
+                }
+            }
+            transform->train(dataOut);
+        }
+    }
+
+    void store(QDataStream &stream) const
+    {
+        transform->store(stream);
+        stream << windowHeight;
+    }
+
+    void load(QDataStream &stream)
+    {
+        transform->load(stream);
+        stream >> windowHeight;
+    }
+
+    void project(const Template &src, Template &dst) const
+    {
+        float scale = src.file.get<float>("scale", 1);
+        projectHelp(src, dst, windowWidth, windowHeight, scale);
+    }
+
+ protected:
+     void projectHelp(const Template &src, Template &dst, int windowWidth, int windowHeight, float scale = 1) const
+     {
+
+        dst = src;
+        if (skipProject) {
+            dst = src;
+            return;
+        }
+
+        Template windowTemplate(src.file, src);
+        QList<float> confidences = dst.file.getList<float>("Confidences", QList<float>());
+        for (float y = 0; y + windowHeight < src.m().rows; y += windowHeight*stepFraction) {
+            for (float x = 0; x + windowWidth < src.m().cols; x += windowWidth*stepFraction) {
+                Mat windowMat(src, Rect(x + ignoreBorder, y + ignoreBorder, windowWidth - ignoreBorder * 2, windowHeight - ignoreBorder * 2));
+                windowTemplate.replace(0,windowMat);
+                Template detect;
+                transform->project(windowTemplate, detect);
+                float conf = detect.m().at<float>(0);
+
+                // the result will be in the Label
+                if (conf > threshold) {
+                    dst.file.appendRect(QRectF(x*scale, y*scale, windowWidth*scale, windowHeight*scale));
+                    confidences.append(conf);
+                    if (takeFirst)
+                        return;
+                }
+            }
+        }
+        dst.file.setList<float>("Confidences", confidences);
+    }
+};
+
+BR_REGISTER(Transform, SlidingWindowTransform)
+
+/*!
+ * \ingroup transforms
+ * \brief Overloads SlidingWindowTransform for integral images that should be
+ *        sampled at multiple scales.
+ * \author Josh Klontz \cite jklontz
+ */
+class IntegralSlidingWindowTransform : public SlidingWindowTransform
+{
+    Q_OBJECT
+
+ private:
+    void project(const Template &src, Template &dst) const
+    {
+        // TODO: call SlidingWindowTransform::project on multiple scales
+        SlidingWindowTransform::projectHelp(src, dst, 24, 24);
+    }
+};
+
+BR_REGISTER(Transform, IntegralSlidingWindowTransform)
+
+} // namespace br
+
+#include "imgproc/slidingwindow.moc"
diff --git a/openbr/plugins/imgproc/splitchannels.cpp b/openbr/plugins/imgproc/splitchannels.cpp
new file mode 100644
index 0000000..9a604ff
--- /dev/null
+++ b/openbr/plugins/imgproc/splitchannels.cpp
@@ -0,0 +1,48 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * 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 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)
+
+} // namespace br
+
+#include "imgproc/splitchannels.moc"
diff --git a/openbr/plugins/imgproc/subdivide.cpp b/openbr/plugins/imgproc/subdivide.cpp
new file mode 100644
index 0000000..17b04f7
--- /dev/null
+++ b/openbr/plugins/imgproc/subdivide.cpp
@@ -0,0 +1,49 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * 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 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)
+
+} // namespace br
+
+#include "imgproc/subdivide.moc"
diff --git a/openbr/plugins/imgproc/subtract.cpp b/openbr/plugins/imgproc/subtract.cpp
new file mode 100644
index 0000000..b2adb4c
--- /dev/null
+++ b/openbr/plugins/imgproc/subtract.cpp
@@ -0,0 +1,43 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * 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 Subtract two matrices.
+ * \author Josh Klontz \cite jklontz
+ */
+class SubtractTransform : public UntrainableMetaTransform
+{
+    Q_OBJECT
+
+    void project(const Template &src, Template &dst) const
+    {
+        if (src.size() != 2) qFatal("Expected exactly two source images, got %d.", src.size());
+        dst.file = src.file;
+        cv::subtract(src[0], src[1], dst);
+    }
+};
+
+BR_REGISTER(Transform, SubtractTransform)
+
+} // namespace br
+
+#include "imgproc/subtract.moc"
diff --git a/openbr/plugins/imgproc/threshold.cpp b/openbr/plugins/imgproc/threshold.cpp
new file mode 100644
index 0000000..1e4f53f
--- /dev/null
+++ b/openbr/plugins/imgproc/threshold.cpp
@@ -0,0 +1,53 @@
+#include <opencv2/imgproc/imgproc.hpp>
+
+#include <openbr/plugins/openbr_internal.h>
+
+using namespace cv;
+
+namespace br
+{
+
+/*!
+ * \ingroup transforms
+ * \brief Wraps OpenCV's adaptive thresholding.
+ * \author Scott Klum \cite sklum
+ */
+class ThresholdTransform : public UntrainableTransform
+{
+    Q_OBJECT
+
+    Q_ENUMS(Type)
+    Q_PROPERTY(Type type READ get_type WRITE set_type RESET reset_type STORED false)
+    Q_PROPERTY(bool otsu READ get_otsu WRITE set_otsu RESET reset_otsu STORED false)
+    Q_PROPERTY(int thresh READ get_thresh WRITE set_thresh RESET reset_thresh STORED false)
+    Q_PROPERTY(int maxValue READ get_maxValue WRITE set_maxValue RESET reset_maxValue STORED false)
+
+public:
+    enum Type { Binary = THRESH_BINARY,
+                BinaryInv = THRESH_BINARY_INV,
+                Trunc = THRESH_TRUNC,
+                ToZero = THRESH_TOZERO,
+                ToZeroInv = THRESH_TOZERO_INV};
+
+private:
+    BR_PROPERTY(Type, type, Binary)
+    BR_PROPERTY(bool, otsu, false)
+    BR_PROPERTY(int, thresh, 0)
+    BR_PROPERTY(int, maxValue, 255)
+
+    void project(const Template &src, Template &dst) const
+    {
+        dst = src;
+
+        Mat mask;
+        threshold(src, mask, thresh, maxValue, otsu ? type+THRESH_OTSU : type);
+
+        dst.file.set("Mask",QVariant::fromValue(mask));
+    }
+};
+
+BR_REGISTER(Transform, ThresholdTransform)
+
+} // namespace br
+
+#include "imgproc/threshold.moc"
diff --git a/openbr/plugins/imgproc/transpose.cpp b/openbr/plugins/imgproc/transpose.cpp
new file mode 100644
index 0000000..422debe
--- /dev/null
+++ b/openbr/plugins/imgproc/transpose.cpp
@@ -0,0 +1,36 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * 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 TransposeTransform : public UntrainableTransform
+{
+    Q_OBJECT
+
+    void project(const Template &src, Template &dst) const
+    {
+        dst.m() = src.m().t();
+    }
+};
+
+BR_REGISTER(Transform, TransposeTransform)
+
+} // namespace br
+
+#include "imgproc/transpose.moc"
diff --git a/openbr/plugins/segmentation.cpp b/openbr/plugins/imgproc/watershedsegmentation.cpp
index f11532b..104b6a6 100644
--- a/openbr/plugins/segmentation.cpp
+++ b/openbr/plugins/imgproc/watershedsegmentation.cpp
@@ -1,6 +1,23 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * 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"
+
+#include <openbr/plugins/openbr_internal.h>
+#include <openbr/core/opencvutils.h>
 
 using namespace cv;
 
@@ -46,8 +63,9 @@ class WatershedSegmentationTransform : public UntrainableTransform
         dst.file.set("NumSegments", compCount);
     }
 };
+
 BR_REGISTER(Transform, WatershedSegmentationTransform)
 
 } // namespace br
 
-#include "segmentation.moc"
+#include "imgproc/watershedsegmentation.moc"
diff --git a/openbr/plugins/independent.cpp b/openbr/plugins/independent.cpp
deleted file mode 100644
index 7ac93ce..0000000
--- a/openbr/plugins/independent.cpp
+++ /dev/null
@@ -1,390 +0,0 @@
-#include <QFutureSynchronizer>
-#include <QtConcurrentRun>
-
-#include "openbr_internal.h"
-#include "openbr/core/common.h"
-
-using namespace cv;
-
-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)
-
-/*!
- * \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)
-
-/*!
- * \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 "independent.moc"
diff --git a/openbr/plugins/integral.cpp b/openbr/plugins/integral.cpp
deleted file mode 100644
index f6117a0..0000000
--- a/openbr/plugins/integral.cpp
+++ /dev/null
@@ -1,374 +0,0 @@
-#include <opencv2/imgproc/imgproc.hpp>
-#include <opencv2/imgproc/imgproc_c.h>
-#include <Eigen/Core>
-#include "openbr_internal.h"
-
-#include "openbr/core/opencvutils.h"
-
-using namespace cv;
-
-namespace br
-{
-
-/*!
- * \ingroup transforms
- * \brief Computes integral image.
- * \author Josh Klontz \cite jklontz
- */
-class IntegralTransform : public UntrainableTransform
-{
-    Q_OBJECT
-
-    void project(const Template &src, Template &dst) const
-    {
-        integral(src, dst);
-    }
-};
-
-BR_REGISTER(Transform, IntegralTransform)
-
-/*!
- * \ingroup transforms
- * \brief Sliding window feature extraction from a multi-channel integral image.
- * \author Josh Klontz \cite jklontz
- */
-class IntegralSamplerTransform : public UntrainableTransform
-{
-    Q_OBJECT
-    Q_PROPERTY(int scales READ get_scales WRITE set_scales RESET reset_scales STORED false)
-    Q_PROPERTY(float scaleFactor READ get_scaleFactor WRITE set_scaleFactor RESET reset_scaleFactor STORED false)
-    Q_PROPERTY(float stepFactor READ get_stepFactor WRITE set_stepFactor RESET reset_stepFactor STORED false)
-    Q_PROPERTY(int minSize READ get_minSize WRITE set_minSize RESET reset_minSize STORED false)
-    Q_PROPERTY(bool secondOrder READ get_secondOrder WRITE set_secondOrder RESET reset_secondOrder STORED false)
-    BR_PROPERTY(int, scales, 6)
-    BR_PROPERTY(float, scaleFactor, 2)
-    BR_PROPERTY(float, stepFactor, 0.75)
-    BR_PROPERTY(int, minSize, 8)
-    BR_PROPERTY(bool, secondOrder, false)
-
-    void project(const Template &src, Template &dst) const
-    {
-        typedef Eigen::Map< const Eigen::Matrix<qint32,Eigen::Dynamic,1> > InputDescriptor;
-        typedef Eigen::Map< const Eigen::Matrix<float,Eigen::Dynamic,1> > SecondOrderInputDescriptor;
-        typedef Eigen::Map< Eigen::Matrix<float,Eigen::Dynamic,1> > OutputDescriptor;
-
-        const Mat &m = src.m();
-        if (m.depth() != CV_32S) qFatal("Expected CV_32S matrix depth.");
-        const int channels = m.channels();
-        const int rowStep = channels * m.cols;
-
-        int descriptors = 0;
-        float idealSize = min(m.rows, m.cols)-1;
-        for (int scale=0; scale<scales; scale++) {
-            const int currentSize(idealSize);
-            const int numDown = 1+(m.rows-currentSize-1)/int(idealSize*stepFactor);
-            const int numAcross = 1+(m.cols-currentSize-1)/int(idealSize*stepFactor);
-            descriptors += numDown*numAcross;
-            if (secondOrder) descriptors += numDown*(numAcross-1) + (numDown-1)*numAcross;
-            idealSize /= scaleFactor;
-            if (idealSize < minSize) break;
-        }
-        Mat n(descriptors, channels, CV_32FC1);
-
-        const qint32 *dataIn = (qint32*)m.data;
-        float *dataOut = (float*)n.data;
-        idealSize = min(m.rows, m.cols)-1;
-        int index = 0;
-        for (int scale=0; scale<scales; scale++) {
-            const int currentSize(idealSize);
-            const int currentStep(idealSize*stepFactor);
-            for (int i=currentSize; i<m.rows; i+=currentStep) {
-                for (int j=currentSize; j<m.cols; j+=currentStep) {
-                    InputDescriptor a(dataIn+((i-currentSize)*rowStep+(j-currentSize)*channels), channels, 1);
-                    InputDescriptor b(dataIn+((i-currentSize)*rowStep+ j             *channels), channels, 1);
-                    InputDescriptor c(dataIn+(i              *rowStep+(j-currentSize)*channels), channels, 1);
-                    InputDescriptor d(dataIn+(i              *rowStep+ j             *channels), channels, 1);
-                    OutputDescriptor y(dataOut+(index*channels), channels, 1);
-                    y = (d-b-c+a).cast<float>()/(currentSize*currentSize);
-                    index++;
-                }
-            }
-            if (secondOrder) {
-                const int numDown = 1+(m.rows-currentSize-1)/currentStep;
-                const int numAcross = 1+(m.cols-currentSize-1)/currentStep;
-                const float *dataIn = n.ptr<float>(index - numDown*numAcross);
-                for (int i=0; i<numDown; i++) {
-                    for (int j=0; j<numAcross; j++) {
-                        SecondOrderInputDescriptor a(dataIn + (i*numAcross+j)*channels, channels, 1);
-                        if (j < numAcross-1) {
-                            OutputDescriptor y(dataOut+(index*channels), channels, 1);
-                            y = a - SecondOrderInputDescriptor(dataIn + (i*numAcross+j+1)*channels, channels, 1);
-                            index++;
-                        }
-                        if (i < numDown-1) {
-                            OutputDescriptor y(dataOut+(index*channels), channels, 1);
-                            y = a - SecondOrderInputDescriptor(dataIn + ((i+1)*numAcross+j)*channels, channels, 1);
-                            index++;
-                        }
-                    }
-                }
-            }
-            idealSize /= scaleFactor;
-            if (idealSize < minSize) break;
-        }
-
-        if (descriptors != index)
-            qFatal("Allocated %d descriptors but computed %d.", descriptors, index);
-
-        dst.m() = n;
-    }
-};
-
-BR_REGISTER(Transform, IntegralSamplerTransform)
-
-/*!
- * \ingroup transforms
- * \brief Construct template in a recursive decent manner.
- * \author Josh Klontz \cite jklontz
- */
-class RecursiveIntegralSamplerTransform : public Transform
-{
-    Q_OBJECT
-    Q_PROPERTY(int scales READ get_scales WRITE set_scales RESET reset_scales STORED false)
-    Q_PROPERTY(float scaleFactor READ get_scaleFactor WRITE set_scaleFactor RESET reset_scaleFactor STORED false)
-    Q_PROPERTY(int minSize READ get_minSize WRITE set_minSize RESET reset_minSize STORED false)
-    Q_PROPERTY(br::Transform *transform READ get_transform WRITE set_transform RESET reset_transform)
-    BR_PROPERTY(int, scales, 6)
-    BR_PROPERTY(float, scaleFactor, 2)
-    BR_PROPERTY(int, minSize, 8)
-    BR_PROPERTY(br::Transform*, transform, NULL)
-
-    Transform *subTransform;
-
-    typedef Eigen::Map< const Eigen::Matrix<qint32,Eigen::Dynamic,1> > InputDescriptor;
-    typedef Eigen::Map< Eigen::Matrix<float,Eigen::Dynamic,1> > OutputDescriptor;
-    typedef Eigen::Map< const Eigen::Matrix<float,Eigen::Dynamic,1> > SecondOrderInputDescriptor;
-
-    void init()
-    {
-        if (scales >= 2) {
-            File subFile = file;
-            subFile.set("scales", scales-1);
-            subTransform = make(subFile.flat());
-        } else {
-            subTransform = NULL;
-        }
-    }
-
-    static void integralHistogram(const Mat &src, const int x, const int y, const int width, const int height, Mat &dst, int index)
-    {
-        const int channels = src.channels();
-        OutputDescriptor(dst.ptr<float>(index), channels, 1) =
-            (  InputDescriptor(src.ptr<qint32>(y+height, x+width), channels, 1)
-             - InputDescriptor(src.ptr<qint32>(y,        x+width), channels, 1)
-             - InputDescriptor(src.ptr<qint32>(y+height, x),       channels, 1)
-             + InputDescriptor(src.ptr<qint32>(y,        x),       channels, 1)).cast<float>()/(height*width);
-    }
-
-    void computeDescriptor(const Mat &src, Mat &dst) const
-    {
-        const int channels = src.channels();
-        const int rows = src.rows-1; // Integral images have an extra row and column
-        const int columns = src.cols-1;
-
-        Mat tmp(5, channels, CV_32FC1);
-        integralHistogram(src,         0,      0, columns/2, rows/2, tmp, 0);
-        integralHistogram(src, columns/2,      0, columns/2, rows/2, tmp, 1);
-        integralHistogram(src,         0, rows/2, columns/2, rows/2, tmp, 2);
-        integralHistogram(src, columns/2, rows/2, columns/2, rows/2, tmp, 3);
-        integralHistogram(src, columns/4, rows/4, columns/2, rows/2, tmp, 4);
-        const SecondOrderInputDescriptor a(tmp.ptr<float>(0), channels, 1);
-        const SecondOrderInputDescriptor b(tmp.ptr<float>(1), channels, 1);
-        const SecondOrderInputDescriptor c(tmp.ptr<float>(2), channels, 1);
-        const SecondOrderInputDescriptor d(tmp.ptr<float>(3), channels, 1);
-        const SecondOrderInputDescriptor e(tmp.ptr<float>(4), channels, 1);
-
-        dst = Mat(5, channels, CV_32FC1);
-        OutputDescriptor(dst.ptr<float>(0), channels, 1) = (a+b+c+d)/4.f;
-        OutputDescriptor(dst.ptr<float>(1), channels, 1) = ((a+b+c+d)/4.f-e);
-        OutputDescriptor(dst.ptr<float>(2), channels, 1) = ((a+b)-(c+d))/2.f;
-        OutputDescriptor(dst.ptr<float>(3), channels, 1) = ((a+c)-(b+d))/2.f;
-        OutputDescriptor(dst.ptr<float>(4), channels, 1) = ((a+d)-(b+c))/2.f;
-        dst = dst.reshape(1, 1);
-    }
-
-    Template subdivide(const Template &src) const
-    {
-        // Integral images have an extra row and column
-        int subWidth = (src.m().cols-1) / scaleFactor + 1;
-        int subHeight = (src.m().rows-1) / scaleFactor + 1;
-        return Template(src.file, QList<Mat>() << Mat(src, Rect(0,                     0, subWidth, subHeight))
-                                               << Mat(src, Rect(src.m().cols-subWidth, 0, subWidth, subHeight))
-                                               << Mat(src, Rect(0,                     src.m().rows-subHeight, subWidth, subHeight))
-                                               << Mat(src, Rect(src.m().cols-subWidth, src.m().rows-subHeight, subWidth, subHeight)));
-    }
-
-    bool canSubdivide(const Template &t) const
-    {
-        // Integral images have an extra row and column
-        const int subWidth = (t.m().cols-1) / scaleFactor;
-        const int subHeight = (t.m().rows-1) / scaleFactor;
-        return ((subWidth >= minSize) && (subHeight >= minSize));
-    }
-
-    void train(const TemplateList &src)
-    {
-        if (src.first().m().depth() != CV_32S)
-            qFatal("Expected CV_32S depth!");
-
-        if (subTransform != NULL) {
-            TemplateList subSrc; subSrc.reserve(src.size());
-            foreach (const Template &t, src)
-                if (canSubdivide(t))
-                    subSrc.append(subdivide(t));
-
-            if (subSrc.isEmpty()) {
-                delete subTransform;
-                subTransform = NULL;
-            } else {
-                subTransform->train(subSrc);
-            }
-        }
-
-        TemplateList dst; dst.reserve(src.size());
-        foreach (const Template &t, src) {
-            Template u(t.file);
-            computeDescriptor(t, u);
-            dst.append(u);
-        }
-        transform->train(dst);
-    }
-
-    void project(const Template &src, Template &dst) const
-    {
-        computeDescriptor(src, dst);
-        transform->project(dst, dst);
-
-        if ((subTransform != NULL) && canSubdivide(src)) {
-            Template subDst;
-            subTransform->project(subdivide(src), subDst);
-            dst.append(subDst);
-        }
-    }
-
-    void store(QDataStream &stream) const
-    {
-        transform->store(stream);
-        stream << (subTransform != NULL);
-        if (subTransform != NULL)
-            subTransform->store(stream);
-    }
-
-    void load(QDataStream &stream)
-    {
-        transform->load(stream);
-        bool hasSubTransform;
-        stream >> hasSubTransform;
-        if (hasSubTransform) subTransform->load(stream);
-        else                 { delete subTransform; subTransform = NULL; }
-    }
-};
-
-BR_REGISTER(Transform, RecursiveIntegralSamplerTransform)
-
-/*!
- * \ingroup transforms
- * \brief Computes magnitude and/or angle of image.
- * \author Josh Klontz \cite jklontz
- */
-class GradientTransform : public UntrainableTransform
-{
-    Q_OBJECT
-    Q_ENUMS(Channel)
-    Q_PROPERTY(Channel channel READ get_channel WRITE set_channel RESET reset_channel STORED false)
-
-public:
-    enum Channel { Magnitude, Angle, MagnitudeAndAngle };
-
-private:
-    BR_PROPERTY(Channel, channel, Angle)
-
-    void project(const Template &src, Template &dst) const
-    {
-        Mat dx, dy, magnitude, angle;
-        Sobel(src, dx, CV_32F, 1, 0, CV_SCHARR);
-        Sobel(src, dy, CV_32F, 0, 1, CV_SCHARR);
-        cartToPolar(dx, dy, magnitude, angle, true);
-        std::vector<Mat> mv;
-        if ((channel == Magnitude) || (channel == MagnitudeAndAngle)) {
-            const float theoreticalMaxMagnitude = sqrt(2*pow(float(2*(3+10+3)*255), 2.f));
-            mv.push_back(magnitude / theoreticalMaxMagnitude);
-        }
-        if ((channel == Angle) || (channel == MagnitudeAndAngle))
-            mv.push_back(angle);
-        Mat result;
-        merge(mv, result);
-        dst.append(result);
-    }
-};
-
-BR_REGISTER(Transform, GradientTransform)
-
-/*!
- * \ingroup transforms
- * \brief Projects each row based on a computed word.
- * \author Josh Klontz \cite jklontz
- */
-class WordWiseTransform : public Transform
-{
-    Q_OBJECT
-    Q_PROPERTY(br::Transform* getWords READ get_getWords WRITE set_getWords RESET reset_getWords)
-    Q_PROPERTY(br::Transform* byWord READ get_byWord WRITE set_byWord RESET reset_byWord)
-    Q_PROPERTY(int numWords READ get_numWords WRITE set_numWords RESET reset_numWords)
-    BR_PROPERTY(br::Transform*, getWords, NULL)
-    BR_PROPERTY(br::Transform*, byWord, NULL)
-    BR_PROPERTY(int, numWords, 0)
-
-    void train(const TemplateList &data)
-    {
-        getWords->train(data);
-        TemplateList bins;
-        getWords->project(data, bins);
-
-        numWords = 0;
-        foreach (const Template &t, bins) {
-            double minVal, maxVal;
-            minMaxLoc(t, &minVal, &maxVal);
-            numWords = max(numWords, int(maxVal)+1);
-        }
-
-        TemplateList reworded; reworded.reserve(data.size());
-        foreach (const Template &t, data)
-            reworded.append(reword(t));
-        byWord->train(reworded);
-    }
-
-    void project(const Template &src, Template &dst) const
-    {
-        byWord->project(reword(src), dst);
-    }
-
-    Template reword(const Template &src) const
-    {
-        Template words;
-        getWords->project(src, words);
-        QVector<int> wordCounts(numWords, 0);
-        for (int i=0; i<words.m().rows; i++)
-            wordCounts[words.m().at<uchar>(i,0)]++;
-        Template reworded(src.file); reworded.reserve(numWords);
-        for (int i=0; i<numWords; i++)
-            reworded.append(Mat(wordCounts[i], src.m().cols, src.m().type()));
-        QVector<int> indicies(numWords, 0);
-        for (int i=0; i<src.m().rows; i++) {
-            const int word = words.m().at<uchar>(i,0);
-            src.m().row(i).copyTo(reworded[word].row(indicies[word]++));
-        }
-        return reworded;
-    }
-};
-
-BR_REGISTER(Transform, WordWiseTransform)
-
-} // namespace br
-
-#include "integral.moc"
diff --git a/openbr/plugins/io/decode.cpp b/openbr/plugins/io/decode.cpp
new file mode 100644
index 0000000..2f12245
--- /dev/null
+++ b/openbr/plugins/io/decode.cpp
@@ -0,0 +1,43 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * Copyright 2012 The MITRE Corporation                                      *
+ *                                                                           *
+ * Licensed under the Apache License, Version 2.0 (the "License");           *
+ * you may not use this file except in compliance with the License.          *
+ * You may obtain a copy of the License at                                   *
+ *                                                                           *
+ *     http://www.apache.org/licenses/LICENSE-2.0                            *
+ *                                                                           *
+ * Unless required by applicable law or agreed to in writing, software       *
+ * distributed under the License is distributed on an "AS IS" BASIS,         *
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  *
+ * See the License for the specific language governing permissions and       *
+ * limitations under the License.                                            *
+ * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+
+#include <opencv2/highgui/highgui.hpp>
+
+#include <openbr/plugins/openbr_internal.h>
+
+namespace br
+{
+
+/*!
+ * \ingroup transforms
+ * \brief Decodes images
+ * \author Josh Klontz \cite jklontz
+ */
+class DecodeTransform : public UntrainableTransform
+{
+    Q_OBJECT
+
+    void project(const Template &src, Template &dst) const
+    {
+        dst.append(cv::imdecode(src.m(), cv::IMREAD_UNCHANGED));
+    }
+};
+
+BR_REGISTER(Transform, DecodeTransform)
+
+} // namespace br
+
+#include "io/decode.moc"
diff --git a/openbr/plugins/io/download.cpp b/openbr/plugins/io/download.cpp
new file mode 100644
index 0000000..dbffb5e
--- /dev/null
+++ b/openbr/plugins/io/download.cpp
@@ -0,0 +1,126 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * 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 <QtNetwork>
+#include <opencv2/highgui/highgui.hpp>
+
+#include <openbr/plugins/openbr_internal.h>
+
+using namespace cv;
+
+namespace br
+{
+
+/*!
+ * \ingroup transforms
+ * \brief Downloads an image from a URL
+ * \author Josh Klontz \cite jklontz
+ */
+class DownloadTransform : public UntrainableMetaTransform
+{
+    Q_OBJECT
+    Q_ENUMS(Mode)
+    Q_PROPERTY(Mode mode READ get_mode WRITE set_mode RESET reset_mode STORED false)
+
+public:
+    enum Mode { Permissive,
+                Encoded,
+                Decoded };
+private:
+    BR_PROPERTY(Mode, mode, Encoded)
+
+    // The reasons for this data structure are as follows:
+    // 1) The QNetworkAccessManager must be used in the thread that _created_ it,
+    //    hence the use of `QThreadStorage`.
+    // 2) The QThreadStorage must be deleted _after_ the threads that added QNetworkAccessManager
+    //    to it are deleted, hence the `static` ensuring that `nam` is deleted at program termination,
+    //    long after the threads that created QNetworkAccessManager are deleted.
+    static QThreadStorage<QNetworkAccessManager*> nam;
+
+    void project(const Template &src, Template &dst) const
+    {
+        dst.file = src.file;
+        QString url = src.file.get<QString>("URL", src.file.name).simplified();
+        if (!url.contains("://"))
+            url = "file://" + url;
+        dst.file.set("URL", url);
+
+        static const QRegularExpression regExp("file:///[A-Z]:/");
+
+        if (url.contains(regExp))
+            url = url.mid(8);
+        else if (url.startsWith("file://"))
+            url = url.mid(7);
+
+        QIODevice *device = NULL;
+        if (QFileInfo(url).exists()) {
+            device = new QFile(url);
+            device->open(QIODevice::ReadOnly);
+        } else {
+            if (!nam.hasLocalData())
+                nam.setLocalData(new QNetworkAccessManager());
+            const QUrl qURL(url, QUrl::StrictMode);
+            if (qURL.isValid() && !qURL.isRelative()) {
+                QNetworkRequest req = QNetworkRequest(qURL);
+                req.setRawHeader("User-Agent", "br");
+                QNetworkReply *reply = nam.localData()->get(req);
+
+                reply->waitForReadyRead(-1);
+                while (!reply->isFinished())
+                    QCoreApplication::processEvents();
+
+                if (reply->error() != QNetworkReply::NoError) {
+                    qDebug() << reply->errorString() << url;
+                    reply->deleteLater();
+                } else {
+                    device = reply;
+                }
+            }
+        }
+
+        QByteArray data;
+        if (device) {
+            data = device->readAll();
+            delete device;
+            device = NULL;
+        }
+
+        if (!data.isEmpty()) {
+            Mat encoded(1, data.size(), CV_8UC1, (void*)data.data());
+            encoded = encoded.clone();
+            if (mode == Permissive) {
+                dst += encoded;
+            } else {
+                Mat decoded = imdecode(encoded, IMREAD_UNCHANGED);
+                if (!decoded.empty())
+                    dst += (mode == Encoded) ? encoded : decoded;
+            }
+
+            dst.file.set("ImageID", QVariant(QCryptographicHash::hash(data, QCryptographicHash::Md5).toHex()));
+            dst.file.set("AlgorithmID", data.isEmpty() ? 0 : (mode == Decoded ? 5 : 3));
+        } else {
+            dst.file.fte = true;
+            qWarning("Error opening %s", qPrintable(url));
+        }
+    }
+};
+QThreadStorage<QNetworkAccessManager*> DownloadTransform::nam;
+
+BR_REGISTER(Transform, DownloadTransform)
+
+} // namespace br
+
+#include "io/download.moc"
diff --git a/openbr/plugins/io/galleryoutput.cpp b/openbr/plugins/io/galleryoutput.cpp
new file mode 100644
index 0000000..152dc50
--- /dev/null
+++ b/openbr/plugins/io/galleryoutput.cpp
@@ -0,0 +1,60 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * 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 GalleryOutputTransform : public TimeVaryingTransform
+{
+    Q_OBJECT
+
+    Q_PROPERTY(QString outputString READ get_outputString WRITE set_outputString RESET reset_outputString STORED false)
+    BR_PROPERTY(QString, outputString, "")
+
+    void projectUpdate(const TemplateList &src, TemplateList &dst)
+    {
+        if (src.empty())
+            return;
+        dst = src;
+        for (int i=0; i < dst.size();i++) {
+            if (dst[i].file.getBool("FTE"))
+                dst[i].file.fte = true;
+        }
+        writer->writeBlock(dst);
+    }
+
+    void train(const TemplateList& data)
+    {
+        (void) data;
+    }
+    ;
+    void init()
+    {
+        writer = QSharedPointer<Gallery>(Gallery::make(outputString));
+    }
+
+    QSharedPointer<Gallery> writer;
+public:
+    GalleryOutputTransform() : TimeVaryingTransform(false,false) {}
+};
+
+BR_REGISTER(Transform, GalleryOutputTransform)
+
+} // namespace br
+
+#include "io/galleryoutput.moc"
diff --git a/openbr/plugins/io/incrementaloutput.cpp b/openbr/plugins/io/incrementaloutput.cpp
new file mode 100644
index 0000000..2b28016
--- /dev/null
+++ b/openbr/plugins/io/incrementaloutput.cpp
@@ -0,0 +1,93 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * 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 Incrementally output templates received to a gallery, based on the current filename
+ * When a template is received in projectUpdate for the first time since a finalize, open a new gallery based on the
+ * template's filename, and the galleryFormat property.
+ * Templates received in projectUpdate will be output to the gallery with a filename combining their original filename and
+ * their FrameNumber property, with the file extension specified by the fileFormat property.
+ * \author Charles Otto \cite caotto
+ */
+class IncrementalOutputTransform : public TimeVaryingTransform
+{
+    Q_OBJECT
+
+    Q_PROPERTY(QString galleryFormat READ get_galleryFormat WRITE set_galleryFormat RESET reset_galleryFormat STORED false)
+    Q_PROPERTY(QString fileFormat READ get_fileFormat WRITE set_fileFormat RESET reset_fileFormat STORED false)
+    BR_PROPERTY(QString, galleryFormat, "")
+    BR_PROPERTY(QString, fileFormat, ".png")
+
+    bool galleryUp;
+
+    void projectUpdate(const TemplateList &src, TemplateList &dst)
+    {
+        if (src.empty())
+            return;
+
+        if (!galleryUp) {
+            QFileInfo finfo(src[0].file.name);
+            QString galleryName = finfo.baseName() + galleryFormat;
+
+            writer = QSharedPointer<Gallery> (Factory<Gallery>::make(galleryName));
+            galleryUp = true;
+        }
+
+        dst = src;
+        int idx =0;
+        foreach (const Template &t, src) {
+            if (t.empty())
+                continue;
+
+            // Build the output filename for this template
+            QFileInfo finfo(t.file.name);
+            QString outputName = finfo.baseName() +"_" + t.file.get<QString>("FrameNumber") + "_" + QString::number(idx)+ fileFormat;
+
+            idx++;
+            Template out = t;
+            out.file.name = outputName;
+            writer->write(out);
+        }
+    }
+
+    void train(const TemplateList& data)
+    {
+        (void) data;
+    }
+
+    // Drop the current gallery.
+    void finalize(TemplateList &data)
+    {
+        (void) data;
+        galleryUp = false;
+    }
+
+    QSharedPointer<Gallery> writer;
+public:
+    IncrementalOutputTransform() : TimeVaryingTransform(false,false) {galleryUp = false;}
+};
+
+BR_REGISTER(Transform, IncrementalOutputTransform)
+
+} // namespace br
+
+#include "io/incrementaloutput.moc"
diff --git a/openbr/plugins/io/open.cpp b/openbr/plugins/io/open.cpp
new file mode 100644
index 0000000..dbd2f1f
--- /dev/null
+++ b/openbr/plugins/io/open.cpp
@@ -0,0 +1,72 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * Copyright 2012 The MITRE Corporation                                      *
+ *                                                                           *
+ * Licensed under the Apache License, Version 2.0 (the "License");           *
+ * you may not use this file except in compliance with the License.          *
+ * You may obtain a copy of the License at                                   *
+ *                                                                           *
+ *     http://www.apache.org/licenses/LICENSE-2.0                            *
+ *                                                                           *
+ * Unless required by applicable law or agreed to in writing, software       *
+ * distributed under the License is distributed on an "AS IS" BASIS,         *
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  *
+ * See the License for the specific language governing permissions and       *
+ * limitations under the License.                                            *
+ * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+
+#include <opencv2/highgui/highgui.hpp>
+
+#include <openbr/plugins/openbr_internal.h>
+
+using namespace cv;
+
+namespace br
+{
+
+/*!
+ * \ingroup transforms
+ * \brief Applies br::Format to br::Template::file::name and appends results.
+ * \author Josh Klontz \cite jklontz
+ */
+class OpenTransform : public UntrainableMetaTransform
+{
+    Q_OBJECT
+
+    void project(const Template &src, Template &dst) const
+    {
+        dst.file = src.file;
+        if (src.empty()) {
+            if (Globals->verbose)
+                qDebug("Opening %s", qPrintable(src.file.flat()));
+
+            // Read from disk otherwise
+            foreach (const File &file, src.file.split()) {
+                QScopedPointer<Format> format(Factory<Format>::make(file));
+                Template t = format->read();
+                if (t.isEmpty())
+                    qWarning("Can't open %s from %s", qPrintable(file.flat()), qPrintable(QDir::currentPath()));
+                dst.append(t);
+                dst.file.append(t.file.localMetadata());
+            }
+            if (dst.isEmpty())
+                dst.file.fte = true;
+        } else {
+            // Propogate or decode existing matricies
+            foreach (const Mat &m, src) {
+                if (((m.rows > 1) && (m.cols > 1)) || (m.type() != CV_8UC1))
+                    dst += m;
+                else {
+                    Mat dec = imdecode(src.m(), IMREAD_UNCHANGED);
+                    if (dec.empty()) qWarning("Can't decode %s", qPrintable(src.file.flat()));
+                    else dst += dec;
+                }
+            }
+        }
+    }
+};
+
+BR_REGISTER(Transform, OpenTransform)
+
+} // namespace br
+
+#include "io/open.moc"
diff --git a/openbr/plugins/io/out.cpp b/openbr/plugins/io/out.cpp
new file mode 100644
index 0000000..7761328
--- /dev/null
+++ b/openbr/plugins/io/out.cpp
@@ -0,0 +1,158 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * 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 OutputTransform : public TimeVaryingTransform
+{
+    Q_OBJECT
+
+    Q_PROPERTY(QString outputString READ get_outputString WRITE set_outputString RESET reset_outputString STORED false)
+    // names of mem galleries containing filelists we need.
+    Q_PROPERTY(QString targetName READ get_targetName WRITE set_targetName RESET reset_targetName STORED false)
+    Q_PROPERTY(QString queryName  READ get_queryName WRITE set_queryName RESET reset_queryName STORED false)
+    Q_PROPERTY(bool transposeMode  READ get_transposeMode WRITE set_transposeMode RESET reset_transposeMode STORED false)
+
+    BR_PROPERTY(QString, outputString, "")
+    BR_PROPERTY(QString, targetName, "")
+    BR_PROPERTY(QString, queryName, "")
+    BR_PROPERTY(bool, transposeMode, false)
+
+    void projectUpdate(const TemplateList &src, TemplateList &dst)
+    {
+        dst = src;
+
+        if (src.empty())
+            return;
+
+        // we received a template, which is the next row/column in order
+        foreach (const Template &t, dst) {
+            bool fte = t.file.getBool("FTE") || t.file.fte;
+
+            for (int i=0; i < scoresPerMat; i++) {
+                output->setRelative(fte ? -std::numeric_limits<float>::max() : t.m().at<float>(0, i), currentRow, currentCol);
+
+                // row-major input
+                if (!transposeMode)
+                    currentCol++;
+                // col-major input
+                else
+                    currentRow++;
+            }
+            // filled in a row, advance to the next, reset column position
+            if (!transposeMode) {
+                currentRow++;
+                currentCol = 0;
+            }
+            // filled in a column, advance, reset row
+            else {
+                currentCol++;
+                currentRow = 0;
+            }
+
+            bool blockDone = false;
+            // In direct mode, we don't buffer rows
+            if (!transposeMode) {
+                currentBlockRow++;
+                blockDone = true;
+            }
+            // in transpose mode, we buffer 100 cols before writing the block
+            else if (currentCol == bufferedSize) {
+                currentBlockCol++;
+                blockDone = true;
+            }
+            else return;
+
+            if (blockDone) {
+                // set the next block, only necessary if we haven't buffered the current item
+                output->setBlock(currentBlockRow, currentBlockCol);
+                currentRow = 0;
+                currentCol = 0;
+            }
+        }
+    }
+
+    void train(const TemplateList& data)
+    {
+        (void) data;
+    }
+
+    void init()
+    {
+        if (targetName.isEmpty() || queryName.isEmpty() || outputString.isEmpty())
+            return;
+
+        FileList targetFiles = FileList::fromGallery(targetName);
+        FileList queryFiles  = FileList::fromGallery(queryName);
+
+        currentBlockRow = 0;
+        currentBlockCol = 0;
+
+        currentRow = 0;
+        currentCol = 0;
+
+        bufferedSize = 100;
+
+        if (transposeMode) {
+            // buffer 100 cols at a time
+            fragmentsPerRow = bufferedSize;
+            // a single col contains comparisons to all query files
+            fragmentsPerCol = queryFiles.size();
+            scoresPerMat = fragmentsPerCol;
+        }
+        else {
+            // a single row contains comparisons to all target files
+            fragmentsPerRow = targetFiles.size();
+            scoresPerMat = fragmentsPerRow;
+            // we output rows one at a time
+            fragmentsPerCol = 1;
+        }
+
+        output = QSharedPointer<Output>(Output::make(outputString+"[targetGallery="+targetName+",queryGallery="+queryName+"]", targetFiles, queryFiles));
+        output->blockRows = fragmentsPerCol;
+        output->blockCols = fragmentsPerRow;
+        output->initialize(targetFiles, queryFiles);
+
+        output->setBlock(currentBlockRow, currentBlockCol);
+    }
+
+    QSharedPointer<Output> output;
+
+    int bufferedSize;
+
+    int currentRow;
+    int currentCol;
+
+    int currentBlockRow;
+    int currentBlockCol;
+
+    int fragmentsPerRow;
+    int fragmentsPerCol;
+
+    int scoresPerMat;
+
+public:
+    OutputTransform() : TimeVaryingTransform(false,false) {}
+};
+
+BR_REGISTER(Transform, OutputTransform)
+
+} // namespace br
+
+#include "io/out.moc"
diff --git a/openbr/plugins/io/print.cpp b/openbr/plugins/io/print.cpp
new file mode 100644
index 0000000..8ab489d
--- /dev/null
+++ b/openbr/plugins/io/print.cpp
@@ -0,0 +1,53 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * 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 Prints the template's file to stdout or stderr.
+ * \author Josh Klontz \cite jklontz
+ */
+class PrintTransform : public UntrainableMetaTransform
+{
+    Q_OBJECT
+    Q_PROPERTY(bool error READ get_error WRITE set_error RESET reset_error)
+    Q_PROPERTY(bool data READ get_data WRITE set_data RESET reset_data)
+    BR_PROPERTY(bool, error, true)
+    BR_PROPERTY(bool, data, false)
+
+    void project(const Template &src, Template &dst) const
+    {
+        dst = src;
+        const QString nameString = src.file.flat();
+        const QString dataString = data ? OpenCVUtils::matrixToString(src)+"\n" : QString();
+        QStringList matricies;
+        foreach (const cv::Mat &m, src)
+            matricies.append(QString::number(m.rows) + "x" + QString::number(m.cols) + "_" + OpenCVUtils::typeToString(m));
+        QString fteString = src.file.fte ? "\n  FTE=true" : QString();
+        fprintf(error ? stderr : stdout, "%s%s\n  %s\n%s", qPrintable(nameString), qPrintable(fteString), qPrintable(matricies.join(",")), qPrintable(dataString));
+    }
+};
+
+BR_REGISTER(Transform, PrintTransform)
+
+} // namespace br
+
+#include "io/print.moc"
diff --git a/openbr/plugins/io/read.cpp b/openbr/plugins/io/read.cpp
new file mode 100644
index 0000000..1450c55
--- /dev/null
+++ b/openbr/plugins/io/read.cpp
@@ -0,0 +1,76 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * Copyright 2012 The MITRE Corporation                                      *
+ *                                                                           *
+ * Licensed under the Apache License, Version 2.0 (the "License");           *
+ * you may not use this file except in compliance with the License.          *
+ * You may obtain a copy of the License at                                   *
+ *                                                                           *
+ *     http://www.apache.org/licenses/LICENSE-2.0                            *
+ *                                                                           *
+ * Unless required by applicable law or agreed to in writing, software       *
+ * distributed under the License is distributed on an "AS IS" BASIS,         *
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  *
+ * See the License for the specific language governing permissions and       *
+ * limitations under the License.                                            *
+ * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+
+#include <opencv2/highgui/highgui.hpp>
+
+#include <openbr/plugins/openbr_internal.h>
+
+using namespace cv;
+
+namespace br
+{
+
+/*!
+ * \ingroup transforms
+ * \brief Read images
+ * \author Josh Klontz \cite jklontz
+ */
+class ReadTransform : public UntrainableMetaTransform
+{
+    Q_OBJECT
+    Q_ENUMS(Mode)
+    Q_PROPERTY(Mode mode READ get_mode WRITE set_mode RESET reset_mode)
+
+public:
+    enum Mode
+    {
+        Unchanged = IMREAD_UNCHANGED,
+        Grayscale = IMREAD_GRAYSCALE,
+        Color     = IMREAD_COLOR,
+        AnyDepth  = IMREAD_ANYDEPTH,
+        AnyColor  = IMREAD_ANYCOLOR
+    };
+
+private:
+    BR_PROPERTY(Mode, mode, Color)
+
+    void project(const Template &src, Template &dst) const
+    {
+        dst.file = src.file;
+        if (Globals->verbose)
+            qDebug("Opening %s", qPrintable(src.file.flat()));
+
+        if (src.empty()) {
+            const Mat img = imread(src.file.resolved().toStdString(), mode);
+            if (img.data) dst.append(img);
+            else          dst.file.fte = true;
+        } else {
+            foreach (const Mat &m, src) {
+                const Mat img = imdecode(m, mode);
+                if (img.data) dst.append(img);
+                else          dst.file.fte = true;
+            }
+        }
+        if (dst.file.fte)
+            qWarning("Error opening %s", qPrintable(src.file.flat()));
+    }
+};
+
+BR_REGISTER(Transform, ReadTransform)
+
+} // namespace br
+
+#include "io/read.moc"
diff --git a/openbr/plugins/io/readlandmarks.cpp b/openbr/plugins/io/readlandmarks.cpp
new file mode 100644
index 0000000..700a9d1
--- /dev/null
+++ b/openbr/plugins/io/readlandmarks.cpp
@@ -0,0 +1,81 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * 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 Read landmarks from a file and associate them with the correct templates.
+ * \author Scott Klum \cite sklum
+ *
+ * Example of the format:
+ * \code
+ * image_001.jpg:146.000000,190.000000,227.000000,186.000000,202.000000,256.000000
+ * image_002.jpg:75.000000,235.000000,140.000000,225.000000,91.000000,300.000000
+ * image_003.jpg:158.000000,186.000000,246.000000,188.000000,208.000000,233.000000
+ * \endcode
+ */
+class ReadLandmarksTransform : public UntrainableMetadataTransform
+{
+    Q_OBJECT
+
+    Q_PROPERTY(QString file READ get_file WRITE set_file RESET reset_file STORED false)
+    Q_PROPERTY(QString imageDelimiter READ get_imageDelimiter WRITE set_imageDelimiter RESET reset_imageDelimiter STORED false)
+    Q_PROPERTY(QString landmarkDelimiter READ get_landmarkDelimiter WRITE set_landmarkDelimiter RESET reset_landmarkDelimiter STORED false)
+    BR_PROPERTY(QString, file, QString())
+    BR_PROPERTY(QString, imageDelimiter, ":")
+    BR_PROPERTY(QString, landmarkDelimiter, ",")
+
+    QHash<QString, QList<QPointF> > landmarks;
+
+    void init()
+    {
+        if (file.isEmpty())
+            return;
+
+        QFile f(file);
+        if (!f.open(QFile::ReadOnly | QFile::Text))
+            qFatal("Failed to open %s for reading.", qPrintable(f.fileName()));
+
+        while (!f.atEnd()) {
+            const QStringList words = QString(f.readLine()).split(imageDelimiter);
+            const QStringList lm = words[1].split(landmarkDelimiter);
+
+            QList<QPointF> points;
+            bool ok;
+            for (int i=0; i<lm.size(); i+=2)
+                points.append(QPointF(lm[i].toFloat(&ok),lm[i+1].toFloat(&ok)));
+            if (!ok) qFatal("Failed to read landmark.");
+
+            landmarks.insert(words[0],points);
+        }
+    }
+
+    void projectMetadata(const File &src, File &dst) const
+    {
+        dst = src;
+        dst.appendPoints(landmarks[dst.fileName()]);
+    }
+};
+
+BR_REGISTER(Transform, ReadLandmarksTransform)
+
+} // namespace br
+
+#include "io/readlandmarks.moc"
diff --git a/openbr/plugins/io/write.cpp b/openbr/plugins/io/write.cpp
new file mode 100644
index 0000000..b030d36
--- /dev/null
+++ b/openbr/plugins/io/write.cpp
@@ -0,0 +1,60 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * 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 Write all mats to disk as images.
+ * \author Brendan Klare \cite bklare
+ */
+class WriteTransform : public TimeVaryingTransform
+{
+    Q_OBJECT
+    Q_PROPERTY(QString outputDirectory READ get_outputDirectory WRITE set_outputDirectory RESET reset_outputDirectory STORED false)
+    Q_PROPERTY(QString imageName READ get_imageName WRITE set_imageName RESET reset_imageName STORED false)
+    Q_PROPERTY(QString imgExtension READ get_imgExtension WRITE set_imgExtension RESET reset_imgExtension STORED false)
+    BR_PROPERTY(QString, outputDirectory, "Temp")
+    BR_PROPERTY(QString, imageName, "image")
+    BR_PROPERTY(QString, imgExtension, "jpg")
+
+    int cnt;
+
+    void init() {
+        cnt = 0;
+        if (! QDir(outputDirectory).exists())
+            QDir().mkdir(outputDirectory);
+    }
+
+    void projectUpdate(const Template &src, Template &dst)
+    {
+        dst = src;
+        OpenCVUtils::saveImage(dst.m(), QString("%1/%2_%3.%4").arg(outputDirectory).arg(imageName).arg(cnt++, 5, 10, QChar('0')).arg(imgExtension));
+    }
+
+};
+
+BR_REGISTER(Transform, WriteTransform)
+
+} // namespace br
+
+#include "io/write.moc"
diff --git a/openbr/plugins/youtube.cpp b/openbr/plugins/io/youtubefacesdb.cpp
index 0f01445..b0655db 100644
--- a/openbr/plugins/youtube.cpp
+++ b/openbr/plugins/io/youtubefacesdb.cpp
@@ -1,8 +1,23 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * 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 <QCoreApplication>
 #include <QProcess>
-#include "openbr_internal.h"
 
-#include "openbr/core/common.h"
+#include <openbr/plugins/openbr_internal.h>
 
 namespace br
 {
@@ -31,7 +46,7 @@ class YouTubeFacesDBTransform : public UntrainableMetaTransform
                                                     << "-parallelism" << QString::number(Globals->parallelism)
                                                     << "-path" << Globals->path
                                                     << "-compare" << File(words[2]).resolved() << File(words[3]).resolved() << matrix;
-        mutex.lock();    
+        mutex.lock();
         int result = 0;
         if (!QFileInfo(matrix).exists())
             result = QProcess::execute(QCoreApplication::applicationFilePath(), arguments);
@@ -47,4 +62,4 @@ BR_REGISTER(Transform, YouTubeFacesDBTransform)
 
 } // namespace br
 
-#include "youtube.moc"
+#include "io/youtubefacesdb.moc"
diff --git a/openbr/plugins/landmarks.cpp b/openbr/plugins/landmarks.cpp
deleted file mode 100644
index a76dc57..0000000
--- a/openbr/plugins/landmarks.cpp
+++ /dev/null
@@ -1,535 +0,0 @@
-#include <opencv2/opencv.hpp>
-#include "openbr_internal.h"
-#include "openbr/core/qtutils.h"
-#include "openbr/core/opencvutils.h"
-#include "openbr/core/eigenutils.h"
-#include <QString>
-#include <Eigen/SVD>
-#include <Eigen/Dense>
-
-using namespace std;
-using namespace cv;
-using namespace Eigen;
-
-namespace br
-{
-
-/*!
- * \ingroup transforms
- * \brief Procrustes alignment of points
- * \author Scott Klum \cite sklum
- */
-class ProcrustesTransform : public Transform
-{
-    Q_OBJECT
-
-    Q_PROPERTY(bool warp READ get_warp WRITE set_warp RESET reset_warp STORED false)
-    BR_PROPERTY(bool, warp, true)
-
-    Eigen::MatrixXf meanShape;
-
-    void train(const TemplateList &data)
-    {
-        QList< QList<QPointF> > normalizedPoints;
-
-        // Normalize all sets of points
-        foreach (br::Template datum, data) {
-            QList<QPointF> points = datum.file.points();
-            QList<QRectF> rects = datum.file.rects();
-
-            if (points.empty() || rects.empty()) continue;
-
-            // Assume rect appended last was bounding box
-            points.append(rects.last().topLeft());
-            points.append(rects.last().topRight());
-            points.append(rects.last().bottomLeft());
-            points.append(rects.last().bottomRight());
-
-            // Center shape at origin
-            Scalar mean = cv::mean(OpenCVUtils::toPoints(points).toVector().toStdVector());
-            for (int i = 0; i < points.size(); i++) points[i] -= QPointF(mean[0],mean[1]);
-
-            // Remove scale component
-            float norm = cv::norm(OpenCVUtils::toPoints(points).toVector().toStdVector());
-            for (int i = 0; i < points.size(); i++) points[i] /= norm;
-
-            normalizedPoints.append(points);
-        }
-
-        if (normalizedPoints.empty()) qFatal("Unable to calculate normalized points");
-
-        // Determine mean shape, assuming all shapes contain the same number of points
-        meanShape = Eigen::MatrixXf(normalizedPoints[0].size(), 2);
-
-        for (int i = 0; i < normalizedPoints[0].size(); i++) {
-            double x = 0;
-            double y = 0;
-
-            for (int j = 0; j < normalizedPoints.size(); j++) {
-                x += normalizedPoints[j][i].x();
-                y += normalizedPoints[j][i].y();
-            }
-
-            x /= (double)normalizedPoints.size();
-            y /= (double)normalizedPoints.size();
-
-            meanShape(i,0) = x;
-            meanShape(i,1) = y;
-        }
-    }
-
-    void project(const Template &src, Template &dst) const
-    {
-        QList<QPointF> points = src.file.points();
-        QList<QRectF> rects = src.file.rects();
-
-        if (points.empty() || rects.empty()) {
-            dst = src;
-            if (Globals->verbose) qWarning("Procrustes alignment failed because points or rects are empty.");
-            return;
-        }
-
-        // Assume rect appended last was bounding box
-        points.append(rects.last().topLeft());
-        points.append(rects.last().topRight());
-        points.append(rects.last().bottomLeft());
-        points.append(rects.last().bottomRight());
-
-        Scalar mean = cv::mean(OpenCVUtils::toPoints(points).toVector().toStdVector());
-        for (int i = 0; i < points.size(); i++) points[i] -= QPointF(mean[0],mean[1]);
-
-        Eigen::MatrixXf srcMat(points.size(), 2);
-        float norm = cv::norm(OpenCVUtils::toPoints(points).toVector().toStdVector());
-        for (int i = 0; i < points.size(); i++) {
-            points[i] /= norm;
-            srcMat(i,0) = points[i].x();
-            srcMat(i,1) = points[i].y();
-        }
-
-        Eigen::JacobiSVD<Eigen::MatrixXf> svd(srcMat.transpose()*meanShape, Eigen::ComputeThinU | Eigen::ComputeThinV);
-        Eigen::MatrixXf R = svd.matrixU()*svd.matrixV().transpose();
-
-        dst = src;
-
-        // Store procrustes stats in the order:
-        // R(0,0), R(1,0), R(1,1), R(0,1), mean_x, mean_y, norm
-        QList<float> procrustesStats;
-        procrustesStats << R(0,0) << R(1,0) << R(1,1) << R(0,1) << mean[0] << mean[1] << norm;
-        dst.file.setList<float>("ProcrustesStats",procrustesStats);
-
-        if (warp) {
-            Eigen::MatrixXf dstMat = srcMat*R;
-            for (int i = 0; i < dstMat.rows(); i++) {
-                dst.file.appendPoint(QPointF(dstMat(i,0),dstMat(i,1)));
-            }
-        }
-    }
-
-    void store(QDataStream &stream) const
-    {
-        stream << meanShape;
-    }
-
-    void load(QDataStream &stream)
-    {
-        stream >> meanShape;
-    }
-
-};
-
-BR_REGISTER(Transform, ProcrustesTransform)
-
-/*!
- * \ingroup transforms
- * \brief Creates a Delaunay triangulation based on a set of points
- * \author Scott Klum \cite sklum
- */
-class DelaunayTransform : public Transform
-{
-    Q_OBJECT
-
-    Q_PROPERTY(float scaleFactor READ get_scaleFactor WRITE set_scaleFactor RESET reset_scaleFactor STORED false)
-    Q_PROPERTY(bool warp READ get_warp WRITE set_warp RESET reset_warp STORED false)
-    BR_PROPERTY(float, scaleFactor, 1)
-    BR_PROPERTY(bool, warp, true)
-
-    void project(const Template &src, Template &dst) const
-    {
-        QList<QPointF> points = src.file.points();
-        QList<QRectF> rects = src.file.rects();
-
-        if (points.empty() || rects.empty()) {
-            dst = src;
-            if (Globals->verbose) qWarning("Delauney triangulation failed because points or rects are empty.");
-            return;
-        }
-
-        int cols = src.m().cols;
-        int rows = src.m().rows;
-
-        // Assume rect appended last was bounding box
-        points.append(rects.last().topLeft());
-        points.append(rects.last().topRight());
-        points.append(rects.last().bottomLeft());
-        points.append(rects.last().bottomRight());
-
-        Subdiv2D subdiv(Rect(0,0,cols,rows));
-        // Make sure points are valid for Subdiv2D
-        // TODO: Modify points to make them valid
-        for (int i = 0; i < points.size(); i++) {
-            if (points[i].x() < 0 || points[i].y() < 0 || points[i].y() >= rows || points[i].x() >= cols) {
-                dst = src;
-                if (Globals->verbose) qWarning("Delauney triangulation failed because points lie on boundary.");
-                return;
-            }
-            subdiv.insert(OpenCVUtils::toPoint(points[i]));
-        }
-
-        vector<Vec6f> triangleList;
-        subdiv.getTriangleList(triangleList);
-
-        QList<QPointF> validTriangles;
-
-        for (size_t i = 0; i < triangleList.size(); i++) {
-            // Check the triangle to make sure it's falls within the matrix
-            bool valid = true;
-
-            QList<QPointF> vertices;
-            vertices.append(QPointF(triangleList[i][0],triangleList[i][1]));
-            vertices.append(QPointF(triangleList[i][2],triangleList[i][3]));
-            vertices.append(QPointF(triangleList[i][4],triangleList[i][5]));
-            for (int j = 0; j < 3; j++) if (vertices[j].x() > cols || vertices[j].y() > rows || vertices[j].x() < 0 || vertices[j].y() < 0) valid = false;
-
-            if (valid) validTriangles.append(vertices);
-        }
-
-        if (warp) {
-            dst.m() = Mat::zeros(rows,cols,src.m().type());
-
-            QList<float> procrustesStats = src.file.getList<float>("ProcrustesStats");
-
-            Eigen::MatrixXf R(2,2);
-            R(0,0) = procrustesStats.at(0);
-            R(1,0) = procrustesStats.at(1);
-            R(1,1) = procrustesStats.at(2);
-            R(0,1) = procrustesStats.at(3);
-
-            cv::Scalar mean(2);
-            mean[0] = procrustesStats.at(4);
-            mean[1] = procrustesStats.at(5);
-
-            float norm = procrustesStats.at(6);
-
-            QList<Point2f> mappedPoints;
-
-            for (int i = 0; i < validTriangles.size(); i+=3) {
-                // Matrix to store original (pre-transformed) triangle vertices
-                Eigen::MatrixXf srcMat(3, 2);
-
-                for (int j = 0; j < 3; j++) {
-                    srcMat(j,0) = (validTriangles[i+j].x()-mean[0])/norm;
-                    srcMat(j,1) = (validTriangles[i+j].y()-mean[1])/norm;
-                }
-
-                Eigen::MatrixXf dstMat = srcMat*R;
-
-                Point2f srcPoints[3];
-                for (int j = 0; j < 3; j++) srcPoints[j] = OpenCVUtils::toPoint(validTriangles[i+j]);
-
-                Point2f dstPoints[3];
-                for (int j = 0; j < 3; j++) {
-                    // Scale and shift destination points
-                    Point2f warpedPoint = Point2f(dstMat(j,0)*scaleFactor+cols/2,dstMat(j,1)*scaleFactor+rows/2);
-                    dstPoints[j] = warpedPoint;
-                    mappedPoints.append(warpedPoint);
-                }
-
-                Mat buffer(rows,cols,src.m().type());
-
-                warpAffine(src.m(), buffer, getAffineTransform(srcPoints, dstPoints), Size(cols,rows));
-
-                Mat mask = Mat::zeros(rows, cols, CV_8UC1);
-                Point maskPoints[1][3];
-                maskPoints[0][0] = dstPoints[0];
-                maskPoints[0][1] = dstPoints[1];
-                maskPoints[0][2] = dstPoints[2];
-                const Point* ppt = { maskPoints[0] };
-
-                fillConvexPoly(mask, ppt, 3, Scalar(255,255,255), 8);
-
-                Mat output(rows,cols,src.m().type());
-
-                if (i > 0) {
-                    Mat overlap;
-                    bitwise_and(dst.m(),mask,overlap);
-                    mask.setTo(0, overlap!=0);
-                }
-
-                bitwise_and(buffer,mask,output);
-
-                dst.m() += output;
-            }
-
-            // Overwrite any rects
-            Rect boundingBox = boundingRect(mappedPoints.toVector().toStdVector());
-            dst.file.setRects(QList<QRectF>() << OpenCVUtils::fromRect(boundingBox));
-        } else dst = src;
-
-        dst.file.setList<QPointF>("DelaunayTriangles", validTriangles);
-    }
-};
-
-BR_REGISTER(Transform, DelaunayTransform)
-
-/*!
- * \ingroup transforms
- * \brief Creates a Delaunay triangulation based on a set of points
- * \author Scott Klum \cite sklum
- */
-class DrawDelaunayTransform : public UntrainableTransform
-{
-    Q_OBJECT
-
-    void project(const Template &src, Template &dst) const
-    {
-        dst = src;
-
-        if (src.file.contains("DelaunayTriangles")) {
-            QList<Point2f> validTriangles = OpenCVUtils::toPoints(src.file.getList<QPointF>("DelaunayTriangles"));
-
-            // Clone the matrix do draw on it
-            for (int i = 0; i < validTriangles.size(); i+=3) {
-                line(dst, validTriangles[i], validTriangles[i+1], Scalar(0,0,0), 1);
-                line(dst, validTriangles[i+1], validTriangles[i+2], Scalar(0,0,0), 1);
-                line(dst, validTriangles[i+2], validTriangles[i], Scalar(0,0,0), 1);
-            }
-        } else qWarning("Template does not contain Delaunay triangulation.");
-    }
-};
-
-BR_REGISTER(Transform, DrawDelaunayTransform)
-
-/*!
- * \ingroup transforms
- * \brief Read landmarks from a file and associate them with the correct templates.
- * \author Scott Klum \cite sklum
- *
- * Example of the format:
- * \code
- * image_001.jpg:146.000000,190.000000,227.000000,186.000000,202.000000,256.000000
- * image_002.jpg:75.000000,235.000000,140.000000,225.000000,91.000000,300.000000
- * image_003.jpg:158.000000,186.000000,246.000000,188.000000,208.000000,233.000000
- * \endcode
- */
-class ReadLandmarksTransform : public UntrainableTransform
-{
-    Q_OBJECT
-
-    Q_PROPERTY(QString file READ get_file WRITE set_file RESET reset_file STORED false)
-    Q_PROPERTY(QString imageDelimiter READ get_imageDelimiter WRITE set_imageDelimiter RESET reset_imageDelimiter STORED false)
-    Q_PROPERTY(QString landmarkDelimiter READ get_landmarkDelimiter WRITE set_landmarkDelimiter RESET reset_landmarkDelimiter STORED false)
-    BR_PROPERTY(QString, file, QString())
-    BR_PROPERTY(QString, imageDelimiter, ":")
-    BR_PROPERTY(QString, landmarkDelimiter, ",")
-
-    QHash<QString, QList<QPointF> > landmarks;
-
-    void init()
-    {
-        if (file.isEmpty())
-            return;
-
-        QFile f(file);
-        if (!f.open(QFile::ReadOnly | QFile::Text))
-            qFatal("Failed to open %s for reading.", qPrintable(f.fileName()));
-
-        while (!f.atEnd()) {
-            const QStringList words = QString(f.readLine()).split(imageDelimiter);
-            const QStringList lm = words[1].split(landmarkDelimiter);
-
-            QList<QPointF> points;
-            bool ok;
-            for (int i=0; i<lm.size(); i+=2)
-                points.append(QPointF(lm[i].toFloat(&ok),lm[i+1].toFloat(&ok)));
-            if (!ok) qFatal("Failed to read landmark.");
-
-            landmarks.insert(words[0],points);
-        }
-    }
-
-    void project(const Template &src, Template &dst) const
-    {
-        dst = src;
-
-        dst.file.appendPoints(landmarks[dst.file.fileName()]);
-    }
-};
-
-BR_REGISTER(Transform, ReadLandmarksTransform)
-
-/*!
- * \ingroup transforms
- * \brief Name a point/rect
- * \author Scott Klum \cite sklum
- */
-class NameLandmarksTransform : public UntrainableMetadataTransform
-{
-    Q_OBJECT
-    Q_PROPERTY(bool point READ get_point WRITE set_point RESET reset_point STORED false)
-    BR_PROPERTY(bool, point, true)
-    Q_PROPERTY(QList<int> indices READ get_indices WRITE set_indices RESET reset_indices STORED false)
-    Q_PROPERTY(QStringList names READ get_names WRITE set_names RESET reset_names STORED false)
-    BR_PROPERTY(QList<int>, indices, QList<int>())
-    BR_PROPERTY(QStringList, names, QStringList())
-
-    void projectMetadata(const File &src, File &dst) const
-    {
-        if (indices.size() != names.size()) qFatal("Index/name size mismatch");
-
-        dst = src;
-
-        if (point) {
-            QList<QPointF> points = src.points();
-
-            for (int i=0; i<indices.size(); i++) {
-                if (indices[i] < points.size()) dst.set(names[i], points[indices[i]]);
-                else qFatal("Index out of range.");
-            }
-        } else {
-            QList<QRectF> rects = src.rects();
-
-            for (int i=0; i<indices.size(); i++) {
-                if (indices[i] < rects.size()) dst.set(names[i], rects[indices[i]]);
-                else qFatal("Index out of range.");
-            }
-        }
-    }
-};
-
-BR_REGISTER(Transform, NameLandmarksTransform)
-
-/*!
- * \ingroup transforms
- * \brief Remove a name from a point/rect
- * \author Scott Klum \cite sklum
- */
-class AnonymizeLandmarksTransform : public UntrainableMetadataTransform
-{
-    Q_OBJECT
-    Q_PROPERTY(QStringList names READ get_names WRITE set_names RESET reset_names STORED false)
-    BR_PROPERTY(QStringList, names, QStringList())
-
-    void projectMetadata(const File &src, File &dst) const
-    {
-        dst = src;
-
-        foreach (const QString &name, names) {
-            if (src.contains(name)) {
-                QVariant variant = src.value(name);
-                if (variant.canConvert(QMetaType::QPointF)) {
-                    dst.appendPoint(variant.toPointF());
-                } else if (variant.canConvert(QMetaType::QRectF)) {
-                    dst.appendRect(variant.toRectF());
-                } else {
-                    qFatal("Cannot convert landmark to point or rect.");
-                }
-            }
-        }
-    }
-};
-
-BR_REGISTER(Transform, AnonymizeLandmarksTransform)
-
-/*!
- * \ingroup transforms
- * \brief Converts either the file::points() list or a QList<QPointF> metadata item to be the template's matrix
- * \author Scott Klum \cite sklum
- */
-class PointsToMatrixTransform : public UntrainableTransform
-{
-    Q_OBJECT
-
-    Q_PROPERTY(QString inputVariable READ get_inputVariable WRITE set_inputVariable RESET reset_inputVariable STORED false)
-    BR_PROPERTY(QString, inputVariable, QString())
-
-    void project(const Template &src, Template &dst) const
-    {
-        dst = src;
-
-        if (inputVariable.isEmpty()) {
-            dst.m() = OpenCVUtils::pointsToMatrix(dst.file.points());
-        } else {
-            if (src.file.contains(inputVariable))
-                dst.m() = OpenCVUtils::pointsToMatrix(dst.file.get<QList<QPointF> >(inputVariable));
-        }
-    }
-};
-
-BR_REGISTER(Transform, PointsToMatrixTransform)
-
-/*!
- * \ingroup transforms
- * \brief Normalize points to be relative to a single point
- * \author Scott Klum \cite sklum
- */
-class NormalizePointsTransform : public UntrainableTransform
-{
-    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;
-
-        QList<QPointF> points = dst.file.points();
-        QPointF normPoint = points.at(index);
-
-        QList<QPointF> normalizedPoints;
-
-        for (int i=0; i<points.size(); i++)
-            if (i!=index)
-                normalizedPoints.append(normPoint-points[i]);
-
-        dst.file.setPoints(normalizedPoints);
-    }
-};
-
-BR_REGISTER(Transform, NormalizePointsTransform)
-
-/*!
- * \ingroup transforms
- * \brief Normalize points to be relative to a single point
- * \author Scott Klum \cite sklum
- */
-class PointDisplacementTransform : public UntrainableTransform
-{
-    Q_OBJECT
-
-    void project(const Template &src, Template &dst) const
-    {
-        dst = src;
-
-        QList<QPointF> points = dst.file.points();
-        QList<QPointF> normalizedPoints;
-
-        for (int i=0; i<points.size(); i++)
-            for (int j=0; j<points.size(); j++)
-                // There is redundant information here
-                if (j!=i) {
-                    QPointF normalizedPoint = points[i]-points[j];
-                    normalizedPoint.setX(pow(normalizedPoint.x(),2));
-                    normalizedPoint.setY(pow(normalizedPoint.y(),2));
-                    normalizedPoints.append(normalizedPoint);
-                }
-
-        dst.file.setPoints(normalizedPoints);
-    }
-};
-
-BR_REGISTER(Transform, PointDisplacementTransform)
-
-} // namespace br
-
-#include "landmarks.moc"
diff --git a/openbr/plugins/meta.cpp b/openbr/plugins/meta.cpp
deleted file mode 100644
index 57888a5..0000000
--- a/openbr/plugins/meta.cpp
+++ /dev/null
@@ -1,849 +0,0 @@
-/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
- * 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 <QRegularExpression>
-#include <QtConcurrentRun>
-#include <qbuffer.h>
-
-#include "openbr_internal.h"
-#include "openbr/core/common.h"
-#include "openbr/core/opencvutils.h"
-#include "openbr/core/qtutils.h"
-#include "openbr/core/resource.h"
-
-using namespace cv;
-
-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;
-}
-
-static void _train(Transform *transform, const QList<TemplateList> *data)
-{
-    transform->train(*data);
-}
-
-/*!
- * \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)
-
-/*!
- * \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)
-
-/*!
- * \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)
-
-/*!
- * \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)
-
-/*!
- * \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)
-
-/*!
- * \ingroup transforms
- * \brief Caches transform training.
- * \author Josh Klontz \cite jklontz
- */
-class LoadStoreTransform : public MetaTransform
-{
-    Q_OBJECT
-    Q_PROPERTY(QString transformString READ get_transformString WRITE set_transformString RESET reset_transformString STORED false)
-    Q_PROPERTY(QString fileName READ get_fileName WRITE set_fileName RESET reset_fileName STORED false)
-    BR_PROPERTY(QString, transformString, "Identity")
-    BR_PROPERTY(QString, fileName, QString())
-
-public:
-    Transform *transform;
-
-    LoadStoreTransform() : transform(NULL) {}
-
-    QString description(bool expanded = false) const
-    {
-        if (expanded) {
-            QString res = transform->description(expanded);
-            return res;
-        }
-        return br::Object::description(expanded);
-    }
-
-    Transform *simplify(bool &newTForm)
-    {
-        Transform *res = transform->simplify(newTForm);
-        return res;
-    }
-
-    QList<Object *> getChildren() const
-    {
-        QList<Object *> rval;
-        rval.append(transform);
-        return rval;
-    }
-private:
-
-    void init()
-    {
-        if (transform != NULL) return;
-        if (fileName.isEmpty()) fileName = QRegExp("^[_a-zA-Z0-9]+$").exactMatch(transformString) ? transformString : QtUtils::shortTextHash(transformString);
-
-        if (!tryLoad())
-            transform = make(transformString);
-        else
-            trainable = false;
-    }
-
-    bool timeVarying() const
-    {
-        return transform->timeVarying();
-    }
-
-    void train(const QList<TemplateList> &data)
-    {
-        if (QFileInfo(getFileName()).exists())
-            return;
-
-        transform->train(data);
-
-        qDebug("Storing %s", qPrintable(fileName));
-        QtUtils::BlockCompression compressedOut;
-        QFile fout(fileName);
-        QtUtils::touchDir(fout);
-        compressedOut.setBasis(&fout);
-
-        QDataStream stream(&compressedOut);
-        QString desc = transform->description();
-
-        if (!compressedOut.open(QFile::WriteOnly))
-            qFatal("Failed to open %s for writing.", qPrintable(file));
-
-        stream << desc;
-        transform->store(stream);
-        compressedOut.close();
-    }
-
-    void project(const Template &src, Template &dst) const
-    {
-        transform->project(src, dst);
-    }
-
-    void project(const TemplateList &src, TemplateList &dst) const
-    {
-        transform->project(src, dst);
-    }
-
-    void projectUpdate(const Template &src, Template &dst)
-    {
-        transform->projectUpdate(src, dst);
-    }
-
-    void projectUpdate(const TemplateList &src, TemplateList &dst)
-    {
-        transform->projectUpdate(src, dst);
-    }
-
-    void finalize(TemplateList &output)
-    {
-        transform->finalize(output);
-    }
-
-    QString getFileName() const
-    {
-        if (QFileInfo(fileName).exists()) return fileName;
-        const QString file = Globals->sdkPath + "/share/openbr/models/transforms/" + fileName;
-        return QFileInfo(file).exists() ? file : QString();
-    }
-
-    bool tryLoad()
-    {
-        const QString file = getFileName();
-        if (file.isEmpty()) return false;
-
-        qDebug("Loading %s", qPrintable(file));
-        QFile fin(file);
-        QtUtils::BlockCompression reader(&fin);
-        if (!reader.open(QIODevice::ReadOnly)) {
-            if (QFileInfo(file).exists()) qFatal("Unable to open %s for reading. Check file permissions.", qPrintable(file));
-            else            qFatal("Unable to open %s for reading. File does not exist.", qPrintable(file));
-        }
-
-        QDataStream stream(&reader);
-        stream >> transformString;
-
-        transform = Transform::make(transformString);
-        transform->load(stream);
-
-        return true;
-    }
-};
-
-BR_REGISTER(Transform, LoadStoreTransform)
-
-/*!
- * \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)
-
-
-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)
-
-/*!
- * \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 "meta.moc"
diff --git a/openbr/plugins/metadata/anonymizelandmarks.cpp b/openbr/plugins/metadata/anonymizelandmarks.cpp
new file mode 100644
index 0000000..15bd155
--- /dev/null
+++ b/openbr/plugins/metadata/anonymizelandmarks.cpp
@@ -0,0 +1,56 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * 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 Remove a name from a point/rect
+ * \author Scott Klum \cite sklum
+ */
+class AnonymizeLandmarksTransform : public UntrainableMetadataTransform
+{
+    Q_OBJECT
+    Q_PROPERTY(QStringList names READ get_names WRITE set_names RESET reset_names STORED false)
+    BR_PROPERTY(QStringList, names, QStringList())
+
+    void projectMetadata(const File &src, File &dst) const
+    {
+        dst = src;
+
+        foreach (const QString &name, names) {
+            if (src.contains(name)) {
+                QVariant variant = src.value(name);
+                if (variant.canConvert(QMetaType::QPointF)) {
+                    dst.appendPoint(variant.toPointF());
+                } else if (variant.canConvert(QMetaType::QRectF)) {
+                    dst.appendRect(variant.toRectF());
+                } else {
+                    qFatal("Cannot convert landmark to point or rect.");
+                }
+            }
+        }
+    }
+};
+
+BR_REGISTER(Transform, AnonymizeLandmarksTransform)
+
+} // namespace br
+
+#include "metadata/anonymizelandmarks.moc"
diff --git a/openbr/plugins/metadata/as.cpp b/openbr/plugins/metadata/as.cpp
new file mode 100644
index 0000000..61821b6
--- /dev/null
+++ b/openbr/plugins/metadata/as.cpp
@@ -0,0 +1,44 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * 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 Change the br::Template::file extension
+ * \author Josh Klontz \cite jklontz
+ */
+class AsTransform : public UntrainableMetadataTransform
+{
+    Q_OBJECT
+    Q_PROPERTY(QString extension READ get_extension WRITE set_extension RESET reset_extension STORED false)
+    BR_PROPERTY(QString, extension, "")
+
+    void projectMetadata(const File &src, File &dst) const
+    {
+        dst = src;
+        dst.name = dst.name.left(dst.name.lastIndexOf('.')+1) + extension;
+    }
+};
+
+BR_REGISTER(Transform, AsTransform)
+
+} // namespace br
+
+#include "metadata/as.moc"
diff --git a/openbr/plugins/metadata/averagepoints.cpp b/openbr/plugins/metadata/averagepoints.cpp
new file mode 100644
index 0000000..704356d
--- /dev/null
+++ b/openbr/plugins/metadata/averagepoints.cpp
@@ -0,0 +1,52 @@
+#include <openbr/plugins/openbr_internal.h>
+
+namespace br
+{
+
+/*!
+ * \ingroup transforms
+ * \brief Averages a set of landmarks into a new landmark
+ * \author Brendan Klare \cite bklare
+ */
+class AveragePointsTransform : public UntrainableMetadataTransform
+{
+    Q_OBJECT
+    Q_PROPERTY(QList<int> indices READ get_indices WRITE set_indices RESET reset_indices STORED false)
+    Q_PROPERTY(QString metaName READ get_metaName WRITE set_metaName RESET reset_metaName STORED true)
+    Q_PROPERTY(bool append READ get_append WRITE set_append RESET reset_append STORED true)
+    Q_PROPERTY(int nLandmarks READ get_nLandmarks WRITE set_nLandmarks RESET reset_nLandmarks STORED true)
+    BR_PROPERTY(QList<int>, indices, QList<int>())
+    BR_PROPERTY(QString, metaName, "")
+    BR_PROPERTY(bool, append, false)
+    BR_PROPERTY(int, nLandmarks, 51)
+
+    void projectMetadata(const File &src, File &dst) const
+    {
+        dst = src;
+        if (src.points().size() != nLandmarks) {
+            if (Globals->verbose)
+                qDebug() << "Warning: Face has " << src.points().size() << "points; should be " << nLandmarks;
+            dst.fte = true;
+            return;
+        }
+        int x1 = 0,
+            y1 = 0;
+
+        for (int i = 0; i < indices.size(); i++) {
+            x1 += src.points()[indices[i]].x();
+            y1 += src.points()[indices[i]].y();
+        }
+
+        QPointF p(x1 / indices.size(), y1 / indices.size());
+        if (!metaName.isEmpty())
+            dst.set(metaName, p);
+        if (append)
+            dst.appendPoint(p);
+    }
+};
+
+BR_REGISTER(Transform, AveragePointsTransform)
+
+} // namespace br
+
+#include "metadata/averagepoints.moc"
diff --git a/openbr/plugins/cascade.cpp b/openbr/plugins/metadata/cascade.cpp
index a0b282a..16935d0 100644
--- a/openbr/plugins/cascade.cpp
+++ b/openbr/plugins/metadata/cascade.cpp
@@ -13,14 +13,14 @@
  * See the License for the specific language governing permissions and       *
  * limitations under the License.                                            *
  * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
-
-#include <opencv2/objdetect/objdetect.hpp>
-#include "openbr_internal.h"
-#include "openbr/core/opencvutils.h"
-#include "openbr/core/resource.h"
-#include "openbr/core/qtutils.h"
 #include <QProcess>
 #include <QTemporaryFile>
+#include <opencv2/objdetect/objdetect.hpp>
+
+#include <openbr/plugins/openbr_internal.h>
+#include <openbr/core/opencvutils.h>
+#include <openbr/core/resource.h>
+#include <openbr/core/qtutils.h>
 
 using namespace cv;
     
@@ -437,4 +437,4 @@ BR_REGISTER(Transform, CascadeTransform)
 
 } // namespace br
 
-#include "cascade.moc"
+#include "metadata/cascade.moc"
diff --git a/openbr/plugins/metadata/check.cpp b/openbr/plugins/metadata/check.cpp
new file mode 100644
index 0000000..2128b10
--- /dev/null
+++ b/openbr/plugins/metadata/check.cpp
@@ -0,0 +1,59 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * 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 transforms
+ * \brief Checks the template for NaN values.
+ * \author Josh Klontz \cite jklontz
+ */
+class CheckTransform : public UntrainableMetaTransform
+{
+    Q_OBJECT
+    static int count;
+    int index;
+
+ public:
+    CheckTransform() : index(count++) {}
+
+    void project(const Template &src, Template &dst) const
+    {
+        dst = src;
+        foreach (const Mat &m, src) {
+            Mat fm;
+            m.convertTo(fm, CV_32F);
+            const int elements = fm.rows * fm.cols * fm.channels();
+            const float *data = (const float*)fm.data;
+            for (int i=0; i<elements; i++)
+                if (data[i] != data[i])
+                    qFatal("%s NaN check %d failed!", qPrintable(src.file.flat()), index);
+        }
+    }
+};
+
+int CheckTransform::count = 0;
+
+BR_REGISTER(Transform, CheckTransform)
+
+} // namespace br
+
+#include "metadata/check.moc"
diff --git a/openbr/plugins/metadata/clearpoints.cpp b/openbr/plugins/metadata/clearpoints.cpp
new file mode 100644
index 0000000..0ffdfde
--- /dev/null
+++ b/openbr/plugins/metadata/clearpoints.cpp
@@ -0,0 +1,42 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * 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 Clears the points from a template
+ * \author Brendan Klare \cite bklare
+ */
+class ClearPointsTransform : public UntrainableMetadataTransform
+{
+    Q_OBJECT
+
+    void projectMetadata(const File &src, File &dst) const
+    {
+        dst = src;
+        dst.clearPoints();
+    }
+};
+
+BR_REGISTER(Transform, ClearPointsTransform)
+
+} // namespace br
+
+#include "metadata/clearpoints.moc"
diff --git a/openbr/plugins/metadata/consolidatedetections.cpp b/openbr/plugins/metadata/consolidatedetections.cpp
new file mode 100644
index 0000000..30e2e34
--- /dev/null
+++ b/openbr/plugins/metadata/consolidatedetections.cpp
@@ -0,0 +1,159 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * 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>
+#include <openbr/core/opencvutils.h>
+
+using namespace Eigen;
+using namespace cv;
+
+namespace br
+{
+
+/*!
+ * \ingroup transforms
+ * \brief Consolidate redundant/overlapping detections.
+ * \author Brendan Klare \cite bklare
+ */
+class ConsolidateDetectionsTransform : public UntrainableMetadataTransform
+{
+    Q_OBJECT
+
+    void projectMetadata(const File &src, File &dst) const
+    {
+        dst = src;
+        if (!dst.contains("Confidences"))
+            return;
+
+        //Compute overlap between rectangles and create discrete Laplacian matrix
+        QList<Rect> rects = OpenCVUtils::toRects(src.rects());
+        int n = rects.size();
+        if (n == 0)
+            return;
+        MatrixXf laplace(n,n);
+        for (int i = 0; i < n; i++) {
+            laplace(i,i) = 0;
+        }
+        for (int i = 0; i < n; i++){
+            for (int j = i + 1; j < n; j++) {
+                float overlap = (float)((rects[i] & rects[j]).area()) / (float)max(rects[i].area(), rects[j].area());
+                if (overlap > 0.5) {
+                    laplace(i,j) = -1.0;
+                    laplace(j,i) = -1.0;
+                    laplace(i,i) = laplace(i,i) + 1.0;
+                    laplace(j,j) = laplace(j,j) + 1.0;
+                } else {
+                    laplace(i,j) = 0;
+                    laplace(j,i) = 0;
+                }
+            }
+        }
+
+        // Compute eigendecomposition
+        SelfAdjointEigenSolver<Eigen::MatrixXf> eSolver(laplace);
+        MatrixXf allEVals = eSolver.eigenvalues();
+        MatrixXf allEVecs = eSolver.eigenvectors();
+
+        //Keep eigenvectors with zero eigenvalues
+        int nRegions = 0;
+        for (int i = 0; i < n; i++) {
+            if (fabs(allEVals(i)) < 1e-4) {
+                nRegions++;
+            }
+        }
+        MatrixXf regionVecs(n, nRegions);
+        for (int i = 0, cnt = 0; i < n; i++) {
+            if (fabs(allEVals(i)) < 1e-4)
+                regionVecs.col(cnt++) = allEVecs.col(i);
+        }
+
+        //Determine membership for each consolidated location
+        // and compute average of regions. This is determined by
+        // finding which eigenvector has the highest magnitude for
+        // each input dimension. Each input dimension corresponds to
+        // one of the input rect region. Thus, each eigenvector represents
+        // a set of overlaping regions.
+        float *midX = new float[nRegions];
+        float *midY = new float[nRegions];
+        float *avgWidth = new float[nRegions];
+        float *avgHeight = new float[nRegions];
+        float *confs = new float[nRegions];
+        int *cnts = new int[nRegions];
+        int mx;
+        int mxIdx;
+        for (int i = 0 ; i < nRegions; i++) {
+            midX[i] = 0;
+            midY[i] = 0;
+            avgWidth[i] = 0;
+            avgHeight[i] = 0;
+            confs[i] = 0;
+            cnts[i] = 0;
+        }
+
+        QList<float> confidences = dst.getList<float>("Confidences");
+        for (int i = 0; i < n; i++) {
+            mx = 0.0;
+            mxIdx = -1;
+
+            for (int j = 0; j < nRegions; j++) {
+                if (fabs(regionVecs(i,j)) > mx) {
+                    mx = fabs(regionVecs(i,j));
+                    mxIdx = j;
+                }
+            }
+
+            Rect curRect = rects[i];
+            midX[mxIdx] += ((float)curRect.x + (float)curRect.width  / 2.0);
+            midY[mxIdx] += ((float)curRect.y + (float)curRect.height / 2.0);
+            avgWidth[mxIdx]  += (float) curRect.width;
+            avgHeight[mxIdx] += (float) curRect.height;
+            confs[mxIdx] += confidences[i];
+            cnts[mxIdx]++;
+        }
+
+        QList<Rect> consolidatedRects;
+        QList<float> consolidatedConfidences;
+        for (int i = 0; i < nRegions; i++) {
+            float cntF = (float) cnts[i];
+            if (cntF > 0) {
+                int x = qRound((midX[i] / cntF) - (avgWidth[i] / cntF) / 2.0);
+                int y = qRound((midY[i] / cntF) - (avgHeight[i] / cntF) / 2.0);
+                int w = qRound(avgWidth[i] / cntF);
+                int h = qRound(avgHeight[i] / cntF);
+                consolidatedRects.append(Rect(x,y,w,h));
+                consolidatedConfidences.append(confs[i] / cntF);
+            }
+        }
+
+        delete [] midX;
+        delete [] midY;
+        delete [] avgWidth;
+        delete [] avgHeight;
+        delete [] confs;
+        delete [] cnts;
+
+        dst.setRects(consolidatedRects);
+        dst.setList<float>("Confidences", consolidatedConfidences);
+    }
+};
+
+BR_REGISTER(Transform, ConsolidateDetectionsTransform)
+
+} // namespace br
+
+#include "metadata/consolidatedetections.moc"
diff --git a/openbr/plugins/metadata/croprect.cpp b/openbr/plugins/metadata/croprect.cpp
new file mode 100644
index 0000000..1ddf59c
--- /dev/null
+++ b/openbr/plugins/metadata/croprect.cpp
@@ -0,0 +1,55 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * 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 Crops the width and height of a template's rects by input width and height factors.
+ * \author Scott Klum \cite sklum
+ */
+class CropRectTransform : public UntrainableMetadataTransform
+{
+    Q_OBJECT
+
+    Q_PROPERTY(QString widthCrop READ get_widthCrop WRITE set_widthCrop RESET reset_widthCrop STORED false)
+    Q_PROPERTY(QString heightCrop READ get_heightCrop WRITE set_heightCrop RESET reset_heightCrop STORED false)
+    BR_PROPERTY(QString, widthCrop, QString())
+    BR_PROPERTY(QString, heightCrop, QString())
+
+    void projectMetadata(const File &src, File &dst) const
+    {
+        dst = src;
+        QList<QRectF> rects = src.rects();
+        for (int i=0;i < rects.size(); i++) {
+            rects[i].setX(rects[i].x() + rects[i].width() * QtUtils::toPoint(widthCrop).x());
+            rects[i].setY(rects[i].y() + rects[i].height() * QtUtils::toPoint(heightCrop).x());
+            rects[i].setWidth(rects[i].width() * (1-QtUtils::toPoint(widthCrop).y()));
+            rects[i].setHeight(rects[i].height() * (1-QtUtils::toPoint(heightCrop).y()));
+        }
+        dst.setRects(rects);
+    }
+};
+
+BR_REGISTER(Transform, CropRectTransform)
+
+} // namespace br
+
+#include "metadata/croprect.moc"
diff --git a/openbr/plugins/metadata/delaunay.cpp b/openbr/plugins/metadata/delaunay.cpp
new file mode 100644
index 0000000..fd05f6b
--- /dev/null
+++ b/openbr/plugins/metadata/delaunay.cpp
@@ -0,0 +1,172 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * 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 <Eigen/Dense>
+
+#include <openbr/plugins/openbr_internal.h>
+#include <openbr/core/opencvutils.h>
+
+using namespace cv;
+
+namespace br
+{
+
+/*!
+ * \ingroup transforms
+ * \brief Creates a Delaunay triangulation based on a set of points
+ * \author Scott Klum \cite sklum
+ */
+class DelaunayTransform : public UntrainableTransform
+{
+    Q_OBJECT
+
+    Q_PROPERTY(float scaleFactor READ get_scaleFactor WRITE set_scaleFactor RESET reset_scaleFactor STORED false)
+    Q_PROPERTY(bool warp READ get_warp WRITE set_warp RESET reset_warp STORED false)
+    BR_PROPERTY(float, scaleFactor, 1)
+    BR_PROPERTY(bool, warp, true)
+
+    void project(const Template &src, Template &dst) const
+    {
+        QList<QPointF> points = src.file.points();
+        QList<QRectF> rects = src.file.rects();
+
+        if (points.empty() || rects.empty()) {
+            dst = src;
+            if (Globals->verbose) qWarning("Delauney triangulation failed because points or rects are empty.");
+            return;
+        }
+
+        int cols = src.m().cols;
+        int rows = src.m().rows;
+
+        // Assume rect appended last was bounding box
+        points.append(rects.last().topLeft());
+        points.append(rects.last().topRight());
+        points.append(rects.last().bottomLeft());
+        points.append(rects.last().bottomRight());
+
+        Subdiv2D subdiv(Rect(0,0,cols,rows));
+        // Make sure points are valid for Subdiv2D
+        // TODO: Modify points to make them valid
+        for (int i = 0; i < points.size(); i++) {
+            if (points[i].x() < 0 || points[i].y() < 0 || points[i].y() >= rows || points[i].x() >= cols) {
+                dst = src;
+                if (Globals->verbose) qWarning("Delauney triangulation failed because points lie on boundary.");
+                return;
+            }
+            subdiv.insert(OpenCVUtils::toPoint(points[i]));
+        }
+
+        vector<Vec6f> triangleList;
+        subdiv.getTriangleList(triangleList);
+
+        QList<QPointF> validTriangles;
+
+        for (size_t i = 0; i < triangleList.size(); i++) {
+            // Check the triangle to make sure it's falls within the matrix
+            bool valid = true;
+
+            QList<QPointF> vertices;
+            vertices.append(QPointF(triangleList[i][0],triangleList[i][1]));
+            vertices.append(QPointF(triangleList[i][2],triangleList[i][3]));
+            vertices.append(QPointF(triangleList[i][4],triangleList[i][5]));
+            for (int j = 0; j < 3; j++) if (vertices[j].x() > cols || vertices[j].y() > rows || vertices[j].x() < 0 || vertices[j].y() < 0) valid = false;
+
+            if (valid) validTriangles.append(vertices);
+        }
+
+        if (warp) {
+            dst.m() = Mat::zeros(rows,cols,src.m().type());
+
+            QList<float> procrustesStats = src.file.getList<float>("ProcrustesStats");
+
+            Eigen::MatrixXf R(2,2);
+            R(0,0) = procrustesStats.at(0);
+            R(1,0) = procrustesStats.at(1);
+            R(1,1) = procrustesStats.at(2);
+            R(0,1) = procrustesStats.at(3);
+
+            cv::Scalar mean(2);
+            mean[0] = procrustesStats.at(4);
+            mean[1] = procrustesStats.at(5);
+
+            float norm = procrustesStats.at(6);
+
+            QList<Point2f> mappedPoints;
+
+            for (int i = 0; i < validTriangles.size(); i+=3) {
+                // Matrix to store original (pre-transformed) triangle vertices
+                Eigen::MatrixXf srcMat(3, 2);
+
+                for (int j = 0; j < 3; j++) {
+                    srcMat(j,0) = (validTriangles[i+j].x()-mean[0])/norm;
+                    srcMat(j,1) = (validTriangles[i+j].y()-mean[1])/norm;
+                }
+
+                Eigen::MatrixXf dstMat = srcMat*R;
+
+                Point2f srcPoints[3];
+                for (int j = 0; j < 3; j++) srcPoints[j] = OpenCVUtils::toPoint(validTriangles[i+j]);
+
+                Point2f dstPoints[3];
+                for (int j = 0; j < 3; j++) {
+                    // Scale and shift destination points
+                    Point2f warpedPoint = Point2f(dstMat(j,0)*scaleFactor+cols/2,dstMat(j,1)*scaleFactor+rows/2);
+                    dstPoints[j] = warpedPoint;
+                    mappedPoints.append(warpedPoint);
+                }
+
+                Mat buffer(rows,cols,src.m().type());
+
+                warpAffine(src.m(), buffer, getAffineTransform(srcPoints, dstPoints), Size(cols,rows));
+
+                Mat mask = Mat::zeros(rows, cols, CV_8UC1);
+                Point maskPoints[1][3];
+                maskPoints[0][0] = dstPoints[0];
+                maskPoints[0][1] = dstPoints[1];
+                maskPoints[0][2] = dstPoints[2];
+                const Point* ppt = { maskPoints[0] };
+
+                fillConvexPoly(mask, ppt, 3, Scalar(255,255,255), 8);
+
+                Mat output(rows,cols,src.m().type());
+
+                if (i > 0) {
+                    Mat overlap;
+                    bitwise_and(dst.m(),mask,overlap);
+                    mask.setTo(0, overlap!=0);
+                }
+
+                bitwise_and(buffer,mask,output);
+
+                dst.m() += output;
+            }
+
+            // Overwrite any rects
+            Rect boundingBox = boundingRect(mappedPoints.toVector().toStdVector());
+            dst.file.setRects(QList<QRectF>() << OpenCVUtils::fromRect(boundingBox));
+        } else dst = src;
+
+        dst.file.setList<QPointF>("DelaunayTriangles", validTriangles);
+    }
+};
+
+BR_REGISTER(Transform, DelaunayTransform)
+
+} // namespace br
+
+#include "metadata/delaunay.moc"
diff --git a/openbr/plugins/metadata/expandrect.cpp b/openbr/plugins/metadata/expandrect.cpp
new file mode 100644
index 0000000..f91c0bc
--- /dev/null
+++ b/openbr/plugins/metadata/expandrect.cpp
@@ -0,0 +1,70 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * 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 Expand the width and height of a template's rects by input width and height factors.
+ * \author Charles Otto \cite caotto
+ */
+class ExpandRectTransform : public UntrainableTransform
+{
+    Q_OBJECT
+    Q_PROPERTY(float widthExpand READ get_widthExpand WRITE set_widthExpand RESET reset_widthExpand STORED false)
+    Q_PROPERTY(float heightExpand READ get_heightExpand WRITE set_heightExpand RESET reset_heightExpand STORED false)
+    BR_PROPERTY(float, widthExpand, .5)
+    BR_PROPERTY(float, heightExpand, .5)
+    void project(const Template &src, Template &dst) const
+    {
+        dst = src;
+        QList<QRectF> rects = dst.file.rects();
+        for (int i=0;i < rects.size(); i++) {
+            QRectF rect = rects[i];
+
+            qreal width = rect.width();
+            qreal height = rect.height();
+            float half_w_expansion = widthExpand / 2;
+            float half_h_expansion = heightExpand / 2;
+
+            qreal half_width = width * widthExpand;
+            qreal quarter_width = width * half_w_expansion;
+            qreal half_height = height * heightExpand;
+            qreal quarter_height = height * half_h_expansion;
+
+            rect.setX(std::max(qreal(0),(rect.x() - quarter_width)));
+            rect.setY(std::max(qreal(0),(rect.y() - quarter_height)));
+
+            qreal x2 = std::min(rect.width() + half_width + rect.x(), qreal(src.m().cols) - 1);
+            qreal y2 = std::min(rect.height() + half_height + rect.y(), qreal(src.m().rows) - 1);
+
+            rect.setWidth(x2 - rect.x());
+            rect.setHeight(y2 - rect.y());
+
+            rects[i] = rect;
+        }
+        dst.file.setRects(rects);
+    }
+};
+
+BR_REGISTER(Transform, ExpandRectTransform)
+
+} // namespace br
+
+#include "metadata/expandrect.moc"
diff --git a/openbr/plugins/metadata/extractmetadata.cpp b/openbr/plugins/metadata/extractmetadata.cpp
new file mode 100644
index 0000000..97b1c83
--- /dev/null
+++ b/openbr/plugins/metadata/extractmetadata.cpp
@@ -0,0 +1,48 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * 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 Create matrix from metadata values.
+ * \author Josh Klontz \cite jklontz
+ */
+class ExtractMetadataTransform : public UntrainableMetaTransform
+{
+    Q_OBJECT
+    Q_PROPERTY(QStringList keys READ get_keys WRITE set_keys RESET reset_keys STORED false)
+    BR_PROPERTY(QStringList, keys, QStringList())
+
+    void project(const Template &src, Template &dst) const
+    {
+        dst.file = src.file;
+        QList<float> values;
+        foreach (const QString &key, keys)
+            values.append(src.file.get<float>(key));
+        dst.append(OpenCVUtils::toMat(values, 1));
+    }
+};
+
+BR_REGISTER(Transform, ExtractMetadataTransform)
+
+} // namespace br
+
+#include "metadata/extractmetadata.moc"
diff --git a/openbr/plugins/eyes.cpp b/openbr/plugins/metadata/eyes.cpp
index 5d3929d..f881b58 100644
--- a/openbr/plugins/eyes.cpp
+++ b/openbr/plugins/metadata/eyes.cpp
@@ -35,8 +35,9 @@
 
 #include <opencv2/imgproc/imgproc.hpp>
 #include <opencv2/imgproc/imgproc_c.h>
-#include "openbr_internal.h"
-#include "openbr/core/opencvutils.h"
+
+#include <openbr/plugins/openbr_internal.h>
+#include <openbr/core/opencvutils.h>
 
 using namespace cv;
 
@@ -194,4 +195,4 @@ BR_REGISTER(Transform, ASEFEyesTransform)
 
 } // namespace br
 
-#include "eyes.moc"
+#include "metadata/eyes.moc"
diff --git a/openbr/plugins/metadata/facefromeyes.cpp b/openbr/plugins/metadata/facefromeyes.cpp
new file mode 100644
index 0000000..7db0a81
--- /dev/null
+++ b/openbr/plugins/metadata/facefromeyes.cpp
@@ -0,0 +1,66 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * 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 Create face bounding box from two eye locations. `widthPadding` specifies
+ *      what percentage of the interpupliary distance (ipd) will be padded in both
+ *      horizontal directions. The `verticalLocation` specifies where vertically the
+ *      eyes are within the bounding box (0.5 would be the center).
+ * \author Brendan Klare \cite bklare
+ */
+
+class FaceFromEyesTransform : public UntrainableMetadataTransform
+{
+    Q_OBJECT
+    Q_PROPERTY(double widthPadding READ get_widthPadding WRITE set_widthPadding RESET reset_widthPadding STORED false)
+    Q_PROPERTY(double verticalLocation READ get_verticalLocation WRITE set_verticalLocation RESET reset_verticalLocation STORED false)
+    Q_PROPERTY(int leftEyeIdx READ get_leftEyeIdx WRITE set_leftEyeIdx RESET reset_leftEyeIdx STORED false)
+    Q_PROPERTY(int rightEyeIdx READ get_rightEyeIdx WRITE set_rightEyeIdx RESET reset_rightEyeIdx STORED false)
+    BR_PROPERTY(double, widthPadding, 0.7)
+    BR_PROPERTY(double, verticalLocation, 0.25)
+    BR_PROPERTY(int, leftEyeIdx, 0)
+    BR_PROPERTY(int, rightEyeIdx, 1)
+
+    void projectMetadata(const File &src, File &dst) const
+    {
+        dst = src;
+
+        if (src.points().isEmpty()) {
+            qWarning("No landmarks");
+            return;
+        }
+
+        QPointF eyeL = src.points()[leftEyeIdx];
+        QPointF eyeR = src.points()[rightEyeIdx];
+        QPointF eyeCenter((eyeL.x() + eyeR.x()) / 2, (eyeL.y() + eyeR.y()) / 2);
+        float ipd = sqrt(pow(eyeL.x() - eyeR.x(), 2) + pow(eyeL.y() - eyeR.y(), 2));
+        float width = ipd + 2 * widthPadding * ipd;
+
+        dst.appendRect(QRectF(eyeCenter.x() - width / 2, eyeCenter.y() - width * verticalLocation, width, width));
+    }
+};
+
+BR_REGISTER(Transform, FaceFromEyesTransform)
+
+} // namespace br
+
+#include "metadata/facefromeyes.moc"
diff --git a/openbr/plugins/metadata/fileexclusion.cpp b/openbr/plugins/metadata/fileexclusion.cpp
new file mode 100644
index 0000000..89112bc
--- /dev/null
+++ b/openbr/plugins/metadata/fileexclusion.cpp
@@ -0,0 +1,60 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * 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 FileExclusionTransform : public UntrainableMetaTransform
+{
+    Q_OBJECT
+
+    Q_PROPERTY(QString exclusionGallery READ get_exclusionGallery WRITE set_exclusionGallery RESET reset_exclusionGallery STORED false)
+    BR_PROPERTY(QString, exclusionGallery, "")
+
+    QSet<QString> excluded;
+
+    void project(const Template &, Template &) const
+    {
+        qFatal("FileExclusion can't do anything here");
+    }
+
+    void project(const TemplateList &src, TemplateList &dst) const
+    {
+        foreach (const Template &srcTemp, src) {
+            if (!excluded.contains(srcTemp.file))
+                dst.append(srcTemp);
+        }
+    }
+
+    void init()
+    {
+        if (exclusionGallery.isEmpty())
+            return;
+        File rFile(exclusionGallery);
+        rFile.remove("append");
+
+        FileList temp = FileList::fromGallery(rFile);
+        excluded = QSet<QString>::fromList(temp.names());
+    }
+};
+
+BR_REGISTER(Transform, FileExclusionTransform)
+
+} // namespace br
+
+#include "metadata/fileexclusion.moc"
diff --git a/openbr/plugins/metadata/filterdupemetadata.cpp b/openbr/plugins/metadata/filterdupemetadata.cpp
new file mode 100644
index 0000000..fdded81
--- /dev/null
+++ b/openbr/plugins/metadata/filterdupemetadata.cpp
@@ -0,0 +1,55 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * 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 duplicate templates based on a unique metadata key
+ * \author Austin Blanton \cite imaus10
+ */
+class FilterDupeMetadataTransform : public TimeVaryingTransform
+{
+    Q_OBJECT
+
+    Q_PROPERTY(QString key READ get_key WRITE set_key RESET reset_key STORED false)
+    BR_PROPERTY(QString, key, "TemplateID")
+
+    QSet<QString> excluded;
+
+    void projectUpdate(const TemplateList &src, TemplateList &dst)
+    {
+        foreach (const Template &t, src) {
+            QString id = t.file.get<QString>(key);
+            if (!excluded.contains(id)) {
+                dst.append(t);
+                excluded.insert(id);
+            }
+        }
+    }
+
+public:
+    FilterDupeMetadataTransform() : TimeVaryingTransform(false,false) {}
+};
+
+BR_REGISTER(Transform, FilterDupeMetadataTransform)
+
+} // namespace br
+
+#include "metadata/filterdupemetadata.moc"
diff --git a/openbr/plugins/metadata/grid.cpp b/openbr/plugins/metadata/grid.cpp
new file mode 100644
index 0000000..3fe9a33
--- /dev/null
+++ b/openbr/plugins/metadata/grid.cpp
@@ -0,0 +1,52 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * 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 Add landmarks to the template in a grid layout
+ * \author Josh Klontz \cite jklontz
+ */
+class GridTransform : public UntrainableTransform
+{
+    Q_OBJECT
+    Q_PROPERTY(int rows READ get_rows WRITE set_rows RESET reset_rows STORED false)
+    Q_PROPERTY(int columns READ get_columns WRITE set_columns RESET reset_columns STORED false)
+    BR_PROPERTY(int, rows, 1)
+    BR_PROPERTY(int, columns, 1)
+
+    void project(const Template &src, Template &dst) const
+    {
+        QList<QPointF> landmarks;
+        const float row_step = 1.f * src.m().rows / rows;
+        const float column_step = 1.f * src.m().cols / columns;
+        for (float y=row_step/2; y<src.m().rows; y+=row_step)
+            for (float x=column_step/2; x<src.m().cols; x+=column_step)
+                landmarks.append(QPointF(x,y));
+        dst = src;
+        dst.file.setPoints(landmarks);
+    }
+};
+
+BR_REGISTER(Transform, GridTransform)
+
+} // namespace br
+
+#include "metadata/grid.moc"
diff --git a/openbr/plugins/metadata/groundtruth.cpp b/openbr/plugins/metadata/groundtruth.cpp
new file mode 100644
index 0000000..1434e93
--- /dev/null
+++ b/openbr/plugins/metadata/groundtruth.cpp
@@ -0,0 +1,55 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * 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 Add any ground truth to the template using the file's base name.
+ * \author Josh Klontz \cite jklontz
+ */
+class GroundTruthTransform : public UntrainableMetadataTransform
+{
+    Q_OBJECT
+    Q_PROPERTY(QString groundTruth READ get_groundTruth WRITE set_groundTruth RESET reset_groundTruth STORED false)
+    Q_PROPERTY(QStringList keys READ get_keys WRITE set_keys RESET reset_keys STORED false)
+    BR_PROPERTY(QString, groundTruth, "")
+    BR_PROPERTY(QStringList, keys, QStringList())
+
+    QMap<QString,File> files;
+
+    void init()
+    {
+        foreach (const File &file, TemplateList::fromGallery(groundTruth).files())
+            files.insert(file.baseName(), file);
+    }
+
+    void projectMetadata(const File &src, File &dst) const
+    {
+        (void) src;
+        foreach(const QString &key, keys)
+            dst.set(key,files[dst.baseName()].value(key));
+    }
+};
+
+BR_REGISTER(Transform, GroundTruthTransform)
+
+} // namespace br
+
+#include "metadata/groundtruth.moc"
diff --git a/openbr/plugins/metadata/hogpersondetector.cpp b/openbr/plugins/metadata/hogpersondetector.cpp
new file mode 100644
index 0000000..66aaacd
--- /dev/null
+++ b/openbr/plugins/metadata/hogpersondetector.cpp
@@ -0,0 +1,58 @@
+#include <opencv2/objdetect/objdetect.hpp>
+
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * 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 transforms
+ * \brief Detects objects with OpenCV's built-in HOG detection.
+ * \author Austin Blanton \cite imaus10
+ */
+class HOGPersonDetectorTransform : public UntrainableTransform
+{
+    Q_OBJECT
+
+    HOGDescriptor hog;
+
+    void init()
+    {
+        hog.setSVMDetector(HOGDescriptor::getDefaultPeopleDetector());
+    }
+
+    void project(const Template &src, Template &dst) const
+    {
+        dst = src;
+        std::vector<Rect> objLocs;
+        QList<Rect> rects;
+        hog.detectMultiScale(src, objLocs);
+        foreach (const Rect &obj, objLocs)
+            rects.append(obj);
+        dst.file.setRects(rects);
+    }
+};
+
+BR_REGISTER(Transform, HOGPersonDetectorTransform)
+
+} // namespace br
+
+#include "metadata/hogpersondetector.moc"
diff --git a/openbr/plugins/metadata/ifmetadata.cpp b/openbr/plugins/metadata/ifmetadata.cpp
new file mode 100644
index 0000000..41f56b8
--- /dev/null
+++ b/openbr/plugins/metadata/ifmetadata.cpp
@@ -0,0 +1,46 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * 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 Clear templates without the required metadata.
+ * \author Josh Klontz \cite jklontz
+ */
+class IfMetadataTransform : public UntrainableMetadataTransform
+{
+    Q_OBJECT
+    Q_PROPERTY(QString key READ get_key WRITE set_key RESET reset_key STORED false)
+    Q_PROPERTY(QString value READ get_value WRITE set_value RESET reset_value STORED false)
+    BR_PROPERTY(QString, key, "")
+    BR_PROPERTY(QString, value, "")
+
+    void projectMetadata(const File &src, File &dst) const
+    {
+        if (src.get<QString>(key, "") == value)
+            dst = src;
+    }
+};
+
+BR_REGISTER(Transform, IfMetadataTransform)
+
+} // namespace br
+
+#include "metadata/ifmetadata.moc"
diff --git a/openbr/plugins/metadata/imposteruniquenessmeasure.cpp b/openbr/plugins/metadata/imposteruniquenessmeasure.cpp
new file mode 100644
index 0000000..869d1f2
--- /dev/null
+++ b/openbr/plugins/metadata/imposteruniquenessmeasure.cpp
@@ -0,0 +1,94 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * 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 Impostor Uniqueness Measure \cite klare12
+ * \author Josh Klontz \cite jklontz
+ */
+class ImpostorUniquenessMeasureTransform : public Transform
+{
+    Q_OBJECT
+    Q_PROPERTY(br::Distance* distance READ get_distance WRITE set_distance RESET reset_distance STORED false)
+    Q_PROPERTY(double mean READ get_mean WRITE set_mean RESET reset_mean)
+    Q_PROPERTY(double stddev READ get_stddev WRITE set_stddev RESET reset_stddev)
+    Q_PROPERTY(QString inputVariable READ get_inputVariable WRITE set_inputVariable RESET reset_inputVariable STORED false)
+    BR_PROPERTY(br::Distance*, distance, Distance::make("Dist(L2)", this))
+    BR_PROPERTY(double, mean, 0)
+    BR_PROPERTY(double, stddev, 1)
+    BR_PROPERTY(QString, inputVariable, "Label")
+
+    TemplateList impostors;
+
+    float calculateIUM(const Template &probe, const TemplateList &gallery) const
+    {
+        const QString probeLabel = probe.file.get<QString>(inputVariable);
+        TemplateList subset = gallery;
+        for (int j=subset.size()-1; j>=0; j--)
+            if (subset[j].file.get<QString>(inputVariable) == probeLabel)
+                subset.removeAt(j);
+
+        QList<float> scores = distance->compare(subset, probe);
+        float min, max;
+        Common::MinMax(scores, &min, &max);
+        double mean = Common::Mean(scores);
+        return (max-mean)/(max-min);
+    }
+
+    void train(const TemplateList &data)
+    {
+        distance->train(data);
+        impostors = data;
+
+        QList<float> iums; iums.reserve(impostors.size());
+        for (int i=0; i<data.size(); i++)
+            iums.append(calculateIUM(impostors[i], impostors));
+
+        Common::MeanStdDev(iums, &mean, &stddev);
+    }
+
+    void project(const Template &src, Template &dst) const
+    {
+        dst = src;
+        float ium = calculateIUM(src, impostors);
+        dst.file.set("Impostor_Uniqueness_Measure", ium);
+        dst.file.set("Impostor_Uniqueness_Measure_Bin", ium < mean-stddev ? 0 : (ium < mean+stddev ? 1 : 2));
+    }
+
+    void store(QDataStream &stream) const
+    {
+        distance->store(stream);
+        stream << mean << stddev << impostors;
+    }
+
+    void load(QDataStream &stream)
+    {
+        distance->load(stream);
+        stream >> mean >> stddev >> impostors;
+    }
+};
+
+BR_REGISTER(Transform, ImpostorUniquenessMeasureTransform)
+
+} // namespace br
+
+#include "metadata/imposteruniquenessmeasure.moc"
diff --git a/openbr/plugins/metadata/json.cpp b/openbr/plugins/metadata/json.cpp
new file mode 100644
index 0000000..1d3dd44
--- /dev/null
+++ b/openbr/plugins/metadata/json.cpp
@@ -0,0 +1,47 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * 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 <QJsonObject>
+#include <QJsonDocument>
+
+#include <openbr/plugins/openbr_internal.h>
+
+namespace br
+{
+
+/*!
+ * \ingroup transforms
+ * \brief Represent the metadata as JSON template data.
+ * \author Josh Klontz \cite jklontz
+ */
+class JSONTransform : public UntrainableMetaTransform
+{
+    Q_OBJECT
+
+    void project(const Template &src, Template &dst) const
+    {
+        dst.file = src.file;
+        dst.file.set("AlgorithmID", 2);
+        const QByteArray json = QJsonDocument(QJsonObject::fromVariantMap(dst.file.localMetadata())).toJson().replace('\n', ' ');
+        dst += cv::Mat(1, json.size()+1 /*include null terminator*/, CV_8UC1, (void*) json.data()).clone();
+    }
+};
+
+BR_REGISTER(Transform, JSONTransform)
+
+} // namespace br
+
+#include "metadata/json.moc"
diff --git a/openbr/plugins/metadata/keepmetadata.cpp b/openbr/plugins/metadata/keepmetadata.cpp
new file mode 100644
index 0000000..6e02f8e
--- /dev/null
+++ b/openbr/plugins/metadata/keepmetadata.cpp
@@ -0,0 +1,46 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * 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 Retains only the values for the keys listed, to reduce template size
+ * \author Scott Klum \cite sklum
+ */
+class KeepMetadataTransform : public UntrainableMetadataTransform
+{
+    Q_OBJECT
+    Q_PROPERTY(QStringList keys READ get_keys WRITE set_keys RESET reset_keys STORED false)
+    BR_PROPERTY(QStringList, keys, QStringList())
+
+    void projectMetadata(const File &src, File &dst) const
+    {
+        dst = src;
+        foreach (const QString& localKey, dst.localKeys())
+            if (!keys.contains(localKey))
+                dst.remove(localKey);
+    }
+};
+
+BR_REGISTER(Transform, KeepMetadataTransform)
+
+} // namespace br
+
+#include "metadata/keepmetadata.moc"
diff --git a/openbr/plugins/keypoint.cpp b/openbr/plugins/metadata/keypointdetector.cpp
index 6c3d88d..ac94c25 100644
--- a/openbr/plugins/keypoint.cpp
+++ b/openbr/plugins/metadata/keypointdetector.cpp
@@ -15,10 +15,9 @@
  * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
 
 #include <opencv2/features2d/features2d.hpp>
-#include <opencv2/objdetect/objdetect.hpp>
-#include <opencv2/nonfree/nonfree.hpp>
-#include "openbr_internal.h"
-#include "openbr/core/opencvutils.h"
+
+#include <openbr/plugins/openbr_internal.h>
+#include <openbr/core/opencvutils.h>
 
 using namespace cv;
 
@@ -66,193 +65,6 @@ class KeyPointDetectorTransform : public UntrainableTransform
 
 BR_REGISTER(Transform, KeyPointDetectorTransform)
 
-/*!
- * \ingroup transforms
- * \brief Wraps OpenCV Key Point Descriptor
- * \author Josh Klontz \cite jklontz
- */
-class KeyPointDescriptorTransform : public UntrainableTransform
-{
-    Q_OBJECT
-    Q_PROPERTY(QString descriptor READ get_descriptor WRITE set_descriptor RESET reset_descriptor STORED false)
-    Q_PROPERTY(int size READ get_size WRITE set_size RESET reset_size STORED false)
-    BR_PROPERTY(QString, descriptor, "SIFT")
-    BR_PROPERTY(int, size, -1)
-
-    Ptr<DescriptorExtractor> descriptorExtractor;
-
-    void init()
-    {
-        descriptorExtractor = DescriptorExtractor::create(descriptor.toStdString());
-        if (descriptorExtractor.empty())
-            qFatal("Failed to create DescriptorExtractor: %s", qPrintable(descriptor));
-    }
-
-    void project(const Template &src, Template &dst) const
-    {
-        std::vector<KeyPoint> keyPoints;
-        if (size == -1)
-            foreach (const QRectF &ROI, src.file.rects())
-                keyPoints.push_back(KeyPoint(ROI.x()+ROI.width()/2, ROI.y()+ROI.height()/2, (ROI.width() + ROI.height())/2));
-        else
-            foreach (const QPointF &landmark, src.file.points())
-                keyPoints.push_back(KeyPoint(landmark.x(), landmark.y(), size));
-        if (keyPoints.empty()) return;
-        descriptorExtractor->compute(src, keyPoints, dst);
-    }
-};
-
-BR_REGISTER(Transform, KeyPointDescriptorTransform)
-
-/*!
- * \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)
-
-/*!
- * \ingroup transforms
- * \brief Specialize wrapper OpenCV SIFT wrapper
- * \author Josh Klontz \cite jklontz
- */
-class SIFTDescriptorTransform : public UntrainableTransform
-{
-    Q_OBJECT
-    Q_PROPERTY(int size READ get_size WRITE set_size RESET reset_size STORED false)
-    Q_PROPERTY(QList<int> sizes READ get_sizes WRITE set_sizes RESET reset_sizes STORED false)
-    Q_PROPERTY(int nFeatures READ get_nFeatures WRITE set_nFeatures RESET reset_nFeatures STORED false)
-    Q_PROPERTY(int nOctaveLayers READ get_nOctaveLayers WRITE set_nOctaveLayers RESET reset_nOctaveLayers STORED false)
-    Q_PROPERTY(double contrastThreshold READ get_contrastThreshold WRITE set_contrastThreshold RESET reset_contrastThreshold STORED false)
-    Q_PROPERTY(double edgeThreshold READ get_edgeThreshold WRITE set_edgeThreshold RESET reset_edgeThreshold STORED false)
-    Q_PROPERTY(double sigma READ get_sigma WRITE set_sigma RESET reset_sigma STORED false)
-    BR_PROPERTY(int, size, 1)
-    BR_PROPERTY(QList<int>, sizes, QList<int>())
-    BR_PROPERTY(int, nFeatures, 0)
-    BR_PROPERTY(int, nOctaveLayers, 3)
-    BR_PROPERTY(double, contrastThreshold, 0.04)
-    BR_PROPERTY(double, edgeThreshold, 10)
-    BR_PROPERTY(double, sigma, 1.6)
-
-    SIFT sift;
-
-    void init()
-    {
-        if (sizes.empty())
-            sizes.append(size);
-        sift = SIFT(nFeatures, nOctaveLayers, contrastThreshold, edgeThreshold, sigma);
-    }
-
-    void project(const Template &src, Template &dst) const
-    {
-        std::vector<KeyPoint> keyPoints;
-        foreach (const QPointF &val, src.file.points())
-            foreach (const int r, sizes)
-                keyPoints.push_back(KeyPoint(val.x(), val.y(), r));
-
-        Mat m;
-        sift(src, Mat(), keyPoints, m, true);
-        m.setTo(0, m<0); // SIFT returns large negative values when it goes off the edge of the image.
-        dst += m;
-    }
-};
-
-BR_REGISTER(Transform, SIFTDescriptorTransform)
-
-/*!
- * \ingroup transforms
- * \brief OpenCV HOGDescriptor wrapper
- * \author Austin Blanton \cite imaus10
- */
-class HoGDescriptorTransform : public UntrainableTransform
-{
-    Q_OBJECT
-
-    HOGDescriptor hog;
-
-    void project(const Template &src, Template &dst) const
-    {
-        std::vector<float> descriptorVals;
-        std::vector<Point> locations;
-        Size winStride = Size(0,0);
-        Size padding = Size(0,0);
-        foreach (const Mat &rect, src) {
-            hog.compute(rect, descriptorVals, winStride, padding, locations);
-            Mat HoGFeats(descriptorVals, true);
-            dst += HoGFeats;
-        }
-    }
-};
-
-BR_REGISTER(Transform, HoGDescriptorTransform)
-
-/*!
- * \ingroup transforms
- * \brief Add landmarks to the template in a grid layout
- * \author Josh Klontz \cite jklontz
- */
-class GridTransform : public UntrainableTransform
-{
-    Q_OBJECT
-    Q_PROPERTY(int rows READ get_rows WRITE set_rows RESET reset_rows STORED false)
-    Q_PROPERTY(int columns READ get_columns WRITE set_columns RESET reset_columns STORED false)
-    BR_PROPERTY(int, rows, 1)
-    BR_PROPERTY(int, columns, 1)
-
-    void project(const Template &src, Template &dst) const
-    {
-        QList<QPointF> landmarks;
-        const float row_step = 1.f * src.m().rows / rows;
-        const float column_step = 1.f * src.m().cols / columns;
-        for (float y=row_step/2; y<src.m().rows; y+=row_step)
-            for (float x=column_step/2; x<src.m().cols; x+=column_step)
-                landmarks.append(QPointF(x,y));
-        dst = src;
-        dst.file.setPoints(landmarks);
-    }
-};
-
-BR_REGISTER(Transform, GridTransform)
-
 } // namespace br
 
-#include "keypoint.moc"
+#include "metadata/keypointdetector.moc"
diff --git a/openbr/plugins/metadata/keytorect.cpp b/openbr/plugins/metadata/keytorect.cpp
new file mode 100644
index 0000000..c36ae4d
--- /dev/null
+++ b/openbr/plugins/metadata/keytorect.cpp
@@ -0,0 +1,51 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * 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 Convert values of key_X, key_Y, key_Width, key_Height to a rect.
+ * \author Jordan Cheney \cite JordanCheney
+ */
+class KeyToRectTransform : public UntrainableMetadataTransform
+{
+    Q_OBJECT
+    Q_PROPERTY(QString key READ get_key WRITE set_key RESET reset_key STORED false)
+    BR_PROPERTY(QString, key, "")
+
+    void projectMetadata(const File &src, File &dst) const
+    {
+        dst = src;
+
+        if (src.contains(QStringList() << key + "_X" << key + "_Y" << key + "_Width" << key + "_Height"))
+            dst.appendRect(QRectF(src.get<int>(key + "_X"),
+                                  src.get<int>(key + "_Y"),
+                                  src.get<int>(key + "_Width"),
+                                  src.get<int>(key + "_Height")));
+
+    }
+
+};
+
+BR_REGISTER(Transform, KeyToRectTransform)
+
+} // namespace br
+
+#include "metadata/keytorect.moc"
diff --git a/openbr/plugins/mongoose.cpp b/openbr/plugins/metadata/mongoose.cpp
index 7b4cc45..dc055de 100644
--- a/openbr/plugins/mongoose.cpp
+++ b/openbr/plugins/metadata/mongoose.cpp
@@ -1,4 +1,4 @@
-#include "openbr_internal.h"
+#include <openbr/plugins/openbr_internal.h>
 #include <mongoose.h>
 
 namespace br
@@ -66,4 +66,4 @@ BR_REGISTER(Initializer, MongooseInitializer)
 
 } // namespace br
 
-#include "mongoose.moc"
+#include "metadata/mongoose.moc"
diff --git a/openbr/plugins/metadata/name.cpp b/openbr/plugins/metadata/name.cpp
new file mode 100644
index 0000000..66eebf4
--- /dev/null
+++ b/openbr/plugins/metadata/name.cpp
@@ -0,0 +1,44 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * 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 Sets the template's matrix data to the br::File::name.
+ * \author Josh Klontz \cite jklontz
+ */
+class NameTransform : public UntrainableMetaTransform
+{
+    Q_OBJECT
+
+    void project(const Template &src, Template &dst) const
+    {
+        dst.file = src.file;
+        QByteArray name = src.file.baseName().toLocal8Bit();
+        dst = cv::Mat(1, name.size(), CV_8UC1);
+        memcpy(dst.m().data, name.data(), name.size());
+    }
+};
+
+BR_REGISTER(Transform, NameTransform)
+
+} // namespace br
+
+#include "metadata/name.moc"
diff --git a/openbr/plugins/metadata/namelandmarks.cpp b/openbr/plugins/metadata/namelandmarks.cpp
new file mode 100644
index 0000000..922fc8c
--- /dev/null
+++ b/openbr/plugins/metadata/namelandmarks.cpp
@@ -0,0 +1,65 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * 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 Name a point/rect
+ * \author Scott Klum \cite sklum
+ */
+class NameLandmarksTransform : public UntrainableMetadataTransform
+{
+    Q_OBJECT
+    Q_PROPERTY(bool point READ get_point WRITE set_point RESET reset_point STORED false)
+    BR_PROPERTY(bool, point, true)
+    Q_PROPERTY(QList<int> indices READ get_indices WRITE set_indices RESET reset_indices STORED false)
+    Q_PROPERTY(QStringList names READ get_names WRITE set_names RESET reset_names STORED false)
+    BR_PROPERTY(QList<int>, indices, QList<int>())
+    BR_PROPERTY(QStringList, names, QStringList())
+
+    void projectMetadata(const File &src, File &dst) const
+    {
+        if (indices.size() != names.size()) qFatal("Index/name size mismatch");
+
+        dst = src;
+
+        if (point) {
+            QList<QPointF> points = src.points();
+
+            for (int i=0; i<indices.size(); i++) {
+                if (indices[i] < points.size()) dst.set(names[i], points[indices[i]]);
+                else qFatal("Index out of range.");
+            }
+        } else {
+            QList<QRectF> rects = src.rects();
+
+            for (int i=0; i<indices.size(); i++) {
+                if (indices[i] < rects.size()) dst.set(names[i], rects[indices[i]]);
+                else qFatal("Index out of range.");
+            }
+        }
+    }
+};
+
+BR_REGISTER(Transform, NameLandmarksTransform)
+
+} // namespace br
+
+#include "metadata/namelandmarks.moc"
diff --git a/openbr/plugins/metadata/normalizepoints.cpp b/openbr/plugins/metadata/normalizepoints.cpp
new file mode 100644
index 0000000..2420df2
--- /dev/null
+++ b/openbr/plugins/metadata/normalizepoints.cpp
@@ -0,0 +1,55 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * 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 Normalize points to be relative to a single point
+ * \author Scott Klum \cite sklum
+ */
+class NormalizePointsTransform : public UntrainableMetadataTransform
+{
+    Q_OBJECT
+
+    Q_PROPERTY(int index READ get_index WRITE set_index RESET reset_index STORED false)
+    BR_PROPERTY(int, index, 0)
+
+    void projectMetadata(const File &src, File &dst) const
+    {
+        dst = src;
+
+        QList<QPointF> points = dst.points();
+        QPointF normPoint = points.at(index);
+
+        QList<QPointF> normalizedPoints;
+
+        for (int i=0; i<points.size(); i++)
+            if (i!=index)
+                normalizedPoints.append(normPoint-points[i]);
+
+        dst.setPoints(normalizedPoints);
+    }
+};
+
+BR_REGISTER(Transform, NormalizePointsTransform)
+
+} // namespace br
+
+#include "metadata/normalizepoints.moc"
diff --git a/openbr/plugins/metadata/pointdisplacement.cpp b/openbr/plugins/metadata/pointdisplacement.cpp
new file mode 100644
index 0000000..4e237ef
--- /dev/null
+++ b/openbr/plugins/metadata/pointdisplacement.cpp
@@ -0,0 +1,56 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * 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 Normalize points to be relative to a single point
+ * \author Scott Klum \cite sklum
+ */
+class PointDisplacementTransform : public UntrainableMetadataTransform
+{
+    Q_OBJECT
+
+    void projectMetadata(const File &src, File &dst) const
+    {
+        dst = src;
+
+        QList<QPointF> points = dst.points();
+        QList<QPointF> normalizedPoints;
+
+        for (int i=0; i<points.size(); i++)
+            for (int j=0; j<points.size(); j++)
+                // There is redundant information here
+                if (j!=i) {
+                    QPointF normalizedPoint = points[i]-points[j];
+                    normalizedPoint.setX(pow(normalizedPoint.x(),2));
+                    normalizedPoint.setY(pow(normalizedPoint.y(),2));
+                    normalizedPoints.append(normalizedPoint);
+                }
+
+        dst.setPoints(normalizedPoints);
+    }
+};
+
+BR_REGISTER(Transform, PointDisplacementTransform)
+
+} // namespace br
+
+#include "metadata/pointdisplacement.moc"
diff --git a/openbr/plugins/metadata/pointstomatrix.cpp b/openbr/plugins/metadata/pointstomatrix.cpp
new file mode 100644
index 0000000..d2d58ce
--- /dev/null
+++ b/openbr/plugins/metadata/pointstomatrix.cpp
@@ -0,0 +1,52 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * 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 Converts either the file::points() list or a QList<QPointF> metadata item to be the template's matrix
+ * \author Scott Klum \cite sklum
+ */
+class PointsToMatrixTransform : public UntrainableTransform
+{
+    Q_OBJECT
+
+    Q_PROPERTY(QString inputVariable READ get_inputVariable WRITE set_inputVariable RESET reset_inputVariable STORED false)
+    BR_PROPERTY(QString, inputVariable, QString())
+
+    void project(const Template &src, Template &dst) const
+    {
+        dst = src;
+
+        if (inputVariable.isEmpty()) {
+            dst.m() = OpenCVUtils::pointsToMatrix(dst.file.points());
+        } else {
+            if (src.file.contains(inputVariable))
+                dst.m() = OpenCVUtils::pointsToMatrix(dst.file.get<QList<QPointF> >(inputVariable));
+        }
+    }
+};
+
+BR_REGISTER(Transform, PointsToMatrixTransform)
+
+} // namespace br
+
+#include "metadata/pointstomatrix.moc"
diff --git a/openbr/plugins/metadata/procrustes.cpp b/openbr/plugins/metadata/procrustes.cpp
new file mode 100644
index 0000000..57a1051
--- /dev/null
+++ b/openbr/plugins/metadata/procrustes.cpp
@@ -0,0 +1,155 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * 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>
+#include <openbr/core/opencvutils.h>
+#include <openbr/core/eigenutils.h>
+
+using namespace cv;
+
+namespace br
+{
+
+/*!
+ * \ingroup transforms
+ * \brief Procrustes alignment of points
+ * \author Scott Klum \cite sklum
+ */
+class ProcrustesTransform : public MetadataTransform
+{
+    Q_OBJECT
+
+    Q_PROPERTY(bool warp READ get_warp WRITE set_warp RESET reset_warp STORED false)
+    BR_PROPERTY(bool, warp, true)
+
+    Eigen::MatrixXf meanShape;
+
+    void train(const TemplateList &data)
+    {
+        QList< QList<QPointF> > normalizedPoints;
+
+        // Normalize all sets of points
+        foreach (br::Template datum, data) {
+            QList<QPointF> points = datum.file.points();
+            QList<QRectF> rects = datum.file.rects();
+
+            if (points.empty() || rects.empty()) continue;
+
+            // Assume rect appended last was bounding box
+            points.append(rects.last().topLeft());
+            points.append(rects.last().topRight());
+            points.append(rects.last().bottomLeft());
+            points.append(rects.last().bottomRight());
+
+            // Center shape at origin
+            Scalar mean = cv::mean(OpenCVUtils::toPoints(points).toVector().toStdVector());
+            for (int i = 0; i < points.size(); i++) points[i] -= QPointF(mean[0],mean[1]);
+
+            // Remove scale component
+            float norm = cv::norm(OpenCVUtils::toPoints(points).toVector().toStdVector());
+            for (int i = 0; i < points.size(); i++) points[i] /= norm;
+
+            normalizedPoints.append(points);
+        }
+
+        if (normalizedPoints.empty()) qFatal("Unable to calculate normalized points");
+
+        // Determine mean shape, assuming all shapes contain the same number of points
+        meanShape = Eigen::MatrixXf(normalizedPoints[0].size(), 2);
+
+        for (int i = 0; i < normalizedPoints[0].size(); i++) {
+            double x = 0;
+            double y = 0;
+
+            for (int j = 0; j < normalizedPoints.size(); j++) {
+                x += normalizedPoints[j][i].x();
+                y += normalizedPoints[j][i].y();
+            }
+
+            x /= (double)normalizedPoints.size();
+            y /= (double)normalizedPoints.size();
+
+            meanShape(i,0) = x;
+            meanShape(i,1) = y;
+        }
+    }
+
+    void projectMetadata(const File &src, File &dst) const
+    {
+        QList<QPointF> points = src.points();
+        QList<QRectF> rects = src.rects();
+
+        if (points.empty() || rects.empty()) {
+            dst = src;
+            if (Globals->verbose) qWarning("Procrustes alignment failed because points or rects are empty.");
+            return;
+        }
+
+        // Assume rect appended last was bounding box
+        points.append(rects.last().topLeft());
+        points.append(rects.last().topRight());
+        points.append(rects.last().bottomLeft());
+        points.append(rects.last().bottomRight());
+
+        Scalar mean = cv::mean(OpenCVUtils::toPoints(points).toVector().toStdVector());
+        for (int i = 0; i < points.size(); i++) points[i] -= QPointF(mean[0],mean[1]);
+
+        Eigen::MatrixXf srcMat(points.size(), 2);
+        float norm = cv::norm(OpenCVUtils::toPoints(points).toVector().toStdVector());
+        for (int i = 0; i < points.size(); i++) {
+            points[i] /= norm;
+            srcMat(i,0) = points[i].x();
+            srcMat(i,1) = points[i].y();
+        }
+
+        Eigen::JacobiSVD<Eigen::MatrixXf> svd(srcMat.transpose()*meanShape, Eigen::ComputeThinU | Eigen::ComputeThinV);
+        Eigen::MatrixXf R = svd.matrixU()*svd.matrixV().transpose();
+
+        dst = src;
+
+        // Store procrustes stats in the order:
+        // R(0,0), R(1,0), R(1,1), R(0,1), mean_x, mean_y, norm
+        QList<float> procrustesStats;
+        procrustesStats << R(0,0) << R(1,0) << R(1,1) << R(0,1) << mean[0] << mean[1] << norm;
+        dst.setList<float>("ProcrustesStats",procrustesStats);
+
+        if (warp) {
+            Eigen::MatrixXf dstMat = srcMat*R;
+            for (int i = 0; i < dstMat.rows(); i++) {
+                dst.appendPoint(QPointF(dstMat(i,0),dstMat(i,1)));
+            }
+        }
+    }
+
+    void store(QDataStream &stream) const
+    {
+        stream << meanShape;
+    }
+
+    void load(QDataStream &stream)
+    {
+        stream >> meanShape;
+    }
+
+};
+
+BR_REGISTER(Transform, ProcrustesTransform)
+
+} // namespace br
+
+#include "metadata/procrustes.moc"
diff --git a/openbr/plugins/metadata/rectfrompoints.cpp b/openbr/plugins/metadata/rectfrompoints.cpp
new file mode 100644
index 0000000..89706e1
--- /dev/null
+++ b/openbr/plugins/metadata/rectfrompoints.cpp
@@ -0,0 +1,94 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * 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 Create rect from landmarks.
+ * \author Scott Klum \cite sklum
+ * \todo Padding should be a percent of total image size
+ */
+
+class RectFromPointsTransform : public UntrainableTransform
+{
+    Q_OBJECT
+    Q_PROPERTY(QList<int> indices READ get_indices WRITE set_indices RESET reset_indices STORED false)
+    Q_PROPERTY(double padding READ get_padding WRITE set_padding RESET reset_padding STORED false)
+    Q_PROPERTY(bool useAspectRatio READ get_useAspectRatio WRITE set_useAspectRatio RESET reset_useAspectRatio STORED false)
+    Q_PROPERTY(double aspectRatio READ get_aspectRatio WRITE set_aspectRatio RESET reset_aspectRatio STORED false)
+    BR_PROPERTY(QList<int>, indices, QList<int>())
+    BR_PROPERTY(double, padding, 0)
+    BR_PROPERTY(bool, useAspectRatio, true)
+    BR_PROPERTY(double, aspectRatio, 1.0)
+
+    void project(const Template &src, Template &dst) const
+    {
+        dst = src;
+
+        if (src.file.points().isEmpty()) {
+            if (Globals->verbose) qWarning("No landmarks");
+            return;
+        }
+
+        int minX, minY;
+        minX = minY = std::numeric_limits<int>::max();
+        int maxX, maxY;
+        maxX = maxY = -std::numeric_limits<int>::max();
+
+        QList<QPointF> points;
+
+        int numPoints = (indices.empty() ? src.file.points().size() : indices.size());
+        for (int idx = 0; idx < numPoints; idx++) {
+            int index = indices.empty() ? idx : indices[idx];
+            if (src.file.points().size() > index) {
+                if (src.file.points()[index].x() <= 0 ||
+                    src.file.points()[index].y() <= 0)   continue;
+                if (src.file.points()[index].x() < minX) minX = src.file.points()[index].x();
+                if (src.file.points()[index].x() > maxX) maxX = src.file.points()[index].x();
+                if (src.file.points()[index].y() < minY) minY = src.file.points()[index].y();
+                if (src.file.points()[index].y() > maxY) maxY = src.file.points()[index].y();
+                points.append(src.file.points()[index]);
+            }
+            else qFatal("Incorrect indices");
+        }
+
+        double width = maxX-minX;
+        double deltaWidth = width*padding;
+        width += deltaWidth;
+
+        double height = maxY-minY;
+        double deltaHeight = height*padding;
+        if (useAspectRatio)
+            deltaHeight = width/aspectRatio - height;
+        height += deltaHeight;
+
+        const int x = std::max(0.0, minX - deltaWidth/2.0);
+        const int y = std::max(0.0, minY - deltaHeight/2.0);
+
+        dst.file.setPoints(points);
+        dst.file.appendRect(QRectF(x, y, std::min((double)src.m().cols-x, width), std::min((double)src.m().rows-y, height)));
+    }
+};
+
+BR_REGISTER(Transform, RectFromPointsTransform)
+
+} // namespace br
+
+#include "metadata/rectfrompoints.moc"
diff --git a/openbr/plugins/metadata/rectstotemplates.cpp b/openbr/plugins/metadata/rectstotemplates.cpp
new file mode 100644
index 0000000..a69b287
--- /dev/null
+++ b/openbr/plugins/metadata/rectstotemplates.cpp
@@ -0,0 +1,54 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * 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 For each rectangle bounding box in src, a new
+ *      template is created.
+ * \author Brendan Klare \cite bklare
+ */
+class RectsToTemplatesTransform : public UntrainableMetaTransform
+{
+    Q_OBJECT
+
+private:
+    void project(const Template &src, Template &dst) const
+    {
+        Template tOut(src.file);
+        QList<float> confidences = src.file.getList<float>("Confidences");
+        QList<QRectF> rects = src.file.rects();
+        for (int i = 0; i < rects.size(); i++) {
+            cv::Mat m(src, OpenCVUtils::toRect(rects[i]));
+            Template t(src.file, m);
+            t.file.set("Confidence", confidences[i]);
+            t.file.clearRects();
+            tOut << t;
+        }
+        dst = tOut;
+    }
+};
+
+BR_REGISTER(Transform, RectsToTemplatesTransform)
+
+} // namespace br
+
+#include "metadata/rectstotemplates.moc"
diff --git a/openbr/plugins/metadata/regexproperty.cpp b/openbr/plugins/metadata/regexproperty.cpp
new file mode 100644
index 0000000..e4549c3
--- /dev/null
+++ b/openbr/plugins/metadata/regexproperty.cpp
@@ -0,0 +1,54 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * Copyright 2012 The MITRE Corporation                                      *
+ *                                                                           *
+ * Licensed under the Apache License, Version 2.0 (the "License");           *
+ * you may not use this file except in compliance with the License.          *
+ * You may obtain a copy of the License at                                   *
+ *                                                                           *
+ *     http://www.apache.org/licenses/LICENSE-2.0                            *
+ *                                                                           *
+ * Unless required by applicable law or agreed to in writing, software       *
+ * distributed under the License is distributed on an "AS IS" BASIS,         *
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  *
+ * See the License for the specific language governing permissions and       *
+ * limitations under the License.                                            *
+ * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+
+#include <QRegularExpression>
+
+#include <openbr/plugins/openbr_internal.h>
+
+namespace br
+{
+
+/*!
+ * \ingroup transforms
+ * \brief Apply the input regular expression to the value of inputProperty, store the matched portion in outputProperty.
+ * \author Charles Otto \cite caotto
+ */
+class RegexPropertyTransform : public UntrainableMetadataTransform
+{
+    Q_OBJECT
+    Q_PROPERTY(QString regexp READ get_regexp WRITE set_regexp RESET reset_regexp STORED false)
+    Q_PROPERTY(QString inputProperty READ get_inputProperty WRITE set_inputProperty RESET reset_inputProperty STORED false)
+    Q_PROPERTY(QString outputProperty READ get_outputProperty WRITE set_outputProperty RESET reset_outputProperty STORED false)
+    BR_PROPERTY(QString, regexp, "(.*)")
+    BR_PROPERTY(QString, inputProperty, "name")
+    BR_PROPERTY(QString, outputProperty, "Label")
+
+    void projectMetadata(const File &src, File &dst) const
+    {
+        dst = src;
+        QRegularExpression re(regexp);
+        QRegularExpressionMatch match = re.match(dst.get<QString>(inputProperty));
+        if (!match.hasMatch())
+            qFatal("Unable to match regular expression \"%s\" to base name \"%s\"!", qPrintable(regexp), qPrintable(dst.get<QString>(inputProperty)));
+        dst.set(outputProperty, match.captured(match.lastCapturedIndex()));
+    }
+};
+
+BR_REGISTER(Transform, RegexPropertyTransform)
+
+} // namespace br
+
+#include "metadata/regexproperty.moc"
diff --git a/openbr/plugins/metadata/removemetadata.cpp b/openbr/plugins/metadata/removemetadata.cpp
new file mode 100644
index 0000000..6757aeb
--- /dev/null
+++ b/openbr/plugins/metadata/removemetadata.cpp
@@ -0,0 +1,45 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * 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 a metadata field from all templates
+ * \author Brendan Klare \cite bklare
+ */
+class RemoveMetadataTransform : public UntrainableMetadataTransform
+{
+    Q_OBJECT
+    Q_PROPERTY(QString attributeName READ get_attributeName WRITE set_attributeName RESET reset_attributeName STORED false)
+    BR_PROPERTY(QString, attributeName, "None")
+
+    void projectMetadata(const File &src, File &dst) const
+    {
+        dst = src;
+        if (dst.contains(attributeName))
+            dst.remove(attributeName);
+    }
+};
+
+BR_REGISTER(Transform, RemoveMetadataTransform)
+
+} // namespace br
+
+#include "metadata/removemetadata.moc"
diff --git a/openbr/plugins/metadata/removetemplates.cpp b/openbr/plugins/metadata/removetemplates.cpp
new file mode 100644
index 0000000..8f4fe4c
--- /dev/null
+++ b/openbr/plugins/metadata/removetemplates.cpp
@@ -0,0 +1,50 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * Copyright 2012 The MITRE Corporation                                      *
+ *                                                                           *
+ * Licensed under the Apache License, Version 2.0 (the "License");           *
+ * you may not use this file except in compliance with the License.          *
+ * You may obtain a copy of the License at                                   *
+ *                                                                           *
+ *     http://www.apache.org/licenses/LICENSE-2.0                            *
+ *                                                                           *
+ * Unless required by applicable law or agreed to in writing, software       *
+ * distributed under the License is distributed on an "AS IS" BASIS,         *
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  *
+ * See the License for the specific language governing permissions and       *
+ * limitations under the License.                                            *
+ * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+
+#include <QRegularExpression>
+
+#include <openbr/plugins/openbr_internal.h>
+
+namespace br
+{
+
+/*!
+ * \ingroup transforms
+ * \brief Remove templates with the specified file extension or metadata value.
+ * \author Josh Klontz \cite jklontz
+ */
+class RemoveTemplatesTransform : public UntrainableMetaTransform
+{
+    Q_OBJECT
+    Q_PROPERTY(QString regexp READ get_regexp WRITE set_regexp RESET reset_regexp STORED false)
+    Q_PROPERTY(QString key READ get_key WRITE set_key RESET reset_key STORED false)
+    BR_PROPERTY(QString, regexp, "")
+    BR_PROPERTY(QString, key, "")
+
+    void project(const Template &src, Template &dst) const
+    {
+        const QRegularExpression re(regexp);
+        const QRegularExpressionMatch match = re.match(key.isEmpty() ? src.file.suffix() : src.file.get<QString>(key));
+        if (match.hasMatch()) dst = Template();
+        else                  dst = src;
+    }
+};
+
+BR_REGISTER(Transform, RemoveTemplatesTransform)
+
+} // namespace br
+
+#include "metadata/removetemplates.moc"
diff --git a/openbr/plugins/metadata/rename.cpp b/openbr/plugins/metadata/rename.cpp
new file mode 100644
index 0000000..431bff5
--- /dev/null
+++ b/openbr/plugins/metadata/rename.cpp
@@ -0,0 +1,52 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * 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 Rename metadata key
+ * \author Josh Klontz \cite jklontz
+ */
+class RenameTransform : public UntrainableMetadataTransform
+{
+    Q_OBJECT
+    Q_PROPERTY(QString find READ get_find WRITE set_find RESET reset_find STORED false)
+    Q_PROPERTY(QString replace READ get_replace WRITE set_replace RESET reset_replace STORED false)
+    Q_PROPERTY(bool keepOldKey READ get_keepOldKey WRITE set_keepOldKey RESET reset_keepOldKey STORED false)
+    BR_PROPERTY(QString, find, "")
+    BR_PROPERTY(QString, replace, "")
+    BR_PROPERTY(bool, keepOldKey, false)
+
+    void projectMetadata(const File &src, File &dst) const
+    {
+        dst = src;
+        if (dst.localKeys().contains(find)) {
+            dst.set(replace, dst.value(find));
+            if (!keepOldKey)
+               dst.remove(find);
+        }
+    }
+};
+
+BR_REGISTER(Transform, RenameTransform)
+
+} // namespace br
+
+#include "metadata/rename.moc"
diff --git a/openbr/plugins/metadata/renamefirst.cpp b/openbr/plugins/metadata/renamefirst.cpp
new file mode 100644
index 0000000..2c307f4
--- /dev/null
+++ b/openbr/plugins/metadata/renamefirst.cpp
@@ -0,0 +1,51 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * 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 Rename first found metadata key
+ * \author Josh Klontz \cite jklontz
+ */
+class RenameFirstTransform : public UntrainableMetadataTransform
+{
+    Q_OBJECT
+    Q_PROPERTY(QStringList find READ get_find WRITE set_find RESET reset_find STORED false)
+    Q_PROPERTY(QString replace READ get_replace WRITE set_replace RESET reset_replace STORED false)
+    BR_PROPERTY(QStringList, find, QStringList())
+    BR_PROPERTY(QString, replace, "")
+
+    void projectMetadata(const File &src, File &dst) const
+    {
+        dst = src;
+        foreach (const QString &key, find)
+            if (dst.localKeys().contains(key)) {
+                dst.set(replace, dst.value(key));
+                dst.remove(key);
+                break;
+            }
+    }
+};
+
+BR_REGISTER(Transform, RenameFirstTransform)
+
+} // namespace br
+
+#include "metadata/renamefirst.moc"
diff --git a/openbr/plugins/metadata/reorderpoints.cpp b/openbr/plugins/metadata/reorderpoints.cpp
new file mode 100644
index 0000000..cf53051
--- /dev/null
+++ b/openbr/plugins/metadata/reorderpoints.cpp
@@ -0,0 +1,57 @@
+#include <openbr/plugins/openbr_internal.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/core/common.h>
+
+namespace br
+{
+
+/*!
+ * \ingroup transforms
+ * \brief Reorder the points such that points[from[i]] becomes points[to[i]] and
+ *        vice versa
+ * \author Scott Klum \cite sklum
+ */
+class ReorderPointsTransform : public UntrainableMetadataTransform
+{
+    Q_OBJECT
+
+    Q_PROPERTY(QList<int> from READ get_from WRITE set_from RESET reset_from STORED false)
+    Q_PROPERTY(QList<int> to READ get_to WRITE set_to RESET reset_to STORED false)
+    BR_PROPERTY(QList<int>, from, QList<int>())
+    BR_PROPERTY(QList<int>, to, QList<int>())
+
+    void projectMetadata(const File &src, File &dst) const
+    {
+        if (from.size() == to.size()) {
+            QList<QPointF> points = src.points();
+            int size = src.points().size();
+            if (!points.contains(QPointF(-1,-1)) && Common::Max(from) < size && Common::Max(to) < size) {
+                for (int i=0; i<from.size(); i++) {
+                    std::swap(points[from[i]],points[to[i]]);
+                }
+                dst.setPoints(points);
+            }
+        } else qFatal("Inconsistent sizes for to and from index lists.");
+    }
+};
+
+BR_REGISTER(Transform, ReorderPointsTransform)
+
+} // namespace br
+
+#include "metadata/reorderpoints.moc"
diff --git a/openbr/plugins/metadata/restoremat.cpp b/openbr/plugins/metadata/restoremat.cpp
new file mode 100644
index 0000000..ad6b685
--- /dev/null
+++ b/openbr/plugins/metadata/restoremat.cpp
@@ -0,0 +1,51 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * 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 Set the last matrix of the input template to a matrix stored as metadata with input propName.
+ *
+ * Also removes the property from the templates metadata after restoring it.
+ *
+ * \author Charles Otto \cite caotto
+ */
+class RestoreMatTransform : public UntrainableMetaTransform
+{
+    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
+    {
+        dst = src;
+        if (dst.file.contains(propName)) {
+            dst.clear();
+            dst.m() = dst.file.get<cv::Mat>(propName);
+            dst.file.remove(propName);
+        }
+    }
+};
+
+BR_REGISTER(Transform, RestoreMatTransform)
+
+} // namespace br
+
+#include "metadata/restoremat.moc"
diff --git a/openbr/plugins/metadata/savemat.cpp b/openbr/plugins/metadata/savemat.cpp
new file mode 100644
index 0000000..97674dc
--- /dev/null
+++ b/openbr/plugins/metadata/savemat.cpp
@@ -0,0 +1,45 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * 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 Store the last matrix of the input template as a metadata key with input property name.
+ * \author Charles Otto \cite caotto
+ */
+class SaveMatTransform : public UntrainableMetaTransform
+{
+    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
+    {
+        dst = src;
+        dst.file.set(propName, QVariant::fromValue(dst.m()));
+    }
+};
+
+BR_REGISTER(Transform, SaveMatTransform)
+
+} // namespace br
+
+#include "metadata/savemat.moc"
diff --git a/openbr/plugins/metadata/selectpoints.cpp b/openbr/plugins/metadata/selectpoints.cpp
new file mode 100644
index 0000000..2851acf
--- /dev/null
+++ b/openbr/plugins/metadata/selectpoints.cpp
@@ -0,0 +1,50 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * 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 Retains only landmarks/points at the provided indices
+ * \author Brendan Klare \cite bklare
+ */
+class SelectPointsTransform : public UntrainableMetadataTransform
+{
+    Q_OBJECT
+    Q_PROPERTY(QList<int> indices READ get_indices WRITE set_indices RESET reset_indices STORED false)
+    Q_PROPERTY(bool invert READ get_invert WRITE set_invert RESET reset_invert STORED false) // keep the points _not_ in the list
+    BR_PROPERTY(QList<int>, indices, QList<int>())
+    BR_PROPERTY(bool, invert, false)
+
+    void projectMetadata(const File &src, File &dst) const
+    {
+        const QList<QPointF> srcPoints = src.points();
+        QList<QPointF> dstPoints;
+        for (int i=0; i<srcPoints.size(); i++)
+            if (indices.contains(i) ^ invert)
+                dstPoints.append(srcPoints[i]);
+        dst.setPoints(dstPoints);
+    }
+};
+
+BR_REGISTER(Transform, SelectPointsTransform)
+
+} // namespace br
+
+#include "metadata/selectpoints.moc"
diff --git a/openbr/plugins/metadata/setmetadata.cpp b/openbr/plugins/metadata/setmetadata.cpp
new file mode 100644
index 0000000..55d698d
--- /dev/null
+++ b/openbr/plugins/metadata/setmetadata.cpp
@@ -0,0 +1,46 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * 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 Sets the metadata key/value pair.
+ * \author Josh Klontz \cite jklontz
+ */
+class SetMetadataTransform : public UntrainableMetadataTransform
+{
+    Q_OBJECT
+    Q_PROPERTY(QString key READ get_key WRITE set_key RESET reset_key STORED false)
+    Q_PROPERTY(QString value READ get_value WRITE set_value RESET reset_value STORED false)
+    BR_PROPERTY(QString, key, "")
+    BR_PROPERTY(QString, value, "")
+
+    void projectMetadata(const File &src, File &dst) const
+    {
+        dst = src;
+        dst.set(key, value);
+    }
+};
+
+BR_REGISTER(Transform, SetMetadataTransform)
+
+} // namespace br
+
+#include "metadata/setmetadata.moc"
diff --git a/openbr/plugins/metadata/setpointsinrect.cpp b/openbr/plugins/metadata/setpointsinrect.cpp
new file mode 100644
index 0000000..940e846
--- /dev/null
+++ b/openbr/plugins/metadata/setpointsinrect.cpp
@@ -0,0 +1,53 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * 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 Set points relative to a rect
+ * \author Jordan Cheney \cite JordanCheney
+ */
+class SetPointsInRectTransform : public UntrainableMetadataTransform
+{
+    Q_OBJECT
+
+    void projectMetadata(const File &src, File &dst) const
+    {
+        dst  = src;
+
+        QList<QRectF> rects = src.rects();
+        if (rects.size() != 1)
+            qFatal("Must have one and only one rect per template");
+        QRectF rect = rects.first();
+
+        QList<QPointF> srcPoints = src.points();
+        QList<QPointF> dstPoints;
+        foreach (const QPointF &point, srcPoints)
+            dstPoints.append(QPointF(point.x() - rect.x(), point.y() - rect.y()));
+
+        dst.setPoints(dstPoints);
+    }
+};
+
+BR_REGISTER(Transform, SetPointsInRectTransform)
+
+} // namespace br
+
+#include "metadata/setpointsinrect.moc"
diff --git a/openbr/plugins/stasm4.cpp b/openbr/plugins/metadata/stasm4.cpp
index 98bbad6..6cc0c06 100644
--- a/openbr/plugins/stasm4.cpp
+++ b/openbr/plugins/metadata/stasm4.cpp
@@ -1,12 +1,12 @@
+#include <QString>
 #include <stasm_lib.h>
 #include <stasmcascadeclassifier.h>
 #include <opencv2/opencv.hpp>
-#include <Eigen/Dense>
-#include "openbr_internal.h"
-#include "openbr/core/qtutils.h"
-#include "openbr/core/opencvutils.h"
-#include "openbr/core/eigenutils.h"
-#include <QString>
+
+#include <openbr/plugins/openbr_internal.h>
+#include <openbr/core/qtutils.h>
+#include <openbr/core/opencvutils.h>
+#include <openbr/core/eigenutils.h>
 
 using namespace std;
 using namespace cv;
@@ -163,41 +163,6 @@ class StasmTransform : public UntrainableTransform
 
 BR_REGISTER(Transform, StasmTransform)
 
-/*!
- * \ingroup transforms
- * \brief Designed for use after eye detection + Stasm, this will
- * revert the detected landmarks to the original coordinate space
- * before affine alignment to the stasm mean shape. The storeAffine
- * parameter must be set to true when calling AffineTransform before this.
- * \author Brendan Klare \cite bklare
- */
-class RevertAffineTransform : public UntrainableTransform
-{
-    Q_OBJECT
-
-private:
-
-    void project(const Template &src, Template &dst) const
-    {
-        QList<float> paramList = src.file.getList<float>("affineParameters");
-        Eigen::MatrixXf points = EigenUtils::pointsToMatrix(src.file.points(), true);
-        Eigen::MatrixXf affine = Eigen::MatrixXf::Zero(3, 3);
-        for (int i = 0, cnt = 0; i < 2; i++)
-            for (int j = 0; j < 3; j++, cnt++)
-                affine(i, j) = paramList[cnt];
-        affine(2, 2) = 1;
-        affine = affine.inverse();
-        Eigen::MatrixXf affineInv = affine.block(0, 0, 2, 3);
-        Eigen::MatrixXf pointsT = points.transpose();
-        points =  affineInv * pointsT;
-        dst = src;
-        dst.file.clearPoints();
-        dst.file.setPoints(EigenUtils::matrixToPoints(points.transpose()));
-    }
-};
-
-BR_REGISTER(Transform, RevertAffineTransform)
-
 } // namespace br
 
-#include "stasm4.moc"
+#include "metadata/stasm4.moc"
diff --git a/openbr/plugins/time.cpp b/openbr/plugins/metadata/stopwatch.cpp
index 484031d..01c19ff 100644
--- a/openbr/plugins/time.cpp
+++ b/openbr/plugins/metadata/stopwatch.cpp
@@ -1,3 +1,19 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * 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
@@ -84,6 +100,6 @@ private:
 
 BR_REGISTER(Transform, StopWatchTransform)
 
-} //namespace br
+} // namespace br
 
-#include "time.moc"
+#include "metadata/stopwatch.moc"
diff --git a/openbr/plugins/misc.cpp b/openbr/plugins/misc.cpp
deleted file mode 100644
index af2f793..0000000
--- a/openbr/plugins/misc.cpp
+++ /dev/null
@@ -1,1013 +0,0 @@
-/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
- * 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 <QtNetwork>
-#include <QElapsedTimer>
-#include <QRegularExpression>
-#include <opencv2/highgui/highgui.hpp>
-#include "openbr_internal.h"
-#include "openbr/core/opencvutils.h"
-#include "openbr/core/qtutils.h"
-
-using namespace cv;
-
-namespace br
-{
-
-/*!
- * \ingroup transforms
- * \brief Applies br::Format to br::Template::file::name and appends results.
- * \author Josh Klontz \cite jklontz
- */
-class OpenTransform : public UntrainableMetaTransform
-{
-    Q_OBJECT
-
-    void project(const Template &src, Template &dst) const
-    {
-        dst.file = src.file;
-        if (src.empty()) {
-            if (Globals->verbose)
-                qDebug("Opening %s", qPrintable(src.file.flat()));
-
-            // Read from disk otherwise
-            foreach (const File &file, src.file.split()) {
-                QScopedPointer<Format> format(Factory<Format>::make(file));
-                Template t = format->read();
-                if (t.isEmpty())
-                    qWarning("Can't open %s from %s", qPrintable(file.flat()), qPrintable(QDir::currentPath()));
-                dst.append(t);
-                dst.file.append(t.file.localMetadata());
-            }
-            if (dst.isEmpty())
-                dst.file.fte = true;
-        } else {
-            // Propogate or decode existing matricies
-            foreach (const Mat &m, src) {
-                if (((m.rows > 1) && (m.cols > 1)) || (m.type() != CV_8UC1))
-                    dst += m;
-                else {
-                    Mat dec = imdecode(src.m(), IMREAD_UNCHANGED);
-                    if (dec.empty()) qWarning("Can't decode %s", qPrintable(src.file.flat()));
-                    else dst += dec;
-                }
-            }
-        }
-    }
-};
-
-BR_REGISTER(Transform, OpenTransform)
-
-/*!
- * \ingroup transforms
- * \brief Decodes images
- * \author Josh Klontz \cite jklontz
- */
-class DecodeTransform : public UntrainableTransform
-{
-    Q_OBJECT
-
-    void project(const Template &src, Template &dst) const
-    {
-        dst.append(cv::imdecode(src.m(), IMREAD_UNCHANGED));
-    }
-};
-
-BR_REGISTER(Transform, DecodeTransform)
-
-/*!
- * \ingroup transforms
- * \brief Read images
- * \author Josh Klontz \cite jklontz
- */
-class ReadTransform : public UntrainableMetaTransform
-{
-    Q_OBJECT
-    Q_ENUMS(Mode)
-    Q_PROPERTY(Mode mode READ get_mode WRITE set_mode RESET reset_mode)
-
-public:
-    enum Mode
-    {
-        Unchanged = IMREAD_UNCHANGED,
-        Grayscale = IMREAD_GRAYSCALE,
-        Color     = IMREAD_COLOR,
-        AnyDepth  = IMREAD_ANYDEPTH,
-        AnyColor  = IMREAD_ANYCOLOR
-    };
-
-private:
-    BR_PROPERTY(Mode, mode, Color)
-
-    void project(const Template &src, Template &dst) const
-    {
-        dst.file = src.file;
-        if (Globals->verbose)
-            qDebug("Opening %s", qPrintable(src.file.flat()));
-
-        if (src.empty()) {
-            const Mat img = imread(src.file.resolved().toStdString(), mode);
-            if (img.data) dst.append(img);
-            else          dst.file.fte = true;
-        } else {
-            foreach (const Mat &m, src) {
-                const Mat img = imdecode(m, mode);
-                if (img.data) dst.append(img);
-                else          dst.file.fte = true;
-            }
-        }
-        if (dst.file.fte)
-            qWarning("Error opening %s", qPrintable(src.file.flat()));
-    }
-};
-BR_REGISTER(Transform, ReadTransform)
-
-/*!
- * \ingroup transforms
- * \brief Downloads an image from a URL
- * \author Josh Klontz \cite jklontz
- */
-class DownloadTransform : public UntrainableMetaTransform
-{
-    Q_OBJECT
-    Q_ENUMS(Mode)
-    Q_PROPERTY(Mode mode READ get_mode WRITE set_mode RESET reset_mode STORED false)
-
-public:
-    enum Mode { Permissive,
-                Encoded,
-                Decoded };
-private:
-    BR_PROPERTY(Mode, mode, Encoded)
-
-    // The reasons for this data structure are as follows:
-    // 1) The QNetworkAccessManager must be used in the thread that _created_ it,
-    //    hence the use of `QThreadStorage`.
-    // 2) The QThreadStorage must be deleted _after_ the threads that added QNetworkAccessManager
-    //    to it are deleted, hence the `static` ensuring that `nam` is deleted at program termination,
-    //    long after the threads that created QNetworkAccessManager are deleted.
-    static QThreadStorage<QNetworkAccessManager*> nam;
-
-    void project(const Template &src, Template &dst) const
-    {
-        dst.file = src.file;
-        QString url = src.file.get<QString>("URL", src.file.name).simplified();
-        if (!url.contains("://"))
-            url = "file://" + url;
-        dst.file.set("URL", url);
-        if (url.startsWith("file://"))
-            url = url.mid(7);
-
-        QIODevice *device = NULL;
-        if (QFileInfo(url).exists()) {
-            device = new QFile(url);
-            device->open(QIODevice::ReadOnly);
-        } else {
-            if (!nam.hasLocalData())
-                nam.setLocalData(new QNetworkAccessManager());
-            const QUrl qURL(url, QUrl::StrictMode);
-            if (qURL.isValid() && !qURL.isRelative()) {
-                QNetworkRequest req = QNetworkRequest(qURL);
-                req.setRawHeader("User-Agent", "br");
-                QNetworkReply *reply = nam.localData()->get(req);
-
-                reply->waitForReadyRead(-1);
-                while (!reply->isFinished())
-                    QCoreApplication::processEvents();
-
-                if (reply->error() != QNetworkReply::NoError) {
-                    qDebug() << reply->errorString() << url;
-                    reply->deleteLater();
-                } else {
-                    device = reply;
-                }
-            }
-        }
-
-        QByteArray data;
-        if (device) {
-            data = device->readAll();
-            delete device;
-            device = NULL;
-        }
-
-        if (!data.isEmpty()) {
-            Mat encoded(1, data.size(), CV_8UC1, (void*)data.data());
-            encoded = encoded.clone();
-            if (mode == Permissive) {
-                dst += encoded;
-            } else {
-                Mat decoded = imdecode(encoded, IMREAD_UNCHANGED);
-                if (!decoded.empty())
-                    dst += (mode == Encoded) ? encoded : decoded;
-            }
-
-            dst.file.set("ImageID", QVariant(QCryptographicHash::hash(data, QCryptographicHash::Md5).toHex()));
-            dst.file.set("AlgorithmID", data.isEmpty() ? 0 : (mode == Decoded ? 5 : 3));
-        }
-    }
-};
-QThreadStorage<QNetworkAccessManager*> DownloadTransform::nam;
-
-BR_REGISTER(Transform, DownloadTransform)
-
-/*!
- * \ingroup transforms
- * \brief Prints the template's file to stdout or stderr.
- * \author Josh Klontz \cite jklontz
- */
-class PrintTransform : public UntrainableMetaTransform
-{
-    Q_OBJECT
-    Q_PROPERTY(bool error READ get_error WRITE set_error RESET reset_error)
-    Q_PROPERTY(bool data READ get_data WRITE set_data RESET reset_data)
-    BR_PROPERTY(bool, error, true)
-    BR_PROPERTY(bool, data, false)
-
-    void project(const Template &src, Template &dst) const
-    {
-        dst = src;
-        const QString nameString = src.file.flat();
-        const QString dataString = data ? OpenCVUtils::matrixToString(src)+"\n" : QString();
-        QStringList matricies;
-        foreach (const Mat &m, src)
-            matricies.append(QString::number(m.rows) + "x" + QString::number(m.cols) + "_" + OpenCVUtils::typeToString(m));
-        QString fteString = src.file.fte ? "\n  FTE=true" : QString();
-        fprintf(error ? stderr : stdout, "%s%s\n  %s\n%s", qPrintable(nameString), qPrintable(fteString), qPrintable(matricies.join(",")), qPrintable(dataString));
-    }
-};
-
-BR_REGISTER(Transform, PrintTransform)
-
-/*!
- * \ingroup transforms
- * \brief Checks the template for NaN values.
- * \author Josh Klontz \cite jklontz
- */
-class CheckTransform : public UntrainableMetaTransform
-{
-    Q_OBJECT
-    static int count;
-    int index;
-
- public:
-    CheckTransform() : index(count++) {}
-
-    void project(const Template &src, Template &dst) const
-    {
-        dst = src;
-        foreach (const Mat &m, src) {
-            Mat fm;
-            m.convertTo(fm, CV_32F);
-            const int elements = fm.rows * fm.cols * fm.channels();
-            const float *data = (const float*)fm.data;
-            for (int i=0; i<elements; i++)
-                if (data[i] != data[i])
-                    qFatal("%s NaN check %d failed!", qPrintable(src.file.flat()), index);
-        }
-    }
-};
-
-int CheckTransform::count = 0;
-
-BR_REGISTER(Transform, CheckTransform)
-
-/*!
- * \ingroup transforms
- * \brief Sets the template's matrix data to the br::File::name.
- * \author Josh Klontz \cite jklontz
- */
-class NameTransform : public UntrainableMetaTransform
-{
-    Q_OBJECT
-
-    void project(const Template &src, Template &dst) const
-    {
-        dst.file = src.file;
-        QByteArray name = src.file.baseName().toLocal8Bit();
-        dst = Mat(1, name.size(), CV_8UC1);
-        memcpy(dst.m().data, name.data(), name.size());
-    }
-};
-
-BR_REGISTER(Transform, NameTransform)
-
-/*!
- * \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)
-
-/*!
- * \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)
-
-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)
-
-/*!
- * \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)
-
-/*!
- * \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)
-
-/*!
- * \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]
-
-/*!
- * \ingroup transforms
- * \brief Rename metadata key
- * \author Josh Klontz \cite jklontz
- */
-class RenameTransform : public UntrainableMetadataTransform
-{
-    Q_OBJECT
-    Q_PROPERTY(QString find READ get_find WRITE set_find RESET reset_find STORED false)
-    Q_PROPERTY(QString replace READ get_replace WRITE set_replace RESET reset_replace STORED false)
-    Q_PROPERTY(bool keepOldKey READ get_keepOldKey WRITE set_keepOldKey RESET reset_keepOldKey STORED false)
-    BR_PROPERTY(QString, find, "")
-    BR_PROPERTY(QString, replace, "")
-    BR_PROPERTY(bool, keepOldKey, false)
-
-    void projectMetadata(const File &src, File &dst) const
-    {
-        dst = src;
-        if (dst.localKeys().contains(find)) {
-            dst.set(replace, dst.value(find));
-            if (!keepOldKey)
-               dst.remove(find);
-        }
-    }
-};
-
-BR_REGISTER(Transform, RenameTransform)
-
-/*!
- * \ingroup transforms
- * \brief Rename first found metadata key
- * \author Josh Klontz \cite jklontz
- */
-class RenameFirstTransform : public UntrainableMetadataTransform
-{
-    Q_OBJECT
-    Q_PROPERTY(QStringList find READ get_find WRITE set_find RESET reset_find STORED false)
-    Q_PROPERTY(QString replace READ get_replace WRITE set_replace RESET reset_replace STORED false)
-    BR_PROPERTY(QStringList, find, QStringList())
-    BR_PROPERTY(QString, replace, "")
-
-    void projectMetadata(const File &src, File &dst) const
-    {
-        dst = src;
-        foreach (const QString &key, find)
-            if (dst.localKeys().contains(key)) {
-                dst.set(replace, dst.value(key));
-                dst.remove(key);
-                break;
-            }
-    }
-};
-
-BR_REGISTER(Transform, RenameFirstTransform)
-
-/*!
- * \ingroup transforms
- * \brief Add any ground truth to the template using the file's base name.
- * \author Josh Klontz \cite jklontz
- */
-class GroundTruthTransform : public UntrainableMetaTransform
-{
-    Q_OBJECT
-    Q_PROPERTY(QString groundTruth READ get_groundTruth WRITE set_groundTruth RESET reset_groundTruth STORED false)
-    Q_PROPERTY(QStringList keys READ get_keys WRITE set_keys RESET reset_keys STORED false)
-    BR_PROPERTY(QString, groundTruth, "")
-    BR_PROPERTY(QStringList, keys, QStringList())
-
-    QMap<QString,File> files;
-
-    void init()
-    {
-        foreach (const File &file, TemplateList::fromGallery(groundTruth).files())
-            files.insert(file.baseName(), file);
-    }
-
-    void project(const Template &src, Template &dst) const
-    {
-        dst = src;
-        foreach(const QString &key, keys) dst.file.set(key,files[dst.file.baseName()].value(key));
-    }
-};
-
-BR_REGISTER(Transform, GroundTruthTransform)
-
-/*!
- * \ingroup transforms
- * \brief Change the br::Template::file extension
- * \author Josh Klontz \cite jklontz
- */
-class AsTransform : public UntrainableMetadataTransform
-{
-    Q_OBJECT
-    Q_PROPERTY(QString extension READ get_extension WRITE set_extension RESET reset_extension STORED false)
-    BR_PROPERTY(QString, extension, "")
-
-    void projectMetadata(const File &src, File &dst) const
-    {
-        dst = src;
-        dst.name = dst.name.left(dst.name.lastIndexOf('.')+1) + extension;
-    }
-};
-
-BR_REGISTER(Transform, AsTransform)
-
-/*!
- * \ingroup transforms
- * \brief Apply the input regular expression to the value of inputProperty, store the matched portion in outputProperty.
- * \author Charles Otto \cite caotto
- */
-class RegexPropertyTransform : public UntrainableMetadataTransform
-{
-    Q_OBJECT
-    Q_PROPERTY(QString regexp READ get_regexp WRITE set_regexp RESET reset_regexp STORED false)
-    Q_PROPERTY(QString inputProperty READ get_inputProperty WRITE set_inputProperty RESET reset_inputProperty STORED false)
-    Q_PROPERTY(QString outputProperty READ get_outputProperty WRITE set_outputProperty RESET reset_outputProperty STORED false)
-    BR_PROPERTY(QString, regexp, "(.*)")
-    BR_PROPERTY(QString, inputProperty, "name")
-    BR_PROPERTY(QString, outputProperty, "Label")
-
-    void projectMetadata(const File &src, File &dst) const
-    {
-        dst = src;
-        QRegularExpression re(regexp);
-        QRegularExpressionMatch match = re.match(dst.get<QString>(inputProperty));
-        if (!match.hasMatch())
-            qFatal("Unable to match regular expression \"%s\" to base name \"%s\"!", qPrintable(regexp), qPrintable(dst.get<QString>(inputProperty)));
-        dst.set(outputProperty, match.captured(match.lastCapturedIndex()));
-    }
-};
-
-BR_REGISTER(Transform, RegexPropertyTransform)
-
-/*!
- * \ingroup transforms
- * \brief Create matrix from metadata values.
- * \author Josh Klontz \cite jklontz
- */
-class ExtractMetadataTransform : public UntrainableMetaTransform
-{
-    Q_OBJECT
-    Q_PROPERTY(QStringList keys READ get_keys WRITE set_keys RESET reset_keys STORED false)
-    BR_PROPERTY(QStringList, keys, QStringList())
-
-    void project(const Template &src, Template &dst) const
-    {
-        dst.file = src.file;
-        QList<float> values;
-        foreach (const QString &key, keys)
-            values.append(src.file.get<float>(key));
-        dst.append(OpenCVUtils::toMat(values, 1));
-    }
-};
-
-BR_REGISTER(Transform, ExtractMetadataTransform)
-
-/*!
- * \ingroup transforms
- * \brief Store the last matrix of the input template as a metadata key with input property name.
- * \author Charles Otto \cite caotto
- */
-class SaveMatTransform : public UntrainableMetaTransform
-{
-    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
-    {
-        dst = src;
-        dst.file.set(propName, QVariant::fromValue(dst.m()));
-    }
-};
-BR_REGISTER(Transform, SaveMatTransform)
-
-/*!
- * \ingroup transforms
- * \brief Set the last matrix of the input template to a matrix stored as metadata with input propName.
- *
- * Also removes the property from the templates metadata after restoring it.
- *
- * \author Charles Otto \cite caotto
- */
-class RestoreMatTransform : public UntrainableMetaTransform
-{
-    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
-    {
-        dst = src;
-        if (dst.file.contains(propName)) {
-            dst.clear();
-            dst.m() = dst.file.get<cv::Mat>(propName);
-            dst.file.remove(propName);
-        }
-    }
-};
-BR_REGISTER(Transform, RestoreMatTransform)
-
-
-/*!
- * \ingroup transforms
- * \brief Incrementally output templates received to a gallery, based on the current filename
- * When a template is received in projectUpdate for the first time since a finalize, open a new gallery based on the
- * template's filename, and the galleryFormat property.
- * Templates received in projectUpdate will be output to the gallery with a filename combining their original filename and
- * their FrameNumber property, with the file extension specified by the fileFormat property.
- * \author Charles Otto \cite caotto
- */
-class IncrementalOutputTransform : public TimeVaryingTransform
-{
-    Q_OBJECT
-
-    Q_PROPERTY(QString galleryFormat READ get_galleryFormat WRITE set_galleryFormat RESET reset_galleryFormat STORED false)
-    Q_PROPERTY(QString fileFormat READ get_fileFormat WRITE set_fileFormat RESET reset_fileFormat STORED false)
-    BR_PROPERTY(QString, galleryFormat, "")
-    BR_PROPERTY(QString, fileFormat, ".png")
-
-    bool galleryUp;
-
-    void projectUpdate(const TemplateList &src, TemplateList &dst)
-    {
-        if (src.empty())
-            return;
-
-        if (!galleryUp) {
-            QFileInfo finfo(src[0].file.name);
-            QString galleryName = finfo.baseName() + galleryFormat;
-
-            writer = QSharedPointer<Gallery> (Factory<Gallery>::make(galleryName));
-            galleryUp = true;
-        }
-
-        dst = src;
-        int idx =0;
-        foreach (const Template &t, src) {
-            if (t.empty())
-                continue;
-
-            // Build the output filename for this template
-            QFileInfo finfo(t.file.name);
-            QString outputName = finfo.baseName() +"_" + t.file.get<QString>("FrameNumber") + "_" + QString::number(idx)+ fileFormat;
-
-            idx++;
-            Template out = t;
-            out.file.name = outputName;
-            writer->write(out);
-        }
-    }
-
-    void train(const TemplateList& data)
-    {
-        (void) data;
-    }
-
-    // Drop the current gallery.
-    void finalize(TemplateList &data)
-    {
-        (void) data;
-        galleryUp = false;
-    }
-
-    QSharedPointer<Gallery> writer;
-public:
-    IncrementalOutputTransform() : TimeVaryingTransform(false,false) {galleryUp = false;}
-};
-
-BR_REGISTER(Transform, IncrementalOutputTransform)
-
-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)
-
-
-class GalleryOutputTransform : public TimeVaryingTransform
-{
-    Q_OBJECT
-
-    Q_PROPERTY(QString outputString READ get_outputString WRITE set_outputString RESET reset_outputString STORED false)
-    BR_PROPERTY(QString, outputString, "")
-
-    void projectUpdate(const TemplateList &src, TemplateList &dst)
-    {
-        if (src.empty())
-            return;
-        dst = src;
-        for (int i=0; i < dst.size();i++) {
-            if (dst[i].file.getBool("FTE"))
-                dst[i].file.fte = true;
-        }
-        writer->writeBlock(dst);
-    }
-
-    void train(const TemplateList& data)
-    {
-        (void) data;
-    }
-    ;
-    void init()
-    {
-        writer = QSharedPointer<Gallery>(Gallery::make(outputString));
-    }
-
-    QSharedPointer<Gallery> writer;
-public:
-    GalleryOutputTransform() : TimeVaryingTransform(false,false) {}
-};
-
-BR_REGISTER(Transform, GalleryOutputTransform)
-
-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)
-
-
-class OutputTransform : public TimeVaryingTransform
-{
-    Q_OBJECT
-
-    Q_PROPERTY(QString outputString READ get_outputString WRITE set_outputString RESET reset_outputString STORED false)
-    // names of mem galleries containing filelists we need.
-    Q_PROPERTY(QString targetName READ get_targetName WRITE set_targetName RESET reset_targetName STORED false)
-    Q_PROPERTY(QString queryName  READ get_queryName WRITE set_queryName RESET reset_queryName STORED false)
-    Q_PROPERTY(bool transposeMode  READ get_transposeMode WRITE set_transposeMode RESET reset_transposeMode STORED false)
-
-    BR_PROPERTY(QString, outputString, "")
-    BR_PROPERTY(QString, targetName, "")
-    BR_PROPERTY(QString, queryName, "")
-
-    BR_PROPERTY(bool,transposeMode, false)
-    ;
-
-    void projectUpdate(const TemplateList &src, TemplateList &dst)
-    {
-        dst = src;
-
-        if (src.empty())
-            return;
-
-        // we received a template, which is the next row/column in order
-        foreach (const Template &t, dst) {
-            bool fte = t.file.getBool("FTE") || t.file.fte;
-
-            for (int i=0; i < scoresPerMat; i++) {
-                output->setRelative(fte ? -std::numeric_limits<float>::max() : t.m().at<float>(0, i), currentRow, currentCol);
-
-                // row-major input
-                if (!transposeMode)
-                    currentCol++;
-                // col-major input
-                else
-                    currentRow++;
-            }
-            // filled in a row, advance to the next, reset column position
-            if (!transposeMode) {
-                currentRow++;
-                currentCol = 0;
-            }
-            // filled in a column, advance, reset row
-            else {
-                currentCol++;
-                currentRow = 0;
-            }
-
-            bool blockDone = false;
-            // In direct mode, we don't buffer rows
-            if (!transposeMode) {
-                currentBlockRow++;
-                blockDone = true;
-            }
-            // in transpose mode, we buffer 100 cols before writing the block
-            else if (currentCol == bufferedSize) {
-                currentBlockCol++;
-                blockDone = true;
-            }
-            else return;
-
-            if (blockDone) {
-                // set the next block, only necessary if we haven't buffered the current item
-                output->setBlock(currentBlockRow, currentBlockCol);
-                currentRow = 0;
-                currentCol = 0;
-            }
-        }
-    }
-
-    void train(const TemplateList& data)
-    {
-        (void) data;
-    }
-
-    void init()
-    {
-        if (targetName.isEmpty() || queryName.isEmpty() || outputString.isEmpty())
-            return;
-
-        FileList targetFiles = FileList::fromGallery(targetName);
-        FileList queryFiles  = FileList::fromGallery(queryName);
-
-        currentBlockRow = 0;
-        currentBlockCol = 0;
-
-        currentRow = 0;
-        currentCol = 0;
-
-        bufferedSize = 100;
-
-        if (transposeMode) {
-            // buffer 100 cols at a time
-            fragmentsPerRow = bufferedSize;
-            // a single col contains comparisons to all query files
-            fragmentsPerCol = queryFiles.size();
-            scoresPerMat = fragmentsPerCol;
-        }
-        else {
-            // a single row contains comparisons to all target files
-            fragmentsPerRow = targetFiles.size();
-            scoresPerMat = fragmentsPerRow;
-            // we output rows one at a time
-            fragmentsPerCol = 1;
-        }
-
-        output = QSharedPointer<Output>(Output::make(outputString+"[targetGallery="+targetName+",queryGallery="+queryName+"]", targetFiles, queryFiles));
-        output->blockRows = fragmentsPerCol;
-        output->blockCols = fragmentsPerRow;
-        output->initialize(targetFiles, queryFiles);
-
-        output->setBlock(currentBlockRow, currentBlockCol);
-    }
-
-    QSharedPointer<Output> output;
-
-    int bufferedSize;
-
-    int currentRow;
-    int currentCol;
-
-    int currentBlockRow;
-    int currentBlockCol;
-
-    int fragmentsPerRow;
-    int fragmentsPerCol;
-
-    int scoresPerMat;
-
-public:
-    OutputTransform() : TimeVaryingTransform(false,false) {}
-};
-
-BR_REGISTER(Transform, OutputTransform)
-
-class FileExclusionTransform : public UntrainableMetaTransform
-{
-    Q_OBJECT
-
-    Q_PROPERTY(QString exclusionGallery READ get_exclusionGallery WRITE set_exclusionGallery RESET reset_exclusionGallery STORED false)
-    BR_PROPERTY(QString, exclusionGallery, "")
-
-    QSet<QString> excluded;
-
-    void project(const Template &, Template &) const
-    {
-        qFatal("FileExclusion can't do anything here");
-    }
-
-    void project(const TemplateList &src, TemplateList &dst) const
-    {
-        foreach (const Template &srcTemp, src) {
-            if (!excluded.contains(srcTemp.file))
-                dst.append(srcTemp);
-        }
-    }
-
-    void init()
-    {
-        if (exclusionGallery.isEmpty())
-            return;
-        File rFile(exclusionGallery);
-        rFile.remove("append");
-
-        FileList temp = FileList::fromGallery(rFile);
-        excluded = QSet<QString>::fromList(temp.names());
-    }
-};
-
-BR_REGISTER(Transform, FileExclusionTransform)
-
-class TransposeTransform : public UntrainableTransform
-{
-    Q_OBJECT
-
-    void project(const Template &src, Template &dst) const
-    {
-        dst.m() = src.m().t();
-    }
-};
-
-BR_REGISTER(Transform, TransposeTransform)
-
-}
-
-#include "misc.moc"
diff --git a/openbr/plugins/output.cpp b/openbr/plugins/output.cpp
deleted file mode 100644
index f503c2f..0000000
--- a/openbr/plugins/output.cpp
+++ /dev/null
@@ -1,658 +0,0 @@
-/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
- * 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 <QByteArray>
-#include <QCoreApplication>
-#include <QDebug>
-#include <QDir>
-#include <QHash>
-#include <QFile>
-#include <QFileInfo>
-#include <QFutureSynchronizer>
-#include <QList>
-#include <QMutex>
-#include <QPair>
-#include <QVector>
-#include <QtConcurrent>
-#include <QtGlobal>
-#include <opencv2/highgui/highgui.hpp>
-#include <iostream>
-#include <limits>
-#include <assert.h>
-#include "openbr_internal.h"
-
-#include "openbr/core/bee.h"
-#include "openbr/core/eval.h"
-#include "openbr/core/common.h"
-#include "openbr/core/opencvutils.h"
-#include "openbr/core/qtutils.h"
-
-namespace br
-{
-/*!
- * \ingroup outputs
- * \brief Adaptor class -- write a matrix output using Format classes.
- * \author Charles Otto \cite caotto
- */
-class DefaultOutput : public MatrixOutput
-{
-    Q_OBJECT
-
-    ~DefaultOutput()
-    {
-        if (file.isNull() || targetFiles.isEmpty() || queryFiles.isEmpty()) return;
-
-        br::Template T(this->file, this->data);
-        QScopedPointer<Format> writer(Factory<Format>::make(this->file));
-        writer->write(T);
-    }
-};
-
-BR_REGISTER(Output, DefaultOutput)
-
-/*!
- * \ingroup outputs
- * \brief Comma separated values output.
- * \author Josh Klontz \cite jklontz
- */
-class csvOutput : public MatrixOutput
-{
-    Q_OBJECT
-
-    ~csvOutput()
-    {
-        if (file.isNull() || targetFiles.isEmpty() || queryFiles.isEmpty()) return;
-        QStringList lines;
-        lines.append("File," + targetFiles.names().join(","));
-        for (int i=0; i<queryFiles.size(); i++) {
-            QStringList words;
-            for (int j=0; j<targetFiles.size(); j++)
-                words.append(toString(i,j));  // The toString idiom is used to output match scores - see MatrixOutput
-            lines.append(queryFiles[i].name+","+words.join(","));
-        }
-        QtUtils::writeFile(file, lines);
-    }
-};
-
-BR_REGISTER(Output, csvOutput)
-
-/*!
- * \ingroup outputs
- * \brief Matrix-like output for heat maps.
- * \author Scott Klum \cite sklum
- */
-class heatOutput : public MatrixOutput
-{
-    Q_OBJECT
-    Q_PROPERTY(int patches READ get_patches WRITE set_patches RESET reset_patches STORED false)
-    BR_PROPERTY(int, patches, -1)
-
-    ~heatOutput()
-    {
-        if (file.isNull() || targetFiles.isEmpty() || queryFiles.isEmpty()) return;
-
-        QStringList lines;
-        for (int i=0; i<data.rows; i++) {
-            lines.append(toString(i,0));
-        }
-        QtUtils::writeFile(file, lines);
-    }
-
-    void initialize(const FileList &targetFiles, const FileList &queryFiles)
-    {
-        if (patches == -1) qFatal("Heat output requires the number of patches");
-        Output::initialize(targetFiles, queryFiles);
-        data.create(patches, 1, CV_32FC1);
-    }
-};
-
-BR_REGISTER(Output, heatOutput)
-
-/*!
- * \ingroup outputs
- * \brief One score per row.
- * \author Josh Klontz \cite jklontz
- */
-class meltOutput : public MatrixOutput
-{
-    Q_OBJECT
-
-    ~meltOutput()
-    {
-        if (file.isNull() || targetFiles.isEmpty() || queryFiles.isEmpty()) return;
-        const bool genuineOnly = file.contains("Genuine") && !file.contains("Impostor");
-        const bool impostorOnly = file.contains("Impostor") && !file.contains("Genuine");
-
-        QMap<QString,QVariant> args = file.localMetadata();
-        args.remove("Genuine");
-        args.remove("Impostor");
-
-        QString keys; foreach (const QString &key, args.keys()) keys += "," + key;
-        QString values; foreach (const QVariant &value, args.values()) values += "," + value.toString();
-
-        QStringList lines;
-        if (file.baseName() != "terminal") lines.append(QString("Query,Target,Mask,Similarity%1").arg(keys));
-
-        QList<QString> queryLabels = File::get<QString>(queryFiles, "Label");
-        QList<QString> targetLabels = File::get<QString>(targetFiles, "Label");
-
-        for (int i=0; i<queryFiles.size(); i++) {
-            for (int j=(selfSimilar ? i+1 : 0); j<targetFiles.size(); j++) {
-                const bool genuine = queryLabels[i] == targetLabels[j];
-                if ((genuineOnly && !genuine) || (impostorOnly && genuine)) continue;
-                lines.append(QString("%1,%2,%3,%4%5").arg(queryFiles[i],
-                                                          targetFiles[j],
-                                                          QString::number(genuine),
-                                                          QString::number(data.at<float>(i,j)),
-                                                          values));
-            }
-        }
-
-        QtUtils::writeFile(file, lines);
-    }
-};
-
-BR_REGISTER(Output, meltOutput)
-
-/*!
- * \ingroup outputs
- * \brief \ref simmat output.
- * \author Josh Klontz \cite jklontz
- */
-class mtxOutput : public Output
-{
-    Q_OBJECT
-
-    Q_PROPERTY(QString targetGallery READ get_targetGallery WRITE set_targetGallery RESET reset_targetGallery STORED false)
-    Q_PROPERTY(QString queryGallery READ get_queryGallery WRITE set_queryGallery RESET reset_queryGallery STORED false)
-    BR_PROPERTY(QString, targetGallery, "Unknown_Target")
-    BR_PROPERTY(QString, queryGallery, "Unknown_Query")
-
-    int headerSize, rowBlock, columnBlock;
-    cv::Mat blockScores;
-
-    ~mtxOutput()
-    {
-        writeBlock();
-    }
-
-    void setBlock(int rowBlock, int columnBlock)
-    {
-        if ((rowBlock == 0) && (columnBlock == 0)) {
-            // Initialize the file
-            QFile f(file);
-            QtUtils::touchDir(f);
-            if (!f.open(QFile::WriteOnly))
-                qFatal("Unable to open %s for writing.", qPrintable(file));
-            const int endian = 0x12345678;
-            QByteArray header;
-            header.append("S2\n");
-            header.append(qPrintable(targetGallery));
-            header.append("\n");
-            header.append(qPrintable(queryGallery));
-            header.append("\nMF ");
-            header.append(qPrintable(QString::number(queryFiles.size())));
-            header.append(" ");
-            header.append(qPrintable(QString::number(targetFiles.size())));
-            header.append(" ");
-            header.append(QByteArray((const char*)&endian, 4));
-            header.append("\n");
-            headerSize = f.write(header);
-            const float defaultValue = -std::numeric_limits<float>::max();
-            for (int i=0; i<targetFiles.size()*queryFiles.size(); i++)
-                f.write((const char*)&defaultValue, 4);
-            f.close();
-        } else {
-            writeBlock();
-        }
-
-        this->rowBlock = rowBlock;
-        this->columnBlock = columnBlock;
-
-        int matrixRows  = std::min(queryFiles.size()-rowBlock*this->blockRows, blockRows);
-        int matrixCols  = std::min(targetFiles.size()-columnBlock*this->blockCols, blockCols);
-
-        blockScores = cv::Mat(matrixRows, matrixCols, CV_32FC1);
-    }
-
-    void setRelative(float value, int i, int j)
-    {
-        blockScores.at<float>(i,j) = value;
-    }
-
-    void set(float value, int i, int j)
-    {
-        (void) value; (void) i; (void) j;
-        qFatal("Logic error.");
-    }
-
-    void writeBlock()
-    {
-        QFile f(file);
-        if (!f.open(QFile::ReadWrite))
-            qFatal("Unable to open %s for modifying.", qPrintable(file));
-        for (int i=0; i<blockScores.rows; i++) {
-            f.seek(headerSize + sizeof(float)*(quint64(rowBlock*this->blockRows+i)*targetFiles.size()+(columnBlock*this->blockCols)));
-            f.write((const char*)blockScores.row(i).data, sizeof(float)*blockScores.cols);
-        }
-        f.close();
-    }
-};
-
-BR_REGISTER(Output, mtxOutput)
-
-/*!
- * \ingroup outputs
- * \brief Rank retrieval output.
- * \author Josh Klontz \cite jklontz
- * \author Scott Klum \cite sklum
- */
-class rrOutput : public MatrixOutput
-{
-    Q_OBJECT
-
-    ~rrOutput()
-    {
-        if (file.isNull() || targetFiles.isEmpty() || queryFiles.isEmpty()) return;
-        const int limit = file.get<int>("limit", 20);
-        const bool byLine = file.getBool("byLine");
-        const bool simple = file.getBool("simple");
-        const float threshold = file.get<float>("threshold", -std::numeric_limits<float>::max());
-
-        QStringList lines;
-
-        for (int i=0; i<queryFiles.size(); i++) {
-            QStringList files;
-            if (simple) files.append(queryFiles[i].fileName());
-
-            typedef QPair<float,int> Pair;
-            foreach (const Pair &pair, Common::Sort(OpenCVUtils::matrixToVector<float>(data.row(i)), true, limit)) {
-                if (Globals->crossValidate > 0 ? (targetFiles[pair.second].get<int>("Partition",-1) == -1 || targetFiles[pair.second].get<int>("Partition",-1) == queryFiles[i].get<int>("Partition",-1)) : true) {
-                    if (pair.first < threshold) break;
-                    File target = targetFiles[pair.second];
-                    target.set("Score", QString::number(pair.first));
-                    if (simple) files.append(target.fileName() + " " + QString::number(pair.first));
-                    else files.append(target.flat());
-                }
-            }
-            lines.append(files.join(byLine ? "\n" : ","));
-        }
-
-        QtUtils::writeFile(file, lines);
-    }
-};
-
-BR_REGISTER(Output, rrOutput)
-
-/*!
- * \ingroup outputs
- * \brief Text file output.
- * \author Josh Klontz \cite jklontz
- */
-class txtOutput : public MatrixOutput
-{
-    Q_OBJECT
-
-    ~txtOutput()
-    {
-        if (file.isNull() || targetFiles.isEmpty() || queryFiles.isEmpty()) return;
-        QStringList lines;
-        foreach (const File &file, queryFiles)
-            lines.append(file.name + " " + file.get<QString>("Label"));
-        QtUtils::writeFile(file, lines);
-    }
-};
-
-BR_REGISTER(Output, txtOutput)
-
-/*!
- * \ingroup outputs
- * \brief Output to the terminal.
- * \author Josh Klontz \cite jklontz
- */
-class EmptyOutput : public MatrixOutput
-{
-    Q_OBJECT
-
-    static QString bufferString(const QString &string, int length)
-    {
-        if (string.size() >= length)
-            return string.left(length);
-        QString buffer; buffer.fill(' ', length-string.size());
-        return string+buffer;
-    }
-
-    ~EmptyOutput()
-    {
-        if (targetFiles.isEmpty() || queryFiles.isEmpty()) return;
-        QString result;
-        if ((queryFiles.size() == 1) && (targetFiles.size() == 1)) {
-            result = toString(0,0) + "\n";
-        } else {
-            const int CELL_SIZE = 12;
-
-            result = bufferString(" ", CELL_SIZE) + " ";
-            foreach (const QString &targetName, targetFiles.names())
-                result += bufferString(targetName, CELL_SIZE) + " ";
-            result += "\n";
-
-            for (int i=0; i<queryFiles.size(); i++) {
-                result += bufferString(queryFiles[i].name, CELL_SIZE) + " ";
-                for (int j=0; j<targetFiles.size(); j++)
-                    result += bufferString(toString(i,j), CELL_SIZE) + " ";
-                result += "\n";
-            }
-        }
-
-        printf("%s", qPrintable(result));
-    }
-};
-
-BR_REGISTER(Output, EmptyOutput)
-
-/*!
- * \ingroup outputs
- * \brief Evaluate the output matrix.
- * \author Josh Klontz \cite jklontz
- */
-class evalOutput : public MatrixOutput
-{
-    Q_OBJECT
-    Q_PROPERTY(QString target READ get_target WRITE set_target RESET reset_target STORED false)
-    Q_PROPERTY(QString query READ get_query WRITE set_query RESET reset_query STORED false)
-    Q_PROPERTY(bool crossValidate READ get_crossValidate WRITE set_crossValidate RESET reset_crossValidate STORED false)
-    BR_PROPERTY(bool, crossValidate, true)
-    BR_PROPERTY(QString, target, QString())
-    BR_PROPERTY(QString, query, QString())
-
-    ~evalOutput()
-    {
-        if (!target.isEmpty()) targetFiles = TemplateList::fromGallery(target).files();
-        if (!query.isEmpty())  queryFiles  = TemplateList::fromGallery(query).files();
-
-        if (data.data) {
-            const QString csv = QString(file.name).replace(".eval", ".csv");
-            if ((Globals->crossValidate == 0) || (!crossValidate)) {
-                Evaluate(data, targetFiles, queryFiles, csv);
-            } else {
-                QFutureSynchronizer<float> futures;
-                for (int i=0; i<Globals->crossValidate; i++)
-                    futures.addFuture(QtConcurrent::run(Evaluate, data, targetFiles, queryFiles, csv.arg(QString::number(i)), i));
-                futures.waitForFinished();
-
-                QList<float> TARs;
-                foreach (const QFuture<float> &future, futures.futures())
-                    TARs.append(future.result());
-
-                double mean, stddev;
-                Common::MeanStdDev(TARs, &mean, &stddev);
-                qDebug("TAR @ FAR = 0.01: %.3f +/- %.3f", mean, stddev);
-            }
-        }
-    }
-};
-
-BR_REGISTER(Output, evalOutput)
-
-/*!
- * \ingroup outputs
- * \brief Discards the scores.
- * \author Josh Klontz \cite jklontz
- */
-class nullOutput : public Output
-{
-    Q_OBJECT
-
-    void set(float value, int i, int j)
-    {
-        (void) value; (void) i; (void) j;
-    }
-};
-
-BR_REGISTER(Output, nullOutput)
-
-/*!
- * \ingroup outputs
- * \brief Outputs highest ranked matches with scores.
- * \author Scott Klum \cite sklum
- */
-class rankOutput : public MatrixOutput
-{
-    Q_OBJECT
-
-    ~rankOutput()
-    {
-        if (targetFiles.isEmpty() || queryFiles.isEmpty()) return;
-
-        QList<int> ranks;
-        QList<int> positions;
-        QList<float> scores;
-        QStringList lines;
-
-        for (int i=0; i<queryFiles.size(); i++) {
-            typedef QPair<float,int> Pair;
-            int rank = 1;
-            foreach (const Pair &pair, Common::Sort(OpenCVUtils::matrixToVector<float>(data.row(i)), true)) {
-                if (Globals->crossValidate > 0 ? (targetFiles[pair.second].get<int>("Partition",-1) == -1 || targetFiles[pair.second].get<int>("Partition",-1) == queryFiles[i].get<int>("Partition",-1)) : true) {
-                    if (QString(targetFiles[pair.second]) != QString(queryFiles[i])) {
-                        if (targetFiles[pair.second].get<QString>("Label") == queryFiles[i].get<QString>("Label")) {
-                            ranks.append(rank);
-                            positions.append(pair.second);
-                            scores.append(pair.first);
-                            break;
-                        }
-                        rank++;
-                    }
-                }
-            }
-        }
-
-        typedef QPair<int,int> RankPair;
-        foreach (const RankPair &pair, Common::Sort(ranks, false))
-            // pair.first == rank retrieved, pair.second == original position
-            lines.append(queryFiles[pair.second].name + " " + QString::number(pair.first) + " " + QString::number(scores[pair.second]) + " " + targetFiles[positions[pair.second]].name);
-
-
-        QtUtils::writeFile(file, lines);
-    }
-};
-
-BR_REGISTER(Output, rankOutput)
-
-/*!
- * \ingroup outputs
- * \brief The highest scoring matches.
- * \author Josh Klontz \cite jklontz
- */
-class tailOutput : public Output
-{
-    Q_OBJECT
-
-    struct Comparison
-    {
-        br::File query, target;
-        float value;
-
-        Comparison(const br::File &_query, const br::File &_target, float _value)
-            : query(_query), target(_target), value(_value) {}
-
-        QString toString(bool args) const
-        {
-            return QString::number(value) + "," + (args ? target.flat() : (QString)target) + "," + (args ? query.flat() : (QString)query);
-        }
-
-        bool operator<(const Comparison &other) const
-        {
-            return value < other.value;
-        }
-    };
-
-    float threshold;
-    int atLeast, atMost;
-    bool args;
-    float lastValue;
-    QList<Comparison> comparisons;
-    QMutex comparisonsLock;
-
-    ~tailOutput()
-    {
-        if (file.isNull() || comparisons.isEmpty()) return;
-        QStringList lines; lines.reserve(comparisons.size()+1);
-        lines.append("Value,Target,Query");
-        foreach (const Comparison &duplicate, comparisons)
-            lines.append(duplicate.toString(args));
-        QtUtils::writeFile(file, lines);
-    }
-
-    void initialize(const FileList &targetFiles, const FileList &queryFiles)
-    {
-        Output::initialize(targetFiles, queryFiles);
-        threshold = file.get<float>("threshold", -std::numeric_limits<float>::max());
-        atLeast = file.get<int>("atLeast", 1);
-        atMost = file.get<int>("atMost", std::numeric_limits<int>::max());
-        args = file.get<bool>("args", false);
-        lastValue = -std::numeric_limits<float>::max();
-    }
-
-    void set(float value, int i, int j)
-    {
-        // Return early for self similar matrices
-        if (selfSimilar && (i <= j)) return;
-
-        // Consider only values passing the criteria
-        if ((value < threshold) && (value <= lastValue) && (comparisons.size() >= atLeast))
-            return;
-
-        comparisonsLock.lock();
-        if (comparisons.isEmpty() || (value < comparisons.last().value)) {
-            // Special cases
-            comparisons.append(Comparison(queryFiles[i], targetFiles[j], value));
-        } else {
-            // General case
-            for (int k=0; k<comparisons.size(); k++) {
-                if (comparisons[k].value <= value) {
-                    comparisons.insert(k, Comparison(queryFiles[i], targetFiles[j], value));
-                    break;
-                }
-            }
-        }
-
-        while (comparisons.size() > atMost)
-            comparisons.removeLast();
-        while ((comparisons.size() > atLeast) && (comparisons.last().value < threshold))
-            comparisons.removeLast();
-
-        lastValue = comparisons.last().value;
-        comparisonsLock.unlock();
-    }
-};
-
-BR_REGISTER(Output, tailOutput)
-
-/*!
- * \ingroup outputs
- * \brief The highest scoring matches.
- * \author Josh Klontz \cite jklontz
- */
-class bestOutput : public Output
-{
-    Q_OBJECT
-
-    typedef QPair< float, QPair<int, int> > BestMatch;
-    QList<BestMatch> bestMatches;
-
-    ~bestOutput()
-    {
-        if (file.isNull() || bestMatches.isEmpty()) return;
-        qSort(bestMatches);
-        QStringList lines; lines.reserve(bestMatches.size()+1);
-        lines.append("Value,Target,Query");
-        for (int i=bestMatches.size()-1; i>=0; i--)
-            lines.append(QString::number(bestMatches[i].first) + "," + targetFiles[bestMatches[i].second.second] + "," + queryFiles[bestMatches[i].second.first]);
-        QtUtils::writeFile(file, lines);
-    }
-
-    void initialize(const FileList &targetFiles, const FileList &queryFiles)
-    {
-        Output::initialize(targetFiles, queryFiles);
-        bestMatches.reserve(queryFiles.size());
-        for (int i=0; i<queryFiles.size(); i++)
-            bestMatches.append(BestMatch(-std::numeric_limits<float>::max(), QPair<int,int>(-1, -1)));
-    }
-
-    void set(float value, int i, int j)
-    {
-        static QMutex lock;
-
-        // Return early for self similar matrices
-        if (selfSimilar && (i == j)) return;
-
-        if (value > bestMatches[i].first) {
-            lock.lock();
-            if (value > bestMatches[i].first)
-                bestMatches[i] = BestMatch(value, QPair<int,int>(i,j));
-            lock.unlock();
-        }
-    }
-};
-
-BR_REGISTER(Output, bestOutput)
-
-/*!
- * \ingroup outputs
- * \brief Score histogram.
- * \author Josh Klontz \cite jklontz
- */
-class histOutput : public Output
-{
-    Q_OBJECT
-
-    float min, max, step;
-    QVector<int> bins;
-
-    ~histOutput()
-    {
-        if (file.isNull() || bins.isEmpty()) return;
-        QStringList counts;
-        foreach (int count, bins)
-            counts.append(QString::number(count));
-        const QString result = counts.join(",");
-        QtUtils::writeFile(file, result);
-    }
-
-    void initialize(const FileList &targetFiles, const FileList &queryFiles)
-    {
-        Output::initialize(targetFiles, queryFiles);
-        min = file.get<float>("min", -5);
-        max = file.get<float>("max", 5);
-        step = file.get<float>("step", 0.1);
-        bins = QVector<int>((max-min)/step, 0);
-    }
-
-    void set(float value, int i, int j)
-    {
-        (void) i;
-        (void) j;
-        if ((value < min) || (value >= max)) return;
-        bins[(value-min)/step]++; // This should technically be locked to ensure atomic increment
-    }
-};
-
-BR_REGISTER(Output, histOutput)
-
-} // namespace br
-
-#include "output.moc"
diff --git a/openbr/plugins/output/best.cpp b/openbr/plugins/output/best.cpp
new file mode 100644
index 0000000..cd89ab0
--- /dev/null
+++ b/openbr/plugins/output/best.cpp
@@ -0,0 +1,74 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * 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 outputs
+ * \brief The highest scoring matches.
+ * \author Josh Klontz \cite jklontz
+ */
+class bestOutput : public Output
+{
+    Q_OBJECT
+
+    typedef QPair< float, QPair<int, int> > BestMatch;
+    QList<BestMatch> bestMatches;
+
+    ~bestOutput()
+    {
+        if (file.isNull() || bestMatches.isEmpty()) return;
+        qSort(bestMatches);
+        QStringList lines; lines.reserve(bestMatches.size()+1);
+        lines.append("Value,Target,Query");
+        for (int i=bestMatches.size()-1; i>=0; i--)
+            lines.append(QString::number(bestMatches[i].first) + "," + targetFiles[bestMatches[i].second.second] + "," + queryFiles[bestMatches[i].second.first]);
+        QtUtils::writeFile(file, lines);
+    }
+
+    void initialize(const FileList &targetFiles, const FileList &queryFiles)
+    {
+        Output::initialize(targetFiles, queryFiles);
+        bestMatches.reserve(queryFiles.size());
+        for (int i=0; i<queryFiles.size(); i++)
+            bestMatches.append(BestMatch(-std::numeric_limits<float>::max(), QPair<int,int>(-1, -1)));
+    }
+
+    void set(float value, int i, int j)
+    {
+        static QMutex lock;
+
+        // Return early for self similar matrices
+        if (selfSimilar && (i == j)) return;
+
+        if (value > bestMatches[i].first) {
+            lock.lock();
+            if (value > bestMatches[i].first)
+                bestMatches[i] = BestMatch(value, QPair<int,int>(i,j));
+            lock.unlock();
+        }
+    }
+};
+
+BR_REGISTER(Output, bestOutput)
+
+} // namespace br
+
+#include "output/best.moc"
diff --git a/openbr/plugins/output/csv.cpp b/openbr/plugins/output/csv.cpp
new file mode 100644
index 0000000..21c35f8
--- /dev/null
+++ b/openbr/plugins/output/csv.cpp
@@ -0,0 +1,51 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * 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 outputs
+ * \brief Comma separated values output.
+ * \author Josh Klontz \cite jklontz
+ */
+class csvOutput : public MatrixOutput
+{
+    Q_OBJECT
+
+    ~csvOutput()
+    {
+        if (file.isNull() || targetFiles.isEmpty() || queryFiles.isEmpty()) return;
+        QStringList lines;
+        lines.append("File," + targetFiles.names().join(","));
+        for (int i=0; i<queryFiles.size(); i++) {
+            QStringList words;
+            for (int j=0; j<targetFiles.size(); j++)
+                words.append(toString(i,j));  // The toString idiom is used to output match scores - see MatrixOutput
+            lines.append(queryFiles[i].name+","+words.join(","));
+        }
+        QtUtils::writeFile(file, lines);
+    }
+};
+
+BR_REGISTER(Output, csvOutput)
+
+} // namespace br
+
+#include "output/csv.moc"
diff --git a/openbr/plugins/output/default.cpp b/openbr/plugins/output/default.cpp
new file mode 100644
index 0000000..6ba15d0
--- /dev/null
+++ b/openbr/plugins/output/default.cpp
@@ -0,0 +1,45 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * 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 outputs
+ * \brief Adaptor class -- write a matrix output using Format classes.
+ * \author Charles Otto \cite caotto
+ */
+class DefaultOutput : public MatrixOutput
+{
+    Q_OBJECT
+
+    ~DefaultOutput()
+    {
+        if (file.isNull() || targetFiles.isEmpty() || queryFiles.isEmpty()) return;
+
+        br::Template T(this->file, this->data);
+        QScopedPointer<Format> writer(Factory<Format>::make(this->file));
+        writer->write(T);
+    }
+};
+
+BR_REGISTER(Output, DefaultOutput)
+
+} // namespace br
+
+#include "output/default.moc"
diff --git a/openbr/plugins/output/empty.cpp b/openbr/plugins/output/empty.cpp
new file mode 100644
index 0000000..5d38960
--- /dev/null
+++ b/openbr/plugins/output/empty.cpp
@@ -0,0 +1,69 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * 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 outputs
+ * \brief Output to the terminal.
+ * \author Josh Klontz \cite jklontz
+ */
+class EmptyOutput : public MatrixOutput
+{
+    Q_OBJECT
+
+    static QString bufferString(const QString &string, int length)
+    {
+        if (string.size() >= length)
+            return string.left(length);
+        QString buffer; buffer.fill(' ', length-string.size());
+        return string+buffer;
+    }
+
+    ~EmptyOutput()
+    {
+        if (targetFiles.isEmpty() || queryFiles.isEmpty()) return;
+        QString result;
+        if ((queryFiles.size() == 1) && (targetFiles.size() == 1)) {
+            result = toString(0,0) + "\n";
+        } else {
+            const int CELL_SIZE = 12;
+
+            result = bufferString(" ", CELL_SIZE) + " ";
+            foreach (const QString &targetName, targetFiles.names())
+                result += bufferString(targetName, CELL_SIZE) + " ";
+            result += "\n";
+
+            for (int i=0; i<queryFiles.size(); i++) {
+                result += bufferString(queryFiles[i].name, CELL_SIZE) + " ";
+                for (int j=0; j<targetFiles.size(); j++)
+                    result += bufferString(toString(i,j), CELL_SIZE) + " ";
+                result += "\n";
+            }
+        }
+
+        printf("%s", qPrintable(result));
+    }
+};
+
+BR_REGISTER(Output, EmptyOutput)
+
+} // namespace br
+
+#include "output/empty.moc"
diff --git a/openbr/plugins/output/eval.cpp b/openbr/plugins/output/eval.cpp
new file mode 100644
index 0000000..343f7a8
--- /dev/null
+++ b/openbr/plugins/output/eval.cpp
@@ -0,0 +1,72 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * 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>
+#include <openbr/core/eval.h>
+
+namespace br
+{
+
+/*!
+ * \ingroup outputs
+ * \brief Evaluate the output matrix.
+ * \author Josh Klontz \cite jklontz
+ */
+class evalOutput : public MatrixOutput
+{
+    Q_OBJECT
+    Q_PROPERTY(QString target READ get_target WRITE set_target RESET reset_target STORED false)
+    Q_PROPERTY(QString query READ get_query WRITE set_query RESET reset_query STORED false)
+    Q_PROPERTY(bool crossValidate READ get_crossValidate WRITE set_crossValidate RESET reset_crossValidate STORED false)
+    BR_PROPERTY(bool, crossValidate, true)
+    BR_PROPERTY(QString, target, QString())
+    BR_PROPERTY(QString, query, QString())
+
+    ~evalOutput()
+    {
+        if (!target.isEmpty()) targetFiles = TemplateList::fromGallery(target).files();
+        if (!query.isEmpty())  queryFiles  = TemplateList::fromGallery(query).files();
+
+        if (data.data) {
+            const QString csv = QString(file.name).replace(".eval", ".csv");
+            if ((Globals->crossValidate == 0) || (!crossValidate)) {
+                Evaluate(data, targetFiles, queryFiles, csv);
+            } else {
+                QFutureSynchronizer<float> futures;
+                for (int i=0; i<Globals->crossValidate; i++)
+                    futures.addFuture(QtConcurrent::run(Evaluate, data, targetFiles, queryFiles, csv.arg(QString::number(i)), i));
+                futures.waitForFinished();
+
+                QList<float> TARs;
+                foreach (const QFuture<float> &future, futures.futures())
+                    TARs.append(future.result());
+
+                double mean, stddev;
+                Common::MeanStdDev(TARs, &mean, &stddev);
+                qDebug("TAR @ FAR = 0.01: %.3f +/- %.3f", mean, stddev);
+            }
+        }
+    }
+};
+
+BR_REGISTER(Output, evalOutput)
+
+} // namespace br
+
+#include "output/eval.moc"
diff --git a/openbr/plugins/output/heat.cpp b/openbr/plugins/output/heat.cpp
new file mode 100644
index 0000000..9edc817
--- /dev/null
+++ b/openbr/plugins/output/heat.cpp
@@ -0,0 +1,57 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * 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 outputs
+ * \brief Matrix-like output for heat maps.
+ * \author Scott Klum \cite sklum
+ */
+class heatOutput : public MatrixOutput
+{
+    Q_OBJECT
+    Q_PROPERTY(int patches READ get_patches WRITE set_patches RESET reset_patches STORED false)
+    BR_PROPERTY(int, patches, -1)
+
+    ~heatOutput()
+    {
+        if (file.isNull() || targetFiles.isEmpty() || queryFiles.isEmpty()) return;
+
+        QStringList lines;
+        for (int i=0; i<data.rows; i++) {
+            lines.append(toString(i,0));
+        }
+        QtUtils::writeFile(file, lines);
+    }
+
+    void initialize(const FileList &targetFiles, const FileList &queryFiles)
+    {
+        if (patches == -1) qFatal("Heat output requires the number of patches");
+        Output::initialize(targetFiles, queryFiles);
+        data.create(patches, 1, CV_32FC1);
+    }
+};
+
+BR_REGISTER(Output, heatOutput)
+
+} // namespace br
+
+#include "output/heat.moc"
diff --git a/openbr/plugins/output/hist.cpp b/openbr/plugins/output/hist.cpp
new file mode 100644
index 0000000..faf0cc8
--- /dev/null
+++ b/openbr/plugins/output/hist.cpp
@@ -0,0 +1,67 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * 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 outputs
+ * \brief Score histogram.
+ * \author Josh Klontz \cite jklontz
+ */
+class histOutput : public Output
+{
+    Q_OBJECT
+
+    float min, max, step;
+    QVector<int> bins;
+
+    ~histOutput()
+    {
+        if (file.isNull() || bins.isEmpty()) return;
+        QStringList counts;
+        foreach (int count, bins)
+            counts.append(QString::number(count));
+        const QString result = counts.join(",");
+        QtUtils::writeFile(file, result);
+    }
+
+    void initialize(const FileList &targetFiles, const FileList &queryFiles)
+    {
+        Output::initialize(targetFiles, queryFiles);
+        min = file.get<float>("min", -5);
+        max = file.get<float>("max", 5);
+        step = file.get<float>("step", 0.1);
+        bins = QVector<int>((max-min)/step, 0);
+    }
+
+    void set(float value, int i, int j)
+    {
+        (void) i;
+        (void) j;
+        if ((value < min) || (value >= max)) return;
+        bins[(value-min)/step]++; // This should technically be locked to ensure atomic increment
+    }
+};
+
+BR_REGISTER(Output, histOutput)
+
+} // namespace br
+
+#include "output/hist.moc"
diff --git a/openbr/plugins/output/melt.cpp b/openbr/plugins/output/melt.cpp
new file mode 100644
index 0000000..dba4bb4
--- /dev/null
+++ b/openbr/plugins/output/melt.cpp
@@ -0,0 +1,71 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * 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 outputs
+ * \brief One score per row.
+ * \author Josh Klontz \cite jklontz
+ */
+class meltOutput : public MatrixOutput
+{
+    Q_OBJECT
+
+    ~meltOutput()
+    {
+        if (file.isNull() || targetFiles.isEmpty() || queryFiles.isEmpty()) return;
+        const bool genuineOnly = file.contains("Genuine") && !file.contains("Impostor");
+        const bool impostorOnly = file.contains("Impostor") && !file.contains("Genuine");
+
+        QMap<QString,QVariant> args = file.localMetadata();
+        args.remove("Genuine");
+        args.remove("Impostor");
+
+        QString keys; foreach (const QString &key, args.keys()) keys += "," + key;
+        QString values; foreach (const QVariant &value, args.values()) values += "," + value.toString();
+
+        QStringList lines;
+        if (file.baseName() != "terminal") lines.append(QString("Query,Target,Mask,Similarity%1").arg(keys));
+
+        QList<QString> queryLabels = File::get<QString>(queryFiles, "Label");
+        QList<QString> targetLabels = File::get<QString>(targetFiles, "Label");
+
+        for (int i=0; i<queryFiles.size(); i++) {
+            for (int j=(selfSimilar ? i+1 : 0); j<targetFiles.size(); j++) {
+                const bool genuine = queryLabels[i] == targetLabels[j];
+                if ((genuineOnly && !genuine) || (impostorOnly && genuine)) continue;
+                lines.append(QString("%1,%2,%3,%4%5").arg(queryFiles[i],
+                                                          targetFiles[j],
+                                                          QString::number(genuine),
+                                                          QString::number(data.at<float>(i,j)),
+                                                          values));
+            }
+        }
+
+        QtUtils::writeFile(file, lines);
+    }
+};
+
+BR_REGISTER(Output, meltOutput)
+
+} // namespace br
+
+#include "output/melt.moc"
diff --git a/openbr/plugins/output/mtx.cpp b/openbr/plugins/output/mtx.cpp
new file mode 100644
index 0000000..9a269eb
--- /dev/null
+++ b/openbr/plugins/output/mtx.cpp
@@ -0,0 +1,112 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * 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 outputs
+ * \brief \ref simmat output.
+ * \author Josh Klontz \cite jklontz
+ */
+class mtxOutput : public Output
+{
+    Q_OBJECT
+
+    Q_PROPERTY(QString targetGallery READ get_targetGallery WRITE set_targetGallery RESET reset_targetGallery STORED false)
+    Q_PROPERTY(QString queryGallery READ get_queryGallery WRITE set_queryGallery RESET reset_queryGallery STORED false)
+    BR_PROPERTY(QString, targetGallery, "Unknown_Target")
+    BR_PROPERTY(QString, queryGallery, "Unknown_Query")
+
+    int headerSize, rowBlock, columnBlock;
+    cv::Mat blockScores;
+
+    ~mtxOutput()
+    {
+        writeBlock();
+    }
+
+    void setBlock(int rowBlock, int columnBlock)
+    {
+        if ((rowBlock == 0) && (columnBlock == 0)) {
+            // Initialize the file
+            QFile f(file);
+            QtUtils::touchDir(f);
+            if (!f.open(QFile::WriteOnly))
+                qFatal("Unable to open %s for writing.", qPrintable(file));
+            const int endian = 0x12345678;
+            QByteArray header;
+            header.append("S2\n");
+            header.append(qPrintable(targetGallery));
+            header.append("\n");
+            header.append(qPrintable(queryGallery));
+            header.append("\nMF ");
+            header.append(qPrintable(QString::number(queryFiles.size())));
+            header.append(" ");
+            header.append(qPrintable(QString::number(targetFiles.size())));
+            header.append(" ");
+            header.append(QByteArray((const char*)&endian, 4));
+            header.append("\n");
+            headerSize = f.write(header);
+            const float defaultValue = -std::numeric_limits<float>::max();
+            for (int i=0; i<targetFiles.size()*queryFiles.size(); i++)
+                f.write((const char*)&defaultValue, 4);
+            f.close();
+        } else {
+            writeBlock();
+        }
+
+        this->rowBlock = rowBlock;
+        this->columnBlock = columnBlock;
+
+        int matrixRows  = std::min(queryFiles.size()-rowBlock*this->blockRows, blockRows);
+        int matrixCols  = std::min(targetFiles.size()-columnBlock*this->blockCols, blockCols);
+
+        blockScores = cv::Mat(matrixRows, matrixCols, CV_32FC1);
+    }
+
+    void setRelative(float value, int i, int j)
+    {
+        blockScores.at<float>(i,j) = value;
+    }
+
+    void set(float value, int i, int j)
+    {
+        (void) value; (void) i; (void) j;
+        qFatal("Logic error.");
+    }
+
+    void writeBlock()
+    {
+        QFile f(file);
+        if (!f.open(QFile::ReadWrite))
+            qFatal("Unable to open %s for modifying.", qPrintable(file));
+        for (int i=0; i<blockScores.rows; i++) {
+            f.seek(headerSize + sizeof(float)*(quint64(rowBlock*this->blockRows+i)*targetFiles.size()+(columnBlock*this->blockCols)));
+            f.write((const char*)blockScores.row(i).data, sizeof(float)*blockScores.cols);
+        }
+        f.close();
+    }
+};
+
+BR_REGISTER(Output, mtxOutput)
+
+} // namespace br
+
+#include "output/mtx.moc"
diff --git a/openbr/plugins/output/null.cpp b/openbr/plugins/output/null.cpp
new file mode 100644
index 0000000..a652bb2
--- /dev/null
+++ b/openbr/plugins/output/null.cpp
@@ -0,0 +1,41 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * 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 outputs
+ * \brief Discards the scores.
+ * \author Josh Klontz \cite jklontz
+ */
+class nullOutput : public Output
+{
+    Q_OBJECT
+
+    void set(float value, int i, int j)
+    {
+        (void) value; (void) i; (void) j;
+    }
+};
+
+BR_REGISTER(Output, nullOutput)
+
+} // namespace br
+
+#include "output/null.moc"
diff --git a/openbr/plugins/output/rank.cpp b/openbr/plugins/output/rank.cpp
new file mode 100644
index 0000000..3faa64b
--- /dev/null
+++ b/openbr/plugins/output/rank.cpp
@@ -0,0 +1,75 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * 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>
+#include <openbr/core/qtutils.h>
+#include <openbr/core/opencvutils.h>
+
+namespace br
+{
+
+/*!
+ * \ingroup outputs
+ * \brief Outputs highest ranked matches with scores.
+ * \author Scott Klum \cite sklum
+ */
+class rankOutput : public MatrixOutput
+{
+    Q_OBJECT
+
+    ~rankOutput()
+    {
+        if (targetFiles.isEmpty() || queryFiles.isEmpty()) return;
+
+        QList<int> ranks;
+        QList<int> positions;
+        QList<float> scores;
+        QStringList lines;
+
+        for (int i=0; i<queryFiles.size(); i++) {
+            typedef QPair<float,int> Pair;
+            int rank = 1;
+            foreach (const Pair &pair, Common::Sort(OpenCVUtils::matrixToVector<float>(data.row(i)), true)) {
+                if (Globals->crossValidate > 0 ? (targetFiles[pair.second].get<int>("Partition",-1) == -1 || targetFiles[pair.second].get<int>("Partition",-1) == queryFiles[i].get<int>("Partition",-1)) : true) {
+                    if (QString(targetFiles[pair.second]) != QString(queryFiles[i])) {
+                        if (targetFiles[pair.second].get<QString>("Label") == queryFiles[i].get<QString>("Label")) {
+                            ranks.append(rank);
+                            positions.append(pair.second);
+                            scores.append(pair.first);
+                            break;
+                        }
+                        rank++;
+                    }
+                }
+            }
+        }
+
+        typedef QPair<int,int> RankPair;
+        foreach (const RankPair &pair, Common::Sort(ranks, false))
+            // pair.first == rank retrieved, pair.second == original position
+            lines.append(queryFiles[pair.second].name + " " + QString::number(pair.first) + " " + QString::number(scores[pair.second]) + " " + targetFiles[positions[pair.second]].name);
+
+
+        QtUtils::writeFile(file, lines);
+    }
+};
+
+BR_REGISTER(Output, rankOutput)
+
+} // namespace br
+
+#include "output/rank.moc"
diff --git a/openbr/plugins/output/rr.cpp b/openbr/plugins/output/rr.cpp
new file mode 100644
index 0000000..509e14e
--- /dev/null
+++ b/openbr/plugins/output/rr.cpp
@@ -0,0 +1,70 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * 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>
+#include <openbr/core/qtutils.h>
+#include <openbr/core/opencvutils.h>
+
+namespace br
+{
+
+/*!
+ * \ingroup outputs
+ * \brief Rank retrieval output.
+ * \author Josh Klontz \cite jklontz
+ * \author Scott Klum \cite sklum
+ */
+class rrOutput : public MatrixOutput
+{
+    Q_OBJECT
+
+    ~rrOutput()
+    {
+        if (file.isNull() || targetFiles.isEmpty() || queryFiles.isEmpty()) return;
+        const int limit = file.get<int>("limit", 20);
+        const bool byLine = file.getBool("byLine");
+        const bool simple = file.getBool("simple");
+        const float threshold = file.get<float>("threshold", -std::numeric_limits<float>::max());
+
+        QStringList lines;
+
+        for (int i=0; i<queryFiles.size(); i++) {
+            QStringList files;
+            if (simple) files.append(queryFiles[i].fileName());
+
+            typedef QPair<float,int> Pair;
+            foreach (const Pair &pair, Common::Sort(OpenCVUtils::matrixToVector<float>(data.row(i)), true, limit)) {
+                if (Globals->crossValidate > 0 ? (targetFiles[pair.second].get<int>("Partition",-1) == -1 || targetFiles[pair.second].get<int>("Partition",-1) == queryFiles[i].get<int>("Partition",-1)) : true) {
+                    if (pair.first < threshold) break;
+                    File target = targetFiles[pair.second];
+                    target.set("Score", QString::number(pair.first));
+                    if (simple) files.append(target.fileName() + " " + QString::number(pair.first));
+                    else files.append(target.flat());
+                }
+            }
+            lines.append(files.join(byLine ? "\n" : ","));
+        }
+
+        QtUtils::writeFile(file, lines);
+    }
+};
+
+BR_REGISTER(Output, rrOutput)
+
+} // namespace br
+
+#include "output/rr.moc"
diff --git a/openbr/plugins/output/tail.cpp b/openbr/plugins/output/tail.cpp
new file mode 100644
index 0000000..47a8e94
--- /dev/null
+++ b/openbr/plugins/output/tail.cpp
@@ -0,0 +1,115 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * 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 outputs
+ * \brief The highest scoring matches.
+ * \author Josh Klontz \cite jklontz
+ */
+class tailOutput : public Output
+{
+    Q_OBJECT
+
+    struct Comparison
+    {
+        br::File query, target;
+        float value;
+
+        Comparison(const br::File &_query, const br::File &_target, float _value)
+            : query(_query), target(_target), value(_value) {}
+
+        QString toString(bool args) const
+        {
+            return QString::number(value) + "," + (args ? target.flat() : (QString)target) + "," + (args ? query.flat() : (QString)query);
+        }
+
+        bool operator<(const Comparison &other) const
+        {
+            return value < other.value;
+        }
+    };
+
+    float threshold;
+    int atLeast, atMost;
+    bool args;
+    float lastValue;
+    QList<Comparison> comparisons;
+    QMutex comparisonsLock;
+
+    ~tailOutput()
+    {
+        if (file.isNull() || comparisons.isEmpty()) return;
+        QStringList lines; lines.reserve(comparisons.size()+1);
+        lines.append("Value,Target,Query");
+        foreach (const Comparison &duplicate, comparisons)
+            lines.append(duplicate.toString(args));
+        QtUtils::writeFile(file, lines);
+    }
+
+    void initialize(const FileList &targetFiles, const FileList &queryFiles)
+    {
+        Output::initialize(targetFiles, queryFiles);
+        threshold = file.get<float>("threshold", -std::numeric_limits<float>::max());
+        atLeast = file.get<int>("atLeast", 1);
+        atMost = file.get<int>("atMost", std::numeric_limits<int>::max());
+        args = file.get<bool>("args", false);
+        lastValue = -std::numeric_limits<float>::max();
+    }
+
+    void set(float value, int i, int j)
+    {
+        // Return early for self similar matrices
+        if (selfSimilar && (i <= j)) return;
+
+        // Consider only values passing the criteria
+        if ((value < threshold) && (value <= lastValue) && (comparisons.size() >= atLeast))
+            return;
+
+        comparisonsLock.lock();
+        if (comparisons.isEmpty() || (value < comparisons.last().value)) {
+            // Special cases
+            comparisons.append(Comparison(queryFiles[i], targetFiles[j], value));
+        } else {
+            // General case
+            for (int k=0; k<comparisons.size(); k++) {
+                if (comparisons[k].value <= value) {
+                    comparisons.insert(k, Comparison(queryFiles[i], targetFiles[j], value));
+                    break;
+                }
+            }
+        }
+
+        while (comparisons.size() > atMost)
+            comparisons.removeLast();
+        while ((comparisons.size() > atLeast) && (comparisons.last().value < threshold))
+            comparisons.removeLast();
+
+        lastValue = comparisons.last().value;
+        comparisonsLock.unlock();
+    }
+};
+
+BR_REGISTER(Output, tailOutput)
+
+} // namespace br
+
+#include "output/tail.moc"
diff --git a/openbr/plugins/output/txt.cpp b/openbr/plugins/output/txt.cpp
new file mode 100644
index 0000000..3b9faaf
--- /dev/null
+++ b/openbr/plugins/output/txt.cpp
@@ -0,0 +1,46 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * 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 outputs
+ * \brief Text file output.
+ * \author Josh Klontz \cite jklontz
+ */
+class txtOutput : public MatrixOutput
+{
+    Q_OBJECT
+
+    ~txtOutput()
+    {
+        if (file.isNull() || targetFiles.isEmpty() || queryFiles.isEmpty()) return;
+        QStringList lines;
+        foreach (const File &file, queryFiles)
+            lines.append(file.name + " " + file.get<QString>("Label"));
+        QtUtils::writeFile(file, lines);
+    }
+};
+
+BR_REGISTER(Output, txtOutput)
+
+} // namespace br
+
+#include "output/txt.moc"
diff --git a/openbr/plugins/plugins.cmake b/openbr/plugins/plugins.cmake
index 163e15c..c4ee8f3 100644
--- a/openbr/plugins/plugins.cmake
+++ b/openbr/plugins/plugins.cmake
@@ -1,25 +1,50 @@
 # Optional Appendable CMake Variables:
 # BR_THIRDPARTY_PLUGINS     - Additional plugins
 # BR_THIRDPARTY_PLUGINS_DIR - Additional folder(s) of plugins
+# BR_EXCLUDED_PLUGINS       - Plugins that should not be built
 # BR_THIRDPARTY_SRC         - Additional source code needed by a plugin
 # BR_THIRDPARTY_LIBS        - Additional libaries needed by a plugin
 
 # Also look for CMake modules in the thirdparty plugins folder(s)
 set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} ${BR_THIRDPARTY_PLUGINS_DIR})
 
-foreach(DIR ${BR_THIRDPARTY_PLUGINS_DIR})
-  file(GLOB PLUGINS ${DIR}/*.cpp ${DIR}/*.h) # Add the headers too so MOC runs on them
-  set(BR_THIRDPARTY_PLUGINS ${BR_THIRDPARTY_PLUGINS} ${PLUGINS})
+# Gather all of the plugin subdirectories
+file(GLOB SUBFILES plugins/*)
+foreach(FILE ${SUBFILES})
+  if(IS_DIRECTORY ${FILE})
+    set(BR_PLUGINS_DIR ${BR_PLUGINS_DIR} ${FILE})
+  endif()
 endforeach()
+set(BR_PLUGINS_DIR ${BR_PLUGINS_DIR} plugins/) # Remove this when finished with reorg
 
-file(GLOB PLUGINS plugins/*.cpp plugins/*.h)
-foreach(PLUGIN ${PLUGINS} ${BR_THIRDPARTY_PLUGINS})
-  get_filename_component(PLUGIN_BASENAME ${PLUGIN} NAME_WE)
-  get_filename_component(PLUGIN_PATH ${PLUGIN} PATH)
-  set(PLUGIN_CMAKE "${PLUGIN_PATH}/${PLUGIN_BASENAME}.cmake")
-  if(EXISTS ${PLUGIN_CMAKE})
-    include(${PLUGIN_CMAKE})
-  else()
-    set(BR_THIRDPARTY_SRC ${BR_THIRDPARTY_SRC} ${PLUGIN})
-  endif()
+# Exclude pertinent plugins based on .cmake files
+mark_as_advanced(BR_EXCLUDED_PLUGINS)
+foreach(DIR plugins/cmake ${BR_THIRDPARTY_PLUGINS_DIR})
+  file(GLOB CMAKE_FILES ${DIR}/*.cmake)
+  foreach(CMAKE_FILE ${CMAKE_FILES})
+    if (NOT ${CMAKE_FILE} MATCHES "Find.*cmake")
+      include(${CMAKE_FILE})
+    endif()
+  endforeach()
 endforeach()
+
+# Collect all source files except for excluded plugins
+foreach(DIR ${BR_PLUGINS_DIR} ${BR_THIRDPARTY_PLUGINS_DIR})
+  get_filename_component(DIR_NAME ${DIR} NAME)
+  file(GLOB PLUGINS ${DIR}/*.cpp ${DIR}/*.h)
+  foreach(PLUGIN ${PLUGINS})
+    get_filename_component(PLUGIN_NAME ${PLUGIN} NAME)
+    set(EXCLUDE FALSE)
+    foreach(EXCLUDED_PLUGIN ${BR_EXCLUDED_PLUGINS})
+      get_filename_component(EXCLUDED_PLUGIN_NAME ${EXCLUDED_PLUGIN} NAME)
+      if (${PLUGIN_NAME} STREQUAL ${EXCLUDED_PLUGIN_NAME})
+        set(EXCLUDE TRUE)
+      endif()
+    endforeach()
+    if(NOT ${EXCLUDE})
+      set(BR_THIRDPARTY_PLUGINS ${BR_THIRDPARTY_PLUGINS} ${PLUGIN})
+    endif()
+  endforeach()
+endforeach()
+
+set(BR_THIRDPARTY_SRC ${BR_THIRDPARTY_SRC} ${BR_THIRDPARTY_PLUGINS})
diff --git a/openbr/plugins/quality.cpp b/openbr/plugins/quality.cpp
deleted file mode 100644
index 11d4bbd..0000000
--- a/openbr/plugins/quality.cpp
+++ /dev/null
@@ -1,449 +0,0 @@
-#include <QFutureSynchronizer>
-#include <QtConcurrent>
-#include "openbr_internal.h"
-
-#include "openbr/core/common.h"
-#include "openbr/core/opencvutils.h"
-
-namespace br
-{
-
-/*!
- * \ingroup transforms
- * \brief Impostor Uniqueness Measure \cite klare12
- * \author Josh Klontz \cite jklontz
- */
-class ImpostorUniquenessMeasureTransform : public Transform
-{
-    Q_OBJECT
-    Q_PROPERTY(br::Distance* distance READ get_distance WRITE set_distance RESET reset_distance STORED false)
-    Q_PROPERTY(double mean READ get_mean WRITE set_mean RESET reset_mean)
-    Q_PROPERTY(double stddev READ get_stddev WRITE set_stddev RESET reset_stddev)
-    Q_PROPERTY(QString inputVariable READ get_inputVariable WRITE set_inputVariable RESET reset_inputVariable STORED false)
-    BR_PROPERTY(br::Distance*, distance, Distance::make("Dist(L2)", this))
-    BR_PROPERTY(double, mean, 0)
-    BR_PROPERTY(double, stddev, 1)
-    BR_PROPERTY(QString, inputVariable, "Label")
-
-    TemplateList impostors;
-
-    float calculateIUM(const Template &probe, const TemplateList &gallery) const
-    {
-        const QString probeLabel = probe.file.get<QString>(inputVariable);
-        TemplateList subset = gallery;
-        for (int j=subset.size()-1; j>=0; j--)
-            if (subset[j].file.get<QString>(inputVariable) == probeLabel)
-                subset.removeAt(j);
-
-        QList<float> scores = distance->compare(subset, probe);
-        float min, max;
-        Common::MinMax(scores, &min, &max);
-        double mean = Common::Mean(scores);
-        return (max-mean)/(max-min);
-    }
-
-    void train(const TemplateList &data)
-    {
-        distance->train(data);
-        impostors = data;
-
-        QList<float> iums; iums.reserve(impostors.size());
-        for (int i=0; i<data.size(); i++)
-            iums.append(calculateIUM(impostors[i], impostors));
-
-        Common::MeanStdDev(iums, &mean, &stddev);
-    }
-
-    void project(const Template &src, Template &dst) const
-    {
-        dst = src;
-        float ium = calculateIUM(src, impostors);
-        dst.file.set("Impostor_Uniqueness_Measure", ium);
-        dst.file.set("Impostor_Uniqueness_Measure_Bin", ium < mean-stddev ? 0 : (ium < mean+stddev ? 1 : 2));
-    }
-
-    void store(QDataStream &stream) const
-    {
-        distance->store(stream);
-        stream << mean << stddev << impostors;
-    }
-
-    void load(QDataStream &stream)
-    {
-        distance->load(stream);
-        stream >> mean >> stddev >> impostors;
-    }
-};
-
-BR_REGISTER(Transform, ImpostorUniquenessMeasureTransform)
-
-
-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)
-
-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)
-
-/*!
- * \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)
-
-/*!
- * \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 "quality.moc"
diff --git a/openbr/plugins/quantize.cpp b/openbr/plugins/quantize.cpp
deleted file mode 100644
index 14ae276..0000000
--- a/openbr/plugins/quantize.cpp
+++ /dev/null
@@ -1,548 +0,0 @@
-/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
- * 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 "openbr_internal.h"
-
-#include "openbr/core/common.h"
-#include "openbr/core/opencvutils.h"
-#include "openbr/core/qtutils.h"
-
-using namespace cv;
-
-namespace br
-{
-
-/*!
- * \ingroup transforms
- * \brief Approximate floats as uchar.
- * \author Josh Klontz \cite jklontz
- */
-class QuantizeTransform : public Transform
-{
-    Q_OBJECT
-    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)
-    BR_PROPERTY(float, a, 1)
-    BR_PROPERTY(float, b, 0)
-
-    void train(const TemplateList &data)
-    {
-        double minVal, maxVal;
-        minMaxLoc(OpenCVUtils::toMat(data.data()), &minVal, &maxVal);
-        a = 255.0/(maxVal-minVal);
-        b = -a*minVal;
-    }
-
-    void project(const Template &src, Template &dst) const
-    {
-        src.m().convertTo(dst, CV_8U, a, b);
-    }
-};
-
-BR_REGISTER(Transform, QuantizeTransform)
-
-/*!
- * \ingroup transforms
- * \brief Approximate floats as uchar with different scalings for each dimension.
- * \author Josh Klontz \cite jklontz
- */
-class HistEqQuantizationTransform : public Transform
-{
-    Q_OBJECT
-    QVector<float> thresholds;
-
-    static void computeThresholds(const Mat &data, float *thresholds)
-    {
-        QList<float> vals = OpenCVUtils::matrixToVector<float>(data);
-        std::sort(vals.begin(), vals.end());
-        for (int i=0; i<255; i++)
-            thresholds[i] = vals[(i+1)*vals.size()/256];
-        thresholds[255] = std::numeric_limits<float>::max();
-    }
-
-    void train(const TemplateList &src)
-    {
-        const Mat data = OpenCVUtils::toMat(src.data());
-        thresholds = QVector<float>(256*data.cols);
-
-        QFutureSynchronizer<void> futures;
-        for (int i=0; i<data.cols; i++)
-            futures.addFuture(QtConcurrent::run(&HistEqQuantizationTransform::computeThresholds, data.col(i), &thresholds.data()[i*256]));
-        futures.waitForFinished();
-    }
-
-    void project(const Template &src, Template &dst) const
-    {
-        const QList<float> vals = OpenCVUtils::matrixToVector<float>(src);
-        dst = Mat(1, vals.size(), CV_8UC1);
-        for (int i=0; i<vals.size(); i++) {
-            const float *t = &thresholds.data()[i*256];
-            const float val = vals[i];
-            uchar j = 0;
-            while (val > t[j]) j++;
-            dst.m().at<uchar>(0,i) = j;
-        }
-    }
-
-    void store(QDataStream &stream) const
-    {
-        stream << thresholds;
-    }
-
-    void load(QDataStream &stream)
-    {
-        stream >> thresholds;
-    }
-};
-
-BR_REGISTER(Transform, HistEqQuantizationTransform)
-
-/*!
- * \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)
-
-/*!
- * \ingroup transforms
- * \brief Approximate floats as signed bit.
- * \author Josh Klontz \cite jklontz
- */
-class BinarizeTransform : public UntrainableTransform
-{
-    Q_OBJECT
-
-    void project(const Template &src, Template &dst) const
-    {
-        const Mat &m = src;
-        if ((m.cols % 8 != 0) || (m.type() != CV_32FC1))
-            qFatal("Expected CV_32FC1 matrix with a multiple of 8 columns.");
-        Mat n(m.rows, m.cols/8, CV_8UC1);
-        for (int i=0; i<m.rows; i++)
-            for (int j=0; j<m.cols-7; j+=8)
-                n.at<uchar>(i,j) = ((m.at<float>(i,j+0) > 0) << 0) +
-                                   ((m.at<float>(i,j+1) > 0) << 1) +
-                                   ((m.at<float>(i,j+2) > 0) << 2) +
-                                   ((m.at<float>(i,j+3) > 0) << 3) +
-                                   ((m.at<float>(i,j+4) > 0) << 4) +
-                                   ((m.at<float>(i,j+5) > 0) << 5) +
-                                   ((m.at<float>(i,j+6) > 0) << 6) +
-                                   ((m.at<float>(i,j+7) > 0) << 7);
-        dst = n;
-    }
-};
-
-BR_REGISTER(Transform, BinarizeTransform)
-
-/*!
- * \ingroup transforms
- * \brief Compress two uchar into one uchar.
- * \author Josh Klontz \cite jklontz
- */
-class PackTransform : public UntrainableTransform
-{
-    Q_OBJECT
-
-    void project(const Template &src, Template &dst) const
-    {
-        const Mat &m = src;
-        if ((m.cols % 2 != 0) || (m.type() != CV_8UC1))
-            qFatal("Invalid template format.");
-
-        Mat n(m.rows, m.cols/2, CV_8UC1);
-        for (int i=0; i<m.rows; i++)
-            for (int j=0; j<m.cols/2; j++)
-                n.at<uchar>(i,j) = ((m.at<uchar>(i,2*j+0) >> 4) << 4) +
-                                   ((m.at<uchar>(i,2*j+1) >> 4) << 0);
-        dst = n;
-    }
-};
-
-BR_REGISTER(Transform, PackTransform)
-
-QVector<Mat> ProductQuantizationLUTs;
-
-/*!
- * \ingroup distances
- * \brief Distance in a product quantized space \cite jegou11
- * \author Josh Klontz \cite jklontz
- */
-class ProductQuantizationDistance : public UntrainableDistance
-{
-    Q_OBJECT
-    Q_PROPERTY(bool bayesian READ get_bayesian WRITE set_bayesian RESET reset_bayesian STORED false)
-    BR_PROPERTY(bool, bayesian, false)
-
-    float compare(const Template &a, const Template &b) const
-    {
-        float distance = 0;
-        for (int i=0; i<a.size(); i++) {
-            const int elements = a[i].total()-sizeof(quint16);
-            uchar *aData = a[i].data;
-            uchar *bData = b[i].data;
-            quint16 index = *reinterpret_cast<quint16*>(aData);
-            aData += sizeof(quint16);
-            bData += sizeof(quint16);
-
-            const float *lut = (const float*)ProductQuantizationLUTs[index].data;
-            for (int j=0; j<elements; j++)
-            {
-                const int aj = aData[j];
-                const int bj = bData[j];
-                // http://stackoverflow.com/questions/4803180/mapping-elements-in-2d-upper-triangle-and-lower-triangle-to-linear-structure
-                const int y = max(aj, bj);
-                const int x = min(aj, bj);
-                distance += lut[j*256*(256+1)/2 + x + (y+1)*y/2];
-            }
-        }
-        if (!bayesian) distance = -log(distance+1);
-        return distance;
-    }
-};
-
-BR_REGISTER(Distance, ProductQuantizationDistance)
-
-/*!
- * \ingroup distances
- * \brief Recurively computed distance in a product quantized space
- * \author Josh Klontz \cite jklontz
- */
-class RecursiveProductQuantizationDistance : public UntrainableDistance
-{
-    Q_OBJECT
-    Q_PROPERTY(float t READ get_t WRITE set_t RESET reset_t STORED false)
-    BR_PROPERTY(float, t, -std::numeric_limits<float>::max())
-
-    float compare(const Template &a, const Template &b) const
-    {
-        return compareRecursive(a, b, 0, a.size(), 0);
-    }
-
-    float compareRecursive(const QList<cv::Mat> &a, const QList<cv::Mat> &b, int i, int size, float evidence) const
-    {
-        float similarity = 0;
-
-        const int elements = a[i].total()-sizeof(quint16);
-        uchar *aData = a[i].data;
-        uchar *bData = b[i].data;
-        quint16 index = *reinterpret_cast<quint16*>(aData);
-        aData += sizeof(quint16);
-        bData += sizeof(quint16);
-
-        const float *lut = (const float*)ProductQuantizationLUTs[index].data;
-        for (int j=0; j<elements; j++) {
-            const int aj = aData[j];
-            const int bj = bData[j];
-            // http://stackoverflow.com/questions/4803180/mapping-elements-in-2d-upper-triangle-and-lower-triangle-to-linear-structure
-            const int y = max(aj, bj);
-            const int x = min(aj, bj);
-            similarity += lut[j*256*(256+1)/2 + x + (y+1)*y/2];
-        }
-
-        evidence += similarity;
-        const int subSize = (size-1)/4;
-        if ((evidence < t) || (subSize == 0)) return similarity;
-        return similarity
-               + compareRecursive(a, b, i+1+0*subSize, subSize, evidence)
-               + compareRecursive(a, b, i+1+1*subSize, subSize, evidence)
-               + compareRecursive(a, b, i+1+2*subSize, subSize, evidence)
-               + compareRecursive(a, b, i+1+3*subSize, subSize, evidence);
-    }
-};
-
-BR_REGISTER(Distance, RecursiveProductQuantizationDistance)
-
-/*!
- * \ingroup transforms
- * \brief Product quantization \cite jegou11
- * \author Josh Klontz \cite jklontz
- */
-class ProductQuantizationTransform : public Transform
-{
-    Q_OBJECT
-    Q_PROPERTY(int n READ get_n WRITE set_n RESET reset_n STORED false)
-    Q_PROPERTY(br::Distance *distance READ get_distance WRITE set_distance RESET reset_distance STORED false)
-    Q_PROPERTY(bool bayesian READ get_bayesian WRITE set_bayesian RESET reset_bayesian STORED false)
-    Q_PROPERTY(QString inputVariable READ get_inputVariable WRITE set_inputVariable RESET reset_inputVariable STORED false)
-    BR_PROPERTY(int, n, 2)
-    BR_PROPERTY(br::Distance*, distance, Distance::make("L2", this))
-    BR_PROPERTY(bool, bayesian, false)
-    BR_PROPERTY(QString, inputVariable, "Label")
-
-    quint16 index;
-    QList<Mat> centers;
-
-public:
-    ProductQuantizationTransform()
-    {
-        if (ProductQuantizationLUTs.size() > std::numeric_limits<quint16>::max())
-            qFatal("Out of LUT space!"); // Unlikely
-
-        static QMutex mutex;
-        QMutexLocker locker(&mutex);
-        index = ProductQuantizationLUTs.size();
-        ProductQuantizationLUTs.append(Mat());
-    }
-
-private:
-//    static double denseKernelDensityBandwidth(const Mat &lut, const Mat &occurences)
-//    {
-//        double total = 0;
-//        int n = 0;
-//        const qint32 *occurencesData = (qint32*)occurences.data;
-//        const float *lutData = (float*)lut.data;
-//        for (int i=0; i<256; i++)
-//            for (int j=i; j<256; j++) {
-//                total += occurencesData[i*256+j] * lutData[i*256+j];
-//                n += occurencesData[i*256+j];
-//            }
-//        const double mean = total/n;
-
-//        double variance = 0;
-//        for (int i=0; i<lut.rows; i++)
-//            for (int j=i; j<lut.cols; j++)
-//                variance += occurencesData[i*256+j] * pow(lutData[i*256+j]-mean, 2.0);
-
-//        return pow(4 * pow(sqrt(variance/n), 5.0) / (3*n), 0.2);
-//    }
-
-//    static double denseKernelDensityEstimation(const Mat &lut, const Mat &occurences, const float x, const float h)
-//    {
-//        double y = 0;
-//        int n = 0;
-//        const qint32 *occurencesData = (qint32*)occurences.data;
-//        const float *lutData = (float*)lut.data;
-//        for (int i=0; i<256; i++)
-//            for (int j=i; j<256; j++) {
-//                const int n_ij = occurencesData[i*256+j];
-//                if (n_ij > 0) {
-//                    y += n_ij * exp(-pow((lutData[i*256+j]-x)/h,2)/2)/2.50662826737 /*sqrt(2*3.1415926353898)*/;
-//                    n += n_ij;
-//                }
-//            }
-//        return y / (n*h);
-//    }
-
-    void _train(const Mat &data, const QList<int> &labels, Mat *lut, Mat *center)
-    {
-        Mat clusterLabels;
-        kmeans(data, 256, clusterLabels, TermCriteria(TermCriteria::MAX_ITER, 10, 0), 3, KMEANS_PP_CENTERS, *center);
-
-        Mat fullLUT(1, 256*256, CV_32FC1);
-        for (int i=0; i<256; i++)
-            for (int j=0; j<256; j++)
-                fullLUT.at<float>(0,i*256+j) = distance->compare(center->row(i), center->row(j));
-
-        if (bayesian) {
-            QList<int> indicies = OpenCVUtils::matrixToVector<int>(clusterLabels);
-            QVector<float> genuineScores, impostorScores;
-            genuineScores.reserve(indicies.size());
-            impostorScores.reserve(indicies.size()*indicies.size()/2);
-            for (int i=0; i<indicies.size(); i++)
-                for (int j=i+1; j<indicies.size(); j++) {
-                    const float score = fullLUT.at<float>(0, indicies[i]*256+indicies[j]);
-                    if (labels[i] == labels[j]) genuineScores.append(score);
-                    else                        impostorScores.append(score);
-                }
-
-            genuineScores = Common::Downsample(genuineScores, 256);
-            impostorScores = Common::Downsample(impostorScores, 256);
-            const double hGenuine = Common::KernelDensityBandwidth(genuineScores);
-            const double hImpostor = Common::KernelDensityBandwidth(impostorScores);
-
-            for (int i=0; i<256; i++)
-                for (int j=i; j<256; j++) {
-                    const float loglikelihood = log(Common::KernelDensityEstimation(genuineScores, fullLUT.at<float>(0,i*256+j), hGenuine) /
-                                                    Common::KernelDensityEstimation(impostorScores, fullLUT.at<float>(0,i*256+j), hImpostor));
-                    fullLUT.at<float>(0,i*256+j) = loglikelihood;
-                    fullLUT.at<float>(0,j*256+i) = loglikelihood;
-                }
-        }
-
-        // Compress LUT into one dimensional array
-        int index = 0;
-        for (int i=0; i<256; i++)
-            for (int j=0; j<=i; j++) {
-                lut->at<float>(0,index) = fullLUT.at<float>(0,i*256+j);
-                index++;
-            }
-        if (index != lut->cols)
-            qFatal("Logic error.");
-    }
-
-    int getStep(int cols) const
-    {
-        if (n > 0) return n;
-        if (n == 0) return cols;
-        return ceil(float(cols)/abs(n));
-    }
-
-    int getOffset(int cols) const
-    {
-        if (n >= 0) return 0;
-        const int step = getStep(cols);
-        return (step - cols%step) % step;
-    }
-
-    int getDims(int cols) const
-    {
-        const int step = getStep(cols);
-        if (n >= 0) return cols/step;
-        return ceil(float(cols)/step);
-    }
-
-    void train(const TemplateList &src)
-    {
-        Mat data = OpenCVUtils::toMat(src.data());
-        const int step = getStep(data.cols);
-
-        const QList<int> labels = src.indexProperty(inputVariable);
-
-        Mat &lut = ProductQuantizationLUTs[index];
-        lut = Mat(getDims(data.cols), 256*(256+1)/2, CV_32FC1);
-
-        QList<Mat> subdata, subluts;
-        const int offset = getOffset(data.cols);
-        for (int i=0; i<lut.rows; i++) {
-            centers.append(Mat());
-            subdata.append(data.colRange(max(0, i*step-offset), (i+1)*step-offset));
-            subluts.append(lut.row(i));
-        }
-
-        QFutureSynchronizer<void> futures;
-        for (int i=0; i<lut.rows; i++) {
-            if (Globals->parallelism) futures.addFuture(QtConcurrent::run(this, &ProductQuantizationTransform::_train, subdata[i], labels, &subluts[i], &centers[i]));
-            else                                                                                               _train (subdata[i], labels, &subluts[i], &centers[i]);
-        }
-        futures.waitForFinished();
-    }
-
-    int getIndex(const Mat &m, const Mat &center) const
-    {
-        int bestIndex = 0;
-        double bestDistance = std::numeric_limits<double>::max();
-        for (int j=0; j<256; j++) {
-            double distance = norm(m, center.row(j), NORM_L2);
-            if (distance < bestDistance) {
-                bestDistance = distance;
-                bestIndex = j;
-            }
-        }
-        return bestIndex;
-    }
-
-    void project(const Template &src, Template &dst) const
-    {
-        Mat m = src.m().reshape(1, 1);
-        const int step = getStep(m.cols);
-        const int offset = getOffset(m.cols);
-        const int dims = getDims(m.cols);
-        dst = Mat(1, sizeof(quint16)+dims, CV_8UC1);
-        memcpy(dst.m().data, &index, sizeof(quint16));
-        for (int i=0; i<dims; i++)
-            dst.m().at<uchar>(0,sizeof(quint16)+i) = getIndex(m.colRange(max(0, i*step-offset), (i+1)*step-offset), centers[i]);
-    }
-
-    void store(QDataStream &stream) const
-    {
-        stream << index << centers << ProductQuantizationLUTs[index];
-    }
-
-    void load(QDataStream &stream)
-    {
-        stream >> index >> centers;
-        while (ProductQuantizationLUTs.size() <= index)
-            ProductQuantizationLUTs.append(Mat());
-        stream >> ProductQuantizationLUTs[index];
-    }
-};
-
-BR_REGISTER(Transform, ProductQuantizationTransform)
-
-} // namespace br
-
-#include "quantize.moc"
diff --git a/openbr/plugins/regions.cpp b/openbr/plugins/regions.cpp
deleted file mode 100644
index dad3d91..0000000
--- a/openbr/plugins/regions.cpp
+++ /dev/null
@@ -1,478 +0,0 @@
-/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
- * 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/core/qtutils.h"
-#include "openbr_internal.h"
-#include "openbr/core/opencvutils.h"
-
-using namespace cv;
-
-namespace br
-{
-
-/*!
- * \ingroup transforms
- * \brief Subdivide matrix into rectangular subregions.
- * \author Josh Klontz \cite jklontz
- */
-class RectRegionsTransform : 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)
-    Q_PROPERTY(int widthStep READ get_widthStep WRITE set_widthStep RESET reset_widthStep STORED false)
-    Q_PROPERTY(int heightStep READ get_heightStep WRITE set_heightStep RESET reset_heightStep STORED false)
-    BR_PROPERTY(int, width, 8)
-    BR_PROPERTY(int, height, 8)
-    BR_PROPERTY(int, widthStep, -1)
-    BR_PROPERTY(int, heightStep, -1)
-
-    void project(const Template &src, Template &dst) const
-    {
-        const int widthStep = this->widthStep == -1 ? width : this->widthStep;
-        const int heightStep = this->heightStep == -1 ? height : this->heightStep;
-        const Mat &m = src;
-        const int xMax = m.cols - width;
-        const int yMax = m.rows - height;
-        for (int x=0; x <= xMax; x += widthStep)
-            for (int y=0; y <= yMax; y += heightStep)
-                dst += m(Rect(x, y, width, height));
-    }
-};
-BR_REGISTER(Transform, RectRegionsTransform)
-
-/*!
- * \ingroup transforms
- * \brief Turns each row into its own matrix.
- * \author Josh Klontz \cite jklontz
- */
-class ByRowTransform : public UntrainableTransform
-{
-    Q_OBJECT
-
-    void project(const Template &src, Template &dst) const
-    {
-        for (int i=0; i<src.m().rows; i++)
-            dst += src.m().row(i);
-    }
-};
-
-BR_REGISTER(Transform, ByRowTransform)
-
-/*!
- * \ingroup transforms
- * \brief Concatenates all input matrices into a single matrix.
- * \author Josh Klontz \cite jklontz
- */
-class CatTransform : public UntrainableMetaTransform
-{
-    Q_OBJECT
-    Q_PROPERTY(int partitions READ get_partitions WRITE set_partitions RESET reset_partitions)
-    BR_PROPERTY(int, partitions, 1)
-
-    void project(const Template &src, Template &dst) const
-    {
-        dst.file = src.file;
-
-        if (src.size() % partitions != 0)
-            qFatal("%d partitions does not evenly divide %d matrices.", partitions, src.size());
-        QVector<int> sizes(partitions, 0);
-        for (int i=0; i<src.size(); i++)
-            sizes[i%partitions] += src[i].total();
-
-        if (!src.empty())
-            foreach (int size, sizes)
-                dst.append(Mat(1, size, src.m().type()));
-
-        QVector<int> offsets(partitions, 0);
-        for (int i=0; i<src.size(); i++) {
-            size_t size = src[i].total() * src[i].elemSize();
-            int j = i % partitions;
-            memcpy(&dst[j].data[offsets[j]], src[i].ptr(), size);
-            offsets[j] += size;
-        }
-    }
-};
-
-BR_REGISTER(Transform, CatTransform)
-
-/*!
- * \ingroup transforms
- * \brief Group all input matrices into a single matrix.
- *
- * Similar to CatTransfrom but groups every _size_ adjacent matricies.
- * \author Josh Klontz \cite jklontz
- */
-class GroupTransform : public UntrainableMetaTransform
-{
-    Q_OBJECT
-    Q_PROPERTY(int size READ get_size WRITE set_size RESET reset_size STORED false)
-    BR_PROPERTY(int, size, 1)
-
-    void project(const Template &src, Template &dst) const
-    {
-        dst.file = src.file;
-
-        if (src.size() % size != 0)
-            qFatal("%d size does not evenly divide %d matrices.", size, src.size());
-        QVector<int> sizes(src.size() / size, 0);
-        for (int i=0; i<src.size(); i++)
-            sizes[i/size] += src[i].total();
-
-        if (!src.empty())
-            foreach (int size_, sizes)
-                dst.append(Mat(1, size_, src.m().type()));
-
-        QVector<int> offsets(src.size() / size, 0);
-        for (int i=0; i<src.size(); i++) {
-            const size_t bytes = src[i].total() * src[i].elemSize();
-            const int j = i / size;
-            memcpy(&dst[j].data[offsets[j]], src[i].ptr(), bytes);
-            offsets[j] += bytes;
-        }
-    }
-};
-
-BR_REGISTER(Transform, GroupTransform)
-
-/*!
- * \ingroup transforms
- * \brief Concatenates all input matrices by row into a single matrix.
- * All matricies must have the same column counts.
- * \author Josh Klontz \cite jklontz
- */
-class CatRowsTransform : public UntrainableMetaTransform
-{
-    Q_OBJECT
-
-    void project(const Template &src, Template &dst) const
-    {
-        dst = Template(src.file, OpenCVUtils::toMatByRow(src));
-    }
-};
-
-BR_REGISTER(Transform, CatRowsTransform)
-
-/*!
- * \ingroup transforms
- * \brief Concatenates all input matrices by column into a single matrix.
- * Use after a fork to concatenate two feature matrices by column.
- * \author Austin Blanton \cite imaus10
- */
-class CatColsTransform : public UntrainableMetaTransform
-{
-    Q_OBJECT
-
-    void project(const Template &src, Template &dst) const
-    {
-        int half = src.size()/2;
-        for (int i=0; i<half; i++) {
-            Mat first = src[i];
-            Mat second = src[half+i];
-            Mat both;
-            hconcat(first, second, both);
-            dst.append(both);
-        }
-        dst.file = src.file;
-    }
-};
-
-BR_REGISTER(Transform, CatColsTransform)
-
-/*!
- * \ingroup transforms
- * \brief Reshape the each matrix to the specified number of rows.
- * \author Josh Klontz \cite jklontz
- */
-class ReshapeTransform : public UntrainableTransform
-{
-    Q_OBJECT
-    Q_PROPERTY(int rows READ get_rows WRITE set_rows RESET reset_rows STORED false)
-    BR_PROPERTY(int, rows, 1)
-
-    void project(const Template &src, Template &dst) const
-    {
-        dst = src.m().reshape(src.m().channels(), rows);
-    }
-};
-
-BR_REGISTER(Transform, ReshapeTransform)
-
-/*!
- * \ingroup transforms
- * \brief Wraps OpenCV merge
- * \author Josh Klontz \cite jklontz
- */
-class MergeTransform : public UntrainableMetaTransform
-{
-    Q_OBJECT
-
-    void project(const Template &src, Template &dst) const
-    {
-        dst.file = src.file;
-        std::vector<Mat> mv;
-        foreach (const Mat &m, src)
-            mv.push_back(m);
-        merge(mv, dst);
-    }
-};
-
-BR_REGISTER(Transform, MergeTransform)
-
-/*!
- * \ingroup transforms
- * \brief Duplicates the template data.
- * \author Josh Klontz \cite jklontz
- */
-class DupTransform : public UntrainableMetaTransform
-{
-    Q_OBJECT
-    Q_PROPERTY(int n READ get_n WRITE set_n RESET reset_n STORED false)
-    Q_PROPERTY(bool dupLandmarks READ get_dupLandmarks WRITE set_dupLandmarks RESET reset_dupLandmarks STORED false)
-    BR_PROPERTY(int, n, 1)
-    BR_PROPERTY(bool, dupLandmarks, false)
-
-    void project(const Template &src, Template &dst) const
-    {
-        for (int i=0; i<n; i++)
-            dst.merge(src);
-
-        if (dupLandmarks) {
-            QList<QPointF> points = src.file.points();
-            QList<QRectF> rects = src.file.rects();
-
-            for (int i=1; i<n; i++) {
-                dst.file.appendPoints(points);
-                dst.file.appendRects(rects);
-            }
-        }
-    }
-};
-
-BR_REGISTER(Transform, DupTransform)
-
-/*!
- * \ingroup transforms
- * \brief Expand the width and height of a template's rects by input width and height factors.
- * \author Charles Otto \cite caotto
- */
-class ExpandRectTransform : public UntrainableTransform
-{
-    Q_OBJECT
-    Q_PROPERTY(float widthExpand READ get_widthExpand WRITE set_widthExpand RESET reset_widthExpand STORED false)
-    Q_PROPERTY(float heightExpand READ get_heightExpand WRITE set_heightExpand RESET reset_heightExpand STORED false)
-    BR_PROPERTY(float, widthExpand, .5)
-    BR_PROPERTY(float, heightExpand, .5)
-    void project(const Template &src, Template &dst) const
-    {
-        dst = src;
-        QList<QRectF> rects = dst.file.rects();
-        for (int i=0;i < rects.size(); i++) {
-            QRectF rect = rects[i];
-
-            qreal width = rect.width();
-            qreal height = rect.height();
-            float half_w_expansion = widthExpand / 2;
-            float half_h_expansion = heightExpand / 2;
-
-            qreal half_width = width * widthExpand;
-            qreal quarter_width = width * half_w_expansion;
-            qreal half_height = height * heightExpand;
-            qreal quarter_height = height * half_h_expansion;
-
-            rect.setX(std::max(qreal(0),(rect.x() - quarter_width)));
-            rect.setY(std::max(qreal(0),(rect.y() - quarter_height)));
-
-            qreal x2 = std::min(rect.width() + half_width + rect.x(), qreal(src.m().cols) - 1);
-            qreal y2 = std::min(rect.height() + half_height + rect.y(), qreal(src.m().rows) - 1);
-
-            rect.setWidth(x2 - rect.x());
-            rect.setHeight(y2 - rect.y());
-
-            rects[i] = rect;
-        }
-        dst.file.setRects(rects);
-    }
-};
-
-BR_REGISTER(Transform, ExpandRectTransform)
-
-/*!
- * \ingroup transforms
- * \brief Crops the width and height of a template's rects by input width and height factors.
- * \author Scott Klum \cite sklum
- */
-class CropRectTransform : public UntrainableTransform
-{
-    Q_OBJECT
-
-    Q_PROPERTY(QString widthCrop READ get_widthCrop WRITE set_widthCrop RESET reset_widthCrop STORED false)
-    Q_PROPERTY(QString heightCrop READ get_heightCrop WRITE set_heightCrop RESET reset_heightCrop STORED false)
-    BR_PROPERTY(QString, widthCrop, QString())
-    BR_PROPERTY(QString, heightCrop, QString())
-
-    void project(const Template &src, Template &dst) const
-    {
-        dst = src;
-        QList<QRectF> rects = src.file.rects();
-        for (int i=0;i < rects.size(); i++) {
-            rects[i].setX(rects[i].x() + rects[i].width() * QtUtils::toPoint(widthCrop).x());
-            rects[i].setY(rects[i].y() + rects[i].height() * QtUtils::toPoint(heightCrop).x());
-            rects[i].setWidth(rects[i].width() * (1-QtUtils::toPoint(widthCrop).y()));
-            rects[i].setHeight(rects[i].height() * (1-QtUtils::toPoint(heightCrop).y()));
-        }
-        dst.file.setRects(rects);
-    }
-};
-
-BR_REGISTER(Transform, CropRectTransform)
-
-/*!
- * \ingroup transforms
- * \brief Create rect from landmarks.
- * \author Scott Klum \cite sklum
- * \todo Padding should be a percent of total image size
- */
-
-class RectFromPointsTransform : public UntrainableTransform
-{
-    Q_OBJECT
-    Q_PROPERTY(QList<int> indices READ get_indices WRITE set_indices RESET reset_indices STORED false)
-    Q_PROPERTY(double padding READ get_padding WRITE set_padding RESET reset_padding STORED false)
-    Q_PROPERTY(double aspectRatio READ get_aspectRatio WRITE set_aspectRatio RESET reset_aspectRatio STORED false)
-    BR_PROPERTY(QList<int>, indices, QList<int>())
-    BR_PROPERTY(double, padding, 0)
-    BR_PROPERTY(double, aspectRatio, 1.0)
-
-    void project(const Template &src, Template &dst) const
-    {
-        dst = src;
-
-        if (src.file.points().isEmpty()) {
-            if (Globals->verbose) qWarning("No landmarks");
-            return;
-        }
-
-        int minX, minY;
-        minX = minY = std::numeric_limits<int>::max();
-        int maxX, maxY;
-        maxX = maxY = -std::numeric_limits<int>::max();
-
-        QList<QPointF> points;
-
-        foreach (int index, indices) {
-            if (src.file.points().size() > index) {
-                if (src.file.points()[index].x() < minX) minX = src.file.points()[index].x();
-                if (src.file.points()[index].x() > maxX) maxX = src.file.points()[index].x();
-                if (src.file.points()[index].y() < minY) minY = src.file.points()[index].y();
-                if (src.file.points()[index].y() > maxY) maxY = src.file.points()[index].y();
-                points.append(src.file.points()[index]);
-            }
-            else qFatal("Incorrect indices");
-        }
-
-        double width = maxX-minX;
-        double deltaWidth = width*padding;
-        width += deltaWidth;
-
-        double height = maxY-minY;
-        double deltaHeight = width/aspectRatio - height;
-        height += deltaHeight;                                       
-
-        const int x = std::max(0.0, minX - deltaWidth/2.0);
-        const int y = std::max(0.0, minY - deltaHeight/2.0);
-
-        dst.file.setPoints(points);
-        dst.file.appendRect(QRectF(x, y, std::min((double)src.m().cols-x, width), std::min((double)src.m().rows-y, height)));
-    }
-};
-
-BR_REGISTER(Transform, RectFromPointsTransform)
-
-/*!
- * \ingroup transforms
- * \brief Create matrix from landmarks.
- * \author Scott Klum \cite sklum
- * \todo Padding should be a percent of total image size
- */
-
-class BoundingBoxTransform : public UntrainableTransform
-{
-    Q_OBJECT
-
-    void project(const Template &src, Template &dst) const
-    {
-        dst = src;
-
-        if (src.file.points().isEmpty()) {
-            if (Globals->verbose) qFatal("No landmarks");
-            return;
-        }
-
-        Rect boundingBox = boundingRect(OpenCVUtils::toPoints(src.file.points()).toVector().toStdVector());
-        dst.file.appendRect(OpenCVUtils::fromRect(boundingBox));
-    }
-};
-
-BR_REGISTER(Transform, BoundingBoxTransform)
-
-/*!
- * \ingroup transforms
- * \brief Create face bounding box from two eye locations. `widthPadding` specifies
- *      what percentage of the interpupliary distance (ipd) will be padded in both
- *      horizontal directions. The `verticalLocation` specifies where vertically the 
- *      eyes are within the bounding box (0.5 would be the center).
- * \author Brendan Klare \cite bklare
- */
-
-class FaceFromEyesTransform : public UntrainableTransform
-{
-    Q_OBJECT
-    Q_PROPERTY(double widthPadding READ get_widthPadding WRITE set_widthPadding RESET reset_widthPadding STORED false)
-    Q_PROPERTY(double verticalLocation READ get_verticalLocation WRITE set_verticalLocation RESET reset_verticalLocation STORED false)
-    Q_PROPERTY(int leftEyeIdx READ get_leftEyeIdx WRITE set_leftEyeIdx RESET reset_leftEyeIdx STORED false)
-    Q_PROPERTY(int rightEyeIdx READ get_rightEyeIdx WRITE set_rightEyeIdx RESET reset_rightEyeIdx STORED false)
-    BR_PROPERTY(double, widthPadding, 0.7)
-    BR_PROPERTY(double, verticalLocation, 0.25)
-    BR_PROPERTY(int, leftEyeIdx, 0)
-    BR_PROPERTY(int, rightEyeIdx, 1)
-
-    void project(const Template &src, Template &dst) const
-    {
-        dst = src;
-
-        if (src.file.points().isEmpty()) {
-            qWarning("No landmarks");
-            dst = src;
-            return;
-        }
-
-        QPointF eyeL = src.file.points()[leftEyeIdx];
-        QPointF eyeR = src.file.points()[rightEyeIdx];
-        QPointF eyeCenter((eyeL.x() + eyeR.x()) / 2, (eyeL.y() + eyeR.y()) / 2);
-        float ipd = sqrt(pow(eyeL.x() - eyeR.x(), 2) + pow(eyeL.y() - eyeR.y(), 2));
-        float width = ipd + 2 * widthPadding * ipd;
-        
-        dst.file.appendRect(QRectF(eyeCenter.x() - width / 2, eyeCenter.y() - width * verticalLocation, width, width));
-    }
-};
-
-BR_REGISTER(Transform, FaceFromEyesTransform)
-
-} // namespace br
-
-#include "regions.moc"
diff --git a/openbr/plugins/sentence.cpp b/openbr/plugins/sentence.cpp
deleted file mode 100644
index fca4cd6..0000000
--- a/openbr/plugins/sentence.cpp
+++ /dev/null
@@ -1,93 +0,0 @@
-#include <stdint.h>
-#include "openbr_internal.h"
-
-using namespace cv;
-
-namespace br
-{
-
-/*!
- * \ingroup transforms
- * \brief Ordered words
- * \author Josh Klontz \cite jklontz
- */
-class SentenceTransform : public UntrainableMetaTransform
-{
-    Q_OBJECT
-
-    void project(const Template &src, Template &dst) const
-    {
-        QByteArray sentence;
-        QDataStream stream(&sentence, QIODevice::WriteOnly);
-        for (int i=0; i<src.size(); i++) {
-            const Mat &m = src[i];
-            if (!m.data) continue;
-            stream.writeRawData((const char*)&i, 4);
-            stream.writeRawData((const char*)&m.rows, 4);
-            stream.writeRawData((const char*)&m.cols, 4);
-            stream.writeRawData((const char*)m.data, 4*m.rows*m.cols);
-        }
-        dst.file = src.file;
-        dst.m() = Mat(1, sentence.size(), CV_8UC1, sentence.data()).clone();
-    }
-};
-
-BR_REGISTER(Transform, SentenceTransform)
-
-/*!
- * \ingroup distances
- * \brief Distance between sentences
- * \author Josh Klontz \cite jklontz
- */
-class SentenceSimilarityDistance : public UntrainableDistance
-{
-    Q_OBJECT
-
-    float compare(const Mat &a, const Mat &b) const
-    {
-        uchar *aBuffer = a.data;
-        uchar *bBuffer = b.data;
-        const uchar *aEnd = aBuffer + a.cols;
-        const uchar *bEnd = bBuffer + b.cols;
-
-        int32_t aWord, bWord, aRows, bRows, aColumns, bColumns;
-        float *aData, *bData;
-        aWord = aRows = aColumns = -2;
-        bWord = bRows = bColumns = -1;
-        aData = bData = NULL;
-
-        float distance = 0;
-        int comparisons = 0;
-        while (true) {
-            if (aWord < bWord) {
-                if (aBuffer == aEnd) return distance == 0 ? -std::numeric_limits<float>::max() : comparisons / distance;
-                aWord = *reinterpret_cast<int32_t*>(aBuffer);
-                aRows = *reinterpret_cast<int32_t*>(aBuffer+4);
-                aColumns = *reinterpret_cast<int32_t*>(aBuffer+8);
-                aData = reinterpret_cast<float*>(aBuffer+12);
-                aBuffer += 12 + 4*aRows*aColumns;
-            } else if (bWord < aWord) {
-                if (bBuffer == bEnd) return comparisons == 0 ? -std::numeric_limits<float>::max() : comparisons / distance;
-                bWord = *reinterpret_cast<int32_t*>(bBuffer);
-                bRows = *reinterpret_cast<int32_t*>(bBuffer+4);
-                bColumns = *reinterpret_cast<int32_t*>(bBuffer+8);
-                bData = reinterpret_cast<float*>(bBuffer+12);
-                bBuffer += 12 + 4*bRows*bColumns;
-            } else {
-                for (int i=0; i<aRows; i++)
-                    for (int j=0; j<bRows; j++)
-                        for (int k=0; k<aColumns; k++)
-                            distance += pow(aData[i*aColumns+k] - bData[j*bColumns+k], 2.f);
-                comparisons += aRows * bRows * aColumns;
-                aWord = -2;
-                bWord = -1;
-            }
-        }
-    }
-};
-
-BR_REGISTER(Distance, SentenceSimilarityDistance)
-
-} // namespace br
-
-#include "sentence.moc"
diff --git a/openbr/plugins/slidingwindow.cpp b/openbr/plugins/slidingwindow.cpp
deleted file mode 100644
index 1ae5663..0000000
--- a/openbr/plugins/slidingwindow.cpp
+++ /dev/null
@@ -1,529 +0,0 @@
-#include "openbr_internal.h"
-#include "openbr/core/opencvutils.h"
-#include "openbr/core/common.h"
-#include "openbr/core/qtutils.h"
-#include <opencv2/objdetect/objdetect.hpp>
-#include <opencv2/imgproc/imgproc.hpp>
-#include <opencv2/highgui/highgui.hpp>
-#include <Eigen/Dense>
-
-using namespace cv;
-using namespace Eigen;
-
-namespace br
-{
-
-// Find avg aspect ratio
-static float getAspectRatio(const TemplateList &data)
-{
-    double tempRatio = 0;
-    int ratioCnt = 0;
-
-    foreach (const Template &tmpl, data) {
-        QList<Rect> posRects = OpenCVUtils::toRects(tmpl.file.rects());
-        foreach (const Rect &posRect, posRects) {
-            if (posRect.x + posRect.width >= tmpl.m().cols || posRect.y + posRect.height >= tmpl.m().rows || posRect.x < 0 || posRect.y < 0) {
-                continue;
-            }
-            tempRatio += (float)posRect.width / (float)posRect.height;
-            ratioCnt += 1;
-        }
-    }
-    return tempRatio / (double)ratioCnt;
-}
-
-/*!
- * \ingroup transforms
- * \brief Applies a transform to a sliding window.
- *        Discards negative detections.
- * \author Austin Blanton \cite imaus10
- */
-class SlidingWindowTransform : public Transform
-{
-    Q_OBJECT
-    Q_PROPERTY(br::Transform *transform READ get_transform WRITE set_transform RESET reset_transform STORED false)
-    Q_PROPERTY(int windowWidth READ get_windowWidth WRITE set_windowWidth RESET reset_windowWidth STORED false)
-    Q_PROPERTY(bool takeFirst READ get_takeFirst WRITE set_takeFirst RESET reset_takeFirst STORED false)
-    Q_PROPERTY(float threshold READ get_threshold WRITE set_threshold RESET reset_threshold STORED false)
-    Q_PROPERTY(float stepFraction READ get_stepFraction WRITE set_stepFraction RESET reset_stepFraction STORED false)
-    Q_PROPERTY(int ignoreBorder READ get_ignoreBorder WRITE set_ignoreBorder RESET reset_ignoreBorder STORED true)
-    BR_PROPERTY(br::Transform *, transform, NULL)
-    BR_PROPERTY(int, windowWidth, 24)
-    BR_PROPERTY(bool, takeFirst, false)
-    BR_PROPERTY(float, threshold, 0)
-    BR_PROPERTY(float, stepFraction, 0.25)
-    BR_PROPERTY(int, ignoreBorder, 0)
-
-private:
-    int windowHeight;
-    bool skipProject;
-
-    void train(const TemplateList &data)
-    {
-        skipProject = true;
-        float aspectRatio = data.first().file.get<float>("aspectRatio", -1);
-        if (aspectRatio == -1)
-            aspectRatio = getAspectRatio(data);
-        windowHeight = qRound(windowWidth / aspectRatio);
-
-        if (transform->trainable) {
-            TemplateList dataOut = data;
-            if (ignoreBorder > 0) {
-                for (int i = 0; i < dataOut.size(); i++) {
-                    Template t = dataOut[i];
-                    Mat m = t.m();
-                    dataOut.replace(i,Template(t.file, Mat(m,Rect(ignoreBorder,ignoreBorder,m.cols - ignoreBorder * 2, m.rows - ignoreBorder * 2))));
-                }
-            }
-            transform->train(dataOut);
-        }
-    }
-
-    void store(QDataStream &stream) const
-    {
-        transform->store(stream);
-        stream << windowHeight;
-    }
-
-    void load(QDataStream &stream)
-    {
-        transform->load(stream);
-        stream >> windowHeight;
-    }
-
-    void project(const Template &src, Template &dst) const
-    {
-        float scale = src.file.get<float>("scale", 1);
-        projectHelp(src, dst, windowWidth, windowHeight, scale);
-    }
-
- protected:
-     void projectHelp(const Template &src, Template &dst, int windowWidth, int windowHeight, float scale = 1) const
-     {
-
-        dst = src;
-        if (skipProject) {
-            dst = src;
-            return;
-        }
-
-        Template windowTemplate(src.file, src);
-        QList<float> confidences = dst.file.getList<float>("Confidences", QList<float>());
-        for (float y = 0; y + windowHeight < src.m().rows; y += windowHeight*stepFraction) {
-            for (float x = 0; x + windowWidth < src.m().cols; x += windowWidth*stepFraction) {
-                Mat windowMat(src, Rect(x + ignoreBorder, y + ignoreBorder, windowWidth - ignoreBorder * 2, windowHeight - ignoreBorder * 2));
-                windowTemplate.replace(0,windowMat);
-                Template detect;
-                transform->project(windowTemplate, detect);
-                float conf = detect.m().at<float>(0);
-
-                // the result will be in the Label
-                if (conf > threshold) {
-                    dst.file.appendRect(QRectF(x*scale, y*scale, windowWidth*scale, windowHeight*scale));
-                    confidences.append(conf);
-                    if (takeFirst)
-                        return;
-                }
-            }
-        }
-        dst.file.setList<float>("Confidences", confidences);
-    }
-};
-
-BR_REGISTER(Transform, SlidingWindowTransform)
-
-/*!
- * \ingroup transforms
- * \brief Overloads SlidingWindowTransform for integral images that should be
- *        sampled at multiple scales.
- * \author Josh Klontz \cite jklontz
- */
-class IntegralSlidingWindowTransform : public SlidingWindowTransform
-{
-    Q_OBJECT
-
- private:
-    void project(const Template &src, Template &dst) const
-    {
-        // TODO: call SlidingWindowTransform::project on multiple scales
-        SlidingWindowTransform::projectHelp(src, dst, 24, 24);
-    }
-};
-
-BR_REGISTER(Transform, IntegralSlidingWindowTransform)
-
-static TemplateList cropTrainingSamples(const TemplateList &data, const float aspectRatio, const int minSize = 32, const float maxOverlap = 0.5, const int negToPosRatio = 1)
-{
-    TemplateList result;
-    foreach (const Template &tmpl, data) {
-        QList<Rect> posRects = OpenCVUtils::toRects(tmpl.file.rects());
-        QList<Rect> negRects;
-        for (int i=0; i<posRects.size(); i++) {
-            Rect &posRect = posRects[i];
-
-            // Adjust for training samples that have different aspect ratios
-            const int diff = int(posRect.height * aspectRatio) - posRect.width;
-            posRect.x -= diff / 2;
-            posRect.width += diff;
-
-            // Ignore samples larger than the image
-            if ((posRect.x + posRect.width >= tmpl.m().cols) ||
-                (posRect.y + posRect.height >= tmpl.m().rows) ||
-                (posRect.x < 0) ||
-                (posRect.y < 0))
-                continue;
-
-            result += Template(tmpl.file, Mat(tmpl, posRect));
-            result.last().file.set("Label", QString("pos"));
-
-            // Add random negative samples
-            Mat m = tmpl.m();
-            int sample = 0;
-            while (sample < negToPosRatio) {
-                const int x = rand() % m.cols;
-                const int y = rand() % m.rows;
-                const int maxWidth = m.cols - x;
-                const int maxHeight = m.rows - y;
-                if (maxWidth <= minSize || maxHeight <= minSize)
-                    continue;
-
-                int height;
-                int width;
-                if (aspectRatio > (float) maxWidth / (float) maxHeight) {
-                    width = rand() % (maxWidth - minSize) + minSize;
-                    height = qRound(width / aspectRatio);
-                } else {
-                    height = rand() % (maxHeight - minSize) + minSize;
-                    width = qRound(height * aspectRatio);
-                }
-                Rect negRect(x, y, width, height);
-
-                // The negative samples cannot overlap the positive samples at
-                // all, but they may partially overlap with other negatives.
-                if (OpenCVUtils::overlaps(posRects, negRect, 0) ||
-                    OpenCVUtils::overlaps(negRects, negRect, maxOverlap))
-                    continue;
-
-                result += Template(tmpl.file, Mat(tmpl, negRect));
-                result.last().file.set("Label", QString("neg"));
-                sample++;
-            }
-        }
-    }
-
-    return result;
-}
-
-/*!
- * \ingroup transforms
- * \brief Document me
- * \author Austin Blanton \cite imaus10
- */
-class BuildScalesTransform : public Transform
-{
-    Q_OBJECT
-    Q_PROPERTY(br::Transform *transform READ get_transform WRITE set_transform RESET reset_transform STORED false)
-    Q_PROPERTY(double scaleFactor READ get_scaleFactor WRITE set_scaleFactor RESET reset_scaleFactor STORED false)
-    Q_PROPERTY(bool takeLargestScale READ get_takeLargestScale WRITE set_takeLargestScale RESET reset_takeLargestScale STORED false)
-    Q_PROPERTY(int windowWidth READ get_windowWidth WRITE set_windowWidth RESET reset_windowWidth STORED false)
-    Q_PROPERTY(int negToPosRatio READ get_negToPosRatio WRITE set_negToPosRatio RESET reset_negToPosRatio STORED false)
-    Q_PROPERTY(int minSize READ get_minSize WRITE set_minSize RESET reset_minSize STORED false)
-    Q_PROPERTY(double maxOverlap READ get_maxOverlap WRITE set_maxOverlap RESET reset_maxOverlap STORED false)
-    Q_PROPERTY(float minScale READ get_minScale WRITE set_minScale RESET reset_minScale STORED false)
-    BR_PROPERTY(br::Transform *, transform, NULL)
-    BR_PROPERTY(double, scaleFactor, 0.75)
-    BR_PROPERTY(bool, takeLargestScale, false)
-    BR_PROPERTY(int, windowWidth, 24)
-    BR_PROPERTY(int, negToPosRatio, 1)
-    BR_PROPERTY(int, minSize, 8)
-    BR_PROPERTY(double, maxOverlap, 0)
-    BR_PROPERTY(float, minScale, 1.0)
-
-private:
-    float aspectRatio;
-    int windowHeight;
-    bool skipProject;
-
-    void train(const TemplateList &data)
-    {
-        skipProject = true;
-        aspectRatio = getAspectRatio(data);
-        windowHeight = qRound(windowWidth / aspectRatio);
-        if (transform->trainable) {
-            TemplateList full;
-            foreach (const Template &roi, cropTrainingSamples(data, aspectRatio, minSize, maxOverlap, negToPosRatio)) {
-                Mat resized;
-                resize(roi, resized, Size(windowWidth, windowHeight));
-                full += Template(roi.file, resized);
-            }
-            full.first().file.set("aspectRatio", aspectRatio);
-            transform->train(full);
-        }
-    }
-
-    void project(const Template &src, Template &dst) const
-    {
-        dst = src;
-        if (skipProject) {
-            dst = src;
-            return;
-        }
-
-        int rows = src.m().rows;
-        int cols = src.m().cols;
-        int windowHeight = (int) qRound((float) windowWidth / aspectRatio);
-
-        float startScale;
-        if ((cols / rows) > aspectRatio)
-            startScale = qRound((float) rows / (float) windowHeight);
-        else
-            startScale = qRound((float) cols / (float) windowWidth);
-
-        for (float scale = startScale; scale >= minScale; scale -= (1.0 - scaleFactor)) {
-            Template scaleImg(dst.file, Mat());
-            scaleImg.file.set("scale", scale);
-            resize(src, scaleImg, Size(qRound(cols / scale), qRound(rows / scale)));
-            transform->project(scaleImg, dst);
-            if (takeLargestScale && !dst.file.rects().empty())
-                return;
-        }
-    }
-
-    void store(QDataStream &stream) const
-    {
-        transform->store(stream);
-        stream << aspectRatio << windowHeight;
-    }
-    void load(QDataStream &stream)
-    {
-        transform->load(stream);
-        stream >> aspectRatio >> windowHeight;
-    }
-};
-
-BR_REGISTER(Transform, BuildScalesTransform)
-
-/*!
- * \ingroup transforms
- * \brief Sample detection bounding boxes from without resizing
- * \author Josh Klontz \cite jklontz
- */
-class Detector : public Transform
-{
-    Q_OBJECT
-    Q_PROPERTY(br::Transform *transform READ get_transform WRITE set_transform RESET reset_transform)
-    BR_PROPERTY(br::Transform*, transform, make("Identity"))
-
-    void train(const TemplateList &data)
-    {
-        const float aspectRatio = getAspectRatio(data);
-        TemplateList cropped = cropTrainingSamples(data, aspectRatio);
-        qDebug("Detector using: %d training samples.", cropped.size());
-        cropped.first().file.set("aspectRatio", aspectRatio);
-        transform->train(cropped);
-    }
-
-    void project(const Template &src, Template &dst) const
-    {
-        dst = src;
-    }
-};
-
-BR_REGISTER(Transform, Detector)
-
-/*!
- * \ingroup transforms
- * \brief Detects objects with OpenCV's built-in HOG detection.
- * \author Austin Blanton \cite imaus10
- */
-class HOGDetectTransform : public UntrainableTransform
-{
-    Q_OBJECT
-
-    HOGDescriptor hog;
-
-    void init()
-    {
-        hog.setSVMDetector(HOGDescriptor::getDefaultPeopleDetector());
-    }
-
-    void project(const Template &src, Template &dst) const
-    {
-        dst = src;
-        std::vector<Rect> objLocs;
-        QList<Rect> rects;
-        hog.detectMultiScale(src, objLocs);
-        foreach (const Rect &obj, objLocs)
-            rects.append(obj);
-        dst.file.setRects(rects);
-    }
-};
-
-BR_REGISTER(Transform, HOGDetectTransform)
-
-/*!
- * \ingroup transforms
- * \brief Consolidate redundant/overlapping detections.
- * \author Brendan Klare \cite bklare
- */
-class ConsolidateDetectionsTransform : public Transform
-{
-    Q_OBJECT
-
-public:
-    ConsolidateDetectionsTransform() : Transform(false, false) {}
-private:
-
-    void project(const Template &src, Template &dst) const
-    {
-        dst = src;
-        if (!dst.file.contains("Confidences"))
-            return;
-
-        //Compute overlap between rectangles and create discrete Laplacian matrix
-        QList<Rect> rects = OpenCVUtils::toRects(src.file.rects());
-        int n = rects.size();
-        if (n == 0)
-            return;
-        MatrixXf laplace(n,n);
-        for (int i = 0; i < n; i++) {
-            laplace(i,i) = 0;
-        }
-        for (int i = 0; i < n; i++){
-            for (int j = i + 1; j < n; j++) {
-                float overlap = (float)((rects[i] & rects[j]).area()) / (float)max(rects[i].area(), rects[j].area());
-                if (overlap > 0.5) {
-                    laplace(i,j) = -1.0;
-                    laplace(j,i) = -1.0;
-                    laplace(i,i) = laplace(i,i) + 1.0;
-                    laplace(j,j) = laplace(j,j) + 1.0;
-                } else {
-                    laplace(i,j) = 0;
-                    laplace(j,i) = 0;
-                }
-            }
-        }
-
-        // Compute eigendecomposition
-        SelfAdjointEigenSolver<Eigen::MatrixXf> eSolver(laplace);
-        MatrixXf allEVals = eSolver.eigenvalues();
-        MatrixXf allEVecs = eSolver.eigenvectors();
-
-        //Keep eigenvectors with zero eigenvalues
-        int nRegions = 0;
-        for (int i = 0; i < n; i++) {
-            if (fabs(allEVals(i)) < 1e-4) {
-                nRegions++;
-            }
-        }
-        MatrixXf regionVecs(n, nRegions);
-        for (int i = 0, cnt = 0; i < n; i++) {
-            if (fabs(allEVals(i)) < 1e-4)
-                regionVecs.col(cnt++) = allEVecs.col(i);
-        }
-
-        //Determine membership for each consolidated location
-        // and compute average of regions. This is determined by
-        // finding which eigenvector has the highest magnitude for
-        // each input dimension. Each input dimension corresponds to
-        // one of the input rect region. Thus, each eigenvector represents
-        // a set of overlaping regions.
-        float *midX = new float[nRegions];
-        float *midY = new float[nRegions];
-        float *avgWidth = new float[nRegions];
-        float *avgHeight = new float[nRegions];
-        float *confs = new float[nRegions];
-        int *cnts = new int[nRegions];
-        int mx;
-        int mxIdx;
-        for (int i = 0 ; i < nRegions; i++) {
-            midX[i] = 0;
-            midY[i] = 0;
-            avgWidth[i] = 0;
-            avgHeight[i] = 0;
-            confs[i] = 0;
-            cnts[i] = 0;
-        }
-
-        QList<float> confidences = dst.file.getList<float>("Confidences");
-        for (int i = 0; i < n; i++) {
-            mx = 0.0;
-            mxIdx = -1;
-
-            for (int j = 0; j < nRegions; j++) {
-                if (fabs(regionVecs(i,j)) > mx) {
-                    mx = fabs(regionVecs(i,j));
-                    mxIdx = j;
-                }
-            }
-
-            Rect curRect = rects[i];
-            midX[mxIdx] += ((float)curRect.x + (float)curRect.width  / 2.0);
-            midY[mxIdx] += ((float)curRect.y + (float)curRect.height / 2.0);
-            avgWidth[mxIdx]  += (float) curRect.width;
-            avgHeight[mxIdx] += (float) curRect.height;
-            confs[mxIdx] += confidences[i];
-            cnts[mxIdx]++;
-        }
-
-        QList<Rect> consolidatedRects;
-        QList<float> consolidatedConfidences;
-        for (int i = 0; i < nRegions; i++) {
-            float cntF = (float) cnts[i];
-            if (cntF > 0) {
-                int x = qRound((midX[i] / cntF) - (avgWidth[i] / cntF) / 2.0);
-                int y = qRound((midY[i] / cntF) - (avgHeight[i] / cntF) / 2.0);
-                int w = qRound(avgWidth[i] / cntF);
-                int h = qRound(avgHeight[i] / cntF);
-                consolidatedRects.append(Rect(x,y,w,h));
-                consolidatedConfidences.append(confs[i] / cntF);
-            }
-        }
-
-        delete [] midX;
-        delete [] midY;
-        delete [] avgWidth;
-        delete [] avgHeight;
-        delete [] confs;
-        delete [] cnts;
-
-        dst.file.setRects(consolidatedRects);
-        dst.file.setList<float>("Confidences", consolidatedConfidences);
-    }
-};
-
-BR_REGISTER(Transform, ConsolidateDetectionsTransform)
-
-/*!
- * \ingroup transforms
- * \brief For each rectangle bounding box in src, a new
- *      template is created.
- * \author Brendan Klare \cite bklare
- */
-class RectsToTemplatesTransform : public UntrainableMetaTransform
-{
-    Q_OBJECT
-
-private:
-    void project(const Template &src, Template &dst) const
-    {
-        Template tOut(src.file);
-        QList<float> confidences = src.file.getList<float>("Confidences");
-        QList<QRectF> rects = src.file.rects();
-        for (int i = 0; i < rects.size(); i++) {
-            Mat m(src, OpenCVUtils::toRect(rects[i]));
-            Template t(src.file, m);
-            t.file.set("Confidence", confidences[i]);
-            t.file.clearRects();
-            tOut << t;
-        }
-        dst = tOut;
-    }
-};
-
-BR_REGISTER(Transform, RectsToTemplatesTransform)
-
-
-} // namespace br
-
-#include "slidingwindow.moc"
diff --git a/openbr/plugins/template.cpp b/openbr/plugins/template.cpp
deleted file mode 100644
index 447a4f8..0000000
--- a/openbr/plugins/template.cpp
+++ /dev/null
@@ -1,248 +0,0 @@
-#include <QtCore>
-
-#include "openbr_internal.h"
-#include "openbr/core/common.h"
-
-namespace br
-{
-
-/*!
- * \ingroup transforms
- * \brief Retains only the values for the keys listed, to reduce template size
- * \author Scott Klum \cite sklum
- */
-class KeepMetadataTransform : public UntrainableMetadataTransform
-{
-    Q_OBJECT
-    Q_PROPERTY(QStringList keys READ get_keys WRITE set_keys RESET reset_keys STORED false)
-    BR_PROPERTY(QStringList, keys, QStringList())
-
-    void projectMetadata(const File &src, File &dst) const
-    {
-        dst = src;
-        foreach (const QString& localKey, dst.localKeys())
-            if (!keys.contains(localKey))
-                dst.remove(localKey);
-    }
-};
-
-BR_REGISTER(Transform, KeepMetadataTransform)
-
-/*!
- * \ingroup transforms
- * \brief Remove templates with the specified file extension or metadata value.
- * \author Josh Klontz \cite jklontz
- */
-class RemoveTemplatesTransform : public UntrainableMetaTransform
-{
-    Q_OBJECT
-    Q_PROPERTY(QString regexp READ get_regexp WRITE set_regexp RESET reset_regexp STORED false)
-    Q_PROPERTY(QString key READ get_key WRITE set_key RESET reset_key STORED false)
-    BR_PROPERTY(QString, regexp, "")
-    BR_PROPERTY(QString, key, "")
-
-    void project(const Template &src, Template &dst) const
-    {
-        const QRegularExpression re(regexp);
-        const QRegularExpressionMatch match = re.match(key.isEmpty() ? src.file.suffix() : src.file.get<QString>(key));
-        if (match.hasMatch()) dst = Template();
-        else                  dst = src;
-    }
-};
-
-BR_REGISTER(Transform, RemoveTemplatesTransform)
-
-/*!
- * \ingroup transforms
- * \brief Sets the metadata key/value pair.
- * \author Josh Klontz \cite jklontz
- */
-class SetMetadataTransform : public UntrainableMetadataTransform
-{
-    Q_OBJECT
-    Q_PROPERTY(QString key READ get_key WRITE set_key RESET reset_key STORED false)
-    Q_PROPERTY(QString value READ get_value WRITE set_value RESET reset_value STORED false)
-    BR_PROPERTY(QString, key, "")
-    BR_PROPERTY(QString, value, "")
-
-    void projectMetadata(const File &src, File &dst) const
-    {
-        dst = src;
-        dst.set(key, value);
-    }
-};
-
-BR_REGISTER(Transform, SetMetadataTransform)
-
-/*!
- * \ingroup transforms
- * \brief Clear templates without the required metadata.
- * \author Josh Klontz \cite jklontz
- */
-class IfMetadataTransform : public UntrainableMetaTransform
-{
-    Q_OBJECT
-    Q_PROPERTY(QString key READ get_key WRITE set_key RESET reset_key STORED false)
-    Q_PROPERTY(QString value READ get_value WRITE set_value RESET reset_value STORED false)
-    BR_PROPERTY(QString, key, "")
-    BR_PROPERTY(QString, value, "")
-
-    void project(const Template &src, Template &dst) const
-    {
-        if (src.file.get<QString>(key, "") == value)
-            dst = src;
-    }
-};
-
-BR_REGISTER(Transform, IfMetadataTransform)
-
-/*!
- * \ingroup transforms
- * \brief Represent the metadata as JSON template data.
- * \author Josh Klontz \cite jklontz
- */
-class JSONTransform : public UntrainableMetaTransform
-{
-    Q_OBJECT
-
-    void project(const Template &src, Template &dst) const
-    {
-        dst.file = src.file;
-        dst.file.set("AlgorithmID", 2);
-        const QByteArray json = QJsonDocument(QJsonObject::fromVariantMap(dst.file.localMetadata())).toJson().replace('\n', ' ');
-        dst += cv::Mat(1, json.size()+1 /*include null terminator*/, CV_8UC1, (void*) json.data()).clone();
-    }
-};
-
-BR_REGISTER(Transform, JSONTransform)
-
-/*!
- * \ingroup transforms
- * \brief Removes a metadata field from all templates
- * \author Brendan Klare \cite bklare
- */
-class RemoveMetadataTransform : public UntrainableMetadataTransform
-{
-    Q_OBJECT
-    Q_PROPERTY(QString attributeName READ get_attributeName WRITE set_attributeName RESET reset_attributeName STORED false)
-    BR_PROPERTY(QString, attributeName, "None")
-
-    void projectMetadata(const File &src, File &dst) const
-    {
-        dst = src;
-        if (dst.contains(attributeName))
-            dst.remove(attributeName);
-    }
-};
-BR_REGISTER(Transform, RemoveMetadataTransform)
-
-/*!
- * \ingroup transforms
- * \brief Clears the points from a template
- * \author Brendan Klare \cite bklare
- */
-class ClearPointsTransform : public UntrainableMetadataTransform
-{
-    Q_OBJECT
-
-    void projectMetadata(const File &src, File &dst) const
-    {
-        dst = src;
-        dst.clearPoints();
-    }
-};
-
-BR_REGISTER(Transform, ClearPointsTransform)
-
-/*!
- * \ingroup transforms
- * \brief Retains only landmarks/points at the provided indices
- * \author Brendan Klare \cite bklare
- */
-class SelectPointsTransform : public UntrainableMetadataTransform
-{
-    Q_OBJECT
-    Q_PROPERTY(QList<int> indices READ get_indices WRITE set_indices RESET reset_indices STORED false)
-    Q_PROPERTY(bool invert READ get_invert WRITE set_invert RESET reset_invert STORED false) // keep the points _not_ in the list
-    BR_PROPERTY(QList<int>, indices, QList<int>())
-    BR_PROPERTY(bool, invert, false)
-
-    void projectMetadata(const File &src, File &dst) const
-    {
-        const QList<QPointF> srcPoints = src.points();
-        QList<QPointF> dstPoints;
-        for (int i=0; i<srcPoints.size(); i++)
-            if (indices.contains(i) ^ invert)
-                dstPoints.append(srcPoints[i]);
-        dst.setPoints(dstPoints);
-    }
-};
-
-BR_REGISTER(Transform, SelectPointsTransform)
-
-/*!
- * \ingroup transforms
- * \brief Removes duplicate templates based on a unique metadata key
- * \author Austin Blanton \cite imaus10
- */
-class FilterDupeMetadataTransform : public TimeVaryingTransform
-{
-    Q_OBJECT
-
-    Q_PROPERTY(QString key READ get_key WRITE set_key RESET reset_key STORED false)
-    BR_PROPERTY(QString, key, "TemplateID")
-
-    QSet<QString> excluded;
-
-    void projectUpdate(const TemplateList &src, TemplateList &dst)
-    {
-        foreach (const Template &t, src) {
-            QString id = t.file.get<QString>(key);
-            if (!excluded.contains(id)) {
-                dst.append(t);
-                excluded.insert(id);
-            }
-        }
-    }
-
-public:
-    FilterDupeMetadataTransform() : TimeVaryingTransform(false,false) {}
-};
-
-BR_REGISTER(Transform, FilterDupeMetadataTransform)
-
-/*!
- * \ingroup transforms
- * \brief Reorder the points such that points[from[i]] becomes points[to[i]] and
- *        vice versa
- * \author Scott Klum \cite sklum
- */
-class ReorderPointsTransform : public UntrainableMetadataTransform
-{
-    Q_OBJECT
-
-    Q_PROPERTY(QList<int> from READ get_from WRITE set_from RESET reset_from STORED false)
-    Q_PROPERTY(QList<int> to READ get_to WRITE set_to RESET reset_to STORED false)
-    BR_PROPERTY(QList<int>, from, QList<int>())
-    BR_PROPERTY(QList<int>, to, QList<int>())
-
-    void projectMetadata(const File &src, File &dst) const
-    {
-        if (from.size() == to.size()) {
-            QList<QPointF> points = src.points();
-            int size = src.points().size();
-            if (!points.contains(QPointF(-1,-1)) && Common::Max(from) < size && Common::Max(to) < size) {
-                for (int i=0; i<from.size(); i++) {
-                    std::swap(points[from[i]],points[to[i]]);
-                }
-                dst.setPoints(points);
-            }
-        } else qFatal("Inconsistent sizes for to and from index lists.");
-    }
-};
-
-BR_REGISTER(Transform, ReorderPointsTransform)
-
-} // namespace br
-
-#include "template.moc"
diff --git a/openbr/plugins/turk.cpp b/openbr/plugins/turk.cpp
deleted file mode 100644
index e079559..0000000
--- a/openbr/plugins/turk.cpp
+++ /dev/null
@@ -1,307 +0,0 @@
-#include "openbr_internal.h"
-#include "openbr/core/common.h"
-#include "openbr/core/opencvutils.h"
-#include "openbr/core/qtutils.h"
-
-namespace br
-{
-
-/*!
- * \ingroup galleries
- * \brief For Amazon Mechanical Turk datasets
- * \author Scott Klum \cite sklum
- */
-class turkGallery : public Gallery
-{
-    Q_OBJECT
-
-    struct Attribute : public QStringList
-    {
-        QString name;
-        Attribute(const QString &str = QString())
-        {
-            const int i = str.indexOf('[');
-            name = str.mid(0, i);
-            if (i != -1)
-                append(str.mid(i+1, str.length()-i-2).split(","));
-        }
-
-        Attribute normalized() const
-        {
-            bool ok;
-            QList<float> values;
-            foreach (const QString &value, *this) {
-                values.append(value.toFloat(&ok));
-                if (!ok)
-                    qFatal("Can't normalize non-numeric vector!");
-            }
-
-            Attribute normal(name);
-            float sum = Common::Sum(values);
-            if (sum == 0) sum = 1;
-            for (int i=0; i<values.size(); i++)
-                normal.append(QString::number(values[i] / sum));
-            return normal;
-        }
-    };
-
-    TemplateList readBlock(bool *done)
-    {
-        *done = true;
-        QStringList lines = QtUtils::readLines(file);
-        QList<Attribute> headers;
-        if (!lines.isEmpty())
-            foreach (const QString &header, parse(lines.takeFirst()))
-                headers.append(header);
-
-        TemplateList templates;
-        foreach (const QString &line, lines) {
-            QStringList words = parse(line);
-            if (words.size() != headers.size())
-                qFatal("turkGallery invalid column count");
-
-            File f;
-            f.name = words[0];
-            f.set("Label", words[0].mid(0,5));
-
-            for (int i=1; i<words.size(); i++) {
-                Attribute ratings = Attribute(words[i]).normalized();
-                if (headers[i].size() != ratings.size())
-                    qFatal("turkGallery invalid attribute count");
-                for (int j=0; j<ratings.size(); j++)
-                    f.set(headers[i].name + "_" + headers[i][j], ratings[j]);
-            }
-            templates.append(f);
-        }
-
-        return templates;
-    }
-
-    void write(const Template &)
-    {
-        qFatal("turkGallery write not implemented.");
-    }
-};
-
-BR_REGISTER(Gallery, turkGallery)
-
-/*!
- * \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)
-
-/*!
- * \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)
-
-/*!
- * \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 "turk.moc"
diff --git a/openbr/plugins/frames.cpp b/openbr/plugins/video/aggregate.cpp
index 100df34..b67d6a4 100644
--- a/openbr/plugins/frames.cpp
+++ b/openbr/plugins/video/aggregate.cpp
@@ -1,4 +1,20 @@
-#include "openbr_internal.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>
 
 namespace br
 {
@@ -56,33 +72,6 @@ private:
 
 BR_REGISTER(Transform, AggregateFrames)
 
-/*!
- * \ingroup transforms
- * \brief Only use one frame every n frames.
- * \author Austin Blanton \cite imaus10
- *
- * For a video with m frames, DropFrames will pass on m/n frames.
- */
-class DropFrames : public UntrainableMetaTransform
-{
-    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 TemplateList &src, TemplateList &dst) const
-    {
-        if (src.first().file.get<int>("FrameNumber") % n != 0) return;
-        dst = src;
-    }
-
-    void project(const Template &src, Template &dst) const
-    {
-        (void) src; (void) dst; qFatal("shouldn't be here");
-    }
-};
-
-BR_REGISTER(Transform, DropFrames)
-
 } // namespace br
 
-#include "frames.moc"
+#include "video/aggregate.moc"
diff --git a/openbr/plugins/video/drop.cpp b/openbr/plugins/video/drop.cpp
new file mode 100644
index 0000000..29e3d23
--- /dev/null
+++ b/openbr/plugins/video/drop.cpp
@@ -0,0 +1,51 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * 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 Only use one frame every n frames.
+ * \author Austin Blanton \cite imaus10
+ *
+ * For a video with m frames, DropFrames will pass on m/n frames.
+ */
+class DropFrames : public UntrainableMetaTransform
+{
+    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 TemplateList &src, TemplateList &dst) const
+    {
+        if (src.first().file.get<int>("FrameNumber") % n != 0) return;
+        dst = src;
+    }
+
+    void project(const Template &src, Template &dst) const
+    {
+        (void) src; (void) dst; qFatal("shouldn't be here");
+    }
+};
+
+BR_REGISTER(Transform, DropFrames)
+
+} // namespace br
+
+#include "video/drop.moc"
diff --git a/openbr/plugins/motion.cpp b/openbr/plugins/video/opticalflow.cpp
index 4511336..32bd3a8 100644
--- a/openbr/plugins/motion.cpp
+++ b/openbr/plugins/video/opticalflow.cpp
@@ -1,7 +1,24 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * 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/video/tracking.hpp>
 #include <opencv2/video/background_segm.hpp>
-#include "openbr_internal.h"
-#include "openbr/core/opencvutils.h"
+
+#include <openbr/plugins/openbr_internal.h>
+#include <openbr/core/opencvutils.h>
 
 using namespace cv;
 
@@ -59,48 +76,6 @@ class OpticalFlowTransform : public UntrainableMetaTransform
 
 BR_REGISTER(Transform, OpticalFlowTransform)
 
-/*!
- * \ingroup transforms
- * \brief Wraps OpenCV's BackgroundSubtractorMOG2 and puts the foreground mask in the Template metadata.
- * \author Austin Blanton \cite imaus10
- */
-class SubtractBackgroundTransform : public TimeVaryingTransform
-{
-    Q_OBJECT
-
-    // TODO: This is broken.
-    // BackgroundSubtractorMOG2 mog;
-
-public:
-    SubtractBackgroundTransform() : TimeVaryingTransform(false, false) {}
-
-private:
-    void projectUpdate(const Template &src, Template &dst)
-    {
-        dst = src;
-        Mat mask;
-        // TODO: broken
-        // mog(src, mask);
-        erode(mask, mask, Mat());
-        dilate(mask, mask, Mat());
-        dst.file.set("Mask", QVariant::fromValue(mask));
-    }
-
-    void project(const Template &src, Template &dst) const
-    {
-        (void) src; (void) dst; qFatal("no way");
-    }
-
-    void finalize(TemplateList &output)
-    {
-        (void) output;
-        // TODO: Broken
-        // mog = BackgroundSubtractorMOG2();
-    }
-};
-
-BR_REGISTER(Transform, SubtractBackgroundTransform)
-
 } // namespace br
 
-#include "motion.moc"
+#include "video/opticalflow.moc"
diff --git a/openbr/universal_template.cpp b/openbr/universal_template.cpp
index 79731ac..1681615 100644
--- a/openbr/universal_template.cpp
+++ b/openbr/universal_template.cpp
@@ -8,7 +8,7 @@
 
 #include "universal_template.h"
 
-br_utemplate br_new_utemplate(const char *imageID, int32_t algorithmID, uint32_t x, uint32_t y, uint32_t width, uint32_t height, uint32_t label, const char *url, const char *fv, uint32_t fvSize)
+br_utemplate br_new_utemplate(const char *imageID, int32_t algorithmID, int32_t x, int32_t y, uint32_t width, uint32_t height, uint32_t label, const char *url, const char *fv, uint32_t fvSize)
 {
     const uint32_t urlSize = strlen(url) + 1;
     br_utemplate utemplate = (br_utemplate) malloc(sizeof(br_universal_template) + urlSize + fvSize);
@@ -52,7 +52,7 @@ static void callAndFree(br_utemplate_callback callback, br_utemplate t, br_callb
     free(t);
 }
 
-static bool read_buffer(FILE *file, char *buffer, size_t bytes, bool eofAllowed)
+static bool read_buffer(FILE *file, char *buffer, size_t bytes)
 {
     size_t bytesRemaining = bytes;
     while (bytesRemaining) {
@@ -61,7 +61,9 @@ static bool read_buffer(FILE *file, char *buffer, size_t bytes, bool eofAllowed)
         bytesRemaining -= bytesRead;
 
         if (feof(file)) {
-            if (eofAllowed && (bytesRemaining == bytes))
+            if ((bytesRemaining != bytes) && !fseek(file, bytesRemaining - bytes, SEEK_CUR)) // Try to rewind
+                bytesRemaining = bytes;
+            if (bytesRemaining == bytes)
                 return false;
             qFatal("End of file after reading %d of %d bytes.", int(bytes - bytesRemaining), int(bytes));
         }
@@ -74,24 +76,34 @@ static bool read_buffer(FILE *file, char *buffer, size_t bytes, bool eofAllowed)
     return true;
 }
 
-void br_iterate_utemplates_file(FILE *file, br_utemplate_callback callback, br_callback_context context, bool parallel)
+int br_iterate_utemplates_file(FILE *file, br_utemplate_callback callback, br_callback_context context, bool parallel)
 {
+    int count = 0;
     QFutureSynchronizer<void> futures;
     while (true) {
         br_utemplate t = (br_utemplate) malloc(sizeof(br_universal_template));
 
-        if (!read_buffer(file, (char*) t, sizeof(br_universal_template), true)) {
+        if (!read_buffer(file, (char*) t, sizeof(br_universal_template))) {
             free(t);
-            return;
+            break;
         }
 
         t = (br_utemplate) realloc(t, sizeof(br_universal_template) + t->urlSize + t->fvSize);
-        read_buffer(file, (char*) &t->data, t->urlSize + t->fvSize, false);
+        if (!read_buffer(file, (char*) &t->data, t->urlSize + t->fvSize)) {
+            free(t);
+
+            // Try to rewind header read
+            if (fseek(file, -sizeof(br_universal_template), SEEK_CUR))
+                qFatal("Unable to recover from partial template read!");
+
+            break;
+        }
 
         if (parallel) futures.addFuture(QtConcurrent::run(callAndFree, callback, t, context));
         else          callAndFree(callback, t, context);
+        count++;
     }
-    futures.waitForFinished();
+    return count;
 }
 
 void br_log(const char *message)
diff --git a/openbr/universal_template.h b/openbr/universal_template.h
index 979871d..edb90d4 100644
--- a/openbr/universal_template.h
+++ b/openbr/universal_template.h
@@ -37,8 +37,8 @@ struct br_universal_template
 {
     unsigned char imageID[16]; /*!< MD5 hash of the undecoded origin file. */
     int32_t  algorithmID; /*!< interpretation of _data_ after _urlSize_. */
-    uint32_t x;      /*!< region of interest horizontal offset (pixels). */
-    uint32_t y;      /*!< region of interest vertical offset (pixels). */
+    int32_t x;      /*!< region of interest horizontal offset (pixels). */
+    int32_t y;      /*!< region of interest vertical offset (pixels). */
     uint32_t width;  /*!< region of interest horizontal size (pixels). */
     uint32_t height; /*!< region of interest vertical size (pixels). */
     uint32_t label; /*!< supervised training class or manually annotated ground truth. */
@@ -57,7 +57,7 @@ typedef const struct br_universal_template *br_const_utemplate;
  * \brief br_universal_template constructor.
  * \see br_free_utemplate
  */
-BR_EXPORT br_utemplate br_new_utemplate(const char *imageID, int32_t algorithmID, uint32_t x, uint32_t y, uint32_t width, uint32_t height, uint32_t label, const char *url, const char *fv, uint32_t fvSize);
+BR_EXPORT br_utemplate br_new_utemplate(const char *imageID, int32_t algorithmID, int32_t x, int32_t y, uint32_t width, uint32_t height, uint32_t label, const char *url, const char *fv, uint32_t fvSize);
 
 /*!
  * \brief br_universal_template destructor.
@@ -86,9 +86,10 @@ BR_EXPORT void br_iterate_utemplates(br_const_utemplate begin, br_const_utemplat
 
 /*!
  * \brief Iterate over br_universal_template in a file.
+ * \return The number of templates iterated
  * \see br_iterate_utemplates
  */
-BR_EXPORT void br_iterate_utemplates_file(FILE *file, br_utemplate_callback callback, br_callback_context context, bool parallel);
+BR_EXPORT int br_iterate_utemplates_file(FILE *file, br_utemplate_callback callback, br_callback_context context, bool parallel);
 
 /*!
  * \brief Write a message annotated with the current time to stderr.
diff --git a/scripts/matlab/writeUT.m b/scripts/matlab/writeUT.m
new file mode 100644
index 0000000..8399383
--- /dev/null
+++ b/scripts/matlab/writeUT.m
@@ -0,0 +1,154 @@
+function writeUT(handle, matrix, imageID, roi_x, roi_y, roi_width, roi_height, label, url)
+% write a single matrix of supported datatype (i.e. not int32) to the file
+% handle in UT format, algorithmID 7
+% inputs: file handle, single layer matrix, imageID (16 char md5 hash, can
+% be empty, in which case we generated a null 16 byte string), roix, roiy,
+% roiw, roih (bounding box of matrix roi), label (class label for training)
+% and url (can be empty)
+% 
+% computed values: fvSize, urlSize (url encoded as null-terminated 8-bit
+% string, urlSize includes null terminator), a null terminator will be
+% added to url by this function
+%
+% For performance reasons, handle should be opened in 'W', i.e. buffered
+% mode.
+
+% 512 -- max supported channels in cv::Mat
+if (size(matrix,3) > 512)
+    disp('Cannot serialize matrix, 512 is the max depth supported');
+    return;
+end
+
+
+% UT format; 
+% struct br_universal_template 
+% { 
+%     unsigned char imageID[16]; /*!< MD5 hash of the undecoded origin file. */ 
+%     int32_t  algorithmID; /*!< interpretation of _data_ after _urlSize_. */ 
+%     int32_t x;      /*!< region of interest horizontal offset (pixels). */ 
+%     int32_t y;      /*!< region of interest vertical offset (pixels). */ 
+%     uint32_t width;  /*!< region of interest horizontal size (pixels). */ 
+%     uint32_t height; /*!< region of interest vertical size (pixels). */ 
+%     uint32_t label; /*!< supervised training class or manually annotated ground truth. */ 
+%     uint32_t urlSize; /*!< length of null-terminated URL at the beginning of _data_, 
+%                            including the null-terminator character. */ 
+%     uint32_t fvSize; /*!< length of the feature vector after the URL in _data_. */ 
+%     unsigned char data[]; /*!< (_urlSize_ + _fvSize_)-byte buffer. 
+%                                The first _urlSize_ bytes represent the URL. 
+%                                The remaining _fvSize_ bytes represent the feature vector. */ 
+% }; 
+
+% algorithm 7 binary data format:
+% uint16 datatype code (copied from opencv, base datatype codes, single
+% channel is assumed)
+% uint32 matrix rows
+% uint32 matrix cols
+% uint16 channel count (max valid is 512)
+% channels->rows->columns
+
+% opencv data type definitions 
+% #define CV_8U   0
+% #define CV_8S   1
+% #define CV_16U  2
+% #define CV_16S  3
+% #define CV_32S  4
+% #define CV_32F  5
+% #define CV_64F  6
+% #define CV_USRTYPE1 7
+
+if (numel(imageID) ~= 16)
+    imageID = uint8(zeros(16,1));
+end
+
+% fixed for this function 
+algorithmID = 7;
+
+% append null terminator
+url = [url, '\0'];
+% calculate complete string length
+urlSize = uint32(length(url));
+
+% figure out datatype code based on the input matrix's data type
+matlab_type = class(matrix(1,1));
+
+type_code = uint32(0);
+% bytes per element
+typeSize = 1;
+
+switch(matlab_type)
+    case 'uint8'
+        type_code = 0;
+        typeSize = 1;
+    case 'int8'
+        type_code = 1;
+        typeSize = 1;
+    case 'uint16'
+        type_code = 2;
+        typeSize = 2;
+    case 'int16'
+        type_code = 3;
+        typeSize = 2;
+    case 'uint32'
+        disp(' uint32 datatype not supported, please try again');
+        return;
+    case 'int32'
+        type_code = 4;
+        typeSize = 4;
+        
+    case 'single'
+        type_code = 5;
+        typeSize = 4;
+    case 'double'
+        type_code = 6;
+        typeSize = 8;
+    otherwise
+        disp(['Unrecognized matlab datatype, ', matlab_type]);
+        return;
+end
+
+% total size of feature vecotr in bytes, plus 12 byte header encoding
+% [uint32 datatype, copied from opencv codes; uint32(matrix width);
+% uint32(matrix height)]
+fvSize = uint32(typeSize * numel(matrix) + 4*3);
+
+% imageID
+fwrite(handle, imageID, 'uint8');
+
+% algorithmID
+fwrite(handle, algorithmID, 'int32');
+
+% roi x
+fwrite(handle, roi_x, 'uint32');
+% roi y
+fwrite(handle, roi_y, 'uint32');
+% roi width
+fwrite(handle, roi_width, 'uint32');
+
+% roi height
+fwrite(handle, roi_height, 'uint32');
+
+% label
+fwrite(handle, label, 'uint32');
+
+% url size 
+fwrite(handle, urlSize, 'uint32');
+
+% feature vector size
+fwrite(handle, fvSize, 'uint32');
+
+% url (just writing a single null byte)
+fwrite(handle, url, 'uint8');
+
+% binary data header -- datatype code, row count, col count, channel count
+% (max 512). Datatype and channel count are uint16, dimensions are uint32
+fwrite(handle, type_code,'uint16');
+fwrite(handle, uint32(size(matrix,1)), 'uint32');
+fwrite(handle, uint32(size(matrix,2)), 'uint32');
+fwrite(handle, uint16(size(matrix,3)), 'uint16');
+
+% write data, explicit row-major enumeration, matrix(:) is col-major,
+% followed by depth. By permuting the dimensions, we can put the bytes in
+% an appropriate order:
+permuted = permute(matrix,[3,2,1]);
+
+fwrite(handle, permuted(:), matlab_type);
diff --git a/scripts/matlab/writeUTFVectors.m b/scripts/matlab/writeUTFVectors.m
new file mode 100644
index 0000000..5c40bc5
--- /dev/null
+++ b/scripts/matlab/writeUTFVectors.m
@@ -0,0 +1,18 @@
+function writeUTFVectors(handle, fvectors)
+% write the rows of fvectors as separate ut format 7 templates. Dummy
+% values will be used for roi settings/imageID/url/etc.
+% handle will not be opened/closed by this function.
+% 
+% see also writeUT
+
+dummy_ID = [];
+roi_x = uint32(0);
+roi_y = uint32(0);
+roi_width = uint32(0);
+roi_height = uint32(0);
+label = uint32(0);
+
+urlTotal = '';
+for i = 1:size(fvectors,1)
+    writeUT(handle, fvectors(i,:), dummy_ID, roi_x, roi_y, roi_width, roi_height, label, urlTotal);
+end
diff --git a/share/openbr/cmake/FindLibAV.cmake b/share/openbr/cmake/FindLibAV.cmake
new file mode 100644
index 0000000..8aa31e1
--- /dev/null
+++ b/share/openbr/cmake/FindLibAV.cmake
@@ -0,0 +1,200 @@
+# Module for locating libav.
+#
+# Customizable variables:
+#   LIBAV_ROOT_DIR
+#     Specifies libav's root directory.
+#
+# Read-only variables:
+#   LIBAV_FOUND
+#     Indicates whether the library has been found.
+#
+#   LIBAV_INCLUDE_DIRS
+#      Specifies libav's include directory.
+#
+#   LIBAV_LIBRARIES
+#     Specifies libav libraries that should be passed to target_link_libararies.
+#
+#   LIBAV_<COMPONENT>_LIBRARIES
+#     Specifies the libraries of a specific <COMPONENT>.
+#
+#   LIBAV_<COMPONENT>_FOUND
+#     Indicates whether the specified <COMPONENT> was found.
+#
+#
+# Copyright (c) 2012 Sergiu Dotenco
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in all
+# copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTLIBAVLAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+# SOFTWARE.
+
+INCLUDE (FindPackageHandleStandardArgs)
+
+IF (CMAKE_VERSION VERSION_GREATER 2.8.7)
+  SET (_LIBAV_CHECK_COMPONENTS FALSE)
+ELSE (CMAKE_VERSION VERSION_GREATER 2.8.7)
+  SET (_LIBAV_CHECK_COMPONENTS TRUE)
+ENDIF (CMAKE_VERSION VERSION_GREATER 2.8.7)
+
+FIND_PATH (LIBAV_ROOT_DIR
+  NAMES include/libavcodec/avcodec.h
+        include/libavdevice/avdevice.h
+        include/libavfilter/avfilter.h
+        include/libavutil/avutil.h
+        include/libswscale/swscale.h
+  PATHS ENV LIBAVROOT
+  DOC "libav root directory")
+
+FIND_PATH (LIBAV_INCLUDE_DIR
+  NAMES libavcodec/avcodec.h
+        libavdevice/avdevice.h
+        libavfilter/avfilter.h
+        libavutil/avutil.h
+        libswscale/swscale.h
+  HINTS ${LIBAV_ROOT_DIR}
+  PATH_SUFFIXES include
+  DOC "libav include directory")
+
+if (NOT LibAV_FIND_COMPONENTS)
+  set (LibAV_FIND_COMPONENTS avcodec avdevice avfilter avformat avutil swscale)
+endif (NOT LibAV_FIND_COMPONENTS)
+
+FOREACH (_LIBAV_COMPONENT ${LibAV_FIND_COMPONENTS})
+  STRING (TOUPPER ${_LIBAV_COMPONENT} _LIBAV_COMPONENT_UPPER)
+  SET (_LIBAV_LIBRARY_BASE LIBAV_${_LIBAV_COMPONENT_UPPER}_LIBRARY)
+
+  FIND_LIBRARY (${_LIBAV_LIBRARY_BASE}
+    NAMES ${_LIBAV_COMPONENT}
+    HINTS ${LIBAV_ROOT_DIR}
+    PATH_SUFFIXES bin lib
+    DOC "libav ${_LIBAV_COMPONENT} library")
+
+  MARK_AS_ADVANCED (${_LIBAV_LIBRARY_BASE})
+
+  SET (LIBAV_${_LIBAV_COMPONENT_UPPER}_FOUND TRUE)
+  SET (LibAV_${_LIBAV_COMPONENT}_FOUND ${LIBAV_${_LIBAV_COMPONENT_UPPER}_FOUND})
+
+  IF (${_LIBAV_LIBRARY_BASE})
+    # setup the LIBAV_<COMPONENT>_LIBRARIES variable
+    SET (LIBAV_${_LIBAV_COMPONENT_UPPER}_LIBRARIES ${${_LIBAV_LIBRARY_BASE}})
+    LIST (APPEND LIBAV_LIBRARIES ${LIBAV_${_LIBAV_COMPONENT_UPPER}_LIBRARIES})
+    LIST (APPEND _LIBAV_ALL_LIBS ${${_LIBAV_LIBRARY_BASE}})
+  ELSE (${_LIBAV_LIBRARY_BASE})
+    LIST (APPEND _LIBAV_MISSING_LIBRARIES ${_LIBAV_LIBRARY_BASE})
+  ENDIF (${_LIBAV_LIBRARY_BASE})
+ENDFOREACH (_LIBAV_COMPONENT ${LibAV_FIND_COMPONENTS})
+
+SET (LIBAV_INCLUDE_DIRS ${LIBAV_INCLUDE_DIR})
+
+IF (DEFINED _LIBAV_MISSING_COMPONENTS AND _LIBAV_CHECK_COMPONENTS)
+  IF (NOT LibAV_FIND_QUIETLY)
+    MESSAGE (STATUS "One or more libav components were not found:")
+    # Display missing components indented, each on a separate line
+    FOREACH (_LIBAV_MISSING_COMPONENT ${_LIBAV_MISSING_COMPONENTS})
+      MESSAGE (STATUS "  " ${_LIBAV_MISSING_COMPONENT})
+    ENDFOREACH (_LIBAV_MISSING_COMPONENT ${_LIBAV_MISSING_COMPONENTS})
+  ENDIF (NOT LibAV_FIND_QUIETLY)
+ENDIF (DEFINED _LIBAV_MISSING_COMPONENTS AND _LIBAV_CHECK_COMPONENTS)
+
+# Determine library's version
+
+FIND_PROGRAM (LIBAV_AVCONV_EXECUTABLE NAMES avconv
+  HINTS ${LIBAV_ROOT_DIR}
+  PATH_SUFFIXES bin
+  DOC "avconv executable")
+
+IF (LIBAV_AVCONV_EXECUTABLE)
+  EXECUTE_PROCESS (COMMAND ${LIBAV_AVCONV_EXECUTABLE} -version
+    OUTPUT_VARIABLE _LIBAV_AVCONV_OUTPUT ERROR_QUIET)
+
+  STRING (REGEX REPLACE ".*avconv[ \t]+([0-9]+\\.[0-9]+\\.[0-9]+).*" "\\1"
+    LIBAV_VERSION "${_LIBAV_AVCONV_OUTPUT}")
+  STRING (REGEX REPLACE "([0-9]+)\\.([0-9]+)\\.([0-9]+)" "\\1"
+    LIBAV_VERSION_MAJOR "${LIBAV_VERSION}")
+  STRING (REGEX REPLACE "([0-9]+)\\.([0-9]+)\\.([0-9]+)" "\\2"
+    LIBAV_VERSION_MINOR "${LIBAV_VERSION}")
+  STRING (REGEX REPLACE "([0-9]+)\\.([0-9]+)\\.([0-9]+)" "\\3"
+    LIBAV_VERSION_PATCH "${LIBAV_VERSION}")
+
+  SET (LIBAV_VERSION_COMPONENTS 3)
+ENDIF (LIBAV_AVCONV_EXECUTABLE)
+
+IF (WIN32)
+  FIND_PROGRAM (LIB_EXECUTABLE NAMES lib
+    HINTS "$ENV{VS110COMNTOOLS}/../../VC/bin"
+          "$ENV{VS100COMNTOOLS}/../../VC/bin"
+          "$ENV{VS90COMNTOOLS}/../../VC/bin"
+          "$ENV{VS71COMNTOOLS}/../../VC/bin"
+          "$ENV{VS80COMNTOOLS}/../../VC/bin"
+    DOC "Library manager")
+
+  MARK_AS_ADVANCED (LIB_EXECUTABLE)
+ENDIF (WIN32)
+
+MACRO (GET_LIB_REQUISITES LIB REQUISITES)
+  IF (LIB_EXECUTABLE)
+    GET_FILENAME_COMPONENT (_LIB_PATH ${LIB_EXECUTABLE} PATH)
+
+    EXECUTE_PROCESS (COMMAND ${LIB_EXECUTABLE} /nologo /list ${LIB}
+      WORKING_DIRECTORY ${_LIB_PATH}/../../Common7/IDE
+      OUTPUT_VARIABLE _LIB_OUTPUT ERROR_QUIET)
+
+    STRING (REPLACE "\n" ";" "${REQUISITES}" "${_LIB_OUTPUT}")
+    LIST (REMOVE_DUPLICATES ${REQUISITES})
+  ENDIF (LIB_EXECUTABLE)
+ENDMACRO (GET_LIB_REQUISITES)
+
+IF (_LIBAV_ALL_LIBS)
+  # collect lib requisites using the lib tool
+  FOREACH (_LIBAV_COMPONENT ${_LIBAV_ALL_LIBS})
+    GET_LIB_REQUISITES (${_LIBAV_COMPONENT} _LIBAV_REQUISITES)
+  ENDFOREACH (_LIBAV_COMPONENT)
+ENDIF (_LIBAV_ALL_LIBS)
+
+IF (NOT LIBAV_BINARY_DIR)
+  SET (_LIBAV_UPDATE_BINARY_DIR TRUE)
+ELSE (NOT LIBAV_BINARY_DIR)
+  SET (_LIBAV_UPDATE_BINARY_DIR FALSE)
+ENDIF (NOT LIBAV_BINARY_DIR)
+
+SET (_LIBAV_BINARY_DIR_HINTS bin)
+
+IF (_LIBAV_REQUISITES)
+  FIND_FILE (LIBAV_BINARY_DIR NAMES ${_LIBAV_REQUISITES}
+	  HINTS ${LIBAV_ROOT_DIR}
+    PATH_SUFFIXES ${_LIBAV_BINARY_DIR_HINTS} NO_DEFAULT_PATH)
+ENDIF (_LIBAV_REQUISITES)
+
+IF (LIBAV_BINARY_DIR AND _LIBAV_UPDATE_BINARY_DIR)
+  SET (_LIBAV_BINARY_DIR ${LIBAV_BINARY_DIR})
+  UNSET (LIBAV_BINARY_DIR CACHE)
+
+  IF (_LIBAV_BINARY_DIR)
+	GET_FILENAME_COMPONENT (LIBAV_BINARY_DIR ${_LIBAV_BINARY_DIR} PATH)
+  ENDIF (_LIBAV_BINARY_DIR)
+ENDIF (LIBAV_BINARY_DIR AND _LIBAV_UPDATE_BINARY_DIR)
+
+SET (LIBAV_BINARY_DIR ${LIBAV_BINARY_DIR} CACHE PATH "libav binary directory")
+
+MARK_AS_ADVANCED (LIBAV_INCLUDE_DIR LIBAV_BINARY_DIR)
+
+IF (NOT _LIBAV_CHECK_COMPONENTS)
+ SET (_LIBAV_FPHSA_ADDITIONAL_ARGS HANDLE_COMPONENTS)
+ENDIF (NOT _LIBAV_CHECK_COMPONENTS)
+
+FIND_PACKAGE_HANDLE_STANDARD_ARGS (LibAV REQUIRED_VARS LIBAV_ROOT_DIR
+  LIBAV_INCLUDE_DIR ${_LIBAV_MISSING_LIBRARIES} VERSION_VAR LIBAV_VERSION
+  ${_LIBAV_FPHSA_ADDITIONAL_ARGS})
\ No newline at end of file
diff --git a/share/openbr/cmake/FindStasm4.cmake b/share/openbr/cmake/FindStasm4.cmake
index 43fda3b..6b1de04 100644
--- a/share/openbr/cmake/FindStasm4.cmake
+++ b/share/openbr/cmake/FindStasm4.cmake
@@ -8,13 +8,9 @@
 #   target_link_libraries(MY_TARGET ${Stasm4_LIBS})
 # ================================================================
 
-find_path(Stasm_DIR stasm/stasm_lib.h ${CMAKE_SOURCE_DIR}/3rdparty/*)
-
-add_subdirectory(${Stasm_DIR} ${Stasm_DIR}/build)
-
-set(SRC ${SOURCE};${SRC})
-
+find_path(Stasm_DIR stasm/stasm_lib.h ${CMAKE_SOURCE_DIR}/3rdparty/* NO_DEFAULT_PATH)
+mark_as_advanced(Stasm_DIR)
 include_directories(${Stasm_DIR}/stasm)
-link_directories(${Stasm_DIR}/build)
-
-set(Stasm4_LIBS stasm)
+include_directories(${Stasm_DIR}/stasm/MOD_1)
+file(GLOB Stasm_SRC "${Stasm_DIR}/stasm/*.cpp")
+file(GLOB Stasm_SRC ${Stasm_SRC} "${Stasm_DIR}/stasm/MOD_1/*.cpp")
diff --git a/share/openbr/cmake/InstallDependencies.cmake b/share/openbr/cmake/InstallDependencies.cmake
index 673b9d8..05d74c3 100644
--- a/share/openbr/cmake/InstallDependencies.cmake
+++ b/share/openbr/cmake/InstallDependencies.cmake
@@ -12,11 +12,16 @@ function(install_opencv_library lib)
       endif()
       list(GET OpenCV_LIB_DIR 0 cv_lib_stripped)
       install(FILES ${cv_lib_stripped}/../bin/${BR_INSTALL_DEPENDENCIES_PREFIX}${lib}${OpenCV_VERSION_MAJOR}${OpenCV_VERSION_MINOR}${OpenCV_VERSION_PATCH}${BR_INSTALL_DEPENDENCIES_SUFFIX}.dll DESTINATION bin)
-    else()
+    elseif(CMAKE_HOST_APPLE)
       set(OpenCV_LIB_DIR "/usr/local/lib")
       install(FILES ${OpenCV_LIB_DIR}/lib${lib}.${OpenCV_VERSION_MAJOR}.${OpenCV_VERSION_MINOR}.${OpenCV_VERSION_PATCH}${CMAKE_SHARED_LIBRARY_SUFFIX} DESTINATION lib)
       install(FILES ${OpenCV_LIB_DIR}/lib${lib}.${OpenCV_VERSION_MAJOR}.${OpenCV_VERSION_MINOR}${CMAKE_SHARED_LIBRARY_SUFFIX} DESTINATION lib)
       install(FILES ${OpenCV_LIB_DIR}/lib${lib}${CMAKE_SHARED_LIBRARY_SUFFIX} DESTINATION lib)
+    else()
+      set(OpenCV_LIB_DIR "/usr/local/lib")
+      install(FILES ${OpenCV_LIB_DIR}/lib${lib}${CMAKE_SHARED_LIBRARY_SUFFIX}.${OpenCV_VERSION_MAJOR}.${OpenCV_VERSION_MINOR}.${OpenCV_VERSION_PATCH} DESTINATION lib)
+      install(FILES ${OpenCV_LIB_DIR}/lib${lib}${CMAKE_SHARED_LIBRARY_SUFFIX}.${OpenCV_VERSION_MAJOR}.${OpenCV_VERSION_MINOR} DESTINATION lib)
+      install(FILES ${OpenCV_LIB_DIR}/lib${lib}${CMAKE_SHARED_LIBRARY_SUFFIX} DESTINATION lib)
     endif()
   endif()
 endfunction()
@@ -59,9 +64,12 @@ function(install_qt_imageformats)
     if(CMAKE_HOST_WIN32)
       set(INSTALL_DEPENDENCIES_PREFIX "")
       set(INSTALL_DEPENDENCIES_EXTENSION ".dll")
-    else()
+    elseif(CMAKE_HOST_APPLE)
       set(INSTALL_DEPENDENCIES_PREFIX "lib")
       set(INSTALL_DEPENDENCIES_EXTENSION ".dylib")
+    else()
+      set(INSTALL_DEPENDENCIES_PREFIX "lib")
+      set(INSTALL_DEPENDENCIES_EXTENSION ".so")
     endif()
     install(FILES ${IMAGE_FORMATS_DIR}/${INSTALL_DEPENDENCIES_PREFIX}qgif${INSTALL_DEPENDENCIES_EXTENSION}
                   ${IMAGE_FORMATS_DIR}/${INSTALL_DEPENDENCIES_PREFIX}qico${INSTALL_DEPENDENCIES_EXTENSION}