togo 0.7.2

A library for 2D geometry, providing geometric algorithms for intersection/distance between circular arcs/line segments.
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
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134

#![allow(dead_code)]

use crate::interval::Interval;

/// Represents a configuration for the intersection of two intervals.
#[derive(Debug, PartialEq)]
pub enum IntervalConfig {
    NoOverlap(),
    Overlap(f64, f64),
    Touching(f64),
}

/// Computes the intersection of two intervals.
///
/// This function checks if two intervals overlap, touch, or are disjoint.
/// If they overlap, it returns the overlapping range.
/// If they touch at a single point, it returns that point.
/// If they are disjoint, it returns `NoOverlap`.
///
/// # Arguments
/// /// * `interval0` - The first interval
/// * `interval1` - The second interval
///
/// # Returns
/// An `IntervalConfig` enum indicating the type of intersection:
/// - `NoOverlap` if the intervals are disjoint
/// - `Overlap(start, end)` if they overlap, where `start` and `end` are the overlapping bounds
/// - `Touching(point)` if they touch at a single point
///
/// # Examples
/// ```
/// use togo::prelude::*;
/// let i0 = interval(1.0, 3.0);
/// let i1 = interval(2.0, 4.0);
/// let result = int_interval_interval(i0, i1);
/// assert_eq!(result, IntervalConfig::Overlap(2.0, 3.0));
/// ```
pub fn int_interval_interval(interval0: Interval, interval1: Interval) -> IntervalConfig {
    debug_assert!(interval0.0 <= interval0.1);
    debug_assert!(interval1.0 <= interval1.1);
    if interval0.1 < interval1.0 || interval0.0 > interval1.1 {
        IntervalConfig::NoOverlap()
    } else if interval0.1 > interval1.0 {
        if interval0.0 < interval1.1 {
            let overlap0 = if interval0.0 < interval1.0 {
                interval1.0
            } else {
                interval0.0
            };
            let overlap1 = if interval0.1 > interval1.1 {
                interval1.1
            } else {
                interval0.1
            };
            if overlap0 < overlap1 {
                IntervalConfig::Overlap(overlap0, overlap1)
            } else {
                // case with degenerate intervals
                IntervalConfig::Overlap(overlap0, overlap0)
            }
        } else {
            // interval0[0] == interval1[1]
            IntervalConfig::Touching(interval0.0)
        }
    } else {
        // interval0[1] == interval1[0]
        IntervalConfig::Touching(interval0.1)
    }
}

#[cfg(test)]
mod tests_intersect_interval_interval {
    use crate::interval::interval;

    use super::*;

    #[test]
    fn test_no_overlap() {
        let i0 = interval(1.0, 2.0);
        let i1 = interval(3.0, 4.0);
        assert_eq!(int_interval_interval(i0, i1), IntervalConfig::NoOverlap());
    }

    #[test]
    fn test_one_point() {
        let i0 = interval(1.0, 2.0);
        let i1 = interval(2.0, 4.0);
        assert_eq!(int_interval_interval(i0, i1), IntervalConfig::Touching(2.0));
    }

    #[test]
    fn test_one_point2() {
        let i0 = interval(1.0, 2.0);
        let i1 = interval(2.0 + f64::EPSILON, 4.0);
        assert_eq!(int_interval_interval(i0, i1), IntervalConfig::Touching(2.0));
    }

    #[test]
    fn test_one_point_degenerate() {
        let i0 = interval(-0.0, -0.0);
        let i1 = interval(-1.0, 1.0);
        assert_eq!(
            int_interval_interval(i0, i1),
            IntervalConfig::Overlap(0.0, 0.0)
        );
    }

    #[test]
    fn test_overlap() {
        let i0 = interval(1.0, 2.0);
        let i1 = interval(2.0 - f64::EPSILON, 4.0);
        assert_eq!(
            int_interval_interval(i0, i1),
            IntervalConfig::Overlap(1.9999999999999998, 2.0)
        );
    }

    #[test]
    fn test_degenerate() {
        let i0 = interval(1.0, 2.0);
        let i1 = interval(1.5, 1.5);
        assert_eq!(
            int_interval_interval(i0, i1),
            IntervalConfig::Overlap(1.5, 1.5)
        );
    }

    #[test]
    fn test_touching_degenerate() {
        let i0 = interval(1.0, 2.0);
        let i1 = interval(2.0, 2.0);
        assert_eq!(int_interval_interval(i0, i1), IntervalConfig::Touching(2.0));
    }
}