curvo 0.1.88

NURBS modeling library
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91

use std::borrow::{Borrow, Cow};

use nalgebra::{
    allocator::Allocator, DefaultAllocator, DimName, DimNameDiff, DimNameSub, OPoint, U1,
};

use crate::{
    curve::NurbsCurve,
    misc::FloatingPoint,
    prelude::{HasIntersection, HasIntersectionParameter},
};

use super::CurveCurveIntersection;

type Intersection<'a, T, D> = (Cow<'a, NurbsCurve<T, D>>, OPoint<T, DimNameDiff<D, U1>>, T);

/// A struct representing the intersection of two curves.
#[derive(Debug, Clone)]
pub struct CompoundCurveIntersection<'a, T: FloatingPoint, D: DimName>
where
    D: DimNameSub<U1>,
    DefaultAllocator: Allocator<D>,
    DefaultAllocator: Allocator<DimNameDiff<D, U1>>,
{
    a: Intersection<'a, T, D>,
    b: Intersection<'a, T, D>,
}

impl<'a, T: FloatingPoint, D: DimName> CompoundCurveIntersection<'a, T, D>
where
    D: DimNameSub<U1>,
    DefaultAllocator: Allocator<D>,
    DefaultAllocator: Allocator<DimNameDiff<D, U1>>,
{
    pub fn new(
        a: &'a NurbsCurve<T, D>,
        b: &'a NurbsCurve<T, D>,
        intersection: CurveCurveIntersection<OPoint<T, DimNameDiff<D, U1>>, T>,
    ) -> Self {
        let ((pa, ta), (pb, tb)) = intersection.as_tuple();
        Self {
            a: (Cow::Borrowed(a), pa, ta),
            b: (Cow::Borrowed(b), pb, tb),
        }
    }

    pub fn a_curve(&self) -> &NurbsCurve<T, D> {
        self.a.0.borrow()
    }

    pub fn b_curve(&self) -> &NurbsCurve<T, D> {
        self.b.0.borrow()
    }

    pub fn swap(&mut self) {
        std::mem::swap(&mut self.a, &mut self.b);
    }
}

impl<T: FloatingPoint, D: DimName> HasIntersectionParameter<T, T>
    for CompoundCurveIntersection<'_, T, D>
where
    D: DimNameSub<U1>,
    DefaultAllocator: Allocator<D>,
    DefaultAllocator: Allocator<DimNameDiff<D, U1>>,
{
    fn a_parameter(&self) -> T {
        self.a.2
    }

    fn b_parameter(&self) -> T {
        self.b.2
    }
}

impl<'a, T: FloatingPoint, D: DimName>
    HasIntersection<Intersection<'a, T, D>, Intersection<'a, T, D>, T, T>
    for CompoundCurveIntersection<'a, T, D>
where
    D: DimNameSub<U1>,
    DefaultAllocator: Allocator<D>,
    DefaultAllocator: Allocator<DimNameDiff<D, U1>>,
{
    fn a(&self) -> &Intersection<'a, T, D> {
        &self.a
    }

    fn b(&self) -> &Intersection<'a, T, D> {
        &self.b
    }
}