refactoring of copy_non_nans

modules/viz/include/opencv2/viz/types.hpp

 #pragma once
 
 #include <vector>
-#include <boost/concept_check.hpp>
 #include <opencv2/core/cvdef.h>
 #include <opencv2/core.hpp>
 #include <opencv2/core/affine.hpp>
@@ -30,6 +29,8 @@ namespace temp_viz
     typedef cv::Size Size;
     typedef cv::Point Point;
     typedef cv::InputArray InputArray;
+    using cv::Point3_;
+    using cv::Vec;
 
 
 
@@ -90,17 +91,21 @@ namespace temp_viz
     
     Vec3d operator*(const Affine3f& affine, const Vec3d& vec);
     
-    inline bool isNaN( float x )
+    inline bool isNan(float x)
     {
-	unsigned int *u = (reinterpret_cast<unsigned int *>(&x));
+        unsigned int *u = reinterpret_cast<unsigned int *>(&x);
         return ((u[0] & 0x7f800000) == 0x7f800000) && (u[0] & 0x007fffff);
     }
     
-    inline bool isNaN( double x )
+    inline bool isNan(double x)
     {
-	// Here u has two elements
-	unsigned int *u = (reinterpret_cast<unsigned int *>(&x));
-	return (u[1] & 0x7ff00000) == 0x7ff00000 && 
-	(u[0] != 0 || (u[1] & 0x000fffff) != 0);
+        unsigned int *u = reinterpret_cast<unsigned int *>(&x);
+        return (u[1] & 0x7ff00000) == 0x7ff00000 && (u[0] != 0 || (u[1] & 0x000fffff) != 0);
     }    
+
+    template<typename _Tp, int cn> inline bool isNan(const Vec<_Tp, cn>& v)
+    { return isNan(v.val[0]) || isNan(v.val[1]) || isNan(v.val[2]); }
+
+    template<typename _Tp> inline bool isNan(const Point3_<_Tp>& p)
+    { return isNan(p.x) || isNan(p.y) || isNan(p.z); }
 }

modules/viz/src/q/viz3d_impl.hpp

@@ -447,10 +447,10 @@ void convertToVtkMatrix (const Eigen::Vector4f &origin, const Eigen::Quaternion<
 void convertToEigenMatrix (const vtkSmartPointer<vtkMatrix4x4> &vtk_matrix, Eigen::Matrix4f &m);
 
 
-template<typename _Tp, typename _Ts, typename _Tc> inline int copy_non_nan_loop(_Tp *d, InputArray _s, InputArray _c)
+
+
+template<typename _Tp, typename _Ts, typename _Tc> inline int copy_non_nan_loop(_Tp *d, const Mat& s, const Mat& c)
 {
-    Mat s = _s.getMat();
-    Mat c = _c.getMat();
     CV_Assert(s.size() == c.size());
     int j = 0;
     for(int y = 0; y < s.rows; ++y)
@@ -458,24 +458,20 @@ template<typename _Tp, typename _Ts, typename _Tc> inline int copy_non_nan_loop(
         const _Ts* srow = s.ptr<_Ts>(y);
         const _Tc* crow = c.ptr<_Tc>(y);
         for(int x = 0; x < s.cols; ++x)
-	    if (!isNaN(crow[x][0]) && !isNaN(crow[x][1]) && !isNaN(crow[x][2]))
-	    {
+            if (!isNan(crow[x]))
                 d[j++] = _Tp((srow[x])[0], (srow[x])[1], (srow[x])[2]);
     }
-    }
     return j;
 }
 
 /** \brief Assign a value to a variable if another variable is not NaN
     * \param[in] d the destination variable
-    * \param[in] _s the source variable
-    * \param[in] _c the values to be controlled if NaN (can be different from _s)
+    * \param[in] s the source variable
+    * \param[in] c the values to be controlled if NaN (can be different from s)
     * \param[out] j number of points that are copied
     */
-template<typename _Tp> inline int copy_non_nans(_Tp *d, InputArray _s, InputArray _c)
+template<typename _Tp> inline int copy_non_nans(_Tp *d, const Mat& s, const Mat& c)
 {
-    Mat s = _s.getMat();
-    Mat c = _c.getMat();
     CV_Assert(s.size() == c.size());
     
     int j = 0;
@@ -485,20 +481,20 @@ template<typename _Tp> inline int copy_non_nans(_Tp *d, InputArray _s, InputArra
         {
             switch(c.type())
             {
-		case CV_32FC3: j = copy_non_nan_loop<_Tp, Vec4f, Vec3f>(d,_s,_c); break;
-		case CV_32FC4: j = copy_non_nan_loop<_Tp, Vec4f, Vec4f>(d,_s,_c); break;
-		case CV_64FC3: j = copy_non_nan_loop<_Tp, Vec4f, Vec3d>(d,_s,_c); break;
-		case CV_64FC4: j = copy_non_nan_loop<_Tp, Vec4f, Vec4d>(d,_s,_c); break;
+            case CV_32FC3: j = copy_non_nan_loop<_Tp, Vec4f, Vec3f>(d, s, c); break;
+            case CV_32FC4: j = copy_non_nan_loop<_Tp, Vec4f, Vec4f>(d, s, c); break;
+            case CV_64FC3: j = copy_non_nan_loop<_Tp, Vec4f, Vec3d>(d, s, c); break;
+            case CV_64FC4: j = copy_non_nan_loop<_Tp, Vec4f, Vec4d>(d, s, c); break;
             }
         }
         else if (s.type() == CV_64FC4)
         {
             switch(c.type())
             {
-		case CV_32FC3: j = copy_non_nan_loop<_Tp, Vec4d, Vec3f>(d,_s,_c); break;
-		case CV_32FC4: j = copy_non_nan_loop<_Tp, Vec4d, Vec4f>(d,_s,_c); break;
-		case CV_64FC3: j = copy_non_nan_loop<_Tp, Vec4d, Vec3d>(d,_s,_c); break;
-		case CV_64FC4: j = copy_non_nan_loop<_Tp, Vec4d, Vec4d>(d,_s,_c); break;
+            case CV_32FC3: j = copy_non_nan_loop<_Tp, Vec4d, Vec3f>(d, s, c); break;
+            case CV_32FC4: j = copy_non_nan_loop<_Tp, Vec4d, Vec4f>(d, s, c); break;
+            case CV_64FC3: j = copy_non_nan_loop<_Tp, Vec4d, Vec3d>(d, s, c); break;
+            case CV_64FC4: j = copy_non_nan_loop<_Tp, Vec4d, Vec4d>(d, s, c); break;
             }
         }
     }
@@ -506,10 +502,10 @@ template<typename _Tp> inline int copy_non_nans(_Tp *d, InputArray _s, InputArra
     {
         switch(c.type())
         {
-	    case CV_32FC3: j = copy_non_nan_loop<_Tp, _Tp, Vec3f>(d,_s,_c); break;
-	    case CV_32FC4: j = copy_non_nan_loop<_Tp, _Tp, Vec4f>(d,_s,_c); break;
-	    case CV_64FC3: j = copy_non_nan_loop<_Tp, _Tp, Vec3d>(d,_s,_c); break;
-	    case CV_64FC4: j = copy_non_nan_loop<_Tp, _Tp, Vec4d>(d,_s,_c); break;
+        case CV_32FC3: j = copy_non_nan_loop<_Tp, _Tp, Vec3f>(d, s, c); break;
+        case CV_32FC4: j = copy_non_nan_loop<_Tp, _Tp, Vec4f>(d, s, c); break;
+        case CV_64FC3: j = copy_non_nan_loop<_Tp, _Tp, Vec3d>(d, s, c); break;
+        case CV_64FC4: j = copy_non_nan_loop<_Tp, _Tp, Vec4d>(d, s, c); break;
         }
     }
     return j;