#include <opencv2/rgbd.hpp>
|  | 
|  | 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::Mat | getCameraMatrix () const CV_OVERRIDE | 
|  | 
| cv::Mat | getIterationCounts () const | 
|  | 
| double | getMaxDepth () const | 
|  | 
| double | getMaxDepthDiff () const | 
|  | 
| double | getMaxPointsPart () const | 
|  | 
| double | getMaxRotation () const | 
|  | 
| double | getMaxTranslation () const | 
|  | 
| double | getMinDepth () const | 
|  | 
| cv::Mat | getMinGradientMagnitudes () const | 
|  | 
| Ptr< RgbdNormals > | getNormalsComputer () const | 
|  | 
| int | getTransformType () const CV_OVERRIDE | 
|  | 
| virtual Size | prepareFrameCache (Ptr< OdometryFrame > &frame, int cacheType) const CV_OVERRIDE | 
|  | 
| void | setCameraMatrix (const cv::Mat &val) CV_OVERRIDE | 
|  | 
| void | setIterationCounts (const cv::Mat &val) | 
|  | 
| void | setMaxDepth (double val) | 
|  | 
| void | setMaxDepthDiff (double val) | 
|  | 
| void | setMaxPointsPart (double val) | 
|  | 
| void | setMaxRotation (double val) | 
|  | 
| void | setMaxTranslation (double val) | 
|  | 
| void | setMinDepth (double val) | 
|  | 
| void | setMinGradientMagnitudes (const cv::Mat &val) | 
|  | 
| void | setTransformType (int val) CV_OVERRIDE | 
|  | 
| 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 | 
|  | 
| bool | compute (Ptr< OdometryFrame > &srcFrame, Ptr< OdometryFrame > &dstFrame, OutputArray Rt, const Mat &initRt=Mat()) const | 
|  | 
|  | Algorithm () | 
|  | 
| virtual | ~Algorithm () | 
|  | 
| virtual void | clear () | 
|  | Clears the algorithm state.  More... 
 | 
|  | 
| virtual bool | empty () const | 
|  | Returns true if the Algorithm is empty (e.g. in the very beginning or after unsuccessful read.  More... 
 | 
|  | 
| virtual String | getDefaultName () const | 
|  | 
| virtual void | read (const FileNode &fn) | 
|  | Reads algorithm parameters from a file storage.  More... 
 | 
|  | 
| virtual void | save (const String &filename) const | 
|  | 
| virtual void | write (FileStorage &fs) const | 
|  | Stores algorithm parameters in a file storage.  More... 
 | 
|  | 
| void | write (FileStorage &fs, const String &name) const | 
|  | 
| void | write (const Ptr< FileStorage > &fs, const String &name=String()) const | 
|  | 
Odometry that merges RgbdOdometry and ICPOdometry by minimize sum of their energy functions. 
◆ RgbdICPOdometry() [1/2]
      
        
          | cv::rgbd::RgbdICPOdometry::RgbdICPOdometry | ( |  | ) |  | 
      
 
 
◆ RgbdICPOdometry() [2/2]
Constructor. 
- Parameters
- 
  
    | cameraMatrix | Camera matrix |  | minDepth | Pixels with depth less than minDepth will not be used |  | maxDepth | Pixels with depth larger than maxDepth will not be used |  | maxDepthDiff | Correspondences between pixels of two given frames will be filtered out if their depth difference is larger than maxDepthDiff |  | maxPointsPart | The method uses a random pixels subset of size frameWidth x frameHeight x pointsPart |  | iterCounts | Count of iterations on each pyramid level. |  | minGradientMagnitudes | For each pyramid level the pixels will be filtered out if they have gradient magnitude less than minGradientMagnitudes[level]. |  | transformType | Class of trasformation |  
 
 
 
◆ checkParams()
  
  | 
        
          | virtual void cv::rgbd::RgbdICPOdometry::checkParams | ( |  | ) | const |  | protectedvirtual | 
 
 
◆ computeImpl()
◆ create()
| Python: | 
|---|
|  | cv.rgbd.RgbdICPOdometry.create( | [, cameraMatrix[, minDepth[, maxDepth[, maxDepthDiff[, maxPointsPart[, iterCounts[, minGradientMagnitudes[, transformType]]]]]]]] | ) -> | retval | 
|  | cv.rgbd.RgbdICPOdometry_create( | [, cameraMatrix[, minDepth[, maxDepth[, maxDepthDiff[, maxPointsPart[, iterCounts[, minGradientMagnitudes[, transformType]]]]]]]] | ) -> | retval | 
 
 
◆ getCameraMatrix()
  
  | 
        
          | cv::Mat cv::rgbd::RgbdICPOdometry::getCameraMatrix | ( |  | ) | const |  | inlinevirtual | 
| Python: | 
|---|
|  | cv.rgbd.RgbdICPOdometry.getCameraMatrix( |  | ) -> | retval | 
 
 
◆ getIterationCounts()
  
  | 
        
          | cv::Mat cv::rgbd::RgbdICPOdometry::getIterationCounts | ( |  | ) | const |  | inline | 
| Python: | 
|---|
|  | cv.rgbd.RgbdICPOdometry.getIterationCounts( |  | ) -> | retval | 
 
 
◆ getMaxDepth()
  
  | 
        
          | double cv::rgbd::RgbdICPOdometry::getMaxDepth | ( |  | ) | const |  | inline | 
| Python: | 
|---|
|  | cv.rgbd.RgbdICPOdometry.getMaxDepth( |  | ) -> | retval | 
 
 
◆ getMaxDepthDiff()
  
  | 
        
          | double cv::rgbd::RgbdICPOdometry::getMaxDepthDiff | ( |  | ) | const |  | inline | 
| Python: | 
|---|
|  | cv.rgbd.RgbdICPOdometry.getMaxDepthDiff( |  | ) -> | retval | 
 
 
◆ getMaxPointsPart()
  
  | 
        
          | double cv::rgbd::RgbdICPOdometry::getMaxPointsPart | ( |  | ) | const |  | inline | 
| Python: | 
|---|
|  | cv.rgbd.RgbdICPOdometry.getMaxPointsPart( |  | ) -> | retval | 
 
 
◆ getMaxRotation()
  
  | 
        
          | double cv::rgbd::RgbdICPOdometry::getMaxRotation | ( |  | ) | const |  | inline | 
| Python: | 
|---|
|  | cv.rgbd.RgbdICPOdometry.getMaxRotation( |  | ) -> | retval | 
 
 
◆ getMaxTranslation()
  
  | 
        
          | double cv::rgbd::RgbdICPOdometry::getMaxTranslation | ( |  | ) | const |  | inline | 
| Python: | 
|---|
|  | cv.rgbd.RgbdICPOdometry.getMaxTranslation( |  | ) -> | retval | 
 
 
◆ getMinDepth()
  
  | 
        
          | double cv::rgbd::RgbdICPOdometry::getMinDepth | ( |  | ) | const |  | inline | 
| Python: | 
|---|
|  | cv.rgbd.RgbdICPOdometry.getMinDepth( |  | ) -> | retval | 
 
 
◆ getMinGradientMagnitudes()
  
  | 
        
          | cv::Mat cv::rgbd::RgbdICPOdometry::getMinGradientMagnitudes | ( |  | ) | const |  | inline | 
| Python: | 
|---|
|  | cv.rgbd.RgbdICPOdometry.getMinGradientMagnitudes( |  | ) -> | retval | 
 
 
◆ getNormalsComputer()
  
  | 
        
          | Ptr<RgbdNormals> cv::rgbd::RgbdICPOdometry::getNormalsComputer | ( |  | ) | const |  | inline | 
| Python: | 
|---|
|  | cv.rgbd.RgbdICPOdometry.getNormalsComputer( |  | ) -> | retval | 
 
 
◆ getTransformType()
  
  | 
        
          | int cv::rgbd::RgbdICPOdometry::getTransformType | ( |  | ) | const |  | inlinevirtual | 
| Python: | 
|---|
|  | cv.rgbd.RgbdICPOdometry.getTransformType( |  | ) -> | retval | 
 
 
◆ prepareFrameCache()
  
  | 
        
          | virtual Size cv::rgbd::RgbdICPOdometry::prepareFrameCache | ( | Ptr< OdometryFrame > & | frame, |  
          |  |  | int | cacheType |  
          |  | ) |  | const |  | virtual | 
| Python: | 
|---|
|  | cv.rgbd.RgbdICPOdometry.prepareFrameCache( | frame, cacheType | ) -> | retval | 
 
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. 
- Parameters
- 
  
    | frame | The odometry which will process the frame. |  | cacheType | The cache type: CACHE_SRC, CACHE_DST or CACHE_ALL. |  
 
Reimplemented from cv::rgbd::Odometry.
 
 
◆ setCameraMatrix()
  
  | 
        
          | void cv::rgbd::RgbdICPOdometry::setCameraMatrix | ( | const cv::Mat & | val | ) |  |  | inlinevirtual | 
| Python: | 
|---|
|  | cv.rgbd.RgbdICPOdometry.setCameraMatrix( | val | ) -> | None | 
 
 
◆ setIterationCounts()
  
  | 
        
          | void cv::rgbd::RgbdICPOdometry::setIterationCounts | ( | const cv::Mat & | val | ) |  |  | inline | 
| Python: | 
|---|
|  | cv.rgbd.RgbdICPOdometry.setIterationCounts( | val | ) -> | None | 
 
 
◆ setMaxDepth()
  
  | 
        
          | void cv::rgbd::RgbdICPOdometry::setMaxDepth | ( | double | val | ) |  |  | inline | 
| Python: | 
|---|
|  | cv.rgbd.RgbdICPOdometry.setMaxDepth( | val | ) -> | None | 
 
 
◆ setMaxDepthDiff()
  
  | 
        
          | void cv::rgbd::RgbdICPOdometry::setMaxDepthDiff | ( | double | val | ) |  |  | inline | 
| Python: | 
|---|
|  | cv.rgbd.RgbdICPOdometry.setMaxDepthDiff( | val | ) -> | None | 
 
 
◆ setMaxPointsPart()
  
  | 
        
          | void cv::rgbd::RgbdICPOdometry::setMaxPointsPart | ( | double | val | ) |  |  | inline | 
| Python: | 
|---|
|  | cv.rgbd.RgbdICPOdometry.setMaxPointsPart( | val | ) -> | None | 
 
 
◆ setMaxRotation()
  
  | 
        
          | void cv::rgbd::RgbdICPOdometry::setMaxRotation | ( | double | val | ) |  |  | inline | 
| Python: | 
|---|
|  | cv.rgbd.RgbdICPOdometry.setMaxRotation( | val | ) -> | None | 
 
 
◆ setMaxTranslation()
  
  | 
        
          | void cv::rgbd::RgbdICPOdometry::setMaxTranslation | ( | double | val | ) |  |  | inline | 
| Python: | 
|---|
|  | cv.rgbd.RgbdICPOdometry.setMaxTranslation( | val | ) -> | None | 
 
 
◆ setMinDepth()
  
  | 
        
          | void cv::rgbd::RgbdICPOdometry::setMinDepth | ( | double | val | ) |  |  | inline | 
| Python: | 
|---|
|  | cv.rgbd.RgbdICPOdometry.setMinDepth( | val | ) -> | None | 
 
 
◆ setMinGradientMagnitudes()
  
  | 
        
          | void cv::rgbd::RgbdICPOdometry::setMinGradientMagnitudes | ( | const cv::Mat & | val | ) |  |  | inline | 
| Python: | 
|---|
|  | cv.rgbd.RgbdICPOdometry.setMinGradientMagnitudes( | val | ) -> | None | 
 
 
◆ setTransformType()
  
  | 
        
          | void cv::rgbd::RgbdICPOdometry::setTransformType | ( | int | val | ) |  |  | inlinevirtual | 
| Python: | 
|---|
|  | cv.rgbd.RgbdICPOdometry.setTransformType( | val | ) -> | None | 
 
 
◆ cameraMatrix
  
  | 
        
          | Mat cv::rgbd::RgbdICPOdometry::cameraMatrix |  | protected | 
 
 
◆ iterCounts
  
  | 
        
          | Mat cv::rgbd::RgbdICPOdometry::iterCounts |  | protected | 
 
 
◆ maxDepth
  
  | 
        
          | double cv::rgbd::RgbdICPOdometry::maxDepth |  | protected | 
 
 
◆ maxDepthDiff
  
  | 
        
          | double cv::rgbd::RgbdICPOdometry::maxDepthDiff |  | protected | 
 
 
◆ maxPointsPart
  
  | 
        
          | double cv::rgbd::RgbdICPOdometry::maxPointsPart |  | protected | 
 
 
◆ maxRotation
  
  | 
        
          | double cv::rgbd::RgbdICPOdometry::maxRotation |  | protected | 
 
 
◆ maxTranslation
  
  | 
        
          | double cv::rgbd::RgbdICPOdometry::maxTranslation |  | protected | 
 
 
◆ minDepth
  
  | 
        
          | double cv::rgbd::RgbdICPOdometry::minDepth |  | protected | 
 
 
◆ minGradientMagnitudes
  
  | 
        
          | Mat cv::rgbd::RgbdICPOdometry::minGradientMagnitudes |  | protected | 
 
 
◆ normalsComputer
◆ transformType
  
  | 
        
          | int cv::rgbd::RgbdICPOdometry::transformType |  | protected | 
 
 
The documentation for this class was generated from the following file: