|  | 
| void | cv::rapid::convertCorrespondencies (InputArray cols, InputArray srcLocations, OutputArray pts2d, InputOutputArray pts3d=noArray(), InputArray mask=noArray()) | 
|  | 
| void | cv::rapid::drawCorrespondencies (InputOutputArray bundle, InputArray cols, InputArray colors=noArray()) | 
|  | 
| void | cv::rapid::drawSearchLines (InputOutputArray img, InputArray locations, const Scalar &color) | 
|  | 
| void | cv::rapid::drawWireframe (InputOutputArray img, InputArray pts2d, InputArray tris, const Scalar &color, int type=LINE_8, bool cullBackface=false) | 
|  | 
| void | cv::rapid::extractControlPoints (int num, int len, InputArray pts3d, InputArray rvec, InputArray tvec, InputArray K, const Size &imsize, InputArray tris, OutputArray ctl2d, OutputArray ctl3d) | 
|  | 
| void | cv::rapid::extractLineBundle (int len, InputArray ctl2d, InputArray img, OutputArray bundle, OutputArray srcLocations) | 
|  | 
| void | cv::rapid::findCorrespondencies (InputArray bundle, OutputArray cols, OutputArray response=noArray()) | 
|  | 
| float | cv::rapid::rapid (InputArray img, int num, int len, InputArray pts3d, InputArray tris, InputArray K, InputOutputArray rvec, InputOutputArray tvec, double *rmsd=0) | 
|  | 
implements "RAPID-a video rate object tracker" [102] with the dynamic control point extraction of [60] 
◆ convertCorrespondencies()
      | Python: | 
|---|
|  | cv.rapid.convertCorrespondencies( | cols, srcLocations[, pts2d[, pts3d[, mask]]] | ) -> | pts2d, pts3d | 
 
#include <opencv2/rapid.hpp>
Collect corresponding 2d and 3d points based on correspondencies and mask 
- Parameters
- 
  
    | cols | correspondence-position per line in line-bundle-space |  | srcLocations | the source image location |  | pts2d | 2d points |  | pts3d | 3d points |  | mask | mask containing non-zero values for the elements to be retained |  
 
 
 
◆ drawCorrespondencies()
      | Python: | 
|---|
|  | cv.rapid.drawCorrespondencies( | bundle, cols[, colors] | ) -> | bundle | 
 
#include <opencv2/rapid.hpp>
Debug draw markers of matched correspondences onto a lineBundle 
- Parameters
- 
  
    | bundle | the lineBundle |  | cols | column coordinates in the line bundle |  | colors | colors for the markers. Defaults to white. |  
 
 
 
◆ drawSearchLines()
      | Python: | 
|---|
|  | cv.rapid.drawSearchLines( | img, locations, color | ) -> | img | 
 
#include <opencv2/rapid.hpp>
Debug draw search lines onto an image 
- Parameters
- 
  
    | img | the output image |  | locations | the source locations of a line bundle |  | color | the line color |  
 
 
 
◆ drawWireframe()
      | Python: | 
|---|
|  | cv.rapid.drawWireframe( | img, pts2d, tris, color[, type[, cullBackface]] | ) -> | img | 
 
#include <opencv2/rapid.hpp>
Draw a wireframe of a triangle mesh 
- Parameters
- 
  
    | img | the output image |  | pts2d | the 2d points obtained by projectPoints |  | tris | triangle face connectivity |  | color | line color |  | type | line type. See LineTypes. |  | cullBackface | enable back-face culling based on CCW order |  
 
 
 
◆ extractControlPoints()
      | Python: | 
|---|
|  | cv.rapid.extractControlPoints( | num, len, pts3d, rvec, tvec, K, imsize, tris[, ctl2d[, ctl3d]] | ) -> | ctl2d, ctl3d | 
 
#include <opencv2/rapid.hpp>
Extract control points from the projected silhouette of a mesh
see [60] Sec 2.1, Step b 
- Parameters
- 
  
    | num | number of control points |  | len | search radius (used to restrict the ROI) |  | pts3d | the 3D points of the mesh |  | rvec | rotation between mesh and camera |  | tvec | translation between mesh and camera |  | K | camera intrinsic |  | imsize | size of the video frame |  | tris | triangle face connectivity |  | ctl2d | the 2D locations of the control points |  | ctl3d | matching 3D points of the mesh |  
 
 
 
◆ extractLineBundle()
      | Python: | 
|---|
|  | cv.rapid.extractLineBundle( | len, ctl2d, img[, bundle[, srcLocations]] | ) -> | bundle, srcLocations | 
 
#include <opencv2/rapid.hpp>
Extract the line bundle from an image 
- Parameters
- 
  
    | len | the search radius. The bundle will have 2*len + 1columns. |  | ctl2d | the search lines will be centered at this points and orthogonal to the contour defined by them. The bundle will have as many rows. |  | img | the image to read the pixel intensities values from |  | bundle | line bundle image with size ctl2d.rows() x (2 * len + 1)and the same type asimg |  | srcLocations | the source pixel locations of bundleinimgas CV_16SC2 |  
 
 
 
◆ findCorrespondencies()
      | Python: | 
|---|
|  | cv.rapid.findCorrespondencies( | bundle[, cols[, response]] | ) -> | cols, response | 
 
#include <opencv2/rapid.hpp>
Find corresponding image locations by searching for a maximal sobel edge along the search line (a single row in the bundle) 
- Parameters
- 
  
    | bundle | the line bundle |  | cols | correspondence-position per line in line-bundle-space |  | response | the sobel response for the selected point |  
 
 
 
◆ rapid()
      | Python: | 
|---|
|  | cv.rapid.rapid( | img, num, len, pts3d, tris, K, rvec, tvec | ) -> | retval, rvec, tvec, rmsd | 
 
#include <opencv2/rapid.hpp>
High level function to execute a single rapid [102] iteration
- extractControlPoints
- extractLineBundle
- findCorrespondencies
- convertCorrespondencies
- solvePnPRefineLM
- Parameters
- 
  
    | img | the video frame |  | num | number of search lines |  | len | search line radius |  | pts3d | the 3D points of the mesh |  | tris | triangle face connectivity |  | K | camera matrix |  | rvec | rotation between mesh and camera. Input values are used as an initial solution. |  | tvec | translation between mesh and camera. Input values are used as an initial solution. |  | rmsd | the 2d reprojection difference |  
 
- Returns
- ratio of search lines that could be extracted and matched