[GSoC] Implementation of the Global Patch Collider and demo for PCAFlow (#752)

* Minor fixes

* Start adding correspondence finding

* Added finding of correspondences using GPC

* New evaluation tool for GPC

* Changed default parameters

* Display ground truth in the evaluation tool

* Added training tool for MPI Sintel dataset

* Added the training tool for Middlebury dataset

* Added some OpenCL optimization

* Added explanatory notes

* Minor improvements: time measurements + little ocl optimization

* Added demos

* Fixed warnings

* Make parameter struct assignable

* Fix warning

* Proper command line argument usage

* Prettified training tool, added parameters

* Fixed VS warning

* Fixed VS warning

* Using of compressed forest.yml.gz files by default to save space

* Added OpenCL flag to the evaluation tool

* Updated documentation

* Major speed and memory improvements:
1) Added new (optional) type of patch descriptors which are much faster. Retraining with option --descriptor-type=1 is required.
2) Got rid of hash table for descriptors, less memory usage.

* Fixed various floating point errors related to precision.
SIMD for dot product, forest traversing is a little bit faster now.

* Tolerant floating point comparison

* Triplets

* Added comment

* Choosing negative sample among nearest neighbors

* Fix warning

* Usage of parallel_for_() in critical places. Performance improvments.

* Simulated annealing heuristic

* Moved OpenCL kernel to separate file

* Moved implementation to source file

* Added basic accuracy tests for GPC and PCAFlow

* Fixing warnings

* Test accuracy constraints were too strict

* Test accuracy constraints were too strict

* Make tests more lightweight

modules/optflow/doc/optflow.bib

@@ -52,3 +52,19 @@
   pages={25--36},
   year={2004}
 }
+
+@inproceedings{Wulff:CVPR:2015,
+  title = {Efficient Sparse-to-Dense Optical Flow Estimation using a Learned Basis and Layers},
+  author = {Wulff, Jonas and Black, Michael J.},
+  booktitle = { IEEE Conf. on Computer Vision and Pattern Recognition (CVPR) 2015},
+  month = {June},
+  year = {2015}
+}
+
+@inproceedings{Wang_2016_CVPR,
+  author = {Wang, Shenlong and Ryan Fanello, Sean and Rhemann, Christoph and Izadi, Shahram and Kohli, Pushmeet},
+  title = {The Global Patch Collider},
+  booktitle = {The IEEE Conference on Computer Vision and Pattern Recognition (CVPR)},
+  month = {June},
+  year = {2016}
+}

modules/optflow/include/opencv2/optflow.hpp

@@ -43,9 +43,6 @@ the use of this software, even if advised of the possibility of such damage.
 #include "opencv2/core.hpp"
 #include "opencv2/video.hpp"
 
-#include "opencv2/optflow/pcaflow.hpp"
-#include "opencv2/optflow/sparse_matching_gpc.hpp"
-
 /**
 @defgroup optflow Optical Flow Algorithms
 
@@ -69,6 +66,9 @@ Functions reading and writing .flo files in "Middlebury" format, see: <http://vi
 
  */
 
+#include "opencv2/optflow/pcaflow.hpp"
+#include "opencv2/optflow/sparse_matching_gpc.hpp"
+
 namespace cv
 {
 namespace optflow

modules/optflow/include/opencv2/optflow/pcaflow.hpp

@@ -37,23 +37,19 @@ or tort (including negligence or otherwise) arising in any way out of
 the use of this software, even if advised of the possibility of such damage.
 */
 
-/*
-Implementation of the PCAFlow algorithm from the following paper:
-http://files.is.tue.mpg.de/black/papers/cvpr2015_pcaflow.pdf
-
-@inproceedings{Wulff:CVPR:2015,
-  title = {Efficient Sparse-to-Dense Optical Flow Estimation using a Learned Basis and Layers},
-  author = {Wulff, Jonas and Black, Michael J.},
-  booktitle = { IEEE Conf. on Computer Vision and Pattern Recognition (CVPR) 2015},
-  month = jun,
-  year = {2015}
-}
-
-There are some key differences which distinguish this algorithm from the original PCAFlow (see paper):
-  - Discrete Cosine Transform basis is used instead of basis extracted with PCA.
-    Reasoning: DCT basis has comparable performance and it doesn't require additional storage space.
-    Also, this decision helps to avoid overloading the algorithm with a lot of external input.
-  - Usage of built-in OpenCV feature tracking instead of libviso.
+/**
+ * @file   pcaflow.hpp
+ * @author Vladislav Samsonov <vvladxx@gmail.com>
+ * @brief  Implementation of the PCAFlow algorithm from the following paper:
+ * http://files.is.tue.mpg.de/black/papers/cvpr2015_pcaflow.pdf
+ *
+ * @cite Wulff:CVPR:2015
+ *
+ * There are some key differences which distinguish this algorithm from the original PCAFlow (see paper):
+ * - Discrete Cosine Transform basis is used instead of basis extracted with PCA.
+ *   Reasoning: DCT basis has comparable performance and it doesn't require additional storage space.
+ *   Also, this decision helps to avoid overloading the algorithm with a lot of external input.
+ * - Usage of built-in OpenCV feature tracking instead of libviso.
 */
 
 #ifndef __OPENCV_OPTFLOW_PCAFLOW_HPP__
@@ -67,7 +63,10 @@ namespace cv
 namespace optflow
 {
 
-/*
+//! @addtogroup optflow
+//! @{
+
+/** @brief
  * This class can be used for imposing a learned prior on the resulting optical flow.
  * Solution will be regularized according to this prior.
  * You need to generate appropriate prior file with "learn_prior.py" script beforehand.
@@ -90,6 +89,8 @@ public:
   void fillConstraints( float *A1, float *A2, float *b1, float *b2 ) const;
 };
 
+/** @brief PCAFlow algorithm.
+ */
 class CV_EXPORTS_W OpticalFlowPCAFlow : public DenseOpticalFlow
 {
 protected:
@@ -103,6 +104,15 @@ protected:
   bool useOpenCL;
 
 public:
+  /** @brief Creates an instance of PCAFlow algorithm.
+   * @param _prior Learned prior or no prior (default). @see cv::optflow::PCAPrior
+   * @param _basisSize Number of basis vectors.
+   * @param _sparseRate Controls density of sparse matches.
+   * @param _retainedCornersFraction Retained corners fraction.
+   * @param _occlusionsThreshold Occlusion threshold.
+   * @param _dampingFactor Regularization term for solving least-squares. It is not related to the prior regularization.
+   * @param _claheClip Clip parameter for CLAHE.
+   */
   OpticalFlowPCAFlow( Ptr<const PCAPrior> _prior = Ptr<const PCAPrior>(), const Size _basisSize = Size( 18, 14 ),
                       float _sparseRate = 0.024, float _retainedCornersFraction = 0.2,
                       float _occlusionsThreshold = 0.0003, float _dampingFactor = 0.00002, float _claheClip = 14 );
@@ -127,7 +137,12 @@ private:
   OpticalFlowPCAFlow& operator=( const OpticalFlowPCAFlow& ); // make it non-assignable
 };
 
+/** @brief Creates an instance of PCAFlow
+*/
 CV_EXPORTS_W Ptr<DenseOpticalFlow> createOptFlow_PCAFlow();
+
+//! @}
+
 }
 }
 

modules/optflow/samples/gpc_evaluate.cpp

+#include "opencv2/core/ocl.hpp"
+#include "opencv2/highgui.hpp"
+#include "opencv2/imgcodecs.hpp"
+#include "opencv2/optflow.hpp"
+#include <fstream>
+#include <iostream>
+#include <stdio.h>
+
+/* This tool finds correspondences between two images using Global Patch Collider
+ * and calculates error using provided ground truth flow.
+ *
+ * It will look for the file named "forest.yml.gz" with a learned forest.
+ * You can obtain the "forest.yml.gz" either by manually training it using another tool with *_train suffix
+ * or by downloading one of the files trained on some publicly available dataset from here:
+ *
+ * https://drive.google.com/open?id=0B7Hb8cfuzrIIZDFscXVYd0NBNFU
+ */
+
+using namespace cv;
+
+const String keys = "{help h ?     |             | print this message}"
+                    "{@image1      |<none>       | image1}"
+                    "{@image2      |<none>       | image2}"
+                    "{@groundtruth |<none>       | path to the .flo file}"
+                    "{@output      |             | output to a file instead of displaying, output image path}"
+                    "{g gpu        |             | use OpenCL}"
+                    "{f forest     |forest.yml.gz| path to the forest.yml.gz}";
+
+const int nTrees = 5;
+
+static double normL2( const Point2f &v ) { return sqrt( v.x * v.x + v.y * v.y ); }
+
+static Vec3d getFlowColor( const Point2f &f, const bool logScale = true, const double scaleDown = 5 )
+{
+  if ( f.x == 0 && f.y == 0 )
+    return Vec3d( 0, 0, 1 );
+
+  double radius = normL2( f );
+  if ( logScale )
+    radius = log( radius + 1 );
+  radius /= scaleDown;
+  radius = std::min( 1.0, radius );
+
+  double angle = ( atan2( -f.y, -f.x ) + CV_PI ) * 180 / CV_PI;
+  return Vec3d( angle, radius, 1 );
+}
+
+static void displayFlow( InputArray _flow, OutputArray _img )
+{
+  const Size sz = _flow.size();
+  Mat flow = _flow.getMat();
+  _img.create( sz, CV_32FC3 );
+  Mat img = _img.getMat();
+
+  for ( int i = 0; i < sz.height; ++i )
+    for ( int j = 0; j < sz.width; ++j )
+      img.at< Vec3f >( i, j ) = getFlowColor( flow.at< Point2f >( i, j ) );
+
+  cvtColor( img, img, COLOR_HSV2BGR );
+}
+
+static bool fileProbe( const char *name ) { return std::ifstream( name ).good(); }
+
+int main( int argc, const char **argv )
+{
+  CommandLineParser parser( argc, argv, keys );
+  parser.about( "Global Patch Collider evaluation tool" );
+
+  if ( parser.has( "help" ) )
+  {
+    parser.printMessage();
+    return 0;
+  }
+
+  String fromPath = parser.get< String >( 0 );
+  String toPath = parser.get< String >( 1 );
+  String gtPath = parser.get< String >( 2 );
+  String outPath = parser.get< String >( 3 );
+  const bool useOpenCL = parser.has( "gpu" );
+  String forestDumpPath = parser.get< String >( "forest" );
+
+  if ( !parser.check() )
+  {
+    parser.printErrors();
+    return 1;
+  }
+
+  if ( !fileProbe( forestDumpPath.c_str() ) )
+  {
+    std::cerr << "Can't open the file with a trained model: `" << forestDumpPath
+              << "`.\nYou can obtain this file either by manually training the model using another tool with *_train suffix or by "
+                 "downloading one of the files trained on some publicly available dataset from "
+                 "here:\nhttps://drive.google.com/open?id=0B7Hb8cfuzrIIZDFscXVYd0NBNFU"
+              << std::endl;
+    return 1;
+  }
+
+  ocl::setUseOpenCL( useOpenCL );
+
+  Ptr< optflow::GPCForest< nTrees > > forest = Algorithm::load< optflow::GPCForest< nTrees > >( forestDumpPath );
+
+  Mat from = imread( fromPath );
+  Mat to = imread( toPath );
+  Mat gt = optflow::readOpticalFlow( gtPath );
+  std::vector< std::pair< Point2i, Point2i > > corr;
+
+  TickMeter meter;
+  meter.start();
+
+  forest->findCorrespondences( from, to, corr, optflow::GPCMatchingParams( useOpenCL ) );
+
+  meter.stop();
+
+  std::cout << "Found " << corr.size() << " matches." << std::endl;
+  std::cout << "Time:  " << meter.getTimeSec() << " sec." << std::endl;
+  double error = 0;
+  Mat dispErr = Mat::zeros( from.size(), CV_32FC3 );
+  dispErr = Scalar( 0, 0, 1 );
+  Mat disp = Mat::zeros( from.size(), CV_32FC3 );
+  disp = Scalar( 0, 0, 1 );
+
+  for ( size_t i = 0; i < corr.size(); ++i )
+  {
+    const Point2f a = corr[i].first;
+    const Point2f b = corr[i].second;
+    const Point2f c = a + gt.at< Point2f >( corr[i].first.y, corr[i].first.x );
+    error += normL2( b - c );
+    circle( disp, a, 3, getFlowColor( b - a ), -1 );
+    circle( dispErr, a, 3, getFlowColor( b - c, false, 32 ), -1 );
+  }
+
+  error /= corr.size();
+
+  std::cout << "Average endpoint error: " << error << " px." << std::endl;
+
+  cvtColor( disp, disp, COLOR_HSV2BGR );
+  cvtColor( dispErr, dispErr, COLOR_HSV2BGR );
+
+  Mat dispGroundTruth;
+  displayFlow( gt, dispGroundTruth );
+
+  if ( outPath.length() )
+  {
+    putText( disp, "Sparse matching: Global Patch Collider", Point2i( 24, 40 ), FONT_HERSHEY_DUPLEX, 1, Vec3b( 1, 0, 0 ), 2, LINE_AA );
+    char buf[256];
+    sprintf( buf, "Average EPE: %.2f", error );
+    putText( disp, buf, Point2i( 24, 80 ), FONT_HERSHEY_DUPLEX, 1, Vec3b( 1, 0, 0 ), 2, LINE_AA );
+    sprintf( buf, "Number of matches: %u", (unsigned)corr.size() );
+    putText( disp, buf, Point2i( 24, 120 ), FONT_HERSHEY_DUPLEX, 1, Vec3b( 1, 0, 0 ), 2, LINE_AA );
+    disp *= 255;
+    imwrite( outPath, disp );
+    return 0;
+  }
+
+  namedWindow( "Correspondences", WINDOW_AUTOSIZE );
+  imshow( "Correspondences", disp );
+  namedWindow( "Error", WINDOW_AUTOSIZE );
+  imshow( "Error", dispErr );
+  namedWindow( "Ground truth", WINDOW_AUTOSIZE );
+  imshow( "Ground truth", dispGroundTruth );
+  waitKey( 0 );
+
+  return 0;
+}

modules/optflow/samples/gpc_train.cpp

 #include "opencv2/optflow.hpp"
 #include <iostream>
 
+/* This tool trains the forest for the Global Patch Collider and stores output to the "forest.yml.gz".
+ */
+
+using namespace cv;
+
+const String keys = "{help h ?       |             | print this message}"
+                    "{max-tree-depth |             | Maximum tree depth to stop partitioning}"
+                    "{min-samples    |             | Minimum number of samples in the node to stop partitioning}"
+                    "{descriptor-type|0            | Descriptor type. Set to 0 for quality, 1 for speed.}"
+                    "{print-progress |             | Set to 0 to enable quiet mode, set to 1 to print progress}"
+                    "{f forest       |forest.yml.gz| Path where to store resulting forest. It is recommended to use .yml.gz extension.}";
+
 const int nTrees = 5;
 
-int main( int argc, const char **argv )
+static void fillInputImagesFromCommandLine( std::vector< String > &img1, std::vector< String > &img2, std::vector< String > &gt, int argc,
+                                            const char **argv )
 {
-  int nSequences = argc - 1;
-
-  if ( nSequences <= 0 || nSequences % 3 != 0 )
+  for ( int i = 1, j = 0; i < argc; ++i )
   {
-    std::cerr << "Usage: " << argv[0] << " ImageFrom1 ImageTo1 GroundTruth1 ... ImageFromN ImageToN GroundTruthN" << std::endl;
-    return 1;
+    if ( argv[i][0] == '-' )
+      continue;
+    if ( j % 3 == 0 )
+      img1.push_back( argv[i] );
+    if ( j % 3 == 1 )
+      img2.push_back( argv[i] );
+    if ( j % 3 == 2 )
+      gt.push_back( argv[i] );
+    ++j;
   }
+}
 
-  nSequences /= 3;
-  std::vector< cv::String > img1, img2, gt;
+int main( int argc, const char **argv )
+{
+  CommandLineParser parser( argc, argv, keys );
+  parser.about( "Global Patch Collider training tool" );
+
+  std::vector< String > img1, img2, gt;
+  optflow::GPCTrainingParams params;
 
-  for ( int i = 0; i < nSequences; ++i )
+  if ( parser.has( "max-tree-depth" ) )
+    params.maxTreeDepth = parser.get< unsigned >( "max-tree-depth" );
+  if ( parser.has( "min-samples" ) )
+    params.minNumberOfSamples = parser.get< unsigned >( "min-samples" );
+  if ( parser.has( "descriptor-type" ) )
+    params.descriptorType = parser.get< int >( "descriptor-type" );
+  if ( parser.has( "print-progress" ) )
+    params.printProgress = parser.get< unsigned >( "print-progress" ) != 0;
+
+  fillInputImagesFromCommandLine( img1, img2, gt, argc, argv );
+
+  if ( parser.has( "help" ) || img1.size() != img2.size() || img1.size() != gt.size() || img1.size() == 0 )
   {
-    img1.push_back( argv[1 + i * 3] );
-    img2.push_back( argv[1 + i * 3 + 1] );
-    gt.push_back( argv[1 + i * 3 + 2] );
+    std::cerr << "\nUsage: " << argv[0] << " [params] ImageFrom1 ImageTo1 GroundTruth1 ... ImageFromN ImageToN GroundTruthN\n" << std::endl;
+    parser.printMessage();
+    return 1;
   }
 
-  cv::Ptr< cv::optflow::GPCForest< nTrees > > forest = cv::optflow::GPCForest< nTrees >::create();
-  forest->train( img1, img2, gt );
-  forest->save( "forest.dump" );
+  Ptr< optflow::GPCForest< nTrees > > forest = optflow::GPCForest< nTrees >::create();
+  forest->train( img1, img2, gt, params );
+  forest->save( parser.get< String >( "forest" ) );
 
   return 0;
 }

modules/optflow/samples/gpc_train_middlebury.py

+import argparse
+import glob
+import os
+import subprocess
+
+
+def execute(cmd):
+    popen = subprocess.Popen(cmd,
+                             stdout=subprocess.PIPE,
+                             stderr=subprocess.PIPE)
+    for stdout_line in iter(popen.stdout.readline, ''):
+        print(stdout_line.rstrip())
+    for stderr_line in iter(popen.stderr.readline, ''):
+        print(stderr_line.rstrip())
+    popen.stdout.close()
+    popen.stderr.close()
+    return_code = popen.wait()
+    if return_code != 0:
+        raise subprocess.CalledProcessError(return_code, cmd)
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        description='Train Global Patch Collider using Middlebury dataset')
+    parser.add_argument(
+        '--bin_path',
+        help='Path to the training executable (example_optflow_gpc_train)',
+        required=True)
+    parser.add_argument('--dataset_path',
+                        help='Path to the directory with frames',
+                        required=True)
+    parser.add_argument('--gt_path',
+                        help='Path to the directory with ground truth flow',
+                        required=True)
+    parser.add_argument('--descriptor_type',
+                        help='Descriptor type',
+                        type=int,
+                        default=0)
+    args = parser.parse_args()
+    seq = glob.glob(os.path.join(args.dataset_path, '*'))
+    seq.sort()
+    input_files = []
+    for s in seq:
+        if os.path.isdir(s):
+            seq_name = os.path.basename(s)
+            frames = glob.glob(os.path.join(s, 'frame*.png'))
+            frames.sort()
+            assert (len(frames) == 2)
+            assert (os.path.basename(frames[0]) == 'frame10.png')
+            assert (os.path.basename(frames[1]) == 'frame11.png')
+            gt_flow = os.path.join(args.gt_path, seq_name, 'flow10.flo')
+            if os.path.isfile(gt_flow):
+                input_files += [frames[0], frames[1], gt_flow]
+    execute([args.bin_path, '--descriptor-type=%d' % args.descriptor_type] + input_files)
+
+
+if __name__ == '__main__':
+    main()

modules/optflow/samples/gpc_train_sintel.py

+import argparse
+import glob
+import os
+import subprocess
+
+FRAME_DIST = 2
+
+assert (FRAME_DIST >= 1)
+
+
+def execute(cmd):
+    popen = subprocess.Popen(cmd,
+                             stdout=subprocess.PIPE,
+                             stderr=subprocess.PIPE)
+    for stdout_line in iter(popen.stdout.readline, ''):
+        print(stdout_line.rstrip())
+    for stderr_line in iter(popen.stderr.readline, ''):
+        print(stderr_line.rstrip())
+    popen.stdout.close()
+    popen.stderr.close()
+    return_code = popen.wait()
+    if return_code != 0:
+        raise subprocess.CalledProcessError(return_code, cmd)
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        description='Train Global Patch Collider using MPI Sintel dataset')
+    parser.add_argument(
+        '--bin_path',
+        help='Path to the training executable (example_optflow_gpc_train)',
+        required=True)
+    parser.add_argument('--dataset_path',
+                        help='Path to the directory with frames',
+                        required=True)
+    parser.add_argument('--gt_path',
+                        help='Path to the directory with ground truth flow',
+                        required=True)
+    parser.add_argument('--descriptor_type',
+                        help='Descriptor type',
+                        type=int,
+                        default=0)
+    args = parser.parse_args()
+    seq = glob.glob(os.path.join(args.dataset_path, '*'))
+    seq.sort()
+    input_files = []
+    for s in seq:
+        seq_name = os.path.basename(s)
+        frames = glob.glob(os.path.join(s, 'frame*.png'))
+        frames.sort()
+        for i in range(0, len(frames) - 1, FRAME_DIST):
+            gt_flow = os.path.join(args.gt_path, seq_name,
+                                   os.path.basename(frames[i])[0:-4] + '.flo')
+            assert (os.path.isfile(gt_flow))
+            input_files += [frames[i], frames[i + 1], gt_flow]
+    execute([args.bin_path, '--descriptor-type=%d' % args.descriptor_type] + input_files)
+
+
+if __name__ == '__main__':
+    main()

modules/optflow/samples/pcaflow_demo.cpp

+#include "opencv2/core/ocl.hpp"
+#include "opencv2/highgui.hpp"
+#include "opencv2/imgcodecs.hpp"
+#include "opencv2/optflow.hpp"
+#include <fstream>
+#include <iostream>
+#include <stdio.h>
+
+using namespace cv;
+using optflow::OpticalFlowPCAFlow;
+using optflow::PCAPrior;
+
+const String keys = "{help h ?     |      | print this message}"
+                    "{@image1      |<none>| image1}"
+                    "{@image2      |<none>| image2}"
+                    "{@groundtruth |<none>| path to the .flo file}"
+                    "{@prior       |<none>| path to a prior file for PCAFlow}"
+                    "{@output      |<none>| output image path}"
+                    "{g gpu        |      | use OpenCL}";
+
+static double normL2( const Point2f &v ) { return sqrt( v.x * v.x + v.y * v.y ); }
+
+static bool fileProbe( const char *name ) { return std::ifstream( name ).good(); }
+
+static Vec3d getFlowColor( const Point2f &f, const bool logScale = true, const double scaleDown = 5 )
+{
+  if ( f.x == 0 && f.y == 0 )
+    return Vec3d( 0, 0, 1 );
+
+  double radius = normL2( f );
+  if ( logScale )
+    radius = log( radius + 1 );
+  radius /= scaleDown;
+  radius = std::min( 1.0, radius );
+
+  double angle = ( atan2( -f.y, -f.x ) + CV_PI ) * 180 / CV_PI;
+  return Vec3d( angle, radius, 1 );
+}
+
+static void displayFlow( InputArray _flow, OutputArray _img )
+{
+  const Size sz = _flow.size();
+  Mat flow = _flow.getMat();
+  _img.create( sz, CV_32FC3 );
+  Mat img = _img.getMat();
+
+  for ( int i = 0; i < sz.height; ++i )
+    for ( int j = 0; j < sz.width; ++j )
+      img.at< Vec3f >( i, j ) = getFlowColor( flow.at< Point2f >( i, j ) );
+
+  cvtColor( img, img, COLOR_HSV2BGR );
+}
+
+static bool isFlowCorrect( const Point2f &u )
+{
+  return !cvIsNaN( u.x ) && !cvIsNaN( u.y ) && ( fabs( u.x ) < 1e9 ) && ( fabs( u.y ) < 1e9 );
+}
+
+static double calcEPE( const Mat &f1, const Mat &f2 )
+{
+  double sum = 0;
+  Size sz = f1.size();
+  size_t cnt = 0;
+  for ( int i = 0; i < sz.height; ++i )
+    for ( int j = 0; j < sz.width; ++j )
+      if ( isFlowCorrect( f1.at< Point2f >( i, j ) ) && isFlowCorrect( f2.at< Point2f >( i, j ) ) )
+      {
+        sum += normL2( f1.at< Point2f >( i, j ) - f2.at< Point2f >( i, j ) );
+        ++cnt;
+      }
+  return sum / cnt;
+}
+
+static void displayResult( Mat &i1, Mat &i2, Mat &gt, Ptr< DenseOpticalFlow > &algo, OutputArray _img, const char *descr,
+                           const bool useGpu = false )
+{
+  Mat flow( i1.size[0], i1.size[1], CV_32FC2 );
+  TickMeter meter;
+  meter.start();
+
+  if ( useGpu )
+    algo->calc( i1, i2, flow.getUMat( ACCESS_RW ) );
+  else
+    algo->calc( i1, i2, flow );
+
+  meter.stop();
+  displayFlow( flow, _img );
+  Mat img = _img.getMat();
+  putText( img, descr, Point2i( 24, 40 ), FONT_HERSHEY_DUPLEX, 1, Vec3b( 1, 0, 0 ), 2, LINE_AA );
+  char buf[256];
+  sprintf( buf, "Average EPE: %.2f", calcEPE( flow, gt ) );
+  putText( img, buf, Point2i( 24, 80 ), FONT_HERSHEY_DUPLEX, 1, Vec3b( 1, 0, 0 ), 2, LINE_AA );
+  sprintf( buf, "Time: %.2fs", meter.getTimeSec() );
+  putText( img, buf, Point2i( 24, 120 ), FONT_HERSHEY_DUPLEX, 1, Vec3b( 1, 0, 0 ), 2, LINE_AA );
+}
+
+static void displayGT( InputArray _flow, OutputArray _img, const char *descr )
+{
+  displayFlow( _flow, _img );
+  Mat img = _img.getMat();
+  putText( img, descr, Point2i( 24, 40 ), FONT_HERSHEY_DUPLEX, 1, Vec3b( 1, 0, 0 ), 2, LINE_AA );
+}
+
+int main( int argc, const char **argv )
+{
+  CommandLineParser parser( argc, argv, keys );
+  parser.about( "PCAFlow demonstration" );
+
+  if ( parser.has( "help" ) )
+  {
+    parser.printMessage();
+    return 0;
+  }
+
+  String img1 = parser.get< String >( 0 );
+  String img2 = parser.get< String >( 1 );
+  String groundtruth = parser.get< String >( 2 );
+  String prior = parser.get< String >( 3 );
+  String outimg = parser.get< String >( 4 );
+  const bool useGpu = parser.has( "gpu" );
+
+  if ( !parser.check() )
+  {
+    parser.printErrors();
+    return 1;
+  }
+
+  if ( !fileProbe( prior.c_str() ) )
+  {
+    std::cerr << "Can't open the file with prior! Check the provided path: " << prior << std::endl;
+    return 1;
+  }
+
+  cv::ocl::setUseOpenCL( useGpu );
+
+  Mat i1 = imread( img1 );
+  Mat i2 = imread( img2 );
+  Mat gt = optflow::readOpticalFlow( groundtruth );
+
+  Mat i1g, i2g;
+  cvtColor( i1, i1g, COLOR_BGR2GRAY );
+  cvtColor( i2, i2g, COLOR_BGR2GRAY );
+
+  Mat pcaflowDisp, pcaflowpriDisp, farnebackDisp, gtDisp;
+
+  {
+    Ptr< DenseOpticalFlow > pcaflow = makePtr< OpticalFlowPCAFlow >( makePtr< PCAPrior >( prior.c_str() ) );
+    displayResult( i1, i2, gt, pcaflow, pcaflowpriDisp, "PCAFlow with prior", useGpu );
+  }
+
+  {
+    Ptr< DenseOpticalFlow > pcaflow = makePtr< OpticalFlowPCAFlow >();
+    displayResult( i1, i2, gt, pcaflow, pcaflowDisp, "PCAFlow without prior", useGpu );
+  }
+
+  {
+    Ptr< DenseOpticalFlow > farneback = optflow::createOptFlow_Farneback();
+    displayResult( i1g, i2g, gt, farneback, farnebackDisp, "Farneback", useGpu );
+  }
+
+  displayGT( gt, gtDisp, "Ground truth" );
+
+  Mat disp1, disp2;
+  vconcat( pcaflowpriDisp, farnebackDisp, disp1 );
+  vconcat( pcaflowDisp, gtDisp, disp2 );
+  hconcat( disp1, disp2, disp1 );
+  disp1 *= 255;
+
+  imwrite( outimg, disp1 );
+
+  return 0;
+}

modules/optflow/src/opencl/sparse_matching_gpc.cl

+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+
+// Copyright (C) 2016, Itseez, Inc., all rights reserved.
+// Third party copyrights are property of their respective owners.
+
+// @Authors
+//    Vladislav Samsonov, vvladxx@gmail.com
+
+__kernel void getPatchDescriptor(
+  __global const uchar* imgCh0, int ic0step, int ic0off,
+  __global const uchar* imgCh1, int ic1step, int ic1off,
+  __global const uchar* imgCh2, int ic2step, int ic2off,
+  __global uchar* out, int outstep, int outoff,
+  const int gh, const int gw, const int PR  )
+{
+  const int i = get_global_id(0);
+  const int j = get_global_id(1);
+
+  if (i >= gh || j >= gw)
+    return;
+
+  __global double* desc = (__global double*)(out + (outstep * (i * gw + j) + outoff));
+  const int patchRadius = PR * 2;
+  float patch[PATCH_RADIUS_DOUBLED][PATCH_RADIUS_DOUBLED];
+
+  for (int i0 = 0; i0 < patchRadius; ++i0) {
+    __global const float* ch0Row = (__global const float*)(imgCh0 + (ic0step * (i + i0) + ic0off + j * sizeof(float)));
+    for (int j0 = 0; j0 < patchRadius; ++j0)
+      patch[i0][j0] = ch0Row[j0];
+  }
+
+  #pragma unroll
+  for (int n0 = 0; n0 < 4; ++n0) {
+    #pragma unroll
+    for (int n1 = 0; n1 < 4; ++n1) {
+      double sum = 0;
+      for (int i0 = 0; i0 < patchRadius; ++i0)
+        for (int j0 = 0; j0 < patchRadius; ++j0)
+          sum += patch[i0][j0] * cos(CV_PI * (i0 + 0.5) * n0 / patchRadius) * cos(CV_PI * (j0 + 0.5) * n1 / patchRadius);
+      desc[n0 * 4 + n1] = sum / PR;
+    }
+  }
+
+  for (int k = 0; k < 4; ++k) {
+    desc[k] *= SQRT2_INV;
+    desc[k * 4] *= SQRT2_INV;
+  }
+
+  double sum = 0;
+
+  for (int i0 = 0; i0 < patchRadius; ++i0) {
+    __global const float* ch1Row = (__global const float*)(imgCh1 + (ic1step * (i + i0) + ic1off + j * sizeof(float)));
+    for (int j0 = 0; j0 < patchRadius; ++j0)
+      sum += ch1Row[j0];
+  }
+
+  desc[16] = sum / patchRadius;
+  sum = 0;
+
+  for (int i0 = 0; i0 < patchRadius; ++i0) {
+    __global const float* ch2Row = (__global const float*)(imgCh2 + (ic2step * (i + i0) + ic2off + j * sizeof(float)));
+    for (int j0 = 0; j0 < patchRadius; ++j0)
+      sum += ch2Row[j0];
+  }
+
+  desc[17] = sum / patchRadius;
+}

modules/optflow/test/test_OF_accuracy.cpp

@@ -49,8 +49,16 @@ using namespace optflow;
 
 static string getDataDir() { return TS::ptr()->get_data_path(); }
 
+static string getRubberWhaleFrame1() { return getDataDir() + "optflow/RubberWhale1.png"; }
+
+static string getRubberWhaleFrame2() { return getDataDir() + "optflow/RubberWhale2.png"; }
+
+static string getRubberWhaleGroundTruth() { return getDataDir() + "optflow/RubberWhale.flo"; }
+
 static bool isFlowCorrect(float u) { return !cvIsNaN(u) && (fabs(u) < 1e9); }
 
+static bool isFlowCorrect(double u) { return !cvIsNaN(u) && (fabs(u) < 1e9); }
+
 static float calcRMSE(Mat flow1, Mat flow2)
 {
     float sum = 0;
@@ -80,11 +88,36 @@ static float calcRMSE(Mat flow1, Mat flow2)
     return (float)sqrt(sum / (1e-9 + counter));
 }
 
+static float calcAvgEPE(vector< pair<Point2i, Point2i> > corr, Mat flow)
+{
+    double sum = 0;
+    int counter = 0;
+
+    for (size_t i = 0; i < corr.size(); ++i)
+    {
+        Vec2f flow1_at_point = Point2f(corr[i].second - corr[i].first);
+        Vec2f flow2_at_point = flow.at<Vec2f>(corr[i].first.y, corr[i].first.x);
+
+        double u1 = (double)flow1_at_point[0];
+        double v1 = (double)flow1_at_point[1];
+        double u2 = (double)flow2_at_point[0];
+        double v2 = (double)flow2_at_point[1];
+
+        if (isFlowCorrect(u1) && isFlowCorrect(u2) && isFlowCorrect(v1) && isFlowCorrect(v2))
+        {
+            sum += sqrt((u1 - u2) * (u1 - u2) + (v1 - v2) * (v1 - v2));
+            counter++;
+        }
+    }
+
+    return (float)(sum / counter);
+}
+
 bool readRubberWhale(Mat &dst_frame_1, Mat &dst_frame_2, Mat &dst_GT)
 {
-    const string frame1_path = getDataDir() + "optflow/RubberWhale1.png";
-    const string frame2_path = getDataDir() + "optflow/RubberWhale2.png";
-    const string gt_flow_path = getDataDir() + "optflow/RubberWhale.flo";
+    const string frame1_path = getRubberWhaleFrame1();
+    const string frame2_path = getRubberWhaleFrame2();
+    const string gt_flow_path = getRubberWhaleGroundTruth();
 
     dst_frame_1 = imread(frame1_path);
     dst_frame_2 = imread(frame2_path);
@@ -188,3 +221,65 @@ TEST(DenseOpticalFlow_VariationalRefinement, ReferenceAccuracy)
     ASSERT_EQ(GT.cols, flow.cols);
     EXPECT_LE(calcRMSE(GT, flow), target_RMSE);
 }
+
+TEST(DenseOpticalFlow_PCAFlow, ReferenceAccuracy)
+{
+    Mat frame1, frame2, GT;
+    ASSERT_TRUE(readRubberWhale(frame1, frame2, GT));
+    const float target_RMSE = 0.55f;
+
+    Mat flow;
+    Ptr<DenseOpticalFlow> algo = createOptFlow_PCAFlow();
+    algo->calc(frame1, frame2, flow);
+    ASSERT_EQ(GT.rows, flow.rows);
+    ASSERT_EQ(GT.cols, flow.cols);
+    EXPECT_LE(calcRMSE(GT, flow), target_RMSE);
+}
+
+TEST(DenseOpticalFlow_GlobalPatchColliderDCT, ReferenceAccuracy)
+{
+    Mat frame1, frame2, GT;
+    ASSERT_TRUE(readRubberWhale(frame1, frame2, GT));
+
+    const Size sz = frame1.size() / 2;
+    frame1 = frame1(Rect(0, 0, sz.width, sz.height));
+    frame2 = frame2(Rect(0, 0, sz.width, sz.height));
+    GT = GT(Rect(0, 0, sz.width, sz.height));
+
+    vector<Mat> img1, img2, gt;
+    vector< pair<Point2i, Point2i> > corr;
+    img1.push_back(frame1);
+    img2.push_back(frame2);
+    gt.push_back(GT);
+
+    Ptr< GPCForest<5> > forest = GPCForest<5>::create();
+    forest->train(img1, img2, gt, GPCTrainingParams(8, 3, GPC_DESCRIPTOR_DCT, false));
+    forest->findCorrespondences(frame1, frame2, corr);
+
+    ASSERT_LE(7500U, corr.size());
+    ASSERT_LE(calcAvgEPE(corr, GT), 0.5f);
+}
+
+TEST(DenseOpticalFlow_GlobalPatchColliderWHT, ReferenceAccuracy)
+{
+    Mat frame1, frame2, GT;
+    ASSERT_TRUE(readRubberWhale(frame1, frame2, GT));
+
+    const Size sz = frame1.size() / 2;
+    frame1 = frame1(Rect(0, 0, sz.width, sz.height));
+    frame2 = frame2(Rect(0, 0, sz.width, sz.height));
+    GT = GT(Rect(0, 0, sz.width, sz.height));
+
+    vector<Mat> img1, img2, gt;
+    vector< pair<Point2i, Point2i> > corr;
+    img1.push_back(frame1);
+    img2.push_back(frame2);
+    gt.push_back(GT);
+
+    Ptr< GPCForest<5> > forest = GPCForest<5>::create();
+    forest->train(img1, img2, gt, GPCTrainingParams(8, 3, GPC_DESCRIPTOR_WHT, false));
+    forest->findCorrespondences(frame1, frame2, corr);
+
+    ASSERT_LE(7000U, corr.size());
+    ASSERT_LE(calcAvgEPE(corr, GT), 0.5f);
+}