rapidgeo-simplify 0.1.2

Douglas-Peucker polyline simplification with pluggable distance backends
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129

use rapidgeo_distance::LngLat;
use rapidgeo_simplify::{simplify_dp_into, SimplifyMethod};

#[cfg(feature = "batch")]
use rapidgeo_simplify::batch::{simplify_batch_par, simplify_dp_into_par};

fn create_large_polyline(size: usize) -> Vec<LngLat> {
    let mut points = Vec::with_capacity(size);

    // Create a realistic GPS trace with noise
    let start_lng = -122.4194;
    let start_lat = 37.7749;
    let end_lng = -118.2437;
    let end_lat = 34.0522;

    for i in 0..size {
        let t = i as f64 / (size - 1) as f64;

        let base_lng = start_lng + t * (end_lng - start_lng);
        let base_lat = start_lat + t * (end_lat - start_lat);

        // Add GPS-like noise
        let noise_lng = (i as f64 * 13.7).sin() * 0.0001;
        let noise_lat = (i as f64 * 17.3).cos() * 0.0001;

        points.push(LngLat::new_deg(base_lng + noise_lng, base_lat + noise_lat));
    }

    points
}

fn main() {
    println!("rapidgeo-simplify batch processing demo");

    // Test single large polyline
    let large_polyline = create_large_polyline(10000);
    println!(
        "Created large polyline with {} points",
        large_polyline.len()
    );

    let tolerance = 25.0; // 25 meters
    let method = SimplifyMethod::GreatCircleMeters;

    // Serial processing
    let start = std::time::Instant::now();
    let mut serial_result = Vec::new();
    let serial_count = simplify_dp_into(&large_polyline, tolerance, method, &mut serial_result);
    let serial_time = start.elapsed();

    println!(
        "Serial: {} -> {} points in {:?}",
        large_polyline.len(),
        serial_count,
        serial_time
    );

    #[cfg(feature = "batch")]
    {
        // Parallel processing
        let start = std::time::Instant::now();
        let mut par_result = Vec::new();
        let par_count = simplify_dp_into_par(&large_polyline, tolerance, method, &mut par_result);
        let par_time = start.elapsed();

        println!(
            "Parallel: {} -> {} points in {:?}",
            large_polyline.len(),
            par_count,
            par_time
        );

        // Verify results are identical
        assert_eq!(serial_count, par_count);
        assert_eq!(serial_result, par_result);
        println!("✅ Serial and parallel results match");

        // Test batch processing of multiple polylines
        let polylines = vec![
            create_large_polyline(2000),
            create_large_polyline(3000),
            create_large_polyline(1500),
            create_large_polyline(2500),
        ];

        let total_points: usize = polylines.iter().map(|p| p.len()).sum();
        println!(
            "\nBatch processing {} polylines with {} total points",
            polylines.len(),
            total_points
        );

        // Serial batch
        let start = std::time::Instant::now();
        let serial_batch = rapidgeo_simplify::batch::simplify_batch(&polylines, tolerance, method);
        let serial_batch_time = start.elapsed();

        let serial_total_out: usize = serial_batch.iter().map(|p| p.len()).sum();
        println!(
            "Serial batch: {} -> {} points in {:?}",
            total_points, serial_total_out, serial_batch_time
        );

        // Parallel batch
        let start = std::time::Instant::now();
        let par_batch = simplify_batch_par(&polylines, tolerance, method);
        let par_batch_time = start.elapsed();

        let par_total_out: usize = par_batch.iter().map(|p| p.len()).sum();
        println!(
            "Parallel batch: {} -> {} points in {:?}",
            total_points, par_total_out, par_batch_time
        );

        // Verify results match
        assert_eq!(serial_batch, par_batch);
        println!("✅ Serial and parallel batch results match");

        if par_batch_time < serial_batch_time {
            let speedup = serial_batch_time.as_secs_f64() / par_batch_time.as_secs_f64();
            println!("🚀 Parallel batch is {:.2}x faster!", speedup);
        }
    }

    #[cfg(not(feature = "batch"))]
    {
        println!("To see parallel processing demo, run with: cargo run --example batch_demo --features batch");
    }
}