pi_cg2d 0.3.0

cg2d
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

use parry2d::math::{Point, Vector, Real};

pub enum InnOuter {
    Inner,
    Outer,
    Boundary,
}

/// 检查点是否在三角形范围内， 要求p1 p2 p3 要么顺时针要么逆时针
pub fn include_tri2(p: &Point<Real>, p1: &Point<Real>, p2: &Point<Real>, p3: &Point<Real>) -> InnOuter
{
    let zero = 0.0;
    let v1 = Vector::new(p.x - p1.x, p.y - p1.y);
    let v2 = Vector::new(p.x - p2.x, p.y - p2.y);
    let v3 = Vector::new(p.x - p3.x, p.y - p3.y);
    // 要求3次叉乘结果，要么都大于0 要么都小于0
    let r = cross(&v1, &v2);
    if r > zero {
        let r = cross(&v2,&v3);
        if r > zero {
        } else if r < zero {
            return InnOuter::Outer;
        } else {
            return InnOuter::Boundary;
        }
        let r = cross(&v3, &v1);
        if r > zero {
            InnOuter::Inner
        } else if r < zero {
            InnOuter::Outer
        } else {
            InnOuter::Boundary
        }
    } else if r < zero {
        let r = cross(&v2, &v3);
        if r < zero {
        } else if r > zero {
            return InnOuter::Outer;
        } else {
            return InnOuter::Boundary;
        }
        let r = cross(&v3, &v1);
        if r < zero {
            InnOuter::Inner
        } else if r > zero {
            InnOuter::Outer
        } else {
            InnOuter::Boundary
        }
    } else {
        InnOuter::Boundary
    }
}

pub fn cross(p1: &Vector<Real>, p2: &Vector<Real>) -> Real{
	(p1.x * p2.y) - (p1.y * p2.x)
}
/// 检查点是否在四边形范围内， 要求p1 p2 p3 p4 要么顺时针要么逆时针
pub fn include_quad2(
    p: &Point<Real>,
    p1: &Point<Real>,
    p2: &Point<Real>,
    p3: &Point<Real>,
    p4: &Point<Real>,
) -> InnOuter
{
    let zero = 0.0;
	// let min = <S as Float>::min_value();
	// 非三维向量叉乘恐慌， （优化：TODO）
    let v1 = Vector::new(p.x - p1.x, p.y - p1.y);
    let v2 = Vector::new(p.x - p2.x, p.y - p2.y);
    let v3 = Vector::new(p.x - p3.x, p.y - p3.y);
    let v4 = Vector::new(p.x - p4.x, p.y - p4.y);
    // 要求4次叉乘结果，要么都大于0 要么都小于0
    let r = cross(&v1,&v2);
    if r > zero {
        let r = cross(&v2, &v3);
        if r > zero {
        } else if r < zero {
            return InnOuter::Outer;
        } else {
            return InnOuter::Boundary;
        }
        let r = cross(&v3, &v4);
        if r > zero {
        } else if r < zero {
            return InnOuter::Outer;
        } else {
            return InnOuter::Boundary;
        }
        let r = cross(&v4, &v1);
        if r > zero {
            InnOuter::Inner
        } else if r < zero {
            InnOuter::Outer
        } else {
            InnOuter::Boundary
        }
    } else if r < zero {
        let r = cross(&v2, &v3);
        if r < zero {
        } else if r > zero {
            return InnOuter::Outer;
        } else {
            return InnOuter::Boundary;
        }
        let r = cross(&v3, &v4);
        if r < zero {
        } else if r > zero {
            return InnOuter::Outer;
        } else {
            return InnOuter::Boundary;
        }
        let r = cross(&v4, &v1);
        if r < zero {
            InnOuter::Inner
        } else if r > zero {
            InnOuter::Outer
        } else {
            InnOuter::Boundary
        }
    } else {
        InnOuter::Boundary
    }
}