i_curve 0.1.2

Boolean operations on closed paths of lines, Bezier curves, and rational elliptic arcs
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

use crate::kernel::int::curve::param::SegmentParam;
use i_overlay::i_float::int::number::int::IntNumber;
use i_overlay::i_float::int::number::product_uint::UIntProduct;
use i_overlay::i_float::int::number::uint::UIntNumber;
use i_overlay::i_float::int::number::wide_int::WideIntNumber;
#[cfg(test)]
use i_overlay::i_float::int::rect::IntRect;
use i_overlay::i_float::int::vector::IntVector;
use i_overlay::i_shape::int::IntPoint;

pub(crate) trait Chord<I: IntNumber> {
    fn chord(&self) -> SegmentChord<I>;
}

#[derive(Debug, Clone, Copy)]
pub(crate) struct SegmentChord<I: IntNumber> {
    pub(crate) a: IntPoint<I>,
    pub(crate) b: IntPoint<I>,
}

impl<I: IntNumber> SegmentChord<I> {
    #[inline]
    pub(crate) fn is_zero_length(&self) -> bool {
        self.b == self.a
    }

    #[inline]
    pub(crate) fn vector(&self) -> IntVector<I> {
        self.b - self.a
    }

    #[inline]
    pub(crate) fn sqr_length(&self) -> I::Wide {
        self.vector().sqr_length()
    }

    #[inline]
    #[cfg(test)]
    pub(crate) fn to_rect(self) -> IntRect<I> {
        IntRect::with_ab(self.a, self.b)
    }

    pub(crate) fn param_for_point(&self, point: IntPoint<I>) -> SegmentParam<I> {
        let vector = self.vector();
        let sqr_length = vector.sqr_length();
        debug_assert!(sqr_length > I::Wide::ZERO);

        let projection = (point - self.a).dot_product(vector);
        if projection <= I::Wide::ZERO {
            return SegmentParam::new(I::ZERO);
        }
        if projection >= sqr_length {
            return SegmentParam::new(I::from_wide(SegmentParam::<I>::DENOMINATOR));
        }

        let product = <I::WideUInt as UIntNumber>::Product::multiply(
            projection.unsigned_abs(),
            SegmentParam::<I>::DENOMINATOR.unsigned_abs(),
        );
        let value = product.divide_with_rounding(sqr_length.unsigned_abs());

        SegmentParam::new(I::from_wide(I::Wide::from_uint(value)))
    }
}