Struct fj_kernel::algorithms::approx::curve::CurveCache

pub struct CurveCache { /* private fields */ }

A cache for results of an approximation

Implementations

impl CurveCache

pub fn new() -> Self

Create an empty cache

pub fn insert(
    &mut self,
    handle: Handle<GlobalCurve>,
    range: RangeOnPath,
    approx: GlobalCurveApprox
) -> GlobalCurveApprox

Insert the approximation of a GlobalCurve

Examples found in repository

src/algorithms/approx/curve.rs (line 38)

    fn approx_with_cache(
        self,
        tolerance: impl Into<Tolerance>,
        cache: &mut Self::Cache,
    ) -> Self::Approximation {
        let (curve, range) = self;

        let global_curve = curve.global_form().clone();
        let global_curve_approx = match cache.get(global_curve.clone(), range) {
            Some(approx) => approx,
            None => {
                let approx = approx_global_curve(curve, range, tolerance);
                cache.insert(global_curve, range, approx)
            }
        };

        CurveApprox::empty().with_points(
            global_curve_approx.points.into_iter().map(|point| {
                let point_surface =
                    curve.path().point_from_path_coords(point.local_form);

                ApproxPoint::new(point_surface, point.global_form)
                    .with_source((curve.clone(), point.local_form))
            }),
        )
    }

pub fn get(
    &self,
    handle: Handle<GlobalCurve>,
    range: RangeOnPath
) -> Option<GlobalCurveApprox>

Access the approximation for the given GlobalCurve, if available

Examples found in repository

src/algorithms/approx/curve.rs (line 34)

    fn approx_with_cache(
        self,
        tolerance: impl Into<Tolerance>,
        cache: &mut Self::Cache,
    ) -> Self::Approximation {
        let (curve, range) = self;

        let global_curve = curve.global_form().clone();
        let global_curve_approx = match cache.get(global_curve.clone(), range) {
            Some(approx) => approx,
            None => {
                let approx = approx_global_curve(curve, range, tolerance);
                cache.insert(global_curve, range, approx)
            }
        };

        CurveApprox::empty().with_points(
            global_curve_approx.points.into_iter().map(|point| {
                let point_surface =
                    curve.path().point_from_path_coords(point.local_form);

                ApproxPoint::new(point_surface, point.global_form)
                    .with_source((curve.clone(), point.local_form))
            }),
        )
    }

Trait Implementations

impl Default for CurveCache

fn default() -> CurveCache

Returns the “default value” for a type.