Struct GeoVar 

pub struct GeoVar<R: RotHint<D>, const D: usize> { /* private fields */ }

Geometric variables.

This type record the information of raw coefficients. You can merge two instance with */*= operator.

use efd::{tests::*, Efd2};

let a = Efd2::from_curve(curve1, false);
let b = Efd2::from_curve(curve2, false);
let geo = b.as_geo() * a.as_geo().inverse();
assert!(curve_diff(&geo.transform(curve1), curve2) < EPS);

Implementations

impl<R, const D: usize> GeoVar<R, D>

where R: RotHint<D>,

pub fn identity() -> Self

Create a new identity instance.

pub fn new(trans: [f64; D], rot: R, scale: f64) -> Self

Create a new instance.

pub fn from_trans(trans: [f64; D]) -> Self

Create a new instance from translation.

pub fn from_rot(rot: R) -> Self

Create a new instance from rotation.

pub fn from_scale(scale: f64) -> Self

Create a new instance from rotation.

pub fn only_trans(self) -> Self

Create a new instance from translation.

pub fn only_rot(self) -> Self

Create a new instance from rotation.

pub fn only_rot_scale(self) -> Self

Create a new instance from rotation and scaling.

pub fn with_trans(self, trans: [f64; D]) -> Self

With the translate property.

pub fn with_rot(self, rot: R) -> Self

With the rotation property.

pub fn with_scale(self, scale: f64) -> Self

With the scaling property.

pub fn to(&self, rhs: &Self) -> Self

Merge inverse self and rhs. (rhs * self^T)

It can be used on a not normalized contour a transforming to b.

use efd::{tests::*, Efd2};

let a = Efd2::from_curve(curve1, false);
let b = Efd2::from_curve(curve2, false);
let geo = a.as_geo().to(b.as_geo());
assert!(curve_diff(&geo.transform(curve1), curve2) < EPS);

pub fn inverse(&self) -> Self

Inverse self. (self^T/self^-1)

use efd::{tests::*, Efd2};

let efd = Efd2::from_curve(curve, false);
let curve = efd.recon(curve.len());
let curve_norm = efd.recon_norm(curve.len());
let curve = efd.as_geo().inverse().transform(curve);

pub fn trans(&self) -> &[f64; D]

Get the translate property.

pub fn rot(&self) -> &R

Get the rotation property.

pub fn scale(&self) -> f64

Get the scaling property.

pub fn set_trans(&mut self, trans: [f64; D])

Set the translate property.

pub fn set_rot(&mut self, rot: R)

Set the rotation property.

pub fn set_scale(&mut self, scale: f64)

Set the scaling property.

pub fn transform_pt(&self, p: [f64; D]) -> [f64; D]

Transform a point.

Please see GeoVar::transform() for more information.

pub fn transform<C>(&self, curve: C) -> Vec<[f64; D]>

where C: Curve<D>,

Transform a contour with this information.

This function rotates first, then translates.

use efd::{tests::*, *};
let efd = Efd2::from_curve(curve, false);
// Normalize the curve
let curve_norm = efd.as_geo().inverse().transform(&curve);

pub fn transform_inplace<C>(&self, curve: C)

where C: AsMut<[[f64; D]]>,

Transform a contour in-placed with this information.

pub fn transform_iter<'a, C>( &'a self, curve: C, ) -> impl Iterator<Item = [f64; D]> + 'a

where C: IntoIterator<Item = [f64; D]> + 'a,

Transform an iterator contour and return a new iterator.

Trait Implementations

impl<R: Clone + RotHint<D>, const D: usize> Clone for GeoVar<R, D>

fn clone(&self) -> GeoVar<R, D>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<R, const D: usize> Debug for GeoVar<R, D>

where R: RotHint<D>,

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

Formats the value using the given formatter.

impl<R: RotHint<D>, const D: usize> Default for GeoVar<R, D>

fn default() -> Self

Returns the “default value” for a type.

impl<R: RotHint<D>, const D: usize> Mul for GeoVar<R, D>

type Output = GeoVar<R, D>

The resulting type after applying the * operator.

fn mul(self, rhs: GeoVar<R, D>) -> Self::Output

Performs the * operation.

impl<R: RotHint<D>, const D: usize> Mul<&GeoVar<R, D>> for GeoVar<R, D>

type Output = GeoVar<R, D>

The resulting type after applying the * operator.

fn mul(self, rhs: &GeoVar<R, D>) -> Self::Output

Performs the * operation.

impl<R: RotHint<D>, const D: usize> Mul<&GeoVar<R, D>> for &GeoVar<R, D>

type Output = GeoVar<R, D>

The resulting type after applying the * operator.

fn mul(self, rhs: &GeoVar<R, D>) -> Self::Output

Performs the * operation.

impl<R: RotHint<D>, const D: usize> Mul<GeoVar<R, D>> for &GeoVar<R, D>

type Output = GeoVar<R, D>

The resulting type after applying the * operator.

fn mul(self, rhs: GeoVar<R, D>) -> Self::Output

Performs the * operation.

impl<R: RotHint<D>, const D: usize> MulAssign for GeoVar<R, D>

fn mul_assign(&mut self, rhs: Self)

Performs the *= operation.

impl<R: RotHint<D>, const D: usize> MulAssign<&GeoVar<R, D>> for GeoVar<R, D>

fn mul_assign(&mut self, rhs: &Self)

Performs the *= operation.