flexpolyline 1.0.0

Flexible Polyline encoding: a lossy compressed representation of a list of coordinate pairs or triples
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

//! Example which generates random polylines covering all possible cases.

use rand::prelude::*;

fn main() {
    let mut rng = rand::thread_rng();
    let range_lat = 180 * 10_i64.pow(15);
    let range_lon = 90 * 10_i64.pow(15);
    let range_z = 1000 * 10_i64.pow(14);
    for &divisor in [
        1,
        10_i64.pow(4),
        10_i64.pow(8),
        10_i64.pow(12),
        10_i64.pow(17),
        10_i64.pow(18),
    ]
    .iter()
    {
        for num_coords in 1..5 {
            for prec2d in 0..=15 {
                for &type3d in [
                    flexpolyline::Type3d::Level,
                    flexpolyline::Type3d::Altitude,
                    flexpolyline::Type3d::Elevation,
                    flexpolyline::Type3d::Reserved1,
                    flexpolyline::Type3d::Reserved2,
                    flexpolyline::Type3d::Custom1,
                    flexpolyline::Type3d::Custom2,
                ]
                .iter()
                {
                    let polyline = flexpolyline::Polyline::Data3d {
                        precision2d: flexpolyline::Precision::from_u32(prec2d).unwrap(),
                        precision3d: flexpolyline::Precision::from_u32(15 - prec2d).unwrap(),
                        type3d,
                        coordinates: (0..num_coords)
                            .map(|_| {
                                (
                                    (rng.gen_range(-range_lat..=range_lat) / divisor) as f64
                                        / 10_i64.pow(15) as f64,
                                    (rng.gen_range(-range_lon..=range_lon) / divisor) as f64
                                        / 10_i64.pow(15) as f64,
                                    (rng.gen_range(-range_z..=range_z) / divisor) as f64
                                        / 10_i64.pow(14) as f64,
                                )
                            })
                            .collect(),
                    };
                    println!("{:.15}", polyline);
                }

                let polyline = flexpolyline::Polyline::Data2d {
                    precision2d: flexpolyline::Precision::from_u32(prec2d).unwrap(),
                    coordinates: (0..num_coords)
                        .map(|_| {
                            (
                                (rng.gen_range(-range_lat..=range_lat) / divisor) as f64
                                    / 10_i64.pow(15) as f64,
                                (rng.gen_range(-range_lon..=range_lon) / divisor) as f64
                                    / 10_i64.pow(15) as f64,
                            )
                        })
                        .collect(),
                };
                println!("{:.15}", polyline);
            }
        }
    }
}