From e4863440c0644b025b06e363d30fc8169222eb37 Mon Sep 17 00:00:00 2001
From: Andy Killorin <37423245+Speedy6451@users.noreply.github.com>
Date: Wed, 1 Nov 2023 14:15:47 -0500
Subject: [PATCH] code vomit

---
 src/main.rs  | 52 ++++++++++++++++++++++++++++++++++++++++++++++++++--
 src/selig.rs | 32 --------------------------------
 2 files changed, 50 insertions(+), 34 deletions(-)

diff --git a/src/main.rs b/src/main.rs
index 3884a7e..613bbe7 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -4,6 +4,8 @@ use nalgebra::Vector3;
 use scad::*;
 use constants::*;
 use selig::Airfoil;
+use selig::Point;
+use std::ops::Range;
 mod constants;
 mod selig;
 
@@ -19,9 +21,11 @@ fn main() {
     let wing_airfoil: Airfoil = Airfoil::parse(include_str!("../ag24.dat"));
     println!("name {}, perim {}", wing_airfoil.get_name(), wing_airfoil.perimiter());
     println!("desc {}", wing_airfoil.get_description().clone().unwrap_or("no desc".to_string()));
-    println!("span {:?}", wing_airfoil.points_in_range(0.0..1.0));
+    //println!("span {:?}", points_in_range(wing_airfoil.get_points()[0..80], 0.0..1.0));
 
-    let span = wing_airfoil.points_in_range(0.0.. wing_airfoil.perimiter() * 0.4);
+    let points = &wing_airfoil.get_points()[0..80];
+    let perimeter = span_length(points);
+    let span = points_in_range(&Vec::from(points), perimeter * 0.4.. perimeter);
     let points = scad::PolygonParameters::new(span);
     register_part(scad!(Polygon(points)));
 
@@ -158,3 +162,47 @@ fn wing(aerofoil: &Airfoil, struts: usize, length: f32, chord: f32, taper: f32)
 
     wing
 }
+
+pub fn points_in_range(input: &Vec<Point>, range: Range<f32>) -> Vec<Point> {
+    let mut last_point: Option<Point> = None;
+    let mut distance: f32 = 0.0;
+    let mut points: Vec<Point> = Vec::new();
+    for point in input {
+        if let Some(last) = last_point {
+            let span: f32 = (last - point).magnitude();
+            match (range.contains(&distance), range.contains(&(distance+span))) {
+                (true, true) => { // fully within span
+                    points.push(point.clone());
+                    println!("in {span}");
+                },
+                (false, true) => { // entering span
+                    let undershoot = distance - range.start;
+                    let part_out = (span - undershoot) / span;
+                    points.push(last.lerp(&point, part_out));
+                    println!("enter");
+                },
+                (true, false) => { // exiting span
+                    let overshoot = range.end - distance;
+                    let part_in = (span - overshoot) / span;
+                    points.push(last.lerp(&point, part_in));
+                },
+                _ => {},
+            }
+            distance += span;
+        }
+        last_point = Some(point.clone());
+    }
+    points
+}
+
+fn span_length(points: &[Point]) -> f32 {
+    let mut last_point: Option<Point> = None;
+    let mut distance: f32 = 0.0;
+    for point in points {
+        if let Some(last) = last_point {
+            distance += (last - point).magnitude();
+        }
+        last_point = Some(point.clone());
+    }
+    distance
+}
diff --git a/src/selig.rs b/src/selig.rs
index f307c1a..f66235c 100644
--- a/src/selig.rs
+++ b/src/selig.rs
@@ -59,36 +59,4 @@ impl Airfoil {
         }
         distance
     }
-
-    pub fn points_in_range(&self, range: Range<f32>) -> Vec<Point> {
-        let mut last_point: Option<Point> = None;
-        let mut distance: f32 = 0.0;
-        let mut points = Vec::new();
-        for point in self.get_points() {
-            if let Some(last) = last_point {
-                let span = (last - point).magnitude();
-                match (range.contains(&distance), range.contains(&(distance+span))) {
-                    (true, true) => { // fully within span
-                        points.push(point.clone());
-                        println!("in {span}");
-                    },
-                    (false, true) => { // entering span
-                        let undershoot = distance - range.start;
-                        let part_out = (span - undershoot) / span;
-                        points.push(last.lerp(&point, part_out));
-                        println!("enter");
-                    },
-                    (true, false) => { // exiting span
-                        let overshoot = range.end - distance;
-                        let part_in = (span - overshoot) / span;
-                        points.push(last.lerp(&point, part_in));
-                    },
-                    _ => {},
-                }
-                distance += span;
-            }
-            last_point = Some(point.clone());
-        }
-        points
-    }
 }