Struct opencv::core::KeyPoint

pub struct KeyPoint { /* private fields */ }

Data structure for salient point detectors.

The class instance stores a keypoint, i.e. a point feature found by one of many available keypoint detectors, such as Harris corner detector, #FAST, %StarDetector, %SURF, %SIFT etc.

The keypoint is characterized by the 2D position, scale (proportional to the diameter of the neighborhood that needs to be taken into account), orientation and some other parameters. The keypoint neighborhood is then analyzed by another algorithm that builds a descriptor (usually represented as a feature vector). The keypoints representing the same object in different images can then be matched using %KDTree or another method.

Implementations

impl KeyPoint

pub fn default() -> Result<KeyPoint>

the default constructor

pub fn new_point(
    pt: Point2f,
    size: f32,
    angle: f32,
    response: f32,
    octave: i32,
    class_id: i32
) -> Result<KeyPoint>

Parameters

• pt: x & y coordinates of the keypoint
• size: keypoint diameter
• angle: keypoint orientation
• response: keypoint detector response on the keypoint (that is, strength of the keypoint)
• octave: pyramid octave in which the keypoint has been detected
• class_id: object id

C++ default parameters

• angle: -1
• response: 0
• octave: 0
• class_id: -1

pub fn new_coords(
    x: f32,
    y: f32,
    size: f32,
    angle: f32,
    response: f32,
    octave: i32,
    class_id: i32
) -> Result<KeyPoint>

Parameters

• x: x-coordinate of the keypoint
• y: y-coordinate of the keypoint
• size: keypoint diameter
• angle: keypoint orientation
• response: keypoint detector response on the keypoint (that is, strength of the keypoint)
• octave: pyramid octave in which the keypoint has been detected
• class_id: object id

C++ default parameters

• angle: -1
• response: 0
• octave: 0
• class_id: -1

pub fn convert(
    keypoints: &Vector<KeyPoint>,
    points2f: &mut Vector<Point2f>,
    keypoint_indexes: &Vector<i32>
) -> Result<()>

This method converts vector of keypoints to vector of points or the reverse, where each keypoint is assigned the same size and the same orientation.

Parameters

• keypoints: Keypoints obtained from any feature detection algorithm like SIFT/SURF/ORB
• points2f: Array of (x,y) coordinates of each keypoint
• keypointIndexes: Array of indexes of keypoints to be converted to points. (Acts like a mask to convert only specified keypoints)

C++ default parameters

• keypoint_indexes: std::vector()

pub fn convert_to(
    points2f: &Vector<Point2f>,
    keypoints: &mut Vector<KeyPoint>,
    size: f32,
    response: f32,
    octave: i32,
    class_id: i32
) -> Result<()>

This method converts vector of keypoints to vector of points or the reverse, where each keypoint is assigned the same size and the same orientation.

Parameters

• keypoints: Keypoints obtained from any feature detection algorithm like SIFT/SURF/ORB
• points2f: Array of (x,y) coordinates of each keypoint
• keypointIndexes: Array of indexes of keypoints to be converted to points. (Acts like a mask to convert only specified keypoints)

Overloaded parameters

• points2f: Array of (x,y) coordinates of each keypoint
• keypoints: Keypoints obtained from any feature detection algorithm like SIFT/SURF/ORB
• size: keypoint diameter
• response: keypoint detector response on the keypoint (that is, strength of the keypoint)
• octave: pyramid octave in which the keypoint has been detected
• class_id: object id

C++ default parameters

• size: 1
• response: 1
• octave: 0
• class_id: -1

pub fn overlap(kp1: &KeyPoint, kp2: &KeyPoint) -> Result<f32>

This method computes overlap for pair of keypoints. Overlap is the ratio between area of keypoint regions’ intersection and area of keypoint regions’ union (considering keypoint region as circle). If they don’t overlap, we get zero. If they coincide at same location with same size, we get 1.

Parameters

• kp1: First keypoint
• kp2: Second keypoint

Trait Implementations

impl Boxed for KeyPoint

unsafe fn from_raw(ptr: *mut c_void) -> Self

Wrap the specified raw pointer

fn into_raw(self) -> *mut c_void

Return an the underlying raw pointer while consuming this wrapper.

fn as_raw(&self) -> *const c_void

Return the underlying raw pointer.

fn as_raw_mut(&mut self) -> *mut c_void

Return the underlying mutable raw pointer

impl Drop for KeyPoint

fn drop(&mut self)

Executes the destructor for this type.

impl From<Elliptic_KeyPoint> for KeyPoint

fn from(s: Elliptic_KeyPoint) -> Self

Converts to this type from the input type.

impl KeyPointTrait for KeyPoint

fn as_raw_mut_KeyPoint(&mut self) -> *mut c_void

fn set_pt(&mut self, val: Point2f)

coordinates of the keypoints

fn set_size(&mut self, val: f32)

diameter of the meaningful keypoint neighborhood

fn set_angle(&mut self, val: f32)

computed orientation of the keypoint (-1 if not applicable); it’s in [0,360) degrees and measured relative to image coordinate system, ie in clockwise.

fn set_response(&mut self, val: f32)

the response by which the most strong keypoints have been selected. Can be used for the further sorting or subsampling

fn set_octave(&mut self, val: i32)

octave (pyramid layer) from which the keypoint has been extracted

fn set_class_id(&mut self, val: i32)

object class (if the keypoints need to be clustered by an object they belong to)

impl KeyPointTraitConst for KeyPoint

fn as_raw_KeyPoint(&self) -> *const c_void

fn pt(&self) -> Point2f

coordinates of the keypoints

fn size(&self) -> f32

diameter of the meaningful keypoint neighborhood

fn angle(&self) -> f32

computed orientation of the keypoint (-1 if not applicable); it’s in [0,360) degrees and measured relative to image coordinate system, ie in clockwise.

fn response(&self) -> f32

the response by which the most strong keypoints have been selected. Can be used for the further sorting or subsampling

fn octave(&self) -> i32

octave (pyramid layer) from which the keypoint has been extracted

fn class_id(&self) -> i32

object class (if the keypoints need to be clustered by an object they belong to)

fn hash(&self) -> Result<size_t>

impl Send for KeyPoint

impl VectorElement for KeyPointwhere
    Vector<KeyPoint>: VectorExtern<KeyPoint>,