#include <opencv2/rgbd/depth.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: