Struct opencv::line_descriptor::KeyLine

#[repr(C)]
pub struct KeyLine {

    pub angle: f32,
    pub class_id: i32,
    pub octave: i32,
    pub pt: Point2f,
    pub response: f32,
    pub size: f32,
    pub start_point_x: f32,
    pub start_point_y: f32,
    pub end_point_x: f32,
    pub end_point_y: f32,
    pub s_point_in_octave_x: f32,
    pub s_point_in_octave_y: f32,
    pub e_point_in_octave_x: f32,
    pub e_point_in_octave_y: f32,
    pub line_length: f32,
    pub num_of_pixels: i32,
}

A class to represent a line

As aformentioned, it is been necessary to design a class that fully stores the information needed to characterize completely a line and plot it on image it was extracted from, when required.

KeyLine class has been created for such goal; it is mainly inspired to Feature2d’s KeyPoint class, since KeyLine shares some of KeyPoint’s fields, even if a part of them assumes a different meaning, when speaking about lines. In particular:

• the class_id field is used to gather lines extracted from different octaves which refer to same line inside original image (such lines and the one they represent in original image share the same class_id value)
• the angle field represents line’s slope with respect to (positive) X axis
• the pt field represents line’s midpoint
• the response field is computed as the ratio between the line’s length and maximum between image’s width and height
• the size field is the area of the smallest rectangle containing line

Apart from fields inspired to KeyPoint class, KeyLines stores information about extremes of line in original image and in octave it was extracted from, about line’s length and number of pixels it covers.

Fields

angle: f32

orientation of the line

class_id: i32

object ID, that can be used to cluster keylines by the line they represent

octave: i32

octave (pyramid layer), from which the keyline has been extracted

pt: Point2f

coordinates of the middlepoint

response: f32

the response, by which the strongest keylines have been selected. It’s represented by the ratio between line’s length and maximum between image’s width and height

size: f32

minimum area containing line

start_point_x: f32

lines’s extremes in original image

start_point_y: f32

end_point_x: f32

end_point_y: f32

s_point_in_octave_x: f32

line’s extremes in image it was extracted from

s_point_in_octave_y: f32

e_point_in_octave_x: f32

e_point_in_octave_y: f32

line_length: f32

the length of line

num_of_pixels: i32

number of pixels covered by the line

Implementations

impl KeyLine

pub fn get_start_point(self) -> Result<Point2f>

Returns the start point of the line in the original image

pub fn get_end_point(self) -> Result<Point2f>

Returns the end point of the line in the original image

pub fn get_start_point_in_octave(self) -> Result<Point2f>

Returns the start point of the line in the octave it was extracted from

pub fn get_end_point_in_octave(self) -> Result<Point2f>

Returns the end point of the line in the octave it was extracted from

pub fn default() -> Result<KeyLine>

constructor

Trait Implementations

impl Clone for KeyLine

fn clone(&self) -> KeyLine

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for KeyLine

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl PartialEq for KeyLine

fn eq(&self, other: &KeyLine) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Copy for KeyLine

impl StructuralPartialEq for KeyLine

impl VectorElement for KeyLine

where Vector<KeyLine>: VectorExtern<KeyLine>,