points in range

src/main.rs

@@ -19,6 +19,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));
+
+    let span = wing_airfoil.points_in_range(0.0.. wing_airfoil.perimiter() * 0.4);
+    let points = scad::PolygonParameters::new(span);
+    register_part(scad!(Polygon(points)));
 
     // symetric airfoil, used in the control surfaces
     let control_airfoil: Airfoil = Airfoil::parse(include_str!("../edgevertical.dat"));

src/selig.rs

@@ -1,3 +1,5 @@
+use std::ops::Range;
+
 use nalgebra::Vector2;
 
 pub type Point = Vector2<f32>;
@@ -43,9 +45,13 @@ impl Airfoil {
     }
 
     pub fn perimiter(&self) -> f32 {
+        self.span_length(&self.get_points()[..])
+    }
+
+    fn span_length(&self, points: &[Point]) -> f32 {
         let mut last_point: Option<Point> = None;
         let mut distance: f32 = 0.0;
-        for point in self.get_points() {
+        for point in points {
             if let Some(last) = last_point {
                 distance += (last - point).magnitude();
             }
@@ -53,4 +59,36 @@ 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
+    }
 }