Struct truck_modeling::geometry::Processor

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

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 const fn entity(&self) -> &E

Returns the reference of entity

pub const fn transform(&self) -> &T

Returns the reference of transform

pub fn map<G, F>(self, f: F) -> Processor<G, T>where
    F: FnOnce(E) -> G,

apply the function to the entity geometry

pub fn map_ref<G, F>(&self, f: F) -> Processor<G, T>where
    F: FnOnce(&E) -> G,
    T: Copy,

apply the function to the entity geometry

pub fn constract(self) -> Ewhere
    E: Transformed<T> + Invertible,

apply the transform and inverse

Trait Implementations

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

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> BoundedSurface for Processor<S, T>where
    T: Transform<<S as ParametricSurface>::Point> + SquareMatrix<Scalar = f64> + Clone,
    S: BoundedSurface<Point = Point3<f64>, Vector = Vector3<f64>>,

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,

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,

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.

fn deref(&self) -> &E

Dereferences the value.

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

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

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

Converts to this type from the input type.

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

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,

fn invert(&mut self)

Inverts self

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.

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 (parameters, 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.

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 (parameters, corresponding points).

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

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,

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: BoundedCurve,
    <C as ParametricCurve>::Point: EuclideanSpace<Diff = <C as ParametricCurve>::Vector>,
    <C as ParametricCurve>::Vector: VectorSpace<Scalar = f64>,
    T: Transform<<C as ParametricCurve>::Point> + Clone,

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.

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

Substitutes the parameter t.

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

Returns the derivation.

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

Returns the 2nd-order derivation.

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

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.

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

Substitutes the parameter (u, v).

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

Returns the derivation by u.

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

Returns the derivation by v.

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

Returns the 2nd-order derivation by u.

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

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

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,

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

Returns the normal vector at (u, v).

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

type Point = <E as SearchParameter<D>>::Point

point

fn search_parameter<H>(
    &self,
    point: <E as SearchParameter<D>>::Point,
    hint: H,
    trials: usize
) -> Option<<D as SPDimension>::Parameter>where
    H: Into<<D as SPDimension>::Hint>,

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,

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,

fn transform_by(&mut self, trans: T)

transform by trans.

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

transformed geometry by trans.

impl TryFrom<Surface> for Processor<RevolutedCurve<Curve>, Matrix4>

type Error = &'static str

The type returned in the event of a conversion error.

fn try_from(value: Surface) -> Result<Self, Self::Error>

Performs the conversion.

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