Struct truck_modeling::geometry::Processor

pub struct Processor<E, T> { /* fields omitted */ }

invertible and transformable geometric element

Examples

Curve processing example

use truck_geometry::*;
let curve: BSplineCurve<Point3> = BSplineCurve::new(
    KnotVec::bezier_knot(2),
    vec![
        Point3::new(0.0, 0.0, 0.0),
        Point3::new(0.0, 0.0, 1.0),
        Point3::new(1.0, 0.0, 0.0),
    ],
);
let mut processed = Processor::<_, Matrix4>::new(curve.clone());

// both curves are the same curve
const N: usize = 100;
for i in 0..=N {
    let t = i as f64 / N as f64;
    assert_eq!(curve.subs(t), processed.subs(t));
}

// Processed curve can inverted!
processed.invert();
for i in 0..=N {
    let t = i as f64 / N as f64;
    assert_eq!(curve.subs(1.0 - t), processed.subs(t));
}

Surface processing example

use truck_geometry::*;
use std::f64::consts::PI;

let sphere = Sphere::new(Point3::new(1.0, 2.0, 3.0), 2.45);
let mut processed = Processor::<_, Matrix4>::new(sphere);

// both surfaces are the same surface
const N: usize = 100;
for i in 0..=N {
    for j in 0..=N {
        let u = PI * i as f64 / N as f64;
        let v = 2.0 * PI * j as f64 / N as f64;
        assert_eq!(sphere.subs(u, v), processed.subs(u, v));
    }
}

// Processed surface can be inverted!
// Here, "invert surface" means swap (u, v)-axes.
processed.invert();
for i in 0..=N {
    for j in 0..=N {
        let u = PI * i as f64 / N as f64;
        let v = 2.0 * PI * j as f64 / N as f64;
        assert_eq!(sphere.subs(u, v), processed.subs(v, u));
    }
}

Implementations

impl<E, T> Processor<E, T> where
    T: One, 

pub fn new(entity: E) -> Processor<E, T>

Creates new processor

pub fn entity(&self) -> &E

Returns the reference of entity

Trait Implementations

impl<S, T> BoundedSurface for Processor<S, T> where
    T: Transform<<S as ParametricSurface>::Point> + SquareMatrix<Scalar = f64> + Clone,
    S: BoundedSurface<Point = Point3<f64>, Vector = Vector3<f64>>, 

pub fn parameter_range(&self) -> ((f64, f64), (f64, f64))

The range of the parameter of the surface.

impl<E, T> Clone for Processor<E, T> where
    E: Clone,
    T: Clone, 

pub fn clone(&self) -> Processor<E, T>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<E, T> Debug for Processor<E, T> where
    E: Debug,
    T: Debug, 

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

Formats the value using the given formatter.

impl<E, T> Deref for Processor<E, T>

type Target = E

The resulting type after dereferencing.

pub fn deref(&self) -> &E

Dereferences the value.

impl<E, T> DerefMut for Processor<E, T>

pub fn deref_mut(&mut self) -> &mut E

Mutably dereferences the value.

impl<'de, E, T> Deserialize<'de> for Processor<E, T> where
    E: Deserialize<'de>,
    T: Deserialize<'de>, 

pub fn deserialize<__D>(
    __deserializer: __D
) -> Result<Processor<E, T>, <__D as Deserializer<'de>>::Error> where
    __D: Deserializer<'de>, 

Deserialize this value from the given Serde deserializer.

impl From<Processor<RevolutedCurve<Curve>, Matrix4<f64>>> for Surface

fn from(original: Processor<RevolutedCurve<Curve>, Matrix4>) -> Surface

Performs the conversion.

impl<E, T, C> IncludeCurve<C> for Processor<E, T> where
    C: ParametricCurve + Transformed<T> + Clone,
    E: IncludeCurve<C>,
    T: Transform<<C as ParametricCurve>::Point>,
    <C as ParametricCurve>::Point: EuclideanSpace, 

pub fn include(&self, curve: &C) -> bool

Returns whether the curve curve is included in the surface self.

impl<E, T> Invertible for Processor<E, T> where
    E: Clone,
    T: Clone, 

pub fn invert(&mut self)

Inverts self

pub fn inverse(&self) -> Processor<E, T>

Returns the inverse.

impl<C> ParameterDivision1D for Processor<C, Matrix3<f64>> where
    C: ParameterDivision1D, 

type Point = <C as ParameterDivision1D>::Point

The curve is in the space of Self::Point.

pub fn parameter_division(
    &self,
    range: (f64, f64),
    tol: f64
) -> (Vec<f64, Global>, Vec<<Processor<C, Matrix3<f64>> as ParameterDivision1D>::Point, Global>)

Creates the curve division (prameters, corresponding points).

impl<C> ParameterDivision1D for Processor<C, Matrix4<f64>> where
    C: ParameterDivision1D, 

type Point = <C as ParameterDivision1D>::Point

The curve is in the space of Self::Point.

pub fn parameter_division(
    &self,
    range: (f64, f64),
    tol: f64
) -> (Vec<f64, Global>, Vec<<Processor<C, Matrix4<f64>> as ParameterDivision1D>::Point, Global>)

Creates the curve division (prameters, corresponding points).

impl<S> ParameterDivision2D for Processor<S, Matrix3<f64>> where
    S: ParameterDivision2D, 

pub fn parameter_division(
    &self,
    range: ((f64, f64), (f64, f64)),
    tol: f64
) -> (Vec<f64, Global>, Vec<f64, Global>)

Creates the surface division

impl<S> ParameterDivision2D for Processor<S, Matrix4<f64>> where
    S: ParameterDivision2D, 

pub fn parameter_division(
    &self,
    range: ((f64, f64), (f64, f64)),
    tol: f64
) -> (Vec<f64, Global>, Vec<f64, Global>)

Creates the surface division

impl<C, T> ParametricCurve for Processor<C, T> where
    C: ParametricCurve,
    T: Transform<<C as ParametricCurve>::Point> + Clone,
    <C as ParametricCurve>::Point: EuclideanSpace,
    <C as ParametricCurve>::Vector: VectorSpace,
    <<C as ParametricCurve>::Point as EuclideanSpace>::Diff == <C as ParametricCurve>::Vector,
    <<C as ParametricCurve>::Vector as VectorSpace>::Scalar == f64, 

type Point = <C as ParametricCurve>::Point

The curve is in the space of Self::Point.

type Vector = <C as ParametricCurve>::Vector

The derivation vector of the curve.

pub fn subs(&self, t: f64) -> <C as ParametricCurve>::Point

Substitutes the parameter t.

pub fn der(&self, t: f64) -> <Processor<C, T> as ParametricCurve>::Vector

Returns the derivation.

pub fn der2(&self, t: f64) -> <Processor<C, T> as ParametricCurve>::Vector

Returns the 2nd-order derivation.

pub fn parameter_range(&self) -> (f64, f64)

The range of the parameter of the curve.

fn front(&self) -> Self::Point

The front end point of the curve.

fn back(&self) -> Self::Point

The back end point of the curve.

impl<S, T> ParametricSurface for Processor<S, T> where
    T: Transform<<S as ParametricSurface>::Point> + SquareMatrix<Scalar = f64> + Clone,
    S: ParametricSurface,
    <S as ParametricSurface>::Point: EuclideanSpace,
    <<S as ParametricSurface>::Point as EuclideanSpace>::Scalar == f64,
    <<S as ParametricSurface>::Point as EuclideanSpace>::Diff == <S as ParametricSurface>::Vector, 

type Point = <S as ParametricSurface>::Point

The surface is in the space of Self::Point.

type Vector = <S as ParametricSurface>::Vector

The derivation vector of the curve.

pub fn subs(
    &self,
    u: f64,
    v: f64
) -> <Processor<S, T> as ParametricSurface>::Point

Substitutes the parameter (u, v).

pub fn uder(
    &self,
    u: f64,
    v: f64
) -> <Processor<S, T> as ParametricSurface>::Vector

Returns the derivation by u.

pub fn vder(
    &self,
    u: f64,
    v: f64
) -> <Processor<S, T> as ParametricSurface>::Vector

Returns the derivation by v.

pub fn uuder(
    &self,
    u: f64,
    v: f64
) -> <Processor<S, T> as ParametricSurface>::Vector

Returns the 2nd-order derivation by u.

pub fn uvder(
    &self,
    u: f64,
    v: f64
) -> <Processor<S, T> as ParametricSurface>::Vector

Returns the 2nd-order derivation by both u and v.

pub fn vvder(
    &self,
    u: f64,
    v: f64
) -> <Processor<S, T> as ParametricSurface>::Vector

Returns the 2nd-order derivation by v.

impl<S, T> ParametricSurface3D for Processor<S, T> where
    S: ParametricSurface3D,
    T: Transform<Point3<f64>> + SquareMatrix<Scalar = f64> + Clone, 

pub fn normal(
    &self,
    u: f64,
    v: f64
) -> <Processor<S, T> as ParametricSurface>::Vector

Returns the normal vector at (u, v).

impl<E, T> SearchParameter for Processor<E, T> where
    E: SearchParameter,
    T: Transform<<E as SearchParameter>::Point>,
    <E as SearchParameter>::Point: EuclideanSpace, 

type Point = <E as SearchParameter>::Point

point

type Parameter = <E as SearchParameter>::Parameter

curve => f64, surface => (f64, f64)

pub fn search_parameter(
    &self,
    point: <E as SearchParameter>::Point,
    hint: Option<<E as SearchParameter>::Parameter>,
    trials: usize
) -> Option<<E as SearchParameter>::Parameter>

Search parameter t such that self.subs(t) is near point.
Returns None if could not find such parameter.

impl<E, T> Serialize for Processor<E, T> where
    E: Serialize,
    T: Serialize, 

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

Serialize this value into the given Serde serializer.

impl<E, T> Transformed<T> for Processor<E, T> where
    T: Mul<T, Output = T> + Copy,
    E: Clone, 

pub fn transform_by(&mut self, trans: T)

transform by trans.

pub fn transformed(&self, trans: T) -> Processor<E, T>

transformed geometry by trans.

impl<E, T> Copy for Processor<E, T> where
    E: Copy,
    T: Copy,