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,12 +38,13 @@
 
 #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
    * @param depth the depth to check for validity
@@ -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/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
@@ -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

@@ -40,6 +40,8 @@
 
 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
@@ -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
@@ -152,7 +155,7 @@ void dilateFrame(Mat& image, Mat& depth)
 class CV_OdometryTest : public cvtest::BaseTest
 {
 public:
-    CV_OdometryTest(const Ptr<Odometry>& _odometry, 
+    CV_OdometryTest(const Ptr<Odometry>& _odometry,
                     double _maxError1, 
                     double _maxError5) :
         odometry(_odometry), 
@@ -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/text/CMakeLists.txt

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