theta_chart/coord/
cartesian_group.rs

1use super::CView;
2use crate::series::Series;
3
4#[derive(Debug, Clone)]
5/// Store data for descartes coordinates system
6pub struct CartesianGroup {
7    data: Vec<(Series, Series)>,
8    view: CView,
9}
10
11impl CartesianGroup {
12    pub fn new() -> Self {
13        Self {
14            data: vec![],
15            view: CView::default(),
16        }
17    }
18
19    pub fn add_data(self, ax: Series, ay: Series) -> Self {
20        let tuple = (ax, ay);
21        let mut data = self.data;
22        data.push(tuple);
23        Self {
24            data: data,
25            view: self.view.clone(),
26        }
27    }
28
29    pub fn set_view(
30        &self,
31        width: u64,
32        height: u64,
33        position_axes: usize,
34        height_x_axis: u64,
35        width_y_axis: u64,
36        margin: u64,
37    ) -> Self {
38        let view = CView::new(
39            width,
40            height,
41            position_axes,
42            height_x_axis,
43            width_y_axis,
44            margin,
45        );
46        Self {
47            data: self.data.clone(),
48            view: view,
49        }
50    }
51
52    pub fn get_view(&self) -> CView {
53        self.view.clone()
54    }
55
56    pub fn get_ax_group(&self) -> Series {
57        let first = &self.data[0].0;
58        match first {
59            Series::Number(s) => {
60                let mut fix = s.clone();
61                for index in 1..self.data.len() {
62                    match &self.data[index].0 {
63                        Series::Number(o) => fix = fix.merge(o.clone()),
64                        Series::Label(_) => (),
65                        Series::Time(_) => (),
66                    }
67                }
68                return Series::Number(fix);
69            }
70            Series::Label(l) => {
71                let mut fix = l.clone();
72                for index in 1..self.data.len() {
73                    match &self.data[index].0 {
74                        Series::Number(_) => (),
75                        Series::Label(l) => fix = fix.merge(l.clone()),
76                        Series::Time(_) => (),
77                    }
78                }
79                return Series::Label(fix);
80            }
81            Series::Time(s) => {
82                let mut fix = s.clone();
83                for index in 1..self.data.len() {
84                    match &self.data[index].0 {
85                        Series::Number(_) => (),
86                        Series::Label(_) => (),
87                        Series::Time(o) => fix = fix.merge(o.clone()),
88                    }
89                }
90                return Series::Time(fix);
91            }
92        }
93    }
94
95    pub fn get_ay_group(&self) -> Series {
96        let first = &self.data[0].1;
97        match first {
98            Series::Number(s) => {
99                let mut fix = s.clone();
100                for index in 1..self.data.len() {
101                    match &self.data[index].1 {
102                        Series::Number(o) => fix = fix.merge(o.clone()),
103                        Series::Label(_) => (),
104                        Series::Time(_) => (),
105                    }
106                }
107                return Series::Number(fix);
108            }
109            Series::Label(l) => {
110                let mut fix = l.clone();
111                for index in 1..self.data.len() {
112                    match &self.data[index].1 {
113                        Series::Number(_) => (),
114                        Series::Label(l) => fix = fix.merge(l.clone()),
115                        Series::Time(_) => (),
116                    }
117                }
118                return Series::Label(fix);
119            }
120            Series::Time(s) => {
121                let mut fix = s.clone();
122                for index in 1..self.data.len() {
123                    match &self.data[index].1 {
124                        Series::Number(_) => (),
125                        Series::Label(_) => (),
126                        Series::Time(o) => fix = fix.merge(o.clone()),
127                    }
128                }
129                return Series::Time(fix);
130            }
131        }
132    }
133
134    pub fn get_data(&self) -> Vec<(Series, Series)> {
135        self.data.clone()
136    }
137}