Struct efd::Efd

pub struct Efd<D: EfdDim> { /* private fields */ }

Elliptical Fourier Descriptor coefficients. Provide transformation between discrete points and coefficients.

Start with Efd::from_curve() and its related methods.

Transformation

The transformation of normalized coefficients.

Implements Kuhl and Giardina method of normalizing the coefficients An, Bn, Cn, Dn. Performs 3 separate normalizations. First, it makes the data location invariant by re-scaling the data to a common origin. Secondly, the data is rotated with respect to the major axis. Thirdly, the coefficients are normalized with regard to the absolute value of A₁.

Please see Transform for more information.

Raw Coefficients

The coefficients is contained with na::Matrix, use Efd::try_from_coeffs() to input the coefficients externally.

Use Efd::into_inner() to get the matrix of the coefficients.

Implementations

impl<D: EfdDim> Efd<D>

pub fn try_from_coeffs(coeffs: Coeff<D>) -> Option<Self>

Create object from a 2D array with boundary check and normalization.

The array size is (harmonic) x (dimension x 2). The dimension is CoordHint::Dim.

Return none if the harmonic is zero.

pub fn try_from_coeffs_unnorm(coeffs: Coeff<D>) -> Option<Self>

Create object from a 2D array with boundary check.

The array size is (harmonic) x (dimension x 2). The dimension is CoordHint::Dim.

Return none if the harmonic is zero.

pub fn from_coeffs_unchecked(coeffs: Coeff<D>) -> Self

Create object from a 2D array directly.

The array size is (harmonic) x (dimension x 2). The dimension is CoordHint::Dim.

Zero harmonic is allowed but meaningless. If the harmonic is zero, some operations will panic.

use efd::{Coeff2, Efd2};
let coeff = Coeff2::from_column_slice(&[]);
let path = Efd2::from_coeffs_unchecked(coeff).generate(20);
assert_eq!(path.len(), 0);

pub fn from_curve<C>(curve: C, is_open: bool) -> Self

where C: Curve<Coord<D>>,

Fully automated coefficient calculation.

1. The initial harmonic number is the same as the curve point.
2. Fourier Power Anaysis (FPA) uses 99.99% threshold.

Tail End Closed

If curve.first() != curve.last(), the curve will be automatically closed when is_open is false.

Open Curve Option

The open curve option is for the curve that duplicated a reversed part of itself. For example,

let efd = efd::Efd2::from_curve(path_open, true);

is equivalent to

let path_closed = path_open
    .iter()
    .chain(path_open.iter().rev().skip(1))
    .cloned()
    .collect::<Vec<_>>();
let efd = efd::Efd2::from_curve(path_closed, false);

but not actually increase the data size.

Panics

Panics if the curve length is not greater than 2 in debug mode. This function check the lengths only. Please use valid_curve() to verify the curve if there has NaN input.

pub fn from_curve_nyquist<C>(curve: C, is_open: bool) -> Self

where C: Curve<Coord<D>>,

Same as Efd::from_curve(), but if your sampling points are large, use Nyquist Frequency as an initial harmonic number.

Nyquist Frequency is half of the sample number.

Please ensure the sampling points are generated from a known function and are more than enough. Otherwise, it will cause undersampling.

pub fn from_curve_harmonic<C>(curve: C, is_open: bool, harmonic: usize) -> Self

where C: Curve<Coord<D>>,

Manual coefficient calculation.

1. The initial harmonic is decide by user.
2. No harmonic reduced. Please call Efd::fourier_power_anaysis().

Panics

Panics if the specific harmonic is zero or the curve length is not greater than 2 in the debug mode. This function check the lengths only. Please use valid_curve() to verify the curve if there has NaN input.

pub fn from_curve_harmonic_unnorm<C>( curve: C, is_open: bool, harmonic: usize ) -> Self

where C: Curve<Coord<D>>,

Same as Efd::from_curve_harmonic() but without normalization.

pub fn with_geo(self, geo: GeoVar<D::Trans>) -> Self

A builder method for changing geometric variables.

pub fn fourier_power_anaysis<T>(self, threshold: T) -> Self

where Option<f64>: From<T>,

Use Fourier Power Anaysis (FPA) to reduce the harmonic number.

The coefficient memory will be saved but cannot be used twice due to undersampling.

The default threshold is 99.99%.

Panics

Panics if the threshold is not in 0..1, or the harmonic is zero.

pub fn normalized(self) -> Self

Force normalize the coefficients.

If the coefficients are constructed by *_unnorm or *_unchecked methods, this method will normalize them.

Panics

Panics if the harmonic is zero.

pub fn into_inner(self) -> Coeff<D>

Consume self and return a raw array of the coefficients.

pub fn coeffs(&self) -> &Coeff<D>

Get a reference to the coefficients.

pub fn coeff(&self, harmonic: usize) -> CKernel<'_, D>

Get a view to the specific coefficients. (0..self.harmonic())

pub fn coeffs_iter(&self) -> impl Iterator<Item = CKernel<'_, D>>

Get an iterator over all the coefficients per harmonic.

pub fn coeffs_iter_mut(&mut self) -> impl Iterator<Item = CKernelMut<'_, D>>

Get a mutable iterator over all the coefficients per harmonic.

pub fn as_geo(&self) -> &GeoVar<D::Trans>

Get the reference of geometric variables.

pub fn as_geo_mut(&mut self) -> &mut GeoVar<D::Trans>

Get the mutable reference of geometric variables.

pub fn harmonic(&self) -> usize

Get the harmonic number of the coefficients.

pub fn is_valid(&self) -> bool

Check if the coefficients are valid.

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

Calculate the L1 distance between two coefficient set.

For more distance methods, please see Distance.

pub fn reverse_inplace(&mut self)

Reverse the order of described curve then return a mutable reference.

pub fn reversed(self) -> Self

Consume and return a reversed version of the coefficients. This method can avoid mutable require.

Please clone the object if you want to do self-comparison.

pub fn generate(&self, n: usize) -> Vec<Coord<D>>

Generate the described curve. (theta=TAU)

Panics

Panics if the number of the points n is less than 2.

pub fn generate_half(&self, n: usize) -> Vec<Coord<D>>

Generate a half of the described curve. (theta=PI)

Panics

Panics if the number of the points n is less than 2.

pub fn generate_in(&self, n: usize, theta: f64) -> Vec<Coord<D>>

Generate the described curve in a specific angle theta (0..=TAU).

Panics

Panics if the number of the points n is less than 2.

pub fn generate_norm_in(&self, n: usize, theta: f64) -> Vec<Coord<D>>

Generate a normalized curve in a specific angle theta (0..=TAU).

Normalized curve is without transformation.

Panics

Panics if the number of the points n is less than 2.

Trait Implementations

impl<D: Clone + EfdDim> Clone for Efd<D>

where D::Trans: Clone,

fn clone(&self) -> Efd<D>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<D: EfdDim> Debug for Efd<D>

where GeoVar<D::Trans>: Debug,

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

Formats the value using the given formatter.

impl<D: EfdDim> Distance for Efd<D>

fn err_buf(&self, rhs: &Self) -> Vec<f64>

Calculate the error between each pair of datas.

fn square_err(&self, rhs: &Self) -> f64

Calculate the square error.

fn l0_norm(&self, rhs: &Self) -> f64

Calculate the L0 norm of the error.

fn l1_norm(&self, rhs: &Self) -> f64

Calculate the L1 norm of the error.

fn l2_norm(&self, rhs: &Self) -> f64

Calculate the L2 norm of the error.

fn lp_norm(&self, rhs: &Self, p: i32) -> f64

Calculate the Lp norm of the error.