Merge pull request #2832 from tsenst:Resolve_Issue_2796_RICInterpolation

Author: alalek

modules/ximgproc/include/opencv2/ximgproc/sparse_match_interpolator.hpp

@@ -57,12 +57,12 @@ class CV_EXPORTS_W SparseMatchInterpolator : public Algorithm
     @param from_image first of the two matched images, 8-bit single-channel or three-channel.
 
     @param from_points points of the from_image for which there are correspondences in the
-    to_image (Point2f vector, size shouldn't exceed 32767)
+    to_image (Point2f vector or Mat of depth CV_32F)
 
     @param to_image second of the two matched images, 8-bit single-channel or three-channel.
 
     @param to_points points in the to_image corresponding to from_points
-    (Point2f vector, size shouldn't exceed 32767)
+    (Point2f vector or Mat of depth CV_32F)
 
     @param dense_flow output dense matching (two-channel CV_32F image)
      */

modules/ximgproc/misc/python/test/test_sparse_match_interpolator.py

@@ -0,0 +1,71 @@
+#!/usr/bin/env python
+import numpy as np
+import cv2 as cv
+
+from tests_common import NewOpenCVTests
+
+class Interpolator_test(NewOpenCVTests):
+    def test_edgeaware_interpolator(self):
+        # readGT
+        MAX_DIF = 1.0
+        MAX_MEAN_DIF = 1.0 / 256.0
+
+        src = cv.imread(self.find_file("cv/optflow/RubberWhale1.png"), cv.IMREAD_COLOR)
+        self.assertFalse(src is None)
+
+        ref_flow = cv.readOpticalFlow(self.find_file("cv/sparse_match_interpolator/RubberWhale_reference_result.flo"))
+        self.assertFalse(ref_flow is None)
+
+        matches = np.genfromtxt(self.find_file("cv/sparse_match_interpolator/RubberWhale_sparse_matches.txt")).astype(np.float32)
+        from_points = matches[:,0:2]
+        to_points = matches[:,2:4]
+        interpolator = cv.ximgproc.createEdgeAwareInterpolator()
+        interpolator.setK(128)
+        interpolator.setSigma(0.05)
+        interpolator.setUsePostProcessing(True)
+        interpolator.setFGSLambda(500.0)
+        interpolator.setFGSSigma(1.5)
+
+        dense_flow = interpolator.interpolate(src, from_points, src, to_points)
+
+        self.assertTrue(cv.norm(dense_flow, ref_flow, cv.NORM_INF) <= MAX_DIF)
+        self.assertTrue(cv.norm(dense_flow, ref_flow, cv.NORM_L1) <= (MAX_MEAN_DIF * dense_flow.shape[0] * dense_flow.shape[1]))
+
+    def test_ric_interpolator(self):
+        # readGT
+        MAX_DIF = 6.0
+        MAX_MEAN_DIF = 60.0 / 256.0
+
+        src0 = cv.imread(self.find_file("cv/optflow/RubberWhale1.png"), cv.IMREAD_COLOR)
+        self.assertFalse(src0 is None)
+
+        src1 = cv.imread(self.find_file("cv/optflow/RubberWhale2.png"), cv.IMREAD_COLOR)
+        self.assertFalse(src1 is None)
+
+        ref_flow = cv.readOpticalFlow(self.find_file("cv/sparse_match_interpolator/RubberWhale_reference_result.flo"))
+        self.assertFalse(ref_flow is None)
+
+        matches = np.genfromtxt(self.find_file("cv/sparse_match_interpolator/RubberWhale_sparse_matches.txt")).astype(np.float32)
+        from_points = matches[:,0:2]
+        to_points = matches[:,2:4]
+
+        interpolator = cv.ximgproc.createRICInterpolator()
+        interpolator.setK(32)
+        interpolator.setSuperpixelSize(15)
+        interpolator.setSuperpixelNNCnt(150)
+        interpolator.setSuperpixelRuler(15.0)
+        interpolator.setSuperpixelMode(cv.ximgproc.SLIC)
+        interpolator.setAlpha(0.7)
+        interpolator.setModelIter(4)
+        interpolator.setRefineModels(True)
+        interpolator.setMaxFlow(250)
+        interpolator.setUseVariationalRefinement(True)
+        interpolator.setUseGlobalSmootherFilter(True)
+        interpolator.setFGSLambda(500.0)
+        interpolator.setFGSSigma(1.5)
+        dense_flow = interpolator.interpolate(src0, from_points, src1, to_points)
+        self.assertTrue(cv.norm(dense_flow, ref_flow, cv.NORM_INF) <= MAX_DIF)
+        self.assertTrue(cv.norm(dense_flow, ref_flow, cv.NORM_L1) <= (MAX_MEAN_DIF * dense_flow.shape[0] * dense_flow.shape[1]))
+
+if __name__ == '__main__':
+    NewOpenCVTests.bootstrap()

modules/ximgproc/src/sparse_match_interpolators.cpp

@@ -173,19 +173,33 @@ Ptr<EdgeAwareInterpolatorImpl> EdgeAwareInterpolatorImpl::create()
 void EdgeAwareInterpolatorImpl::interpolate(InputArray from_image, InputArray from_points, InputArray, InputArray to_points, OutputArray dense_flow)
 {
     CV_Assert( !from_image.empty() && (from_image.depth() == CV_8U) && (from_image.channels() == 3 || from_image.channels() == 1) );
-    CV_Assert( !from_points.empty() && from_points.isVector() &&
-               !to_points  .empty() && to_points  .isVector() &&
-               from_points.sameSize(to_points) );
+    CV_Assert( !from_points.empty() && !to_points.empty() && from_points.sameSize(to_points) );
+    CV_Assert((from_points.isVector() || from_points.isMat()) && from_points.depth() == CV_32F);
+    CV_Assert((to_points.isVector() || to_points.isMat()) && to_points.depth() == CV_32F);
+    CV_Assert(from_points.sameSize(to_points));
 
     w = from_image.cols();
     h = from_image.rows();
 
-    vector<Point2f> from_vector = *(const vector<Point2f>*)from_points.getObj();
-    vector<Point2f> to_vector   = *(const vector<Point2f>*)to_points  .getObj();
-    vector<SparseMatch> matches_vector(from_vector.size());
-    for(unsigned int i=0;i<from_vector.size();i++)
-        matches_vector[i] = SparseMatch(from_vector[i],to_vector[i]);
+    Mat from_mat = from_points.getMat();
+    Mat to_mat = to_points.getMat();
+    int npoints = from_mat.checkVector(2, CV_32F, false);
+    if (from_mat.channels() != 2)
+        from_mat = from_mat.reshape(2, npoints);
+
+    if (to_mat.channels() != 2){
+        to_mat = to_mat.reshape(2, npoints);
+        npoints = from_mat.checkVector(2, CV_32F, false);
+    }
+
+
+    vector<SparseMatch> matches_vector(npoints);
+    for(unsigned int i=0;i<matches_vector.size();i++)
+        matches_vector[i] = SparseMatch(from_mat.at<Point2f>(i), to_mat.at<Point2f>(i));
+
+
     sort(matches_vector.begin(),matches_vector.end());
+
     match_num = (int)matches_vector.size();
     CV_Assert(match_num<SHRT_MAX);
 
@@ -1102,17 +1116,29 @@ void RICInterpolatorImpl::interpolate(InputArray from_image, InputArray from_poi
     CV_Assert(use_variational_refinement == false || !to_image.empty());
     CV_Assert(use_variational_refinement == false || to_image.depth() == CV_8U);
     CV_Assert(use_variational_refinement == false || to_image.channels() == 3 || to_image.channels() == 1);
-    CV_Assert(!from_points.empty() && from_points.isVector());
-    CV_Assert(!to_points.empty() && to_points.isVector());
+    CV_Assert(!from_points.empty());
+    CV_Assert(!to_points.empty());
+    CV_Assert((from_points.isVector() || from_points.isMat()) && from_points.depth() == CV_32F);
+    CV_Assert((to_points.isVector() || to_points.isMat()) && to_points.depth() == CV_32F);
     CV_Assert(from_points.sameSize(to_points));
 
-    vector<Point2f> from_vector = *(const vector<Point2f>*)from_points.getObj();
-    vector<Point2f> to_vector = *(const vector<Point2f>*)to_points.getObj();
-    vector<SparseMatch> matches_vector(from_vector.size());
-    for (unsigned int i = 0; i < from_vector.size(); i++)
-        matches_vector[i] = SparseMatch(from_vector[i], to_vector[i]);
+    Mat from_mat = from_points.getMat();
+    Mat to_mat = to_points.getMat();
+    int npoints = from_mat.checkVector(2, CV_32F, false);
+
+    if (from_mat.channels() != 2)
+        from_mat = from_mat.reshape(2, npoints);
+
+    if (to_mat.channels() != 2 ){
+        to_mat = to_mat.reshape(2, npoints);
+        npoints = from_mat.checkVector(2, CV_32F, false);
+    }
+
+    vector<SparseMatch> matches_vector(npoints);
+    for(unsigned int i=0;i<matches_vector.size();i++)
+        matches_vector[i] = SparseMatch(from_mat.at<Point2f>(i),to_mat.at<Point2f>(i));
 
-    match_num = static_cast<int>(from_vector.size());
+    match_num = static_cast<int>(matches_vector.size());
 
     Mat src = from_image.getMat();
     Size src_size = src.size();

modules/ximgproc/test/test_sparse_match_interpolator.cpp

@@ -93,6 +93,14 @@ TEST(InterpolatorTest, ReferenceAccuracy)
 
     EXPECT_LE(cv::norm(res_flow, ref_flow, NORM_INF), MAX_DIF);
     EXPECT_LE(cv::norm(res_flow, ref_flow, NORM_L1) , MAX_MEAN_DIF*res_flow.total());
+
+    Mat from_point_mat(from_points);
+    Mat to_points_mat(to_points);
+    interpolator->interpolate(src,from_point_mat,Mat(),to_points_mat,res_flow);
+
+    EXPECT_LE(cv::norm(res_flow, ref_flow, NORM_INF), MAX_DIF);
+    EXPECT_LE(cv::norm(res_flow, ref_flow, NORM_L1) , MAX_MEAN_DIF*res_flow.total());
+
 }
 
 TEST(InterpolatorTest, RICReferenceAccuracy)
@@ -141,6 +149,13 @@ TEST(InterpolatorTest, RICReferenceAccuracy)
 
     EXPECT_LE(cv::norm(res_flow, ref_flow, NORM_INF), MAX_DIF);
     EXPECT_LE(cv::norm(res_flow, ref_flow, NORM_L1), MAX_MEAN_DIF*res_flow.total());
+
+    Mat from_point_mat(from_points);
+    Mat to_points_mat(to_points);
+    interpolator->interpolate(src, from_point_mat, src1, to_points_mat, res_flow);
+
+    EXPECT_LE(cv::norm(res_flow, ref_flow, NORM_INF), MAX_DIF);
+    EXPECT_LE(cv::norm(res_flow, ref_flow, NORM_L1) , MAX_MEAN_DIF*res_flow.total());
 }
 
 TEST_P(InterpolatorTest, MultiThreadReproducibility)