From 49a357b9485d62be85e1c69628a8e8fdd9bbe01d Mon Sep 17 00:00:00 2001 From: Vincent Rabaud Date: Thu, 13 Feb 2014 01:38:46 +0100 Subject: [PATCH] add an RGBD module --- modules/rgbd/CMakeLists.txt | 3 + modules/rgbd/doc/rgbd.rst | 12 + modules/rgbd/include/opencv2/rgbd.hpp | 658 ++++++++ modules/rgbd/samples/CMakeLists.txt | 9 + modules/rgbd/samples/odometry_evaluation.cpp | 250 +++ modules/rgbd/src/depth_cleaner.cpp | 326 ++++ modules/rgbd/src/depth_to_3d.cpp | 265 ++++ modules/rgbd/src/depth_to_3d.h | 121 ++ modules/rgbd/src/normal.cpp | 888 +++++++++++ modules/rgbd/src/odometry.cpp | 1406 +++++++++++++++++ modules/rgbd/src/plane.cpp | 641 ++++++++ modules/rgbd/src/rgbd_init.cpp | 115 ++ modules/rgbd/src/utils.cpp | 77 + modules/rgbd/src/utils.h | 73 + modules/rgbd/test/test_main.cpp | 3 + modules/rgbd/test/test_normal.cpp | 415 +++++ modules/rgbd/test/test_odometry.cpp | 350 ++++ modules/rgbd/test/test_precomp.cpp | 1 + modules/rgbd/test/test_precomp.hpp | 8 + modules/rgbd/test/test_utils.cpp | 61 + modules/rgbd/testdata/rgbd/odometry/depth.png | Bin 0 -> 123265 bytes modules/rgbd/testdata/rgbd/odometry/rgb.png | Bin 0 -> 523446 bytes 22 files changed, 5682 insertions(+) create mode 100644 modules/rgbd/CMakeLists.txt create mode 100644 modules/rgbd/doc/rgbd.rst create mode 100644 modules/rgbd/include/opencv2/rgbd.hpp create mode 100644 modules/rgbd/samples/CMakeLists.txt create mode 100644 modules/rgbd/samples/odometry_evaluation.cpp create mode 100644 modules/rgbd/src/depth_cleaner.cpp create mode 100644 modules/rgbd/src/depth_to_3d.cpp create mode 100644 modules/rgbd/src/depth_to_3d.h create mode 100644 modules/rgbd/src/normal.cpp create mode 100644 modules/rgbd/src/odometry.cpp create mode 100644 modules/rgbd/src/plane.cpp create mode 100644 modules/rgbd/src/rgbd_init.cpp create mode 100644 modules/rgbd/src/utils.cpp create mode 100644 modules/rgbd/src/utils.h create mode 100644 modules/rgbd/test/test_main.cpp create mode 100644 modules/rgbd/test/test_normal.cpp create mode 100644 modules/rgbd/test/test_odometry.cpp create mode 100644 modules/rgbd/test/test_precomp.cpp create mode 100644 modules/rgbd/test/test_precomp.hpp create mode 100644 modules/rgbd/test/test_utils.cpp create mode 100644 modules/rgbd/testdata/rgbd/odometry/depth.png create mode 100644 modules/rgbd/testdata/rgbd/odometry/rgb.png diff --git a/modules/rgbd/CMakeLists.txt b/modules/rgbd/CMakeLists.txt new file mode 100644 index 000000000..165bd4626 --- /dev/null +++ b/modules/rgbd/CMakeLists.txt @@ -0,0 +1,3 @@ +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) diff --git a/modules/rgbd/doc/rgbd.rst b/modules/rgbd/doc/rgbd.rst new file mode 100644 index 000000000..ea586449e --- /dev/null +++ b/modules/rgbd/doc/rgbd.rst @@ -0,0 +1,12 @@ +************************** +rgbd. RGB-Depth Processing +************************** + +.. highlight:: cpp + +.. toctree:: + :maxdepth: 2 + + depth_image + geometry + odometry diff --git a/modules/rgbd/include/opencv2/rgbd.hpp b/modules/rgbd/include/opencv2/rgbd.hpp new file mode 100644 index 000000000..2ebdef851 --- /dev/null +++ b/modules/rgbd/include/opencv2/rgbd.hpp @@ -0,0 +1,658 @@ +/* + * Software License Agreement (BSD License) + * + * Copyright (c) 2009, Willow Garage, Inc. + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions 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. + * * Neither the name of Willow Garage, Inc. nor the names of its + * contributors may 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 + * COPYRIGHT OWNER 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. + * + */ + +#ifndef __OPENCV_RGBD_HPP__ +#define __OPENCV_RGBD_HPP__ + +#ifdef __cplusplus + +#include + +#include + +namespace cv +{ + /** 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 + */ + CV_EXPORTS + inline bool + isValidDepth(const float & depth) + { + return !cvIsNaN(depth); + } + CV_EXPORTS + inline bool + isValidDepth(const double & depth) + { + return !cvIsNaN(depth); + } + CV_EXPORTS + inline bool + isValidDepth(const short int & depth) + { + return (depth != std::numeric_limits::min()) && (depth != std::numeric_limits::max()); + } + CV_EXPORTS + inline bool + isValidDepth(const unsigned short int & depth) + { + return (depth != std::numeric_limits::min()) + && (depth != std::numeric_limits::max()); + } + CV_EXPORTS + inline bool + isValidDepth(const int & depth) + { + return (depth != std::numeric_limits::min()) && (depth != std::numeric_limits::max()); + } + CV_EXPORTS + inline bool + isValidDepth(const unsigned int & depth) + { + return (depth != std::numeric_limits::min()) && (depth != std::numeric_limits::max()); + } + + /** Object that can compute the normals in an image. + * It is an object as it can cache data for speed efficiency + * The implemented methods are either: + * - FALS (the fastest) and SRI from + * ``Fast and Accurate Computation of Surface Normals from Range Images`` + * by H. Badino, D. Huber, Y. Park and T. Kanade + * - the normals with bilateral filtering on a depth image from + * ``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 + */ + class CV_EXPORTS RgbdNormals: public Algorithm + { + public: + enum RGBD_NORMALS_METHOD + { + RGBD_NORMALS_METHOD_FALS, RGBD_NORMALS_METHOD_LINEMOD, RGBD_NORMALS_METHOD_SRI + }; + + RgbdNormals() + : + rows_(0), + cols_(0), + depth_(0), + K_(Mat()), + window_size_(0), + method_(RGBD_NORMALS_METHOD_FALS), + rgbd_normals_impl_(0) + { + } + + /** Constructor + * @param rows the number of rows of the depth image normals will be computed on + * @param cols the number of cols of the depth image normals will be computed on + * @param depth the depth of the normals (only CV_32F or CV_64F for FALS and SRI, CV_16U for LINEMOD) + * @param K the calibration matrix to use + * @param window_size the window size to compute the normals: can only be 1,3,5 or 7 + * @param method one of the methods to use: RGBD_NORMALS_METHOD_SRI, RGBD_NORMALS_METHOD_FALS + */ + RgbdNormals(int rows, int cols, int depth, InputArray K, int window_size = 5, int method = + RGBD_NORMALS_METHOD_FALS); + + ~RgbdNormals(); + + AlgorithmInfo* + info() const; + + /** Given a set of 3d points in a depth image, compute the normals at each point. + * @param points a rows x cols x 3 matrix of CV_32F/CV64F or a rows x cols x 1 CV_U16S + * @param normals a rows x cols x 3 matrix + */ + void + operator()(InputArray points, OutputArray normals) const; + + /** Initializes some data that is cached for later computation + * If that function is not called, it will be called the first time normals are computed + */ + void + initialize() const; + + /** Return the current method in that normal computer + * @return + */ + int + method() const + { + return method_; + } + protected: + void + initialize_normals_impl(int rows, int cols, int depth, const Mat & K, int window_size, int method) const; + + int rows_, cols_, depth_; + Mat K_; + int window_size_; + int method_; + mutable void* rgbd_normals_impl_; + }; + + /** Object that can clean a noisy depth image + */ + class CV_EXPORTS DepthCleaner: public Algorithm + { + public: + /** NIL method is from + * ``Modeling Kinect Sensor Noise for Improved 3d Reconstruction and Tracking`` + * by C. Nguyen, S. Izadi, D. Lovel + */ + enum DEPTH_CLEANER_METHOD + { + DEPTH_CLEANER_NIL + }; + + DepthCleaner() + : + depth_(0), + window_size_(0), + method_(DEPTH_CLEANER_NIL), + depth_cleaner_impl_(0) + { + } + + /** Constructor + * @param depth the depth of the normals (only CV_32F or CV_64F for FALS and SRI, CV_16U for LINEMOD) + * @param window_size the window size to compute the normals: can only be 1,3,5 or 7 + * @param method one of the methods to use: RGBD_NORMALS_METHOD_SRI, RGBD_NORMALS_METHOD_FALS + */ + DepthCleaner(int depth, int window_size = 5, int method = DEPTH_CLEANER_NIL); + + ~DepthCleaner(); + + AlgorithmInfo* + info() const; + + /** Given a set of 3d points in a depth image, compute the normals at each point. + * @param points a rows x cols x 3 matrix of CV_32F/CV64F or a rows x cols x 1 CV_U16S + * @param depth a rows x cols matrix of the cleaned up depth + */ + void + operator()(InputArray points, OutputArray depth) const; + + /** Initializes some data that is cached for later computation + * If that function is not called, it will be called the first time normals are computed + */ + void + initialize() const; + + /** Return the current method in that normal computer + * @return + */ + int + method() const + { + return method_; + } + protected: + void + initialize_cleaner_impl() const; + + int depth_; + int window_size_; + int method_; + mutable void* depth_cleaner_impl_; + }; + + /** + * @param depth the depth image + * @param K + * @param in_points the list of xy coordinates + * @param points3d the resulting 3d points + */ + CV_EXPORTS + void + depthTo3dSparse(InputArray depth, InputArray in_K, InputArray in_points, OutputArray points3d); + + /** Converts a depth image to an organized set of 3d points. + * The coordinate system is x pointing left, y down and z away from the camera + * @param depth the depth image (if given as short int CV_U, it is assumed to be the depth in millimeters + * (as done with the Microsoft Kinect), otherwise, if given as CV_32F or CV_64F, it is assumed in meters) + * @param K The calibration matrix + * @param points3d the resulting 3d points. They are of depth the same as `depth` if it is CV_32F or CV_64F, and the + * depth of `K` if `depth` is of depth CV_U + * @param mask the mask of the points to consider (can be empty) + */ + CV_EXPORTS + void + depthTo3d(InputArray depth, InputArray K, OutputArray points3d, InputArray mask = noArray()); + + /** 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::quiet_NaN() + * Otherwise, the image is simply converted to floats + * @param in the depth image (if given as short int CV_U, it is assumed to be the depth in millimeters + * (as done with the Microsoft Kinect), it is assumed in meters) + * @param the desired output depth (floats or double) + * @param out The rescaled float depth image + */ + CV_EXPORTS + void + rescaleDepth(InputArray in, int depth, OutputArray out); + + /** Object that can compute planes in an image + */ + class CV_EXPORTS RgbdPlane: public Algorithm + { + public: + enum RGBD_PLANE_METHOD + { + RGBD_PLANE_METHOD_DEFAULT + }; + + RgbdPlane(RGBD_PLANE_METHOD method = RGBD_PLANE_METHOD_DEFAULT) + : + method_(method), + block_size_(40), + min_size_(block_size_*block_size_), + threshold_(0.01), + sensor_error_a_(0), + sensor_error_b_(0), + sensor_error_c_(0) + { + } + + /** Find The planes in a depth image + * @param points3d the 3d points organized like the depth image: rows x cols with 3 channels + * @param the normals for every point in the depth image + * @param mask An image where each pixel is labeled with the plane it belongs to + * and 255 if it does not belong to any plane + * @param the coefficients of the corresponding planes (a,b,c,d) such that ax+by+cz+d=0, norm(a,b,c)=1 + * and c < 0 (so that the normal points towards the camera) + */ + void + operator()(InputArray points3d, InputArray normals, OutputArray mask, + OutputArray plane_coefficients); + + /** Find The planes in a depth image but without doing a normal check, which is faster but less accurate + * @param points3d the 3d points organized like the depth image: rows x cols with 3 channels + * @param mask An image where each pixel is labeled with the plane it belongs to + * and 255 if it does not belong to any plane + * @param the coefficients of the corresponding planes (a,b,c,d) such that ax+by+cz+d=0 + */ + void + operator()(InputArray points3d, OutputArray mask, OutputArray plane_coefficients); + + AlgorithmInfo* + info() const; + private: + /** The method to use to compute the planes */ + int method_; + /** The size of the blocks to look at for a stable MSE */ + int block_size_; + /** The minimum size of a cluster to be considered a plane */ + int min_size_; + /** How far a point can be from a plane to belong to it (in meters) */ + double threshold_; + /** coefficient of the sensor error with respect to the. All 0 by default but you want a=0.0075 for a Kinect */ + double sensor_error_a_, sensor_error_b_, sensor_error_c_; + }; + + /** Object that contains a frame data. + */ + struct CV_EXPORTS RgbdFrame + { + RgbdFrame(); + RgbdFrame(const Mat& image, const Mat& depth, const Mat& mask=Mat(), const Mat& normals=Mat(), int ID=-1); + virtual ~RgbdFrame(); + + virtual void + release(); + + int ID; + Mat image; + Mat depth; + Mat mask; + Mat normals; + }; + + /** Object that contains a frame data that is possibly needed for the Odometry. + * It's used for the efficiency (to pass precomputed/cached data of the frame that participates + * in the Odometry processing several times). + */ + struct CV_EXPORTS OdometryFrame : public RgbdFrame + { + /** These constants are used to set a type of cache which has to be prepared depending on the frame role: + * srcFrame or dstFrame (see compute method of the Odometry class). For the srcFrame and dstFrame different cache data may be required, + * some part of a cache may be common for both frame roles. + * @param CACHE_SRC The cache data for the srcFrame will be prepared. + * @param CACHE_DST The cache data for the dstFrame will be prepared. + * @param CACHE_ALL The cache data for both srcFrame and dstFrame roles will be computed. + */ + enum + { + CACHE_SRC = 1, CACHE_DST = 2, CACHE_ALL = CACHE_SRC + CACHE_DST + }; + + OdometryFrame(); + OdometryFrame(const Mat& image, const Mat& depth, const Mat& mask=Mat(), const Mat& normals=Mat(), int ID=-1); + + virtual void + release(); + + void + releasePyramids(); + + std::vector pyramidImage; + std::vector pyramidDepth; + std::vector pyramidMask; + + std::vector pyramidCloud; + + std::vector pyramid_dI_dx; + std::vector pyramid_dI_dy; + std::vector pyramidTexturedMask; + + std::vector pyramidNormals; + std::vector pyramidNormalsMask; + }; + + /** Base class for computation of odometry. + */ + class CV_EXPORTS Odometry: public Algorithm + { + public: + + /** A class of transformation*/ + enum + { + ROTATION = 1, TRANSLATION = 2, RIGID_BODY_MOTION = 4 + }; + + static inline float + DEFAULT_MIN_DEPTH() + { + return 0.f; // in meters + } + static inline float + DEFAULT_MAX_DEPTH() + { + return 4.f; // in meters + } + static inline float + DEFAULT_MAX_DEPTH_DIFF() + { + return 0.07f; // in meters + } + static inline float + DEFAULT_MAX_POINTS_PART() + { + return 0.07f; // in [0, 1] + } + static inline float + DEFAULT_MAX_TRANSLATION() + { + return 0.15f; // in meters + } + static inline float + DEFAULT_MAX_ROTATION() + { + return 15; // in degrees + } + + /** 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. + * 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). + * @param srcImage Image data of the source frame (CV_8UC1) + * @param srcDepth Depth data of the source frame (CV_32FC1, in meters) + * @param srcMask Mask that sets which pixels have to be used from the source frame (CV_8UC1) + * @param dstImage Image data of the destination frame (CV_8UC1) + * @param dstDepth Depth data of the destination frame (CV_32FC1, in meters) + * @param dstMask Mask that sets which pixels have to be used from the destination frame (CV_8UC1) + * @param Rt Resulting transformation from the source frame to the destination one (rigid body motion): + dst_p = Rt * src_p, where dst_p is a homogeneous point in the destination frame and src_p is + homogeneous point in the source frame, + Rt is 4x4 matrix of CV_64FC1 type. + * @param initRt Initial transformation from the source frame to the destination one (optional) + */ + bool + compute(const Mat& srcImage, const Mat& srcDepth, const Mat& srcMask, const Mat& dstImage, const Mat& dstDepth, + const Mat& dstMask, Mat& Rt, const Mat& initRt = Mat()) const; + + /** One more method to compute a transformation from the source frame to the destination one. + * It is designed to save on computing the frame data (image pyramids, normals, etc.). + */ + bool + compute(Ptr& srcFrame, Ptr& dstFrame, Mat& Rt, const Mat& initRt = Mat()) const; + + /** Prepare a cache for the frame. The function checks the precomputed/passed data (throws the error if this data + * does not satisfy) and computes all remaining cache data needed for the frame. Returned size is a resolution + * of the prepared frame. + * @param odometry The odometry which will process the frame. + * @param cacheType The cache type: CACHE_SRC, CACHE_DST or CACHE_ALL. + */ + virtual Size + prepareFrameCache(Ptr& frame, int cacheType) const; + + protected: + virtual void + checkParams() const = 0; + + virtual bool + computeImpl(const Ptr& srcFrame, const Ptr& dstFrame, Mat& Rt, + const Mat& initRt) const = 0; + }; + + /** Odometry based on the paper "Real-Time Visual Odometry from Dense RGB-D Images", + * F. Steinbucker, J. Strum, D. Cremers, ICCV, 2011. + */ + class CV_EXPORTS RgbdOdometry: public Odometry + { + public: + RgbdOdometry(); + /** Constructor. + * @param cameraMatrix Camera matrix + * @param minDepth Pixels with depth less than minDepth will not be used (in meters) + * @param maxDepth Pixels with depth larger than maxDepth will not be used (in meters) + * @param maxDepthDiff Correspondences between pixels of two given frames will be filtered out + * if their depth difference is larger than maxDepthDiff (in meters) + * @param iterCounts Count of iterations on each pyramid level. + * @param minGradientMagnitudes For each pyramid level the pixels will be filtered out + * if they have gradient magnitude less than minGradientMagnitudes[level]. + */ + RgbdOdometry(const Mat& cameraMatrix, float minDepth = DEFAULT_MIN_DEPTH(), float maxDepth = DEFAULT_MAX_DEPTH(), + float maxDepthDiff = DEFAULT_MAX_DEPTH_DIFF(), const std::vector& iterCounts = std::vector(), + const std::vector& minGradientMagnitudes = std::vector(), float maxPointsPart = DEFAULT_MAX_POINTS_PART(), + int transformType = RIGID_BODY_MOTION); + + virtual Size + prepareFrameCache(Ptr& frame, int cacheType) const; + + AlgorithmInfo* + info() const; + + protected: + virtual void + checkParams() const; + + virtual bool + computeImpl(const Ptr& srcFrame, const Ptr& 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. + /*float*/ + double minDepth, maxDepth, maxDepthDiff; + /*vector*/ + Mat iterCounts; + /*vector*/ + Mat minGradientMagnitudes; + double maxPointsPart; + + Mat cameraMatrix; + int transformType; + + double maxTranslation, maxRotation; + }; + + /** Odometry based on the paper "KinectFusion: Real-Time Dense Surface Mapping and Tracking", + * Richard A. Newcombe, Andrew Fitzgibbon, at al, SIGGRAPH, 2011. + */ + class ICPOdometry: public Odometry + { + public: + ICPOdometry(); + /** Constructor. + * @param cameraMatrix Camera matrix + * @param minDepth Pixels with depth less than minDepth will not be used + * @param maxDepth Pixels with depth larger than maxDepth will not be used + * @param maxDepthDiff Correspondences between pixels of two given frames will be filtered out + * if their depth difference is larger than maxDepthDiff + * @param pointsPart The method uses a random pixels subset of size frameWidth x frameHeight x pointsPart + * @param iterCounts Count of iterations on each pyramid level. + */ + ICPOdometry(const Mat& cameraMatrix, float minDepth = DEFAULT_MIN_DEPTH(), float maxDepth = DEFAULT_MAX_DEPTH(), + float maxDepthDiff = DEFAULT_MAX_DEPTH_DIFF(), float maxPointsPart = DEFAULT_MAX_POINTS_PART(), + const std::vector& iterCounts = std::vector(), int transformType = RIGID_BODY_MOTION); + + virtual Size + prepareFrameCache(Ptr& frame, int cacheType) const; + + AlgorithmInfo* + info() const; + + protected: + virtual void + checkParams() const; + + virtual bool + computeImpl(const Ptr& srcFrame, const Ptr& 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. + /*float*/ + double minDepth, maxDepth, maxDepthDiff; + /*float*/ + double maxPointsPart; + /*vector*/ + Mat iterCounts; + + Mat cameraMatrix; + int transformType; + + double maxTranslation, maxRotation; + + mutable cv::Ptr normalsComputer; + }; + + /** Odometry that merges RgbdOdometry and ICPOdometry by minimize sum of their energy functions. + */ + + class RgbdICPOdometry: public Odometry + { + public: + RgbdICPOdometry(); + /** Constructor. + * @param cameraMatrix Camera matrix + * @param minDepth Pixels with depth less than minDepth will not be used + * @param maxDepth Pixels with depth larger than maxDepth will not be used + * @param maxDepthDiff Correspondences between pixels of two given frames will be filtered out + * if their depth difference is larger than maxDepthDiff + * @param pointsPart The method uses a random pixels subset of size frameWidth x frameHeight x pointsPart + * @param iterCounts Count of iterations on each pyramid level. + * @param minGradientMagnitudes For each pyramid level the pixels will be filtered out + * if they have gradient magnitude less than minGradientMagnitudes[level]. + */ + RgbdICPOdometry(const Mat& cameraMatrix, float minDepth = DEFAULT_MIN_DEPTH(), float maxDepth = DEFAULT_MAX_DEPTH(), + float maxDepthDiff = DEFAULT_MAX_DEPTH_DIFF(), float maxPointsPart = DEFAULT_MAX_POINTS_PART(), + const std::vector& iterCounts = std::vector(), + const std::vector& minGradientMagnitudes = std::vector(), + int transformType = RIGID_BODY_MOTION); + + virtual Size + prepareFrameCache(Ptr& frame, int cacheType) const; + + AlgorithmInfo* + info() const; + + protected: + virtual void + checkParams() const; + + virtual bool + computeImpl(const Ptr& srcFrame, const Ptr& 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. + /*float*/ + double minDepth, maxDepth, maxDepthDiff; + /*float*/ + double maxPointsPart; + /*vector*/ + Mat iterCounts; + /*vector*/ + Mat minGradientMagnitudes; + + Mat cameraMatrix; + int transformType; + + double maxTranslation, maxRotation; + + mutable cv::Ptr normalsComputer; + }; + + /** Warp the image: compute 3d points from the depth, transform them using given transformation, + * then project color point cloud to an image plane. + * This function can be used to visualize results of the Odometry algorithm. + * @param image The image (of CV_8UC1 or CV_8UC3 type) + * @param depth The depth (of type used in depthTo3d fuction) + * @param mask The mask of used pixels (of CV_8UC1), it can be empty + * @param Rt The transformation that will be applied to the 3d points computed from the depth + * @param cameraMatrix Camera matrix + * @param distCoeff Distortion coefficients + * @param warpedImage The warped image. + * @param warpedDepth The warped depth. + * @param warpedMask The warped mask. + */ + CV_EXPORTS + void + warpFrame(const Mat& image, const Mat& depth, const Mat& mask, const Mat& Rt, const Mat& cameraMatrix, + const Mat& distCoeff, Mat& warpedImage, Mat* warpedDepth = 0, Mat* warpedMask = 0); + +// TODO Depth interpolation +// Curvature +// Get rescaleDepth return dubles if asked for +} /* namespace cv */ + +#endif /* __cplusplus */ + +#endif + +/* End of file. */ diff --git a/modules/rgbd/samples/CMakeLists.txt b/modules/rgbd/samples/CMakeLists.txt new file mode 100644 index 000000000..1f7390679 --- /dev/null +++ b/modules/rgbd/samples/CMakeLists.txt @@ -0,0 +1,9 @@ +cmake_minimum_required(VERSION 2.8) +project(map_test) +find_package(OpenCV REQUIRED) + +set(SOURCES odometry_evaluation.cpp) + +include_directories(${OpenCV_INCLUDE_DIRS}) +add_executable(odometry_evaluation ${SOURCES} ${HEADERS}) +target_link_libraries(odometry_evaluation ${OpenCV_LIBS}) diff --git a/modules/rgbd/samples/odometry_evaluation.cpp b/modules/rgbd/samples/odometry_evaluation.cpp new file mode 100644 index 000000000..fdad37132 --- /dev/null +++ b/modules/rgbd/samples/odometry_evaluation.cpp @@ -0,0 +1,250 @@ +/* + * Software License Agreement (BSD License) + * + * Copyright (c) 2009, Willow Garage, Inc. + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions 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. + * * Neither the name of Willow Garage, Inc. nor the names of its + * contributors may 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 + * COPYRIGHT OWNER 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. + * + */ + +#include + +#include "opencv2/highgui/highgui.hpp" +#include "opencv2/contrib/contrib.hpp" +#include "opencv2/calib3d/calib3d.hpp" + +#include +#include +#include + +using namespace std; +using namespace cv; + +#define BILATERAL_FILTER 0// if 1 then bilateral filter will be used for the depth + +static +void writeResults( const string& filename, const vector& timestamps, const vector& Rt ) +{ + CV_Assert( timestamps.size() == Rt.size() ); + + ofstream file( filename.c_str() ); + if( !file.is_open() ) + return; + + cout.precision(4); + for( size_t i = 0; i < Rt.size(); i++ ) + { + const Mat& Rt_curr = Rt[i]; + if( Rt_curr.empty() ) + continue; + + CV_Assert( Rt_curr.type() == CV_64FC1 ); + + Mat R = Rt_curr(Rect(0,0,3,3)), rvec; + Rodrigues(R, rvec); + double alpha = norm( rvec ); + if(alpha > DBL_MIN) + rvec = rvec / alpha; + + double cos_alpha2 = std::cos(0.5 * alpha); + double sin_alpha2 = std::sin(0.5 * alpha); + + rvec *= sin_alpha2; + + CV_Assert( rvec.type() == CV_64FC1 ); + // timestamp tx ty tz qx qy qz qw + file << timestamps[i] << " " << fixed + << Rt_curr.at(0,3) << " " << Rt_curr.at(1,3) << " " << Rt_curr.at(2,3) << " " + << rvec.at(0) << " " << rvec.at(1) << " " << rvec.at(2) << " " << cos_alpha2 << endl; + + } + file.close(); +} + +static +void setCameraMatrixFreiburg1(float& fx, float& fy, float& cx, float& cy) +{ + fx = 517.3f; fy = 516.5f; cx = 318.6f; cy = 255.3f; +} + +static +void setCameraMatrixFreiburg2(float& fx, float& fy, float& cx, float& cy) +{ + fx = 520.9f; fy = 521.0f; cx = 325.1f; cy = 249.7f; +} + +/* + * This sample helps to evaluate odometry on TUM datasets and benchmark http://vision.in.tum.de/data/datasets/rgbd-dataset. + * At this link you can find instructions for evaluation. The sample runs some opencv odometry and saves a camera trajectory + * to file of format that the benchmark requires. Saved file can be used for online evaluation. + */ +int main(int argc, char** argv) +{ + if(argc != 4) + { + cout << "Format: file_with_rgb_depth_pairs trajectory_file odometry_name [Rgbd or ICP or RgbdICP]" << endl; + return -1; + } + + vector timestamps; + vector Rts; + + const string filename = argv[1]; + ifstream file( filename.c_str() ); + if( !file.is_open() ) + return -1; + + char dlmrt = '/'; + size_t pos = filename.rfind(dlmrt); + string dirname = pos == string::npos ? "" : filename.substr(0, pos) + dlmrt; + + const int timestampLength = 17; + const int rgbPathLehgth = 17+8; + const int depthPathLehgth = 17+10; + + float fx = 525.0f, // default + fy = 525.0f, + cx = 319.5f, + cy = 239.5f; + if(filename.find("freiburg1") != string::npos) + setCameraMatrixFreiburg1(fx, fy, cx, cy); + if(filename.find("freiburg2") != string::npos) + setCameraMatrixFreiburg2(fx, fy, cx, cy); + Mat cameraMatrix = Mat::eye(3,3,CV_32FC1); + { + cameraMatrix.at(0,0) = fx; + cameraMatrix.at(1,1) = fy; + cameraMatrix.at(0,2) = cx; + cameraMatrix.at(1,2) = cy; + } + + Ptr frame_prev = new OdometryFrame(), + frame_curr = new OdometryFrame(); + Ptr odometry = Algorithm::create("RGBD." + string(argv[3]) + "Odometry"); + if(odometry.empty()) + { + cout << "Can not create Odometry algorithm. Check the passed odometry name." << endl; + return -1; + } + odometry->set("cameraMatrix", cameraMatrix); + + TickMeter gtm; + int count = 0; + for(int i = 0; !file.eof(); i++) + { + string str; + std::getline(file, str); + if(str.empty()) break; + if(str.at(0) == '#') continue; /* comment */ + + Mat image, depth; + // 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; +#endif + { + string rgbFilename = str.substr(timestampLength + 1, rgbPathLehgth ); + string timestap = str.substr(0, timestampLength); + string depthFilename = str.substr(2*timestampLength + rgbPathLehgth + 3, depthPathLehgth ); + + image = imread(dirname + rgbFilename); + depth = imread(dirname + depthFilename, -1); + + CV_Assert(!image.empty()); + CV_Assert(!depth.empty()); + CV_Assert(depth.type() == CV_16UC1); + + cout << i << " " << rgbFilename << " " << depthFilename << endl; + + // scale depth + Mat depth_flt; + depth.convertTo(depth_flt, CV_32FC1, 1.f/5000.f); +#if not BILATERAL_FILTER + depth_flt.setTo(std::numeric_limits::quiet_NaN(), depth == 0); + depth = depth_flt; +#else + tm_bilateral_filter.start(); + depth = Mat(depth_flt.size(), CV_32FC1, Scalar(0)); + const double depth_sigma = 0.03; + const double space_sigma = 4.5; // in pixels + Mat invalidDepthMask = depth_flt == 0.f; + depth_flt.setTo(-5*depth_sigma, invalidDepthMask); + bilateralFilter(depth_flt, depth, -1, depth_sigma, space_sigma); + depth.setTo(std::numeric_limits::quiet_NaN(), invalidDepthMask); + tm_bilateral_filter.stop(); + cout << "Time filter " << tm_bilateral_filter.getTimeSec() << endl; +#endif + timestamps.push_back( timestap ); + } + + { + Mat gray; + cvtColor(image, gray, CV_BGR2GRAY); + frame_curr->image = gray; + frame_curr->depth = depth; + + Mat Rt; + if(!Rts.empty()) + { + TickMeter tm; + tm.start(); + gtm.start(); + bool res = odometry->compute(frame_curr, frame_prev, Rt); + gtm.stop(); + tm.stop(); + count++; + cout << "Time " << tm.getTimeSec() << endl; +#if BILATERAL_FILTER + cout << "Time ratio " << tm_bilateral_filter.getTimeSec() / tm.getTimeSec() << endl; +#endif + if(!res) + Rt = Mat::eye(4,4,CV_64FC1); + } + + if( Rts.empty() ) + Rts.push_back(Mat::eye(4,4,CV_64FC1)); + else + { + Mat& prevRt = *Rts.rbegin(); + cout << "Rt " << Rt << endl; + Rts.push_back( prevRt * Rt ); + } + + if(!frame_prev.empty()) + frame_prev->release(); + std::swap(frame_prev, frame_curr); + } + } + + std::cout << "Average time " << gtm.getTimeSec()/count << std::endl; + writeResults(argv[2], timestamps, Rts); + + return 0; +} diff --git a/modules/rgbd/src/depth_cleaner.cpp b/modules/rgbd/src/depth_cleaner.cpp new file mode 100644 index 000000000..d99da3c9e --- /dev/null +++ b/modules/rgbd/src/depth_cleaner.cpp @@ -0,0 +1,326 @@ +/* + * Software License Agreement (BSD License) + * + * Copyright (c) 2012, Willow Garage, Inc. + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions 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. + * * Neither the name of Willow Garage, Inc. nor the names of its + * contributors may 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 + * COPYRIGHT OWNER 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. + * + */ + +#include +#include +#include +#include + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + +namespace +{ + class DepthCleanerImpl + { + public: + DepthCleanerImpl(int window_size, int depth, cv::DepthCleaner::DEPTH_CLEANER_METHOD method) + : + depth_(depth), + window_size_(window_size), + method_(method) + { + } + + virtual + ~DepthCleanerImpl() + { + } + + virtual void + cache()=0; + + bool + validate(int depth, int window_size, int method) const + { + return (window_size == window_size_) && (depth == depth_) && (method == method_); + } + protected: + int depth_; + int window_size_; + cv::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 + */ + template + class NIL: public DepthCleanerImpl + { + public: + typedef cv::Vec Vec3T; + typedef cv::Matx Mat33T; + + NIL(int window_size, int depth, cv::DepthCleaner::DEPTH_CLEANER_METHOD method) + : + DepthCleanerImpl(window_size, depth, method) + { + } + + /** Compute cached data + */ + virtual void + cache() + { + } + + /** Compute the normals + * @param r + * @return + */ + void + compute(const cv::Mat& depth_in, cv::Mat& depth_out) const + { + switch (depth_in.depth()) + { + case CV_16U: + { + const cv::Mat_ &depth(depth_in); + cv::Mat depth_out_tmp; + computeImpl(depth, depth_out_tmp, 0.001); + depth_out_tmp.convertTo(depth_out, CV_16U); + break; + } + case CV_32F: + { + const cv::Mat_ &depth(depth_in); + computeImpl(depth, depth_out, 1); + break; + } + case CV_64F: + { + const cv::Mat_ &depth(depth_in); + computeImpl(depth, depth_out, 1); + break; + } + } + } + + private: + /** Compute the normals + * @param r + * @return + */ + template + void + computeImpl(const cv::Mat_ &depth_in, cv::Mat & depth_out, ContainerDepth scale) const + { + const ContainerDepth theta_mean = 30. * CV_PI / 180; + int rows = depth_in.rows; + int cols = depth_in.cols; + + // Precompute some data + const ContainerDepth sigma_L = 0.8 + 0.035 * theta_mean / (CV_PI / 2 - theta_mean); + cv::Mat_ sigma_z(rows, cols); + for (int y = 0; y < rows; ++y) + for (int x = 0; x < cols; ++x) + sigma_z(y, x) = 0.0012 + 0.0019 * (depth_in(y, x) * scale - 0.4) * (depth_in(y, x) * scale - 0.4); + + ContainerDepth difference_threshold = 10; + cv::Mat_ Dw_sum = cv::Mat_::zeros(rows, cols), w_sum = + cv::Mat_::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) + for (int x = 1; x < cols - 1; ++x) + { + for (int j = 0; j <= 1; ++j) + for (int i = -1; i <= 1; ++i) + { + if ((j == 0) && (i == -1)) + continue; + ContainerDepth delta_u = sqrt( + ContainerDepth(j) * ContainerDepth(j) + ContainerDepth(i) * ContainerDepth(i)); + ContainerDepth delta_z; + if (depth_in(y, x) > depth_in(y + j, x + i)) + delta_z = depth_in(y, x) - depth_in(y + j, x + i); + else + delta_z = depth_in(y + j, x + i) - depth_in(y, x); + if (delta_z < difference_threshold) + { + delta_z *= scale; + ContainerDepth w = exp( + -delta_u * delta_u / 2 / sigma_L / sigma_L - delta_z * delta_z / 2 / sigma_z(y, x) / sigma_z(y, x)); + w_sum(y, x) += w; + Dw_sum(y, x) += depth_in(y + j, x + i) * w; + if ((j != 0) || (i != 0)) + { + w = exp( + -delta_u * delta_u / 2 / sigma_L / sigma_L - delta_z * delta_z / 2 / sigma_z(y + j, x + i) + / sigma_z(y + j, x + i)); + w_sum(y + j, x + i) += w; + Dw_sum(y + j, x + i) += depth_in(y, x) * w; + } + } + } + } + } + cv::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) + : + depth_(depth), + window_size_(window_size), + method_(method_in), + depth_cleaner_impl_(0) + { + CV_Assert(depth == CV_16U || depth == CV_32F || depth == CV_64F); + } + + /** Destructor + */ + DepthCleaner::~DepthCleaner() + { + if (depth_cleaner_impl_ == 0) + return; + switch (method_) + { + case DEPTH_CLEANER_NIL: + { + switch (depth_) + { + case CV_16U: + delete reinterpret_cast *>(depth_cleaner_impl_); + break; + case CV_32F: + delete reinterpret_cast *>(depth_cleaner_impl_); + break; + case CV_64F: + delete reinterpret_cast *>(depth_cleaner_impl_); + break; + } + break; + } + } + } + + void + DepthCleaner::initialize_cleaner_impl() const + { + CV_Assert(depth_ == CV_16U || depth_ == CV_32F || depth_ == CV_64F); + CV_Assert(window_size_ == 1 || window_size_ == 3 || window_size_ == 5 || window_size_ == 7); + CV_Assert( method_ == DEPTH_CLEANER_NIL); + switch (method_) + { + case (DEPTH_CLEANER_NIL): + { + switch (depth_) + { + case CV_16U: + depth_cleaner_impl_ = new NIL(window_size_, depth_, DEPTH_CLEANER_NIL); + break; + case CV_32F: + depth_cleaner_impl_ = new NIL(window_size_, depth_, DEPTH_CLEANER_NIL); + break; + case CV_64F: + depth_cleaner_impl_ = new NIL(window_size_, depth_, DEPTH_CLEANER_NIL); + break; + } + break; + } + } + + reinterpret_cast(depth_cleaner_impl_)->cache(); + } + + /** Initializes some data that is cached for later computation + * If that function is not called, it will be called the first time normals are computed + */ + void + DepthCleaner::initialize() const + { + if (depth_cleaner_impl_ == 0) + initialize_cleaner_impl(); + else if (!reinterpret_cast(depth_cleaner_impl_)->validate(depth_, window_size_, method_)) + initialize_cleaner_impl(); + } + + /** Given a set of 3d points in a depth image, compute the normals at each point + * using the SRI method described in + * ``Fast and Accurate Computation of Surface Normals from Range Images`` + * by H. Badino, D. Huber, Y. Park and T. Kanade + * @param depth depth a float depth image. Or it can be rows x cols x 3 is they are 3d points + * @param window_size the window size on which to compute the derivatives + * @return normals a rows x cols x 3 matrix + */ + void + DepthCleaner::operator()(InputArray depth_in_array, OutputArray depth_out_array) const + { + cv::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(); + + // Initialize the pimpl + initialize(); + + // Clean the depth + switch (method_) + { + case (DEPTH_CLEANER_NIL): + { + switch (depth_) + { + case CV_16U: + reinterpret_cast *>(depth_cleaner_impl_)->compute(depth_in, depth_out); + break; + case CV_32F: + reinterpret_cast *>(depth_cleaner_impl_)->compute(depth_in, depth_out); + break; + case CV_64F: + reinterpret_cast *>(depth_cleaner_impl_)->compute(depth_in, depth_out); + break; + } + break; + } + } + } +} diff --git a/modules/rgbd/src/depth_to_3d.cpp b/modules/rgbd/src/depth_to_3d.cpp new file mode 100644 index 000000000..d3411f293 --- /dev/null +++ b/modules/rgbd/src/depth_to_3d.cpp @@ -0,0 +1,265 @@ +/* + * Software License Agreement (BSD License) + * + * Copyright (c) 2009, Willow Garage, Inc. + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions 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. + * * Neither the name of Willow Garage, Inc. nor the names of its + * contributors may 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 + * COPYRIGHT OWNER 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. + * + */ + +#include +#include + +#include "depth_to_3d.h" +#include "utils.h" + +namespace +{ + /** + * @param K + * @param depth the depth image + * @param mask the mask of the points to consider (can be empty) + * @param points3d the resulting 3d points, a 3-channel matrix + */ + 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) + { + CV_Assert((u_mat.size() == z_mat.size()) && (v_mat.size() == z_mat.size())); + if (u_mat.empty()) + return; + CV_Assert((u_mat.type() == z_mat.type()) && (v_mat.type() == z_mat.type())); + + //grab camera params + cv::Mat_ K; + + if (in_K.depth() == CV_32F) + K = in_K; + else + in_K.convertTo(K, CV_32F); + + float fx = K(0, 0); + float fy = K(1, 1); + float s = K(0, 1); + float cx = K(0, 2); + float cy = K(1, 2); + + std::vector coordinates(3); + + coordinates[0] = (u_mat - cx) / fx; + + if (s != 0) + coordinates[0] = coordinates[0] + (-(s / fy) * v_mat + cy * s / fy) / fx; + + coordinates[0] = coordinates[0].mul(z_mat); + coordinates[1] = (v_mat - cy).mul(z_mat) * (1. / fy); + coordinates[2] = z_mat; + cv::merge(coordinates, points3d); + } + + /** + * @param K + * @param depth the depth image + * @param mask the mask of the points to consider (can be empty) + * @param points3d the resulting 3d points + */ + void + depthTo3dMask(const cv::Mat& depth, const cv::Mat& K, const cv::Mat& mask, cv::Mat& points3d) + { + // Create 3D points in one go. + cv::Mat_ u_mat, v_mat, z_mat; + + cv::Mat_ uchar_mask = mask; + + if (mask.depth() != (CV_8U)) + mask.convertTo(uchar_mask, CV_8U); + + // Figure out the interesting indices + size_t n_points; + + if (depth.depth() == CV_16U) + n_points = convertDepthToFloat(depth, mask, 1.0 / 1000.0f, u_mat, v_mat, z_mat); + else if (depth.depth() == CV_16S) + n_points = convertDepthToFloat(depth, mask, 1.0 / 1000.0f, u_mat, v_mat, z_mat); + else + { + CV_Assert(depth.type() == CV_32F); + n_points = convertDepthToFloat(depth, mask, 1.0f, u_mat, v_mat, z_mat); + } + + if (n_points == 0) + return; + + u_mat.resize(n_points); + v_mat.resize(n_points); + z_mat.resize(n_points); + + depthTo3d_from_uvz(K, u_mat, v_mat, z_mat, points3d); + points3d = points3d.reshape(3, 1); + } + + /** + * @param K + * @param depth the depth image + * @param points3d the resulting 3d points + */ + template + void + depthTo3dNoMask(const cv::Mat& in_depth, const cv::Mat_& K, cv::Mat& points3d) + { + const T inv_fx = T(1) / K(0, 0); + const T inv_fy = T(1) / K(1, 1); + const T ox = K(0, 2); + const T oy = K(1, 2); + + // Build z + cv::Mat_ z_mat; + if (z_mat.depth() == in_depth.depth()) + z_mat = in_depth; + else + rescaleDepthTemplated(in_depth, z_mat); + + // Pre-compute some constants + cv::Mat_ x_cache(1, in_depth.cols), y_cache(in_depth.rows, 1); + T* x_cache_ptr = x_cache[0], *y_cache_ptr = y_cache[0]; + for (int x = 0; x < in_depth.cols; ++x, ++x_cache_ptr) + *x_cache_ptr = (x - ox) * inv_fx; + for (int y = 0; y < in_depth.rows; ++y, ++y_cache_ptr) + *y_cache_ptr = (y - oy) * inv_fy; + + y_cache_ptr = y_cache[0]; + for (int y = 0; y < in_depth.rows; ++y, ++y_cache_ptr) + { + cv::Vec* point = points3d.ptr >(y); + const T* x_cache_ptr_end = x_cache[0] + in_depth.cols; + const T* depth = z_mat[y]; + for (x_cache_ptr = x_cache[0]; x_cache_ptr != x_cache_ptr_end; ++x_cache_ptr, ++point, ++depth) + { + T z = *depth; + (*point)[0] = (*x_cache_ptr) * z; + (*point)[1] = (*y_cache_ptr) * z; + (*point)[2] = z; + } + } + } +} + +/////////////////////////////////////////////////////////////////////////////// + +namespace cv +{ + + /** + * @param K + * @param depth the depth image + * @param u_mat the list of x coordinates + * @param v_mat the list of matching y coordinates + * @param points3d the resulting 3d points + */ + void + depthTo3dSparse(InputArray depth_in, InputArray K_in, InputArray points_in, OutputArray points3d_out) + { + // Make sure we use foat types + cv::Mat points = points_in.getMat(); + cv::Mat depth = depth_in.getMat(); + + cv::Mat points_float; + if (points.depth() != CV_32F) + points.convertTo(points_float, CV_32FC2); + else + points_float = points; + + // Fill the depth matrix + cv::Mat_ z_mat; + + if (depth.depth() == CV_16U) + convertDepthToFloat(depth, 1.0 / 1000.0f, points_float, z_mat); + else if (depth.depth() == CV_16U) + convertDepthToFloat(depth, 1.0 / 1000.0f, points_float, z_mat); + else + { + CV_Assert(depth.type() == CV_32F); + convertDepthToFloat(depth, 1.0f, points_float, z_mat); + } + + std::vector channels(2); + cv::split(points_float, channels); + + points3d_out.create(channels[0].rows, channels[0].cols, CV_32FC3); + cv::Mat points3d = points3d_out.getMat(); + depthTo3d_from_uvz(K_in.getMat(), channels[0], channels[1], z_mat, points3d); + } + + /** + * @param depth the depth image (if given as short int CV_U, it is assumed to be the depth in millimeters + * (as done with the Microsoft Kinect), otherwise, if given as CV_32F, it is assumed in meters) + * @param K The calibration matrix + * @param points3d the resulting 3d points. They are of depth the same as `depth` if it is CV_32F or CV_64F, and the + * depth of `K` if `depth` is of depth CV_U + * @param mask the mask of the points to consider (can be empty) + */ + void + depthTo3d(InputArray depth_in, InputArray K_in, OutputArray points3d_out, InputArray mask_in) + { + cv::Mat depth = depth_in.getMat(); + cv::Mat K = K_in.getMat(); + cv::Mat mask = mask_in.getMat(); + CV_Assert(K.cols == 3 && K.rows == 3 && (K.depth() == CV_64F || K.depth()==CV_32F)); + CV_Assert( + depth.type() == CV_64FC1 || depth.type() == CV_32FC1 || depth.type() == CV_16UC1 || depth.type() == CV_16SC1); + CV_Assert(mask.empty() || mask.channels() == 1); + + // TODO figure out what to do when types are different: convert or reject ? + cv::Mat K_new; + if ((depth.depth() == CV_32F || depth.depth() == CV_64F) && depth.depth() != K.depth()) + { + K.convertTo(K_new, depth.depth()); + } + else + K_new = K; + + // Create 3D points in one go. + if (!mask.empty()) + { + cv::Mat points3d; + depthTo3dMask(depth, K_new, mask, points3d); + points3d_out.create(points3d.size(), CV_MAKETYPE(K_new.depth(), 3)); + points3d.copyTo(points3d_out.getMat()); + } + else + { + points3d_out.create(depth.size(), CV_MAKETYPE(K_new.depth(), 3)); + cv::Mat points3d = points3d_out.getMat(); + if (K_new.depth() == CV_64F) + depthTo3dNoMask(depth, K_new, points3d); + else + depthTo3dNoMask(depth, K_new, points3d); + } + } +} diff --git a/modules/rgbd/src/depth_to_3d.h b/modules/rgbd/src/depth_to_3d.h new file mode 100644 index 000000000..dcbd09d9f --- /dev/null +++ b/modules/rgbd/src/depth_to_3d.h @@ -0,0 +1,121 @@ +/* + * Software License Agreement (BSD License) + * + * Copyright (c) 2009, Willow Garage, Inc. + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions 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. + * * Neither the name of Willow Garage, Inc. nor the names of its + * contributors may 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 + * COPYRIGHT OWNER 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. + * + */ + +#ifndef __OPENCV_RGBD_DEPTH_TO_3D_HPP__ +#define __OPENCV_RGBD_DEPTH_TO_3D_HPP__ + +#ifdef __cplusplus + +#include +#include + +/** + * @param depth the depth image, containing depth with the value T + * @param the mask, containing CV_8UC1 + */ +template +size_t +convertDepthToFloat(const cv::Mat& depth, const cv::Mat& mask, float scale, cv::Mat_ &u_mat, cv::Mat_ &v_mat, cv::Mat_ &z_mat) +{ + CV_Assert (depth.size == mask.size); + + cv::Size depth_size = depth.size(); + + cv::Mat_ uchar_mask = mask; + + if (mask.depth() != CV_8U) + mask.convertTo(uchar_mask, CV_8U); + + u_mat = cv::Mat_(depth_size.area(), 1); + v_mat = cv::Mat_(depth_size.area(), 1); + z_mat = cv::Mat_(depth_size.area(), 1); + + // Raw data from the Kinect has int + size_t n_points = 0; + + for (int v = 0; v < depth_size.height; v++) + { + uchar* r = uchar_mask.ptr(v, 0); + + for (int u = 0; u < depth_size.width; u++, ++r) + if (*r) + { + u_mat(n_points, 0) = u; + v_mat(n_points, 0) = v; + T depth_i = depth.at(v, u); + + if (cvIsNaN(depth_i) || (depth_i == std::numeric_limits::min()) || (depth_i == std::numeric_limits::max())) + z_mat(n_points, 0) = std::numeric_limits::quiet_NaN(); + else + z_mat(n_points, 0) = depth_i * scale; + + ++n_points; + } + } + + return n_points; +} + +/** + * @param depth the depth image, containing depth with the value T + * @param the mask, containing CV_8UC1 + */ +template +void +convertDepthToFloat(const cv::Mat& depth, float scale, const cv::Mat &uv_mat, cv::Mat_ &z_mat) +{ + z_mat = cv::Mat_(uv_mat.size()); + + // Raw data from the Kinect has int + float* z_mat_iter = reinterpret_cast(z_mat.data); + + for (cv::Mat_::const_iterator uv_iter = uv_mat.begin(), uv_end = uv_mat.end(); + uv_iter != uv_end; ++uv_iter, ++z_mat_iter) + { + T depth_i = depth.at < T > ((*uv_iter)[1], (*uv_iter)[0]); + + if (cvIsNaN(depth_i) || (depth_i == std::numeric_limits < T > ::min()) + || (depth_i == std::numeric_limits < T > ::max())) + *z_mat_iter = std::numeric_limits::quiet_NaN(); + else + *z_mat_iter = depth_i * scale; + } +} + +#endif /* __cplusplus */ + +#endif + +/* End of file. */ diff --git a/modules/rgbd/src/normal.cpp b/modules/rgbd/src/normal.cpp new file mode 100644 index 000000000..c0000328f --- /dev/null +++ b/modules/rgbd/src/normal.cpp @@ -0,0 +1,888 @@ +/* + * Software License Agreement (BSD License) + * + * Copyright (c) 2012, Willow Garage, Inc. + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions 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. + * * Neither the name of Willow Garage, Inc. nor the names of its + * contributors may 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 + * COPYRIGHT OWNER 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. + * + */ + +#include +#include +#include +#include + +namespace +{ + /** Just compute the norm of a vector + * @param vec a vector of size 3 and any type T + * @return + */ + template + T + inline + norm_vec(const cv::Vec &vec) + { + return std::sqrt(vec[0] * vec[0] + vec[1] * vec[1] + vec[2] * vec[2]); + } + + /** Given 3d points, compute their distance to the origin + * @param points + * @return + */ + template + cv::Mat_ + computeRadius(const cv::Mat &points) + { + typedef cv::Vec PointT; + + // Compute the + cv::Size size(points.cols, points.rows); + cv::Mat_ r(size); + if (points.isContinuous()) + size = cv::Size(points.cols * points.rows, 1); + for (int y = 0; y < size.height; ++y) + { + const PointT* point = points.ptr < PointT > (y), *point_end = points.ptr < PointT > (y) + size.width; + T * row = r[y]; + for (; point != point_end; ++point, ++row) + *row = norm_vec(*point); + } + + return r; + } + + // Compute theta and phi according to equation 3 of + // ``Fast and Accurate Computation of Surface Normals from Range Images`` + // by H. Badino, D. Huber, Y. Park and T. Kanade + template + void + computeThetaPhi(int rows, int cols, const cv::Matx& K, cv::Mat &cos_theta, cv::Mat &sin_theta, + cv::Mat &cos_phi, cv::Mat &sin_phi) + { + // Create some bogus coordinates + cv::Mat depth_image = K(0, 0) * cv::Mat_ < T > ::ones(rows, cols); + cv::Mat points3d; + depthTo3d(depth_image, cv::Mat(K), points3d); + + typedef cv::Vec Vec3T; + + cos_theta = cv::Mat_ < T > (rows, cols); + sin_theta = cv::Mat_ < T > (rows, cols); + cos_phi = cv::Mat_ < T > (rows, cols); + sin_phi = cv::Mat_ < T > (rows, cols); + cv::Mat r = computeRadius(points3d); + for (int y = 0; y < rows; ++y) + { + T *row_cos_theta = cos_theta.ptr < T > (y), *row_sin_theta = sin_theta.ptr < T > (y); + T *row_cos_phi = cos_phi.ptr < T > (y), *row_sin_phi = sin_phi.ptr < T > (y); + const Vec3T * row_points = points3d.ptr < Vec3T > (y), *row_points_end = points3d.ptr < Vec3T + > (y) + points3d.cols; + const T * row_r = r.ptr < T > (y); + for (; row_points < row_points_end; + ++row_cos_theta, ++row_sin_theta, ++row_cos_phi, ++row_sin_phi, ++row_points, ++row_r) + { + // In the paper, z goes away from the camera, y goes down, x goes right + // OpenCV has the same conventions + // Theta goes from z to x (and actually goes from -pi/2 to pi/2, phi goes from z to y + float theta = std::atan2(row_points->val[0], row_points->val[2]); + *row_cos_theta = std::cos(theta); + *row_sin_theta = std::sin(theta); + float phi = std::asin(row_points->val[1] / (*row_r)); + *row_cos_phi = std::cos(phi); + *row_sin_phi = std::sin(phi); + } + } + } + + /** Modify normals to make sure they point towards the camera + * @param normals + */ + template + inline + void + signNormal(const cv::Vec & normal_in, cv::Vec & normal_out) + { + cv::Vec res; + if (normal_in[2] > 0) + res = -normal_in / norm_vec(normal_in); + else + res = normal_in / norm_vec(normal_in); + normal_out[0] = res[0]; + normal_out[1] = res[1]; + normal_out[2] = res[2]; + } + /** Modify normals to make sure they point towards the camera + * @param normals + */ + template + inline + void + signNormal(T a, T b, T c, cv::Vec & normal) + { + T norm = 1 / std::sqrt(a * a + b * b + c * c); + if (c > 0) + { + normal[0] = -a * norm; + normal[1] = -b * norm; + normal[2] = -c * norm; + } + else + { + normal[0] = a * norm; + normal[1] = b * norm; + normal[2] = c * norm; + } + } +} +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + +namespace +{ + class RgbdNormalsImpl + { + public: + RgbdNormalsImpl(int rows, int cols, int window_size, int depth, const cv::Mat &K, + cv::RgbdNormals::RGBD_NORMALS_METHOD method) + : + rows_(rows), + cols_(cols), + depth_(depth), + window_size_(window_size), + method_(method) + { + K.convertTo(K_, depth); + K.copyTo(K_ori_); + } + + virtual + ~RgbdNormalsImpl() + { + } + + virtual void + cache()=0; + + bool + validate(int rows, int cols, int depth, const cv::Mat &K_ori, int window_size, int method) const + { + if ((K_ori.cols != K_ori_.cols) || (K_ori.rows != K_ori_.rows) || (K_ori.type() != K_ori_.type())) + return false; + bool K_test = !(cv::countNonZero(K_ori != K_ori_)); + return (rows == rows_) && (cols = cols_) && (window_size == window_size_) && (depth == depth_) && (K_test) + && (method == method_); + } + protected: + int rows_, cols_, depth_; + cv::Mat K_, K_ori_; + int window_size_; + cv::RgbdNormals::RGBD_NORMALS_METHOD method_; + }; + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + + /** Given a set of 3d points in a depth image, compute the normals at each point + * using the FALS method described in + * ``Fast and Accurate Computation of Surface Normals from Range Images`` + * by H. Badino, D. Huber, Y. Park and T. Kanade + */ + template + class FALS: public RgbdNormalsImpl + { + public: + typedef cv::Matx Mat33T; + typedef cv::Vec Vec9T; + typedef cv::Vec Vec3T; + + FALS(int rows, int cols, int window_size, int depth, const cv::Mat &K, cv::RgbdNormals::RGBD_NORMALS_METHOD method) + : + RgbdNormalsImpl(rows, cols, window_size, depth, K, method) + { + } + ~FALS() + { + } + + /** Compute cached data + */ + virtual void + cache() + { + // Compute theta and phi according to equation 3 + cv::Mat cos_theta, sin_theta, cos_phi, sin_phi; + computeThetaPhi(rows_, cols_, K_, cos_theta, sin_theta, cos_phi, sin_phi); + + // Compute all the v_i for every points + std::vector channels(3); + channels[0] = sin_theta.mul(cos_phi); + channels[1] = sin_phi; + channels[2] = cos_theta.mul(cos_phi); + cv::merge(channels, V_); + + // Compute M + cv::Mat_ M(rows_, cols_); + Mat33T VVt; + const Vec3T * vec = V_[0]; + Vec9T * M_ptr = M[0], *M_ptr_end = M_ptr + rows_ * cols_; + for (; M_ptr != M_ptr_end; ++vec, ++M_ptr) + { + VVt = (*vec) * vec->t(); + *M_ptr = Vec9T(VVt.val); + } + + cv::boxFilter(M, M, M.depth(), cv::Size(window_size_, window_size_), cv::Point(-1, -1), false); + + // Compute M's inverse + Mat33T M_inv; + M_inv_.create(rows_, cols_); + Vec9T * M_inv_ptr = M_inv_[0]; + for (M_ptr = &M(0); M_ptr != M_ptr_end; ++M_inv_ptr, ++M_ptr) + { + // We have a semi-definite matrix + cv::invert(Mat33T(M_ptr->val), M_inv, cv::DECOMP_CHOLESKY); + *M_inv_ptr = Vec9T(M_inv.val); + } + } + + /** Compute the normals + * @param r + * @return + */ + virtual void + compute(const cv::Mat&, const cv::Mat &r, cv::Mat & normals) const + { + // Compute B + cv::Mat_ B(rows_, cols_); + + const T* row_r = r.ptr < T > (0), *row_r_end = row_r + rows_ * cols_; + const Vec3T *row_V = V_[0]; + Vec3T *row_B = B[0]; + for (; row_r != row_r_end; ++row_r, ++row_B, ++row_V) + { + if (cvIsNaN(*row_r)) + *row_B = Vec3T(); + else + *row_B = (*row_V) / (*row_r); + } + + // Apply a box filter to B + cv::boxFilter(B, B, B.depth(), cv::Size(window_size_, window_size_), cv::Point(-1, -1), false); + + // compute the Minv*B products + row_r = r.ptr < T > (0); + const Vec3T * B_vec = B[0]; + const Mat33T * M_inv = reinterpret_cast(M_inv_.ptr(0)); + Vec3T *normal = normals.ptr(0); + for (; row_r != row_r_end; ++row_r, ++B_vec, ++normal, ++M_inv) + if (cvIsNaN(*row_r)) + { + (*normal)[0] = *row_r; + (*normal)[1] = *row_r; + (*normal)[2] = *row_r; + } + else + signNormal((*M_inv) * (*B_vec), *normal); + } + + private: + cv::Mat_ V_; + cv::Mat_ M_inv_; + }; +} + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + +/** Function that multiplies K_inv by a vector. It is just meant to speed up the product as we know + * that K_inv is upper triangular and K_inv(2,2)=1 + * @param K_inv + * @param a + * @param b + * @param c + * @param res + */ +template +void +multiply_by_K_inv(const cv::Matx & K_inv, U a, U b, U c, cv::Vec &res) +{ + res[0] = K_inv(0, 0) * a + K_inv(0, 1) * b + K_inv(0, 2) * c; + res[1] = K_inv(1, 1) * b + K_inv(1, 2) * c; + res[2] = c; +} + +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 + */ + template + class LINEMOD: public RgbdNormalsImpl + { + public: + typedef cv::Vec Vec3T; + typedef cv::Matx Mat33T; + + LINEMOD(int rows, int cols, int window_size, int depth, const cv::Mat &K, + cv::RgbdNormals::RGBD_NORMALS_METHOD method) + : + RgbdNormalsImpl(rows, cols, window_size, depth, K, method) + { + } + + /** Compute cached data + */ + virtual void + cache() + { + } + + /** Compute the normals + * @param r + * @param normals the output normals + */ + void + compute(const cv::Mat& depth_in, cv::Mat & normals) const + { + switch (depth_in.depth()) + { + case CV_16U: + { + const cv::Mat_ &depth(depth_in); + computeImpl(depth, normals); + break; + } + case CV_32F: + { + const cv::Mat_ &depth(depth_in); + computeImpl(depth, normals); + break; + } + case CV_64F: + { + const cv::Mat_ &depth(depth_in); + computeImpl(depth, normals); + break; + } + } + } + + private: + /** Compute the normals + * @param r + * @return + */ + template + cv::Mat + computeImpl(const cv::Mat_ &depth, cv::Mat & normals) const + { + const int r = 5; // used to be 7 + const int sample_step = r; + const int square_size = ((2 * r / sample_step) + 1); + long offsets[square_size * square_size]; + long offsets_x[square_size * square_size]; + long offsets_y[square_size * square_size]; + long offsets_x_x[square_size * square_size]; + long offsets_x_y[square_size * square_size]; + long offsets_y_y[square_size * square_size]; + for (int j = -r, index = 0; j <= r; j += sample_step) + for (int i = -r; i <= r; i += sample_step, ++index) + { + offsets_x[index] = i; + offsets_y[index] = j; + offsets_x_x[index] = i*i; + offsets_x_y[index] = i*j; + offsets_y_y[index] = j*j; + offsets[index] = j * cols_ + i; + } + + // Define K_inv by hand, just for higher accuracy + Mat33T K_inv = cv::Matx::eye(), K; + K_.copyTo(K); + K_inv(0, 0) = 1.0 / K(0, 0); + K_inv(0, 1) = -K(0, 1) / (K(0, 0) * K(1, 1)); + K_inv(0, 2) = (K(0, 1) * K(1, 2) - K(0, 2) * K(1, 1)) / (K(0, 0) * K(1, 1)); + K_inv(1, 1) = 1 / K(1, 1); + K_inv(1, 2) = -K(1, 2) / K(1, 1); + + Vec3T X1_minus_X, X2_minus_X; + + ContainerDepth difference_threshold = 50; + for (int y = r; y < rows_ - r - 1; ++y) + { + const DepthDepth * p_line = reinterpret_cast(depth.ptr(y, r)); + Vec3T *normal = normals.ptr(y, r); + + for (int x = r; x < cols_ - r - 1; ++x) + { + DepthDepth d = p_line[0]; + + // accum + long A[4]; + A[0] = A[1] = A[2] = A[3] = 0; + ContainerDepth b[2]; + b[0] = b[1] = 0; + for (unsigned int i = 0; i < square_size * square_size; ++i) { + // We need to cast to ContainerDepth in case we have unsigned DepthDepth + ContainerDepth delta = ContainerDepth(p_line[offsets[i]]) - ContainerDepth(d); + if (std::abs(delta) > difference_threshold) + continue; + + A[0] += offsets_x_x[i]; + A[1] += offsets_x_y[i]; + A[3] += offsets_y_y[i]; + b[0] += offsets_x[i] * delta; + b[1] += offsets_y[i] * delta; + } + + // solve for the optimal gradient D of equation (8) + long det = A[0] * A[3] - A[1] * A[1]; + // We should divide the following two by det, but instead, we multiply + // X1_minus_X and X2_minus_X by det (which does not matter as we normalize the normals) + // Therefore, no division is done: this is only for speedup + ContainerDepth dx = (A[3] * b[0] - A[1] * b[1]); + ContainerDepth dy = (-A[1] * b[0] + A[0] * b[1]); + + // Compute the dot product + //Vec3T X = K_inv * Vec3T(x, y, 1) * depth(y, x); + //Vec3T X1 = K_inv * Vec3T(x + 1, y, 1) * (depth(y, x) + dx); + //Vec3T X2 = K_inv * Vec3T(x, y + 1, 1) * (depth(y, x) + dy); + //Vec3T nor = (X1 - X).cross(X2 - X); + multiply_by_K_inv(K_inv, d * det + (x + 1) * dx, y * dx, dx, X1_minus_X); + multiply_by_K_inv(K_inv, x * dy, d * det + (y + 1) * dy, dy, X2_minus_X); + Vec3T nor = X1_minus_X.cross(X2_minus_X); + signNormal(nor, *normal); + + ++p_line; + ++normal; + } + } + + return normals; + } + }; +} + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + +namespace +{ + + /** Given a set of 3d points in a depth image, compute the normals at each point + * using the SRI method described in + * ``Fast and Accurate Computation of Surface Normals from Range Images`` + * by H. Badino, D. Huber, Y. Park and T. Kanade + */ + template + class SRI: public RgbdNormalsImpl + { + public: + typedef cv::Matx Mat33T; + typedef cv::Vec Vec9T; + typedef cv::Vec Vec3T; + + SRI(int rows, int cols, int window_size, int depth, const cv::Mat &K, cv::RgbdNormals::RGBD_NORMALS_METHOD method) + : + RgbdNormalsImpl(rows, cols, window_size, depth, K, method), + phi_step_(0), + theta_step_(0) + { + } + + /** Compute cached data + */ + virtual void + cache() + { + cv::Mat_ cos_theta, sin_theta, cos_phi, sin_phi; + computeThetaPhi(rows_, cols_, K_, cos_theta, sin_theta, cos_phi, sin_phi); + + // Create the derivative kernels + getDerivKernels(kx_dx_, ky_dx_, 1, 0, window_size_, true, depth_); + getDerivKernels(kx_dy_, ky_dy_, 0, 1, window_size_, true, depth_); + + // Get the mapping function for SRI + float min_theta = std::asin(sin_theta(0, 0)), max_theta = std::asin(sin_theta(0, cols_ - 1)); + float min_phi = std::asin(sin_phi(0, cols_/2-1)), max_phi = std::asin(sin_phi(rows_ - 1, cols_/2-1)); + + std::vector points3d(cols_ * rows_); + R_hat_.create(rows_, cols_); + phi_step_ = float(max_phi - min_phi) / (rows_ - 1); + theta_step_ = float(max_theta - min_theta) / (cols_ - 1); + for (int phi_int = 0, k = 0; phi_int < rows_; ++phi_int) + { + float phi = min_phi + phi_int * phi_step_; + for (int theta_int = 0; theta_int < cols_; ++theta_int, ++k) + { + float theta = min_theta + theta_int * theta_step_; + // Store the 3d point to project it later + points3d[k] = cv::Point3f(std::sin(theta) * std::cos(phi), std::sin(phi), std::cos(theta) * std::cos(phi)); + + // Cache the rotation matrix and negate it + cv::Mat_ mat = + (cv::Mat_ < T > (3, 3) << 0, 1, 0, 0, 0, 1, 1, 0, 0) * ((cv::Mat_ < T > (3, 3) << std::cos(theta), -std::sin( + theta), 0, std::sin(theta), std::cos(theta), 0, 0, 0, 1)) + * ((cv::Mat_ < T > (3, 3) << std::cos(phi), 0, -std::sin(phi), 0, 1, 0, std::sin(phi), 0, std::cos(phi))); + for (unsigned char i = 0; i < 3; ++i) + mat(i, 1) = mat(i, 1) / std::cos(phi); + // The second part of the matrix is never explained in the paper ... but look at the wikipedia normal article + mat(0, 0) = mat(0, 0) - 2 * std::cos(phi) * std::sin(theta); + mat(1, 0) = mat(1, 0) - 2 * std::sin(phi); + mat(2, 0) = mat(2, 0) - 2 * std::cos(phi) * std::cos(theta); + + R_hat_(phi_int, theta_int) = Vec9T((T*) (mat.data)); + } + } + + map_.create(rows_, cols_); + cv::projectPoints(points3d, cv::Mat(3,1,CV_32FC1,cv::Scalar::all(0.0f)), cv::Mat(3,1,CV_32FC1,cv::Scalar::all(0.0f)), K_, cv::Mat(), map_); + map_ = map_.reshape(2, rows_); + cv::convertMaps(map_, cv::Mat(), xy_, fxy_, CV_16SC2); + + //map for converting from Spherical coordinate space to Euclidean space + euclideanMap_.create(rows_,cols_); + float invFx = 1.0f/K_.at(0,0), cx = K_.at(0,2); + double invFy = 1.0f/K_.at(1,1), cy = K_.at(1,2); + for (int i = 0; i < rows_; i++) + { + float y = (i - cy)*invFy; + for (int j = 0; j < cols_; j++) + { + float x = (j - cx)*invFx; + float theta = std::atan(x); + float phi = std::asin(y/std::sqrt(x*x+y*y+1.0f)); + + euclideanMap_(i,j) = cv::Vec2f((theta-min_theta)/theta_step_,(phi-min_phi)/phi_step_); + } + } + //convert map to 2 maps in short format for increasing speed in remap function + cv::convertMaps(euclideanMap_, cv::Mat(), invxy_, invfxy_, CV_16SC2); + + // Update the kernels: the steps are due to the fact that derivatives will be computed on a grid where + // the step is not 1. Only need to do it on one dimension as it computes derivatives in only one direction + kx_dx_ /= theta_step_; + ky_dy_ /= phi_step_; + } + + /** Compute the normals + * @param r + * @return + */ + virtual void + compute(const cv::Mat& points3d, const cv::Mat &r, cv::Mat & normals) const + { + const cv::Mat_& r_T(r); + const cv::Mat_ &points3d_T(points3d); + compute(points3d_T, r_T, normals); + } + + /** Compute the normals + * @param r + * @return + */ + void + compute(const cv::Mat_ &, const cv::Mat_ &r_non_interp, cv::Mat & normals_out) const + { + // Interpolate the radial image to make derivatives meaningful + cv::Mat_ r; + // higher quality remapping does not help here + cv::remap(r_non_interp, r, xy_, fxy_, CV_INTER_LINEAR); + + // Compute the derivatives with respect to theta and phi + // TODO add bilateral filtering (as done in kinfu) + cv::Mat_ r_theta, r_phi; + cv::sepFilter2D(r, r_theta, r.depth(), kx_dx_, ky_dx_); + //current OpenCV version sometimes corrupts r matrix after second call of sepFilter2D + //it depends on resolution, be careful + cv::sepFilter2D(r, r_phi, r.depth(), kx_dy_, ky_dy_); + + // Fill the result matrix + cv::Mat_ normals(rows_, cols_); + + const T* r_theta_ptr = r_theta[0], *r_theta_ptr_end = r_theta_ptr + rows_ * cols_; + const T* r_phi_ptr = r_phi[0]; + const Mat33T * R = reinterpret_cast(R_hat_[0]); + const T* r_ptr = r[0]; + Vec3T * normal = normals[0]; + for (; r_theta_ptr != r_theta_ptr_end; ++r_theta_ptr, ++r_phi_ptr, ++R, ++r_ptr, ++normal) + { + if (cvIsNaN(*r_ptr)) + { + (*normal)[0] = *r_ptr; + (*normal)[1] = *r_ptr; + (*normal)[2] = *r_ptr; + } + else + { + T r_theta_over_r = (*r_theta_ptr) / (*r_ptr); + T r_phi_over_r = (*r_phi_ptr) / (*r_ptr); + // R(1,1) is 0 + signNormal((*R)(0, 0) + (*R)(0, 1) * r_theta_over_r + (*R)(0, 2) * r_phi_over_r, + (*R)(1, 0) + (*R)(1, 2) * r_phi_over_r, + (*R)(2, 0) + (*R)(2, 1) * r_theta_over_r + (*R)(2, 2) * r_phi_over_r, *normal); + } + } + + cv::remap(normals, normals_out, invxy_, invfxy_, cv::INTER_LINEAR); + normal = normals_out.ptr(0); + Vec3T * normal_end = normal + rows_ * cols_; + for (; normal != normal_end; ++normal) + signNormal((*normal)[0], (*normal)[1], (*normal)[2], *normal); + } + private: + /** Stores R */ + cv::Mat_ R_hat_; + float phi_step_, theta_step_; + + /** Derivative kernels */ + cv::Mat kx_dx_, ky_dx_, kx_dy_, ky_dy_; + /** mapping function to get an SRI image */ + cv::Mat_ map_; + cv::Mat xy_, fxy_; + + cv::Mat_ euclideanMap_; + cv::Mat invxy_, invfxy_; + }; +} + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + +namespace cv +{ + /** Default constructor of the Algorithm class that computes normals + */ + RgbdNormals::RgbdNormals(int rows, int cols, int depth, InputArray K_in, int window_size, int method_in) + : + rows_(rows), + cols_(cols), + depth_(depth), + K_(K_in.getMat()), + window_size_(window_size), + method_(method_in), + rgbd_normals_impl_(0) + { + CV_Assert(depth == CV_32F || depth == CV_64F); + CV_Assert(K_.cols == 3 && K_.rows == 3); + } + + // Just to remove a warning + void delete_normals_impl(void *rgbd_normals_impl_, int method_, int depth); + void delete_normals_impl(void *rgbd_normals_impl_, int method_, int depth) + { + if (rgbd_normals_impl_ == 0) + return; + switch (method_) + { + case RgbdNormals::RGBD_NORMALS_METHOD_LINEMOD: + { + if (depth == CV_32F) + delete reinterpret_cast *>(rgbd_normals_impl_); + else + delete reinterpret_cast *>(rgbd_normals_impl_); + break; + } + case RgbdNormals::RGBD_NORMALS_METHOD_SRI: + { + if (depth == CV_32F) + delete reinterpret_cast *>(rgbd_normals_impl_); + else + delete reinterpret_cast *>(rgbd_normals_impl_); + break; + } + case (RgbdNormals::RGBD_NORMALS_METHOD_FALS): + { + if (depth == CV_32F) + delete reinterpret_cast *>(rgbd_normals_impl_); + else + delete reinterpret_cast *>(rgbd_normals_impl_); + break; + } + } + } + + /** Destructor + */ + RgbdNormals::~RgbdNormals() + { + delete_normals_impl(rgbd_normals_impl_, method_, depth_); + } + + void + RgbdNormals::initialize_normals_impl(int rows, int cols, int depth, const cv::Mat & K, int window_size, + int method_in) const + { + CV_Assert(rows > 0 && cols > 0 && (depth == CV_32F || depth == CV_64F)); + CV_Assert(window_size == 1 || window_size == 3 || window_size == 5 || window_size == 7); + CV_Assert(K_.cols == 3 && K.rows == 3 && (K.depth() == CV_32F || K.depth() == CV_64F)); + CV_Assert( + method_in == RGBD_NORMALS_METHOD_FALS || method_in == RGBD_NORMALS_METHOD_LINEMOD + || method_in == RGBD_NORMALS_METHOD_SRI); + switch (method_in) + { + case (RGBD_NORMALS_METHOD_FALS): + { + if (depth == CV_32F) + rgbd_normals_impl_ = new FALS(rows, cols, window_size, depth, K, RGBD_NORMALS_METHOD_FALS); + else + rgbd_normals_impl_ = new FALS(rows, cols, window_size, depth, K, RGBD_NORMALS_METHOD_FALS); + break; + } + case (RGBD_NORMALS_METHOD_LINEMOD): + { + if (depth == CV_32F) + rgbd_normals_impl_ = new LINEMOD(rows, cols, window_size, depth, K, RGBD_NORMALS_METHOD_LINEMOD); + else + rgbd_normals_impl_ = new LINEMOD(rows, cols, window_size, depth, K, RGBD_NORMALS_METHOD_LINEMOD); + break; + } + case RGBD_NORMALS_METHOD_SRI: + { + if (depth == CV_32F) + rgbd_normals_impl_ = new SRI(rows, cols, window_size, depth, K, RGBD_NORMALS_METHOD_SRI); + else + rgbd_normals_impl_ = new SRI(rows, cols, window_size, depth, K, RGBD_NORMALS_METHOD_SRI); + break; + } + } + + reinterpret_cast(rgbd_normals_impl_)->cache(); + } + + /** Initializes some data that is cached for later computation + * If that function is not called, it will be called the first time normals are computed + */ + void + RgbdNormals::initialize() const + { + if (rgbd_normals_impl_ == 0) + initialize_normals_impl(rows_, cols_, depth_, K_, window_size_, method_); + else if (!reinterpret_cast(rgbd_normals_impl_)->validate(rows_, cols_, depth_, K_, window_size_, + method_)) { + delete_normals_impl(rgbd_normals_impl_, method_, depth_); + initialize_normals_impl(rows_, cols_, depth_, K_, window_size_, method_); + } + } + + /** Given a set of 3d points in a depth image, compute the normals at each point + * @param points3d_in depth a float depth image. Or it can be rows x cols x 3 is they are 3d points + * @param normals a rows x cols x 3 matrix + */ + void + RgbdNormals::operator()(InputArray points3d_in, OutputArray normals_out) const + { + cv::Mat points3d_ori = points3d_in.getMat(); + + CV_Assert(points3d_ori.dims == 2); + // Either we have 3d points or a depth image + switch (method_) + { + case (RGBD_NORMALS_METHOD_FALS): + { + CV_Assert(points3d_ori.channels() == 3); + CV_Assert(points3d_ori.depth() == CV_32F || points3d_ori.depth() == CV_64F); + break; + } + case RGBD_NORMALS_METHOD_LINEMOD: + { + CV_Assert( + ((points3d_ori.channels() == 3) && (points3d_ori.depth() == CV_32F || points3d_ori.depth() == CV_64F)) || ((points3d_ori.channels() == 1) && (points3d_ori.depth() == CV_16U || points3d_ori.depth() == CV_32F || points3d_ori.depth() == CV_64F))); + break; + } + case RGBD_NORMALS_METHOD_SRI: + { + CV_Assert( ((points3d_ori.channels() == 3) && (points3d_ori.depth() == CV_32F || points3d_ori.depth() == CV_64F))); + break; + } + } + + // Initialize the pimpl + initialize(); + + // Precompute something for RGBD_NORMALS_METHOD_SRI and RGBD_NORMALS_METHOD_FALS + cv::Mat points3d, radius; + if ((method_ == RGBD_NORMALS_METHOD_SRI) || (method_ == RGBD_NORMALS_METHOD_FALS)) + { + // Make the points have the right depth + if (points3d_ori.depth() == depth_) + points3d = points3d_ori; + else + points3d_ori.convertTo(points3d, depth_); + + // Compute the distance to the points + if (depth_ == CV_32F) + radius = computeRadius(points3d); + else + radius = computeRadius(points3d); + } + + // Get the normals + normals_out.create(points3d_ori.size(), CV_MAKETYPE(depth_, 3)); + if (points3d_in.empty()) + return; + + cv::Mat normals = normals_out.getMat(); + switch (method_) + { + case (RGBD_NORMALS_METHOD_FALS): + { + if (depth_ == CV_32F) + reinterpret_cast *>(rgbd_normals_impl_)->compute(points3d, radius, normals); + else + reinterpret_cast *>(rgbd_normals_impl_)->compute(points3d, radius, normals); + break; + } + case RGBD_NORMALS_METHOD_LINEMOD: + { + // Only focus on the depth image for LINEMOD + cv::Mat depth; + if (points3d_ori.channels() == 3) + { + std::vector channels; + cv::split(points3d, channels); + depth = channels[2]; + } + else + depth = points3d_ori; + + if (depth_ == CV_32F) + reinterpret_cast *>(rgbd_normals_impl_)->compute(depth, normals); + else + reinterpret_cast *>(rgbd_normals_impl_)->compute(depth, normals); + break; + } + case RGBD_NORMALS_METHOD_SRI: + { + if (depth_ == CV_32F) + reinterpret_cast *>(rgbd_normals_impl_)->compute(points3d, radius, normals); + else + reinterpret_cast *>(rgbd_normals_impl_)->compute(points3d, radius, normals); + break; + } + } + } +} diff --git a/modules/rgbd/src/odometry.cpp b/modules/rgbd/src/odometry.cpp new file mode 100644 index 000000000..ee292cea1 --- /dev/null +++ b/modules/rgbd/src/odometry.cpp @@ -0,0 +1,1406 @@ +/* + * Software License Agreement (BSD License) + * + * Copyright (c) 2012, Willow Garage, Inc. + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions 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. + * * Neither the name of Willow Garage, Inc. nor the names of its + * contributors may 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 + * COPYRIGHT OWNER 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. + * + */ + +#include +#include +#include +#include +#include +#include +#include + +#include +#include + +#if defined(HAVE_EIGEN) && EIGEN_WORLD_VERSION == 3 +#define HAVE_EIGEN3_HERE +#include +#include +#include +#endif + +using namespace cv; + +enum +{ + RGBD_ODOMETRY = 1, + ICP_ODOMETRY = 2, + MERGED_ODOMETRY = RGBD_ODOMETRY + ICP_ODOMETRY +}; + +const int sobelSize = 3; +const double sobelScale = 1./8.; +int normalWinSize = 5; +int normalMethod = RgbdNormals::RGBD_NORMALS_METHOD_FALS; + +static inline +void setDefaultIterCounts(Mat& iterCounts) +{ + iterCounts = Mat(Vec4i(7,7,7,10)); +} + +static inline +void setDefaultMinGradientMagnitudes(Mat& minGradientMagnitudes) +{ + minGradientMagnitudes = Mat(Vec4f(10,10,10,10)); +} + +static +void buildPyramidCameraMatrix(const Mat& cameraMatrix, int levels, std::vector& pyramidCameraMatrix) +{ + pyramidCameraMatrix.resize(levels); + + Mat cameraMatrix_dbl; + cameraMatrix.convertTo(cameraMatrix_dbl, CV_64FC1); + + for(int i = 0; i < levels; i++) + { + Mat levelCameraMatrix = i == 0 ? cameraMatrix_dbl : 0.5f * pyramidCameraMatrix[i-1]; + levelCameraMatrix.at(2,2) = 1.; + pyramidCameraMatrix[i] = levelCameraMatrix; + } +} + +static inline +void checkImage(const Mat& image) +{ + if(image.empty()) + CV_Error(CV_StsBadSize, "Image is empty."); + if(image.type() != CV_8UC1) + CV_Error(CV_StsBadSize, "Image type has to be CV_8UC1."); +} + +static inline +void checkDepth(const Mat& depth, const Size& imageSize) +{ + if(depth.empty()) + CV_Error(CV_StsBadSize, "Depth is empty."); + if(depth.size() != imageSize) + CV_Error(CV_StsBadSize, "Depth has to have the size equal to the image size."); + if(depth.type() != CV_32FC1) + CV_Error(CV_StsBadSize, "Depth type has to be CV_32FC1."); +} + +static inline +void checkMask(const Mat& mask, const Size& imageSize) +{ + if(!mask.empty()) + { + if(mask.size() != imageSize) + CV_Error(CV_StsBadSize, "Mask has to have the size equal to the image size."); + if(mask.type() != CV_8UC1) + CV_Error(CV_StsBadSize, "Mask type has to be CV_8UC1."); + } +} + +static inline +void checkNormals(const Mat& normals, const Size& depthSize) +{ + if(normals.size() != depthSize) + CV_Error(CV_StsBadSize, "Normals has to have the size equal to the depth size."); + if(normals.type() != CV_32FC3) + CV_Error(CV_StsBadSize, "Normals type has to be CV_32FC3."); +} + +static +void preparePyramidImage(const Mat& image, std::vector& pyramidImage, size_t levelCount) +{ + if(!pyramidImage.empty()) + { + if(pyramidImage.size() < levelCount) + CV_Error(CV_StsBadSize, "Levels count of pyramidImage has to be equal or less than size of iterCounts."); + + CV_Assert(pyramidImage[0].size() == image.size()); + for(size_t i = 0; i < pyramidImage.size(); i++) + CV_Assert(pyramidImage[i].type() == image.type()); + } + else + buildPyramid(image, pyramidImage, levelCount - 1); +} + +static +void preparePyramidDepth(const Mat& depth, std::vector& pyramidDepth, size_t levelCount) +{ + if(!pyramidDepth.empty()) + { + if(pyramidDepth.size() < levelCount) + CV_Error(CV_StsBadSize, "Levels count of pyramidDepth has to be equal or less than size of iterCounts."); + + CV_Assert(pyramidDepth[0].size() == depth.size()); + for(size_t i = 0; i < pyramidDepth.size(); i++) + CV_Assert(pyramidDepth[i].type() == depth.type()); + } + else + buildPyramid(depth, pyramidDepth, levelCount - 1); +} + +static +void preparePyramidMask(const Mat& mask, const std::vector& pyramidDepth, float minDepth, float maxDepth, + const std::vector& pyramidNormal, + std::vector& pyramidMask) +{ + minDepth = std::max(0.f, minDepth); + + if(!pyramidMask.empty()) + { + if(pyramidMask.size() != pyramidDepth.size()) + CV_Error(CV_StsBadSize, "Levels count of pyramidMask has to be equal to size of pyramidDepth."); + + for(size_t i = 0; i < pyramidMask.size(); i++) + { + CV_Assert(pyramidMask[i].size() == pyramidDepth[i].size()); + CV_Assert(pyramidMask[i].type() == CV_8UC1); + } + } + else + { + Mat validMask; + if(mask.empty()) + validMask = Mat(pyramidDepth[0].size(), CV_8UC1, Scalar(255)); + else + validMask = mask.clone(); + + buildPyramid(validMask, pyramidMask, pyramidDepth.size() - 1); + + for(size_t i = 0; i < pyramidMask.size(); i++) + { + Mat levelDepth = pyramidDepth[i].clone(); + patchNaNs(levelDepth, 0); + + Mat& levelMask = pyramidMask[i]; + levelMask &= (levelDepth > minDepth) & (levelDepth < maxDepth); + + if(!pyramidNormal.empty()) + { + CV_Assert(pyramidNormal[i].type() == CV_32FC3); + CV_Assert(pyramidNormal[i].size() == pyramidDepth[i].size()); + Mat levelNormal = pyramidNormal[i].clone(); + + Mat validNormalMask = levelNormal == levelNormal; // otherwise it's Nan + CV_Assert(validNormalMask.type() == CV_8UC3); + + std::vector channelMasks; + split(validNormalMask, channelMasks); + validNormalMask = channelMasks[0] & channelMasks[1] & channelMasks[2]; + + levelMask &= validNormalMask; + } + } + } +} + +static +void preparePyramidCloud(const std::vector& pyramidDepth, const Mat& cameraMatrix, std::vector& pyramidCloud) +{ + if(!pyramidCloud.empty()) + { + if(pyramidCloud.size() != pyramidDepth.size()) + CV_Error(CV_StsBadSize, "Incorrect size of pyramidCloud."); + + for(size_t i = 0; i < pyramidDepth.size(); i++) + { + CV_Assert(pyramidCloud[i].size() == pyramidDepth[i].size()); + CV_Assert(pyramidCloud[i].type() == CV_32FC3); + } + } + else + { + std::vector pyramidCameraMatrix; + buildPyramidCameraMatrix(cameraMatrix, pyramidDepth.size(), pyramidCameraMatrix); + + pyramidCloud.resize(pyramidDepth.size()); + for(size_t i = 0; i < pyramidDepth.size(); i++) + { + Mat cloud; + depthTo3d(pyramidDepth[i], pyramidCameraMatrix[i], cloud); + pyramidCloud[i] = cloud; + } + } +} + +static +void preparePyramidSobel(const std::vector& pyramidImage, int dx, int dy, std::vector& pyramidSobel) +{ + if(!pyramidSobel.empty()) + { + if(pyramidSobel.size() != pyramidImage.size()) + CV_Error(CV_StsBadSize, "Incorrect size of pyramidSobel."); + + for(size_t i = 0; i < pyramidSobel.size(); i++) + { + CV_Assert(pyramidSobel[i].size() == pyramidImage[i].size()); + CV_Assert(pyramidSobel[i].type() == CV_16SC1); + } + } + else + { + pyramidSobel.resize(pyramidImage.size()); + for(size_t i = 0; i < pyramidImage.size(); i++) + { + Sobel(pyramidImage[i], pyramidSobel[i], CV_16S, dx, dy, sobelSize); + } + } +} + +static +void randomSubsetOfMask(Mat& mask, float part) +{ + const int minPointsCount = 1000; // minimum point count (we can process them fast) + const int nonzeros = countNonZero(mask); + const int needCount = std::max(minPointsCount, int(mask.total() * part)); + if(needCount < nonzeros) + { + RNG rng; + Mat subset(mask.size(), CV_8UC1, Scalar(0)); + + int subsetSize = 0; + while(subsetSize < needCount) + { + int y = rng(mask.rows); + int x = rng(mask.cols); + if(mask.at(y,x)) + { + subset.at(y,x) = 255; + mask.at(y,x) = 0; + subsetSize++; + } + } + mask = subset; + } +} + +static +void preparePyramidTexturedMask(const std::vector& pyramid_dI_dx, const std::vector& pyramid_dI_dy, + const std::vector& minGradMagnitudes, const std::vector& pyramidMask, double maxPointsPart, + std::vector& pyramidTexturedMask) +{ + if(!pyramidTexturedMask.empty()) + { + if(pyramidTexturedMask.size() != pyramid_dI_dx.size()) + CV_Error(CV_StsBadSize, "Incorrect size of pyramidTexturedMask."); + + for(size_t i = 0; i < pyramidTexturedMask.size(); i++) + { + CV_Assert(pyramidTexturedMask[i].size() == pyramid_dI_dx[i].size()); + CV_Assert(pyramidTexturedMask[i].type() == CV_8UC1); + } + } + else + { + const float sobelScale2_inv = 1.f / (sobelScale * sobelScale); + pyramidTexturedMask.resize(pyramid_dI_dx.size()); + for(size_t i = 0; i < pyramidTexturedMask.size(); i++) + { + const float minScaledGradMagnitude2 = minGradMagnitudes[i] * minGradMagnitudes[i] * sobelScale2_inv; + const Mat& dIdx = pyramid_dI_dx[i]; + const Mat& dIdy = pyramid_dI_dy[i]; + + Mat texturedMask(dIdx.size(), CV_8UC1, Scalar(0)); + + for(int y = 0; y < dIdx.rows; y++) + { + const short *dIdx_row = dIdx.ptr(y); + const short *dIdy_row = dIdy.ptr(y); + uchar *texturedMask_row = texturedMask.ptr(y); + for(int x = 0; x < dIdx.cols; x++) + { + float magnitude2 = static_cast(dIdx_row[x] * dIdx_row[x] + dIdy_row[x] * dIdy_row[x]); + if(magnitude2 >= minScaledGradMagnitude2) + texturedMask_row[x] = 255; + } + } + pyramidTexturedMask[i] = texturedMask & pyramidMask[i]; + + randomSubsetOfMask(pyramidTexturedMask[i], maxPointsPart); + } + } +} + +static +void preparePyramidNormals(const Mat& normals, const std::vector& pyramidDepth, std::vector& pyramidNormals) +{ + if(!pyramidNormals.empty()) + { + if(pyramidNormals.size() != pyramidDepth.size()) + CV_Error(CV_StsBadSize, "Incorrect size of pyramidNormals."); + + for(size_t i = 0; i < pyramidNormals.size(); i++) + { + CV_Assert(pyramidNormals[i].size() == pyramidDepth[i].size()); + CV_Assert(pyramidNormals[i].type() == CV_32FC3); + } + } + else + { + buildPyramid(normals, pyramidNormals, pyramidDepth.size() - 1); + // renormalize normals + for(size_t i = 1; i < pyramidNormals.size(); i++) + { + Mat& currNormals = pyramidNormals[i]; + for(int y = 0; y < currNormals.rows; y++) + { + Point3f* normals_row = currNormals.ptr(y); + for(int x = 0; x < currNormals.cols; x++) + { + double nrm = norm(normals_row[x]); + normals_row[x] *= 1./nrm; + } + } + } + } +} + +static +void preparePyramidNormalsMask(const std::vector& pyramidNormals, const std::vector& pyramidMask, double maxPointsPart, + std::vector& pyramidNormalsMask) +{ + if(!pyramidNormalsMask.empty()) + { + if(pyramidNormalsMask.size() != pyramidMask.size()) + CV_Error(CV_StsBadSize, "Incorrect size of pyramidNormalsMask."); + + for(size_t i = 0; i < pyramidNormalsMask.size(); i++) + { + CV_Assert(pyramidNormalsMask[i].size() == pyramidMask[i].size()); + CV_Assert(pyramidNormalsMask[i].type() == pyramidMask[i].type()); + } + } + else + { + pyramidNormalsMask.resize(pyramidMask.size()); + + for(size_t i = 0; i < pyramidNormalsMask.size(); i++) + { + pyramidNormalsMask[i] = pyramidMask[i].clone(); + Mat& normalsMask = pyramidNormalsMask[i]; + for(int y = 0; y < normalsMask.rows; y++) + { + const Vec3f *normals_row = pyramidNormals[i].ptr(y); + uchar *normalsMask_row = pyramidNormalsMask[i].ptr(y); + for(int x = 0; x < normalsMask.cols; x++) + { + Vec3f n = normals_row[x]; + if(cvIsNaN(n[0])) + { + CV_DbgAssert(cvIsNaN(n[1]) && cvIsNaN(n[2])); + normalsMask_row[x] = 0; + } + } + } + randomSubsetOfMask(normalsMask, maxPointsPart); + } + } +} + +/////////////////////////////////////////////////////////////////////////////////////// + +static +void computeProjectiveMatrix(const Mat& ksi, Mat& Rt) +{ + CV_Assert(ksi.size() == Size(1,6) && ksi.type() == CV_64FC1); + +#ifdef HAVE_EIGEN3_HERE + const double* ksi_ptr = ksi.ptr(); + Eigen::Matrix twist, g; + twist << 0., -ksi_ptr[2], ksi_ptr[1], ksi_ptr[3], + ksi_ptr[2], 0., -ksi_ptr[0], ksi_ptr[4], + -ksi_ptr[1], ksi_ptr[0], 0, ksi_ptr[5], + 0., 0., 0., 0.; + g = twist.exp(); + + eigen2cv(g, Rt); +#else + // TODO: check computeProjectiveMatrix when there is not eigen library, + // because it gives less accurate pose of the camera + Rt = Mat::eye(4, 4, CV_64FC1); + + Mat R = Rt(Rect(0,0,3,3)); + Mat rvec = ksi.rowRange(0,3); + + Rodrigues(rvec, R); + + Rt.at(0,3) = ksi.at(3); + Rt.at(1,3) = ksi.at(4); + Rt.at(2,3) = ksi.at(5); +#endif +} + +static +void computeCorresps(const Mat& K, const Mat& K_inv, const Mat& Rt, + const Mat& depth0, const Mat& validMask0, + const Mat& depth1, const Mat& selectMask1, float maxDepthDiff, + Mat& _corresps) +{ + CV_Assert(K.type() == CV_64FC1); + CV_Assert(K_inv.type() == CV_64FC1); + CV_Assert(Rt.type() == CV_64FC1); + + Mat corresps(depth1.size(), CV_16SC2, Scalar::all(-1)); + + Rect r(0, 0, depth1.cols, depth1.rows); + Mat Kt = Rt(Rect(3,0,1,3)).clone(); + Kt = K * Kt; + const double * Kt_ptr = Kt.ptr(); + + AutoBuffer buf(3 * (depth1.cols + depth1.rows)); + float *KRK_inv0_u1 = buf; + float *KRK_inv1_v1_plus_KRK_inv2 = KRK_inv0_u1 + depth1.cols; + float *KRK_inv3_u1 = KRK_inv1_v1_plus_KRK_inv2 + depth1.rows; + float *KRK_inv4_v1_plus_KRK_inv5 = KRK_inv3_u1 + depth1.cols; + float *KRK_inv6_u1 = KRK_inv4_v1_plus_KRK_inv5 + depth1.rows; + float *KRK_inv7_v1_plus_KRK_inv8 = KRK_inv6_u1 + depth1.cols; + { + Mat R = Rt(Rect(0,0,3,3)).clone(); + + Mat KRK_inv = K * R * K_inv; + const double * KRK_inv_ptr = KRK_inv.ptr(); + for(int u1 = 0; u1 < depth1.cols; u1++) + { + KRK_inv0_u1[u1] = KRK_inv_ptr[0] * u1; + KRK_inv3_u1[u1] = KRK_inv_ptr[3] * u1; + KRK_inv6_u1[u1] = KRK_inv_ptr[6] * u1; + } + + for(int v1 = 0; v1 < depth1.rows; v1++) + { + KRK_inv1_v1_plus_KRK_inv2[v1] = KRK_inv_ptr[1] * v1 + KRK_inv_ptr[2]; + KRK_inv4_v1_plus_KRK_inv5[v1] = KRK_inv_ptr[4] * v1 + KRK_inv_ptr[5]; + KRK_inv7_v1_plus_KRK_inv8[v1] = KRK_inv_ptr[7] * v1 + KRK_inv_ptr[8]; + } + } + + int correspCount = 0; + for(int v1 = 0; v1 < depth1.rows; v1++) + { + const float *depth1_row = depth1.ptr(v1); + const uchar *mask1_row = selectMask1.ptr(v1); + for(int u1 = 0; u1 < depth1.cols; u1++) + { + float d1 = depth1_row[u1]; + if(mask1_row[u1]) + { + CV_DbgAssert(!cvIsNaN(d1)); + float transformed_d1 = static_cast(d1 * (KRK_inv6_u1[u1] + KRK_inv7_v1_plus_KRK_inv8[v1]) + + Kt_ptr[2]); + if(transformed_d1 > 0) + { + float transformed_d1_inv = 1.f / transformed_d1; + int u0 = cvRound(transformed_d1_inv * (d1 * (KRK_inv0_u1[u1] + KRK_inv1_v1_plus_KRK_inv2[v1]) + + Kt_ptr[0])); + int v0 = cvRound(transformed_d1_inv * (d1 * (KRK_inv3_u1[u1] + KRK_inv4_v1_plus_KRK_inv5[v1]) + + Kt_ptr[1])); + + if(r.contains(Point(u0,v0))) + { + float d0 = depth0.at(v0,u0); + if(validMask0.at(v0, u0) && std::abs(transformed_d1 - d0) <= maxDepthDiff) + { + CV_DbgAssert(!cvIsNaN(d0)); + Vec2s& c = corresps.at(v0,u0); + if(c[0] != -1) + { + int exist_u1 = c[0], exist_v1 = c[1]; + + float exist_d1 = (float)(depth1.at(exist_v1,exist_u1) * + (KRK_inv6_u1[exist_u1] + KRK_inv7_v1_plus_KRK_inv8[exist_v1]) + Kt_ptr[2]); + + if(transformed_d1 > exist_d1) + continue; + } + else + correspCount++; + + c = Vec2s(u1,v1); + } + } + } + } + } + } + + _corresps.create(correspCount, 1, CV_32SC4); + Vec4i * corresps_ptr = _corresps.ptr(); + for(int v0 = 0, i = 0; v0 < corresps.rows; v0++) + { + const Vec2s* corresps_row = corresps.ptr(v0); + for(int u0 = 0; u0 < corresps.cols; u0++) + { + const Vec2s& c = corresps_row[u0]; + if(c[0] != -1) + corresps_ptr[i++] = Vec4i(u0,v0,c[0],c[1]); + } + } +} + +static inline +void calcRgbdEquationCoeffs(double* C, double dIdx, double dIdy, const Point3f& p3d, double fx, double fy) +{ + double invz = 1. / p3d.z, + v0 = dIdx * fx * invz, + v1 = dIdy * fy * invz, + v2 = -(v0 * p3d.x + v1 * p3d.y) * invz; + + C[0] = -p3d.z * v1 + p3d.y * v2; + C[1] = p3d.z * v0 - p3d.x * v2; + C[2] = -p3d.y * v0 + p3d.x * v1; + C[3] = v0; + C[4] = v1; + C[5] = v2; +} + +static inline +void calcRgbdEquationCoeffsRotation(double* C, double dIdx, double dIdy, const Point3f& p3d, double fx, double fy) +{ + double invz = 1. / p3d.z, + v0 = dIdx * fx * invz, + v1 = dIdy * fy * invz, + v2 = -(v0 * p3d.x + v1 * p3d.y) * invz; + C[0] = -p3d.z * v1 + p3d.y * v2; + C[1] = p3d.z * v0 - p3d.x * v2; + C[2] = -p3d.y * v0 + p3d.x * v1; +} + +static inline +void calcRgbdEquationCoeffsTranslation(double* C, double dIdx, double dIdy, const Point3f& p3d, double fx, double fy) +{ + double invz = 1. / p3d.z, + v0 = dIdx * fx * invz, + v1 = dIdy * fy * invz, + v2 = -(v0 * p3d.x + v1 * p3d.y) * invz; + C[0] = v0; + C[1] = v1; + C[2] = v2; +} + +typedef +void (*CalcRgbdEquationCoeffsPtr)(double*, double, double, const Point3f&, double, double); + +static inline +void calcICPEquationCoeffs(double* C, const Point3f& p0, const Vec3f& n1) +{ + C[0] = -p0.z * n1[1] + p0.y * n1[2]; + C[1] = p0.z * n1[0] - p0.x * n1[2]; + C[2] = -p0.y * n1[0] + p0.x * n1[1]; + C[3] = n1[0]; + C[4] = n1[1]; + C[5] = n1[2]; +} + +static inline +void calcICPEquationCoeffsRotation(double* C, const Point3f& p0, const Vec3f& n1) +{ + C[0] = -p0.z * n1[1] + p0.y * n1[2]; + C[1] = p0.z * n1[0] - p0.x * n1[2]; + C[2] = -p0.y * n1[0] + p0.x * n1[1]; +} + +static inline +void calcICPEquationCoeffsTranslation(double* C, const Point3f& /*p0*/, const Vec3f& n1) +{ + C[0] = n1[0]; + C[1] = n1[1]; + C[2] = n1[2]; +} + +typedef +void (*CalcICPEquationCoeffsPtr)(double*, const Point3f&, const Vec3f&); + +static +void calcRgbdLsmMatrices(const Mat& image0, const Mat& cloud0, const Mat& Rt, + const Mat& image1, const Mat& dI_dx1, const Mat& dI_dy1, + const Mat& corresps, double fx, double fy, double sobelScaleIn, + Mat& AtA, Mat& AtB, CalcRgbdEquationCoeffsPtr func, int transformDim) +{ + AtA = Mat(transformDim, transformDim, CV_64FC1, Scalar(0)); + AtB = Mat(transformDim, 1, CV_64FC1, Scalar(0)); + double* AtB_ptr = AtB.ptr(); + + const int correspsCount = corresps.rows; + + CV_Assert(Rt.type() == CV_64FC1); + const double * Rt_ptr = Rt.ptr(); + + AutoBuffer diffs(correspsCount); + float* diffs_ptr = diffs; + + const Vec4i* corresps_ptr = corresps.ptr(); + + double sigma = 0; + for(int correspIndex = 0; correspIndex < corresps.rows; correspIndex++) + { + const Vec4i& c = corresps_ptr[correspIndex]; + int u0 = c[0], v0 = c[1]; + int u1 = c[2], v1 = c[3]; + + diffs_ptr[correspIndex] = static_cast(static_cast(image0.at(v0,u0)) - + static_cast(image1.at(v1,u1))); + sigma += diffs_ptr[correspIndex] * diffs_ptr[correspIndex]; + } + sigma = std::sqrt(sigma/correspsCount); + + std::vector A_buf(transformDim); + double* A_ptr = &A_buf[0]; + + for(int correspIndex = 0; correspIndex < corresps.rows; correspIndex++) + { + const Vec4i& c = corresps_ptr[correspIndex]; + int u0 = c[0], v0 = c[1]; + int u1 = c[2], v1 = c[3]; + + double w = sigma + std::abs(diffs_ptr[correspIndex]); + w = w > DBL_EPSILON ? 1./w : 1.; + + double w_sobelScale = w * sobelScaleIn; + + const Point3f& p0 = cloud0.at(v0,u0); + Point3f tp0; + tp0.x = p0.x * Rt_ptr[0] + p0.y * Rt_ptr[1] + p0.z * Rt_ptr[2] + Rt_ptr[3]; + tp0.y = p0.x * Rt_ptr[4] + p0.y * Rt_ptr[5] + p0.z * Rt_ptr[6] + Rt_ptr[7]; + tp0.z = p0.x * Rt_ptr[8] + p0.y * Rt_ptr[9] + p0.z * Rt_ptr[10] + Rt_ptr[11]; + + func(A_ptr, + w_sobelScale * dI_dx1.at(v1,u1), + w_sobelScale * dI_dy1.at(v1,u1), + tp0, fx, fy); + + for(int y = 0; y < transformDim; y++) + { + double* AtA_ptr = AtA.ptr(y); + for(int x = y; x < transformDim; x++) + AtA_ptr[x] += A_ptr[y] * A_ptr[x]; + + AtB_ptr[y] += A_ptr[y] * w * diffs_ptr[correspIndex]; + } + } + + for(int y = 0; y < transformDim; y++) + for(int x = y+1; x < transformDim; x++) + AtA.at(x,y) = AtA.at(y,x); +} + +static +void calcICPLsmMatrices(const Mat& cloud0, const Mat& Rt, + const Mat& cloud1, const Mat& normals1, + const Mat& corresps, + Mat& AtA, Mat& AtB, CalcICPEquationCoeffsPtr func, int transformDim) +{ + AtA = Mat(transformDim, transformDim, CV_64FC1, Scalar(0)); + AtB = Mat(transformDim, 1, CV_64FC1, Scalar(0)); + double* AtB_ptr = AtB.ptr(); + + const int correspsCount = corresps.rows; + + CV_Assert(Rt.type() == CV_64FC1); + const double * Rt_ptr = Rt.ptr(); + + AutoBuffer diffs(correspsCount); + float * diffs_ptr = diffs; + + AutoBuffer transformedPoints0(correspsCount); + Point3f * tps0_ptr = transformedPoints0; + + const Vec4i* corresps_ptr = corresps.ptr(); + + double sigma = 0; + for(int correspIndex = 0; correspIndex < corresps.rows; correspIndex++) + { + const Vec4i& c = corresps_ptr[correspIndex]; + int u0 = c[0], v0 = c[1]; + int u1 = c[2], v1 = c[3]; + + const Point3f& p0 = cloud0.at(v0,u0); + Point3f tp0; + tp0.x = p0.x * Rt_ptr[0] + p0.y * Rt_ptr[1] + p0.z * Rt_ptr[2] + Rt_ptr[3]; + tp0.y = p0.x * Rt_ptr[4] + p0.y * Rt_ptr[5] + p0.z * Rt_ptr[6] + Rt_ptr[7]; + tp0.z = p0.x * Rt_ptr[8] + p0.y * Rt_ptr[9] + p0.z * Rt_ptr[10] + Rt_ptr[11]; + + Vec3f n1 = normals1.at(v1, u1); + Point3f v = cloud1.at(v1,u1) - tp0; + + tps0_ptr[correspIndex] = tp0; + diffs_ptr[correspIndex] = n1[0] * v.x + n1[1] * v.y + n1[2] * v.z; + sigma += diffs_ptr[correspIndex] * diffs_ptr[correspIndex]; + } + + sigma = std::sqrt(sigma/correspsCount); + + std::vector A_buf(transformDim); + double* A_ptr = &A_buf[0]; + for(int correspIndex = 0; correspIndex < corresps.rows; correspIndex++) + { + const Vec4i& c = corresps_ptr[correspIndex]; + int u1 = c[2], v1 = c[3]; + + double w = sigma + std::abs(diffs_ptr[correspIndex]); + w = w > DBL_EPSILON ? 1./w : 1.; + + func(A_ptr, tps0_ptr[correspIndex], normals1.at(v1, u1) * w); + + for(int y = 0; y < transformDim; y++) + { + double* AtA_ptr = AtA.ptr(y); + for(int x = y; x < transformDim; x++) + AtA_ptr[x] += A_ptr[y] * A_ptr[x]; + + AtB_ptr[y] += A_ptr[y] * w * diffs_ptr[correspIndex]; + } + } + + for(int y = 0; y < transformDim; y++) + for(int x = y+1; x < transformDim; x++) + AtA.at(x,y) = AtA.at(y,x); +} + +static +bool solveSystem(const Mat& AtA, const Mat& AtB, double detThreshold, Mat& x) +{ + double det = cv::determinant(AtA); + + if(fabs (det) < detThreshold || cvIsNaN(det) || cvIsInf(det)) + return false; + + cv::solve(AtA, AtB, x, DECOMP_CHOLESKY); + + return true; +} + +static +bool testDeltaTransformation(const Mat& deltaRt, double maxTranslation, double maxRotation) +{ + double translation = norm(deltaRt(Rect(3, 0, 1, 3))); + + Mat rvec; + Rodrigues(deltaRt(Rect(0,0,3,3)), rvec); + + double rotation = norm(rvec) * 180. / CV_PI; + + return translation <= maxTranslation && rotation <= maxRotation; +} + +static +bool RGBDICPOdometryImpl(Mat& Rt, const Mat& initRt, + const Ptr& srcFrame, + const Ptr& dstFrame, + const cv::Mat& cameraMatrix, + float maxDepthDiff, const std::vector& iterCounts, + double maxTranslation, double maxRotation, + int method, int transfromType) +{ + int transformDim = -1; + CalcRgbdEquationCoeffsPtr rgbdEquationFuncPtr = 0; + CalcICPEquationCoeffsPtr icpEquationFuncPtr = 0; + switch(transfromType) + { + case Odometry::RIGID_BODY_MOTION: + transformDim = 6; + rgbdEquationFuncPtr = calcRgbdEquationCoeffs; + icpEquationFuncPtr = calcICPEquationCoeffs; + break; + case Odometry::ROTATION: + transformDim = 3; + rgbdEquationFuncPtr = calcRgbdEquationCoeffsRotation; + icpEquationFuncPtr = calcICPEquationCoeffsRotation; + break; + case Odometry::TRANSLATION: + transformDim = 3; + rgbdEquationFuncPtr = calcRgbdEquationCoeffsTranslation; + icpEquationFuncPtr = calcICPEquationCoeffsTranslation; + break; + default: + CV_Error(CV_StsBadArg, "Incorrect transformation type"); + } + + const int minOverdetermScale = 20; + const int minCorrespsCount = minOverdetermScale * transformDim; + + std::vector pyramidCameraMatrix; + buildPyramidCameraMatrix(cameraMatrix, iterCounts.size(), pyramidCameraMatrix); + + Mat resultRt = initRt.empty() ? Mat::eye(4,4,CV_64FC1) : initRt.clone(); + Mat currRt, ksi; + + bool isOk = false; + for(int level = iterCounts.size() - 1; level >= 0; level--) + { + const Mat& levelCameraMatrix = pyramidCameraMatrix[level]; + const Mat& levelCameraMatrix_inv = levelCameraMatrix.inv(DECOMP_SVD); + const Mat& srcLevelDepth = srcFrame->pyramidDepth[level]; + const Mat& dstLevelDepth = dstFrame->pyramidDepth[level]; + + const double fx = levelCameraMatrix.at(0,0); + const double fy = levelCameraMatrix.at(1,1); + const double determinantThreshold = 1e-6; + + Mat AtA_rgbd, AtB_rgbd, AtA_icp, AtB_icp; + Mat corresps_rgbd, corresps_icp; + + // Run transformation search on current level iteratively. + for(int iter = 0; iter < iterCounts[level]; iter ++) + { + Mat resultRt_inv = resultRt.inv(DECOMP_SVD); + + if(method & RGBD_ODOMETRY) + computeCorresps(levelCameraMatrix, levelCameraMatrix_inv, resultRt_inv, + srcLevelDepth, srcFrame->pyramidMask[level], dstLevelDepth, dstFrame->pyramidTexturedMask[level], + maxDepthDiff, corresps_rgbd); + + if(method & ICP_ODOMETRY) + computeCorresps(levelCameraMatrix, levelCameraMatrix_inv, resultRt_inv, + srcLevelDepth, srcFrame->pyramidMask[level], dstLevelDepth, dstFrame->pyramidNormalsMask[level], + maxDepthDiff, corresps_icp); + + if(corresps_rgbd.rows < minCorrespsCount && corresps_icp.rows < minCorrespsCount) + break; + + Mat AtA(transformDim, transformDim, CV_64FC1, Scalar(0)), AtB(transformDim, 1, CV_64FC1, Scalar(0)); + if(corresps_rgbd.rows >= minCorrespsCount) + { + calcRgbdLsmMatrices(srcFrame->pyramidImage[level], srcFrame->pyramidCloud[level], resultRt, + dstFrame->pyramidImage[level], dstFrame->pyramid_dI_dx[level], dstFrame->pyramid_dI_dy[level], + corresps_rgbd, fx, fy, sobelScale, + AtA_rgbd, AtB_rgbd, rgbdEquationFuncPtr, transformDim); + + AtA += AtA_rgbd; + AtB += AtB_rgbd; + } + if(corresps_icp.rows >= minCorrespsCount) + { + calcICPLsmMatrices(srcFrame->pyramidCloud[level], resultRt, + dstFrame->pyramidCloud[level], dstFrame->pyramidNormals[level], + corresps_icp, AtA_icp, AtB_icp, icpEquationFuncPtr, transformDim); + AtA += AtA_icp; + AtB += AtB_icp; + } + + bool solutionExist = solveSystem(AtA, AtB, determinantThreshold, ksi); + if(!solutionExist) + break; + + if(transfromType == Odometry::ROTATION) + { + Mat tmp(6, 1, CV_64FC1, Scalar(0)); + ksi.copyTo(tmp.rowRange(0,3)); + ksi = tmp; + } + else if(transfromType == Odometry::TRANSLATION) + { + Mat tmp(6, 1, CV_64FC1, Scalar(0)); + ksi.copyTo(tmp.rowRange(3,6)); + ksi = tmp; + } + + computeProjectiveMatrix(ksi, currRt); + resultRt = currRt * resultRt; + isOk = true; + } + } + + Rt = resultRt; + + if(isOk) + { + Mat deltaRt; + if(initRt.empty()) + deltaRt = resultRt; + else + deltaRt = resultRt * initRt.inv(DECOMP_SVD); + + isOk = testDeltaTransformation(deltaRt, maxTranslation, maxRotation); + } + + return isOk; +} + +template +static void +warpFrameImpl(const cv::Mat& image, const Mat& depth, const Mat& mask, + const Mat& Rt, const Mat& cameraMatrix, const Mat& distCoeff, + Mat& warpedImage, Mat* warpedDepth, Mat* warpedMask) +{ + CV_Assert(image.size() == depth.size()); + + Mat cloud; + depthTo3d(depth, cameraMatrix, cloud); + + std::vector points2d; + Mat transformedCloud; + perspectiveTransform(cloud, transformedCloud, Rt); + projectPoints(transformedCloud.reshape(3, 1), Mat::eye(3, 3, CV_64FC1), Mat::zeros(3, 1, CV_64FC1), cameraMatrix, + distCoeff, points2d); + + warpedImage = Mat(image.size(), image.type(), Scalar::all(0)); + + Mat zBuffer(image.size(), CV_32FC1, std::numeric_limits::max()); + const Rect rect = Rect(0, 0, image.cols, image.rows); + + for (int y = 0; y < image.rows; y++) + { + //const Point3f* cloud_row = cloud.ptr(y); + const Point3f* transformedCloud_row = transformedCloud.ptr(y); + const Point2f* points2d_row = &points2d[y*image.cols]; + const ImageElemType* image_row = image.ptr(y); + const uchar* mask_row = mask.empty() ? 0 : mask.ptr(y); + for (int x = 0; x < image.cols; x++) + { + const float transformed_z = transformedCloud_row[x].z; + const Point2i p2d = points2d_row[x]; + if((!mask_row || mask_row[x]) && transformed_z > 0 && rect.contains(p2d) && /*!cvIsNaN(cloud_row[x].z) && */zBuffer.at(p2d) > transformed_z) + { + warpedImage.at(p2d) = image_row[x]; + zBuffer.at(p2d) = transformed_z; + } + } + } + + if(warpedMask) + *warpedMask = zBuffer != std::numeric_limits::max(); + + if(warpedDepth) + { + zBuffer.setTo(std::numeric_limits::quiet_NaN(), zBuffer == std::numeric_limits::max()); + *warpedDepth = zBuffer; + } +} + +/////////////////////////////////////////////////////////////////////////////////////////////// + +namespace cv +{ + +RgbdFrame::RgbdFrame() : ID(-1) +{} + +RgbdFrame::RgbdFrame(const Mat& image_in, const Mat& depth_in, const Mat& mask_in, const Mat& normals_in, int ID_in) + : ID(ID_in), image(image_in), depth(depth_in), mask(mask_in), normals(normals_in) +{} + +RgbdFrame::~RgbdFrame() +{} + +void RgbdFrame::release() +{ + ID = -1; + image.release(); + depth.release(); + mask.release(); + normals.release(); +} + +OdometryFrame::OdometryFrame() : RgbdFrame() +{} + +OdometryFrame::OdometryFrame(const Mat& image_in, const Mat& depth_in, const Mat& mask_in, const Mat& normals_in, int ID_in) + : RgbdFrame(image_in, depth_in, mask_in, normals_in, ID_in) +{} + +void OdometryFrame::release() +{ + RgbdFrame::release(); + releasePyramids(); +} + +void OdometryFrame::releasePyramids() +{ + pyramidImage.clear(); + pyramidDepth.clear(); + pyramidMask.clear(); + + pyramidCloud.clear(); + + pyramid_dI_dx.clear(); + pyramid_dI_dy.clear(); + pyramidTexturedMask.clear(); + + pyramidNormals.clear(); + pyramidNormalsMask.clear(); +} + +bool Odometry::compute(const Mat& srcImage, const Mat& srcDepth, const Mat& srcMask, + const Mat& dstImage, const Mat& dstDepth, const Mat& dstMask, + Mat& Rt, const Mat& initRt) const +{ + Ptr srcFrame(new OdometryFrame(srcImage, srcDepth, srcMask)); + Ptr dstFrame(new OdometryFrame(dstImage, dstDepth, dstMask)); + + return compute(srcFrame, dstFrame, Rt, initRt); +} + +bool Odometry::compute(Ptr& srcFrame, Ptr& dstFrame, Mat& Rt, const Mat& initRt) const +{ + checkParams(); + + Size srcSize = prepareFrameCache(srcFrame, OdometryFrame::CACHE_SRC); + Size dstSize = prepareFrameCache(dstFrame, OdometryFrame::CACHE_DST); + + if(srcSize != dstSize) + CV_Error(CV_StsBadSize, "srcFrame and dstFrame have to have the same size (resolution)."); + + return computeImpl(srcFrame, dstFrame, Rt, initRt); +} + +Size Odometry::prepareFrameCache(Ptr &frame, int /*cacheType*/) const +{ + if(frame == 0) + CV_Error(CV_StsBadArg, "Null frame pointer.\n"); + + return Size(); +} + +// +RgbdOdometry::RgbdOdometry() : + minDepth(DEFAULT_MIN_DEPTH()), + maxDepth(DEFAULT_MAX_DEPTH()), + maxDepthDiff(DEFAULT_MAX_DEPTH_DIFF()), + maxPointsPart(DEFAULT_MAX_POINTS_PART()), + transformType(Odometry::RIGID_BODY_MOTION), + maxTranslation(DEFAULT_MAX_TRANSLATION()), + maxRotation(DEFAULT_MAX_ROTATION()) + +{ + setDefaultIterCounts(iterCounts); + setDefaultMinGradientMagnitudes(minGradientMagnitudes); +} + +RgbdOdometry::RgbdOdometry(const Mat& _cameraMatrix, + float _minDepth, float _maxDepth, float _maxDepthDiff, + const std::vector& _iterCounts, + const std::vector& _minGradientMagnitudes, + float _maxPointsPart, + int _transformType) : + minDepth(_minDepth), maxDepth(_maxDepth), maxDepthDiff(_maxDepthDiff), + iterCounts(Mat(_iterCounts).clone()), + minGradientMagnitudes(Mat(_minGradientMagnitudes).clone()), + maxPointsPart(_maxPointsPart), + cameraMatrix(_cameraMatrix), transformType(_transformType), + maxTranslation(DEFAULT_MAX_TRANSLATION()), maxRotation(DEFAULT_MAX_ROTATION()) +{ + if(iterCounts.empty() || minGradientMagnitudes.empty()) + { + setDefaultIterCounts(iterCounts); + setDefaultMinGradientMagnitudes(minGradientMagnitudes); + } +} + +Size RgbdOdometry::prepareFrameCache(Ptr& frame, int cacheType) const +{ + Odometry::prepareFrameCache(frame, cacheType); + + if(frame->image.empty()) + { + if(!frame->pyramidImage.empty()) + frame->image = frame->pyramidImage[0]; + else + CV_Error(CV_StsBadSize, "Image or pyramidImage have to be set."); + } + checkImage(frame->image); + + if(frame->depth.empty()) + { + if(!frame->pyramidDepth.empty()) + frame->depth = frame->pyramidDepth[0]; + else if(!frame->pyramidCloud.empty()) + { + Mat cloud = frame->pyramidCloud[0]; + std::vector xyz; + cv::split(cloud, xyz); + frame->depth = xyz[2]; + } + else + CV_Error(CV_StsBadSize, "Depth or pyramidDepth or pyramidCloud have to be set."); + } + checkDepth(frame->depth, frame->image.size()); + + if(frame->mask.empty() && !frame->pyramidMask.empty()) + frame->mask = frame->pyramidMask[0]; + checkMask(frame->mask, frame->image.size()); + + preparePyramidImage(frame->image, frame->pyramidImage, iterCounts.total()); + + preparePyramidDepth(frame->depth, frame->pyramidDepth, iterCounts.total()); + + preparePyramidMask(frame->mask, frame->pyramidDepth, minDepth, maxDepth, + frame->pyramidNormals, frame->pyramidMask); + + if(cacheType & OdometryFrame::CACHE_SRC) + preparePyramidCloud(frame->pyramidDepth, cameraMatrix, frame->pyramidCloud); + + if(cacheType & OdometryFrame::CACHE_DST) + { + preparePyramidSobel(frame->pyramidImage, 1, 0, frame->pyramid_dI_dx); + preparePyramidSobel(frame->pyramidImage, 0, 1, frame->pyramid_dI_dy); + preparePyramidTexturedMask(frame->pyramid_dI_dx, frame->pyramid_dI_dy, minGradientMagnitudes, + frame->pyramidMask, maxPointsPart, frame->pyramidTexturedMask); + } + + return frame->image.size(); +} + +void RgbdOdometry::checkParams() const +{ + CV_Assert(maxPointsPart > 0. && maxPointsPart <= 1.); + CV_Assert(cameraMatrix.size() == Size(3,3) && (cameraMatrix.type() == CV_32FC1 || cameraMatrix.type() == CV_64FC1)); + CV_Assert(minGradientMagnitudes.size() == iterCounts.size() || minGradientMagnitudes.size() == iterCounts.t().size()); +} + +bool RgbdOdometry::computeImpl(const Ptr& srcFrame, const Ptr& dstFrame, Mat& Rt, const Mat& initRt) const +{ + return RGBDICPOdometryImpl(Rt, initRt, srcFrame, dstFrame, cameraMatrix, maxDepthDiff, iterCounts, maxTranslation, maxRotation, RGBD_ODOMETRY, transformType); +} + +// +ICPOdometry::ICPOdometry() : + minDepth(DEFAULT_MIN_DEPTH()), maxDepth(DEFAULT_MAX_DEPTH()), + maxDepthDiff(DEFAULT_MAX_DEPTH_DIFF()), maxPointsPart(DEFAULT_MAX_POINTS_PART()), transformType(Odometry::RIGID_BODY_MOTION), + maxTranslation(DEFAULT_MAX_TRANSLATION()), maxRotation(DEFAULT_MAX_ROTATION()) +{ + setDefaultIterCounts(iterCounts); +} + +ICPOdometry::ICPOdometry(const Mat& _cameraMatrix, + float _minDepth, float _maxDepth, float _maxDepthDiff, + float _maxPointsPart, const std::vector& _iterCounts, + int _transformType) : + minDepth(_minDepth), maxDepth(_maxDepth), maxDepthDiff(_maxDepthDiff), + maxPointsPart(_maxPointsPart), iterCounts(Mat(_iterCounts).clone()), + cameraMatrix(_cameraMatrix), transformType(_transformType), + maxTranslation(DEFAULT_MAX_TRANSLATION()), maxRotation(DEFAULT_MAX_ROTATION()) +{ + if(iterCounts.empty()) + setDefaultIterCounts(iterCounts); +} + +Size ICPOdometry::prepareFrameCache(Ptr& frame, int cacheType) const +{ + Odometry::prepareFrameCache(frame, cacheType); + + if(frame->depth.empty()) + { + if(!frame->pyramidDepth.empty()) + frame->depth = frame->pyramidDepth[0]; + else if(!frame->pyramidCloud.empty()) + { + Mat cloud = frame->pyramidCloud[0]; + std::vector xyz; + cv::split(cloud, xyz); + frame->depth = xyz[2]; + } + else + CV_Error(CV_StsBadSize, "Depth or pyramidDepth or pyramidCloud have to be set."); + } + checkDepth(frame->depth, frame->depth.size()); + + if(frame->mask.empty() && !frame->pyramidMask.empty()) + frame->mask = frame->pyramidMask[0]; + checkMask(frame->mask, frame->depth.size()); + + preparePyramidDepth(frame->depth, frame->pyramidDepth, iterCounts.total()); + + preparePyramidCloud(frame->pyramidDepth, cameraMatrix, frame->pyramidCloud); + + if(cacheType & OdometryFrame::CACHE_DST) + { + if(frame->normals.empty()) + { + if(!frame->pyramidNormals.empty()) + frame->normals = frame->pyramidNormals[0]; + else + { + if(normalsComputer.empty() || + normalsComputer->get("rows") != frame->depth.rows || + normalsComputer->get("cols") != frame->depth.cols || + cv::norm(normalsComputer->get("K"), cameraMatrix) > FLT_EPSILON) + normalsComputer = cv::Ptr(new RgbdNormals(frame->depth.rows, frame->depth.cols, frame->depth.depth(), cameraMatrix, normalWinSize, normalMethod)); + + (*normalsComputer)(frame->pyramidCloud[0], frame->normals); + } + } + checkNormals(frame->normals, frame->depth.size()); + + preparePyramidNormals(frame->normals, frame->pyramidDepth, frame->pyramidNormals); + + preparePyramidMask(frame->mask, frame->pyramidDepth, minDepth, maxDepth, + frame->pyramidNormals, frame->pyramidMask); + + preparePyramidNormalsMask(frame->pyramidNormals, frame->pyramidMask, maxPointsPart, frame->pyramidNormalsMask); + } + else + preparePyramidMask(frame->mask, frame->pyramidDepth, minDepth, maxDepth, + frame->pyramidNormals, frame->pyramidMask); + + return frame->depth.size(); +} + +void ICPOdometry::checkParams() const +{ + CV_Assert(maxPointsPart > 0. && maxPointsPart <= 1.); + CV_Assert(cameraMatrix.size() == Size(3,3) && (cameraMatrix.type() == CV_32FC1 || cameraMatrix.type() == CV_64FC1)); +} + +bool ICPOdometry::computeImpl(const Ptr& srcFrame, const Ptr& dstFrame, Mat& Rt, const Mat& initRt) const +{ + return RGBDICPOdometryImpl(Rt, initRt, srcFrame, dstFrame, cameraMatrix, maxDepthDiff, iterCounts, maxTranslation, maxRotation, ICP_ODOMETRY, transformType); +} + +// +RgbdICPOdometry::RgbdICPOdometry() : + minDepth(DEFAULT_MIN_DEPTH()), maxDepth(DEFAULT_MAX_DEPTH()), + maxDepthDiff(DEFAULT_MAX_DEPTH_DIFF()), maxPointsPart(DEFAULT_MAX_POINTS_PART()), transformType(Odometry::RIGID_BODY_MOTION), + maxTranslation(DEFAULT_MAX_TRANSLATION()), maxRotation(DEFAULT_MAX_ROTATION()) +{ + setDefaultIterCounts(iterCounts); + setDefaultMinGradientMagnitudes(minGradientMagnitudes); +} + +RgbdICPOdometry::RgbdICPOdometry(const Mat& _cameraMatrix, + float _minDepth, float _maxDepth, float _maxDepthDiff, + float _maxPointsPart, const std::vector& _iterCounts, + const std::vector& _minGradientMagnitudes, + int _transformType) : + minDepth(_minDepth), maxDepth(_maxDepth), maxDepthDiff(_maxDepthDiff), + maxPointsPart(_maxPointsPart), iterCounts(Mat(_iterCounts).clone()), + minGradientMagnitudes(Mat(_minGradientMagnitudes).clone()), + cameraMatrix(_cameraMatrix), transformType(_transformType), + maxTranslation(DEFAULT_MAX_TRANSLATION()), maxRotation(DEFAULT_MAX_ROTATION()) +{ + if(iterCounts.empty() || minGradientMagnitudes.empty()) + { + setDefaultIterCounts(iterCounts); + setDefaultMinGradientMagnitudes(minGradientMagnitudes); + } +} + +Size RgbdICPOdometry::prepareFrameCache(Ptr& frame, int cacheType) const +{ + if(frame->image.empty()) + { + if(!frame->pyramidImage.empty()) + frame->image = frame->pyramidImage[0]; + else + CV_Error(CV_StsBadSize, "Image or pyramidImage have to be set."); + } + checkImage(frame->image); + + if(frame->depth.empty()) + { + if(!frame->pyramidDepth.empty()) + frame->depth = frame->pyramidDepth[0]; + else if(!frame->pyramidCloud.empty()) + { + Mat cloud = frame->pyramidCloud[0]; + std::vector xyz; + cv::split(cloud, xyz); + frame->depth = xyz[2]; + } + else + CV_Error(CV_StsBadSize, "Depth or pyramidDepth or pyramidCloud have to be set."); + } + checkDepth(frame->depth, frame->image.size()); + + if(frame->mask.empty() && !frame->pyramidMask.empty()) + frame->mask = frame->pyramidMask[0]; + checkMask(frame->mask, frame->image.size()); + + preparePyramidImage(frame->image, frame->pyramidImage, iterCounts.total()); + + preparePyramidDepth(frame->depth, frame->pyramidDepth, iterCounts.total()); + + preparePyramidCloud(frame->pyramidDepth, cameraMatrix, frame->pyramidCloud); + + if(cacheType & OdometryFrame::CACHE_DST) + { + if(frame->normals.empty()) + { + if(!frame->pyramidNormals.empty()) + frame->normals = frame->pyramidNormals[0]; + else + { + if(normalsComputer.empty() || + normalsComputer->get("rows") != frame->depth.rows || + normalsComputer->get("cols") != frame->depth.cols || + cv::norm(normalsComputer->get("K"), cameraMatrix) > FLT_EPSILON) + normalsComputer = cv::Ptr(new RgbdNormals(frame->depth.rows, frame->depth.cols, frame->depth.depth(), cameraMatrix, normalWinSize, normalMethod)); + + (*normalsComputer)(frame->pyramidCloud[0], frame->normals); + } + } + checkNormals(frame->normals, frame->depth.size()); + + preparePyramidNormals(frame->normals, frame->pyramidDepth, frame->pyramidNormals); + + preparePyramidMask(frame->mask, frame->pyramidDepth, minDepth, maxDepth, + frame->pyramidNormals, frame->pyramidMask); + + preparePyramidSobel(frame->pyramidImage, 1, 0, frame->pyramid_dI_dx); + preparePyramidSobel(frame->pyramidImage, 0, 1, frame->pyramid_dI_dy); + preparePyramidTexturedMask(frame->pyramid_dI_dx, frame->pyramid_dI_dy, + minGradientMagnitudes, frame->pyramidMask, + maxPointsPart, frame->pyramidTexturedMask); + + preparePyramidNormalsMask(frame->pyramidNormals, frame->pyramidMask, maxPointsPart, frame->pyramidNormalsMask); + } + else + preparePyramidMask(frame->mask, frame->pyramidDepth, minDepth, maxDepth, + frame->pyramidNormals, frame->pyramidMask); + + return frame->image.size(); +} + +void RgbdICPOdometry::checkParams() const +{ + CV_Assert(maxPointsPart > 0. && maxPointsPart <= 1.); + CV_Assert(cameraMatrix.size() == Size(3,3) && (cameraMatrix.type() == CV_32FC1 || cameraMatrix.type() == CV_64FC1)); + CV_Assert(minGradientMagnitudes.size() == iterCounts.size() || minGradientMagnitudes.size() == iterCounts.t().size()); +} + +bool RgbdICPOdometry::computeImpl(const Ptr& srcFrame, const Ptr& dstFrame, Mat& Rt, const Mat& initRt) const +{ + return RGBDICPOdometryImpl(Rt, initRt, srcFrame, dstFrame, cameraMatrix, maxDepthDiff, iterCounts, maxTranslation, maxRotation, MERGED_ODOMETRY, transformType); +} + +// + +void +warpFrame(const Mat& image, const Mat& depth, const Mat& mask, + const Mat& Rt, const Mat& cameraMatrix, const Mat& distCoeff, + Mat& warpedImage, Mat* warpedDepth, Mat* warpedMask) +{ + if(image.type() == CV_8UC1) + warpFrameImpl(image, depth, mask, Rt, cameraMatrix, distCoeff, warpedImage, warpedDepth, warpedMask); + else if(image.type() == CV_8UC3) + warpFrameImpl >(image, depth, mask, Rt, cameraMatrix, distCoeff, warpedImage, warpedDepth, warpedMask); + else + CV_Error(CV_StsBadArg, "Image has to be type of CV_8UC1 or CV_8UC3"); +} +} // namespace cv diff --git a/modules/rgbd/src/plane.cpp b/modules/rgbd/src/plane.cpp new file mode 100644 index 000000000..3a56c4d9c --- /dev/null +++ b/modules/rgbd/src/plane.cpp @@ -0,0 +1,641 @@ +/* + * Software License Agreement (BSD License) + * + * Copyright (c) 2012, Willow Garage, Inc. + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions 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. + * * Neither the name of Willow Garage, Inc. nor the names of its + * contributors may 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 + * COPYRIGHT OWNER 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. + * + */ + +/** This is an implementation of a fast plane detection loosely inspired by + * Fast Plane Detection and Polygonalization in noisy 3D Range Images + * Jann Poppinga, Narunas Vaskevicius, Andreas Birk, and Kaustubh Pathak + * and the follow-up + * Fast Plane Detection for SLAM from Noisy Range Images in + * Both Structured and Unstructured Environments + * Junhao Xiao, Jianhua Zhang and Jianwei Zhang + * Houxiang Zhang and Hans Petter Hildre + */ + +#include +#include + +#include + +/** Structure defining a plane. The notations are from the second paper */ +class PlaneBase +{ +public: + PlaneBase(const cv::Vec3f & m, const cv::Vec3f &n_in, int index) + : + index_(index), + n_(n_in), + m_sum_(cv::Vec3f(0, 0, 0)), + m_(m), + Q_(cv::Matx33f::zeros()), + mse_(0), + K_(0) + { + UpdateD(); + } + + virtual + ~PlaneBase() + { + } + + /** Compute the distance to the plane. This will be implemented by the children to take into account different + * sensor models + * @param p_j + * @return + */ + virtual + float + distance(const cv::Vec3f& p_j) const = 0; + + /** The d coefficient in the plane equation ax+by+cz+d = 0 + * @return + */ + inline float + d() const + { + return d_; + } + + /** The normal to the plane + * @return the normal to the plane + */ + const cv::Vec3f & + n() const + { + return n_; + } + + /** Update the different coefficients of the plane, based on the new statistics + */ + void + UpdateParameters() + { + if (empty()) + return; + m_ = m_sum_ / K_; + // Compute C + cv::Matx33f C = Q_ - m_sum_ * m_.t(); + + // Compute n + cv::SVD svd(C); + n_ = cv::Vec3f(svd.vt.at(2, 0), svd.vt.at(2, 1), svd.vt.at(2, 2)); + mse_ = svd.w.at(2) / K_; + + UpdateD(); + } + + /** Update the different sum of point and sum of point*point.t() + */ + void + UpdateStatistics(const cv::Vec3f & point, const cv::Matx33f & Q_local) + { + m_sum_ += point; + Q_ += Q_local; + ++K_; + } + + inline size_t + empty() const + { + return K_ == 0; + } + + inline int + K() const + { + return K_; + } +/** The index of the plane */ + int index_; +protected: + /** The 4th coefficient in the plane equation ax+by+cz+d = 0 */ + float d_; + /** Normal of the plane */ + cv::Vec3f n_; +private: + inline void + UpdateD() + { + d_ = -m_.dot(n_); + } + /** The sum of the points */ + cv::Vec3f m_sum_; + /** The mean of the points */ + cv::Vec3f m_; + /** The sum of pi * pi^\top */ + cv::Matx33f Q_; + /** The different matrices we need to update */ + cv::Matx33f C_; + float mse_; + /** the number of points that form the plane */ + int K_; +}; + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + +/** Basic planar child, with no sensor error model + */ +class Plane: public PlaneBase +{ +public: + Plane(const cv::Vec3f & m, const cv::Vec3f &n_in, int index) + : + PlaneBase(m, n_in, index) + { + } + + /** The computed distance is perfect in that case + * @param p_j the point to compute its distance to + * @return + */ + float + distance(const cv::Vec3f& p_j) const + { + return std::abs(float(p_j.dot(n_) + d_)); + } +}; + +/** Planar child with a quadratic error model + */ +class PlaneABC: public PlaneBase +{ +public: + PlaneABC(const cv::Vec3f & m, const cv::Vec3f &n_in, int index, float sensor_error_a, float sensor_error_b, + float sensor_error_c) + : + PlaneBase(m, n_in, index), + sensor_error_a_(sensor_error_a), + sensor_error_b_(sensor_error_b), + sensor_error_c_(sensor_error_c) + { + } + + /** The distance is now computed by taking the sensor error into account */ + inline + float + distance(const cv::Vec3f& p_j) const + { + float cst = p_j.dot(n_) + d_; + float err = sensor_error_a_ * p_j[2] * p_j[2] + sensor_error_b_ * p_j[2] + sensor_error_c_; + if (((cst - n_[2] * err <= 0) && (cst + n_[2] * err >= 0)) || ((cst + n_[2] * err <= 0) && (cst - n_[2] * err >= 0))) + return 0; + return std::min(std::abs(cst - err), std::abs(cst + err)); + } +private: + float sensor_error_a_; + float sensor_error_b_; + float sensor_error_c_; +}; + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + +/** The PlaneGrid contains statistic about the individual tiles + */ +class PlaneGrid +{ +public: + PlaneGrid(const cv::Mat_ & points3d, int block_size) + : + block_size_(block_size) + { + // Figure out some dimensions + int mini_rows = points3d.rows / block_size; + if (points3d.rows % block_size != 0) + ++mini_rows; + + int mini_cols = points3d.cols / block_size; + if (points3d.cols % block_size != 0) + ++mini_cols; + + // Compute all the interesting quantities + m_.create(mini_rows, mini_cols); + n_.create(mini_rows, mini_cols); + Q_.create(points3d.rows, points3d.cols); + mse_.create(mini_rows, mini_cols); + for (int y = 0; y < mini_rows; ++y) + for (int x = 0; x < mini_cols; ++x) + { + // Update the tiles + cv::Matx33f Q = cv::Matx33f::zeros(); + cv::Vec3f m = cv::Vec3f(0, 0, 0); + int K = 0; + for (int j = y * block_size; j < std::min((y + 1) * block_size, points3d.rows); ++j) + { + const cv::Vec3f * vec = points3d.ptr < cv::Vec3f > (j, x * block_size), *vec_end; + float * pointpointt = reinterpret_cast(Q_.ptr < cv::Vec > (j, x * block_size)); + if (x == mini_cols - 1) + vec_end = points3d.ptr < cv::Vec3f > (j, points3d.cols - 1) + 1; + else + vec_end = vec + block_size; + for (; vec != vec_end; ++vec, pointpointt += 9) + { + if (cvIsNaN(vec->val[0])) + continue; + // Fill point*point.t() + *pointpointt = vec->val[0] * vec->val[0]; + *(pointpointt + 1) = vec->val[0] * vec->val[1]; + *(pointpointt + 2) = vec->val[0] * vec->val[2]; + *(pointpointt + 3) = *(pointpointt + 1); + *(pointpointt + 4) = vec->val[1] * vec->val[1]; + *(pointpointt + 5) = vec->val[1] * vec->val[2]; + *(pointpointt + 6) = *(pointpointt + 2); + *(pointpointt + 7) = *(pointpointt + 5); + *(pointpointt + 8) = vec->val[2] * vec->val[2]; + + Q += *reinterpret_cast(pointpointt); + m += (*vec); + ++K; + } + } + if (K == 0) + { + mse_(y, x) = std::numeric_limits::max(); + continue; + } + + m /= K; + m_(y, x) = m; + + // Compute C + cv::Matx33f C = Q - K * m * m.t(); + + // Compute n + cv::SVD svd(C); + n_(y, x) = cv::Vec3f(svd.vt.at(2, 0), svd.vt.at(2, 1), svd.vt.at(2, 2)); + mse_(y, x) = svd.w.at(2) / K; + } + } + + /** The size of the block */ + int block_size_; + cv::Mat_ m_; + cv::Mat_ n_; + cv::Mat_ > Q_; + cv::Mat_ mse_; +}; + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + +class TileQueue +{ +public: + struct PlaneTile + { + PlaneTile(int x, int y, float mse) + : + x_(x), + y_(y), + mse_(mse) + { + } + + bool + operator<(const PlaneTile &tile2) const + { + return mse_ < tile2.mse_; + } + + int x_; + int y_; + float mse_; + }; + + TileQueue(const PlaneGrid &plane_grid) + { + done_tiles_ = cv::Mat_::zeros(plane_grid.mse_.rows, plane_grid.mse_.cols); + tiles_.clear(); + for (int y = 0; y < plane_grid.mse_.rows; ++y) + for (int x = 0; x < plane_grid.mse_.cols; ++x) + if (plane_grid.mse_(y, x) != std::numeric_limits::max()) + // Update the tiles + tiles_.push_back(PlaneTile(x, y, plane_grid.mse_(y, x))); + // Sort tiles by MSE + tiles_.sort(); + } + + bool + empty() + { + while (!tiles_.empty()) + { + const PlaneTile & tile = tiles_.front(); + if (done_tiles_(tile.y_, tile.x_)) + tiles_.pop_front(); + else + break; + } + return tiles_.empty(); + } + + const PlaneTile & + front() const + { + return tiles_.front(); + } + + void + remove(int y, int x) + { + done_tiles_(y, x) = 1; + } +private: + /** The list of tiles ordered from most planar to least */ + std::list tiles_; + /** contains 1 when the tiles has been studied, 0 otherwise */ + cv::Mat_ done_tiles_; +}; + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + +class InlierFinder +{ +public: + InlierFinder(float err, const cv::Mat_ & points3d, const cv::Mat_ & normals, + unsigned char plane_index, int block_size) + : + err_(err), + points3d_(points3d), + normals_(normals), + plane_index_(plane_index), + block_size_(block_size) + { + } + + void + Find(const PlaneGrid &plane_grid, cv::Ptr & plane, TileQueue & tile_queue, + std::set & neighboring_tiles, cv::Mat_ & overall_mask, + cv::Mat_ & plane_mask) + { + // Do not use reference as we pop the from later on + TileQueue::PlaneTile tile = *(neighboring_tiles.begin()); + + // Figure the part of the image to look at + cv::Range range_x, range_y; + int x = tile.x_ * block_size_, y = tile.y_ * block_size_; + + if (tile.x_ == plane_mask.cols - 1) + range_x = cv::Range(x, overall_mask.cols); + else + range_x = cv::Range(x, x + block_size_); + + if (tile.y_ == plane_mask.rows - 1) + range_y = cv::Range(y, overall_mask.rows); + else + range_y = cv::Range(y, y + block_size_); + + int n_valid_points = 0; + for (int yy = range_y.start; yy != range_y.end; ++yy) + { + uchar* data = overall_mask.ptr(yy, range_x.start), *data_end = data + range_x.size(); + const cv::Vec3f* point = points3d_.ptr < cv::Vec3f > (yy, range_x.start); + const cv::Matx33f* Q_local = reinterpret_cast(plane_grid.Q_.ptr < cv::Vec + > (yy, range_x.start)); + + // Depending on whether you have a normal, check it + if (!normals_.empty()) + { + const cv::Vec3f* normal = normals_.ptr < cv::Vec3f > (yy, range_x.start); + for (; data != data_end; ++data, ++point, ++normal, ++Q_local) + { + // Don't do anything if the point already belongs to another plane + if (cvIsNaN(point->val[0]) || ((*data) != 255)) + continue; + + // If the point is close enough to the plane + if (plane->distance(*point) < err_) + { + // make sure the normals are similar to the plane + if (std::abs(plane->n().dot(*normal)) > 0.3) + { + // The point now belongs to the plane + plane->UpdateStatistics(*point, *Q_local); + *data = plane_index_; + ++n_valid_points; + } + } + } + } + else + { + for (; data != data_end; ++data, ++point, ++Q_local) + { + // Don't do anything if the point already belongs to another plane + if (cvIsNaN(point->val[0]) || ((*data) != 255)) + continue; + + // If the point is close enough to the plane + if (plane->distance(*point) < err_) + { + // The point now belongs to the plane + plane->UpdateStatistics(*point, *Q_local); + *data = plane_index_; + ++n_valid_points; + } + } + } + } + + plane->UpdateParameters(); + + // Mark the front as being done and pop it + if (n_valid_points > (range_x.size() * range_y.size()) / 2) + tile_queue.remove(tile.y_, tile.x_); + plane_mask(tile.y_, tile.x_) = 1; + neighboring_tiles.erase(neighboring_tiles.begin()); + + // Add potential neighbors of the tile + std::vector > pairs; + if (tile.x_ > 0) + for (unsigned char * val = overall_mask.ptr(range_y.start, range_x.start), *val_end = val + + range_y.size() * overall_mask.step; val != val_end; val += overall_mask.step) + if (*val == plane_index_) + { + pairs.push_back(std::pair(tile.x_ - 1, tile.y_)); + break; + } + if (tile.x_ < plane_mask.cols - 1) + for (unsigned char * val = overall_mask.ptr(range_y.start, range_x.end - 1), *val_end = val + + range_y.size() * overall_mask.step; val != val_end; val += overall_mask.step) + if (*val == plane_index_) + { + pairs.push_back(std::pair(tile.x_ + 1, tile.y_)); + break; + } + if (tile.y_ > 0) + for (unsigned char * val = overall_mask.ptr(range_y.start, range_x.start), *val_end = val + + range_x.size(); val != val_end; ++val) + if (*val == plane_index_) + { + pairs.push_back(std::pair(tile.x_, tile.y_ - 1)); + break; + } + if (tile.y_ < plane_mask.rows - 1) + for (unsigned char * val = overall_mask.ptr(range_y.end - 1, range_x.start), *val_end = val + + range_x.size(); val != val_end; ++val) + if (*val == plane_index_) + { + pairs.push_back(std::pair(tile.x_, tile.y_ + 1)); + break; + } + + for (unsigned char i = 0; i < pairs.size(); ++i) + if (!plane_mask(pairs[i].second, pairs[i].first)) + neighboring_tiles.insert( + TileQueue::PlaneTile(pairs[i].first, pairs[i].second, plane_grid.mse_(pairs[i].second, pairs[i].first))); + } + +private: + float err_; + const cv::Mat_ & points3d_; + const cv::Mat_ & normals_; + unsigned char plane_index_; + /** THe block size as defined in the main algorithm */ + int block_size_; +} +; + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + +namespace cv +{ + void + RgbdPlane::operator()(InputArray points3d_in, OutputArray mask_out, OutputArray plane_coefficients) + { + this->operator()(points3d_in, cv::Mat(), mask_out, plane_coefficients); + } + + void + RgbdPlane::operator()(InputArray points3d_in, InputArray normals_in, OutputArray mask_out, + OutputArray plane_coefficients_out) + { + cv::Mat_ points3d, normals; + if (points3d_in.depth() == CV_32F) + points3d = points3d_in.getMat(); + else + points3d_in.getMat().convertTo(points3d, CV_32F); + if (!normals_in.empty()) + { + if (normals_in.depth() == CV_32F) + normals = normals_in.getMat(); + else + normals_in.getMat().convertTo(normals, CV_32F); + } + + // Pre-computations + mask_out.create(points3d.size(), CV_8U); + cv::Mat mask_out_mat = mask_out.getMat(); + cv::Mat_ mask_out_uc = (cv::Mat_&) mask_out_mat; + mask_out_uc.setTo(255); + PlaneGrid plane_grid(points3d, block_size_); + TileQueue plane_queue(plane_grid); + size_t index_plane = 0; + + std::vector plane_coefficients; + float mse_min = threshold_ * threshold_; + + while (!plane_queue.empty()) + { + // Get the first tile if it's good enough + const TileQueue::PlaneTile front_tile = plane_queue.front(); + if (front_tile.mse_ > mse_min) + break; + + InlierFinder inlier_finder(threshold_, points3d, normals, index_plane, block_size_); + + // Construct the plane for the first tile + int x = front_tile.x_, y = front_tile.y_; + const cv::Vec3f & n = plane_grid.n_(y, x); + cv::Ptr plane; + if ((sensor_error_a_ == 0) && (sensor_error_b_ == 0) && (sensor_error_c_ == 0)) + plane = cv::Ptr(new Plane(plane_grid.m_(y, x), n, index_plane)); + else + plane = cv::Ptr(new PlaneABC(plane_grid.m_(y, x), n, index_plane, sensor_error_a_, sensor_error_b_, sensor_error_c_)); + + cv::Mat_ plane_mask = cv::Mat_::zeros(points3d.rows / block_size_, + points3d.cols / block_size_); + std::set neighboring_tiles; + neighboring_tiles.insert(front_tile); + plane_queue.remove(front_tile.y_, front_tile.x_); + + // Process all the neighboring tiles + while (!neighboring_tiles.empty()) + inlier_finder.Find(plane_grid, plane, plane_queue, neighboring_tiles, mask_out_uc, plane_mask); + + // Don't record the plane if it's empty + if (plane->empty()) + continue; + // Don't record the plane if it's smaller than asked + if (plane->K() < min_size_) { + // Reset the plane index in the mask + for (y = 0; y < plane_mask.rows; ++y) + for (x = 0; x < plane_mask.cols; ++x) { + if (!plane_mask(y, x)) + continue; + // Go over the tile + for (int yy = y * block_size_; + yy < std::min((y + 1) * block_size_, mask_out_uc.rows); ++yy) { + uchar* data = mask_out_uc.ptr(yy, x * block_size_); + uchar* data_end = data + + std::min(block_size_, + mask_out_uc.cols - x * block_size_); + for (; data != data_end; ++data) { + if (*data == index_plane) + *data = 255; + } + } + } + continue; + } + + ++index_plane; + if (index_plane >= 255) + break; + cv::Vec4f coeffs(plane->n()[0], plane->n()[1], plane->n()[2], plane->d()); + if (coeffs(2) > 0) + coeffs = -coeffs; + plane_coefficients.push_back(coeffs); + }; + + // Fill the plane coefficients + if (plane_coefficients.empty()) + return; + plane_coefficients_out.create(plane_coefficients.size(), 1, CV_32FC4); + cv::Mat plane_coefficients_mat = plane_coefficients_out.getMat(); + float* data = plane_coefficients_mat.ptr(0); + for(size_t i=0; i +#include +#include "opencv2/core/utility.hpp" +#include "opencv2/core/private.hpp" + +namespace cv +{ + CV_INIT_ALGORITHM(DepthCleaner, "RGBD.DepthCleaner", + obj.info()->addParam(obj, "window_size", obj.window_size_); + obj.info()->addParam(obj, "depth", obj.depth_); + obj.info()->addParam(obj, "method", obj.method_)) + + CV_INIT_ALGORITHM(RgbdNormals, "RGBD.RgbdNormals", + obj.info()->addParam(obj, "rows", obj.rows_); + obj.info()->addParam(obj, "cols", obj.cols_); + obj.info()->addParam(obj, "window_size", obj.window_size_); + obj.info()->addParam(obj, "depth", obj.depth_); + obj.info()->addParam(obj, "K", obj.K_); + obj.info()->addParam(obj, "method", obj.method_)) + + CV_INIT_ALGORITHM(RgbdPlane, "RGBD.RgbdPlane", + obj.info()->addParam(obj, "block_size", obj.block_size_); + obj.info()->addParam(obj, "min_size", obj.min_size_); + obj.info()->addParam(obj, "method", obj.method_); + obj.info()->addParam(obj, "threshold", obj.threshold_); + obj.info()->addParam(obj, "sensor_error_a", obj.sensor_error_a_); + obj.info()->addParam(obj, "sensor_error_b", obj.sensor_error_b_); + obj.info()->addParam(obj, "sensor_error_c", obj.sensor_error_c_)) + + CV_INIT_ALGORITHM(RgbdOdometry, "RGBD.RgbdOdometry", + obj.info()->addParam(obj, "cameraMatrix", obj.cameraMatrix); + obj.info()->addParam(obj, "minDepth", obj.minDepth); + obj.info()->addParam(obj, "maxDepth", obj.maxDepth); + obj.info()->addParam(obj, "maxDepthDiff", obj.maxDepthDiff); + obj.info()->addParam(obj, "iterCounts", obj.iterCounts); + obj.info()->addParam(obj, "minGradientMagnitudes", obj.minGradientMagnitudes); + obj.info()->addParam(obj, "maxPointsPart", obj.maxPointsPart); + obj.info()->addParam(obj, "transformType", obj.transformType); + obj.info()->addParam(obj, "maxTranslation", obj.maxTranslation); + obj.info()->addParam(obj, "maxRotation", obj.maxRotation);) + + CV_INIT_ALGORITHM(ICPOdometry, "RGBD.ICPOdometry", + obj.info()->addParam(obj, "cameraMatrix", obj.cameraMatrix); + obj.info()->addParam(obj, "minDepth", obj.minDepth); + obj.info()->addParam(obj, "maxDepth", obj.maxDepth); + obj.info()->addParam(obj, "maxDepthDiff", obj.maxDepthDiff); + obj.info()->addParam(obj, "maxPointsPart", obj.maxPointsPart); + obj.info()->addParam(obj, "iterCounts", obj.iterCounts); + obj.info()->addParam(obj, "transformType", obj.transformType); + obj.info()->addParam(obj, "maxTranslation", obj.maxTranslation); + obj.info()->addParam(obj, "maxRotation", obj.maxRotation); + obj.info()->addParam(obj, "normalsComputer", obj.normalsComputer, true);) + + CV_INIT_ALGORITHM(RgbdICPOdometry, "RGBD.RgbdICPOdometry", + obj.info()->addParam(obj, "cameraMatrix", obj.cameraMatrix); + obj.info()->addParam(obj, "minDepth", obj.minDepth); + obj.info()->addParam(obj, "maxDepth", obj.maxDepth); + obj.info()->addParam(obj, "maxDepthDiff", obj.maxDepthDiff); + obj.info()->addParam(obj, "maxPointsPart", obj.maxPointsPart); + obj.info()->addParam(obj, "iterCounts", obj.iterCounts); + obj.info()->addParam(obj, "minGradientMagnitudes", obj.minGradientMagnitudes); + obj.info()->addParam(obj, "transformType", obj.transformType); + obj.info()->addParam(obj, "maxTranslation", obj.maxTranslation); + obj.info()->addParam(obj, "maxRotation", obj.maxRotation); + obj.info()->addParam(obj, "normalsComputer", obj.normalsComputer, true);) + + bool + initModule_rgbd(void); + bool + initModule_rgbd(void) + { + bool all = true; + all &= !RgbdNormals_info_auto.name().empty(); + all &= !RgbdPlane_info_auto.name().empty(); + all &= !RgbdOdometry_info_auto.name().empty(); + all &= !ICPOdometry_info_auto.name().empty(); + all &= !RgbdICPOdometry_info_auto.name().empty(); + return all; + } +} diff --git a/modules/rgbd/src/utils.cpp b/modules/rgbd/src/utils.cpp new file mode 100644 index 000000000..e2be065cd --- /dev/null +++ b/modules/rgbd/src/utils.cpp @@ -0,0 +1,77 @@ +/* + * Software License Agreement (BSD License) + * + * Copyright (c) 2009, Willow Garage, Inc. + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions 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. + * * Neither the name of Willow Garage, Inc. nor the names of its + * contributors may 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 + * COPYRIGHT OWNER 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. + * + */ + +#include +#include + +#include "utils.h" + +namespace cv +{ + /** 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::quiet_NaN() + * Otherwise, the image is simply converted to floats + * @param in_in the depth image (if given as short int CV_U, it is assumed to be the depth in millimeters + * (as done with the Microsoft Kinect), it is assumed in meters) + * @param depth the desired output depth (floats or double) + * @param out_out The rescaled float depth image + */ + void + rescaleDepth(InputArray in_in, int depth, OutputArray out_out) + { + cv::Mat in = in_in.getMat(); + CV_Assert(in.type() == CV_64FC1 || in.type() == CV_32FC1 || in.type() == CV_16UC1 || in.type() == CV_16SC1); + CV_Assert(depth == CV_64FC1 || depth == CV_32FC1); + + int in_depth = in.depth(); + + out_out.create(in.size(), depth); + cv::Mat out = out_out.getMat(); + if (in_depth == CV_16U) + { + in.convertTo(out, depth, 1 / 1000.0); //convert to float so that it is in meters + cv::Mat valid_mask = in == std::numeric_limits::min(); // Should we do std::numeric_limits::max() too ? + out.setTo(std::numeric_limits::quiet_NaN(), valid_mask); //set a$ + } + if (in_depth == CV_16S) + { + in.convertTo(out, depth, 1 / 1000.0); //convert to float so tha$ + cv::Mat valid_mask = (in == std::numeric_limits::min()) | (in == std::numeric_limits::max()); // Should we do std::numeric_limits::max() too ? + out.setTo(std::numeric_limits::quiet_NaN(), valid_mask); //set a$ + } + if ((in_depth == CV_32F) || (in_depth == CV_64F)) + in.convertTo(out, depth); + } +} diff --git a/modules/rgbd/src/utils.h b/modules/rgbd/src/utils.h new file mode 100644 index 000000000..8d4bc2e89 --- /dev/null +++ b/modules/rgbd/src/utils.h @@ -0,0 +1,73 @@ +/* + * Software License Agreement (BSD License) + * + * Copyright (c) 2009, Willow Garage, Inc. + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions 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. + * * Neither the name of Willow Garage, Inc. nor the names of its + * contributors may 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 + * COPYRIGHT OWNER 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. + * + */ + +#ifndef __OPENCV_RGBD_UTILS_HPP__ +#define __OPENCV_RGBD_UTILS_HPP__ + +#ifdef __cplusplus + +#include + +/** 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::quiet_NaN() + * Otherwise, the image is simply converted to floats + * @param in the depth image (if given as short int CV_U, it is assumed to be the depth in millimeters + * (as done with the Microsoft Kinect), it is assumed in meters) + * @param the desired output depth (floats or double) + * @param out The rescaled float depth image + */ +template +void +rescaleDepthTemplated(const cv::Mat& in, cv::Mat& out); + +template<> +inline void +rescaleDepthTemplated(const cv::Mat& in, cv::Mat& out) +{ + rescaleDepth(in, CV_32F, out); +} + +template<> +inline void +rescaleDepthTemplated(const cv::Mat& in, cv::Mat& out) +{ + rescaleDepth(in, CV_64F, out); +} + +#endif /* __cplusplus */ + +#endif + +/* End of file. */ diff --git a/modules/rgbd/test/test_main.cpp b/modules/rgbd/test/test_main.cpp new file mode 100644 index 000000000..d66d0ffc9 --- /dev/null +++ b/modules/rgbd/test/test_main.cpp @@ -0,0 +1,3 @@ +#include "test_precomp.hpp" + +CV_TEST_MAIN("rgbd") diff --git a/modules/rgbd/test/test_normal.cpp b/modules/rgbd/test/test_normal.cpp new file mode 100644 index 000000000..2bf1f7f4f --- /dev/null +++ b/modules/rgbd/test/test_normal.cpp @@ -0,0 +1,415 @@ +/* + * Software License Agreement (BSD License) + * + * Copyright (c) 2012, Willow Garage, Inc. + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions 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. + * * Neither the name of Willow Garage, Inc. nor the names of its + * contributors may 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 + * COPYRIGHT OWNER 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. + * + */ + +#include + +#include +#include + +#include "test_precomp.hpp" + +cv::Point3f +rayPlaneIntersection(cv::Point2f uv, const cv::Mat& centroid, const cv::Mat& normal, const cv::Mat_& Kinv); + +cv::Vec3f +rayPlaneIntersection(const cv::Vec3d& uv1, double centroid_dot_normal, const cv::Vec3d& normal, + const cv::Matx33d& Kinv); +cv::Vec3f +rayPlaneIntersection(const cv::Vec3d& uv1, double centroid_dot_normal, const cv::Vec3d& normal, const cv::Matx33d& Kinv) +{ + + cv::Matx31d L = Kinv * uv1; //a ray passing through camera optical center + //and uv. + L = L * (1.0 / cv::norm(L)); + double LdotNormal = L.dot(normal); + double d; + if (std::fabs(LdotNormal) > 1e-9) + { + d = centroid_dot_normal / LdotNormal; + } + else + { + d = 1.0; + std::cout << "warning, LdotNormal nearly 0! " << LdotNormal << std::endl; + std::cout << "contents of L, Normal: " << cv::Mat(L) << ", " << cv::Mat(normal) << std::endl; + } + cv::Vec3f xyz(d * L(0), d * L(1), d * L(2)); + return xyz; +} + +cv::Point3f +rayPlaneIntersection(cv::Point2f uv, const cv::Mat& centroid, const cv::Mat& normal, const cv::Mat_& Kinv) +{ + cv::Matx33d dKinv(Kinv); + cv::Vec3d dNormal(normal); + return rayPlaneIntersection(cv::Vec3d(uv.x, uv.y, 1), centroid.dot(normal), dNormal, dKinv); +} + +const int W = 640; +const int H = 480; +int window_size = 5; +float focal_length = 525; +float cx = W / 2.f + 0.5f; +float cy = H / 2.f + 0.5f; + +cv::Mat K = (cv::Mat_(3, 3) << focal_length, 0, cx, 0, focal_length, cy, 0, 0, 1); +cv::Mat Kinv = K.inv(); + +static cv::RNG rng; +struct Plane +{ + + cv::Vec3d n, p; + double p_dot_n; + Plane() + { + n[0] = rng.uniform(-0.5, 0.5); + n[1] = rng.uniform(-0.5, 0.5); + n[2] = -0.3; //rng.uniform(-1.f, 0.5f); + n = n / cv::norm(n); + set_d(rng.uniform(-2.0, 0.6)); + } + + void + set_d(float d) + { + p = cv::Vec3d(0, 0, d / n[2]); + p_dot_n = p.dot(n); + } + + cv::Vec3f + intersection(float u, float v, const cv::Matx33f& Kinv_in) const + { + return rayPlaneIntersection(cv::Vec3d(u, v, 1), p_dot_n, n, Kinv_in); + } +}; + +void +gen_points_3d(std::vector& planes_out, cv::Mat_ &plane_mask, cv::Mat& points3d, cv::Mat& normals, + int n_planes); +void +gen_points_3d(std::vector& planes_out, cv::Mat_ &plane_mask, cv::Mat& points3d, cv::Mat& normals, + int n_planes) +{ + std::vector planes; + for (int i = 0; i < n_planes; i++) + { + Plane px; + for (int j = 0; j < 1; j++) + { + px.set_d(rng.uniform(-3.f, -0.5f)); + planes.push_back(px); + } + } + cv::Mat_ < cv::Vec3f > outp(H, W); + cv::Mat_ < cv::Vec3f > outn(H, W); + plane_mask.create(H, W); + + // n ( r - r_0) = 0 + // n * r_0 = d + // + // r_0 = (0,0,0) + // r[0] + for (int v = 0; v < H; v++) + { + for (int u = 0; u < W; u++) + { + unsigned int plane_index = (u / float(W)) * planes.size(); + Plane plane = planes[plane_index]; + outp(v, u) = plane.intersection(u, v, Kinv); + outn(v, u) = plane.n; + plane_mask(v, u) = plane_index; + } + } + planes_out = planes; + points3d = outp; + normals = outn; +} + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + +class CV_RgbdNormalsTest: public cvtest::BaseTest +{ +public: + CV_RgbdNormalsTest() + { + } + ~CV_RgbdNormalsTest() + { + } +protected: + void + run(int) + { + try + { + cv::Mat_ plane_mask; + for (unsigned char i = 0; i < 3; ++i) + { + cv::RgbdNormals::RGBD_NORMALS_METHOD method; + // inner vector: whether it's 1 plane or 3 planes + // outer vector: float or double + std::vector > errors(2); + errors[0].resize(2); + errors[1].resize(2); + switch (i) + { + case 0: + method = cv::RgbdNormals::RGBD_NORMALS_METHOD_FALS; + std::cout << std::endl << "*** FALS" << std::endl; + errors[0][0] = 0.006; + errors[0][1] = 0.03; + errors[1][0] = 0.00008; + errors[1][1] = 0.02; + break; + case 1: + method = cv::RgbdNormals::RGBD_NORMALS_METHOD_LINEMOD; + std::cout << std::endl << "*** LINEMOD" << std::endl; + errors[0][0] = 0.04; + errors[0][1] = 0.07; + errors[1][0] = 0.05; + errors[1][1] = 0.08; + break; + case 2: + method = cv::RgbdNormals::RGBD_NORMALS_METHOD_SRI; + std::cout << std::endl << "*** SRI" << std::endl; + errors[0][0] = 0.02; + errors[0][1] = 0.04; + errors[1][0] = 0.02; + errors[1][1] = 0.04; + break; + } + + for (unsigned char j = 0; j < 2; ++j) + { + int depth = (j % 2 == 0) ? CV_32F : CV_64F; + if (depth == CV_32F) + std::cout << "* float" << std::endl; + else + std::cout << "* double" << std::endl; + + cv::RgbdNormals normals_computer(H, W, depth, K, 5, method); + normals_computer.initialize(); + + std::vector plane_params; + cv::Mat points3d, ground_normals; + // 1 plane, continuous scene, very low error.. + std::cout << "1 plane" << std::endl; + float err_mean = 0; + for (int ii = 0; ii < 5; ++ii) + { + gen_points_3d(plane_params, plane_mask, points3d, ground_normals, 1); + err_mean += testit(points3d, ground_normals, normals_computer); + } + std::cout << "mean diff: " << (err_mean / 5) << std::endl; + EXPECT_LE(err_mean/5, errors[j][0])<< " thresh: " << errors[j][0] << std::endl; + + // 3 discontinuities, more error expected. + std::cout << "3 planes" << std::endl; + err_mean = 0; + for (int ii = 0; ii < 5; ++ii) + { + gen_points_3d(plane_params, plane_mask, points3d, ground_normals, 3); + err_mean += testit(points3d, ground_normals, normals_computer); + } + std::cout << "mean diff: " << (err_mean / 5) << std::endl; + EXPECT_LE(err_mean/5, errors[j][1])<< "mean diff: " << (err_mean/5) << " thresh: " << errors[j][1] << std::endl; + } + } + + //TODO test NaNs in data + + } catch (...) + { + ts->set_failed_test_info(cvtest::TS::FAIL_MISMATCH); + } + ts->set_failed_test_info(cvtest::TS::OK); + } + + float + testit(const cv::Mat & points3d, const cv::Mat & in_ground_normals, const cv::RgbdNormals & normals_computer) + { + cv::TickMeter tm; + tm.start(); + cv::Mat in_normals; + if (normals_computer.method() == cv::RgbdNormals::RGBD_NORMALS_METHOD_LINEMOD) + { + std::vector channels; + cv::split(points3d, channels); + normals_computer(channels[2], in_normals); + } + else + normals_computer(points3d, in_normals); + tm.stop(); + + cv::Mat_ normals, ground_normals; + in_normals.convertTo(normals, CV_32FC3); + in_ground_normals.convertTo(ground_normals, CV_32FC3); + + float err = 0; + for (int y = 0; y < normals.rows; ++y) + for (int x = 0; x < normals.cols; ++x) + { + cv::Vec3f vec1 = normals(y, x), vec2 = ground_normals(y, x); + vec1 = vec1 / cv::norm(vec1); + vec2 = vec2 / cv::norm(vec2); + + float dot = vec1.dot(vec2); + // Just for rounding errors + if (std::abs(dot) < 1) + err += std::min(std::acos(dot), std::acos(-dot)); + } + + err /= normals.rows * normals.cols; + std::cout << "Average error: " << err << " Speed: " << tm.getTimeMilli() << " ms" << std::endl; + return err; + } +}; + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + +class CV_RgbdPlaneTest: public cvtest::BaseTest +{ +public: + CV_RgbdPlaneTest() + { + } + ~CV_RgbdPlaneTest() + { + } +protected: + void + run(int) + { + try + { + cv::RgbdPlane plane_computer; + + std::vector planes; + cv::Mat points3d, ground_normals; + cv::Mat_ plane_mask; + gen_points_3d(planes, plane_mask, points3d, ground_normals, 1); + testit(planes, plane_mask, points3d, plane_computer); // 1 plane, continuous scene, very low error.. + for (int ii = 0; ii < 10; ii++) + { + gen_points_3d(planes, plane_mask, points3d, ground_normals, 3); //three planes + testit(planes, plane_mask, points3d, plane_computer); // 3 discontinuities, more error expected. + } + } catch (...) + { + ts->set_failed_test_info(cvtest::TS::FAIL_MISMATCH); + } + ts->set_failed_test_info(cvtest::TS::OK); + } + + void + testit(const std::vector & gt_planes, const cv::Mat & gt_plane_mask, const cv::Mat & points3d, + cv::RgbdPlane & plane_computer) + { + for (char i_test = 0; i_test < 2; ++i_test) + { + cv::TickMeter tm1, tm2; + cv::Mat plane_mask; + std::vector plane_coefficients; + + if (i_test == 0) + { + tm1.start(); + // First, get the normals + int depth = CV_32F; + cv::RgbdNormals normals_computer(H, W, depth, K, 5, cv::RgbdNormals::RGBD_NORMALS_METHOD_FALS); + cv::Mat normals; + normals_computer(points3d, normals); + tm1.stop(); + + tm2.start(); + plane_computer(points3d, normals, plane_mask, plane_coefficients); + tm2.stop(); + } + else + { + tm2.start(); + plane_computer(points3d, plane_mask, plane_coefficients); + tm2.stop(); + } + + // Compare each found plane to each ground truth plane + size_t n_planes = plane_coefficients.size(); + size_t n_gt_planes = gt_planes.size(); + cv::Mat_ matching(n_gt_planes, n_planes); + for (size_t j = 0; j < n_gt_planes; ++j) + { + cv::Mat gt_mask = gt_plane_mask == j; + int n_gt = cv::countNonZero(gt_mask); + int n_max = 0, i_max = 0; + for (size_t i = 0; i < n_planes; ++i) + { + cv::Mat dst; + cv::bitwise_and(gt_mask, plane_mask == i, dst); + matching(j, i) = cv::countNonZero(dst); + if (matching(j, i) > n_max) + { + n_max = matching(j, i); + i_max = i; + } + } + // Get the best match + ASSERT_LE(float(n_max - n_gt) / n_gt, 0.001); + // Compare the normals + cv::Vec3d normal(plane_coefficients[i_max][0], plane_coefficients[i_max][1], plane_coefficients[i_max][2]); + ASSERT_GE(std::abs(gt_planes[j].n.dot(normal)), 0.95); + } + + std::cout << " Speed: "; + if (i_test == 0) + std::cout << "normals " << tm1.getTimeMilli() << " ms and "; + std::cout << "plane " << tm2.getTimeMilli() << " ms " << std::endl; + } + } +}; + +//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + +TEST(Rgbd_Normals, compute) +{ + CV_RgbdNormalsTest test; + test.safe_run(); +} + +TEST(Rgbd_Plane, compute) +{ + CV_RgbdPlaneTest test; + test.safe_run(); +} diff --git a/modules/rgbd/test/test_odometry.cpp b/modules/rgbd/test/test_odometry.cpp new file mode 100644 index 000000000..8fd723a96 --- /dev/null +++ b/modules/rgbd/test/test_odometry.cpp @@ -0,0 +1,350 @@ +/* + * Software License Agreement (BSD License) + * + * Copyright (c) 2012, Willow Garage, Inc. + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions 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. + * * Neither the name of Willow Garage, Inc. nor the names of its + * contributors may 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 + * COPYRIGHT OWNER 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. + * + */ + +#include +#include +#include + +#include "test_precomp.hpp" + +using namespace cv; + +#define SHOW_DEBUG_LOG 0 +#define SHOW_DEBUG_IMAGES 0 + +static +void warpFrame(const Mat& image, const Mat& depth, const Mat& rvec, const Mat& tvec, const Mat& K, + Mat& warpedImage, Mat& warpedDepth) +{ + CV_Assert(!image.empty()); + CV_Assert(image.type() == CV_8UC1); + + CV_Assert(depth.size() == image.size()); + CV_Assert(depth.type() == CV_32FC1); + + CV_Assert(!rvec.empty()); + CV_Assert(rvec.total() == 3); + CV_Assert(rvec.type() == CV_64FC1); + + CV_Assert(!tvec.empty()); + CV_Assert(tvec.size() == Size(1, 3)); + CV_Assert(tvec.type() == CV_64FC1); + + warpedImage.create(image.size(), CV_8UC1); + warpedImage = Scalar(0); + warpedDepth.create(image.size(), CV_32FC1); + warpedDepth = Scalar(FLT_MAX); + + Mat cloud; + depthTo3d(depth, K, cloud); + Mat Rt = Mat::eye(4, 4, CV_64FC1); + { + Mat R, dst; + Rodrigues(rvec, R); + + dst = Rt(Rect(0,0,3,3)); + R.copyTo(dst); + + dst = Rt(Rect(3,0,1,3)); + tvec.copyTo(dst); + } + Mat warpedCloud, warpedImagePoints; + perspectiveTransform(cloud, warpedCloud, Rt); + projectPoints(warpedCloud.reshape(3, 1), Mat(3,1,CV_32FC1, Scalar(0)), Mat(3,1,CV_32FC1, Scalar(0)), K, Mat(1,5,CV_32FC1, Scalar(0)), warpedImagePoints); + warpedImagePoints = warpedImagePoints.reshape(2, cloud.rows); + Rect r(0, 0, image.cols, image.rows); + for(int y = 0; y < cloud.rows; y++) + { + for(int x = 0; x < cloud.cols; x++) + { + Point p = warpedImagePoints.at(y,x); + if(r.contains(p)) + { + float curDepth = warpedDepth.at(p.y, p.x); + float newDepth = warpedCloud.at(y, x).z; + if(newDepth < curDepth && newDepth > 0) + { + warpedImage.at(p.y, p.x) = image.at(y,x); + warpedDepth.at(p.y, p.x) = newDepth; + } + } + } + } + warpedDepth.setTo(std::numeric_limits::quiet_NaN(), warpedDepth > 100); +} + +static +void dilateFrame(Mat& image, Mat& depth) +{ + CV_Assert(!image.empty()); + CV_Assert(image.type() == CV_8UC1); + + CV_Assert(!depth.empty()); + CV_Assert(depth.type() == CV_32FC1); + CV_Assert(depth.size() == image.size()); + + Mat mask(image.size(), CV_8UC1, Scalar(255)); + for(int y = 0; y < depth.rows; y++) + for(int x = 0; x < depth.cols; x++) + if(cvIsNaN(depth.at(y,x)) || depth.at(y,x) > 10 || depth.at(y,x) <= FLT_EPSILON) + mask.at(y,x) = 0; + + image.setTo(255, ~mask); + Mat minImage; + erode(image, minImage, Mat()); + + image.setTo(0, ~mask); + Mat maxImage; + dilate(image, maxImage, Mat()); + + depth.setTo(FLT_MAX, ~mask); + Mat minDepth; + erode(depth, minDepth, Mat()); + + depth.setTo(0, ~mask); + Mat maxDepth; + dilate(depth, maxDepth, Mat()); + + Mat dilatedMask; + dilate(mask, dilatedMask, Mat(), Point(-1,-1), 1); + for(int y = 0; y < depth.rows; y++) + for(int x = 0; x < depth.cols; x++) + if(!mask.at(y,x) && dilatedMask.at(y,x)) + { + image.at(y,x) = static_cast(0.5f * (static_cast(minImage.at(y,x)) + + static_cast(maxImage.at(y,x)))); + depth.at(y,x) = 0.5f * (minDepth.at(y,x) + maxDepth.at(y,x)); + } +} + +class CV_OdometryTest : public cvtest::BaseTest +{ +public: + CV_OdometryTest(const Ptr& _odometry, + double _maxError1, + double _maxError5) : + odometry(_odometry), + maxError1(_maxError1), + maxError5(_maxError5) {} + +protected: + bool readData(Mat& image, Mat& depth) const; + static void generateRandomTransformation(Mat& R, Mat& t); + + virtual void run(int); + + Ptr odometry; + double maxError1; + double maxError5; +}; + +bool CV_OdometryTest::readData(Mat& image, Mat& depth) const +{ + std::string imageFilename = std::string(ts->get_data_path()) + "/odometry/rgb.png"; + std::string depthFilename = std::string(ts->get_data_path()) + "/odometry/depth.png"; + + image = imread(imageFilename, 0); + depth = imread(depthFilename, -1); + + if(image.empty()) + { + ts->printf( cvtest::TS::LOG, "Image %s can not be read.\n", imageFilename.c_str() ); + ts->set_failed_test_info( cvtest::TS::FAIL_INVALID_TEST_DATA ); + return false; + } + if(depth.empty()) + { + ts->printf( cvtest::TS::LOG, "Depth %s can not be read.\n", depthFilename.c_str() ); + ts->set_failed_test_info( cvtest::TS::FAIL_INVALID_TEST_DATA ); + ts->set_gtest_status(); + return false; + } + + CV_DbgAssert(gray.type() == CV_8UC1); + CV_DbgAssert(depth.type() == CV_16UC1); + { + Mat depth_flt; + depth.convertTo(depth_flt, CV_32FC1, 1.f/5000.f); + depth_flt.setTo(std::numeric_limits::quiet_NaN(), depth_flt < FLT_EPSILON); + depth = depth_flt; + } + + return true; +} + +void CV_OdometryTest::generateRandomTransformation(Mat& rvec, Mat& tvec) +{ + const float maxRotation = 3.f / 180.f * CV_PI; //rad + const float maxTranslation = 0.02f; //m + + RNG& rng = theRNG(); + rvec.create(3, 1, CV_64FC1); + tvec.create(3, 1, CV_64FC1); + + randu(rvec, Scalar(-1000), Scalar(1000)); + normalize(rvec, rvec, rng.uniform(0.007f, maxRotation)); + + randu(tvec, Scalar(-1000), Scalar(1000)); + normalize(tvec, tvec, rng.uniform(0.007f, maxTranslation)); +} + +void CV_OdometryTest::run(int) +{ + float fx = 525.0f, // default + fy = 525.0f, + cx = 319.5f, + cy = 239.5f; + Mat K = Mat::eye(3,3,CV_32FC1); + { + K.at(0,0) = fx; + K.at(1,1) = fy; + K.at(0,2) = cx; + K.at(1,2) = cy; + } + + Mat image, depth; + if(!readData(image, depth)) + return; + + odometry->set("cameraMatrix", K); + + Mat calcRt; + + // 1. Try to find Rt between the same frame (try masks also). + bool isComputed = odometry->compute(image, depth, Mat(image.size(), CV_8UC1, Scalar(255)), + image, depth, Mat(image.size(), CV_8UC1, Scalar(255)), + calcRt); + if(!isComputed) + { + ts->printf(cvtest::TS::LOG, "Can not find Rt between the same frame"); + ts->set_failed_test_info(cvtest::TS::FAIL_INVALID_OUTPUT); + } + double diff = norm(calcRt, Mat::eye(4,4,CV_64FC1)); + if(diff > DBL_EPSILON) + { + ts->printf(cvtest::TS::LOG, "Incorrect transformation between the same frame (not the identity matrix), diff = %f", diff); + ts->set_failed_test_info(cvtest::TS::FAIL_BAD_ACCURACY); + } + + // 2. Generate random rigid body motion in some ranges several times (iterCount). + // On each iteration an input frame is warped using generated transformation. + // Odometry is run on the following pair: the original frame and the warped one. + // Comparing a computed transformation with an applied one we compute 2 errors: + // better_1time_count - count of poses which error is less than ground thrush pose, + // better_5times_count - count of poses which error is 5 times less than ground thrush pose. + int iterCount = 100; + int better_1time_count = 0; + int better_5times_count = 0; + for(int iter = 0; iter < iterCount; iter++) + { + Mat rvec, tvec; + generateRandomTransformation(rvec, tvec); + Mat warpedImage, warpedDepth; + warpFrame(image, depth, rvec, tvec, K, warpedImage, warpedDepth); + dilateFrame(warpedImage, warpedDepth); // due to inaccuracy after warping + + isComputed = odometry->compute(image, depth, Mat(), warpedImage, warpedDepth, Mat(), calcRt); + if(!isComputed) + continue; + + Mat calcR = calcRt(Rect(0,0,3,3)), calcRvec; + Rodrigues(calcR, calcRvec); + calcRvec = calcRvec.reshape(rvec.channels(), rvec.rows); + Mat calcTvec = calcRt(Rect(3,0,1,3)); + +#if SHOW_DEBUG_IMAGES + imshow("image", image); + imshow("warpedImage", warpedImage); + Mat resultImage, resultDepth; + warpFrame(image, depth, calcRvec, calcTvec, K, resultImage, resultDepth); + imshow("resultImage", resultImage); + waitKey(); +#endif + + + // compare rotation + double rdiffnorm = norm(rvec - calcRvec), + rnorm = norm(rvec); + double tdiffnorm = norm(tvec - calcTvec), + tnorm = norm(tvec); + if(rdiffnorm < rnorm && tdiffnorm < tnorm) + better_1time_count++; + if(5. * rdiffnorm < rnorm && 5 * tdiffnorm < tnorm) + better_5times_count++; + +#if SHOW_DEBUG_LOG + std::cout << "Iter " << iter << std::endl; + std::cout << "rdiffnorm " << rdiffnorm << "; rnorm " << rnorm << std::endl; + std::cout << "tdiffnorm " << tdiffnorm << "; tnorm " << tnorm << std::endl; + + std::cout << "better_1time_count " << better_1time_count << "; better_5time_count " << better_5times_count << std::endl; +#endif + } + + + if(static_cast(better_1time_count) < maxError1 * static_cast(iterCount)) + { + ts->printf(cvtest::TS::LOG, "\nIncorrect count of accurate poses [1st case]: %f / %f", static_cast(better_1time_count), maxError1 * static_cast(iterCount)); + ts->set_failed_test_info(cvtest::TS::FAIL_BAD_ACCURACY); + } + + if(static_cast(better_5times_count) < maxError5 * static_cast(iterCount)) + { + ts->printf(cvtest::TS::LOG, "\nIncorrect count of accurate poses [2nd case]: %f / %f", static_cast(better_5times_count), maxError5 * static_cast(iterCount)); + ts->set_failed_test_info(cvtest::TS::FAIL_BAD_ACCURACY); + } +} + +/****************************************************************************************\ +* Tests registrations * +\****************************************************************************************/ + +TEST(RGBD_Odometry_Rgbd, algorithmic) +{ + CV_OdometryTest test(Algorithm::create("RGBD.RgbdOdometry"), 0.99, 0.94); + test.safe_run(); +} + +TEST(RGBD_Odometry_ICP, algorithmic) +{ + CV_OdometryTest test(Algorithm::create("RGBD.ICPOdometry"), 0.99, 0.99); + test.safe_run(); +} + +TEST(RGBD_Odometry_RgbdICP, algorithmic) +{ + CV_OdometryTest test(Algorithm::create("RGBD.RgbdICPOdometry"), 0.99, 0.99); + test.safe_run(); +} diff --git a/modules/rgbd/test/test_precomp.cpp b/modules/rgbd/test/test_precomp.cpp new file mode 100644 index 000000000..5956e13e3 --- /dev/null +++ b/modules/rgbd/test/test_precomp.cpp @@ -0,0 +1 @@ +#include "test_precomp.hpp" diff --git a/modules/rgbd/test/test_precomp.hpp b/modules/rgbd/test/test_precomp.hpp new file mode 100644 index 000000000..ccf662065 --- /dev/null +++ b/modules/rgbd/test/test_precomp.hpp @@ -0,0 +1,8 @@ +#ifndef __OPENCV_TEST_PRECOMP_HPP__ +#define __OPENCV_TEST_PRECOMP_HPP__ + +#include +#include +#include + +#endif diff --git a/modules/rgbd/test/test_utils.cpp b/modules/rgbd/test/test_utils.cpp new file mode 100644 index 000000000..3bbe03643 --- /dev/null +++ b/modules/rgbd/test/test_utils.cpp @@ -0,0 +1,61 @@ +#include + +#include "test_precomp.hpp" + +class CV_RgbdDepthTo3dTest: public cvtest::BaseTest +{ +public: + CV_RgbdDepthTo3dTest() + { + } + ~CV_RgbdDepthTo3dTest() + { + } +protected: + void + run(int) + { + try + { + // K from a VGA Kinect + cv::Mat K = (cv::Mat_(3, 3) << 525., 0., 319.5, 0., 525., 239.5, 0., 0., 1.); + + // Create a random depth image + cv::RNG rng; + cv::Mat_ depth(480, 640); + rng.fill(depth, cv::RNG::UNIFORM, 0, 100); + + // Create some 3d points on the plane + int rows = depth.rows, cols = depth.cols; + cv::Mat_ points3d; + cv::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_(1,3) << 0, 0, 0); + cv::projectPoints(points, rvec, tvec, K, cv::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 += cv::norm(image_points.at(y,x) - cv::Vec2f(x,y)); + + // Verify the function works + ASSERT_LE(avg_diff/rows/cols, 1e-4) << "Average error for ground truth is: " << (avg_diff / rows / cols); + } catch (...) + { + ts->set_failed_test_info(cvtest::TS::FAIL_MISMATCH); + } + ts->set_failed_test_info(cvtest::TS::OK); + } +}; + +TEST(Rgbd_DepthTo3d, compute) +{ + CV_RgbdDepthTo3dTest test; + test.safe_run(); +} diff --git a/modules/rgbd/testdata/rgbd/odometry/depth.png b/modules/rgbd/testdata/rgbd/odometry/depth.png new file mode 100644 index 0000000000000000000000000000000000000000..dd4364259a2a08bf478c87a0e4f4d919143fa09b GIT binary patch literal 123265 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

=a=Y+6j6QQ=3b8gBQ<)7oi<%etz%!-#<` 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

sOYqe{GR*XM|C1LK({%)M?=iH)9#05+qBr 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%0D0n~v$pu>7X0%ybV2eBq9!8D8 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

U)N{9_`5&*#gCus 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

=y$ExW6wO3K89DTNeBrw!}2+w@$PXiYU)(+pwc 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«eql9j~55I~%4+QNo1X%=B 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 z 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 |!prdBF9Njv%UJ{a5t}Auz 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%0Acn!20;8arNjcd=AqF zY-YoJ+pD~K|HOKr@9i%g8?Xa3((GJyrM8{h&UTaI2;7|51G_^G1q`sXc9WO7)GySl z;hA=(Arg*imT&`Z#Ky6aABImO8Z0~vPs2^PV-?u&f!xpuFB;gerh~?F@mhXs-K&x) z;0D|o59AYF*5yEfO=kyt6*B21PkaU+(Fb`j#1h3xPTPph@N}NWBXD!8g@Qk_W$9c@EC5Mm$`m55%U5)J0}(o5kfoPeB&jSwM#q|K_8BFng7 zfTPyd%jc*W*kyZTpf*Vbz95ayE8xZ%b6l+%1eM{;+cv5BM#;~Zqs_Q1)fNN?ln;z5US82JH?4#59|> z?^_*1{ZKzOg4=)_-0JGQ)Di`Imd>89w!L~7)1WNRhC>c?SV!OjCoI}xJ)6%~6}l|o zff3%rn?B9@ws2oMcfU5y%h!b~`ieS)TO(zq?Plxd$h54u4AbeEUV@1Px3;0*X8nHQ zFYLb%r|eW5hQs*uJVR?C6D(MgB!LzrVr%TkLbY|bgaCs$gd6aLP6e?{*)V}cHML2b zP^LD_WJMk~_ z@3p=cjO9cdWXPpjN_Y`B)6Kx$xtl7~d||(sepCMjaKVo z4^|5eUMsJx+1IKvlNtJ*{o!!Y@pj;C_n&jUUp#gkyPtDiv$w9Tn2B2It+W?T@I-(? z+gf{jfdxx;LM3m(VSxb$yy2k34*JdZ6Z?tn*th)+$Hv|Hw%My!S4kz6;4N<$;6RHl zqhQT`>3%_#y5UW4PQ#){AsPl4u#D-1nvxMtv(>&z8?n*V-cgMf4#&-}|GD@-lfRO` z5=Zx;=C#{Av=%Pucf mIy0epy` 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