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

Brendan Klare
2 parents a9fbb83e 5b3c7a8e
Showing 37 changed files with 468 additions and 1671 deletions
CHANGELOG.md
app/br/br.cpp
openbr/core/plot.cpp
openbr/core/plot.h
openbr/core/resource.h
openbr/openbr.cpp
openbr/openbr.h
openbr/openbr_plugin.cpp
openbr/plugins/algorithms.cpp
openbr/plugins/crop.cpp
openbr/plugins/eigen3.cpp
openbr/plugins/fst3.cmake
openbr/plugins/fst3.cpp
openbr/plugins/gui.cpp
openbr/plugins/keypoint.cpp
openbr/plugins/meta.cpp
openbr/plugins/misc.cpp
openbr/plugins/openbr_internal.h
openbr/plugins/phash.cmake
openbr/plugins/phash.cpp
 0.4.0 - ??/??/??
 ================
+* Added -evalLandmarking and -plotLandmarking for evaluating and plotting landmarking accuracy (#9)
 * Added -evalDetection and -plotDetection for evaluating and plotting object detection accuracy (#9)
 * Deprecated Transform::backProject
  
@@ -146,6 +146,9 @@ public:
             } else if (!strcmp(fun, "plotDetection")) {
                 check(parc >= 2, "Incorrect parameter count for 'plotDetection'.");
                 br_plot_detection(parc-1, parv, parv[parc-1], true);
+            } else if (!strcmp(fun, "plotLandmarking")) {
+                check(parc >= 2, "Incorrect parameter count for 'plotLandmarking'.");
+                br_plot_landmarking(parc-1, parv, parv[parc-1], true);
             } else if (!strcmp(fun, "plotMetadata")) {
                 check(parc >= 2, "Incorrect parameter count for 'plotMetadata'.");
                 br_plot_metadata(parc-1, parv, parv[parc-1], true);
@@ -224,6 +227,7 @@ private:
                "-evalLandmarking <predicted_gallery> <truth_gallery> [{csv} [<normalization_index_a> <normalization_index_b>]]\n"
                "-evalRegression <predicted_gallery> <truth_gallery> <predicted property name> <ground truth property name>\n"
                "-plotDetection <file> ... <file> {destination}\n"
+               "-plotLandmarking <file> ... <file> {destination}\n"
                "-plotMetadata <file> ... <file> <columns>\n"
                "-getHeader <matrix>\n"
                "-setHeader {<matrix>} <target_gallery> <query_gallery>\n"
@@ -228,7 +228,7 @@ bool Plot(const QStringList &amp;files, const File &amp;destination, bool show)
                             QString(", xlab=\"False Accept Rate\", ylab=\"True Accept Rate\") + theme_minimal()") +
                             (p.major.size > 1 ? getScale("colour", p.major.header, p.major.size) : QString()) +
                             (p.minor.size > 1 ? QString(" + scale_linetype_discrete(\"%1\")").arg(p.minor.header) : QString()) +
-                            QString(" + scale_x_log10(labels=percent) + scale_y_continuous(labels=percent) + annotation_logticks(sides=\"b\")\n\n")));
+                            QString(" + scale_x_log10(labels=percent, limits=c(min(DET$X),1)) + scale_y_continuous(labels=percent) + annotation_logticks(sides=\"b\")\n\n")));
  
     p.file.write(qPrintable(QString("qplot(X, Y, data=DET%1").arg((p.major.smooth || p.minor.smooth) ? ", geom=\"smooth\", method=loess, level=0.99" : ", geom=\"line\"") +
                             (p.major.size > 1 ? QString(", colour=factor(%1)").arg(p.major.header) : QString()) +
@@ -236,7 +236,7 @@ bool Plot(const QStringList &amp;files, const File &amp;destination, bool show)
                             QString(", xlab=\"False Accept Rate\", ylab=\"False Reject Rate\") + geom_abline(alpha=0.5, colour=\"grey\", linetype=\"dashed\") + theme_minimal()") +
                             (p.major.size > 1 ? getScale("colour", p.major.header, p.major.size) : QString()) +
                             (p.minor.size > 1 ? QString(" + scale_linetype_discrete(\"%1\")").arg(p.minor.header) : QString()) +
-                            QString(" + scale_x_log10(labels=percent) + scale_y_log10(labels=percent) + annotation_logticks()\n\n")));
+                            QString(" + scale_x_log10(labels=percent, limits=c(min(DET$X),1)) + scale_y_log10(labels=percent) + annotation_logticks()\n\n")));
  
     p.file.write(qPrintable(QString("qplot(X, data=SD, geom=\"histogram\", fill=Y, position=\"identity\", alpha=I(1/2)") +
                             QString(", xlab=\"Score%1\"").arg((p.flip ? p.major.size : p.minor.size) > 1 ? " / " + (p.flip ? p.major.header : p.minor.header) : QString()) +
@@ -302,7 +302,6 @@ bool filesHaveSinglePoint(const QStringList &amp;files) {
 bool PlotDetection(const QStringList &files, const File &destination, bool show)
 {
     qDebug("Plotting %d detection file(s) to %s", files.size(), qPrintable(destination));
-
     RPlot p(files, destination, false);
  
     p.file.write("# Split data into individual plots\n"
@@ -345,6 +344,27 @@ bool PlotDetection(const QStringList &amp;files, const File &amp;destination, bool show)
     return p.finalize(show);
 }
  
+bool PlotLandmarking(const QStringList &files, const File &destination, bool show)
+{
+    qDebug("Plotting %d landmarking file(s) to %s", files.size(), qPrintable(destination));
+    RPlot p(files, destination, false);
+
+    p.file.write("# Split data into individual plots\n"
+                 "plot_index = which(names(data)==\"Plot\")\n"
+                 "Box <- data[grep(\"Box\",data$Plot),-c(1)]\n"
+                 "rm(data)\n"
+                 "\n");
+
+    p.file.write(qPrintable(QString("ggplot(Box, aes(Y,%1%2))").arg(p.major.size > 1 ? QString(", colour=%1").arg(p.major.header) : QString(), p.minor.size > 1 ? QString(", linetype=%1").arg(p.minor.header) : QString()) +
+                            QString(" + annotation_logticks(sides=\"b\") + stat_ecdf() + scale_x_log10(\"Normalized Error\", breaks=c(0.001,0.01,0.1,1,10)) + scale_y_continuous(\"Cumulative Density\", label=percent) + theme_minimal()\n\n")));
+    p.file.write(qPrintable(QString("ggplot(Box, aes(factor(X), Y%1%2))").arg(p.major.size > 1 ? QString(", colour=%1").arg(p.major.header) : QString(), p.minor.size > 1 ? QString(", linetype=%1").arg(p.minor.header) : QString()) +
+                            QString("+ annotation_logticks(sides=\"l\") + geom_boxplot(alpha=0.5) + geom_jitter(size=1, alpha=0.5) + scale_x_discrete(\"Landmark\") + scale_y_log10(\"Normalized Error\", breaks=c(0.01,0.1,1,10)) + theme_minimal()\n\n")));
+    p.file.write(qPrintable(QString("ggplot(Box, aes(factor(X), Y%1%2))").arg(p.major.size > 1 ? QString(", colour=%1").arg(p.major.header) : QString(), p.minor.size > 1 ? QString(", linetype=%1").arg(p.minor.header) : QString()) +
+                            QString("+ annotation_logticks(sides=\"l\") + geom_violin(alpha=0.5) + scale_x_discrete(\"Landmark\") + scale_y_log10(\"Normalized Error\", breaks=c(0.001,0.01,0.1,1,10))\n\n")));
+
+    return p.finalize(show);
+}
+
 bool PlotMetadata(const QStringList &files, const QString &columns, bool show)
 {
     qDebug("Plotting %d metadata file(s) for columns %s", files.size(), qPrintable(columns));
@@ -26,6 +26,7 @@ namespace br
 {
     bool Plot(const QStringList &files, const File &destination, bool show = false);
     bool PlotDetection(const QStringList &files, const File &destination, bool show = false);
+    bool PlotLandmarking(const QStringList &files, const File &destination, bool show = false);
     bool PlotMetadata(const QStringList &files, const QString &destination, bool show = false);
 }
  
@@ -40,6 +40,9 @@ class DefaultResourceMaker : public ResourceMaker&lt;T&gt;
     T *make() const { return new T(); }
 };
  
+// Manage multiple copies of a limited resource in a thread-safe manner.
+// TimeVaryingTransform makes a strong assumption that ResourceMaker::Make
+// is only called in acquire, not in the constructor.
 template <typename T>
 class Resource
 {
@@ -182,6 +182,11 @@ bool br_plot_detection(int num_files, const char *files[], const char *destinati
     return PlotDetection(QtUtils::toStringList(num_files, files), destination, show);
 }
  
+bool br_plot_landmarking(int num_files, const char *files[], const char *destination, bool show)
+{
+    return PlotLandmarking(QtUtils::toStringList(num_files, files), destination, show);
+}
+
 bool br_plot_metadata(int num_files, const char *files[], const char *columns, bool show)
 {
     return PlotMetadata(QtUtils::toStringList(num_files, files), columns, show);
@@ -265,6 +265,12 @@ BR_EXPORT const char *br_objects(const char *abstractions = &quot;.*&quot;, const char *im
  * - <i>destination</i><tt>.R</tt> which is the auto-generated R script used to render the figures.
  * - <i>destination</i><tt>.pdf</tt> which has all of the figures in one file multi-page file.
  *
+ * OpenBR uses file and folder names to automatically determine the plot legend.
+ * For example, let's consider the case where three algorithms (<tt>A</tt>, <tt>B</tt>, & <tt>C</tt>) were each evaluated on two datasets (<tt>Y</tt> & <tt>Z</tt>).
+ * The suggested way to plot these experiments on the same graph is to create a folder named <tt>Algorithm_Dataset</tt> that contains the six <tt>.csv</tt> files produced by \ref br_eval: <tt>A_Y.csv</tt>, <tt>A_Z.csv</tt>, <tt>B_Y.csv</tt>, <tt>B_Z.csv</tt>, <tt>C_Y.csv</tt>, & <tt>C_Z.csv</tt>.
+ * The '<tt>_</tt>' character plays a special role in determining the legend title(s) and value(s).
+ * In this case, <tt>A</tt>, <tt>B</tt>, & <tt>C</tt> will be identified as different values of type <tt>Algorithm</tt>, and each will be assigned its own color; <tt>Y</tt> & <tt>Z</tt> will be identified as different values of type Dataset, and each will be assigned its own line style.
+ *
  * \param num_files Number of <tt>.csv</tt> files.
  * \param files <tt>.csv</tt> files created using \ref br_eval.
  * \param destination Basename for the resulting figures.
@@ -295,6 +301,20 @@ BR_EXPORT bool br_plot(int num_files, const char *files[], const char *destinati
 BR_EXPORT bool br_plot_detection(int num_files, const char *files[], const char *destination, bool show = false);
  
 /*!
+ * \brief Renders landmarking performance figures for a set of <tt>.csv</tt> files created by \ref br_eval_landmarking.
+ *
+ * In order of their output, the figures are:
+ * -# Cumulative landmarks less than normalized error (CD)
+ * -# Normalized error box and whisker plots (Box)
+ * -# Normalized error violin plots (Violin)
+ *
+ * Landmarking error is normalized against the distance between two predifined points, usually inter-ocular distance (IOD).
+ *
+ * \see br_plot
+ */
+BR_EXPORT bool br_plot_landmarking(int num_files, const char *files[], const char *destination, bool show = false);
+
+/*!
  * \brief Renders metadata figures for a set of <tt>.csv</tt> files with specified columns.
  *
  * Several files will be created:
@@ -387,7 +387,7 @@ TemplateList TemplateList::fromGallery(const br::File &amp;gallery)
  
         const int crossValidate = gallery.get<int>("crossValidate");
  
-        if (gallery.getBool("leaveOneOut")) {
+        if (gallery.getBool("leaveOneImageOut")) {
             QStringList labels;
             for (int i=newTemplates.size()-1; i>=0; i--) {
                 newTemplates[i].file.set("Index", i+templates.size());
@@ -406,11 +406,11 @@ TemplateList TemplateList::fromGallery(const br::File &amp;gallery)
                     // Extend the gallery for each partition
                     for (int j=0; j<labelIndices.size(); j++) {
                         for (int k=0; k<crossValidate; k++) {
-                            Template leaveOneOutTemplate = newTemplates[labelIndices[j]];
-                            if (k!=leaveOneOutTemplate.file.get<int>("Partition")) {
-                                leaveOneOutTemplate.file.set("Partition", k);
-                                leaveOneOutTemplate.file.set("testOnly", true);
-                                newTemplates.insert(i+1,leaveOneOutTemplate);
+                            Template leaveOneImageOutTemplate = newTemplates[labelIndices[j]];
+                            if (k!=leaveOneImageOutTemplate.file.get<int>("Partition")) {
+                                leaveOneImageOutTemplate.file.set("Partition", k);
+                                leaveOneImageOutTemplate.file.set("testOnly", true);
+                                newTemplates.insert(i+1,leaveOneImageOutTemplate);
                             }
                         }
                     }
@@ -50,9 +50,9 @@ class AlgorithmsInitializer : public Initializer
         Globals->abbreviations.insert("PerFrameDetection", "Stream(SaveMat(original)+Cvt(Gray)+Cascade(FrontalFace)+ASEFEyes+RestoreMat(original)+Draw(inPlace=true)+Show(false,[FrameNumber])+Discard)");
         Globals->abbreviations.insert("AgeGenderDemo", "Stream(SaveMat(original)+Cvt(Gray)+Cascade(FrontalFace)+Expand+<FaceClassificationRegistration>+<FaceClassificationExtraction>+<AgeRegressor>/<GenderClassifier>+Discard+RestoreMat(original)+Draw(inPlace=true)+DrawPropertiesPoint([Age,Gender],Affine_0,inPlace=true)+SaveMat(original)+Discard+Contract+RestoreMat(original)+FPSCalc+Show(false,[AvgFPS,Age,Gender])+Discard)");
  
-        Globals->abbreviations.insert("HOG", "Stream(DropFrames(5)+Cvt(Gray)+KeyPointDetector(SIFT)+ROI+Expand+Resize(32,32)+Gradient+RectRegions+Bin(0,360,8)+Hist(8)+Cat)+Contract+CatRows+KMeans(500)+Hist(500)+SVM");
-        Globals->abbreviations.insert("HOF", "Stream(DropFrames(5)+KeyPointDetector(SIFT)+AggregateFrames(2)+OpticalFlow+ROI+Expand+Resize(32,32)+Gradient+RectRegions+Bin(0,360,8)+Hist(8)+Cat)+Contract+CatRows+KMeans(500)+Hist(500)");
-        Globals->abbreviations.insert("HOGHOF", "Stream(DropFrames(5)+KeyPointDetector(SIFT)+AggregateFrames(2)+(OpticalFlow++ROI+Expand+Resize(32,32)+Gradient+RectRegions+Bin(0,360,8)+Hist(8)+Cat+Contract)/(First+Cvt(Gray)+ROI+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("HOG", "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("HOF", "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("HOGHOF", "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");
  
         // Generic Image Processing
         Globals->abbreviations.insert("SIFT", "Open+KeyPointDetector(SIFT)+KeyPointDescriptor(SIFT):KeyPointMatcher(BruteForce)");
@@ -69,6 +69,31 @@ 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.
@@ -253,9 +253,7 @@ class DFFSTransform : public Transform
 {
     Q_OBJECT
     Q_PROPERTY(float keep READ get_keep WRITE set_keep RESET reset_keep STORED false)
-    Q_PROPERTY(br::Transform *transform READ get_transform WRITE set_transform STORED false)
     BR_PROPERTY(float, keep, 0.95)
-    BR_PROPERTY(br::Transform*, transform, NULL)
  
     PCATransform pca;
     Transform *cvtFloat;
-set(BR_WITH_FST3 OFF CACHE BOOL "Build with Feature Selection Toolbox 3")
-
-if(${BR_WITH_FST3})
-  find_package(FST3 REQUIRED)
-  set(BR_THIRDPARTY_LIBS ${BR_THIRDPARTY_LIBS} plugins/fst3.cpp ${FST3_SRC})
-
-  find_package(Boost REQUIRED)
-  include_directories(${Boost_INCLUDE_DIRS})
-  set(BR_THIRDPARTY_LIBS ${BR_THIRDPARTY_LIBS} boost_thread)
-
-  find_package(LibSVM REQUIRED)
-  set(BR_THIRDPARTY_SRC ${BR_THIRDPARTY_SRC} ${LibSVM_SRC})
-endif()
-#include <QMap>
-#include <QString>
-#include <QStringList>
-#include <QTime>
-#include <opencv2/core/core.hpp>
-#include <opencv2/imgproc/imgproc.hpp>
-#include <mm_plugin.h>
-
-#include "model.h"
-#include "common/opencvutils.h"
-#include "common/qtutils.h"
-#include "plugins/meta.h"
-#include "plugins/regions.h"
-
-//#ifdef MM_SDK_TRAINABLE
-#include <boost/smart_ptr.hpp>
-#include <exception>
-#include <iostream>
-#include <cstdlib>
-#include <sstream>
-#include <string>
-#include <vector>
-
-#include <error.hpp>
-#include <global.hpp>
-#include <subset.hpp>
-#include <data_intervaller.hpp>
-#include <data_splitter.hpp>
-#include <data_splitter_5050.hpp>
-#include <data_splitter_cv.hpp>
-#include <data_splitter_resub.hpp>
-#include <data_scaler.hpp>
-#include <data_scaler_void.hpp>
-#include <data_accessor_splitting_mem.hpp>
-#include <criterion_wrapper.hpp>
-#include <distance_euclid.hpp>
-#include <classifier_knn.hpp>
-#include <seq_step_straight_threaded.hpp>
-#include <search_seq_dos.hpp>
-#include <search_seq_sfs.hpp>
-#include <search_seq_sffs.hpp>
-#include <search_monte_carlo_threaded.hpp>
-
-using namespace FST;
-//#endif // MM_SDK_TRAINABLE
-
-using namespace mm;
-
-enum DimensionStatus {
-    On,
-    Off,
-    Ignore
-};
-
-//#ifdef MM_SDK_TRAINABLE
-template<typename DATATYPE, typename IDXTYPE, class INTERVALCONTAINER>
-class FST3Data_Accessor_Splitting_MemMM : public Data_Accessor_Splitting_Mem<DATATYPE,IDXTYPE,INTERVALCONTAINER>
-{
-    QList<MatrixList> mll;
-    QList<DimensionStatus> dsl;
-    int features;
-    QMap<int, int> labelCounts;
-
-public:
-    typedef Data_Accessor_Splitting_Mem<DATATYPE,IDXTYPE,INTERVALCONTAINER> DASM;
-    typedef boost::shared_ptr<Data_Scaler<DATATYPE> > PScaler;
-    typedef typename DASM::PSplitters PSplitters;
-
-    FST3Data_Accessor_Splitting_MemMM(const QList<MatrixList> &_mll, const QList<DimensionStatus> &_dsl, const PSplitters _dsp, const PScaler _dsc)
-        : Data_Accessor_Splitting_Mem<DATATYPE,IDXTYPE,INTERVALCONTAINER>("MM", _dsp, _dsc), mll(_mll), dsl(_dsl)
-    {
-        features = 0;
-        foreach (DimensionStatus ds, dsl)
-            if (ds != Ignore) features++;
-        labelCounts = mll.first().labelCounts();
-    }
-
-    FST3Data_Accessor_Splitting_MemMM(const MatrixList &_ml, const PSplitters _dsp, const PScaler _dsc)
-        : Data_Accessor_Splitting_Mem<DATATYPE,IDXTYPE,INTERVALCONTAINER>("MM", _dsp, _dsc)
-    {
-        mll.append(_ml);
-        features = _ml.first().total() * _ml.first().channels();
-        for (int i=0; i<features; i++)
-            dsl.append(Off);
-        labelCounts = _ml.labelCounts();
-    }
-
-    FST3Data_Accessor_Splitting_MemMM* sharing_clone() const;
-    virtual std::ostream& print(std::ostream& os) const;
-
-protected:
-    FST3Data_Accessor_Splitting_MemMM(const Data_Accessor_Splitting_MemMM &damt, int x)
-        : Data_Accessor_Splitting_Mem<DATATYPE,IDXTYPE,INTERVALCONTAINER>(damt, x)
-    {} // weak (referencing) copy-constructor to be used in sharing_clone()
-
-    virtual void initial_data_read();    //!< \note off-limits in shared_clone
-    virtual void initial_file_prepare() {}
-
-public:
-    virtual unsigned int file_getNoOfClasses() const { return labelCounts.size(); }
-    virtual unsigned int file_getNoOfFeatures() const { return features; }
-    virtual IDXTYPE file_getClassSize(unsigned int cls) const { return labelCounts[cls]; }
-};
-
-template<typename DATATYPE, typename IDXTYPE, class INTERVALCONTAINER>
-void FST3Data_Accessor_Splitting_MemMM<DATATYPE,IDXTYPE,INTERVALCONTAINER>::initial_data_read() //!< \note off-limits in shared_clone
-{
-    if (Clonable::is_sharing_clone()) throw fst_error("Data_Accessor_Splitting_MemMM()::initial_data_read() called from shared_clone instance.");
-    IDXTYPE idx=0;
-
-    // TODO: Assert that ml data type is DATATYPE
-    const QList<float> labels = mll.first().labels();
-    foreach (int label, labelCounts.keys()) {
-        for (int i=0; i<labels.size(); i++) {
-            if (labels[i] == label) {
-                int dslIndex = 0;
-                foreach (const MatrixList &ml, mll) {
-                    const Matrix &m = ml[i];
-                    const int dims = m.total() * m.channels();
-                    for (int j=0; j<dims; j++)
-                        if (dsl[dslIndex++] != Ignore)
-                            this->data[idx++] = reinterpret_cast<float*>(m.data)[j];
-                }
-            }
-        }
-    }
-}
-
-/*template<typename DATATYPE, typename IDXTYPE, class INTERVALCONTAINER>
-Data_Accessor_Splitting_MemMM<DATATYPE,IDXTYPE,INTERVALCONTAINER>* Data_Accessor_Splitting_MemMM<DATATYPE,IDXTYPE,INTERVALCONTAINER>::sharing_clone() const
-{
-        Data_Accessor_Splitting_MemMM<DATATYPE,IDXTYPE,INTERVALCONTAINER> *clone=new Data_Accessor_Splitting_MemMM<DATATYPE,IDXTYPE,INTERVALCONTAINER>(*this, (int)0);
-        clone->set_sharing_cloned();
-        return clone;
-}
-
-template<typename DATATYPE, typename IDXTYPE, class INTERVALCONTAINER>
-std::ostream& Data_Accessor_Splitting_MemMM<DATATYPE,IDXTYPE,INTERVALCONTAINER>::print(std::ostream& os) const
-{
-        DASM::print(os);
-        os << std::endl << "Data_Accessor_Splitting_MemMM()";
-        return os;
-}*/
-
-//#endif // MM_SDK_TRAINABLE
-
-
-class FST3DOS : public Feature
-{
-    friend class Maker<DOS,true>;
-
-    int delta;
-
-    mm::Remap remap;
-
-    DOS(int delta = 1)
-    {
-        this->delta = delta;
-    }
-
-    static QString args()
-    {
-        return "delta = 1";
-    }
-
-    static DOS *make(const QString &args)
-    {
-        QStringList words = QtUtils::parse(args);
-        if (words.size() > 1) qFatal("DOS::make invalid argument count.");
-
-        int delta = 1;
-
-        bool ok;
-        switch (words.size()) {
-          case 1:
-            delta = words[0].toInt(&ok); if (!ok) qFatal("DOS::make expected integer delta.");
-        }
-
-        return new DOS(delta);
-    }
-
-    QSharedPointer<Feature> clone() const
-    {
-        return QSharedPointer<Feature>(new DOS(delta));
-    }
-
-    void train(const MatrixList &data, Matrix &metadata)
-    {
-        (void) metadata;
-        //#ifdef MM_SDK_TRAINABLE
-        try {
-            typedef float RETURNTYPE; 	typedef float DATATYPE;       typedef float REALTYPE;
-            typedef unsigned int IDXTYPE; typedef unsigned int DIMTYPE; typedef int BINTYPE;
-            typedef Subset<BINTYPE, DIMTYPE> SUBSET;
-            typedef Data_Intervaller<std::vector<Data_Interval<IDXTYPE> >,IDXTYPE> INTERVALLER;
-            typedef boost::shared_ptr<Data_Splitter<INTERVALLER,IDXTYPE> > PSPLITTER;
-            typedef Data_Splitter_CV<INTERVALLER,IDXTYPE> SPLITTERCV;
-            typedef Data_Splitter_5050<INTERVALLER,IDXTYPE> SPLITTER5050;
-            typedef Data_Splitter_Resub<INTERVALLER,IDXTYPE> SPLITTERRESUB;
-            typedef Data_Accessor_Splitting_MemMM<DATATYPE,IDXTYPE,INTERVALLER> DATAACCESSOR;
-            typedef Distance_Euclid<DATATYPE,DIMTYPE,SUBSET> DISTANCE;
-            typedef Classifier_kNN<RETURNTYPE,DATATYPE,IDXTYPE,DIMTYPE,SUBSET,DATAACCESSOR,DISTANCE> CLASSIFIERKNN;
-            typedef Criterion_Wrapper<RETURNTYPE,SUBSET,CLASSIFIERKNN,DATAACCESSOR> WRAPPERKNN;
-            typedef Sequential_Step_Straight_Threaded<RETURNTYPE,DIMTYPE,SUBSET,WRAPPERKNN,24> EVALUATOR;
-
-            // Initialize dataset
-            PSPLITTER dsp_outer(new SPLITTER5050()); // keep second half of data for independent testing of final classification performance
-            PSPLITTER dsp_inner(new SPLITTERCV(3)); // in the course of search use the first half of data by 3-fold cross-validation in wrapper FS criterion evaluation
-            boost::shared_ptr<Data_Scaler<DATATYPE> > dsc(new Data_Scaler_void<DATATYPE>()); // do not scale data
-            boost::shared_ptr<std::vector<PSPLITTER> > splitters(new std::vector<PSPLITTER>); // set-up data access
-            splitters->push_back(dsp_outer); //splitters->push_back(dsp_inner);
-            boost::shared_ptr<DATAACCESSOR> da(new DATAACCESSOR(data, splitters, dsc));
-            da->initialize();
-            da->setSplittingDepth(0); if(!da->getFirstSplit()) throw fst_error("50/50 data split failed.");
-            //da->setSplittingDepth(1); if(!da->getFirstSplit()) throw fst_error("3-fold cross-validation failure.");
-            boost::shared_ptr<SUBSET> sub(new SUBSET(da->getNoOfFeatures())); // initiate the storage for subset to-be-selected
-            //sub->select_all();
-
-            // Run search
-            boost::shared_ptr<CLASSIFIERKNN> cknn(new CLASSIFIERKNN); cknn->set_k(1);
-            boost::shared_ptr<WRAPPERKNN> wknn(new WRAPPERKNN);
-            wknn->initialize(cknn,da);
-            boost::shared_ptr<EVALUATOR> eval(new EVALUATOR); // set-up the standard sequential search step object (option: hybrid, ensemble, etc.)
-            //Search_DOS<RETURNTYPE,DIMTYPE,SUBSET,WRAPPERKNN,EVALUATOR> srch(eval); // set-up Sequential Forward Floating Selection search procedure
-            //srch.set_delta(delta);
-
-            //FST::Search_SFFS<RETURNTYPE,DIMTYPE,SUBSET,WRAPPERKNN,EVALUATOR> srch(eval);
-            //srch.set_search_direction(FST::BACKWARD);
-
-            //FST::Search_SFS<RETURNTYPE,DIMTYPE,SUBSET,WRAPPERKNN,EVALUATOR> srch(eval);
-            //srch.set_search_direction(FST::FORWARD);
-
-            FST::Search_Monte_Carlo_Threaded<RETURNTYPE,DIMTYPE,SUBSET,WRAPPERKNN,24> srch;
-            srch.set_cardinality_randomization(0.5); // probability of inclusion of each particular feature (~implies also the expected subset size)
-            srch.set_stopping_condition(0/*max trials*/,30/*seconds*/); // one or both values must have positive value
-
-            RETURNTYPE critval_train;
-            if(!srch.search(0,critval_train,sub,wknn,std::cout)) throw fst_error("Search not finished.");
-
-            // Create map matrix
-            const int dims = sub->get_d_raw();
-            cv::Mat xMap(1, dims, CV_16SC1),
-                    yMap(1, dims, CV_16SC1);
-            int index = 0;
-            for (int i=0; i<dims; i++) {
-                if (sub->selected_raw(i)) {
-                    xMap.at<short>(0, index) = i;
-                    yMap.at<short>(0, index) = 0;
-                    index++;
-                }
-            }
-
-            remap = Remap(xMap, yMap, cv::INTER_NEAREST);
-        }
-        catch (fst_error &e) { qFatal("FST ERROR: %s, code=%d", e.what(), e.code()); }
-        catch (std::exception &e) { qFatal("non-FST ERROR: %s", e.what()); }
-        metadata >> remap;
-        //#else // MM_SDK_TRAINABLE
-        //qFatal("StreamwiseFS::train not supported.");
-        //#endif // MM_SDK_TRAINABLE
-    }
-
-    void project(const Matrix &src, Matrix &dst) const
-    {
-        dst = src;
-        dst >> remap;
-    }
-
-    void store(QDataStream &stream) const
-    {
-        stream << remap;
-    }
-
-    void load(QDataStream &stream)
-    {
-        stream >> remap;
-    }
-};
-
-MM_REGISTER(Feature, FST3DOS, true)
-
-
-class FST3StreamwiseFS : public Feature
-{
-    friend class Maker<StreamwiseFS,true>;
-
-    QSharedPointer<Feature> weakLearnerTemplate;
-    int time;
-
-    mm::Dup dup;
-    mm::Remap remap;
-
-    StreamwiseFS(const QSharedPointer<Feature> &weakLearnerTemplate, int time)
-        : dup(weakLearnerTemplate, 1)
-    {
-        this->weakLearnerTemplate = weakLearnerTemplate;
-        this->time = time;
-    }
-
-    static QString args()
-    {
-        return "<feature> weakLearnerTemplate, int time";
-    }
-
-    static StreamwiseFS *make(const QString &args)
-    {
-        QStringList words = QtUtils::parse(args);
-        if (words.size() != 2) qFatal("StreamwiseFS::make invalid argument count.");
-
-        QSharedPointer<Feature> weakLearnerTemplate = Feature::make(words[0]);
-        bool ok;
-        int time = words[1].toInt(&ok); assert(ok);
-
-        return new StreamwiseFS(weakLearnerTemplate, time);
-    }
-
-    QSharedPointer<Feature> clone() const
-    {
-        return QSharedPointer<Feature>(new StreamwiseFS(weakLearnerTemplate, time));
-    }
-
-    void train(const MatrixList &data, Matrix &metadata)
-    {
-        QList< QSharedPointer<Feature> > weakLearners;
-        QList<MatrixList> projectedDataList;
-        QList<int> weakLearnerDimsList;
-        QList<DimensionStatus> dimStatusList;
-
-        QTime timer; timer.start();
-        while (timer.elapsed() / 1000 < time) {
-            // Construct a new weak learner
-            QSharedPointer<Feature> newWeakLearner = weakLearnerTemplate->clone();
-            Matrix metadataCopy(metadata);
-            newWeakLearner->train(data, metadataCopy);
-            weakLearners.append(newWeakLearner);
-
-            MatrixList projectedData = data;
-            projectedData >> *newWeakLearner;
-            projectedDataList.append(projectedData);
-            weakLearnerDimsList.append(projectedData.first().total() * projectedData.first().channels());
-            for (int i=0; i<weakLearnerDimsList.last(); i++) dimStatusList.append(Off);
-
-            //#ifdef MM_SDK_TRAINABLE
-            try
-            {
-                typedef float RETURNTYPE; 	typedef float DATATYPE;       typedef float REALTYPE;
-                typedef unsigned int IDXTYPE; typedef unsigned int DIMTYPE; typedef int BINTYPE;
-                typedef Subset<BINTYPE, DIMTYPE> SUBSET;
-                typedef Data_Intervaller<std::vector<Data_Interval<IDXTYPE> >,IDXTYPE> INTERVALLER;
-                typedef boost::shared_ptr<Data_Splitter<INTERVALLER,IDXTYPE> > PSPLITTER;
-                typedef Data_Splitter_CV<INTERVALLER,IDXTYPE> SPLITTERCV;
-                typedef Data_Splitter_5050<INTERVALLER,IDXTYPE> SPLITTER5050;
-                typedef Data_Accessor_Splitting_MemMM<DATATYPE,IDXTYPE,INTERVALLER> DATAACCESSOR;
-                typedef Distance_Euclid<DATATYPE,DIMTYPE,SUBSET> DISTANCE;
-                typedef Classifier_kNN<RETURNTYPE,DATATYPE,IDXTYPE,DIMTYPE,SUBSET,DATAACCESSOR,DISTANCE> CLASSIFIERKNN;
-                typedef Criterion_Wrapper<RETURNTYPE,SUBSET,CLASSIFIERKNN,DATAACCESSOR> WRAPPERKNN;
-                typedef Sequential_Step_Straight_Threaded<RETURNTYPE,DIMTYPE,SUBSET,WRAPPERKNN,24> EVALUATOR;
-
-                // Initialize dataset
-                PSPLITTER dsp_outer(new SPLITTER5050()); // keep second half of data for independent testing of final classification performance
-                PSPLITTER dsp_inner(new SPLITTERCV(3)); // in the course of search use the first half of data by 3-fold cross-validation in wrapper FS criterion evaluation
-                boost::shared_ptr<Data_Scaler<DATATYPE> > dsc(new Data_Scaler_void<DATATYPE>()); // do not scale data
-                boost::shared_ptr<std::vector<PSPLITTER> > splitters(new std::vector<PSPLITTER>); // set-up data access
-                splitters->push_back(dsp_outer); splitters->push_back(dsp_inner);
-                boost::shared_ptr<DATAACCESSOR> da(new DATAACCESSOR(projectedDataList, dimStatusList, splitters, dsc));
-                da->initialize();
-                da->setSplittingDepth(0); if(!da->getFirstSplit()) throw fst_error("50/50 data split failed.");
-                da->setSplittingDepth(1); if(!da->getFirstSplit()) throw fst_error("3-fold cross-validation failure.");
-                boost::shared_ptr<SUBSET> sub(new SUBSET(da->getNoOfFeatures())); // initiate the storage for subset to-be-selected
-
-                { // Initialize subset from previous iteration results
-                    sub->deselect_all();
-                    int index = 0;
-                    for (int i=0; i<dimStatusList.size(); i++) {
-                        if (dimStatusList[i] == On) sub->select(index);
-                        if (dimStatusList[i] != Ignore) index++;
-                    }
-                }
-
-                // Run search
-                boost::shared_ptr<CLASSIFIERKNN> cknn(new CLASSIFIERKNN); cknn->set_k(3); // set-up 3-Nearest Neighbor classifier based on Euclidean distances
-                boost::shared_ptr<WRAPPERKNN> wknn(new WRAPPERKNN); // wrap the 3-NN classifier to enable its usage as FS criterion (criterion value will be estimated by 3-fold cross-val.)
-                wknn->initialize(cknn,da);
-                boost::shared_ptr<EVALUATOR> eval(new EVALUATOR); // set-up the standard sequential search step object (option: hybrid, ensemble, etc.)
-                Search_DOS<RETURNTYPE,DIMTYPE,SUBSET,WRAPPERKNN,EVALUATOR> srch(eval); // set-up Sequential Forward Floating Selection search procedure
-                srch.set_delta(1);
-                RETURNTYPE critval_train;
-                if(!srch.search(0,critval_train,sub,wknn,std::cout)) throw fst_error("Search not finished.");
-
-                { // Update results
-                    int dslIndex = dimStatusList.size() - 1;
-                    int subIndex = da->getNoOfFeatures() - 1;
-                    for (int wlIndex = weakLearnerDimsList.size()-1; wlIndex >= 0; wlIndex--) {
-                        const int weakLearnerDims = weakLearnerDimsList[wlIndex];
-                        int numSelectedDims = 0;
-                        for (int i=0; i<weakLearnerDims; i++) {
-                            if (dimStatusList[dslIndex] != Ignore)
-                                dimStatusList[dslIndex] = sub->selected_raw(subIndex--) ? numSelectedDims++, On : Ignore;
-                            dslIndex--;
-                        }
-
-                        if (numSelectedDims == 0) {
-                            for (int j=0; j<weakLearnerDims; j++)
-                                dimStatusList.removeAt(dslIndex+1);
-                            weakLearnerDimsList.removeAt(wlIndex);
-                            projectedDataList.removeAt(wlIndex);
-                            weakLearners.removeAt(wlIndex);
-                        }
-                    }
-                }
-            }
-            catch (fst_error &e) { qFatal("FST ERROR: %s, code=%d", e.what(), e.code()); }
-            catch (std::exception &e) { qFatal("non-FST ERROR: %s", e.what()); }
-            //#else // MM_SDK_TRAINABLE
-            //qFatal("StreamwiseFS::train not supported.");
-            //#endif // MM_SDK_TRAINABLE
-        }
-
-        dup = Dup(weakLearners);
-
-        // Create map matrix
-        int dims = 0;
-        foreach (DimensionStatus ds, dimStatusList) if (ds == On) dims++;
-        cv::Mat xMap(1, dims, CV_16SC1),
-                yMap(1, dims, CV_16SC1);
-        int index = 0;
-        for (int i=0; i<dimStatusList.size(); i++) {
-            if (dimStatusList[i] == On) {
-                xMap.at<short>(0, index) = i;
-                yMap.at<short>(0, index) = 0;
-                index++;
-            }
-        }
-
-        remap = Remap(xMap, yMap, cv::INTER_NEAREST);
-    }
-
-    void project(const Matrix &src, Matrix &dst) const
-    {
-        dst = src;
-        dst >> dup >> mm::Cat >> remap;
-    }
-
-    void store(QDataStream &stream) const
-    {
-        stream << dup << remap;
-    }
-
-    void load(QDataStream &stream)
-    {
-        stream >> dup >> remap;
-    }
-};
-
-MM_REGISTER(Feature, FST3StreamwiseFS, true)
@@ -5,6 +5,11 @@
 #include <QMutex>
 #include <QMouseEvent>
 #include <QPainter>
+#include <QMainWindow>
+#include <QPushButton>
+#include <QHBoxLayout>
+#include <QFormLayout>
+#include <QLineEdit>
  
 #include <opencv2/imgproc/imgproc.hpp>
 #include "openbr_internal.h"
@@ -65,6 +70,7 @@ public:
  
     DisplayWindow(QWidget * parent = NULL) : QLabel(parent)
     {
+        setFixedSize(200,200);
         QApplication::instance()->installEventFilter(this);
     }
  
@@ -75,7 +81,13 @@ public slots:
  
         show();
         setPixmap(pixmap);
-        setFixedSize(input.size());
+
+        // We appear to get a warning on windows if we set window width < 104. This is of course not
+        // reflected in the Qt min size settings, and I don't know how to query it.
+        QSize temp = input.size();
+        if (temp.width() < 104)
+            temp.setWidth(104);
+        setFixedSize(temp);
     }
  
  
@@ -188,6 +200,85 @@ private:
  
 };
  
+class DisplayGUI : public QMainWindow
+{
+    Q_OBJECT
+
+public:
+
+    DisplayGUI(QWidget * parent = NULL) : QMainWindow(parent)
+    {
+        centralWidget = new QWidget();
+        layout = new QHBoxLayout();
+        inputLayout = new QVBoxLayout();
+
+        button.setText("Set Template Metadata");
+
+        layout->addWidget(&label);
+
+        inputLayout->addWidget(&button);
+        layout->addLayout(inputLayout);
+
+        centralWidget->setLayout(layout);
+
+        setCentralWidget(centralWidget);
+
+        connect(&button, SIGNAL(clicked()), this, SLOT(buttonPressed()));
+    }
+
+public slots:
+    void showImage(const QPixmap & input)
+    {
+        pixmap = input;
+        foreach(const QString& label, keys) {
+            QLineEdit *edit = new QLineEdit;
+            fields.append(edit);
+            QFormLayout *form = new QFormLayout;
+            form->addRow(label, edit);
+            inputLayout->addLayout(form);
+        }
+
+        show();
+        label.setPixmap(pixmap);
+        label.setFixedSize(input.size());
+    }
+
+    QStringList waitForButtonPress()
+    {
+        QMutexLocker locker(&lock);
+        wait.wait(&lock);
+
+        QStringList values;
+        for(int i = 0; i<fields.size(); i++) values.append(fields.at(i)->text());
+        return values;
+    }
+
+public slots:
+
+    void buttonPressed()
+    {
+        wait.wakeAll();
+    }
+
+    void setKeys(const QStringList& k)
+    {
+        keys = k;
+    }
+
+private:
+
+    QWidget *centralWidget;
+    QStringList keys;
+    QList<QLineEdit*> fields;
+    QPushButton button;
+    QMutex lock;
+    QWaitCondition wait;
+    QPixmap pixmap;
+    QLabel label;
+    QHBoxLayout *layout;
+    QVBoxLayout *inputLayout;
+
+};
  
 // I want a template class that doesn't look like a template class
 class NominalCreation
@@ -298,7 +389,7 @@ public:
     {
         dst = src;
  
-        if (src.empty() || !Globals->useGui)
+        if (src.empty())
             return;
  
         foreach (const Template & t, src) {
@@ -427,6 +518,104 @@ public:
  
 BR_REGISTER(Transform, ManualTransform)
  
+/*!
+ * \ingroup transforms
+ * \brief Elicits metadata for templates in a pretty GUI
+ * \author Scott Klum \cite sklum
+ */
+class ElicitTransform : public TimeVaryingTransform
+{
+    Q_PROPERTY(QStringList keys READ get_keys WRITE set_keys RESET reset_keys STORED false)
+    BR_PROPERTY(QStringList, keys, QStringList())
+
+    Q_OBJECT
+
+    MainThreadCreator creator;
+    DisplayGUI *gui;
+    QImage qImageBuffer;
+    QPixmap *displayBuffer;
+
+public:
+    ElicitTransform() : TimeVaryingTransform(false, false)
+    {
+        displayBuffer = NULL;
+        gui = NULL;
+    }
+
+    ~ElicitTransform()
+    {
+        delete displayBuffer;
+        delete gui;
+    }
+
+    void train(const TemplateList &data) { (void) data; }
+
+    void project(const TemplateList &src, TemplateList &dst) const
+    {
+        Transform * non_const = (ElicitTransform *) this;
+        non_const->projectUpdate(src,dst);
+    }
+
+    void projectUpdate(const TemplateList &src, TemplateList &dst)
+    {
+        dst = src;
+
+        if (src.empty()) return;
+
+        for (int i = 0; i < dst.size(); i++) {
+            foreach(const cv::Mat &m, dst[i]) {
+                qImageBuffer = toQImage(m);
+                displayBuffer->convertFromImage(qImageBuffer);
+
+                emit updateImage(displayBuffer->copy(displayBuffer->rect()));
+
+                QStringList metadata = gui->waitForButtonPress();
+                for(int j = 0; j < keys.size(); j++) dst[i].file.set(keys[j],metadata[j]);
+            }
+        }
+    }
+
+    void finalize(TemplateList & output)
+    {
+        (void) output;
+        emit hideWindow();
+    }
+
+    void init()
+    {
+        initActual<DisplayGUI>();
+    }
+
+    template<typename GUIType>
+    void initActual()
+    {
+        if (!Globals->useGui)
+            return;
+
+        TimeVaryingTransform::init();
+
+        if (displayBuffer)
+            delete displayBuffer;
+
+        displayBuffer = new QPixmap();
+
+        if (gui)
+            delete gui;
+
+        gui = creator.getItem<GUIType>();
+        gui->setKeys(keys);
+        // Connect our signals to the window's slots
+        connect(this, SIGNAL(updateImage(QPixmap)), gui,SLOT(showImage(QPixmap)));
+        connect(this, SIGNAL(hideWindow()), gui, SLOT(hide()));
+    }
+
+signals:
+
+    void updateImage(const QPixmap & input);
+    void hideWindow();
+
+};
+BR_REGISTER(Transform, ElicitTransform)
  
 /*!
  * \ingroup transforms
@@ -222,9 +222,9 @@ class GridTransform : public UntrainableTransform
         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 i=row_step/2; i<src.m().rows; i+=row_step)
-            for (float j=column_step/2; j<src.m().cols; j+=column_step)
-                landmarks.append(QPointF(i,j));
+        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);
     }
@@ -264,7 +264,6 @@ class ContractTransform : public UntrainableMetaTransform
  
     virtual void project(const TemplateList &src, TemplateList &dst) const
     {
-        //dst = Expanded(src);
         if (src.empty()) return;
         Template out;
  
@@ -682,8 +681,10 @@ public:
  
     void init()
     {
-        if (transform && transform->timeVarying())
-            transform = new br::TimeInvariantWrapperTransform(transform);
+        if (!transform)
+            return;
+
+        trainable = transform->trainable;
     }
  
 };
@@ -332,57 +332,6 @@ class AnonymizeTransform : public UntrainableMetaTransform
  
 BR_REGISTER(Transform, AnonymizeTransform)
  
-// TODO: Use a global Mutex to prevent concurrent reads from stdin
-#if 0
-/*!
- * \ingroup transforms
- * \brief Name a point
- * \author Scott Klum \cite sklum
- */
-class ElicitMetadataTransform : public UntrainableMetaTransform
-{
-    Q_OBJECT
-
-    Q_PROPERTY(QStringList metadata READ get_metadata WRITE set_metadata RESET reset_metadata STORED false)
-    BR_PROPERTY(QStringList, metadata, QStringList())
-
-    void init()
-    {
-        Globals->setProperty("parallelism", "0"); // Can only work in single threaded mode
-    }
-
-    void project(const Template &src, Template &dst) const
-    {
-        dst = src;
-
-        QTextStream stream(stdin);
-
-        foreach (const QString &key, metadata) {
-            qDebug() << "Specify a value for key: " << key;
-            QString value = stream.readLine();
-            if (value[0] == '(') {
-                QStringList values = value.split(',');
-                if (values.size() == 2) /* QPointF */ {
-                    values[1].chop(1);
-                    QPointF point(values[0].mid(1).toFloat(), values[1].toFloat());
-                    if (key != "Points") dst.file.set(key, point);
-                    else dst.file.appendPoint(point);
-                }
-                else /* QRectF */ {
-                    values[3].chop(1);
-                    QRectF rect(values[0].mid(1).toFloat(), values[1].toFloat(), values[2].toFloat(), values[3].toFloat());
-                    if (key != "Rects") dst.file.set(key, rect);
-                    else dst.file.appendRect(rect);
-                }
-            }
-            else dst.file.set(key, value);
-        }
-    }
-};
-
-BR_REGISTER(Transform, ElicitMetadataTransform)
-#endif
-
 /*!
  * \ingroup transforms
  * \brief Change the br::Template::file extension
@@ -405,27 +354,31 @@ BR_REGISTER(Transform, AsTransform)
  
 /*!
  * \ingroup transforms
- * \brief Change the template subject using a regular expresion matched to the file's base name.
- * \author Josh Klontz \cite jklontz
+ * \brief Apply the input regular expression to the value of inputProperty, store the matched portion in outputProperty.
+ * \author Charles Otto \cite caotto
  */
-class SubjectTransform : public UntrainableMetaTransform
+class RegexPropertyTransform : public UntrainableMetaTransform
 {
     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 project(const Template &src, Template &dst) const
     {
         dst = src;
         QRegularExpression re(regexp);
-        QRegularExpressionMatch match = re.match(dst.file.baseName());
+        QRegularExpressionMatch match = re.match(dst.file.get<QString>(inputProperty));
         if (!match.hasMatch())
-            qFatal("Unable to match regular expression \"%s\" to base name \"%s\"!", qPrintable(regexp), qPrintable(dst.file.baseName()));
-        dst.file.set("Subject", match.captured(match.lastCapturedIndex()));
+            qFatal("Unable to match regular expression \"%s\" to base name \"%s\"!", qPrintable(regexp), qPrintable(dst.file.get<QString>(inputProperty)));
+        dst.file.set(outputProperty, match.captured(match.lastCapturedIndex()));
     }
 };
  
-BR_REGISTER(Transform, SubjectTransform)
+BR_REGISTER(Transform, RegexPropertyTransform)
  
 /*!
  * \ingroup transforms
@@ -521,6 +474,73 @@ class RestoreMatTransform : public UntrainableMetaTransform
 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;
+        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") + fileFormat;
+
+            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
@@ -24,81 +24,27 @@ private:
 };
  
 /*!
- * \brief A br::MetaTransform that does not require training data.
+ * \brief A br::Transform expecting multiple matrices per template.
  */
-class BR_EXPORT UntrainableMetaTransform : public UntrainableTransform
+class BR_EXPORT MetaTransform : public Transform
 {
     Q_OBJECT
  
 protected:
-    UntrainableMetaTransform() : UntrainableTransform(false) {}
-};
-
-/*!
- * \brief A br::Transform for which the results of project may change due to prior calls to project
- */
-class BR_EXPORT TimeVaryingTransform : public Transform
-{
-    Q_OBJECT
-
-public:
-    virtual bool timeVarying() const { return true; }
-
-    virtual void project(const Template &src, Template &dst) const
-    {
-        qFatal("No const project defined for time-varying transform");
-        (void) dst; (void) src;
-    }
-
-    virtual void project(const TemplateList &src, TemplateList &dst) const
-    {
-        qFatal("No const project defined for time-varying transform");
-        (void) dst; (void) src;
-    }
-
-    // Get a compile failure if this isn't here to go along with the other
-    // projectUpdate, no idea why
-    virtual void projectUpdate(const Template & src, Template & dst)
-    {
-        (void) src; (void) dst;
-        qFatal("do something useful");
-    }
-
-    virtual void projectUpdate(const TemplateList &src, TemplateList &dst)
-    {
-        foreach (const Template & src_part, src) {
-            Template out;
-            projectUpdate(src_part, out);
-            dst.append(out);
-        }
-    }
-
-    /*!
-     *\brief For transforms that don't do any training, this default implementation
-     * which creates a new copy of the Transform from its description string is sufficient.
-     */
-    virtual Transform * smartCopy()
-    {
-        return this->clone();
-    }
-
-
-protected:
-    TimeVaryingTransform(bool independent = true, bool trainable = true) : Transform(independent, trainable) {}
+    MetaTransform() : Transform(false) {}
 };
  
 /*!
- * \brief A br::Transform expecting multiple matrices per template.
+ * \brief A br::MetaTransform that does not require training data.
  */
-class BR_EXPORT MetaTransform : public Transform
+class BR_EXPORT UntrainableMetaTransform : public UntrainableTransform
 {
     Q_OBJECT
  
 protected:
-    MetaTransform() : Transform(false) {}
+    UntrainableMetaTransform() : UntrainableTransform(false) {}
 };
  
-
 class TransformCopier : public ResourceMaker<Transform>
 {
 public:
@@ -151,6 +97,63 @@ private:
     Transform * baseTransform;
 };
  
+/*!
+ * \brief A br::Transform for which the results of project may change due to prior calls to project
+ */
+class BR_EXPORT TimeVaryingTransform : public Transform
+{
+    Q_OBJECT
+
+public:
+
+    virtual bool timeVarying() const { return true; }
+
+    virtual void project(const Template &src, Template &dst) const
+    {
+        timeInvariantAlias.project(src,dst);
+    }
+
+    virtual void project(const TemplateList &src, TemplateList &dst) const
+    {
+        timeInvariantAlias.project(src,dst);
+    }
+
+    // Get a compile failure if this isn't here to go along with the other
+    // projectUpdate, no idea why
+    virtual void projectUpdate(const Template & src, Template & dst)
+    {
+        (void) src; (void) dst;
+        qFatal("do something useful");
+    }
+
+    virtual void projectUpdate(const TemplateList &src, TemplateList &dst)
+    {
+        foreach (const Template & src_part, src) {
+            Template out;
+            projectUpdate(src_part, out);
+            dst.append(out);
+        }
+    }
+
+    /*!
+     *\brief For transforms that don't do any training, this default implementation
+     * which creates a new copy of the Transform from its description string is sufficient.
+     */
+    virtual Transform * smartCopy()
+    {
+        return this->clone();
+    }
+
+protected:
+    // Since copies aren't actually made until project is called, we can set up
+    // timeInvariantAlias in the constructor.
+    TimeInvariantWrapperTransform timeInvariantAlias;
+    TimeVaryingTransform(bool independent = true, bool trainable = true) : Transform(independent, trainable), timeInvariantAlias(this)
+    {
+        //
+    }
+};
+
  
 /*!
  * \brief A MetaTransform that aggregates some sub-transforms
@@ -165,15 +168,17 @@ public:
  
     virtual void project(const Template &src, Template &dst) const
     {
-        if (timeVarying()) qFatal("No const project defined for time-varying transform");
+        if (timeVarying()) {
+            timeInvariantAlias.project(src,dst);
+            return;
+        }
         _project(src, dst);
     }
  
     virtual void project(const TemplateList &src, TemplateList &dst) const
     {
         if (timeVarying()) {
-            CompositeTransform * non_const = const_cast<CompositeTransform *>(this);
-            non_const->projectUpdate(src,dst);
+            timeInvariantAlias.project(src,dst);
             return;
         }
         _project(src, dst);
-set(BR_WITH_PHASH OFF CACHE BOOL "Build with pHash")
-
-if(${BR_WITH_PHASH})
-  find_package(pHash REQUIRED)
-  find_package(CImg REQUIRED)
-  set(BR_THIRDPARTY_SRC ${BR_THIRDPARTY_SRC} plugins/phash.cpp ${PHASH_SRC})
-endif()
-#include <opencv2/core/core.hpp>
-#include <pHash.h>
-#include <mm_plugin.h>
-
-using namespace mm;
-
-/**** PHASH ****/
-class pHashEnroll : public UntrainableFeature
-{
-    void project(const Matrix &src, Matrix &dst) const
-    {
-        CImg<uint8_t> cImg(src.data, src.cols, src.rows, 1, src.channels());
-        cv::Mat m(1, sizeof(ulong64), CV_8UC1);
-        ulong64 hash;
-        if (ph_dct_imagehash(cImg, hash) == -1)
-            qFatal("pHashEnroll::project ph_dct_imagehash failure for file %s.", qPrintable(src.metadata.fileName));
-        memcpy(m.data, &hash, sizeof(ulong64));
-        dst = Matrix(m, src.metadata);
-    }
-
-    /*** Taken from pHash, modified to take in a CImg instead of a file. ***/
-    static CImg<float>* ph_dct_matrix(const int N){
-        CImg<float> *ptr_matrix = new CImg<float>(N,N,1,1,1/sqrt((float)N));
-        const float c1 = sqrt(2.0/N);
-        for (int x=0;x<N;x++){
-            for (int y=1;y<N;y++){
-                *ptr_matrix->data(x,y) = c1*cos((cimg::PI/2/N)*y*(2*x+1));
-            }
-        }
-        return ptr_matrix;
-    }
-
-    static int ph_dct_imagehash(CImg<uint8_t> src, ulong64 &hash)
-    {
-        CImg<float> meanfilter(7,7,1,1,1);
-        CImg<float> img;
-        if (src.spectrum() == 3){
-            img = src.RGBtoYCbCr().channel(0).get_convolve(meanfilter);
-        } else if (src.spectrum() == 4){
-            int width = img.width();
-            int height = img.height();
-            int depth = img.depth();
-            img = src.crop(0,0,0,0,width-1,height-1,depth-1,2).RGBtoYCbCr().channel(0).get_convolve(meanfilter);
-        } else {
-            img = src.channel(0).get_convolve(meanfilter);
-        }
-
-        img.resize(32,32);
-        CImg<float> *C  = ph_dct_matrix(32);
-        CImg<float> Ctransp = C->get_transpose();
-
-        CImg<float> dctImage = (*C)*img*Ctransp;
-
-        CImg<float> subsec = dctImage.crop(1,1,8,8).unroll('x');;
-
-        float median = subsec.median();
-        ulong64 one = 0x0000000000000001;
-        hash = 0x0000000000000000;
-        for (int i=0;i< 64;i++){
-            float current = subsec(i);
-            if (current > median)
-                hash |= one;
-            one = one << 1;
-        }
-
-        delete C;
-
-        return 0;
-    }
-};
-
-MM_REGISTER(Feature, pHashEnroll, false)
-
-
-/**** PHASH_COMPARE ****/
-class pHashCompare : public ComparerBase
-{
-    float compare(const cv::Mat &a, const cv::Mat &b) const
-    {
-        return 1.f - 1.f * ph_hamming_distance(*reinterpret_cast<ulong64*>(a.data), *reinterpret_cast<ulong64*>(b.data)) / 64;
-    }
-};
-
-MM_REGISTER(Comparer, pHashCompare, false)
-
-
-/**** PHASH ****/
-class pHash : public Algorithm
-{
-    QString algorithm() const
-    {
-        return "Open+pHashEnroll:Identity:pHashCompare";
-    }
-};
-
-MM_REGISTER(Algorithm, pHash, false)
-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)
-endif()
-#include <QThreadPool>
-#include <pittpatt_errors.h>
-#include <pittpatt_nc_sdk.h>
-#include <pittpatt_raw_image_io.h>
-#include <pittpatt_license.h>
-#include <mm_plugin.h>
-
-#define TRY(CC)                                                                                               \
-{                                                                                                             \
-    if ((CC) != PPR_SUCCESS) qFatal("%d error (%s, %d): %s.", CC, __FILE__, __LINE__, ppr_error_message(CC)); \
-}
-
-#define TRY_VIDEO(CC)                                                                                                           \
-{                                                                                                                               \
-    if ((CC) != PPR_VIDEO_IO_SUCCESS) qFatal("%d error (%s, %d): %s.", CC, __FILE__, __LINE__, ppr_video_io_error_message(CC)); \
-}
-
-#define TRY_RAW_IMAGE(CC)                                                                                                         \
-{                                                                                                                                 \
-    if ((CC) != PPR_RAW_IMAGE_SUCCESS) qFatal("%d error (%s, %d): %s.", CC, __FILE__, __LINE__, ppr_raw_image_error_message(CC)); \
-}
-
-using namespace mm;
-
-/*!
- * \brief PittPatt 4 context
- * \author Josh Klontz \cite jklontz
- * \warning Needs a maintainer.
- */
-struct PP4Context
-{
-    static ppr_context_type context;
-
-    static void createRawImage(const cv::Mat &src, ppr_raw_image_type &dst)
-    {
-        ppr_raw_image_create(&dst, src.cols, src.rows, PPR_RAW_IMAGE_BGR24);
-        assert((src.type() == CV_8UC3) && src.isContinuous());
-        memcpy(dst.data, src.data, 3*src.rows*src.cols);
-    }
-
-    static void createMat(const ppr_template_type &src, cv::Mat &dst)
-    {
-        ppr_flat_template_type flat_template;
-        TRY(ppr_flatten_template(context,src,&flat_template))
-        dst = cv::Mat(1, flat_template.num_bytes, CV_8UC1, flat_template.data).clone();
-        ppr_free_flat_template(flat_template);
-    }
-
-    static void createTemplate(const cv::Mat &src, ppr_template_type *dst)
-    {
-        ppr_flat_template_type flat_template;
-        flat_template.num_bytes = src.cols;
-        flat_template.data = src.data;
-        TRY(ppr_unflatten_template(context, flat_template, dst))
-    }
-
-    static QString toString(const ppr_landmark_category_type &category)
-    {
-        switch (category) {
-          case PPR_LANDMARK_LEFT_EYE:
-            return "Left_Eye";
-          case PPR_LANDMARK_RIGHT_EYE:
-            return "Right_Eye";
-          case PPR_LANDMARK_NOSE_BASE:
-            return "Nose_Base";
-          case PPR_LANDMARK_NOSE_BRIDGE:
-            return "Nose_Bridge";
-          case PPR_LANDMARK_NOSE_TIP:
-            return "Nose_Tip";
-          case PPR_LANDMARK_NOSE_TOP:
-            return "Nose_Top";
-          case PPR_LANDMARK_EYE_NOSE:
-            return "Eye_Nose";
-          case PPR_LANDMARK_MOUTH:
-            return "Mouth";
-        }
-
-        return "Unknown";
-    }
-
-    static File toMetadata(const ppr_object_type &object)
-    {
-        File metadata;
-        metadata.insert("PP4_Object_X", object.position.x - object.dimensions.width/2);
-        metadata.insert("PP4_Object_Y", object.position.y - object.dimensions.height/2);
-        metadata.insert("PP4_Object_Width", object.dimensions.width);
-        metadata.insert("PP4_Object_Height", object.dimensions.height);
-        metadata.insert("PP4_Object_Confidence", object.confidence);
-        metadata.insert("PP4_Object_Roll", object.rotation.roll);
-        metadata.insert("PP4_Object_Pitch", object.rotation.pitch);
-        metadata.insert("PP4_Object_Yaw", object.rotation.yaw);
-        metadata.insert("PP4_Object_Precision", object.rotation.precision);
-        metadata.insert("PP4_Object_ModelID", object.model_id);
-        metadata.insert("PP4_Object_NumLandmarks", object.num_landmarks);
-        metadata.insert("PP4_Object_Size", object.size);
-
-        QList<ppr_landmark_category_type> categories;
-        categories << PPR_LANDMARK_RIGHT_EYE
-                   << PPR_LANDMARK_LEFT_EYE
-                   << PPR_LANDMARK_NOSE_BASE
-                   << PPR_LANDMARK_NOSE_BRIDGE
-                   << PPR_LANDMARK_NOSE_TIP
-                   << PPR_LANDMARK_NOSE_TOP
-                   << PPR_LANDMARK_EYE_NOSE
-                   << PPR_LANDMARK_MOUTH;
-
-        for (int i=0; i<categories.size(); i++) {
-            ppr_landmark_category_type category = categories[i];
-            QString metadataString = QString("PP4_Landmark%1_%2").arg(QString::number(i), toString(category));
-
-            bool found = false;
-            for (int j=0; j<object.num_landmarks; j++) {
-                ppr_landmark_type &landmark = object.landmarks[j];
-                if (landmark.category != category) continue;
-
-                metadata.insert(metadataString+"_X", landmark.position.x);
-                metadata.insert(metadataString+"_Y", landmark.position.y);
-                metadata.insert(metadataString+"_Category", landmark.category);
-                metadata.insert(metadataString+"_ModelID", landmark.model_id);
-                metadata.insert(metadataString+"_Index", j);
-                found = true;
-                break;
-            }
-
-            if (!found) {
-                metadata.insert(metadataString+"_X", -1);
-                metadata.insert(metadataString+"_Y", -1);
-                metadata.insert(metadataString+"_Category", -1);
-                metadata.insert(metadataString+"_ModelID", -1);
-                metadata.insert(metadataString+"_Index", -1);
-            }
-        }
-
-        return metadata;
-    }
-
-    static ppr_object_type fromMetadata(const File &metadata)
-    {
-        ppr_object_type object;
-
-        object.position.x = metadata.value("PP4_Object_X").toFloat() + metadata.value("PP4_Object_Width").toFloat()/2;
-        object.position.y = metadata.value("PP4_Object_Y").toFloat() + metadata.value("PP4_Object_Height").toFloat()/2;
-        object.dimensions.width = metadata.value("PP4_Object_Width").toFloat();
-        object.dimensions.height = metadata.value("PP4_Object_Height").toFloat();
-        object.confidence = metadata.value("PP4_Object_Confidence").toFloat();
-        object.rotation.roll = metadata.value("PP4_Object_Roll").toFloat();
-        object.rotation.pitch = metadata.value("PP4_Object_Pitch").toFloat();
-        object.rotation.yaw = metadata.value("PP4_Object_Yaw").toFloat();
-        object.rotation.precision = (ppr_precision_type) metadata.value("PP4_Object_Precision").toFloat();
-        object.model_id = metadata.value("PP4_Object_ModelID").toInt();
-        object.num_landmarks = metadata.value("PP4_Object_NumLandmarks").toInt();
-        object.size = metadata.value("PP4_Object_Size").toFloat();
-
-        QStringList landmarkNames = QStringList(metadata.keys()).filter(QRegExp("(.*)_Category")).replaceInStrings("_Category", "");
-        object.landmarks = new ppr_landmark_type[object.num_landmarks];
-        for (int j=0; j<landmarkNames.size(); j++) {
-            int landmarkIndex = metadata.value(landmarkNames[j]+"_Index").toInt();
-            if (landmarkIndex == -1) continue;
-            object.landmarks[landmarkIndex].position.x = metadata.value(landmarkNames[j]+"_X").toFloat();
-            object.landmarks[landmarkIndex].position.y = metadata.value(landmarkNames[j]+"_Y").toFloat();
-            object.landmarks[landmarkIndex].category = (ppr_landmark_category_type)metadata.value(landmarkNames[j]+"_Category").toInt();
-            object.landmarks[landmarkIndex].model_id = metadata.value(landmarkNames[j]+"_ModelID").toInt();
-            landmarkIndex++;
-        }
-
-        return object;
-    }
-
-    static void freeObject(ppr_object_type &object)
-    {
-        delete[] object.landmarks;
-        object.landmarks = NULL;
-        object.num_landmarks = 0;
-    }
-};
-
-ppr_context_type PP4Context::context;
-
-/*!
- * \ingroup initializers
- * \brief Initialize PittPatt 4
- * \author Josh Klontz \cite jklontz
- * \warning Needs a maintainer.
- */
-class PP4Initializer : public Initializer
-                     , public PP4Context
-{
-    Q_OBJECT
-
-    void initialize() const
-    {
-        context = ppr_get_context();
-        TRY(ppr_enable_recognition(context))
-        TRY(ppr_set_license(context, my_license_id, my_license_key))
-        TRY(ppr_set_models_path(context, qPrintable(Globals->SDKPath + "/models/pp4")))
-        TRY(ppr_set_num_recognition_threads(context, QThreadPool::globalInstance()->maxThreadCount()))
-        TRY(ppr_set_num_detection_threads(context, 1))
-        TRY(ppr_set_detection_precision(context, PPR_FINE_PRECISION))
-        TRY(ppr_set_landmark_detector_type(context, PPR_DUAL_MULTI_POSE_LANDMARK_DETECTOR, PPR_AUTOMATIC_LANDMARKS))
-        TRY(ppr_set_min_size(context, 4))
-        TRY(ppr_set_frontal_yaw_constraint(context, PPR_FRONTAL_YAW_CONSTRAINT_PERMISSIVE))
-        TRY(ppr_set_template_extraction_type(context, PPR_EXTRACT_DOUBLE))
-        TRY(ppr_initialize_context(context))
-        Globals->Abbreviations.insert("PP4", "Open+PP4Detect!PP4Enroll:PP4Compare");
-    }
-
-    void finalize() const
-    {
-        TRY(ppr_release_context(context))
-        ppr_finalize_sdk();
-    }
-};
-
-MM_REGISTER(Initializer, PP4Initializer, "")
-
-/*!
- * \ingroup transforms
- * \brief Detect a face in PittPatt 4
- * \author Josh Klontz \cite jklontz
- * \warning Needs a maintainer.
- */
-class PP4Detect : public UntrainableMetaFeature
-                , public PP4Context
-{
-    Q_OBJECT
-
-    void project(const Template &src, Template &dst) const
-    {
-        dst.file = src.file;
-
-        foreach (const cv::Mat &matrix, src) {
-            ppr_raw_image_type raw_image;
-            createRawImage(matrix, raw_image);
-            ppr_image_type image;
-            TRY(ppr_create_image(raw_image, &image))
-            ppr_object_list_type object_list;
-            TRY(ppr_detect_objects(context, image, &object_list))
-
-            QList<ppr_object_type> objects;
-            if (src.file.getBool("ForceEnrollment")) objects = getBestObject(object_list);
-            else                                     objects = getAllObjects(object_list);
-
-            foreach (const ppr_object_type &object, objects) {
-                dst.file.append(toMetadata(object));
-                dst += matrix;
-            }
-
-            ppr_free_object_list(object_list);
-            ppr_free_image(image);
-            ppr_raw_image_free(raw_image);
-        }
-
-        if (src.file.getBool("ForceEnrollment") && dst.isEmpty()) dst += cv::Mat();
-    }
-
-private:
-    QList<ppr_object_type> getBestObject(ppr_object_list_type object_list) const
-    {
-        int best_index = -1;
-        float best_confidence = 0;
-        for (int i=0; i<object_list.num_objects; i++) {
-            ppr_object_type object = object_list.objects[i];
-            ppr_object_suitability_type suitability;
-            TRY(ppr_is_object_suitable_for_recognition(context, object, &suitability))
-            if (suitability != PPR_OBJECT_SUITABLE_FOR_RECOGNITION) continue;
-            if ((object.confidence > best_confidence) ||
-                (best_index == -1)) {
-                best_confidence = object.confidence;
-                best_index = i;
-            }
-        }
-
-        QList<ppr_object_type> objects;
-        if (best_index != -1) objects.append(object_list.objects[best_index]);
-        return objects;
-    }
-
-    QList<ppr_object_type> getAllObjects(ppr_object_list_type object_list) const
-    {
-        QList<ppr_object_type> objects;
-        for (int i=0; i<object_list.num_objects; i++)
-            objects.append(object_list.objects[i]);
-        return objects;
-    }
-};
-
-MM_REGISTER(Feature, PP4Detect, "")
-
-/*!
- * \ingroup transforms
- * \brief Enroll face in PittPatt 4
- * \author Josh Klontz \cite jklontz
- * \warning Needs a maintainer.
- */
-class PP4Enroll : public UntrainableMetaFeature
-                , public PP4Context
-{
-    Q_OBJECT
-
-    void project(const Template &src, Template &dst) const
-    {
-        if (!src.m().data) {
-            dst += cv::Mat();
-            return;
-        }
-
-        ppr_raw_image_type raw_image;
-        createRawImage(src, raw_image);
-        ppr_image_type image;
-        TRY(ppr_create_image(raw_image, &image))
-
-        ppr_object_type object = fromMetadata(src.file);
-
-        ppr_template_type curr_template;
-        TRY(ppr_extract_template_from_object(context, image, object, &curr_template))
-
-        freeObject(object);
-
-        cv::Mat m;
-        createMat(curr_template, m);
-        dst += m;
-
-        ppr_free_template(curr_template);
-        ppr_free_image(image);
-        ppr_raw_image_free(raw_image);
-    }
-};
-
-MM_REGISTER(Feature, PP4Enroll, "")
-
-
-class PP4Compare : public Comparer,
-                   public PP4Context
-{
-    Q_OBJECT
-
-    void compare(const TemplateList &target, const TemplateList &query, Output *output) const
-    {
-        ppr_gallery_type target_gallery, query_gallery;
-        ppr_create_gallery(context, &target_gallery);
-        ppr_create_gallery(context, &query_gallery);
-        QList<int> target_template_ids, query_template_ids;
-        enroll(target, &target_gallery, target_template_ids);
-        enroll(query, &query_gallery, query_template_ids);
-
-        ppr_similarity_matrix_type similarity_matrix;
-        TRY(ppr_compare_galleries(context, query_gallery, target_gallery, &similarity_matrix))
-
-        for (int i=0; i<query_template_ids.size(); i++) {
-            int query_template_id = query_template_ids[i];
-            for (int j=0; j<target_template_ids.size(); j++) {
-                int target_template_id = target_template_ids[j];
-                float score = -std::numeric_limits<float>::max();
-                if ((query_template_id != -1) && (target_template_id != -1)) {
-                    TRY(ppr_get_similarity_matrix_element(context, similarity_matrix, query_template_id, target_template_id, &score))
-                }
-                output->setData(score, i, j);
-            }
-        }
-
-        ppr_free_similarity_matrix(similarity_matrix);
-        ppr_free_gallery(target_gallery);
-        ppr_free_gallery(query_gallery);
-    }
-
-    void enroll(const TemplateList &templates, ppr_gallery_type *gallery, QList<int> &template_ids) const
-    {
-        foreach (const Template &t, templates) {
-            if (t.m().data) {
-                ppr_template_type u;
-                createTemplate(t.m(), &u);
-                int template_id;
-                TRY(ppr_copy_template_to_gallery(context, gallery, u, &template_id))
-                template_ids.append(template_id);
-                ppr_free_template(u);
-            } else {
-                template_ids.append(-1);
-            }
-        }
-    }
-};
-
-MM_REGISTER(Comparer, PP4Compare, "")
-
-#include "plugins/pp4.moc"
@@ -141,13 +141,15 @@ class CatColsTransform : public UntrainableMetaTransform
  
     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;
-        Mat m = OpenCVUtils::toMatByRow(src);
-        // right now this just splits src in half and joins them horizontally
-        // TODO: add partitions parameter for more than a single split
-        Mat first = m.rowRange(Range(0, m.rows/2));
-        Mat second = m.rowRange(Range(m.rows/2, m.rows));
-        hconcat(first, second, dst);
     }
 };
  
@@ -54,6 +54,9 @@ class StasmTransform : public UntrainableTransform
 {
     Q_OBJECT
  
+    Q_PROPERTY(bool stasm3Format READ get_stasm3Format WRITE set_stasm3Format RESET reset_stasm3Format STORED false)
+    BR_PROPERTY(bool, stasm3Format, false)
+
     Resource<StasmCascadeClassifier> stasmCascadeResource;
  
     void init()
@@ -69,14 +72,20 @@ class StasmTransform : public UntrainableTransform
         StasmCascadeClassifier *stasmCascade = stasmCascadeResource.acquire();
  
         int foundface;
+        int nLandmarks = stasm_NLANDMARKS;
         float landmarks[2 * stasm_NLANDMARKS];
         stasm_search_single(&foundface, landmarks, reinterpret_cast<const char*>(src.m().data), src.m().cols, src.m().rows, *stasmCascade, NULL, NULL);
  
+        if (stasm3Format) {
+            nLandmarks = 76;
+            stasm_convert_shape(landmarks, nLandmarks);
+        }
+
         stasmCascadeResource.release(stasmCascade);
  
         if (!foundface) qWarning("No face found in %s", qPrintable(src.file.fileName()));
         else {
-            for (int i = 0; i < stasm_NLANDMARKS; i++)
+            for (int i = 0; i < nLandmarks; i++)
                 dst.file.appendPoint(QPointF(landmarks[2 * i], landmarks[2 * i + 1]));
         }
  
@@ -364,6 +364,7 @@ protected:
     QMutex last_frame_update;
 };
  
+static QMutex openLock;
 // Read a video frame by frame using cv::VideoCapture
 class VideoDataSource : public DataSource
 {
@@ -396,6 +397,8 @@ public:
             // Yes, we should specify absolute path:
             // http://stackoverflow.com/questions/9396459/loading-a-video-in-opencv-in-python
             QString fileName = (Globals->path.isEmpty() ? "" : Globals->path + "/") + input.file.name;
+            // On windows, this appears to not be thread-safe
+            QMutexLocker lock(&openLock);
             video.open(QFileInfo(fileName).absoluteFilePath().toStdString());
         }
  
@@ -707,8 +710,7 @@ public:
         if (input == NULL) {
             qFatal("null input to multi-thread stage");
         }
-        // Project the input we got
-        transform->projectUpdate(input->data);
+        input->data >> *transform;
  
         should_continue = nextStage->tryAcquireNextStage(input);
  
@@ -1058,7 +1060,10 @@ public:
         dst = src;
  
         bool res = readStage->dataSource.open(dst);
-        if (!res) return;
+        if (!res) {
+            qDebug("stream failed to open %s", qPrintable(dst[0].file.name));
+            return;
+        }
  
         // Start the first thread in the stream.
         QWriteLocker lock(&readStage->statusLock);
@@ -1300,6 +1305,7 @@ public:
     {
         if (!transform)
             return;
+
         trainable = transform->trainable;
  
         basis.setParent(this->parent());
-set(BR_WITH_TOPSURF OFF CACHE BOOL "Build with TOP-SURF")
-
-if(${BR_WITH_TOPSURF})
-  find_package(TopSurf REQUIRED)
-  set(THIRDPARTY_SRC ${THIRDPARTY_SRC} plugins/topsurf.cpp ${TOPSURF_SRC} ${TOPSURF_FLANN_SRC})
-  install(DIRECTORY ${TOPSURF_DIR}/dictionary_10000
-                    ${TOPSURF_DIR}/dictionary_20000
-                    ${TOPSURF_DIR}/dictionary_40000
-          DESTINATION models/topsurf)
-endif()
-#include <topsurf/descriptor.h>
-#include <topsurf/topsurf.h>
-#include <mm_plugin.h>
-
-#include "common/opencvutils.h"
-#include "common/qtutils.h"
-#include "common/resource.h"
-
-using namespace cv;
-using namespace mm;
-using namespace std;
-
-class TopSurfInitializer : public Initializer
-{
-    void initialize() const
-    {
-        Globals.Abbreviations.insert("TopSurf", "Open!TopSurfExtract(40000):TopSurfCompare");
-        Globals.Abbreviations.insert("TopSurfM", "Open!TopSurfExtract(1000000):TopSurfCompare");
-        Globals.Abbreviations.insert("TopSurfKNN", "Open!TopSurfExtract+TopSurfKNN");
-        Globals.Abbreviations.insert("DocumentClassification", "TopSurfKNN");
-    }
-
-    void finalize() const {}
-};
-
-MM_REGISTER(Initializer, TopSurfInitializer, false)
-
-
-class TopSurfResourceMaker : public ResourceMaker<TopSurf>
-{
-    QString file;
-
-public:
-    TopSurfResourceMaker(const QString &dictionary)
-    {
-        file = Globals.SDKPath + "/models/topsurf/dictionary_" + dictionary;
-    }
-
-private:
-    TopSurf *make() const
-    {
-        TopSurf *topSurf = new TopSurf(256, 100);
-        if (!topSurf->LoadDictionary(qPrintable(file)))
-            qFatal("TopSurfResourceMaker::make failed to load dictionary.");
-        return topSurf;
-    }
-};
-
-
-/****
-TopSurfExtract
-    Wrapper to TopSurf::ExtractDescriptor()
-    B. Thomee, E.M. Bakker, and M.S. Lew, "TOP-SURF: a visual words toolkit",
-    in Proceedings of the 18th ACM International Conference on Multimedia, pp. 1473-1476, Firenze, Italy, 2010.
-****/
-class TopSurfExtract : public UntrainableFeature
-{
-    Q_OBJECT
-    Q_PROPERTY(QString dictionary READ get_dictionary WRITE set_dictionary)
-    MM_MEMBER(QString, dictionary)
-
-    Resource<TopSurf> topSurfResource;
-
-public:
-    TopSurfExtract() : topSurfResource(new TopSurfResourceMaker("10000")) {}
-
-private:
-    void init()
-    {
-        topSurfResource.setResourceMaker(new TopSurfResourceMaker(dictionary));
-    }
-
-    void project(const Template &src, Template &dst) const
-    {
-        // Compute descriptor (not thread safe)
-        TopSurf *topSurf = topSurfResource.acquire();
-        TOPSURF_DESCRIPTOR descriptor;
-        IplImage iplSrc = src.m();
-        if (!topSurf->ExtractDescriptor(iplSrc, descriptor))
-            qFatal("TopSurfExtract::project ExtractDescriptor failure.");
-        topSurfResource.release(topSurf);
-
-        // Copy descriptor and clean up
-        unsigned char *data;
-        int length;
-        Descriptor2Array(descriptor, data, length);
-        Mat m(1, length, CV_8UC1);
-        memcpy(m.data, data, length);
-        delete data;
-        TopSurf::ReleaseDescriptor(descriptor);
-        dst = m;
-    }
-
-public:
-    static QString args()
-    {
-        return "10000|20000|40000 dictionary = 10000";
-    }
-
-    static TopSurfExtract *make(const QStringList &args)
-    {
-        (void) args;
-        return new TopSurfExtract();
-    }
-};
-
-MM_REGISTER(Feature, TopSurfExtract, true)
-
-
-class TopSurfHist : public UntrainableFeature
-{
-    Q_OBJECT
-    Q_PROPERTY(int size READ get_size WRITE set_size)
-    MM_MEMBER(int, size)
-
-    void project(const Template &src, Template &dst) const
-    {
-        TOPSURF_DESCRIPTOR td;
-        Array2Descriptor(src.m().data, td);
-
-        Mat m(1, size, CV_32FC1);
-        m.setTo(0);
-        for (int i=0; i<td.count; i++)
-            m.at<float>(0, td.visualword[i].identifier % size)++;
-
-        TopSurf::ReleaseDescriptor(td);
-        dst = m;
-    }
-
-public:
-    static QString args()
-    {
-        return "int size = 10000";
-    }
-
-    static TopSurfHist *make(const QStringList &args)
-    {
-        (void) args;
-        return new TopSurfHist();
-    }
-};
-
-MM_REGISTER(Feature, TopSurfHist, true)
-
-
-// Wrapper around TopSurf CompareDescriptors
-float TopSurfSimilarity(const Mat &a, const Mat &b, bool cosine)
-{
-    TOPSURF_DESCRIPTOR tda, tdb;
-    Array2Descriptor(a.data, tda);
-    Array2Descriptor(b.data, tdb);
-
-    float result;
-    if (cosine) result = TopSurf::CompareDescriptorsCosine(tda, tdb);
-    else        result = TopSurf::CompareDescriptorsAbsolute(tda, tdb);
-
-    TopSurf::ReleaseDescriptor(tda);
-    TopSurf::ReleaseDescriptor(tdb);
-    return result;
-}
-
-
-/****
-TopSurfCompare
-    Wrapper to TopSurf_CompareDescriptors()
-    B. Thomee, E.M. Bakker, and M.S. Lew, "TOP-SURF: a visual words toolkit",
-    in Proceedings of the 18th ACM International Conference on Multimedia, pp. 1473-1476, Firenze, Italy, 2010.
-****/
-class TopSurfCompare : public ComparerBase
-{
-    Q_OBJECT
-    Q_PROPERTY(bool cosine READ get_cosine WRITE set_cosine)
-    MM_MEMBER(bool, cosine)
-
-    float compare(const Mat &a, const Mat &b) const
-    {
-        return TopSurfSimilarity(a, b, cosine);
-    }
-
-public:
-    static QString args()
-    {
-        return "bool cosine = 1";
-    }
-
-    static TopSurfCompare *make(const QStringList &args)
-    {
-        (void) args;
-        return new TopSurfCompare();
-    }
-};
-
-MM_REGISTER(Comparer, TopSurfCompare, true)
-
-
-/****
-TopSurfKNN
-    KNN classifier for TopSurf features.
-****/
-class TopSurfKNN : public Feature
-{
-    Q_OBJECT
-    Q_PROPERTY(int k READ get_k WRITE set_k)
-    Q_PROPERTY(bool cosine READ get_cosine WRITE set_cosine)
-    MM_MEMBER(int, k)
-    MM_MEMBER(bool, cosine)
-
-    TemplateList data;
-
-private:
-    void train(const TemplateList &data)
-    {
-        this->data = data;
-    }
-
-    void project(const Template &src, Template &dst) const
-    {
-        // Compute distance to each descriptor
-        QList< QPair<float, int> > distances; // <distance, label>
-        distances.reserve(data.size());
-        foreach (const Template &t, data)
-            distances.append(QPair<float, int>(TopSurfSimilarity(src, t, cosine), t.file.label()));
-
-        // Find nearest neighbors
-        qSort(distances);
-        QHash<int, QPair<int, float> > counts; // <label, <count, cumulative distance>>
-        for (int i=0; i<k; i++) {
-            QPair<float,int> &distance = distances[i];
-            QPair<int,float> &count = counts[distance.second];
-            count.first++;
-            count.second += distance.first;
-        }
-
-        // Find most occuring label
-        int best_label = -1;
-        int best_count = 0;
-        float best_distance = numeric_limits<float>::max();
-        foreach (int label, counts.keys()) {
-            const QPair<int, float> &count = counts[label];
-            if ((count.first > best_count) || ((count.first == best_count) && (count.second < best_distance))) {
-                best_label = label;
-                best_count = count.first;
-                best_distance = count.second;
-            }
-        }
-        assert(best_label != -1);
-
-        // Measure confidence
-        int rest_count = 0;
-        float rest_distance = 0;
-        foreach (int label, counts.keys()) {
-            if (label != best_label) {
-                const QPair<int, float> &count = counts[label];
-                rest_count = count.first;
-                rest_distance = count.second;
-            }
-        }
-
-        dst = src;
-        dst.file["Label"] = best_label;
-        dst.file["Confidence"] = (float)best_count/(float)k;
-    }
-
-    void store(QDataStream &stream) const
-    {
-        stream << data;
-    }
-
-    void load(QDataStream &stream)
-    {
-        stream >> data;
-    }
-
-public:
-    static QString args()
-    {
-        return "int k, int cosine = 1";
-    }
-
-    static TopSurfKNN *make(const QStringList &args)
-    {
-        (void) args;
-        return new TopSurfKNN();
-    }
-};
-
-MM_REGISTER(Feature, TopSurfKNN, true)
-
-#include "topsurf.moc"
@@ -19,9 +19,9 @@ class CrossValidateTransform : public MetaTransform
 {
     Q_OBJECT
     Q_PROPERTY(QString description READ get_description WRITE set_description RESET reset_description STORED false)
-    Q_PROPERTY(bool leaveOneOut READ get_leaveOneOut WRITE set_leaveOneOut RESET reset_leaveOneOut STORED false)
+    Q_PROPERTY(bool leaveOneImageOut READ get_leaveOneImageOut WRITE set_leaveOneImageOut RESET reset_leaveOneImageOut STORED false)
     BR_PROPERTY(QString, description, "Identity")
-    BR_PROPERTY(bool, leaveOneOut, false)
+    BR_PROPERTY(bool, leaveOneImageOut, false)
  
     QList<br::Transform*> transforms;
  
@@ -49,10 +49,10 @@ class CrossValidateTransform : public MetaTransform
             int j = partitionedData.size()-1;
             while (j>=0) {
                 // Remove all templates belonging to partition i
-                // if leaveOneOut is true,
+                // if leaveOneImageOut is true,
                 // and i is greater than the number of images for a particular subject
                 // even if the partitions are different
-                if (leaveOneOut) {
+                if (leaveOneImageOut) {
                     const QString label = partitionedData.at(j).file.get<QString>("Label");
                     QList<int> subjectIndices = partitionedData.find("Label",label);
                     QList<int> removed;
@@ -80,6 +80,7 @@ class CrossValidateTransform : public MetaTransform
                     }
                 } else if (partitions[j] == i) {
                     partitionedData.removeAt(j);
+                    j--;
                 } else j--;
             }
             // Train on the remaining templates
-set(BR_WITH_YUBICO OFF CACHE BOOL "Build YubiKey authentication")
-
-if(${BR_WITH_YUBICO})
-  find_package(YubiKey REQUIRED) # For decrypting YubiKeys
-  find_package(YKPers REQUIRED)  # For reading YubiKeys
-
-  install(FILES ${YUBIKEY_LICENSE} RENAME YubiKey DESTINATION share/openbr/licenses)
-  install(FILES ${YKPERS_LICENSE} RENAME YKPers DESTINATION share/openbr/licenses)
-  install(FILES ${YKPERS_RULES} DESTINATION share/openbr)
-
-  set(BR_THIRDPARTY_SRC ${BR_THIRDPARTY_SRC} ${YUBIKEY_SRC} ${YKPERS_SRC} plugins/yubico.cpp)
-  set(BR_THIRDPARTY_LIBS ${BR_THIRDPARTY_LIBS} ${YKPERS_LIBS})
-endif()
-#include <mm_plugin.h>
-#include <yubikey.h>
-#include <ykdef.h>
-#include <ykpers.h>
-#include <stdlib.h>
-#include <time.h>
-
-/****
-YubiKey Challenge-Response Authentication
-
-To configure YubiKeys for mm usage:
-1) Download the cross platform personalization tool from http://yubico.com/personalization-tool.
-2) Insert YubiKey and launch the personalization tool (may require sudo access).
-3) Click "Challenge-Response Mode".
-4) Click "Yubico OTP".
-5) Select "Configuration Slot 2"
-6) In the Private Identity text box enter "21 92 78 11 55 8a".
-7) In the Secret Key text box enter "e7 32 df 49 f3 87 e6 89 04 d2 03 6a 59 ad b7 2f".
-8) Click "Write Configuration".
-9) Done!
-
-Unix implementation derived from "ykchalresp.c" in ykpers repository.
-Windows implementation derived from "MFCTestDlg.cpp" in Yubikey Client API installer.
-
-!!! Attention Linux Users !!!
-cp trunk/3rdparty/ykpers-1.6.3/70-yubikey.rules /etc/udev/rules.d
-
-!!! Attention Windows Users !!!
-Install Yubikey Client API.
-****/
-
-using namespace mm;
-
-static int challenge_response(YK_KEY *yk, int slot,
-                              unsigned char *challenge, unsigned int len,
-                              bool hmac, bool may_block, bool verbose, unsigned char output_buf[(SHA1_MAX_BLOCK_SIZE * 2) + 1])
-{
-    unsigned char response[64];
-    int yk_cmd;
-    unsigned int flags = 0;
-    unsigned int response_len = 0;
-    unsigned int expect_bytes = 0;
-
-    memset(response, 0, sizeof(response));
-
-    if (may_block)
-        flags |= YK_FLAG_MAYBLOCK;
-
-    if (verbose) {
-        fprintf(stderr, "Sending %i bytes %s challenge to slot %i\n", len, (hmac == true) ? "HMAC" : "Yubico", slot);
-        //_yk_hexdump(challenge, len);
-    }
-
-    switch(slot) {
-    case 1:
-        yk_cmd = (hmac == true) ? SLOT_CHAL_HMAC1 : SLOT_CHAL_OTP1;
-        break;
-    case 2:
-        yk_cmd = (hmac == true) ? SLOT_CHAL_HMAC2 : SLOT_CHAL_OTP2;
-        break;
-    }
-
-    if (!yk_write_to_key(yk, yk_cmd, challenge, len))
-        return 0;
-
-    if (verbose) {
-        fprintf(stderr, "Reading response...\n");
-    }
-
-    /* HMAC responses are 160 bits, Yubico 128 */
-    expect_bytes = (hmac == true) ? 20 : 16;
-
-    if (! yk_read_response_from_key(yk, slot, flags,
-                                    &response, sizeof(response),
-                                    expect_bytes,
-                                    &response_len))
-        return 0;
-
-    if (hmac && response_len > 20)
-        response_len = 20;
-    if (! hmac && response_len > 16)
-        response_len = 16;
-
-    memset(output_buf, 0, SHA1_MAX_BLOCK_SIZE * 2 + 1);
-    if (hmac) {
-        yubikey_hex_encode((char *)output_buf, (char *)response, response_len);
-    } else {
-        yubikey_modhex_encode((char *)output_buf, (char *)response, response_len);
-    }
-    // printf("%s\n", output_buf);
-
-    return 1;
-}
-
-/*!
- * \ingroup initializers
- * \brief Initialize yubikey
- * \author Josh Klontz \cite jklontz
- */
-class YubiKey : public Initializer
-{
-    Q_OBJECT
-
-    void initialize() const
-    {
-        // Read from device
-        YK_KEY *yk = 0;
-
-        if (!yk_init())
-            qFatal("YubiKey::initialize yk_init failure.");
-
-        if (!(yk = yk_open_first_key()))
-            qFatal("Could not connect to license.");
-
-        // Challenge value is arbitrary
-        srand(time(NULL));
-        uint8_t challenge[6] = {rand()%255, rand()%255, rand()%255, rand()%255, rand()%255, rand()%255};
-        unsigned char output_buf[(SHA1_MAX_BLOCK_SIZE * 2) + 1];
-        if (!challenge_response(yk, 2, challenge, 6, false, true, false, output_buf))
-            qFatal("YubiKey::initialize challenge_response failure.");
-
-        if (yk && !yk_close_key(yk))
-            qFatal("YubiKey::initialize yk_close_key failure.");
-
-        if (!yk_release())
-            qFatal("YubiKey::initialize yk_release failure.");
-
-        // Check response
-        // Our Secret Key! Shhh...
-        const uint8_t key[YUBIKEY_KEY_SIZE] = {0xe7, 0x32, 0xdf, 0x49, 0xf3, 0x87, 0xe6, 0x89, 0x04, 0xd2, 0x03, 0x6a, 0x59, 0xad, 0xb7, 0x2f};
-        yubikey_token_st out;
-        yubikey_parse(output_buf, key, &out);
-
-        // Our Private Identity! Shhh...
-        uint8_t uid[YUBIKEY_UID_SIZE] = {0x21, 0x92, 0x78, 0x11, 0x55, 0x8a};
-        if ((uid[0] != (out.uid[0] ^ challenge[0])) ||
-            (uid[1] != (out.uid[1] ^ challenge[1])) ||
-            (uid[2] != (out.uid[2] ^ challenge[2])) ||
-            (uid[3] != (out.uid[3] ^ challenge[3])) ||
-            (uid[4] != (out.uid[4] ^ challenge[4])) ||
-            (uid[5] != (out.uid[5] ^ challenge[5])))
-            qFatal("Invalid license.");
-    }
-
-    void finalize() const
-    {
-        // Nothing to do
-    }
-};
-
-MM_REGISTER(Initializer,YubiKey,"")
-
-#include "yubico.moc"
-# ================================================================
-# The CT8 CMake configuration file
-#
-# Usage from an external project:
-#   In your CMakeLists.txt, add these lines:
-#
-#   find_package(CT8 REQUIRED)
-#   target_link_libraries(MY_TARGET ${CT8_LIBS})
-# ================================================================
-
-set(CT8_DIR "CT8_DIR-NOTFOUND" CACHE PATH "Cognitec FaceVACS 8.x directory")
-
-
-if("${CMAKE_SIZEOF_VOID_P}" EQUAL "8")
-  set(ARCH_STRING x86_64)
-else("${CMAKE_SIZEOF_VOID_P}" EQUAL "8")
-  set(ARCH_STRING x86_32)
-endif("${CMAKE_SIZEOF_VOID_P}" EQUAL "8")
-
-if(DEFINED MSVC80)
-  set(COMP_DIR_EXT "msc_8.0-ipp_crtdll")
-elseif(DEFINED MSVC90)
-  set(COMP_DIR_EXT "msc_9.0-ipp_crtdll")
-elseif(DEFINED MSVC10)
-  set(COMP_DIR_EXT "msc_10.0-ipp_crtdll")
-elseif(CMAKE_HOST_APPLE)
-  set(COMP_DIR_EXT "gcc-4.2-ipp")
-else()
-  set(COMP_DIR_EXT "gcc-4.3-ipp")
-endif()
-
-set(CT8_DIR_LIB ${CT8_DIR}/lib/${ARCH_STRING}/${COMP_DIR_EXT} )
-set(CT8_LIBRARY_RELEASE libfrsdk-8.6.0)
-set(CT8_LIBRARY_DEBUG libfrsdk-8.6.0d)
-
-include_directories(${CT8_DIR}/include)
-link_directories(${CT8_DIR_LIB} ${CT8_DIR_LIB}_g)
-find_path(FST3_DIR _src_criteria/classifier.hpp ${CMAKE_SOURCE_DIR}/3rdparty/*)
-mark_as_advanced(FST3_DIR)
-include_directories(${FST3_DIR}/_src_criteria ${FST3_DIR}/_src_dataio ${FST3_DIR}/_src_global ${FST3_DIR}/_src_search)
-set(FST3_SRC ${FST3_DIR}/_src_global/global.cpp)
-# ================================================================
-# The PP4 CMake configuration file
-#
-# Usage from an external project:
-#   In your CMakeLists.txt, add these lines:
-#
-#   find_package(PP4 REQUIRED)
-#   target_link_libraries(MY_TARGET ${PP4_LIBS})
-# ================================================================
-
-find_path(PP4_DIR include/pittpatt_nc_sdk.h ${CMAKE_SOURCE_DIR}/3rdparty/*)
-include_directories(${PP4_DIR}/include)
-link_directories(${PP4_DIR}/lib)
-set(PP4_LIBS pittpatt_nc_sdk
-             pittpatt_raw_image
-             pittpatt_raw_image_io
-             pittpatt_recognition_core
-             pittpatt_video_io)
-find_path(TOPSURF_DIR topsurf/topsurf.h ${CMAKE_SOURCE_DIR}/3rdparty/*)
-mark_as_advanced(TOPSURF_DIR)
-include_directories(${TOPSURF_DIR})
-aux_source_directory(${TOPSURF_DIR}/topsurf TOPSURF_SRC)
-aux_source_directory(${TOPSURF_DIR}/topsurf/flann TOPSURF_FLANN_SRC)
-find_path(YUBIKEY_DIR yubikey.h ${CMAKE_SOURCE_DIR}/3rdparty/*)
-mark_as_advanced(YUBIKEY_DIR)
-include_directories(${YUBIKEY_DIR})
-if(MSVC)
-  include_directories(${YUBIKEY_DIR}/stdbool)
-endif()
-
-if(NOT TARGET yubikey)
-  set(YUBIKEY_SRC ${YUBIKEY_DIR}/ykaes.c ${YUBIKEY_DIR}/ykcrc.c ${YUBIKEY_DIR}/ykhex.c ${YUBIKEY_DIR}/ykmodhex.c ${YUBIKEY_DIR}/yktoken.c)
-  if(WIN32)
-    set_source_files_properties(${YUBIKEY_SRC} PROPERTIES LANGUAGE CXX)
-  endif()
-endif()
-
-set(YUBIKEY_LICENSE ${YUBIKEY_DIR}/COPYING)
-find_path(PHASH_DIR src/pHash.h ${CMAKE_SOURCE_DIR}/3rdparty/*)
-mark_as_advanced(PHASH_DIR)
-include_directories(${PHASH_DIR} ${PHASH_DIR}/src)
-set(PHASH_SRC ${PHASH_DIR}/src/pHash.cpp ${PHASH_DIR}/src/ph_fft.c)
-Subproject commit dccddf4dd3a5239911807beeec39308f8890b1e4
+Subproject commit a73d51013ea05f263e88a28539393159fff2183e