more future refactoring

Josh Klontz
1 parent 952f60e6
Showing 6 changed files with 37 additions and 45 deletions
sdk/core/qtutils.h
sdk/openbr_plugin.cpp
sdk/plugins/distance.cpp
sdk/plugins/meta.cpp
sdk/plugins/normalize.cpp
sdk/plugins/validate.cpp
@@ -63,14 +63,6 @@ namespace QtUtils
     bool runRScript(const QString &file);
     bool runDot(const QString &file);
     void showFile(const QString &file);
-
-    /**** Thread Utilities ****/
-    template <typename T>
-    static inline void waitForFinished(const QList< QFuture<T> > &futures)
-    {
-        foreach (QFuture<T> future, futures)
-            future.waitForFinished();
-    }
 }
 #endif // __QTUTILS_H
@@ -14,6 +14,7 @@
  * limitations under the License.                                            *
  * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+#include <QFutureSynchronizer>
 #include <QMetaProperty>
 #include <QPointF>
 #include <QRect>
@@ -1162,12 +1163,12 @@ private:
         for (int i=0; i<templatesList.size(); i++)
             templatesList[i] = Downsample(templatesList[i], transforms[i]);
-        QList< QFuture<void> > futures;
+        QFutureSynchronizer<void> futures;
         for (int i=0; i<templatesList.size(); i++) {
-            if (Globals->parallelism) futures.append(QtConcurrent::run(_train, transforms[i], &templatesList[i]));
-            else                                                       _train (transforms[i], &templatesList[i]);
+            if (Globals->parallelism) futures.addFuture(QtConcurrent::run(_train, transforms[i], &templatesList[i]));
+            else                                                          _train (transforms[i], &templatesList[i]);
         }
-        QtUtils::waitForFinished(futures);
+        futures.waitForFinished();
     }
     void project(const Template &src, Template &dst) const
@@ -1306,11 +1307,11 @@ void Transform::backProject(const TemplateList &amp;dst, TemplateList &amp;src) const
     src.reserve(dst.size());
     for (int i=0; i<dst.size(); i++) src.append(Template());
-    QList< QFuture<void> > futures;
+    QFutureSynchronizer<void> futures;
     for (int i=0; i<dst.size(); i++)
-        if (Globals->parallelism) futures.append(QtConcurrent::run(_backProject, this, &dst[i], &src[i]));
-        else                                                       _backProject (this, &dst[i], &src[i]);
-    QtUtils::waitForFinished(futures);
+        if (Globals->parallelism) futures.addFuture(QtConcurrent::run(_backProject, this, &dst[i], &src[i]));
+        else                                                          _backProject (this, &dst[i], &src[i]);
+    futures.waitForFinished();
 }
 /* Distance - public methods */
@@ -1338,16 +1339,16 @@ void Distance::compare(const TemplateList &amp;target, const TemplateList &amp;query, Ou
     const bool stepTarget = target.size() > query.size();
     const int totalSize = std::max(target.size(), query.size());
     int stepSize = ceil(float(totalSize) / float(std::max(1, abs(Globals->parallelism))));
-    QList< QFuture<void> > futures; futures.reserve(ceil(float(totalSize)/float(stepSize)));
+    QFutureSynchronizer<void> futures;
     for (int i=0; i<totalSize; i+=stepSize) {
         const TemplateList &targets(stepTarget ? TemplateList(target.mid(i, stepSize)) : target);
         const TemplateList &queries(stepTarget ? query : TemplateList(query.mid(i, stepSize)));
         const int targetOffset = stepTarget ? i : 0;
         const int queryOffset = stepTarget ? 0 : i;
-        if (Globals->parallelism) futures.append(QtConcurrent::run(this, &Distance::compareBlock, targets, queries, output, targetOffset, queryOffset));
-        else                                                                        compareBlock (targets, queries, output, targetOffset, queryOffset);
+        if (Globals->parallelism) futures.addFuture(QtConcurrent::run(this, &Distance::compareBlock, targets, queries, output, targetOffset, queryOffset));
+        else                                                                           compareBlock (targets, queries, output, targetOffset, queryOffset);
     }
-    QtUtils::waitForFinished(futures);
+    futures.waitForFinished();
 }
 QList<float> Distance::compare(const TemplateList &targets, const Template &query) const
@@ -14,6 +14,7 @@
  * limitations under the License.                                            *
  * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+#include <QFutureSynchronizer>
 #include <QtConcurrentRun>
 #include <opencv2/imgproc/imgproc.hpp>
 #include <openbr_plugin.h>
@@ -155,11 +156,11 @@ class PipeDistance : public Distance
     void train(const TemplateList &data)
     {
-        QList< QFuture<void> > futures;
+        QFutureSynchronizer<void> futures;
         foreach (br::Distance *distance, distances)
-            if (Globals->parallelism) futures.append(QtConcurrent::run(distance, &Distance::train, data));
-            else                      distance->train(data);
-        QtUtils::waitForFinished(futures);
+            if (Globals->parallelism) futures.addFuture(QtConcurrent::run(distance, &Distance::train, data));
+            else                                                          distance->train(data);
+        futures.waitForFinished();
     }
     float compare(const Template &a, const Template &b) const
@@ -14,6 +14,7 @@
  * limitations under the License.                                            *
  * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+#include <QFutureSynchronizer>
 #include <QtConcurrentRun>
 #include <openbr_plugin.h>
@@ -284,12 +285,12 @@ class ForkTransform : public CompositeTransform
     void train(const TemplateList &data)
     {
-        QList< QFuture<void> > futures;
+        QFutureSynchronizer<void> futures;
         for (int i=0; i<transforms.size(); i++) {
-            if (Globals->parallelism) futures.append(QtConcurrent::run(_train, transforms[i], &data));
-            else                                                       _train (transforms[i], &data);
+            if (Globals->parallelism) futures.addFuture(QtConcurrent::run(_train, transforms[i], &data));
+            else                                                          _train (transforms[i], &data);
         }
-        QtUtils::waitForFinished(futures);
+        futures.waitForFinished();
     }
     void backProject(const Template &dst, Template &src) const {Transform::backProject(dst, src);}
@@ -634,16 +635,13 @@ public:
             output_buffer.append(TemplateList());
         }
-        QList< QFuture<void> > futures;
-        futures.reserve(src.size());
+        QFutureSynchronizer<void> futures;
         for (int i=0; i<src.size(); i++) {
             input_buffer[i].append(src[i]);
-            if (Globals->parallelism)
-                futures.append(QtConcurrent::run(_projectList, transform, &input_buffer[i], &output_buffer[i]));
-            else
-                _projectList(transform, &input_buffer[i], &output_buffer[i]);
+            if (Globals->parallelism) futures.addFuture(QtConcurrent::run(_projectList, transform, &input_buffer[i], &output_buffer[i]));
+            else                                                          _projectList( transform, &input_buffer[i], &output_buffer[i]);
         }
-        QtUtils::waitForFinished(futures);
+        futures.waitForFinished();
         for (int i=0; i<src.size(); i++) dst.append(output_buffer[i]);
     }
@@ -14,6 +14,7 @@
  * limitations under the License.                                            *
  * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+#include <QFutureSynchronizer>
 #include <QtConcurrentRun>
 #include <opencv2/imgproc/imgproc.hpp>
 #include <opencv2/highgui/highgui.hpp>
@@ -120,16 +121,16 @@ private:
             bv.push_back(Mat(1, dims, CV_64FC1));
         }
-        QList< QFuture<void> > futures;
+        QFutureSynchronizer<void> futures;
         const bool parallel = (data.size() > 1000) && Globals->parallelism;
         for (size_t c = 0; c < mv.size(); c++) {
             for (int i=0; i<dims; i++)
-                if (parallel) futures.append(QtConcurrent::run(_train, method, mv[c], &av[c], &bv[c], i));
-                else                                           _train (method, mv[c], &av[c], &bv[c], i);
+                if (parallel) futures.addFuture(QtConcurrent::run(_train, method, mv[c], &av[c], &bv[c], i));
+                else                                              _train (method, mv[c], &av[c], &bv[c], i);
             av[c] = av[c].reshape(1, data.first().m().rows);
             bv[c] = bv[c].reshape(1, data.first().m().rows);
         }
-        QtUtils::waitForFinished(futures);
+        futures.waitForFinished();
         merge(av, a);
         merge(bv, b);
+#include <QFutureSynchronizer>
 #include <QtConcurrentRun>
 #include <openbr_plugin.h>
-#include "core/qtutils.h"
-
 namespace br
 {
@@ -36,16 +35,16 @@ class CrossValidateTransform : public MetaTransform
             return;
         }
-        QList< QFuture<void> > futures;
+        QFutureSynchronizer<void> futures;
         for (int i=0; i<numPartitions; i++) {
             TemplateList partitionedData = data;
             for (int j=partitionedData.size()-1; j>=0; j--)
                 if (partitions[j] == i)
                     partitionedData.removeAt(j);
-            if (Globals->parallelism) futures.append(QtConcurrent::run(transforms[i], &Transform::train, partitionedData));
-            else                                                       transforms[i]->train(partitionedData);
+            if (Globals->parallelism) futures.addFuture(QtConcurrent::run(transforms[i], &Transform::train, partitionedData));
+            else                                                          transforms[i]->train(partitionedData);
         }
-        QtUtils::waitForFinished(futures);
+        futures.waitForFinished();
     }
     void project(const Template &src, Template &dst) const