OpenCV 4.5.3(日本語機械翻訳)
depth.hpp
1 // This file is part of OpenCV project.
2 // It is subject to the license terms in the LICENSE file found in the top-level directory
3 // of this distribution and at http://opencv.org/license.html
4
5 // This code is also subject to the license terms in the LICENSE_WillowGarage.md file found in this module's directory
6
7 #ifndef __OPENCV_RGBD_DEPTH_HPP__
8 #define __OPENCV_RGBD_DEPTH_HPP__
9
10 #include <opencv2/core.hpp>
11 #include <limits>
12
13 namespace cv
14{
15 namespace rgbd
16{
17
20
25 CV_EXPORTS
26 inline bool
27 isValidDepth(const float & depth)
28 {
29 return !cvIsNaN(depth);
30 }
31 CV_EXPORTS
32 inline bool
33 isValidDepth(const double & depth)
34 {
35 return !cvIsNaN(depth);
36 }
37 CV_EXPORTS
38 inline bool
39 isValidDepth(const short int & depth)
40 {
41 return (depth != std::numeric_limits<short int>::min()) && (depth != std::numeric_limits<short int>::max());
42 }
43 CV_EXPORTS
44 inline bool
45 isValidDepth(const unsigned short int & depth)
46 {
47 return (depth != std::numeric_limits<unsigned short int>::min())
48 && (depth != std::numeric_limits<unsigned short int>::max());
49 }
50 CV_EXPORTS
51 inline bool
52 isValidDepth(const int & depth)
53 {
54 return (depth != std::numeric_limits<int>::min()) && (depth != std::numeric_limits<int>::max());
55 }
56 CV_EXPORTS
57 inline bool
58 isValidDepth(const unsigned int & depth)
59 {
60 return (depth != std::numeric_limits<unsigned int>::min()) && (depth != std::numeric_limits<unsigned int>::max());
61 }
62
73 class CV_EXPORTS_W RgbdNormals: public Algorithm
74 {
75 public:
76 enum RGBD_NORMALS_METHOD
77 {
78 RGBD_NORMALS_METHOD_FALS = 0,
79 RGBD_NORMALS_METHOD_LINEMOD = 1,
80 RGBD_NORMALS_METHOD_SRI = 2
81 };
82
83 RgbdNormals()
84 :
85 rows_(0),
86 cols_(0),
87 depth_(0),
88 K_(Mat()),
89 window_size_(0),
90 method_(RGBD_NORMALS_METHOD_FALS),
91 rgbd_normals_impl_(0)
92 {
93 }
94
103 RgbdNormals(int rows, int cols, int depth, InputArray K, int window_size = 5, int method =
104 RgbdNormals::RGBD_NORMALS_METHOD_FALS);
105
106 ~RgbdNormals();
107
108 CV_WRAP static Ptr<RgbdNormals> create(int rows, int cols, int depth, InputArray K, int window_size = 5, int method =
109 RgbdNormals::RGBD_NORMALS_METHOD_FALS);
110
115 CV_WRAP_AS(apply) void
116 operator()(InputArray points, OutputArray normals) const;
117
121 CV_WRAP void
122 initialize() const;
123
124 CV_WRAP int getRows() const
125 {
126 return rows_;
127 }
128 CV_WRAP void setRows(int val)
129 {
130 rows_ = val;
131 }
132 CV_WRAP int getCols() const
133 {
134 return cols_;
135 }
136 CV_WRAP void setCols(int val)
137 {
138 cols_ = val;
139 }
140 CV_WRAP int getWindowSize() const
141 {
142 return window_size_;
143 }
144 CV_WRAP void setWindowSize(int val)
145 {
146 window_size_ = val;
147 }
148 CV_WRAP int getDepth() const
149 {
150 return depth_;
151 }
152 CV_WRAP void setDepth(int val)
153 {
154 depth_ = val;
155 }
156 CV_WRAP cv::Mat getK() const
157 {
158 return K_;
159 }
160 CV_WRAP void setK(const cv::Mat &val)
161 {
162 K_ = val;
163 }
164 CV_WRAP int getMethod() const
165 {
166 return method_;
167 }
168 CV_WRAP void setMethod(int val)
169 {
170 method_ = val;
171 }
172
173 protected:
174 void
175 initialize_normals_impl(int rows, int cols, int depth, const Mat & K, int window_size, int method) const;
176
177 int rows_, cols_, depth_;
178 Mat K_;
179 int window_size_;
180 int method_;
181 mutable void* rgbd_normals_impl_;
182 };
183
186 class CV_EXPORTS_W DepthCleaner: public Algorithm
187 {
188 public:
193 enum DEPTH_CLEANER_METHOD
194 {
195 DEPTH_CLEANER_NIL
196 };
197
198 DepthCleaner()
199 :
200 depth_(0),
201 window_size_(0),
202 method_(DEPTH_CLEANER_NIL),
203 depth_cleaner_impl_(0)
204 {
205 }
206
212 DepthCleaner(int depth, int window_size = 5, int method = DepthCleaner::DEPTH_CLEANER_NIL);
213
214 ~DepthCleaner();
215
216 CV_WRAP static Ptr<DepthCleaner> create(int depth, int window_size = 5, int method = DepthCleaner::DEPTH_CLEANER_NIL);
217
222 CV_WRAP_AS(apply) void
223 operator()(InputArray points, OutputArray depth) const;
224
228 CV_WRAP void
229 initialize() const;
230
231 CV_WRAP int getWindowSize() const
232 {
233 return window_size_;
234 }
235 CV_WRAP void setWindowSize(int val)
236 {
237 window_size_ = val;
238 }
239 CV_WRAP int getDepth() const
240 {
241 return depth_;
242 }
243 CV_WRAP void setDepth(int val)
244 {
245 depth_ = val;
246 }
247 CV_WRAP int getMethod() const
248 {
249 return method_;
250 }
251 CV_WRAP void setMethod(int val)
252 {
253 method_ = val;
254 }
255
256 protected:
257 void
258 initialize_cleaner_impl() const;
259
260 int depth_;
261 int window_size_;
262 int method_;
263 mutable void* depth_cleaner_impl_;
264 };
265
266
285 CV_EXPORTS_W
286 void
287 registerDepth(InputArray unregisteredCameraMatrix, InputArray registeredCameraMatrix, InputArray registeredDistCoeffs,
288 InputArray Rt, InputArray unregisteredDepth, const Size& outputImagePlaneSize,
289 OutputArray registeredDepth, bool depthDilation=false);
290
297 CV_EXPORTS_W
298 void
299 depthTo3dSparse(InputArray depth, InputArray in_K, InputArray in_points, OutputArray points3d);
300
310 CV_EXPORTS_W
311 void
312 depthTo3d(InputArray depth, InputArray K, OutputArray points3d, InputArray mask = noArray());
313
323 CV_EXPORTS_W
324 void
325 rescaleDepth(InputArray in, int depth, OutputArray out, double depth_factor = 1000.0);
326
329 class CV_EXPORTS_W RgbdPlane: public Algorithm
330 {
331 public:
332 enum RGBD_PLANE_METHOD
333 {
334 RGBD_PLANE_METHOD_DEFAULT
335 };
336
337 RgbdPlane(int method = RgbdPlane::RGBD_PLANE_METHOD_DEFAULT)
338 :
339 method_(method),
340 block_size_(40),
341 min_size_(block_size_*block_size_),
342 threshold_(0.01),
343 sensor_error_a_(0),
344 sensor_error_b_(0),
345 sensor_error_c_(0)
346 {
347 }
348
358 RgbdPlane(int method, int block_size,
359 int min_size, double threshold, double sensor_error_a = 0,
360 double sensor_error_b = 0, double sensor_error_c = 0);
361
362 ~RgbdPlane();
363
364 CV_WRAP static Ptr<RgbdPlane> create(int method, int block_size, int min_size, double threshold,
365 double sensor_error_a = 0, double sensor_error_b = 0,
366 double sensor_error_c = 0);
367
376 CV_WRAP_AS(apply) void
377 operator()(InputArray points3d, InputArray normals, OutputArray mask,
378 OutputArray plane_coefficients);
379
386 CV_WRAP_AS(apply) void
387 operator()(InputArray points3d, OutputArray mask, OutputArray plane_coefficients);
388
389 CV_WRAP int getBlockSize() const
390 {
391 return block_size_;
392 }
393 CV_WRAP void setBlockSize(int val)
394 {
395 block_size_ = val;
396 }
397 CV_WRAP int getMinSize() const
398 {
399 return min_size_;
400 }
401 CV_WRAP void setMinSize(int val)
402 {
403 min_size_ = val;
404 }
405 CV_WRAP int getMethod() const
406 {
407 return method_;
408 }
409 CV_WRAP void setMethod(int val)
410 {
411 method_ = val;
412 }
413 CV_WRAP double getThreshold() const
414 {
415 return threshold_;
416 }
417 CV_WRAP void setThreshold(double val)
418 {
419 threshold_ = val;
420 }
421 CV_WRAP double getSensorErrorA() const
422 {
423 return sensor_error_a_;
424 }
425 CV_WRAP void setSensorErrorA(double val)
426 {
427 sensor_error_a_ = val;
428 }
429 CV_WRAP double getSensorErrorB() const
430 {
431 return sensor_error_b_;
432 }
433 CV_WRAP void setSensorErrorB(double val)
434 {
435 sensor_error_b_ = val;
436 }
437 CV_WRAP double getSensorErrorC() const
438 {
439 return sensor_error_c_;
440 }
441 CV_WRAP void setSensorErrorC(double val)
442 {
443 sensor_error_c_ = val;
444 }
445
446 private:
448 int method_;
450 int block_size_;
452 int min_size_;
454 double threshold_;
456 double sensor_error_a_, sensor_error_b_, sensor_error_c_;
457 };
458
461 struct CV_EXPORTS_W RgbdFrame
462 {
463 RgbdFrame();
464 RgbdFrame(const Mat& image, const Mat& depth, const Mat& mask=Mat(), const Mat& normals=Mat(), int ID=-1);
465 virtual ~RgbdFrame();
466
467 CV_WRAP static Ptr<RgbdFrame> create(const Mat& image=Mat(), const Mat& depth=Mat(), const Mat& mask=Mat(), const Mat& normals=Mat(), int ID=-1);
468
469 CV_WRAP virtual void
470 release();
471
472 CV_PROP int ID;
473 CV_PROP Mat image;
474 CV_PROP Mat depth;
475 CV_PROP Mat mask;
476 CV_PROP Mat normals;
477 };
478
483 struct CV_EXPORTS_W OdometryFrame : public RgbdFrame
484 {
492 enum
493 {
494 CACHE_SRC = 1, CACHE_DST = 2, CACHE_ALL = CACHE_SRC + CACHE_DST
495 };
496
497 OdometryFrame();
498 OdometryFrame(const Mat& image, const Mat& depth, const Mat& mask=Mat(), const Mat& normals=Mat(), int ID=-1);
499
500 CV_WRAP static Ptr<OdometryFrame> create(const Mat& image=Mat(), const Mat& depth=Mat(), const Mat& mask=Mat(), const Mat& normals=Mat(), int ID=-1);
501
502 CV_WRAP virtual void
503 release() CV_OVERRIDE;
504
505 CV_WRAP void
506 releasePyramids();
507
508 CV_PROP std::vector<Mat> pyramidImage;
509 CV_PROP std::vector<Mat> pyramidDepth;
510 CV_PROP std::vector<Mat> pyramidMask;
511
512 CV_PROP std::vector<Mat> pyramidCloud;
513
514 CV_PROP std::vector<Mat> pyramid_dI_dx;
515 CV_PROP std::vector<Mat> pyramid_dI_dy;
516 CV_PROP std::vector<Mat> pyramidTexturedMask;
517
518 CV_PROP std::vector<Mat> pyramidNormals;
519 CV_PROP std::vector<Mat> pyramidNormalsMask;
520 };
521
524 class CV_EXPORTS_W Odometry: public Algorithm
525 {
526 public:
527
529 enum
530 {
531 ROTATION = 1, TRANSLATION = 2, RIGID_BODY_MOTION = 4
532 };
533
534 CV_WRAP static inline float
535 DEFAULT_MIN_DEPTH()
536 {
537 return 0.f; // in meters
538 }
539 CV_WRAP static inline float
540 DEFAULT_MAX_DEPTH()
541 {
542 return 4.f; // in meters
543 }
544 CV_WRAP static inline float
545 DEFAULT_MAX_DEPTH_DIFF()
546 {
547 return 0.07f; // in meters
548 }
549 CV_WRAP static inline float
550 DEFAULT_MAX_POINTS_PART()
551 {
552 return 0.07f; // in [0, 1]
553 }
554 CV_WRAP static inline float
555 DEFAULT_MAX_TRANSLATION()
556 {
557 return 0.15f; // in meters
558 }
559 CV_WRAP static inline float
560 DEFAULT_MAX_ROTATION()
561 {
562 return 15; // in degrees
563 }
564
583 CV_WRAP bool
584 compute(const Mat& srcImage, const Mat& srcDepth, const Mat& srcMask, const Mat& dstImage, const Mat& dstDepth,
585 const Mat& dstMask, OutputArray Rt, const Mat& initRt = Mat()) const;
586
590 CV_WRAP_AS(compute2) bool
591 compute(Ptr<OdometryFrame>& srcFrame, Ptr<OdometryFrame>& dstFrame, OutputArray Rt, const Mat& initRt = Mat()) const;
592
599 CV_WRAP virtual Size prepareFrameCache(Ptr<OdometryFrame>& frame, int cacheType) const;
600
601 CV_WRAP static Ptr<Odometry> create(const String & odometryType);
602
604 CV_WRAP virtual cv::Mat getCameraMatrix() const = 0;
606 CV_WRAP virtual void setCameraMatrix(const cv::Mat &val) = 0;
608 CV_WRAP virtual int getTransformType() const = 0;
610 CV_WRAP virtual void setTransformType(int val) = 0;
611
612 protected:
613 virtual void
614 checkParams() const = 0;
615
616 virtual bool
617 computeImpl(const Ptr<OdometryFrame>& srcFrame, const Ptr<OdometryFrame>& dstFrame, OutputArray Rt,
618 const Mat& initRt) const = 0;
619 };
620
624 class CV_EXPORTS_W RgbdOdometry: public Odometry
625 {
626 public:
627 RgbdOdometry();
640 RgbdOdometry(const Mat& cameraMatrix, float minDepth = Odometry::DEFAULT_MIN_DEPTH(), float maxDepth = Odometry::DEFAULT_MAX_DEPTH(),
641 float maxDepthDiff = Odometry::DEFAULT_MAX_DEPTH_DIFF(), const std::vector<int>& iterCounts = std::vector<int>(),
642 const std::vector<float>& minGradientMagnitudes = std::vector<float>(), float maxPointsPart = Odometry::DEFAULT_MAX_POINTS_PART(),
643 int transformType = Odometry::RIGID_BODY_MOTION);
644
645 CV_WRAP static Ptr<RgbdOdometry> create(const Mat& cameraMatrix = Mat(), float minDepth = Odometry::DEFAULT_MIN_DEPTH(), float maxDepth = Odometry::DEFAULT_MAX_DEPTH(),
646 float maxDepthDiff = Odometry::DEFAULT_MAX_DEPTH_DIFF(), const std::vector<int>& iterCounts = std::vector<int>(),
647 const std::vector<float>& minGradientMagnitudes = std::vector<float>(), float maxPointsPart = Odometry::DEFAULT_MAX_POINTS_PART(),
648 int transformType = Odometry::RIGID_BODY_MOTION);
649
650 CV_WRAP virtual Size prepareFrameCache(Ptr<OdometryFrame>& frame, int cacheType) const CV_OVERRIDE;
651
652 CV_WRAP cv::Mat getCameraMatrix() const CV_OVERRIDE
653 {
654 return cameraMatrix;
655 }
656 CV_WRAP void setCameraMatrix(const cv::Mat &val) CV_OVERRIDE
657 {
658 cameraMatrix = val;
659 }
660 CV_WRAP double getMinDepth() const
661 {
662 return minDepth;
663 }
664 CV_WRAP void setMinDepth(double val)
665 {
666 minDepth = val;
667 }
668 CV_WRAP double getMaxDepth() const
669 {
670 return maxDepth;
671 }
672 CV_WRAP void setMaxDepth(double val)
673 {
674 maxDepth = val;
675 }
676 CV_WRAP double getMaxDepthDiff() const
677 {
678 return maxDepthDiff;
679 }
680 CV_WRAP void setMaxDepthDiff(double val)
681 {
682 maxDepthDiff = val;
683 }
684 CV_WRAP cv::Mat getIterationCounts() const
685 {
686 return iterCounts;
687 }
688 CV_WRAP void setIterationCounts(const cv::Mat &val)
689 {
690 iterCounts = val;
691 }
692 CV_WRAP cv::Mat getMinGradientMagnitudes() const
693 {
694 return minGradientMagnitudes;
695 }
696 CV_WRAP void setMinGradientMagnitudes(const cv::Mat &val)
697 {
698 minGradientMagnitudes = val;
699 }
700 CV_WRAP double getMaxPointsPart() const
701 {
702 return maxPointsPart;
703 }
704 CV_WRAP void setMaxPointsPart(double val)
705 {
706 maxPointsPart = val;
707 }
708 CV_WRAP int getTransformType() const CV_OVERRIDE
709 {
710 return transformType;
711 }
712 CV_WRAP void setTransformType(int val) CV_OVERRIDE
713 {
714 transformType = val;
715 }
716 CV_WRAP double getMaxTranslation() const
717 {
718 return maxTranslation;
719 }
720 CV_WRAP void setMaxTranslation(double val)
721 {
722 maxTranslation = val;
723 }
724 CV_WRAP double getMaxRotation() const
725 {
726 return maxRotation;
727 }
728 CV_WRAP void setMaxRotation(double val)
729 {
730 maxRotation = val;
731 }
732
733 protected:
734 virtual void
735 checkParams() const CV_OVERRIDE;
736
737 virtual bool
738 computeImpl(const Ptr<OdometryFrame>& srcFrame, const Ptr<OdometryFrame>& dstFrame, OutputArray Rt,
739 const Mat& initRt) const CV_OVERRIDE;
740
741 // Some params have commented desired type. It's due to AlgorithmInfo::addParams does not support it now.
742 /*float*/
743 double minDepth, maxDepth, maxDepthDiff;
744 /*vector<int>*/
745 Mat iterCounts;
746 /*vector<float>*/
747 Mat minGradientMagnitudes;
748 double maxPointsPart;
749
750 Mat cameraMatrix;
751 int transformType;
752
753 double maxTranslation, maxRotation;
754 };
755
759 class CV_EXPORTS_W ICPOdometry: public Odometry
760 {
761 public:
762 ICPOdometry();
773 ICPOdometry(const Mat& cameraMatrix, float minDepth = Odometry::DEFAULT_MIN_DEPTH(), float maxDepth = Odometry::DEFAULT_MAX_DEPTH(),
774 float maxDepthDiff = Odometry::DEFAULT_MAX_DEPTH_DIFF(), float maxPointsPart = Odometry::DEFAULT_MAX_POINTS_PART(),
775 const std::vector<int>& iterCounts = std::vector<int>(), int transformType = Odometry::RIGID_BODY_MOTION);
776
777 CV_WRAP static Ptr<ICPOdometry> create(const Mat& cameraMatrix = Mat(), float minDepth = Odometry::DEFAULT_MIN_DEPTH(), float maxDepth = Odometry::DEFAULT_MAX_DEPTH(),
778 float maxDepthDiff = Odometry::DEFAULT_MAX_DEPTH_DIFF(), float maxPointsPart = Odometry::DEFAULT_MAX_POINTS_PART(),
779 const std::vector<int>& iterCounts = std::vector<int>(), int transformType = Odometry::RIGID_BODY_MOTION);
780
781 CV_WRAP virtual Size prepareFrameCache(Ptr<OdometryFrame>& frame, int cacheType) const CV_OVERRIDE;
782
783 CV_WRAP cv::Mat getCameraMatrix() const CV_OVERRIDE
784 {
785 return cameraMatrix;
786 }
787 CV_WRAP void setCameraMatrix(const cv::Mat &val) CV_OVERRIDE
788 {
789 cameraMatrix = val;
790 }
791 CV_WRAP double getMinDepth() const
792 {
793 return minDepth;
794 }
795 CV_WRAP void setMinDepth(double val)
796 {
797 minDepth = val;
798 }
799 CV_WRAP double getMaxDepth() const
800 {
801 return maxDepth;
802 }
803 CV_WRAP void setMaxDepth(double val)
804 {
805 maxDepth = val;
806 }
807 CV_WRAP double getMaxDepthDiff() const
808 {
809 return maxDepthDiff;
810 }
811 CV_WRAP void setMaxDepthDiff(double val)
812 {
813 maxDepthDiff = val;
814 }
815 CV_WRAP cv::Mat getIterationCounts() const
816 {
817 return iterCounts;
818 }
819 CV_WRAP void setIterationCounts(const cv::Mat &val)
820 {
821 iterCounts = val;
822 }
823 CV_WRAP double getMaxPointsPart() const
824 {
825 return maxPointsPart;
826 }
827 CV_WRAP void setMaxPointsPart(double val)
828 {
829 maxPointsPart = val;
830 }
831 CV_WRAP int getTransformType() const CV_OVERRIDE
832 {
833 return transformType;
834 }
835 CV_WRAP void setTransformType(int val) CV_OVERRIDE
836 {
837 transformType = val;
838 }
839 CV_WRAP double getMaxTranslation() const
840 {
841 return maxTranslation;
842 }
843 CV_WRAP void setMaxTranslation(double val)
844 {
845 maxTranslation = val;
846 }
847 CV_WRAP double getMaxRotation() const
848 {
849 return maxRotation;
850 }
851 CV_WRAP void setMaxRotation(double val)
852 {
853 maxRotation = val;
854 }
855 CV_WRAP Ptr<RgbdNormals> getNormalsComputer() const
856 {
857 return normalsComputer;
858 }
859
860 protected:
861 virtual void
862 checkParams() const CV_OVERRIDE;
863
864 virtual bool
865 computeImpl(const Ptr<OdometryFrame>& srcFrame, const Ptr<OdometryFrame>& dstFrame, OutputArray Rt,
866 const Mat& initRt) const CV_OVERRIDE;
867
868 // Some params have commented desired type. It's due to AlgorithmInfo::addParams does not support it now.
869 /*float*/
870 double minDepth, maxDepth, maxDepthDiff;
871 /*float*/
872 double maxPointsPart;
873 /*vector<int>*/
874 Mat iterCounts;
875
876 Mat cameraMatrix;
877 int transformType;
878
879 double maxTranslation, maxRotation;
880
881 mutable Ptr<RgbdNormals> normalsComputer;
882 };
883
887 class CV_EXPORTS_W RgbdICPOdometry: public Odometry
888 {
889 public:
890 RgbdICPOdometry();
903 RgbdICPOdometry(const Mat& cameraMatrix, float minDepth = Odometry::DEFAULT_MIN_DEPTH(), float maxDepth = Odometry::DEFAULT_MAX_DEPTH(),
904 float maxDepthDiff = Odometry::DEFAULT_MAX_DEPTH_DIFF(), float maxPointsPart = Odometry::DEFAULT_MAX_POINTS_PART(),
905 const std::vector<int>& iterCounts = std::vector<int>(),
906 const std::vector<float>& minGradientMagnitudes = std::vector<float>(),
907 int transformType = Odometry::RIGID_BODY_MOTION);
908
909 CV_WRAP static Ptr<RgbdICPOdometry> create(const Mat& cameraMatrix = Mat(), float minDepth = Odometry::DEFAULT_MIN_DEPTH(), float maxDepth = Odometry::DEFAULT_MAX_DEPTH(),
910 float maxDepthDiff = Odometry::DEFAULT_MAX_DEPTH_DIFF(), float maxPointsPart = Odometry::DEFAULT_MAX_POINTS_PART(),
911 const std::vector<int>& iterCounts = std::vector<int>(),
912 const std::vector<float>& minGradientMagnitudes = std::vector<float>(),
913 int transformType = Odometry::RIGID_BODY_MOTION);
914
915 CV_WRAP virtual Size prepareFrameCache(Ptr<OdometryFrame>& frame, int cacheType) const CV_OVERRIDE;
916
917 CV_WRAP cv::Mat getCameraMatrix() const CV_OVERRIDE
918 {
919 return cameraMatrix;
920 }
921 CV_WRAP void setCameraMatrix(const cv::Mat &val) CV_OVERRIDE
922 {
923 cameraMatrix = val;
924 }
925 CV_WRAP double getMinDepth() const
926 {
927 return minDepth;
928 }
929 CV_WRAP void setMinDepth(double val)
930 {
931 minDepth = val;
932 }
933 CV_WRAP double getMaxDepth() const
934 {
935 return maxDepth;
936 }
937 CV_WRAP void setMaxDepth(double val)
938 {
939 maxDepth = val;
940 }
941 CV_WRAP double getMaxDepthDiff() const
942 {
943 return maxDepthDiff;
944 }
945 CV_WRAP void setMaxDepthDiff(double val)
946 {
947 maxDepthDiff = val;
948 }
949 CV_WRAP double getMaxPointsPart() const
950 {
951 return maxPointsPart;
952 }
953 CV_WRAP void setMaxPointsPart(double val)
954 {
955 maxPointsPart = val;
956 }
957 CV_WRAP cv::Mat getIterationCounts() const
958 {
959 return iterCounts;
960 }
961 CV_WRAP void setIterationCounts(const cv::Mat &val)
962 {
963 iterCounts = val;
964 }
965 CV_WRAP cv::Mat getMinGradientMagnitudes() const
966 {
967 return minGradientMagnitudes;
968 }
969 CV_WRAP void setMinGradientMagnitudes(const cv::Mat &val)
970 {
971 minGradientMagnitudes = val;
972 }
973 CV_WRAP int getTransformType() const CV_OVERRIDE
974 {
975 return transformType;
976 }
977 CV_WRAP void setTransformType(int val) CV_OVERRIDE
978 {
979 transformType = val;
980 }
981 CV_WRAP double getMaxTranslation() const
982 {
983 return maxTranslation;
984 }
985 CV_WRAP void setMaxTranslation(double val)
986 {
987 maxTranslation = val;
988 }
989 CV_WRAP double getMaxRotation() const
990 {
991 return maxRotation;
992 }
993 CV_WRAP void setMaxRotation(double val)
994 {
995 maxRotation = val;
996 }
997 CV_WRAP Ptr<RgbdNormals> getNormalsComputer() const
998 {
999 return normalsComputer;
1000 }
1001
1002 protected:
1003 virtual void
1004 checkParams() const CV_OVERRIDE;
1005
1006 virtual bool
1007 computeImpl(const Ptr<OdometryFrame>& srcFrame, const Ptr<OdometryFrame>& dstFrame, OutputArray Rt,
1008 const Mat& initRt) const CV_OVERRIDE;
1009
1010 // Some params have commented desired type. It's due to AlgorithmInfo::addParams does not support it now.
1011 /*float*/
1012 double minDepth, maxDepth, maxDepthDiff;
1013 /*float*/
1014 double maxPointsPart;
1015 /*vector<int>*/
1016 Mat iterCounts;
1017 /*vector<float>*/
1018 Mat minGradientMagnitudes;
1019
1020 Mat cameraMatrix;
1021 int transformType;
1022
1023 double maxTranslation, maxRotation;
1024
1025 mutable Ptr<RgbdNormals> normalsComputer;
1026 };
1027
1039 class CV_EXPORTS_W FastICPOdometry: public Odometry
1040 {
1041 public:
1042 FastICPOdometry();
1054 FastICPOdometry(const Mat& cameraMatrix,
1055 float maxDistDiff = Odometry::DEFAULT_MAX_DEPTH_DIFF(),
1056 float angleThreshold = (float)(30. * CV_PI / 180.),
1057 float sigmaDepth = 0.04f,
1058 float sigmaSpatial = 4.5f,
1059 int kernelSize = 7,
1060 const std::vector<int>& iterCounts = std::vector<int>());
1061
1062 CV_WRAP static Ptr<FastICPOdometry> create(const Mat& cameraMatrix,
1063 float maxDistDiff = Odometry::DEFAULT_MAX_DEPTH_DIFF(),
1064 float angleThreshold = (float)(30. * CV_PI / 180.),
1065 float sigmaDepth = 0.04f,
1066 float sigmaSpatial = 4.5f,
1067 int kernelSize = 7,
1068 const std::vector<int>& iterCounts = std::vector<int>());
1069
1070 CV_WRAP virtual Size prepareFrameCache(Ptr<OdometryFrame>& frame, int cacheType) const CV_OVERRIDE;
1071
1072 CV_WRAP cv::Mat getCameraMatrix() const CV_OVERRIDE
1073 {
1074 return cameraMatrix;
1075 }
1076 CV_WRAP void setCameraMatrix(const cv::Mat &val) CV_OVERRIDE
1077 {
1078 cameraMatrix = val;
1079 }
1080 CV_WRAP double getMaxDistDiff() const
1081 {
1082 return maxDistDiff;
1083 }
1084 CV_WRAP void setMaxDistDiff(float val)
1085 {
1086 maxDistDiff = val;
1087 }
1088 CV_WRAP float getAngleThreshold() const
1089 {
1090 return angleThreshold;
1091 }
1092 CV_WRAP void setAngleThreshold(float f)
1093 {
1094 angleThreshold = f;
1095 }
1096 CV_WRAP float getSigmaDepth() const
1097 {
1098 return sigmaDepth;
1099 }
1100 CV_WRAP void setSigmaDepth(float f)
1101 {
1102 sigmaDepth = f;
1103 }
1104 CV_WRAP float getSigmaSpatial() const
1105 {
1106 return sigmaSpatial;
1107 }
1108 CV_WRAP void setSigmaSpatial(float f)
1109 {
1110 sigmaSpatial = f;
1111 }
1112 CV_WRAP int getKernelSize() const
1113 {
1114 return kernelSize;
1115 }
1116 CV_WRAP void setKernelSize(int f)
1117 {
1118 kernelSize = f;
1119 }
1120 CV_WRAP cv::Mat getIterationCounts() const
1121 {
1122 return iterCounts;
1123 }
1124 CV_WRAP void setIterationCounts(const cv::Mat &val)
1125 {
1126 iterCounts = val;
1127 }
1128 CV_WRAP int getTransformType() const CV_OVERRIDE
1129 {
1130 return Odometry::RIGID_BODY_MOTION;
1131 }
1132 CV_WRAP void setTransformType(int val) CV_OVERRIDE
1133 {
1134 if(val != Odometry::RIGID_BODY_MOTION)
1135 throw std::runtime_error("Rigid Body Motion is the only accepted transformation type"
1136 " for this odometry method");
1137 }
1138
1139 protected:
1140 virtual void
1141 checkParams() const CV_OVERRIDE;
1142
1143 virtual bool
1144 computeImpl(const Ptr<OdometryFrame>& srcFrame, const Ptr<OdometryFrame>& dstFrame, OutputArray Rt,
1145 const Mat& initRt) const CV_OVERRIDE;
1146
1147 // Some params have commented desired type. It's due to AlgorithmInfo::addParams does not support it now.
1148 float maxDistDiff;
1149
1150 float angleThreshold;
1151
1152 float sigmaDepth;
1153
1154 float sigmaSpatial;
1155
1156 int kernelSize;
1157
1158 /*vector<int>*/
1159 Mat iterCounts;
1160
1161 Mat cameraMatrix;
1162 };
1163
1177 CV_EXPORTS_W
1178 void
1179 warpFrame(const Mat& image, const Mat& depth, const Mat& mask, const Mat& Rt, const Mat& cameraMatrix,
1180 const Mat& distCoeff, OutputArray warpedImage, OutputArray warpedDepth = noArray(), OutputArray warpedMask = noArray());
1181
1182 // TODO Depth interpolation
1183 // Curvature
1184 // Get rescaleDepth return dubles if asked for
1185
1187
1188} /* namespace rgbd */
1189} /* namespace cv */
1190
1191 #endif
1192
1193 /* End of file. */
cv::_OutputArray
This type is very similar to InputArray except that it is used for input/output and output function p...
Definition: mat.hpp:295
cv::Algorithm
This is a base class for all more or less complex algorithms in OpenCV
Definition: core.hpp:3091
cv::Mat
n-dimensional dense array class
Definition: mat.hpp:802
cv::Size_
Template class for specifying the size of an image or rectangle.
Definition: core/types.hpp:316
cv::rgbd::DepthCleaner
Definition: depth.hpp:187
cv::rgbd::DepthCleaner::DEPTH_CLEANER_METHOD
DEPTH_CLEANER_METHOD
Definition: depth.hpp:194
cv::rgbd::DepthCleaner::CV_WRAP_AS
CV_WRAP_AS(apply) void operator()(InputArray points
cv::rgbd::DepthCleaner::initialize
CV_WRAP void initialize() const
cv::rgbd::DepthCleaner::DepthCleaner
DepthCleaner(int depth, int window_size=5, int method=DepthCleaner::DEPTH_CLEANER_NIL)
cv::rgbd::FastICPOdometry
Definition: depth.hpp:1040
cv::rgbd::FastICPOdometry::FastICPOdometry
FastICPOdometry(const Mat &cameraMatrix, float maxDistDiff=Odometry::DEFAULT_MAX_DEPTH_DIFF(), float angleThreshold=(float)(30. *CV_PI/180.), float sigmaDepth=0.04f, float sigmaSpatial=4.5f, int kernelSize=7, const std::vector< int > &iterCounts=std::vector< int >())
cv::rgbd::ICPOdometry
Definition: depth.hpp:760
cv::rgbd::ICPOdometry::ICPOdometry
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< int > &iterCounts=std::vector< int >(), int transformType=Odometry::RIGID_BODY_MOTION)
cv::rgbd::Odometry
Definition: depth.hpp:525
cv::rgbd::Odometry::compute
CV_WRAP bool compute(const Mat &srcImage, const Mat &srcDepth, const Mat &srcMask, const Mat &dstImage, const Mat &dstDepth, const Mat &dstMask, OutputArray Rt, const Mat &initRt=Mat()) const
cv::rgbd::Odometry::CV_WRAP_AS
CV_WRAP_AS(compute2) bool compute(Ptr< OdometryFrame > &srcFrame
cv::rgbd::RgbdICPOdometry
Definition: depth.hpp:888
cv::rgbd::RgbdICPOdometry::RgbdICPOdometry
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< int > &iterCounts=std::vector< int >(), const std::vector< float > &minGradientMagnitudes=std::vector< float >(), int transformType=Odometry::RIGID_BODY_MOTION)
cv::rgbd::RgbdNormals
Definition: depth.hpp:74
cv::rgbd::RgbdNormals::initialize
CV_WRAP void initialize() const
cv::rgbd::RgbdNormals::RgbdNormals
RgbdNormals(int rows, int cols, int depth, InputArray K, int window_size=5, int method=RgbdNormals::RGBD_NORMALS_METHOD_FALS)
cv::rgbd::RgbdNormals::CV_WRAP_AS
CV_WRAP_AS(apply) void operator()(InputArray points
cv::rgbd::RgbdOdometry
Definition: depth.hpp:625
cv::rgbd::RgbdOdometry::RgbdOdometry
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< int > &iterCounts=std::vector< int >(), const std::vector< float > &minGradientMagnitudes=std::vector< float >(), float maxPointsPart=Odometry::DEFAULT_MAX_POINTS_PART(), int transformType=Odometry::RIGID_BODY_MOTION)
cv::rgbd::RgbdPlane
Definition: depth.hpp:330
cv::rgbd::RgbdPlane::RgbdPlane
RgbdPlane(int method, int block_size, int min_size, double threshold, double sensor_error_a=0, double sensor_error_b=0, double sensor_error_c=0)
cv::rgbd::RgbdPlane::CV_WRAP_AS
CV_WRAP_AS(apply) void operator()(InputArray points3d
cv::max
CV_EXPORTS_W void max(InputArray src1, InputArray src2, OutputArray dst)
Calculates per-element maximum of two arrays or an array and a scalar.
cv::min
CV_EXPORTS_W void min(InputArray src1, InputArray src2, OutputArray dst)
Calculates per-element minimum of two arrays or an array and a scalar.
cvIsNaN
CV_INLINE int cvIsNaN(double value)
Determines if the argument is Not A Number.
Definition: fast_math.hpp:273
cv::threshold
CV_EXPORTS_W double threshold(InputArray src, OutputArray dst, double thresh, double maxval, int type)
Applies a fixed-level threshold to each array element.
cv::rgbd::depthTo3d
CV_EXPORTS_W void depthTo3d(InputArray depth, InputArray K, OutputArray points3d, InputArray mask=noArray())
cv::rgbd::warpFrame
CV_EXPORTS_W void warpFrame(const Mat &image, const Mat &depth, const Mat &mask, const Mat &Rt, const Mat &cameraMatrix, const Mat &distCoeff, OutputArray warpedImage, OutputArray warpedDepth=noArray(), OutputArray warpedMask=noArray())
cv::rgbd::rescaleDepth
CV_EXPORTS_W void rescaleDepth(InputArray in, int depth, OutputArray out, double depth_factor=1000.0)
cv::rgbd::registerDepth
CV_EXPORTS_W void registerDepth(InputArray unregisteredCameraMatrix, InputArray registeredCameraMatrix, InputArray registeredDistCoeffs, InputArray Rt, InputArray unregisteredDepth, const Size &outputImagePlaneSize, OutputArray registeredDepth, bool depthDilation=false)
cv::rgbd::isValidDepth
CV_EXPORTS bool isValidDepth(const float &depth)
Definition: depth.hpp:27
cv::rgbd::depthTo3dSparse
CV_EXPORTS_W void depthTo3dSparse(InputArray depth, InputArray in_K, InputArray in_points, OutputArray points3d)
cv
"black box" representation of the file storage associated with a file on disk.
Definition: aruco.hpp:75
cv::Ptr
Definition: cvstd_wrapper.hpp:74
cv::rgbd::OdometryFrame
Definition: depth.hpp:484
cv::rgbd::RgbdFrame
Definition: depth.hpp:462
構築: doxygen 1.9.2