mappers 0.8.1

Pure Rust geographical projections library
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

use std::{sync::Arc, thread};

use float_cmp::assert_approx_eq;
use mappers::{
    Ellipsoid, Projection,
    projections::{AzimuthalEquidistant, LambertConformalConic, LongitudeLatitude},
};

#[test]
fn arc_interop() {
    let proj = AzimuthalEquidistant::builder()
        .ref_lonlat(30., 30.)
        .ellipsoid(Ellipsoid::WGS84)
        .initialize_projection()
        .unwrap();
    let proj = Arc::new(proj);
    let mut handles = vec![];

    for _ in 0..10 {
        let proj = Arc::clone(&proj);
        let handle = thread::spawn(move || {
            let map_coords = proj.project(25.0, 45.0).unwrap();
            let geo_coords = proj.inverse_project(200_000.0, 300_000.0).unwrap();

            (map_coords, geo_coords)
        });
        handles.push(handle);
    }

    for handle in handles {
        let (map_coords, geo_coords) = handle.join().unwrap();

        assert_approx_eq!(f64, map_coords.0, -398563.2994422894, epsilon = 0.000_000_1);
        assert_approx_eq!(f64, map_coords.1, 1674853.7525355904, epsilon = 0.000_000_1);

        assert_approx_eq!(f64, geo_coords.0, 32.132000374279365, epsilon = 0.000_000_1);
        assert_approx_eq!(f64, geo_coords.1, 32.68850065409422, epsilon = 0.000_000_1);
    }
}

#[test]
fn conversion_arc_interop() {
    let ll = LongitudeLatitude;
    let lcc = LambertConformalConic::builder()
        .ref_lonlat(30., 30.)
        .standard_parallels(30., 60.)
        .ellipsoid(Ellipsoid::WGS84)
        .initialize_projection()
        .unwrap();
    let aeqd = AzimuthalEquidistant::builder()
        .ref_lonlat(30., 30.)
        .ellipsoid(Ellipsoid::WGS84)
        .initialize_projection()
        .unwrap();

    let ll = Arc::new(ll);
    let lcc = Arc::new(lcc);
    let aeqd = Arc::new(aeqd);

    let mut handles = vec![];

    for _ in 0..10 {
        let ll = Arc::clone(&ll);
        let lcc = Arc::clone(&lcc);
        let aeqd = Arc::clone(&aeqd);

        let handle = thread::spawn(move || {
            let (lcc_x, lcc_y) = ll.pipe_to(&*lcc).convert(25.0, 45.0).unwrap();
            let (aeqd_x, aeqd_y) = lcc.pipe_to(&*aeqd).convert(lcc_x, lcc_y).unwrap();
            aeqd.pipe_to(&*ll).convert(aeqd_x, aeqd_y).unwrap()
        });
        handles.push(handle);
    }

    for handle in handles {
        let coords = handle.join().unwrap();

        assert_approx_eq!(f64, coords.0, 25.0, epsilon = 1e-8);
        assert_approx_eq!(f64, coords.1, 45.0, epsilon = 1e-8);
    }
}