Type Definition nalgebra::geometry::Point2

type Point2<N> = Point<N, U2>;

A statically sized 2-dimensional column point.

Trait Implementations

impl<N: Real> Mul<Point2<N>> for UnitComplex<N> where
    DefaultAllocator: Allocator<N, U2, U1>, 

type Output = Point2<N>

The resulting type after applying the * operator.

fn mul(self, rhs: Point2<N>) -> Self::Output

Performs the * operation.

impl<'a, N: Real> Mul<Point2<N>> for &'a UnitComplex<N> where
    DefaultAllocator: Allocator<N, U2, U1>, 

type Output = Point2<N>

The resulting type after applying the * operator.

fn mul(self, rhs: Point2<N>) -> Self::Output

Performs the * operation.

impl<'b, N: Real> Mul<&'b Point2<N>> for UnitComplex<N> where
    DefaultAllocator: Allocator<N, U2, U1>, 

type Output = Point2<N>

The resulting type after applying the * operator.

fn mul(self, rhs: &'b Point2<N>) -> Self::Output

Performs the * operation.

impl<'a, 'b, N: Real> Mul<&'b Point2<N>> for &'a UnitComplex<N> where
    DefaultAllocator: Allocator<N, U2, U1>, 

type Output = Point2<N>

The resulting type after applying the * operator.

fn mul(self, rhs: &'b Point2<N>) -> Self::Output

Performs the * operation.

impl<N: Real> Transformation<Point2<N>> for UnitComplex<N> where
    DefaultAllocator: Allocator<N, U2>, 

fn transform_point(&self, pt: &Point2<N>) -> Point2<N>

Applies this group's action on a point from the euclidean space.

fn transform_vector(&self, v: &Vector2<N>) -> Vector2<N>

Applies this group's action on a vector from the euclidean space.

impl<N: Real> ProjectiveTransformation<Point2<N>> for UnitComplex<N> where
    DefaultAllocator: Allocator<N, U2>, 

fn inverse_transform_point(&self, pt: &Point2<N>) -> Point2<N>

Applies this group's inverse action on a point from the euclidean space.

fn inverse_transform_vector(&self, v: &Vector2<N>) -> Vector2<N>

Applies this group's inverse action on a vector from the euclidean space.

impl<N: Real> AffineTransformation<Point2<N>> for UnitComplex<N> where
    DefaultAllocator: Allocator<N, U2>, 

type Rotation = Self

Type of the first rotation to be applied.

type NonUniformScaling = Id

Type of the non-uniform scaling to be applied.

type Translation = Id

The type of the pure translation part of this affine transformation.

fn decompose(&self) -> (Id, Self, Id, Self)

Decomposes this affine transformation into a rotation followed by a non-uniform scaling, followed by a rotation, followed by a translation.

fn append_translation(&self, _: &Self::Translation) -> Self

Appends a translation to this similarity.

fn prepend_translation(&self, _: &Self::Translation) -> Self

Prepends a translation to this similarity.

fn append_rotation(&self, r: &Self::Rotation) -> Self

Appends a rotation to this similarity.

fn prepend_rotation(&self, r: &Self::Rotation) -> Self

Prepends a rotation to this similarity.

fn append_scaling(&self, _: &Self::NonUniformScaling) -> Self

Appends a scaling factor to this similarity.

fn prepend_scaling(&self, _: &Self::NonUniformScaling) -> Self

Prepends a scaling factor to this similarity.

fn append_rotation_wrt_point(&self, r: &Self::Rotation, p: &E) -> Option<Self>

Appends to this similarity a rotation centered at the point p, i.e., this point is left invariant.

impl<N: Real> Similarity<Point2<N>> for UnitComplex<N> where
    DefaultAllocator: Allocator<N, U2>, 

type Scaling = Id

The type of the pure (uniform) scaling part of this similarity transformation.

fn translation(&self) -> Id

The pure translational component of this similarity transformation.

fn rotation(&self) -> Self

The pure rotational component of this similarity transformation.

fn scaling(&self) -> Id

The pure scaling component of this similarity transformation.

fn translate_point(&self, pt: &E) -> E

Applies this transformation's pure translational part to a point.

fn rotate_point(&self, pt: &E) -> E

Applies this transformation's pure rotational part to a point.

fn scale_point(&self, pt: &E) -> E

Applies this transformation's pure scaling part to a point.

fn rotate_vector(
    &self,
    pt: &<E as EuclideanSpace>::Coordinates
) -> <E as EuclideanSpace>::Coordinates

Applies this transformation's pure rotational part to a vector.

fn scale_vector(
    &self,
    pt: &<E as EuclideanSpace>::Coordinates
) -> <E as EuclideanSpace>::Coordinates

Applies this transformation's pure scaling part to a vector.

fn inverse_translate_point(&self, pt: &E) -> E

Applies this transformation inverse's pure translational part to a point.

fn inverse_rotate_point(&self, pt: &E) -> E

Applies this transformation inverse's pure rotational part to a point.

fn inverse_scale_point(&self, pt: &E) -> E

Applies this transformation inverse's pure scaling part to a point.

fn inverse_rotate_vector(
    &self,
    pt: &<E as EuclideanSpace>::Coordinates
) -> <E as EuclideanSpace>::Coordinates

Applies this transformation inverse's pure rotational part to a vector.

fn inverse_scale_vector(
    &self,
    pt: &<E as EuclideanSpace>::Coordinates
) -> <E as EuclideanSpace>::Coordinates

Applies this transformation inverse's pure scaling part to a vector.

impl<N: Real> Isometry<Point2<N>> for UnitComplex<N> where
    DefaultAllocator: Allocator<N, U2>, 

impl<N: Real> DirectIsometry<Point2<N>> for UnitComplex<N> where
    DefaultAllocator: Allocator<N, U2>, 

impl<N: Real> OrthogonalTransformation<Point2<N>> for UnitComplex<N> where
    DefaultAllocator: Allocator<N, U2>, 

impl<N: Real> Rotation<Point2<N>> for UnitComplex<N> where
    DefaultAllocator: Allocator<N, U2>, 

fn powf(&self, n: N) -> Option<Self>

Raises this rotation to a power. If this is a simple rotation, the result must be equivalent to multiplying the rotation angle by n.

fn rotation_between(a: &Vector2<N>, b: &Vector2<N>) -> Option<Self>

Computes a simple rotation that makes the angle between a and b equal to zero, i.e., b.angle(a * delta_rotation(a, b)) = 0. If a and b are collinear, the computed rotation may not be unique. Returns None if no such simple rotation exists in the subgroup represented by Self.

fn scaled_rotation_between(a: &Vector2<N>, b: &Vector2<N>, s: N) -> Option<Self>

Computes the rotation between a and b and raises it to the power n.