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

Charles Otto
2 parents 9670e296 ead4a56a
Showing 36 changed files with 478 additions and 1667 deletions
CHANGELOG.md
app/br/br.cpp
data/FDDB/README.md
data/README.md
openbr/core/plot.cpp
openbr/core/plot.h
openbr/core/resource.h
openbr/openbr.cpp
openbr/openbr.h
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/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"
+## FDDB Face Detection Data Set and Benchmark
+Unconstrained face detection dataset containing 2845 images with 5171 annotated face locations. Contained in this directory are .FDDB files for train and test splits for FDDB. These are based on the `FDDB-folds` directory that comes with the original dataset, but organized as 10 different train/test splits instead of 10 folds. All splits are based on the original folds.
+
+Image data currently available online.
+* [Website](http://vis-www.cs.umass.edu/fddb/)
@@ -10,6 +10,7 @@
 * [MNIST](MNIST/README.md)
 * [PCSO](PCSO/README.md)
 * [KTH](KTH/README.md)
+* [FDDB](FDDB/README.md) 
  
 For both practical and legal reasons we only include images for some of the datasets in this repository.
 Researchers should contact the respective owners of the other datasets in order to obtain a copy.
@@ -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:
@@ -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"
@@ -13,6 +18,109 @@ using namespace cv;
  
 namespace br
 {
+// Generally speaking, Qt wants GUI objects to be on the main thread, and
+// for the main thread to be in an event loop. We don't restrict transform
+// creation to just the main thread, but in br we do compromise and put
+// the main thread in an event loop (and so should any applications wanting to
+// use GUI transforms). This does mean we need a way to make our QWidget subclasses
+// on the main thread. We can't create them from an arbitrary thread, then move them
+// (you know, since that would be crazy), so we need some tricks to get the main
+// thread to make these objects.
+
+// Part 1. A generic interface for creating objects, the type of object
+// created is not exposed in the interface.
+class NominalCreation
+{
+public:
+    virtual ~NominalCreation() {}
+    virtual void creation()=0;
+};
+
+// Part 2. A template class that creates an object of the specified type
+// through the interface defined in part 1. The point of this is that the
+// type of object created can be hidden by using a NominalCreation *.
+template<typename T>
+class ActualCreation : public NominalCreation
+{
+public:
+    T * basis;
+
+    void creation()
+    {
+        basis = new T();
+    }
+};
+
+// Part 3. A class that inherits from QObject, but not QWidget. This means
+// we are free to move it to the main thread.
+// If this object is on the main thread, and we signal one of its slots, then
+// the slot will be executed by the main thread, which is what we need.
+// Unfortunately, since it uses Q_OBJECT we cannot make it a template class, but
+// we still want to be able to make objects of arbitrary type on the main thread,
+// so that we don't need a different adaptor for every type of QWidget subclass we use.
+class MainThreadCreator : public QObject
+{
+    Q_OBJECT
+public:
+
+    MainThreadCreator()
+    {
+        this->moveToThread(QApplication::instance()->thread());
+        // We actually bind a signal on this object to one of its own slots.
+        // the signal will be emitted by a call to getItem from an abitrary
+        // thread.
+        connect(this, SIGNAL(needCreation()), this, SLOT(createThing()), Qt::BlockingQueuedConnection);
+    }
+
+    // While this cannot be a template class, it can still have a template
+    // method. Which is useful, but the slot which will actually be executed
+    // by the main thread cannot be a template. So, we use the template method
+    // here (called from an arbitrary thread, to create an object of arbitrary type)
+    // to instantiate an ActualCreation object with matching type, then we hide
+    // the template with the NominalCreation interface, and call worker->creation
+    // in the slot.
+    template<typename T>
+    T * getItem()
+    {
+        // If this is called by the main thread, we can just create the object
+        // it's important to check, otherwise we will have problems trying to
+        // wait for a blocking connection that is supposed to be processed by
+        // the thread that is waiting.
+        if (QThread::currentThread() == QApplication::instance()->thread())
+            return new T();
+
+        // Create the object creation interface
+        ActualCreation<T> * actualWorker;
+        actualWorker = new ActualCreation<T> ();
+        // hide it
+        worker = actualWorker;
+
+        // emit the signal, we set up a blocking queued connection, so
+        // this is a blocking wait for the slot to finish being run.
+        emit needCreation();
+
+        // collect the results, and return.
+        T * output = actualWorker->basis;
+        delete actualWorker;
+        return output;
+    }
+
+    NominalCreation * worker;
+
+signals:
+    void needCreation();
+
+public slots:
+    // The actual slot, to be run by the main thread. The type
+    // of object being created is not, and indeed cannot, be exposed here
+    // since this cannot be a template method, and the class cannot be a
+    // template class.
+    void createThing()
+    {
+        worker->creation();
+    }
+};
+
 QImage toQImage(const Mat &mat)
 {
     // Convert to 8U depth
@@ -65,6 +173,7 @@ public:
  
     DisplayWindow(QWidget * parent = NULL) : QLabel(parent)
     {
+        setFixedSize(200,200);
         QApplication::instance()->installEventFilter(this);
     }
  
@@ -75,7 +184,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,74 +303,84 @@ private:
  
 };
  
-
-// I want a template class that doesn't look like a template class
-class NominalCreation
+class DisplayGUI : public QMainWindow
 {
-public:
-    virtual ~NominalCreation() {}
-    virtual void creation()=0;
-};
+    Q_OBJECT
  
-// Putting the template on a subclass means we can maintain a pointer that
-// doesn't include T in its type.
-template<typename T>
-class ActualCreation : public NominalCreation
-{
 public:
-    T * basis;
  
-    void creation()
+    DisplayGUI(QWidget * parent = NULL) : QMainWindow(parent)
     {
-        basis = new T();
-    }
-};
+        centralWidget = new QWidget();
+        layout = new QHBoxLayout();
+        inputLayout = new QVBoxLayout();
  
-// We want to create a QLabel subclass on the main thread, but are running in another thread.
-// We cannot move QWidget subclasses to a different thread (obviously that would be crazy), but
-// we can create one of these, and move it to the main thread, and then use it to create the object
-// we want.
-// Additional fact: QObject subclasses cannot be template classes.
-class MainThreadCreator : public QObject
-{
-    Q_OBJECT
-public:
+        button.setText("Set Template Metadata");
  
-    MainThreadCreator()
-    {
-        this->moveToThread(QApplication::instance()->thread());
+        layout->addWidget(&label);
  
-        connect(this, SIGNAL(needCreation()), this, SLOT(createThing()), Qt::BlockingQueuedConnection);
+        inputLayout->addWidget(&button);
+        layout->addLayout(inputLayout);
+
+        centralWidget->setLayout(layout);
+
+        setCentralWidget(centralWidget);
+
+        connect(&button, SIGNAL(clicked()), this, SLOT(buttonPressed()));
     }
  
-    // While this cannot be a template class, it can still have a template method.
-    template<typename T>
-    T * getItem()
+public slots:
+    void showImage(const QPixmap & input)
     {
-        if (QThread::currentThread() == QApplication::instance()->thread())
-            return new T();
+        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);
+        }
  
-        ActualCreation<T> * actualWorker;
-        actualWorker = new ActualCreation<T> ();
-        worker = actualWorker;
+        show();
+        label.setPixmap(pixmap);
+        label.setFixedSize(input.size());
+    }
  
-        emit needCreation();
+    QStringList waitForButtonPress()
+    {
+        QMutexLocker locker(&lock);
+        wait.wait(&lock);
  
-        T * output = actualWorker->basis;
-        delete actualWorker;
-        return output;
+        QStringList values;
+        for(int i = 0; i<fields.size(); i++) values.append(fields.at(i)->text());
+        return values;
     }
  
-    NominalCreation * worker;
+public slots:
  
-signals:
-    void needCreation();
+    void buttonPressed()
+    {
+        wait.wakeAll();
+    }
  
-public slots:
-    void createThing()
+    void setKeys(const QStringList& k)
     {
-        worker->creation();
+        keys = k;
     }
+
+private:
+
+    QWidget *centralWidget;
+    QStringList keys;
+    QList<QLineEdit*> fields;
+    QPushButton button;
+    QMutex lock;
+    QWaitCondition wait;
+    QPixmap pixmap;
+    QLabel label;
+    QHBoxLayout *layout;
+    QVBoxLayout *inputLayout;
+
 };
  
 /*!
@@ -288,17 +413,11 @@ public:
  
     void train(const TemplateList &data) { (void) data; }
  
-    void project(const TemplateList &src, TemplateList &dst) const
-    {
-        Transform * non_const = (ShowTransform *) this;
-        non_const->projectUpdate(src,dst);
-    }
-
     void projectUpdate(const TemplateList &src, TemplateList &dst)
     {
         dst = src;
  
-        if (src.empty() || !Globals->useGui)
+        if (src.empty())
             return;
  
         foreach (const Template & t, src) {
@@ -427,6 +546,98 @@ 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 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
@@ -489,6 +700,11 @@ public:
 BR_REGISTER(Transform, SurveyTransform)
  
  
+/*!
+ * \ingroup transforms
+ * \brief Limits the frequency of projects going through this transform to the input targetFPS
+ * \author Charles Otto \cite caotto
+ */
 class FPSLimit : public TimeVaryingTransform
 {
     Q_OBJECT
@@ -539,6 +755,12 @@ protected:
 };
 BR_REGISTER(Transform, FPSLimit)
  
+/*!
+ * \ingroup transforms
+ * \brief Calculates the average FPS of projects going through this transform, stores the result in AvgFPS
+ * Reports an average FPS from the initialization of this transform onwards.
+ * \author Charles Otto \cite caotto
+ */
 class FPSCalc : public TimeVaryingTransform
 {
     Q_OBJECT
@@ -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);
     }
@@ -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
@@ -116,12 +116,12 @@ public:
  
     virtual void project(const Template &src, Template &dst) const
     {
-        timeInvariantAlias->project(src,dst);
+        timeInvariantAlias.project(src,dst);
     }
  
     virtual void project(const TemplateList &src, TemplateList &dst) const
     {
-        timeInvariantAlias->project(src,dst);
+        timeInvariantAlias.project(src,dst);
     }
  
     // Get a compile failure if this isn't here to go along with the other
@@ -150,21 +150,13 @@ public:
         return this->clone();
     }
  
-    void init()
-    {
-        delete timeInvariantAlias;
-        timeInvariantAlias = new TimeInvariantWrapperTransform(this);
-    }
-
 protected:
-    Transform * timeInvariantAlias;
-    TimeVaryingTransform(bool independent = true, bool trainable = true) : Transform(independent, trainable)
+    // 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)
     {
-        timeInvariantAlias = NULL;
-    }
-    ~TimeVaryingTransform()
-    {
-        delete timeInvariantAlias;
+        //
     }
 };
  
@@ -183,7 +175,7 @@ public:
     virtual void project(const Template &src, Template &dst) const
     {
         if (timeVarying()) {
-            timeInvariantAlias->project(src,dst);
+            timeInvariantAlias.project(src,dst);
             return;
         }
         _project(src, dst);
@@ -192,7 +184,7 @@ public:
     virtual void project(const TemplateList &src, TemplateList &dst) const
     {
         if (timeVarying()) {
-            timeInvariantAlias->project(src,dst);
+            timeInvariantAlias.project(src,dst);
             return;
         }
         _project(src, dst);
@@ -209,10 +201,6 @@ public:
             isTimeVarying = isTimeVarying || transform->timeVarying();
             trainable = trainable || transform->trainable;
         }
-
-        // If we are time varying, set up timeInvariantAlias
-        if (this->timeVarying())
-            TimeVaryingTransform::init();
     }
  
     /*!
-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"
@@ -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());
         }
  
@@ -1119,7 +1122,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);
@@ -1368,11 +1374,6 @@ public:
         if (!transform)
             return;
  
-        // Set up timeInvariantAlias
-        // this is only safe because copies are actually made in project
-        // calls, not during init.
-        TimeVaryingTransform::init();
-
         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"
@@ -89,6 +89,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