Merge pull request #41 from vpisarev/added_text_module

added "text" module; added linemod to rgbd module, fixed compile errors in rgbd

modules/rgbd/CMakeLists.txt

 set(the_description "RGBD algorithms")
 ocv_warnings_disable(CMAKE_CXX_FLAGS -Wundef)
-ocv_define_module(rgbd opencv_core opencv_calib3d opencv_contrib opencv_highgui opencv_imgproc)
+ocv_define_module(rgbd opencv_core opencv_calib3d opencv_highgui opencv_imgproc)

modules/rgbd/include/opencv2/rgbd.hpp

@@ -38,11 +38,12 @@
 
 #ifdef __cplusplus
 
-#include <limits>
-
 #include <opencv2/core.hpp>
+#include <limits>
 
 namespace cv
+{
+namespace rgbd
 {    
   /** Checks if the value is a valid depth. For CV_16U or CV_16S, the convention is to be invalid if it is
    * a limit. For a float/double, we just check if it is a NaN
@@ -427,7 +428,7 @@ namespace cv
 
     /** Method to compute a transformation from the source frame to the destination one.
      * Some odometry algorithms do not used some data of frames (eg. ICP does not use images).
-     * In such case corresponding arguments can be set as empty cv::Mat.
+     * In such case corresponding arguments can be set as empty Mat.
      * The method returns true if all internal computions were possible (e.g. there were enough correspondences, 
      * system of equations has a solution, etc) and resulting transformation satisfies some test if it's provided
      * by the Odometry inheritor implementation (e.g. thresholds for maximum translation and rotation).
@@ -507,7 +508,7 @@ namespace cv
     computeImpl(const Ptr<OdometryFrame>& srcFrame, const Ptr<OdometryFrame>& dstFrame, Mat& Rt,
                 const Mat& initRt) const;
 
-    // Some params have commented desired type. It's due to cv::AlgorithmInfo::addParams does not support it now.
+    // Some params have commented desired type. It's due to AlgorithmInfo::addParams does not support it now.
     /*float*/
     double minDepth, maxDepth, maxDepthDiff;
     /*vector<int>*/
@@ -556,7 +557,7 @@ namespace cv
     computeImpl(const Ptr<OdometryFrame>& srcFrame, const Ptr<OdometryFrame>& dstFrame, Mat& Rt,
                 const Mat& initRt) const;
 
-    // Some params have commented desired type. It's due to cv::AlgorithmInfo::addParams does not support it now.
+    // Some params have commented desired type. It's due to AlgorithmInfo::addParams does not support it now.
     /*float*/
     double minDepth, maxDepth, maxDepthDiff;
     /*float*/
@@ -569,7 +570,7 @@ namespace cv
 
     double maxTranslation, maxRotation;
 
-    mutable cv::Ptr<cv::RgbdNormals> normalsComputer;
+    mutable Ptr<RgbdNormals> normalsComputer;
   };
 
   /** Odometry that merges RgbdOdometry and ICPOdometry by minimize sum of their energy functions.
@@ -610,7 +611,7 @@ namespace cv
     computeImpl(const Ptr<OdometryFrame>& srcFrame, const Ptr<OdometryFrame>& dstFrame, Mat& Rt,
                 const Mat& initRt) const;
 
-    // Some params have commented desired type. It's due to cv::AlgorithmInfo::addParams does not support it now.
+    // Some params have commented desired type. It's due to AlgorithmInfo::addParams does not support it now.
     /*float*/
     double minDepth, maxDepth, maxDepthDiff;
     /*float*/
@@ -625,7 +626,7 @@ namespace cv
 
     double maxTranslation, maxRotation;
 
-    mutable cv::Ptr<cv::RgbdNormals> normalsComputer;
+    mutable Ptr<RgbdNormals> normalsComputer;
   };
 
   /** Warp the image: compute 3d points from the depth, transform them using given transformation, 
@@ -649,10 +650,12 @@ namespace cv
 // TODO Depth interpolation
 // Curvature
 // Get rescaleDepth return dubles if asked for
+} /* namespace rgbd */
 } /* namespace cv */
 
-#endif /* __cplusplus */
+#include "opencv2/rgbd/linemod.hpp"
 
+#endif /* __cplusplus */
 #endif
 
 /* End of file. */

modules/rgbd/samples/odometry_evaluation.cpp

@@ -36,18 +36,45 @@
 #include <opencv2/rgbd.hpp>
 
 #include <opencv2/highgui.hpp>
-#include <opencv2/contrib.hpp>
 #include <opencv2/calib3d.hpp>
 #include <opencv2/imgproc.hpp>
+#include <opencv2/core/utility.hpp>
 
 #include <iostream>
 #include <fstream>
 
 using namespace std;
 using namespace cv;
+using namespace cv::rgbd;
 
 #define BILATERAL_FILTER 0// if 1 then bilateral filter will be used for the depth
 
+class MyTickMeter
+{
+public:
+    MyTickMeter() { reset(); }
+    void start() { startTime = getTickCount(); }
+    void stop()
+    {
+        int64 time = getTickCount();
+        if ( startTime == 0 )
+            return;
+        ++counter;
+        sumTime += ( time - startTime );
+        startTime = 0;
+    }
+
+    int64 getTimeTicks() const { return sumTime; }
+    double getTimeSec()   const { return (double)getTimeTicks()/getTickFrequency(); }
+    int64 getCounter() const { return counter; }
+
+    void reset() { startTime = sumTime = 0; counter = 0; }
+private:
+    int64 counter;
+    int64 sumTime;
+    int64 startTime;
+};
+
 static
 void writeResults( const string& filename, const vector<string>& timestamps, const vector<Mat>& Rt )
 {
@@ -154,7 +181,7 @@ int main(int argc, char** argv)
     }
     odometry->set("cameraMatrix", cameraMatrix);
 
-    TickMeter gtm;
+    MyTickMeter gtm;
     int count = 0;
     for(int i = 0; !file.eof(); i++)
     {
@@ -167,7 +194,7 @@ int main(int argc, char** argv)
         // Read one pair (rgb and depth)
         // example: 1305031453.359684 rgb/1305031453.359684.png 1305031453.374112 depth/1305031453.374112.png
 #if BILATERAL_FILTER
-        TickMeter tm_bilateral_filter;
+        MyTickMeter tm_bilateral_filter;
 #endif
         {
             string rgbFilename = str.substr(timestampLength + 1, rgbPathLehgth );
@@ -213,7 +240,7 @@ int main(int argc, char** argv)
             Mat Rt;
             if(!Rts.empty())
             {
-                TickMeter tm;
+                MyTickMeter tm;
                 tm.start();
                 gtm.start();
                 bool res = odometry->compute(frame_curr, frame_prev, Rt);

modules/rgbd/src/depth_cleaner.cpp

@@ -33,19 +33,18 @@
  *
  */
 
-#include <opencv2/calib3d.hpp>
-#include <opencv2/imgproc.hpp>
-#include <opencv2/rgbd.hpp>
-#include <iostream>
+#include "precomp.hpp"
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 
-namespace
+namespace cv
+{
+namespace rgbd
 {
   class DepthCleanerImpl
   {
   public:
-    DepthCleanerImpl(int window_size, int depth, cv::DepthCleaner::DEPTH_CLEANER_METHOD method)
+    DepthCleanerImpl(int window_size, int depth, DepthCleaner::DEPTH_CLEANER_METHOD method)
         :
           depth_(depth),
           window_size_(window_size),
@@ -69,14 +68,11 @@ namespace
   protected:
     int depth_;
     int window_size_;
-    cv::DepthCleaner::DEPTH_CLEANER_METHOD method_;
+    DepthCleaner::DEPTH_CLEANER_METHOD method_;
   };
-}
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 
-namespace
-{
   /** Given a depth image, compute the normals as detailed in the LINEMOD paper
    * ``Gradient Response Maps for Real-Time Detection of Texture-Less Objects``
    * by S. Hinterstoisser, C. Cagniart, S. Ilic, P. Sturm, N. Navab, P. Fua, and V. Lepetit
@@ -85,10 +81,10 @@ namespace
   class NIL: public DepthCleanerImpl
   {
   public:
-    typedef cv::Vec<T, 3> Vec3T;
-    typedef cv::Matx<T, 3, 3> Mat33T;
+    typedef Vec<T, 3> Vec3T;
+    typedef Matx<T, 3, 3> Mat33T;
 
-    NIL(int window_size, int depth, cv::DepthCleaner::DEPTH_CLEANER_METHOD method)
+    NIL(int window_size, int depth, DepthCleaner::DEPTH_CLEANER_METHOD method)
         :
           DepthCleanerImpl(window_size, depth, method)
     {
@@ -106,27 +102,27 @@ namespace
      * @return
      */
     void
-    compute(const cv::Mat& depth_in, cv::Mat& depth_out) const
+    compute(const Mat& depth_in, Mat& depth_out) const
     {
       switch (depth_in.depth())
       {
         case CV_16U:
         {
-          const cv::Mat_<unsigned short> &depth(depth_in);
-          cv::Mat depth_out_tmp;
+          const Mat_<unsigned short> &depth(depth_in);
+          Mat depth_out_tmp;
           computeImpl<unsigned short, float>(depth, depth_out_tmp, 0.001f);
           depth_out_tmp.convertTo(depth_out, CV_16U);
           break;
         }
         case CV_32F:
         {
-          const cv::Mat_<float> &depth(depth_in);
+          const Mat_<float> &depth(depth_in);
           computeImpl<float, float>(depth, depth_out, 1);
           break;
         }
         case CV_64F:
         {
-          const cv::Mat_<double> &depth(depth_in);
+          const Mat_<double> &depth(depth_in);
           computeImpl<double, double>(depth, depth_out, 1);
           break;
         }
@@ -140,7 +136,7 @@ namespace
      */
     template<typename DepthDepth, typename ContainerDepth>
     void
-    computeImpl(const cv::Mat_<DepthDepth> &depth_in, cv::Mat & depth_out, ContainerDepth scale) const
+    computeImpl(const Mat_<DepthDepth> &depth_in, Mat & depth_out, ContainerDepth scale) const
     {
       const ContainerDepth theta_mean = (float)(30. * CV_PI / 180);
       int rows = depth_in.rows;
@@ -148,14 +144,14 @@ namespace
 
       // Precompute some data
       const ContainerDepth sigma_L = (float)(0.8 + 0.035 * theta_mean / (CV_PI / 2 - theta_mean));
-      cv::Mat_<ContainerDepth> sigma_z(rows, cols);
+      Mat_<ContainerDepth> sigma_z(rows, cols);
       for (int y = 0; y < rows; ++y)
         for (int x = 0; x < cols; ++x)
           sigma_z(y, x) = (float)(0.0012 + 0.0019 * (depth_in(y, x) * scale - 0.4) * (depth_in(y, x) * scale - 0.4));
 
       ContainerDepth difference_threshold = 10;
-      cv::Mat_<ContainerDepth> Dw_sum = cv::Mat_<ContainerDepth>::zeros(rows, cols), w_sum =
-          cv::Mat_<ContainerDepth>::zeros(rows, cols);
+      Mat_<ContainerDepth> Dw_sum = Mat_<ContainerDepth>::zeros(rows, cols), w_sum =
+          Mat_<ContainerDepth>::zeros(rows, cols);
       for (int y = 0; y < rows - 1; ++y)
       {
         // Every pixel has had the contribution of previous pixels (in a row-major way)
@@ -192,15 +188,12 @@ namespace
             }
         }
       }
-      cv::Mat(Dw_sum / w_sum).copyTo(depth_out);
+      Mat(Dw_sum / w_sum).copyTo(depth_out);
     }
   };
-}
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 
-namespace cv
-{
   /** Default constructor of the Algorithm class that computes normals
    */
   DepthCleaner::DepthCleaner(int depth, int window_size, int method_in)
@@ -292,12 +285,12 @@ namespace cv
   void
   DepthCleaner::operator()(InputArray depth_in_array, OutputArray depth_out_array) const
   {
-    cv::Mat depth_in = depth_in_array.getMat();
+    Mat depth_in = depth_in_array.getMat();
     CV_Assert(depth_in.dims == 2);
     CV_Assert(depth_in.channels() == 1);
 
     depth_out_array.create(depth_in.size(), depth_);
-    cv::Mat depth_out = depth_out_array.getMat();
+    Mat depth_out = depth_out_array.getMat();
 
     // Initialize the pimpl
     initialize();
@@ -324,3 +317,4 @@ namespace cv
     }
   }
 }
+}

modules/rgbd/src/depth_to_3d.cpp

@@ -34,12 +34,13 @@
  */
 
 #include <opencv2/rgbd.hpp>
-#include <limits>
 
 #include "depth_to_3d.h"
 #include "utils.h"
 
-namespace
+namespace cv
+{
+namespace rgbd
 {
   /**
    * @param K
@@ -47,7 +48,7 @@ namespace
    * @param mask the mask of the points to consider (can be empty)
    * @param points3d the resulting 3d points, a 3-channel matrix
    */
-  void
+  static void
   depthTo3d_from_uvz(const cv::Mat& in_K, const cv::Mat& u_mat, const cv::Mat& v_mat, const cv::Mat& z_mat,
                      cv::Mat& points3d)
   {
@@ -89,7 +90,7 @@ namespace
    * @param mask the mask of the points to consider (can be empty)
    * @param points3d the resulting 3d points
    */
-  void
+  static void
   depthTo3dMask(const cv::Mat& depth, const cv::Mat& K, const cv::Mat& mask, cv::Mat& points3d)
   {
     // Create 3D points in one go.
@@ -168,13 +169,9 @@ namespace
       }
     }
   }
-}
 
 ///////////////////////////////////////////////////////////////////////////////
 
-namespace cv
-{
-
   /**
    * @param K
    * @param depth the depth image
@@ -263,3 +260,4 @@ namespace cv
     }
   }
 }
+}

modules/rgbd/src/depth_to_3d.h

@@ -39,7 +39,12 @@
 #ifdef __cplusplus
 
 #include <opencv2/core.hpp>
-#include <limits>
+#include <limits.h>
+
+namespace cv
+{
+namespace rgbd
+{
 
 /**
  * @param depth the depth image, containing depth with the value T
@@ -114,6 +119,9 @@ convertDepthToFloat(const cv::Mat& depth, float scale, const cv::Mat &uv_mat, cv
   }
 }
 
+}
+}
+
 #endif /* __cplusplus */
 
 #endif

modules/rgbd/src/precomp.hpp

+/*M///////////////////////////////////////////////////////////////////////////////////////
+//
+//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
+//
+//  By downloading, copying, installing or using the software you agree to this license.
+//  If you do not agree to this license, do not download, install,
+//  copy or use the software.
+//
+//
+//                          License Agreement
+//                For Open Source Computer Vision Library
+//
+// Copyright (C) 2000-2008, Intel Corporation, all rights reserved.
+// Copyright (C) 2009, Willow Garage Inc., all rights reserved.
+// Third party copyrights are property of their respective owners.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//   * Redistribution's of source code must retain the above copyright notice,
+//     this list of conditions and the following disclaimer.
+//
+//   * Redistribution's in binary form must reproduce the above copyright notice,
+//     this list of conditions and the following disclaimer in the documentation
+//     and/or other materials provided with the distribution.
+//
+//   * The name of the copyright holders may not be used to endorse or promote products
+//     derived from this software without specific prior written permission.
+//
+// This software is provided by the copyright holders and contributors "as is" and
+// any express or implied warranties, including, but not limited to, the implied
+// warranties of merchantability and fitness for a particular purpose are disclaimed.
+// In no event shall the Intel Corporation or contributors be liable for any direct,
+// indirect, incidental, special, exemplary, or consequential damages
+// (including, but not limited to, procurement of substitute goods or services;
+// loss of use, data, or profits; or business interruption) however caused
+// and on any theory of liability, whether in contract, strict liability,
+// 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.
+//
+//M*/
+
+#ifndef __OPENCV_PRECOMP_H__
+#define __OPENCV_PRECOMP_H__
+
+#include "opencv2/rgbd.hpp"
+#include "opencv2/calib3d.hpp"
+#include "opencv2/imgproc.hpp"
+#include "opencv2/core/utility.hpp"
+#include "opencv2/core/private.hpp"
+#include <iostream>
+#include <list>
+#include <set>
+#include <limits>
+
+#endif

modules/rgbd/src/rgbd_init.cpp

@@ -39,6 +39,8 @@
 #include "opencv2/core/private.hpp"
 
 namespace cv
+{
+namespace rgbd
 {
   CV_INIT_ALGORITHM(DepthCleaner, "RGBD.DepthCleaner",
       obj.info()->addParam(obj, "window_size", obj.window_size_);
@@ -84,7 +86,7 @@ namespace cv
       obj.info()->addParam(obj, "transformType", obj.transformType);
       obj.info()->addParam(obj, "maxTranslation", obj.maxTranslation);
       obj.info()->addParam(obj, "maxRotation", obj.maxRotation);
-      obj.info()->addParam<cv::RgbdNormals>(obj, "normalsComputer", obj.normalsComputer, true, NULL, NULL);)
+      obj.info()->addParam<RgbdNormals>(obj, "normalsComputer", obj.normalsComputer, true, NULL, NULL);)
 
   CV_INIT_ALGORITHM(RgbdICPOdometry, "RGBD.RgbdICPOdometry",
       obj.info()->addParam(obj, "cameraMatrix", obj.cameraMatrix);
@@ -97,7 +99,7 @@ namespace cv
       obj.info()->addParam(obj, "transformType", obj.transformType);
       obj.info()->addParam(obj, "maxTranslation", obj.maxTranslation);
       obj.info()->addParam(obj, "maxRotation", obj.maxRotation);
-      obj.info()->addParam<cv::RgbdNormals>(obj, "normalsComputer", obj.normalsComputer, true, NULL, NULL);)
+      obj.info()->addParam<RgbdNormals>(obj, "normalsComputer", obj.normalsComputer, true, NULL, NULL);)
 
   bool
   initModule_rgbd(void);
@@ -113,3 +115,5 @@ namespace cv
     return all;
   }
 }
+}
+

modules/rgbd/src/utils.cpp

@@ -39,6 +39,8 @@
 #include "utils.h"
 
 namespace cv
+{
+namespace rgbd
 {    
   /** If the input image is of type CV_16UC1 (like the Kinect one), the image is converted to floats, divided
    * by 1000 to get a depth in meters, and the values 0 are converted to std::numeric_limits<float>::quiet_NaN()
@@ -75,3 +77,5 @@ namespace cv
       in.convertTo(out, depth);
   }
 }
+}
+

modules/rgbd/src/utils.h

@@ -40,6 +40,11 @@
 
 #include <opencv2/rgbd.hpp>
 
+namespace cv
+{
+namespace rgbd
+{
+
 /** If the input image is of type CV_16UC1 (like the Kinect one), the image is converted to floats, divided
  * by 1000 to get a depth in meters, and the values 0 are converted to std::numeric_limits<float>::quiet_NaN()
  * Otherwise, the image is simply converted to floats
@@ -50,22 +55,25 @@
  */
 template<typename T>
 void
-rescaleDepthTemplated(const cv::Mat& in, cv::Mat& out);
+rescaleDepthTemplated(const Mat& in, Mat& out);
 
 template<>
 inline void
-rescaleDepthTemplated<float>(const cv::Mat& in, cv::Mat& out)
+rescaleDepthTemplated<float>(const Mat& in, Mat& out)
 {
   rescaleDepth(in, CV_32F, out);
 }
 
 template<>
 inline void
-rescaleDepthTemplated<double>(const cv::Mat& in, cv::Mat& out)
+rescaleDepthTemplated<double>(const Mat& in, Mat& out)
 {
   rescaleDepth(in, CV_64F, out);
 }
 
+}
+}
+
 #endif /* __cplusplus */
 
 #endif

modules/rgbd/test/test_odometry.cpp

@@ -33,13 +33,16 @@
  *
  */
 
+#include "test_precomp.hpp"
+
 #include <opencv2/calib3d.hpp>
 #include <opencv2/highgui.hpp>
 #include <opencv2/imgproc.hpp>
 
-#include "test_precomp.hpp"
-
-using namespace cv;
+namespace cv
+{
+namespace rgbd
+{
 
 #define SHOW_DEBUG_LOG     0
 #define SHOW_DEBUG_IMAGES  0
@@ -330,21 +333,23 @@ void CV_OdometryTest::run(int)
 /****************************************************************************************\
 *                                Tests registrations                                     *
 \****************************************************************************************/
+}
+}
 
 TEST(RGBD_Odometry_Rgbd, algorithmic)
 {
-    CV_OdometryTest test(Algorithm::create<Odometry>("RGBD.RgbdOdometry"), 0.99, 0.94);
+    cv::rgbd::CV_OdometryTest test(cv::Algorithm::create<cv::rgbd::Odometry>("RGBD.RgbdOdometry"), 0.99, 0.94);
     test.safe_run();
 }
 
 TEST(RGBD_Odometry_ICP, algorithmic)
 {
-    CV_OdometryTest test(Algorithm::create<Odometry>("RGBD.ICPOdometry"), 0.99, 0.99);
+    cv::rgbd::CV_OdometryTest test(cv::Algorithm::create<cv::rgbd::Odometry>("RGBD.ICPOdometry"), 0.99, 0.99);
     test.safe_run();
 }
 
 TEST(RGBD_Odometry_RgbdICP, algorithmic)
 {
-    CV_OdometryTest test(Algorithm::create<Odometry>("RGBD.RgbdICPOdometry"), 0.99, 0.99);
+    cv::rgbd::CV_OdometryTest test(cv::Algorithm::create<cv::rgbd::Odometry>("RGBD.RgbdICPOdometry"), 0.99, 0.99);
     test.safe_run();
 }

modules/rgbd/test/test_utils.cpp

+#include "test_precomp.hpp"
+
 #include <opencv2/calib3d.hpp>
 
-#include "test_precomp.hpp"
+namespace cv
+{
+namespace rgbd
+{
 
 class CV_RgbdDepthTo3dTest: public cvtest::BaseTest
 {
@@ -18,31 +23,31 @@ protected:
     try
     {
       // K from a VGA Kinect
-      cv::Mat K = (cv::Mat_<float>(3, 3) << 525., 0., 319.5, 0., 525., 239.5, 0., 0., 1.);
+      Mat K = (Mat_<float>(3, 3) << 525., 0., 319.5, 0., 525., 239.5, 0., 0., 1.);
 
       // Create a random depth image
-      cv::RNG rng;
-      cv::Mat_<float> depth(480, 640);
-      rng.fill(depth, cv::RNG::UNIFORM, 0, 100);
+      RNG rng;
+      Mat_<float> depth(480, 640);
+      rng.fill(depth, RNG::UNIFORM, 0, 100);
 
       // Create some 3d points on the plane
       int rows = depth.rows, cols = depth.cols;
-      cv::Mat_<cv::Vec3f> points3d;
-      cv::depthTo3d(depth, K, points3d);
+      Mat_<Vec3f> points3d;
+      depthTo3d(depth, K, points3d);
 
       // Make sure the points belong to the plane
-      cv::Mat points = points3d.reshape(1, rows*cols);
-      cv::Mat image_points;
-      cv::Mat rvec;
-      cv::Rodrigues(cv::Mat::eye(3,3,CV_32F),rvec);
-      cv::Mat tvec = (cv::Mat_<float>(1,3) << 0, 0, 0);
-      cv::projectPoints(points, rvec, tvec, K, cv::Mat(), image_points);
+      Mat points = points3d.reshape(1, rows*cols);
+      Mat image_points;
+      Mat rvec;
+      Rodrigues(Mat::eye(3,3,CV_32F),rvec);
+      Mat tvec = (Mat_<float>(1,3) << 0, 0, 0);
+      projectPoints(points, rvec, tvec, K, Mat(), image_points);
       image_points = image_points.reshape(2, rows);
 
       float avg_diff = 0;
       for (int y = 0; y < rows; ++y)
         for (int x = 0; x < cols; ++x)
-          avg_diff += (float)cv::norm(image_points.at<cv::Vec2f>(y,x) - cv::Vec2f((float)x,(float)y));
+          avg_diff += (float)norm(image_points.at<Vec2f>(y,x) - Vec2f((float)x,(float)y));
 
       // Verify the function works
       ASSERT_LE(avg_diff/rows/cols, 1e-4) << "Average error for ground truth is: " << (avg_diff / rows / cols);
@@ -54,8 +59,11 @@ protected:
   }
 };
 
+}
+}
+
 TEST(Rgbd_DepthTo3d, compute)
 {
-  CV_RgbdDepthTo3dTest test;
+  cv::rgbd::CV_RgbdDepthTo3dTest test;
   test.safe_run();
 }

modules/text/CMakeLists.txt

+set(the_description "Text Detection and Recognition")
+ocv_define_module(text opencv_ml opencv_highgui opencv_imgproc opencv_core)