proj4rs 0.1.4

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
115
116
117

//!
//! Handle Nadgrids
//!
use crate::errors::{Error, Result};
use crate::transform::Direction;

mod catlg;
mod grid;

pub use catlg::{catalog, Catalog, GridRef};

#[cfg(not(target_arch = "wasm32"))]
mod header;

#[cfg(not(target_arch = "wasm32"))]
pub mod files;

use std::ops::ControlFlow;

pub(crate) use grid::Lp;
pub(crate) use grid::{Grid, GridId};

/// NadGrids
///
/// Returned from the sequence
/// of nadgrids from projstring definition
#[derive(Debug, Clone)]
pub struct NadGrids(Vec<GridRef>);

impl PartialEq for NadGrids {
    fn eq(&self, other: &Self) -> bool {
        // Don't bother to compare all names
        self.0.is_empty() && other.0.is_empty()
    }
}

impl NadGrids {
    pub fn apply_shift(
        &self,
        dir: Direction,
        lam: f64,
        phi: f64,
        z: f64,
    ) -> Result<(f64, f64, f64)> {
        if self.0.is_empty() {
            return Ok((lam, phi, z));
        }

        // Find the correct (root)  grid for an input
        let mut iter = self.0.iter();
        let mut candidate = iter.find(|g| g.is_root() && g.matches(lam, phi, z));

        // Check for childs grid
        if let Some(grid) = candidate {
            iter.try_fold(grid, |grid, g| {
                if !g.is_child_of(grid) {
                    // No more childs, stop with the last candidate
                    ControlFlow::Break(())
                } else if g.matches(lam, phi, z) {
                    // Match, check for childs
                    candidate.replace(g);
                    ControlFlow::Continue(g)
                } else {
                    // Go next child
                    ControlFlow::Continue(grid)
                }
            });
        }

        match candidate {
            Some(g) => g.nad_cvt(dir, lam, phi, z),
            None => Err(Error::PointOutsideNadShiftArea),
        }
    }

    /// Return a list of grids from the catalog
    pub fn new_grid_transform(names: &str) -> Result<Self> {
        // Parse the grid list and return an error
        // if there is any mandatory grid or the list is not terminated by
        // '@null'
        let mut v: Vec<GridRef> = vec![];

        match names.split(',').try_for_each(|s| {
            let s = s.trim();
            if s == "@null" || s == "null" {
                // Allow empty list
                // Mark also the end of parsing
                ControlFlow::Break(true)
            } else if let Some(s) = s.strip_prefix('@') {
                // Optional grid
                catalog::find_grids(s, &mut v);
                ControlFlow::Continue(())
            } else {
                // Mandatory grid
                if catalog::find_grids(s, &mut v) {
                    ControlFlow::Continue(())
                } else {
                    ControlFlow::Break(false)
                }
            }
        }) {
            ControlFlow::Break(true) => Ok(Self(v)),
            ControlFlow::Break(false) => Err(Error::NadGridNotAvailable),
            _ => {
                if v.is_empty() {
                    Err(Error::NadGridNotAvailable)
                } else {
                    Ok(Self(v))
                }
            }
        }
    }

    pub fn is_empty(&self) -> bool {
        self.0.is_empty()
    }
}