introduced static File::get that can operate on both FileList and TemplateList

Josh Klontz
1 parent 11ea4c85
Showing 8 changed files with 51 additions and 58 deletions
openbr/core/bee.cpp
openbr/core/cluster.cpp
openbr/openbr_plugin.cpp
openbr/openbr_plugin.h
openbr/plugins/eigen3.cpp
openbr/plugins/independent.cpp
openbr/plugins/output.cpp
openbr/plugins/svm.cpp
@@ -268,8 +268,8 @@ cv::Mat BEE::makeMask(const br::FileList &amp;targets, const br::FileList &amp;queries, 
 {
     // Would like to use indexProperty for this, but didn't make a version of that for Filelist yet
     // -cao
-    QList<QString> targetLabels = targets.get<QString>("Subject", "-1");
-    QList<QString> queryLabels = queries.get<QString>("Subject", "-1");
+    QList<QString> targetLabels = File::get<QString>(targets, "Subject", "-1");
+    QList<QString> queryLabels = File::get<QString>(queries, "Subject", "-1");
     QList<int> targetPartitions = targets.crossValidationPartitions();
     QList<int> queryPartitions = queries.crossValidationPartitions();
  
@@ -280,7 +280,7 @@ void br::EvalClustering(const QString &amp;csv, const QString &amp;input)
  
     // We assume clustering algorithms store assigned cluster labels as integers (since the clusters are
     // not named).
-    QList<int> labels = TemplateList::fromGallery(input).files().get<int>("Subject");
+    QList<int> labels = File::get<int>(TemplateList::fromGallery(input), "Subject");
  
     QHash<int, int> labelToIndex;
     int nClusters = 0;
@@ -436,7 +436,7 @@ TemplateList TemplateList::fromGallery(const br::File &amp;gallery)
 // stores the index values in "Label" of the output template list
 TemplateList TemplateList::relabel(const TemplateList &tl, const QString & propName)
 {
-    const QList<QString> originalLabels = tl.get<QString>(propName);
+    const QList<QString> originalLabels = File::get<QString>(tl, propName);
     QHash<QString,int> labelTable;
     foreach (const QString & label, originalLabels)
         if (!labelTable.contains(label))
@@ -464,7 +464,7 @@ QList&lt;int&gt; TemplateList::indexProperty(const QString &amp; propName, QHash&lt;QString, 
     valueMap.clear();
     reverseLookup.clear();
  
-    const QList<QVariant> originalLabels = values(propName);
+    const QList<QVariant> originalLabels = File::values(*this, propName);
     foreach (const QVariant & label, originalLabels) {
         QString labelString = label.toString();
         if (!valueMap.contains(labelString)) {
@@ -481,9 +481,9 @@ QList&lt;int&gt; TemplateList::indexProperty(const QString &amp; propName, QHash&lt;QString, 
 }
  
 // uses -1 for missing values
-QList<int> TemplateList::applyIndex(const QString & propName, const QHash<QString, int> & valueMap) const
+QList<int> TemplateList::applyIndex(const QString &propName, const QHash<QString, int> &valueMap) const
 {
-    const QList<QString> originalLabels = get<QString>(propName);
+    const QList<QString> originalLabels = File::get<QString>(*this, propName);
  
     QList<int> result;
     for (int i=0; i<originalLabels.size(); i++) {
@@ -228,7 +228,20 @@ struct BR_EXPORT File
         return variant.value<T>();
     }
  
-    /*!< \brief Returns a list of type T for the key, throwing an error if the key does not exist or if the value cannot be converted to the specified type. */
+    /*!< \brief Returns a value for the key, returning \em defaultValue if the key does not exist or can't be converted. */
+    template <typename T>
+    T get(const QString &key, const T &defaultValue) const
+    {
+        if (!contains(key)) return defaultValue;
+        QVariant variant = value(key);
+        if (!variant.canConvert<T>()) return defaultValue;
+        return variant.value<T>();
+    }
+
+    /*!< \brief Specialization for boolean type. */
+    bool getBool(const QString &key, bool defaultValue = false) const;
+
+    /*!< \brief Specialization for list type. Returns a list of type T for the key, throwing an error if the key does not exist or if the value cannot be converted to the specified type. */
     template <typename T>
     QList<T> getList(const QString &key) const
     {
@@ -241,17 +254,31 @@ struct BR_EXPORT File
         return list;
     }
  
-    /*!< \brief Specialization for boolean type. */
-    bool getBool(const QString &key, bool defaultValue = false) const;
+    /*!< \brief Returns the value for the specified key for every file in the list. */
+    template<class U>
+    static QList<QVariant> values(const QList<U> &fileList, const QString &key)
+    {
+        QList<QVariant> values; values.reserve(fileList.size());
+        foreach (const U &f, fileList) values.append(((const File&)f).value(key));
+        return values;
+    }
  
-    /*!< \brief Returns a value for the key, returning \em defaultValue if the key does not exist or can't be converted. */
-    template <typename T>
-    T get(const QString &key, const T &defaultValue) const
+    /*!< \brief Returns a value for the key for every file in the list, throwing an error if the key does not exist. */
+    template<class T, class U>
+    static QList<T> get(const QList<U> &fileList, const QString &key)
     {
-        if (!contains(key)) return defaultValue;
-        QVariant variant = value(key);
-        if (!variant.canConvert<T>()) return defaultValue;
-        return variant.value<T>();
+        QList<T> result; result.reserve(fileList.size());
+        foreach (const U &f, fileList) result.append(((const File&)f).get<T>(key));
+        return result;
+    }
+
+    /*!< \brief Returns a value for the key for every file in the list, returning \em defaultValue if the key does not exist or can't be converted. */
+    template<class T, class U>
+    static QList<T> get(const QList<U> &fileList, const QString &key, const T &defaultValue)
+    {
+        QList<T> result; result.reserve(fileList.size());
+        foreach (const U &f, fileList) result.append(((const File&)f).get<T>(key, defaultValue));
+        return result;
     }
  
     inline bool failed() const { return getBool("FTE") || getBool("FTO"); } /*!< \brief Returns \c true if the file failed to open or enroll, \c false otherwise. */
@@ -297,23 +324,6 @@ struct BR_EXPORT FileList : public QList&lt;File&gt;
     QStringList flat() const; /*!< \brief Returns br::File::flat() for each file in the list. */
     QStringList names() const; /*!<  \brief Returns #br::File::name for each file in the list. */
     void sort(const QString& key); /*!<  \brief Sort the list based on metadata. */
-     /*!< \brief Returns values associated with the input propName for each file in the list. */
-    template<typename T>
-    QList<T> get(const QString & propName) const
-    {
-        QList<T> values; values.reserve(size());
-        foreach (const File &f, *this)
-            values.append(f.get<T>(propName));
-        return values;
-    }
-    template<typename T>
-    QList<T> get(const QString & propName, T defaultValue) const
-    {
-        QList<T> values; values.reserve(size());
-        foreach (const File &f, *this)
-            values.append(f.contains(propName) ? f.get<T>(propName) : defaultValue);
-        return values;
-    }
  
     QList<int> crossValidationPartitions() const; /*!< \brief Returns the cross-validation partition (default=0) for each file in the list. */
     int failures() const; /*!< \brief Returns the number of files with br::File::failed(). */
@@ -344,6 +354,7 @@ struct Template : public QList&lt;cv::Mat&gt;
     inline const cv::Mat &m() const { static const cv::Mat NullMatrix;
                                       return isEmpty() ? qFatal("Empty template."), NullMatrix : last(); } /*!< \brief Idiom to treat the template as a matrix. */
     inline cv::Mat &m() { return isEmpty() ? append(cv::Mat()), last() : last(); } /*!< \brief Idiom to treat the template as a matrix. */
+    inline const File &operator()() const { return file; }
     inline cv::Mat &operator=(const cv::Mat &other) { return m() = other; } /*!< \brief Idiom to treat the template as a matrix. */
     inline operator const cv::Mat&() const { return m(); } /*!< \brief Idiom to treat the template as a matrix. */
     inline operator cv::Mat&() { return m(); } /*!< \brief Idiom to treat the template as a matrix. */
@@ -406,7 +417,6 @@ struct TemplateList : public QList&lt;Template&gt;
     QList<int> indexProperty(const QString & propName, QHash<QString, int> & valueMap, QHash<int, QVariant> & reverseLookup) const;
     QList<int> applyIndex(const QString & propName, const QHash<QString, int> & valueMap) const;
  
-
     /*!
      * \brief Returns the total number of bytes in all the templates.
      */
@@ -477,23 +487,6 @@ struct TemplateList : public QList&lt;Template&gt;
     FileList operator()() const { return files(); }
  
     /*!
-     * \brief Returns br::Template::label() for each template in the list.
-     */
-    template<typename T>
-    QList<T> get(const QString & propName) const
-    {
-        QList<T> values; values.reserve(size());
-        foreach (const Template &t, *this) values.append(t.file.get<T>(propName));
-        return values;
-    }
-    QList<QVariant> values(const QString & propName) const
-    {
-        QList<QVariant> values; values.reserve(size());
-        foreach (const Template &t, *this) values.append(t.file.value(propName));
-        return values;
-    }
-
-    /*!
      * \brief Returns the number of occurences for each label in the list.
      */
     template<typename T>
@@ -1025,7 +1018,7 @@ public:
     virtual TemplateList readBlock(bool *done) = 0; /*!< \brief Retrieve a portion of the stored templates. */
     void writeBlock(const TemplateList &templates); /*!< \brief Serialize a template list. */
     virtual void write(const Template &t) = 0; /*!< \brief Serialize a template. */
-    static Gallery *make(const File &file); /*!< \brief Make a gallery from a file list. */
+    static Gallery *make(const File &file); /*!< \brief Make a gallery to/from a file on disk. */
  
 private:
     QSharedPointer<Gallery> next;
@@ -348,7 +348,7 @@ class LDATransform : public Transform
  
         // OpenBR ensures that class values range from 0 to numClasses-1.
         // Label exists because we created it earlier with relabel
-        QList<int> classes = trainingSet.get<int>("Label");
+        QList<int> classes = File::get<int>(trainingSet, "Label");
         QMap<int, int> classCounts = trainingSet.countValues<int>("Label");
         const int numClasses = classCounts.size();
  
@@ -20,7 +20,7 @@ static TemplateList Downsample(const TemplateList &amp;templates, const Transform *t
     const bool atLeast = transform->instances < 0;
     const int instances = abs(transform->instances);
  
-    QList<QString> allLabels = templates.get<QString>("Subject");
+    QList<QString> allLabels = File::get<QString>(templates, "Subject");
     QList<QString> uniqueLabels = allLabels.toSet().toList();
     qSort(uniqueLabels);
  
@@ -146,8 +146,8 @@ class meltOutput : public MatrixOutput
         QStringList lines;
         if (file.baseName() != "terminal") lines.append(QString("Query,Target,Mask,Similarity%1").arg(keys));
  
-        QList<QString> queryLabels = queryFiles.get<QString>("Subject");
-        QList<QString> targetLabels = targetFiles.get<QString>("Subject");
+        QList<QString> queryLabels = File::get<QString>(queryFiles, "Subject");
+        QList<QString> targetLabels = File::get<QString>(targetFiles, "Subject");
  
         for (int i=0; i<queryFiles.size(); i++) {
             for (int j=(selfSimilar ? i+1 : 0); j<targetFiles.size(); j++) {
@@ -130,7 +130,7 @@ private:
         Mat lab;
         // If we are doing regression, assume subject has float values
         if (type == EPS_SVR || type == NU_SVR) {
-            lab = OpenCVUtils::toMat(_data.get<float>("Subject"));
+            lab = OpenCVUtils::toMat(File::get<float>(_data, "Subject"));
         }
         // If we are doing classification, assume subject has discrete values, map them
         // and store the mapping data