fix height split

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "stratos"
-version = "0.1.4"
+version = "0.1.5"
 authors = ["Lennart Heinrich <[email protected]>"]
 edition = "2018"
 license = "ISC"

src/analyze.rs

@@ -3,11 +3,30 @@
 use crate::XY;
 
 /// Split xy-tuple into seperate vectors (rise, fall)
-pub fn split_up<'a>(values: &'a [XY], height: &[f64]) -> (&'a [XY], &'a [XY]) {
+pub fn split_up(values: Vec<XY>, highest: usize) -> (Vec<XY>, Vec<XY>) {
+    // check if empty vector
     if values.is_empty() {
-        return (&[], &[]);
+        return (vec![], vec![]);
     }
-    values.split_at(highest(height).0)
+
+    // split into rise and fall
+    let mut fall = Vec::new();
+    let rise: Vec<XY> = values
+        .into_iter()
+        .enumerate()
+        .filter(|(i, v)| {
+            if i > &highest {
+                fall.push(*v);
+                false
+            } else {
+                true
+            }
+        })
+        .map(|(_, v)| v)
+        .collect();
+
+    // return vectors
+    (rise, fall)
 }
 
 /// Get highest value in list
@@ -91,130 +110,91 @@ pub fn set_range(
     x_max: Option<&&str>,
     y_min: Option<&&str>,
     y_max: Option<&&str>,
-    height: &mut Option<Vec<f64>>,
 ) -> Vec<XY> {
-    let mut removed = Vec::new();
-
     // set x-min
     if let Some(x_min) = x_min {
         if let Ok(x_min) = x_min.parse() {
-            let (temp_values, mut temp_removed) = remove_lower_x(values, x_min);
-            values = temp_values;
-            removed.append(&mut temp_removed);
+            values = remove_lower_x(values, x_min);
         }
     }
 
     // set x-max
     if let Some(x_max) = x_max {
         if let Ok(x_max) = x_max.parse() {
-            let (temp_values, mut temp_removed) = remove_higher_x(values, x_max);
-            values = temp_values;
-            removed.append(&mut temp_removed);
+            values = remove_higher_x(values, x_max);
         }
     }
 
     // set y-min
     if let Some(y_min) = y_min {
         if let Ok(y_min) = y_min.parse() {
-            let (temp_values, mut temp_removed) = remove_lower_y(values, y_min);
-            values = temp_values;
-            removed.append(&mut temp_removed);
+            values = remove_lower_y(values, y_min);
         }
     }
 
     // set y-max
     if let Some(y_max) = y_max {
         if let Ok(y_max) = y_max.parse() {
-            let (temp_values, mut temp_removed) = remove_higher_y(values, y_max);
-            values = temp_values;
-            removed.append(&mut temp_removed);
+            values = remove_higher_y(values, y_max);
         }
     }
 
-    // remove values from height
-    if let Some(temp_height) = height {
-        removed.sort();
-        removed.dedup();
-        removed.iter().enumerate().for_each(|(i, ri)| {
-            temp_height.remove(ri - i);
-        });
-    }
-
+    // return values
     values
 }
 
 /// Remove higher values (x) from XY
-/// Returns XY-list and removed indexes
-pub fn remove_higher_x(mut values: Vec<XY>, highest: f64) -> (Vec<XY>, Vec<usize>) {
-    let mut removed = Vec::new();
-    values = values
+/// Returns XY-list
+pub fn remove_higher_x(values: Vec<XY>, highest: f64) -> Vec<XY> {
+    values
         .into_iter()
-        .enumerate()
-        .filter(|(i, v)| {
+        .filter(|v| {
             if v.0 <= highest {
-                removed.push(*i);
                 return true;
             }
             false
         })
-        .map(|(_, v)| v)
-        .collect();
-    (values, removed)
+        .collect()
 }
 
 /// Remove lower values (x) from XY
-/// Returns XY-list and removed indexes
-pub fn remove_lower_x(mut values: Vec<XY>, lowest: f64) -> (Vec<XY>, Vec<usize>) {
-    let mut removed = Vec::new();
-    values = values
+/// Returns XY-list
+pub fn remove_lower_x(values: Vec<XY>, lowest: f64) -> Vec<XY> {
+    values
         .into_iter()
-        .enumerate()
-        .filter(|(i, v)| {
+        .filter(|v| {
             if v.0 >= lowest {
-                removed.push(*i);
                 return true;
             }
             false
         })
-        .map(|(_, v)| v)
-        .collect();
-    (values, removed)
+        .collect()
 }
 
 /// Remove higher values (y) from XY
-/// Returns XY-list and removed indexes
-pub fn remove_higher_y(mut values: Vec<XY>, highest: f64) -> (Vec<XY>, Vec<usize>) {
-    let mut removed = Vec::new();
-    values = values
+/// Returns XY-list
+pub fn remove_higher_y(values: Vec<XY>, highest: f64) -> Vec<XY> {
+    values
         .into_iter()
-        .enumerate()
-        .filter(|(i, v)| {
+        .filter(|v| {
             if v.1 <= highest {
-                removed.push(*i);
                 return true;
             }
             false
         })
-        .map(|(_, v)| v)
-        .collect();
-    (values, removed)
+        .collect()
 }
 
 /// Remove lower values (y) from XY
-/// Returns XY-list and removed indexes
-pub fn remove_lower_y(mut values: Vec<XY>, lowest: f64) -> (Vec<XY>, Vec<usize>) {
-    let mut removed = Vec::new();
-    values = values
+/// Returns XY-list
+pub fn remove_lower_y(values: Vec<XY>, lowest: f64) -> Vec<XY> {
+    values
         .into_iter()
-        .enumerate()
-        .filter(|(i, v)| {
+        .filter(|v| {
             if v.1 >= lowest {
-                removed.push(*i);
                 return true;
             }
             false
         })
-        .map(|(_, v)| v)
-        .collect();
-    (values, removed)
+        .collect()
 }

src/common/functions.rs

@@ -1,6 +1,6 @@
 //! General functions
 
-use crate::analyze::{highest_x, highest_y, lowest_x, lowest_y, set_range, split_up};
+use crate::analyze::{highest, highest_x, highest_y, lowest_x, lowest_y, set_range, split_up};
 use crate::parse::to_xy;
 use crate::XY;
 use crate::{Log, Parameters};
@@ -27,18 +27,39 @@ pub fn draw<'a>(log: &'a str, params: Parameters) -> Result<String, Box<dyn erro
     let x_values = log.at_key(params.x_axis)?;
     let y_values = log.at_key(params.y_axis)?;
     let values = to_xy(&x_values, &y_values)?;
-    let mut height_values = match params.height {
-        Some(height) => Some(log.at_key(height)?),
-        None => None,
+
+    // get highest and lowest
+    let highest_x = highest_x(&values).1;
+    let highest_y = highest_y(&values).1;
+    let lowest_x = lowest_x(&values).1;
+    let lowest_y = lowest_y(&values).1;
+
+    // get highest
+    let highest = if let Some(height) = params.height {
+        if let Ok(height_values) = log.at_key(height) {
+            highest(&height_values).0
+        } else {
+            values.len()
+        }
+    } else {
+        values.len()
     };
 
-    let values = set_range(
-        values,
+    // split and set range
+    let (rise_values, fall_values) = split_up(values, highest);
+    let rise_values = set_range(
+        rise_values,
+        params.x_min,
+        params.x_max,
+        params.y_min,
+        params.y_max,
+    );
+    let fall_values = set_range(
+        fall_values,
         params.x_min,
         params.x_max,
         params.y_min,
         params.y_max,
-        &mut height_values,
     );
 
     // create view
@@ -54,25 +75,11 @@ pub fn draw<'a>(log: &'a str, params: Parameters) -> Result<String, Box<dyn erro
             params.y_axis.to_string()
         });
 
-    // create scatters
-    let mut scatters = (Scatter::from_slice(&[]), Scatter::from_slice(&[]));
-    if let Some(height_values) = height_values {
-        // split and create scatters
-        let (rise_values, fall_values) = split_up(&values, &height_values);
-        let rise_scatter = new_scatter(&rise_values, params.colour, params.size);
-        let fall_scatter = new_scatter(&fall_values, params.colour_fall, params.size);
-
-        // add scatters
-        scatters.0 = rise_scatter;
-        scatters.1 = fall_scatter;
-        view = view.add(&scatters.0);
-        view = view.add(&scatters.1);
-    } else {
-        // create and add scatter to vector
-        let scatter = new_scatter(&values, params.colour, params.size);
-        scatters.0 = scatter;
-        view = view.add(&scatters.0);
-    }
+    // add scatters to view
+    let rise_scatter = new_scatter(&rise_values, params.colour, params.size);
+    let fall_scatter = new_scatter(&fall_values, params.colour_fall, params.size);
+    view = view.add(&rise_scatter);
+    view = view.add(&fall_scatter);
 
     // set x-range
     if let (Some(x_min), Some(x_max)) = (params.x_min, params.x_max) {
@@ -81,11 +88,11 @@ pub fn draw<'a>(log: &'a str, params: Parameters) -> Result<String, Box<dyn erro
         }
     } else if let Some(x_min) = params.x_min {
         if let Ok(x_min) = x_min.parse() {
-            view = view.x_range(x_min, highest_x(&values).1);
+            view = view.x_range(x_min, highest_x);
         }
     } else if let Some(x_max) = params.x_max {
         if let Ok(x_max) = x_max.parse() {
-            view = view.x_range(lowest_x(&values).1, x_max);
+            view = view.x_range(lowest_x, x_max);
         }
     }
 
@@ -96,11 +103,11 @@ pub fn draw<'a>(log: &'a str, params: Parameters) -> Result<String, Box<dyn erro
         }
     } else if let Some(y_min) = params.y_min {
         if let Ok(y_min) = y_min.parse() {
-            view = view.y_range(y_min, highest_y(&values).1);
+            view = view.y_range(y_min, highest_y);
         }
     } else if let Some(y_max) = params.y_max {
         if let Ok(y_max) = y_max.parse() {
-            view = view.y_range(lowest_y(&values).1, y_max);
+            view = view.y_range(lowest_y, y_max);
         }
     }