proj4rs 0.1.9

Rust adaptation of Proj4
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

//!
//! Transform adaptors
//!
#[cfg(feature = "geo-types")]
pub mod geo_types;

use crate::errors::Result;
use crate::proj::Proj;
use crate::transform::{transform, Transform, TransformClosure};

//
// Transform a 3-tuple
//
impl Transform for (f64, f64, f64) {
    fn transform_coordinates<F: TransformClosure>(&mut self, f: &mut F) -> Result<()> {
        (self.0, self.1, self.2) = f(self.0, self.1, self.2)?;
        Ok(())
    }
}

//
// Transform a 2-tuple
//
impl Transform for (f64, f64) {
    fn transform_coordinates<F: TransformClosure>(&mut self, f: &mut F) -> Result<()> {
        (self.0, self.1) = f(self.0, self.1, 0.).map(|(x, y, _)| (x, y))?;
        Ok(())
    }
}

/// Transform a 3-tuple
///
/// ```rust
/// use proj4rs::Proj;
/// use proj4rs::adaptors::transform_vertex_3d;
///
/// let dst = Proj::from_proj_string("+proj=utm +ellps=GRS80 +zone=30").unwrap();
/// let src = Proj::from_proj_string("+proj=latlong +ellps=GRS80").unwrap();
///
/// let (x, y, z) = transform_vertex_3d(&src, &dst, (2.0, 1.0, 0.0)).unwrap();
/// ```
pub fn transform_vertex_3d(src: &Proj, dst: &Proj, pt: (f64, f64, f64)) -> Result<(f64, f64, f64)> {
    let mut pt_out = pt;
    transform(src, dst, &mut pt_out)?;
    Ok(pt_out)
}

/// Transform a 2-tuple
///
/// ```rust
/// use proj4rs::Proj;
/// use proj4rs::adaptors::transform_vertex_2d;
///
/// let dst = Proj::from_proj_string("+proj=utm +ellps=GRS80 +zone=30").unwrap();
/// let src = Proj::from_proj_string("+proj=latlong +ellps=GRS80").unwrap();
///
/// let (x, y) = transform_vertex_2d(&src, &dst, (2.0, 1.0)).unwrap();
/// ```
#[inline(always)]
pub fn transform_vertex_2d(src: &Proj, dst: &Proj, pt: (f64, f64)) -> Result<(f64, f64)> {
    transform_vertex_3d(src, dst, (pt.0, pt.1, 0.)).map(|(x, y, _)| (x, y))
}

/// Transform x, y and z value
///
/// ```rust
/// use proj4rs::Proj;
/// use proj4rs::adaptors::transform_xyz;
///
/// let dst = Proj::from_proj_string("+proj=utm +ellps=GRS80 +zone=30").unwrap();
/// let src = Proj::from_proj_string("+proj=latlong +ellps=GRS80").unwrap();
///
/// let (x, y, z) = transform_xyz(&src, &dst, 2.0, 1.0, 0.0).unwrap();
/// ```
#[inline(always)]
pub fn transform_xyz(src: &Proj, dst: &Proj, x: f64, y: f64, z: f64) -> Result<(f64, f64, f64)> {
    transform_vertex_3d(src, dst, (x, y, z))
}

/// Transform x, y value
///
/// ```rust
/// use proj4rs::Proj;
/// use proj4rs::adaptors::transform_xy;
///
/// let dst = Proj::from_proj_string("+proj=utm +ellps=GRS80 +zone=30").unwrap();
/// let src = Proj::from_proj_string("+proj=latlong +ellps=GRS80").unwrap();
///
/// let (x, y) = transform_xy(&src, &dst, 2.0, 1.0).unwrap();
/// ```
#[inline(always)]
pub fn transform_xy(src: &Proj, dst: &Proj, x: f64, y: f64) -> Result<(f64, f64)> {
    transform_xyz(src, dst, x, y, 0.).map(|(x, y, _)| (x, y))
}

//
// Transform an array of 3-tuple:
//
impl Transform for [(f64, f64, f64)] {
    fn transform_coordinates<F: TransformClosure>(&mut self, f: &mut F) -> Result<()> {
        self.iter_mut()
            .try_for_each(|xyz| xyz.transform_coordinates(f))
    }
}

//
// Transform an array of 2-tuple:
//
impl Transform for [(f64, f64)] {
    fn transform_coordinates<F: TransformClosure>(&mut self, f: &mut F) -> Result<()> {
        self.iter_mut()
            .try_for_each(|xy| xy.transform_coordinates(f))
    }
}