[−][src]Struct cv::WorldPoint

pub struct WorldPoint(pub Point<f64, U3>);

A point in "world" coordinates. This means that the real-world units of the pose are unknown, but the unit of distance and orientation are the same as the current reconstruction.

The reason that the unit of measurement is typically unknown is because if the whole world is scaled by any factor n (excluding the camera itself), then the normalized image coordinates will be exactly same on every frame. Due to this, the scaling of the world is chosen arbitrarily.

To extract the real scale of the world, a known distance between two WorldPoints must be used to scale the whole world (and all translations between cameras). At that point, the world will be appropriately scaled. It is recommended not to make the WorldPoint in the reconstruction scale to the "correct" scale. This is for two reasons:

Firstly, because it is possible for scale drift to occur due to the above situation, the further in the view graph you go from the reference measurement, the more the scale will drift from the reference. It would give a false impression that the scale is known globally when it is only known locally if the whole reconstruction was scaled.

Secondly, as the reconstruction progresses, the reference points might get rescaled as optimization of the reconstruction brings everything into global consistency. This means that, while the reference points would be initially scaled correctly, any graph optimization might cause them to drift in scale as well.

Please scale your points on-demand. When you need to know a real distance in the reconstruction, please use the closest known refenence in the view graph to scale it appropriately. In the future we will add APIs to utilize references as optimization constraints when a known reference reconstruction is present.

Methods from Deref<Target = Point<f64, U3>>

`pub fn to_homogeneous( &self ) -> Matrix<N, <D as DimNameAdd<U1>>::Output, U1, <DefaultAllocator as Allocator<N, <D as DimNameAdd<U1>>::Output, U1>>::Buffer> where D: DimNameAdd<U1>, N: One, DefaultAllocator: Allocator<N, <D as DimNameAdd<U1>>::Output, U1>,` [src]

Converts this point into a vector in homogeneous coordinates, i.e., appends a 1 at the end of it.

This is the same as .into().

Example

let p = Point2::new(10.0, 20.0);
assert_eq!(p.to_homogeneous(), Vector3::new(10.0, 20.0, 1.0));

// This works in any dimension.
let p = Point3::new(10.0, 20.0, 30.0);
assert_eq!(p.to_homogeneous(), Vector4::new(10.0, 20.0, 30.0, 1.0));

`pub fn len(&self) -> usize`[src]

The dimension of this point.

Example

let p = Point2::new(1.0, 2.0);
assert_eq!(p.len(), 2);

// This works in any dimension.
let p = Point3::new(10.0, 20.0, 30.0);
assert_eq!(p.len(), 3);

`pub fn stride(&self) -> usize`[src]

👎 Deprecated:

This methods is no longer significant and will always return 1.

The stride of this point. This is the number of buffer element separating each component of this point.

`pub fn iter( &self ) -> MatrixIter<N, D, U1, <DefaultAllocator as Allocator<N, D, U1>>::Buffer>`[src]

Iterates through this point coordinates.

Example

let p = Point3::new(1.0, 2.0, 3.0);
let mut it = p.iter().cloned();

assert_eq!(it.next(), Some(1.0));
assert_eq!(it.next(), Some(2.0));
assert_eq!(it.next(), Some(3.0));
assert_eq!(it.next(), None);

`pub unsafe fn get_unchecked(&self, i: usize) -> &N`[src]

Gets a reference to i-th element of this point without bound-checking.

`pub fn iter_mut( &mut self ) -> MatrixIterMut<N, D, U1, <DefaultAllocator as Allocator<N, D, U1>>::Buffer>`[src]

Mutably iterates through this point coordinates.

Example

let mut p = Point3::new(1.0, 2.0, 3.0);

for e in p.iter_mut() {
    *e *= 10.0;
}

assert_eq!(p, Point3::new(10.0, 20.0, 30.0));

`pub unsafe fn get_unchecked_mut(&mut self, i: usize) -> &mut N`[src]

Gets a mutable reference to i-th element of this point without bound-checking.

`pub unsafe fn swap_unchecked(&mut self, i1: usize, i2: usize)`[src]

Swaps two entries without bound-checking.

`pub fn inf(&self, other: &Point<N, D>) -> Point<N, D>`[src]

Computes the infimum (aka. componentwise min) of two points.

`pub fn sup(&self, other: &Point<N, D>) -> Point<N, D>`[src]

Computes the supremum (aka. componentwise max) of two points.