diff --git a/modules/rgbd/include/opencv2/rgbd.hpp b/modules/rgbd/include/opencv2/rgbd.hpp old mode 100644 new mode 100755 index e245044c0..83674c042 --- a/modules/rgbd/include/opencv2/rgbd.hpp +++ b/modules/rgbd/include/opencv2/rgbd.hpp @@ -104,12 +104,14 @@ namespace rgbd * ``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 + class CV_EXPORTS_W RgbdNormals: public Algorithm { public: enum RGBD_NORMALS_METHOD { - RGBD_NORMALS_METHOD_FALS, RGBD_NORMALS_METHOD_LINEMOD, RGBD_NORMALS_METHOD_SRI + RGBD_NORMALS_METHOD_FALS = 0, + RGBD_NORMALS_METHOD_LINEMOD = 1, + RGBD_NORMALS_METHOD_SRI = 2 }; RgbdNormals() @@ -133,10 +135,13 @@ namespace rgbd * @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::RGBD_NORMALS_METHOD_FALS); ~RgbdNormals(); + CV_WRAP static Ptr create(int rows, int cols, int depth, InputArray K, int window_size = 5, int method = + RgbdNormals::RGBD_NORMALS_METHOD_FALS); + /** 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 @@ -147,54 +152,54 @@ namespace rgbd /** 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 + CV_WRAP void initialize() const; - int getRows() const + CV_WRAP int getRows() const { return rows_; } - void setRows(int val) + CV_WRAP void setRows(int val) { rows_ = val; } - int getCols() const + CV_WRAP int getCols() const { return cols_; } - void setCols(int val) + CV_WRAP void setCols(int val) { cols_ = val; } - int getWindowSize() const + CV_WRAP int getWindowSize() const { return window_size_; } - void setWindowSize(int val) + CV_WRAP void setWindowSize(int val) { window_size_ = val; } - int getDepth() const + CV_WRAP int getDepth() const { return depth_; } - void setDepth(int val) + CV_WRAP void setDepth(int val) { depth_ = val; } - cv::Mat getK() const + CV_WRAP cv::Mat getK() const { return K_; } - void setK(const cv::Mat &val) + CV_WRAP void setK(const cv::Mat &val) { K_ = val; } - int getMethod() const + CV_WRAP int getMethod() const { return method_; } - void setMethod(int val) + CV_WRAP void setMethod(int val) { method_ = val; } @@ -212,7 +217,7 @@ namespace rgbd /** Object that can clean a noisy depth image */ - class CV_EXPORTS DepthCleaner: public Algorithm + class CV_EXPORTS_W DepthCleaner: public Algorithm { public: /** NIL method is from @@ -238,10 +243,12 @@ namespace rgbd * @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(int depth, int window_size = 5, int method = DepthCleaner::DEPTH_CLEANER_NIL); ~DepthCleaner(); + CV_WRAP static Ptr create(int depth, int window_size = 5, int method = DepthCleaner::DEPTH_CLEANER_NIL); + /** 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 @@ -252,30 +259,30 @@ namespace rgbd /** 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 + CV_WRAP void initialize() const; - int getWindowSize() const + CV_WRAP int getWindowSize() const { return window_size_; } - void setWindowSize(int val) + CV_WRAP void setWindowSize(int val) { window_size_ = val; } - int getDepth() const + CV_WRAP int getDepth() const { return depth_; } - void setDepth(int val) + CV_WRAP void setDepth(int val) { depth_ = val; } - int getMethod() const + CV_WRAP int getMethod() const { return method_; } - void setMethod(int val) + CV_WRAP void setMethod(int val) { method_ = val; } @@ -309,7 +316,7 @@ namespace rgbd * @param registeredDepth the result of transforming the depth into the external camera * @param depthDilation whether or not the depth is dilated to avoid holes and occlusion errors (optional) */ - CV_EXPORTS + CV_EXPORTS_W void registerDepth(InputArray unregisteredCameraMatrix, InputArray registeredCameraMatrix, InputArray registeredDistCoeffs, InputArray Rt, InputArray unregisteredDepth, const Size& outputImagePlaneSize, @@ -321,7 +328,7 @@ namespace rgbd * @param in_points the list of xy coordinates * @param points3d the resulting 3d points */ - CV_EXPORTS + CV_EXPORTS_W void depthTo3dSparse(InputArray depth, InputArray in_K, InputArray in_points, OutputArray points3d); @@ -346,13 +353,13 @@ namespace rgbd * @param depth the desired output depth (floats or double) * @param out The rescaled float depth image */ - CV_EXPORTS + CV_EXPORTS_W void rescaleDepth(InputArray in, int depth, OutputArray out); /** Object that can compute planes in an image */ - class CV_EXPORTS RgbdPlane: public Algorithm + class CV_EXPORTS_W RgbdPlane: public Algorithm { public: enum RGBD_PLANE_METHOD @@ -360,7 +367,7 @@ namespace rgbd RGBD_PLANE_METHOD_DEFAULT }; - RgbdPlane(RGBD_PLANE_METHOD method = RGBD_PLANE_METHOD_DEFAULT) + RgbdPlane(int method = RgbdPlane::RGBD_PLANE_METHOD_DEFAULT) : method_(method), block_size_(40), @@ -393,59 +400,59 @@ namespace rgbd void operator()(InputArray points3d, OutputArray mask, OutputArray plane_coefficients); - int getBlockSize() const + CV_WRAP int getBlockSize() const { return block_size_; } - void setBlockSize(int val) + CV_WRAP void setBlockSize(int val) { block_size_ = val; } - int getMinSize() const + CV_WRAP int getMinSize() const { return min_size_; } - void setMinSize(int val) + CV_WRAP void setMinSize(int val) { min_size_ = val; } - int getMethod() const + CV_WRAP int getMethod() const { return method_; } - void setMethod(int val) + CV_WRAP void setMethod(int val) { method_ = val; } - double getThreshold() const + CV_WRAP double getThreshold() const { return threshold_; } - void setThreshold(double val) + CV_WRAP void setThreshold(double val) { threshold_ = val; } - double getSensorErrorA() const + CV_WRAP double getSensorErrorA() const { return sensor_error_a_; } - void setSensorErrorA(double val) + CV_WRAP void setSensorErrorA(double val) { sensor_error_a_ = val; } - double getSensorErrorB() const + CV_WRAP double getSensorErrorB() const { return sensor_error_b_; } - void setSensorErrorB(double val) + CV_WRAP void setSensorErrorB(double val) { sensor_error_b_ = val; } - double getSensorErrorC() const + CV_WRAP double getSensorErrorC() const { return sensor_error_c_; } - void setSensorErrorC(double val) + CV_WRAP void setSensorErrorC(double val) { sensor_error_c_ = val; } @@ -465,27 +472,29 @@ namespace rgbd /** Object that contains a frame data. */ - struct CV_EXPORTS RgbdFrame + struct CV_EXPORTS_W RgbdFrame { RgbdFrame(); RgbdFrame(const Mat& image, const Mat& depth, const Mat& mask=Mat(), const Mat& normals=Mat(), int ID=-1); virtual ~RgbdFrame(); - virtual void + CV_WRAP static Ptr create(const Mat& image=Mat(), const Mat& depth=Mat(), const Mat& mask=Mat(), const Mat& normals=Mat(), int ID=-1); + + CV_WRAP virtual void release(); - int ID; - Mat image; - Mat depth; - Mat mask; - Mat normals; + CV_PROP int ID; + CV_PROP Mat image; + CV_PROP Mat depth; + CV_PROP Mat mask; + CV_PROP 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 + struct CV_EXPORTS_W 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, @@ -502,29 +511,31 @@ namespace rgbd OdometryFrame(); OdometryFrame(const Mat& image, const Mat& depth, const Mat& mask=Mat(), const Mat& normals=Mat(), int ID=-1); - virtual void + CV_WRAP static Ptr create(const Mat& image=Mat(), const Mat& depth=Mat(), const Mat& mask=Mat(), const Mat& normals=Mat(), int ID=-1); + + CV_WRAP virtual void release(); - void + CV_WRAP void releasePyramids(); - std::vector pyramidImage; - std::vector pyramidDepth; - std::vector pyramidMask; + CV_PROP std::vector pyramidImage; + CV_PROP std::vector pyramidDepth; + CV_PROP std::vector pyramidMask; - std::vector pyramidCloud; + CV_PROP std::vector pyramidCloud; - std::vector pyramid_dI_dx; - std::vector pyramid_dI_dy; - std::vector pyramidTexturedMask; + CV_PROP std::vector pyramid_dI_dx; + CV_PROP std::vector pyramid_dI_dy; + CV_PROP std::vector pyramidTexturedMask; - std::vector pyramidNormals; - std::vector pyramidNormalsMask; + CV_PROP std::vector pyramidNormals; + CV_PROP std::vector pyramidNormalsMask; }; /** Base class for computation of odometry. */ - class CV_EXPORTS Odometry: public Algorithm + class CV_EXPORTS_W Odometry: public Algorithm { public: @@ -534,32 +545,32 @@ namespace rgbd ROTATION = 1, TRANSLATION = 2, RIGID_BODY_MOTION = 4 }; - static inline float + CV_WRAP static inline float DEFAULT_MIN_DEPTH() { return 0.f; // in meters } - static inline float + CV_WRAP static inline float DEFAULT_MAX_DEPTH() { return 4.f; // in meters } - static inline float + CV_WRAP static inline float DEFAULT_MAX_DEPTH_DIFF() { return 0.07f; // in meters } - static inline float + CV_WRAP static inline float DEFAULT_MAX_POINTS_PART() { return 0.07f; // in [0, 1] } - static inline float + CV_WRAP static inline float DEFAULT_MAX_TRANSLATION() { return 0.15f; // in meters } - static inline float + CV_WRAP static inline float DEFAULT_MAX_ROTATION() { return 15; // in degrees @@ -583,15 +594,15 @@ namespace rgbd Rt is 4x4 matrix of CV_64FC1 type. * @param initRt Initial transformation from the source frame to the destination one (optional) */ - bool + CV_WRAP 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; + const Mat& dstMask, OutputArray 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; + CV_WRAP_AS(compute2) bool + compute(Ptr& srcFrame, Ptr& dstFrame, OutputArray 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 @@ -599,32 +610,32 @@ namespace rgbd * @param frame 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; + CV_WRAP virtual Size prepareFrameCache(Ptr& frame, int cacheType) const; - static Ptr create(const String & odometryType); + CV_WRAP static Ptr create(const String & odometryType); /** @see setCameraMatrix */ - virtual cv::Mat getCameraMatrix() const = 0; + CV_WRAP virtual cv::Mat getCameraMatrix() const = 0; /** @copybrief getCameraMatrix @see getCameraMatrix */ - virtual void setCameraMatrix(const cv::Mat &val) = 0; + CV_WRAP virtual void setCameraMatrix(const cv::Mat &val) = 0; /** @see setTransformType */ - virtual int getTransformType() const = 0; + CV_WRAP virtual int getTransformType() const = 0; /** @copybrief getTransformType @see getTransformType */ - virtual void setTransformType(int val) = 0; + CV_WRAP virtual void setTransformType(int val) = 0; protected: virtual void checkParams() const = 0; virtual bool - computeImpl(const Ptr& srcFrame, const Ptr& dstFrame, Mat& Rt, + computeImpl(const Ptr& srcFrame, const Ptr& dstFrame, OutputArray 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 + class CV_EXPORTS_W RgbdOdometry: public Odometry { public: RgbdOdometry(); @@ -640,90 +651,95 @@ namespace rgbd * @param maxPointsPart The method uses a random pixels subset of size frameWidth x frameHeight x pointsPart * @param transformType Class of transformation */ - 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); + RgbdOdometry(const Mat& cameraMatrix, float minDepth = Odometry::DEFAULT_MIN_DEPTH(), float maxDepth = Odometry::DEFAULT_MAX_DEPTH(), + float maxDepthDiff = Odometry::DEFAULT_MAX_DEPTH_DIFF(), const std::vector& iterCounts = std::vector(), + const std::vector& minGradientMagnitudes = std::vector(), float maxPointsPart = Odometry::DEFAULT_MAX_POINTS_PART(), + int transformType = Odometry::RIGID_BODY_MOTION); - virtual Size prepareFrameCache(Ptr& frame, int cacheType) const; + CV_WRAP static Ptr create(const Mat& cameraMatrix = Mat(), float minDepth = Odometry::DEFAULT_MIN_DEPTH(), float maxDepth = Odometry::DEFAULT_MAX_DEPTH(), + float maxDepthDiff = Odometry::DEFAULT_MAX_DEPTH_DIFF(), const std::vector& iterCounts = std::vector(), + const std::vector& minGradientMagnitudes = std::vector(), float maxPointsPart = Odometry::DEFAULT_MAX_POINTS_PART(), + int transformType = Odometry::RIGID_BODY_MOTION); - cv::Mat getCameraMatrix() const + CV_WRAP virtual Size prepareFrameCache(Ptr& frame, int cacheType) const; + + CV_WRAP cv::Mat getCameraMatrix() const { return cameraMatrix; } - void setCameraMatrix(const cv::Mat &val) + CV_WRAP void setCameraMatrix(const cv::Mat &val) { cameraMatrix = val; } - double getMinDepth() const + CV_WRAP double getMinDepth() const { return minDepth; } - void setMinDepth(double val) + CV_WRAP void setMinDepth(double val) { minDepth = val; } - double getMaxDepth() const + CV_WRAP double getMaxDepth() const { return maxDepth; } - void setMaxDepth(double val) + CV_WRAP void setMaxDepth(double val) { maxDepth = val; } - double getMaxDepthDiff() const + CV_WRAP double getMaxDepthDiff() const { return maxDepthDiff; } - void setMaxDepthDiff(double val) + CV_WRAP void setMaxDepthDiff(double val) { maxDepthDiff = val; } - cv::Mat getIterationCounts() const + CV_WRAP cv::Mat getIterationCounts() const { return iterCounts; } - void setIterationCounts(const cv::Mat &val) + CV_WRAP void setIterationCounts(const cv::Mat &val) { iterCounts = val; } - cv::Mat getMinGradientMagnitudes() const + CV_WRAP cv::Mat getMinGradientMagnitudes() const { return minGradientMagnitudes; } - void setMinGradientMagnitudes(const cv::Mat &val) + CV_WRAP void setMinGradientMagnitudes(const cv::Mat &val) { minGradientMagnitudes = val; } - double getMaxPointsPart() const + CV_WRAP double getMaxPointsPart() const { return maxPointsPart; } - void setMaxPointsPart(double val) + CV_WRAP void setMaxPointsPart(double val) { maxPointsPart = val; } - int getTransformType() const + CV_WRAP int getTransformType() const { return transformType; } - void setTransformType(int val) + CV_WRAP void setTransformType(int val) { transformType = val; } - double getMaxTranslation() const + CV_WRAP double getMaxTranslation() const { return maxTranslation; } - void setMaxTranslation(double val) + CV_WRAP void setMaxTranslation(double val) { maxTranslation = val; } - double getMaxRotation() const + CV_WRAP double getMaxRotation() const { return maxRotation; } - void setMaxRotation(double val) + CV_WRAP void setMaxRotation(double val) { maxRotation = val; } @@ -733,7 +749,7 @@ namespace rgbd checkParams() const; virtual bool - computeImpl(const Ptr& srcFrame, const Ptr& dstFrame, Mat& Rt, + computeImpl(const Ptr& srcFrame, const Ptr& dstFrame, OutputArray Rt, const Mat& initRt) const; // Some params have commented desired type. It's due to AlgorithmInfo::addParams does not support it now. @@ -754,7 +770,7 @@ namespace rgbd /** 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 + class CV_EXPORTS_W ICPOdometry: public Odometry { public: ICPOdometry(); @@ -768,85 +784,89 @@ namespace rgbd * @param iterCounts Count of iterations on each pyramid level. * @param transformType Class of trasformation */ - 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); + ICPOdometry(const Mat& cameraMatrix, float minDepth = Odometry::DEFAULT_MIN_DEPTH(), float maxDepth = Odometry::DEFAULT_MAX_DEPTH(), + float maxDepthDiff = Odometry::DEFAULT_MAX_DEPTH_DIFF(), float maxPointsPart = Odometry::DEFAULT_MAX_POINTS_PART(), + const std::vector& iterCounts = std::vector(), int transformType = Odometry::RIGID_BODY_MOTION); - virtual Size prepareFrameCache(Ptr& frame, int cacheType) const; + CV_WRAP static Ptr create(const Mat& cameraMatrix = Mat(), float minDepth = Odometry::DEFAULT_MIN_DEPTH(), float maxDepth = Odometry::DEFAULT_MAX_DEPTH(), + float maxDepthDiff = Odometry::DEFAULT_MAX_DEPTH_DIFF(), float maxPointsPart = Odometry::DEFAULT_MAX_POINTS_PART(), + const std::vector& iterCounts = std::vector(), int transformType = Odometry::RIGID_BODY_MOTION); - cv::Mat getCameraMatrix() const + CV_WRAP virtual Size prepareFrameCache(Ptr& frame, int cacheType) const; + + CV_WRAP cv::Mat getCameraMatrix() const { return cameraMatrix; } - void setCameraMatrix(const cv::Mat &val) + CV_WRAP void setCameraMatrix(const cv::Mat &val) { cameraMatrix = val; } - double getMinDepth() const + CV_WRAP double getMinDepth() const { return minDepth; } - void setMinDepth(double val) + CV_WRAP void setMinDepth(double val) { minDepth = val; } - double getMaxDepth() const + CV_WRAP double getMaxDepth() const { return maxDepth; } - void setMaxDepth(double val) + CV_WRAP void setMaxDepth(double val) { maxDepth = val; } - double getMaxDepthDiff() const + CV_WRAP double getMaxDepthDiff() const { return maxDepthDiff; } - void setMaxDepthDiff(double val) + CV_WRAP void setMaxDepthDiff(double val) { maxDepthDiff = val; } - cv::Mat getIterationCounts() const + CV_WRAP cv::Mat getIterationCounts() const { return iterCounts; } - void setIterationCounts(const cv::Mat &val) + CV_WRAP void setIterationCounts(const cv::Mat &val) { iterCounts = val; } - double getMaxPointsPart() const + CV_WRAP double getMaxPointsPart() const { return maxPointsPart; } - void setMaxPointsPart(double val) + CV_WRAP void setMaxPointsPart(double val) { maxPointsPart = val; } - int getTransformType() const + CV_WRAP int getTransformType() const { return transformType; } - void setTransformType(int val) + CV_WRAP void setTransformType(int val) { transformType = val; } - double getMaxTranslation() const + CV_WRAP double getMaxTranslation() const { return maxTranslation; } - void setMaxTranslation(double val) + CV_WRAP void setMaxTranslation(double val) { maxTranslation = val; } - double getMaxRotation() const + CV_WRAP double getMaxRotation() const { return maxRotation; } - void setMaxRotation(double val) + CV_WRAP void setMaxRotation(double val) { maxRotation = val; } - Ptr getNormalsComputer() const + CV_WRAP Ptr getNormalsComputer() const { return normalsComputer; } @@ -856,7 +876,7 @@ namespace rgbd checkParams() const; virtual bool - computeImpl(const Ptr& srcFrame, const Ptr& dstFrame, Mat& Rt, + computeImpl(const Ptr& srcFrame, const Ptr& dstFrame, OutputArray Rt, const Mat& initRt) const; // Some params have commented desired type. It's due to AlgorithmInfo::addParams does not support it now. @@ -878,7 +898,7 @@ namespace rgbd /** Odometry that merges RgbdOdometry and ICPOdometry by minimize sum of their energy functions. */ - class RgbdICPOdometry: public Odometry + class CV_EXPORTS_W RgbdICPOdometry: public Odometry { public: RgbdICPOdometry(); @@ -894,95 +914,101 @@ namespace rgbd * if they have gradient magnitude less than minGradientMagnitudes[level]. * @param transformType Class of trasformation */ - 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(), + RgbdICPOdometry(const Mat& cameraMatrix, float minDepth = Odometry::DEFAULT_MIN_DEPTH(), float maxDepth = Odometry::DEFAULT_MAX_DEPTH(), + float maxDepthDiff = Odometry::DEFAULT_MAX_DEPTH_DIFF(), float maxPointsPart = Odometry::DEFAULT_MAX_POINTS_PART(), const std::vector& iterCounts = std::vector(), const std::vector& minGradientMagnitudes = std::vector(), - int transformType = RIGID_BODY_MOTION); + int transformType = Odometry::RIGID_BODY_MOTION); - virtual Size prepareFrameCache(Ptr& frame, int cacheType) const; + CV_WRAP static Ptr create(const Mat& cameraMatrix = Mat(), float minDepth = Odometry::DEFAULT_MIN_DEPTH(), float maxDepth = Odometry::DEFAULT_MAX_DEPTH(), + float maxDepthDiff = Odometry::DEFAULT_MAX_DEPTH_DIFF(), float maxPointsPart = Odometry::DEFAULT_MAX_POINTS_PART(), + const std::vector& iterCounts = std::vector(), + const std::vector& minGradientMagnitudes = std::vector(), + int transformType = Odometry::RIGID_BODY_MOTION); - cv::Mat getCameraMatrix() const + CV_WRAP virtual Size prepareFrameCache(Ptr& frame, int cacheType) const; + + CV_WRAP cv::Mat getCameraMatrix() const { return cameraMatrix; } - void setCameraMatrix(const cv::Mat &val) + CV_WRAP void setCameraMatrix(const cv::Mat &val) { cameraMatrix = val; } - double getMinDepth() const + CV_WRAP double getMinDepth() const { return minDepth; } - void setMinDepth(double val) + CV_WRAP void setMinDepth(double val) { minDepth = val; } - double getMaxDepth() const + CV_WRAP double getMaxDepth() const { return maxDepth; } - void setMaxDepth(double val) + CV_WRAP void setMaxDepth(double val) { maxDepth = val; } - double getMaxDepthDiff() const + CV_WRAP double getMaxDepthDiff() const { return maxDepthDiff; } - void setMaxDepthDiff(double val) + CV_WRAP void setMaxDepthDiff(double val) { maxDepthDiff = val; } - double getMaxPointsPart() const + CV_WRAP double getMaxPointsPart() const { return maxPointsPart; } - void setMaxPointsPart(double val) + CV_WRAP void setMaxPointsPart(double val) { maxPointsPart = val; } - cv::Mat getIterationCounts() const + CV_WRAP cv::Mat getIterationCounts() const { return iterCounts; } - void setIterationCounts(const cv::Mat &val) + CV_WRAP void setIterationCounts(const cv::Mat &val) { iterCounts = val; } - cv::Mat getMinGradientMagnitudes() const + CV_WRAP cv::Mat getMinGradientMagnitudes() const { return minGradientMagnitudes; } - void setMinGradientMagnitudes(const cv::Mat &val) + CV_WRAP void setMinGradientMagnitudes(const cv::Mat &val) { minGradientMagnitudes = val; } - int getTransformType() const + CV_WRAP int getTransformType() const { return transformType; } - void setTransformType(int val) + CV_WRAP void setTransformType(int val) { transformType = val; } - double getMaxTranslation() const + CV_WRAP double getMaxTranslation() const { return maxTranslation; } - void setMaxTranslation(double val) + CV_WRAP void setMaxTranslation(double val) { maxTranslation = val; } - double getMaxRotation() const + CV_WRAP double getMaxRotation() const { return maxRotation; } - void setMaxRotation(double val) + CV_WRAP void setMaxRotation(double val) { maxRotation = val; } - Ptr getNormalsComputer() const + CV_WRAP Ptr getNormalsComputer() const { return normalsComputer; } @@ -992,7 +1018,7 @@ namespace rgbd checkParams() const; virtual bool - computeImpl(const Ptr& srcFrame, const Ptr& dstFrame, Mat& Rt, + computeImpl(const Ptr& srcFrame, const Ptr& dstFrame, OutputArray Rt, const Mat& initRt) const; // Some params have commented desired type. It's due to AlgorithmInfo::addParams does not support it now. diff --git a/modules/rgbd/src/odometry.cpp b/modules/rgbd/src/odometry.cpp old mode 100644 new mode 100755 index 1e46b25ac..f26ca5d8d --- a/modules/rgbd/src/odometry.cpp +++ b/modules/rgbd/src/odometry.cpp @@ -804,7 +804,7 @@ bool testDeltaTransformation(const Mat& deltaRt, double maxTranslation, double m } static -bool RGBDICPOdometryImpl(Mat& Rt, const Mat& initRt, +bool RGBDICPOdometryImpl(OutputArray _Rt, const Mat& initRt, const Ptr& srcFrame, const Ptr& dstFrame, const Mat& cameraMatrix, @@ -920,8 +920,9 @@ bool RGBDICPOdometryImpl(Mat& Rt, const Mat& initRt, isOk = true; } } - - Rt = resultRt; + _Rt.create(resultRt.size(), resultRt.type()); + Mat Rt = _Rt.getMat(); + resultRt.copyTo(Rt); if(isOk) { @@ -991,6 +992,14 @@ warpFrameImpl(const Mat& image, const Mat& depth, const Mat& mask, /////////////////////////////////////////////////////////////////////////////////////////////// +Ptr RgbdNormals::create(int rows_in, int cols_in, int depth_in, InputArray K_in, int window_size_in, int method_in) { + return makePtr(rows_in, cols_in, depth_in, K_in, window_size_in, method_in); +} + +Ptr DepthCleaner::create(int depth_in, int window_size_in, int method_in) { + return makePtr(depth_in, window_size_in, method_in); +} + RgbdFrame::RgbdFrame() : ID(-1) {} @@ -1001,6 +1010,10 @@ RgbdFrame::RgbdFrame(const Mat& image_in, const Mat& depth_in, const Mat& mask_i RgbdFrame::~RgbdFrame() {} +Ptr RgbdFrame::create(const Mat& image_in, const Mat& depth_in, const Mat& mask_in, const Mat& normals_in, int ID_in) { + return makePtr(image_in, depth_in, mask_in, normals_in, ID_in); +} + void RgbdFrame::release() { ID = -1; @@ -1017,6 +1030,10 @@ OdometryFrame::OdometryFrame(const Mat& image_in, const Mat& depth_in, const Mat : RgbdFrame(image_in, depth_in, mask_in, normals_in, ID_in) {} +Ptr OdometryFrame::create(const Mat& image_in, const Mat& depth_in, const Mat& mask_in, const Mat& normals_in, int ID_in) { + return makePtr(image_in, depth_in, mask_in, normals_in, ID_in); +} + void OdometryFrame::release() { RgbdFrame::release(); @@ -1041,7 +1058,7 @@ void OdometryFrame::releasePyramids() 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 + OutputArray Rt, const Mat& initRt) const { Ptr srcFrame(new OdometryFrame(srcImage, srcDepth, srcMask)); Ptr dstFrame(new OdometryFrame(dstImage, dstDepth, dstMask)); @@ -1049,7 +1066,7 @@ bool Odometry::compute(const Mat& srcImage, const Mat& srcDepth, const Mat& srcM return compute(srcFrame, dstFrame, Rt, initRt); } -bool Odometry::compute(Ptr& srcFrame, Ptr& dstFrame, Mat& Rt, const Mat& initRt) const +bool Odometry::compute(Ptr& srcFrame, Ptr& dstFrame, OutputArray Rt, const Mat& initRt) const { checkParams(); @@ -1116,6 +1133,13 @@ RgbdOdometry::RgbdOdometry(const Mat& _cameraMatrix, } } +Ptr RgbdOdometry::create(const Mat& _cameraMatrix, float _minDepth, float _maxDepth, + float _maxDepthDiff, const std::vector& _iterCounts, + const std::vector& _minGradientMagnitudes, float _maxPointsPart, + int _transformType) { + return makePtr(_cameraMatrix, _minDepth, _maxDepth, _maxDepthDiff, _iterCounts, _minGradientMagnitudes, _maxPointsPart, _transformType); +} + Size RgbdOdometry::prepareFrameCache(Ptr& frame, int cacheType) const { Odometry::prepareFrameCache(frame, cacheType); @@ -1177,7 +1201,7 @@ void RgbdOdometry::checkParams() const 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 +bool RgbdOdometry::computeImpl(const Ptr& srcFrame, const Ptr& dstFrame, OutputArray Rt, const Mat& initRt) const { return RGBDICPOdometryImpl(Rt, initRt, srcFrame, dstFrame, cameraMatrix, (float)maxDepthDiff, iterCounts, maxTranslation, maxRotation, RGBD_ODOMETRY, transformType); } @@ -1204,6 +1228,12 @@ ICPOdometry::ICPOdometry(const Mat& _cameraMatrix, setDefaultIterCounts(iterCounts); } +Ptr ICPOdometry::create(const Mat& _cameraMatrix, float _minDepth, float _maxDepth, + float _maxDepthDiff, float _maxPointsPart, const std::vector& _iterCounts, + int _transformType) { + return makePtr(_cameraMatrix, _minDepth, _maxDepth, _maxDepthDiff, _maxPointsPart, _iterCounts, _transformType); +} + Size ICPOdometry::prepareFrameCache(Ptr& frame, int cacheType) const { Odometry::prepareFrameCache(frame, cacheType); @@ -1276,7 +1306,7 @@ void ICPOdometry::checkParams() const 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 +bool ICPOdometry::computeImpl(const Ptr& srcFrame, const Ptr& dstFrame, OutputArray Rt, const Mat& initRt) const { return RGBDICPOdometryImpl(Rt, initRt, srcFrame, dstFrame, cameraMatrix, (float)maxDepthDiff, iterCounts, maxTranslation, maxRotation, ICP_ODOMETRY, transformType); } @@ -1309,6 +1339,13 @@ RgbdICPOdometry::RgbdICPOdometry(const Mat& _cameraMatrix, } } +Ptr RgbdICPOdometry::create(const Mat& _cameraMatrix, float _minDepth, float _maxDepth, + float _maxDepthDiff, float _maxPointsPart, const std::vector& _iterCounts, + const std::vector& _minGradientMagnitudes, + int _transformType) { + return makePtr(_cameraMatrix, _minDepth, _maxDepth, _maxDepthDiff, _maxPointsPart, _iterCounts, _minGradientMagnitudes, _transformType); +} + Size RgbdICPOdometry::prepareFrameCache(Ptr& frame, int cacheType) const { if(frame->image.empty()) @@ -1397,7 +1434,7 @@ void RgbdICPOdometry::checkParams() const 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 +bool RgbdICPOdometry::computeImpl(const Ptr& srcFrame, const Ptr& dstFrame, OutputArray Rt, const Mat& initRt) const { return RGBDICPOdometryImpl(Rt, initRt, srcFrame, dstFrame, cameraMatrix, (float)maxDepthDiff, iterCounts, maxTranslation, maxRotation, MERGED_ODOMETRY, transformType); }