Struct cam_geom::Camera

pub struct Camera<R, I> where
    I: IntrinsicParameters<R>,
    R: RealField,  { /* fields omitted */ }

A camera model that can convert world coordinates into pixel coordinates.

Examples

Creates a new perspective camera:

use cam_geom::*;
use nalgebra::*;

// perepective parameters - focal length of 100, no skew, pixel center at (640,480)
let intrinsics = IntrinsicParametersPerspective::from(PerspectiveParams {
    fx: 100.0,
    fy: 100.0,
    skew: 0.0,
    cx: 640.0,
    cy: 480.0,
});

// Set extrinsic parameters - camera at (10,0,10), looing at (0,0,0), up (0,0,1)
let camcenter = Vector3::new(10.0, 0.0, 10.0);
let lookat = Vector3::new(0.0, 0.0, 0.0);
let up = Unit::new_normalize(Vector3::new(0.0, 0.0, 1.0));
let pose = ExtrinsicParameters::from_view(&camcenter, &lookat, &up);

// Create camera with both intrinsic and extrinsic parameters.
let cam = Camera::new(intrinsics, pose);

Creates a new orthographic camera:

use cam_geom::*;
use nalgebra::*;

// orthographic parameters - scale of 100, pixel center at (640,480)
let intrinsics = IntrinsicParametersOrthographic::from(OrthographicParams {
    sx: 100.0,
    sy: 100.0,
    cx: 640.0,
    cy: 480.0,
});

// Set extrinsic parameters - camera at (10,0,10), looing at (0,0,0), up (0,0,1)
let camcenter = Vector3::new(10.0, 0.0, 10.0);
let lookat = Vector3::new(0.0, 0.0, 0.0);
let up = Unit::new_normalize(Vector3::new(0.0, 0.0, 1.0));
let pose = ExtrinsicParameters::from_view(&camcenter, &lookat, &up);

// Create camera with both intrinsic and extrinsic parameters.
let cam = Camera::new(intrinsics, pose);

Methods

impl<R, I> Camera<R, I> where
    I: IntrinsicParameters<R>,
    R: RealField, 

pub fn new(intrinsics: I, extrinsics: ExtrinsicParameters<R>) -> Self

Create a new camera from intrinsic and extrinsic parameters.

Arguments

Intrinsic parameters and extrinsic parameters

pub fn extrinsics(&self) -> &ExtrinsicParameters<R>

Return a reference to the extrinsic parameters.

pub fn intrinsics(&self) -> &I

Return a reference to the intrinsic parameters.

pub fn world_to_pixel<NPTS, InStorage>(
    &self,
    world: &Points<WorldFrame, R, NPTS, InStorage>
) -> Pixels<R, NPTS, Owned<R, NPTS, U2>> where
    NPTS: Dim,
    InStorage: Storage<R, NPTS, U3>,
    DefaultAllocator: Allocator<R, NPTS, U3>,
    DefaultAllocator: Allocator<R, NPTS, U2>, 

take 3D coordinates in world frame and convert to pixel coordinates

pub fn pixel_to_world<IN, NPTS>(
    &self,
    pixels: &Pixels<R, NPTS, IN>
) -> RayBundle<WorldFrame, I::BundleType, R, NPTS, Owned<R, NPTS, U3>> where
    I::BundleType: Bundle<R>,
    IN: Storage<R, NPTS, U2>,
    NPTS: Dim,
    I::BundleType: Bundle<R>,
    DefaultAllocator: Allocator<R, U1, U2>,
    DefaultAllocator: Allocator<R, NPTS, U2>,
    DefaultAllocator: Allocator<R, NPTS, U3>, 

take pixel coordinates and project to 3D in world frame

output arguments: camera - camera frame coordinate rays world - world frame coordinate rays

Note that the camera frame coordinates are returned as they must be computed anyway, so this additional data is "free".

impl<R: RealField> Camera<R, IntrinsicParametersPerspective<R>>

pub fn from_perspective_matrix<S>(
    pmat: &Matrix<R, U3, U4, S>
) -> Result<Self, Error> where
    S: Storage<R, U3, U4> + Clone, 

Create a Camera from a 3x4 perspective projection matrix.

pub fn as_camera_matrix(&self) -> MatrixMN<R, U3, U4>

Create a 3x4 perspective projection matrix modeling this camera.

Trait Implementations

impl<R: Clone, I: Clone> Clone for Camera<R, I> where
    I: IntrinsicParameters<R>,
    R: RealField, 

fn clone(&self) -> Camera<R, I>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<R: Debug, I: Debug> Debug for Camera<R, I> where
    I: IntrinsicParameters<R>,
    R: RealField, 

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

Formats the value using the given formatter.

impl<'de, R, I> Deserialize<'de> for Camera<R, I> where
    I: IntrinsicParameters<R>,
    R: RealField,
    R: Deserialize<'de>,
    I: Deserialize<'de>, 

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error> where
    __D: Deserializer<'de>, 

Deserialize this value from the given Serde deserializer.

impl<R: PartialEq, I: PartialEq> PartialEq<Camera<R, I>> for Camera<R, I> where
    I: IntrinsicParameters<R>,
    R: RealField, 

fn eq(&self, other: &Camera<R, I>) -> bool

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

fn ne(&self, other: &Camera<R, I>) -> bool

This method tests for !=.

impl<R, I> Serialize for Camera<R, I> where
    I: IntrinsicParameters<R>,
    R: RealField,
    R: Serialize,
    I: Serialize, 

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error> where
    __S: Serializer, 

Serialize this value into the given Serde serializer.

impl<R, I> StructuralPartialEq for Camera<R, I> where
    I: IntrinsicParameters<R>,
    R: RealField,