refactoring

gpx-rs/src/core/algorithm/mod.rs

@@ -1,5 +0,0 @@
-mod simplify;
-mod smooth;
-
-pub use simplify::*;
-pub use smooth::*;

gpx-rs/src/core/algorithm/simplify.rs

@@ -1,69 +0,0 @@
-use crate::{
-    core::gpx::{TrackSegment, TrackSegmentIndex},
-    core::utils::crossarc,
-};
-
-pub fn ramer_douglas_peucker<F>(
-    trkseg: &TrackSegment,
-    mapping: &F,
-    epsilon: f64,
-) -> Vec<TrackSegmentIndex>
-where
-    F: Fn(TrackSegmentIndex) -> (f64, f64),
-{
-    match trkseg.len() {
-        0 => vec![],
-        1 => vec![trkseg.first_index().unwrap()],
-        2 => vec![trkseg.last_index().unwrap()],
-        _ => {
-            let first = trkseg.first_index().unwrap();
-            let last = trkseg.last_index().unwrap();
-
-            let mut indices = vec![first];
-            ramer_douglas_peucker_helper(trkseg, first, last, mapping, epsilon, &mut indices);
-            indices.push(last);
-            indices
-        }
-    }
-}
-
-fn ramer_douglas_peucker_helper<F>(
-    trkseg: &TrackSegment,
-    start: TrackSegmentIndex,
-    end: TrackSegmentIndex,
-    mapping: &F,
-    epsilon: f64,
-    indices: &mut Vec<TrackSegmentIndex>,
-) where
-    F: Fn(TrackSegmentIndex) -> (f64, f64),
-{
-    let mut max_idx = None;
-    let mut max_dist = 0.0;
-
-    let start_pt = mapping(start);
-    let end_pt = mapping(end);
-
-    let mut cur = trkseg.next_index(Some(start));
-    while let Some(idx) = cur {
-        if idx == end {
-            break;
-        }
-
-        let pt = mapping(idx);
-        let dist = crossarc(start_pt.0, start_pt.1, end_pt.0, end_pt.1, pt.0, pt.1);
-        if dist > max_dist {
-            max_idx = Some(idx);
-            max_dist = dist;
-        }
-
-        cur = trkseg.next_index(cur);
-    }
-
-    if let Some(idx) = max_idx {
-        if max_dist > epsilon {
-            ramer_douglas_peucker_helper(trkseg, start, idx, mapping, epsilon, indices);
-            indices.push(idx);
-            ramer_douglas_peucker_helper(trkseg, idx, end, mapping, epsilon, indices);
-        }
-    }
-}

gpx-rs/src/core/algorithm/smooth.rs

@@ -1,54 +0,0 @@
-#[macro_export]
-macro_rules! for_each_window {
-    (
-        $trkseg:expr,
-        $left:expr,
-        $right:expr,
-        $window:expr,
-        |$a:ident, $b:ident| $distance:expr,
-        |$i:ident, $l:ident, $r:ident| $body:block,
-    ) => {{
-        let mut window_start = $left.unwrap_or_default();
-        let mut window_center = $left;
-        let mut window_end = $left.unwrap_or_default();
-        while let Some(idx) = window_center {
-            // advance left if needed
-            while window_start != idx && {
-                let $a = window_start;
-                let $b = idx;
-                $distance
-            } > $window {
-                if let Some(next) = $trkseg.next_index(Some(window_start)) {
-                    if next == idx {
-                        break;
-                    }
-                    window_start = next;
-                } else {
-                    break;
-                }
-            }
-            // advance right if needed
-            window_end = window_end.max(idx);
-            while let Some(next) = $trkseg.next_index(Some(window_end)) {
-                if window_end != idx && {
-                    let $a = idx;
-                    let $b = next;
-                    $distance
-                } > $window {
-                    break;
-                }
-                window_end = next;
-            }
-            // apply body
-            let $i = idx;
-            let $l = window_start;
-            let $r = window_end;
-            $body
-            // go next
-            if window_center == $right {
-                break;
-            }
-            window_center = $trkseg.next_index(window_center);
-        }
-    }};
-}