smitters 0.1.1

Smith chart, Volpert–Smith chart, egui
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

use crate::{
    math::{react_circle, res_circle, Angle, Circle, Pos2, ResActive, ResReactive},
    trigonometry::{intersect_angle_react_by_res, intersect_angle_res_by_react},
};

#[derive(Debug)]
pub struct CircleArc {
    pub circle: Circle,
    pub start: Angle,
    pub lenght: Angle,
}

fn res_circle_params(res: ResActive, center_of_image: &Pos2, half_width: f64) -> Circle {
    let mut circle = res_circle(res, half_width);
    circle.center = circle.center + *center_of_image;
    circle
}

fn react_circle_params(res: ResReactive, center_of_image: &Pos2, half_width: f64) -> Circle {
    let mut circle = react_circle(res, half_width);
    circle.center = circle.center + *center_of_image;
    circle
}

pub fn react_circle_arc(
    center_of_image: &Pos2,
    half_width: f64,
    react: ResReactive,
    res_start: ResActive,
    res_end: ResActive,
) -> CircleArc {
    // assert!(res_start.0 > 0.0);
    // assert!(res_end.0 > 0.0);

    let react_circle = react_circle_params(react, &center_of_image, half_width);

    let res_circle_1 = res_circle_params(res_start, &center_of_image, half_width);

    let start = intersect_angle_react_by_res(react_circle, res_circle_1);

    let res_circle_2 = res_circle_params(res_end, &center_of_image, half_width);

    let end = intersect_angle_react_by_res(react_circle, res_circle_2);

    let lenght = end;

    if react.0.is_sign_negative() {
        let true_start = Angle(std::f64::consts::PI / 2. + start.0);

        let lenght = Angle(lenght.0 - start.0);

        CircleArc {
            circle: react_circle,
            start: true_start,
            lenght,
        }
    } else {
        let true_start = Angle(-std::f64::consts::PI / 2. - start.0);

        let lenght = Angle(-lenght.0 + start.0);

        CircleArc {
            circle: react_circle,
            start: true_start,
            lenght,
        }
    }
}

pub fn res_circle_arc(
    center_of_image: &Pos2,
    half_width: f64,
    res: ResActive,
    react_start: ResReactive,
    react_end: ResReactive,
) -> CircleArc {
    let res_circle = res_circle_params(res, &center_of_image, half_width);

    // todo inf
    let true_start = if react_start.0 != 0.0 {
        let react_circle_1 = react_circle_params(react_start, &center_of_image, half_width);

        let start = intersect_angle_res_by_react(res_circle, react_circle_1);

        let true_start = if react_start.0.is_sign_negative() {
            start
        } else {
            Angle(std::f64::consts::TAU - start.0)
        };

        true_start
    } else {
        Angle(std::f64::consts::PI)
    };

    let react_circle_2 = react_circle_params(react_end, &center_of_image, half_width);

    let end = intersect_angle_res_by_react(res_circle, react_circle_2);

    let end = if react_end.0 != 0.0 {
        let true_end = if react_end.0.is_sign_negative() {
            Angle(end.0)
        } else {
            Angle(std::f64::consts::TAU - end.0)
        };

        true_end
    } else {
        Angle(std::f64::consts::PI)
    };

    let lenght = Angle(end.0 - true_start.0);

    CircleArc {
        circle: res_circle,
        start: true_start,
        lenght,
    }
}