Struct efd::Efd

pub struct Efd<const D: usize>
where
    U<D>: EfdDim<D>,
{ /* private fields */ }

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

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

Normalization

The geometric normalization of EFD 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 Efd::as_geo() and GeoVar for more information.

Implementations

impl<const D: usize> Efd<D>

where U<D>: EfdDim<D>,

pub fn from_parts_unchecked(coeffs: Coeffs<D>, geo: GeoVar<Rot<D>, D>) -> Self

Create object from coefficients and geometric variables.

Raw Coefficients

There is no “check method” for the input coefficients. Please use Efd::from_curve() and its related methods to create the object. This method is designed for loading coefficients from external sources.

See also Efd::from_coeffs_unchecked() and Efd::into_inner().

Panics

Panics if the harmonic is zero. (coeffs.len() == 0)

use efd::{Efd2, GeoVar};
let curve = Efd2::from_parts_unchecked(vec![], GeoVar::identity()).recon(20);

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

Create object from coefficients without check.

Panics

Panics if the harmonic is zero. (coeffs.len() == 0)

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

where C: Curve<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(curve_open, true);

is equivalent to

let curve_closed = curve_open
    .iter()
    .chain(curve_open.iter().rev().skip(1))
    .cloned()
    .collect::<Vec<_>>();
let efd = efd::Efd2::from_curve(curve_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<D>,

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

Please ensure the sampling points meet the Nyquist–Shannon sampling theorem.

See also harmonic_nyquist.

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

where C: Curve<D>,

Manual coefficient calculation.

1. The initial harmonic is decided by user.
   • harmonic() is used in Efd::from_curve().
   • harmonic_nyquist() is used in Efd::from_curve_nyquist().
2. No harmonic reduced.
   • Please call Efd::fourier_power_anaysis() manually.

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<D>,

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

Please call Efd::normalized() if you want to normalize later.

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

where Option<f64>: From<T>,

A builder method using 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 set_harmonic(&mut self, harmonic: usize)

Set the harmonic number of the coefficients.

Panics

Panics if the harmonic is zero or greater than the current harmonic.

pub fn normalized(self) -> Self

Force normalize the coefficients.

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

See also Efd::from_curve_harmonic_unnorm().

Panics

Panics if the harmonic is zero.

pub fn into_inner(self) -> (Coeffs<D>, GeoVar<Rot<D>, D>)

Consume self and return the parts of this type.

See also Efd::from_parts_unchecked().

pub fn coeffs(&self) -> &[Kernel<D>]

Get a reference to the coefficients.

pub fn coeff(&self, harmonic: usize) -> &Kernel<D>

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

pub fn coeffs_iter(&self) -> impl Iterator<Item = &Kernel<D>>

Get an iterator over all the coefficients per harmonic.

pub fn coeffs_iter_mut(&mut self) -> impl Iterator<Item = &mut Kernel<D>>

Get a mutable iterator over all the coefficients per harmonic.

Warning: If you want to change the coefficients, the geometric variables will be wrong.

pub fn as_geo(&self) -> &GeoVar<Rot<D>, D>

Get the reference of geometric variables.

pub fn as_geo_mut(&mut self) -> &mut GeoVar<Rot<D>, D>

Get the mutable reference of geometric variables.

pub fn is_open(&self) -> bool

Check if the descibed curve is open.

pub fn harmonic(&self) -> usize

Get the harmonic number of the coefficients.

pub fn is_valid(&self) -> bool

Check if the coefficients are valid.

• The harmonic number must be greater than 0.
• All the coefficients must be finite number.

It is only helpful if this object is constructed by Efd::from_parts_unchecked().

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

Calculate the L1 distance between two coefficient set.

For more distance methods, please see Distance.

pub fn err_sig(&self, sig: &PathSig<D>) -> f64

Calculate the distance from a PathSig.

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.

pub fn recon(&self, n: usize) -> Vec<[f64; D]>

Reconstruct the described curve.

If the described curve is open, the time series is 0..PI instead of 0..TAU.

pub fn recon_norm(&self, n: usize) -> Vec<[f64; D]>

Reconstruct the described curve. (t=0~TAU)

Normalized curve is without transformation.

pub fn recon_by(&self, t: &[f64]) -> Vec<[f64; D]>

Reconstruct a described curve in a time series t.

let efd = efd::Efd2::from_curve(curve, false);
let sig = efd::PathSig::new(curve, false);
let curve_recon = efd.recon_by(sig.as_t());

See also PathSig.

pub fn recon_norm_by(&self, t: &[f64]) -> Vec<[f64; D]>

Reconstruct a normalized curve in a time series t.

Normalized curve is without transformation.

See also Efd::recon_by().

Trait Implementations

impl<const D: usize> Clone for Efd<D>

where U<D>: EfdDim<D>,

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

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<const D: usize> Debug for Efd<D>

where U<D>: EfdDim<D>,

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

Formats the value using the given formatter.

impl<const D: usize> Distance for Efd<D>

where U<D>: EfdDim<D>,

fn as_components(&self) -> impl Iterator<Item = &f64>

Get the components of the data.

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

Calculate the square error.

fn l0_err(&self, rhs: &impl Distance) -> f64

Calculate the L0 norm of the error.

fn l1_err(&self, rhs: &impl Distance) -> f64

Calculate the L1 norm of the error.

fn l2_err(&self, rhs: &impl Distance) -> f64

Calculate the L2 norm of the error.

fn lp_err(&self, rhs: &impl Distance, p: f64) -> f64

Calculate the Lp norm of the error.

fn linf_err(&self, rhs: &impl Distance) -> f64

Calculate the Linf norm of the error.

fn l0_norm(&self) -> f64

Calculate the norm (vector length) according to the origin (zeros).

fn l1_norm(&self) -> f64

Calculate the norm (vector length) according to the origin (zeros).

fn l2_norm(&self) -> f64

Calculate the norm (vector length) according to the origin (zeros).

fn linf_norm(&self) -> f64

Calculate the norm (vector length) according to the origin (zeros).

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

Calculate the norm (vector length) according to the origin (zeros).