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

use egui::{pos2, Color32, Painter, Stroke};

use crate::{
    chart_fancy::draw_patch,
    drawing_primitives::{react_circle_arc, res_circle_arc},
    egui::egui_draw_arc,
    math::{Pos2, ResActive, ResReactive},
};
pub struct Context<'a> {
    pub painter: &'a Painter,
    // not a real center
    pub center_of_image: Pos2,
    pub half_width: f64,
}

impl<'a> Context<'a> {
    pub fn get_context(ui: &'a egui::Ui) -> Context<'a> {
        let size = ui.available_rect_before_wrap();

        let center = size.center();

        let half_width = size.width() as f64 / 2.;

        let center_of_image = Pos2 {
            x: center.x as f64 - half_width,
            y: center.y as f64 - half_width,
        };

        let painter = ui.painter();

        let ctx = Context {
            painter,
            half_width,
            center_of_image,
        };
        ctx
    }

    pub fn center(&self) -> Pos2 {
        Pos2 {
            x: (self.center_of_image.x + self.half_width),
            y: (self.center_of_image.y + self.half_width),
        }
    }

    pub fn res(&self, res: f64, react_start: f64, react_end: f64, stroke: &Stroke) {
        let arc = res_circle_arc(
            &self.center_of_image,
            self.half_width,
            ResActive(res),
            ResReactive(react_start),
            ResReactive(react_end),
        );

        egui_draw_arc(&self.painter, arc, stroke);
    }

    pub fn react(&self, react: f64, res_start: f64, res_end: f64, stroke: &Stroke) {
        let arc = react_circle_arc(
            &self.center_of_image,
            self.half_width,
            ResReactive(react),
            ResActive(res_start),
            ResActive(res_end),
        );

        egui_draw_arc(&self.painter, arc, stroke)
    }

    pub fn draw_patch(&self, ending: f64, starting: f64, steps: usize, steps_m: usize) {
        draw_patch(&self, ending, starting, steps, steps_m);
    }

    pub fn horizontal_line(&self) {
        let start = pos2(
            (self.center_of_image.x) as f32,
            (self.center_of_image.y + self.half_width) as f32,
        );
        let end = pos2(
            (self.center_of_image.x + self.half_width + self.half_width) as f32,
            (self.center_of_image.y + self.half_width) as f32,
        );
        self.painter.line_segment(
            [start, end],
            Stroke {
                width: 0.5,
                color: Color32::RED,
            },
        )
    }
}