geodesy 0.15.0

A platform for experiments with geodetic transformations and data flow
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
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206

use super::pushpop::{do_the_pop, do_the_push};
use super::stack::{stack_fwd, stack_inv};
use crate::authoring::*;

// ----- F O R W A R D -----------------------------------------------------------------

fn pipeline_fwd(op: &Op, ctx: &dyn Context, operands: &mut dyn CoordinateSet) -> usize {
    let mut stack = Vec::new();
    let mut n = usize::MAX;
    let steps = op.steps.as_ref().unwrap();
    for step in steps {
        if step.params.boolean("omit_fwd") {
            continue;
        }
        let m = match step.params.name.as_str() {
            "push" => do_the_push(&mut stack, operands, &step.params.boolean),
            "pop" => do_the_pop(&mut stack, operands, &step.params.boolean),
            "stack" => stack_fwd(&mut stack, operands, &step.params),
            _ => step.apply(ctx, operands, Fwd),
        };
        n = n.min(m);
    }

    // In case every step has been marked as `omit_fwd`
    if n == usize::MAX {
        n = operands.len();
    }
    n
}

// ----- I N V E R S E -----------------------------------------------------------------

fn pipeline_inv(op: &Op, ctx: &dyn Context, operands: &mut dyn CoordinateSet) -> usize {
    let mut stack = Vec::new();
    let mut n = usize::MAX;
    let steps = op.steps.as_ref().unwrap();
    for step in steps.iter().rev() {
        if step.params.boolean("omit_inv") {
            continue;
        }
        // Note: Under inverse invocation "push" calls pop and vice versa
        let m = match step.params.name.as_str() {
            "push" => do_the_pop(&mut stack, operands, &step.params.boolean),
            "pop" => do_the_push(&mut stack, operands, &step.params.boolean),
            "stack" => stack_inv(&mut stack, operands, &step.params),
            _ => step.apply(ctx, operands, Inv),
        };
        n = n.min(m);
    }

    // In case every step has been marked as `omit_inv`
    if n == usize::MAX {
        n = operands.len();
    }
    n
}

// ----- C O N S T R U C T O R ---------------------------------------------------------

#[rustfmt::skip]
pub const GAMUT: [OpParameter; 0] = [];

pub fn new(parameters: &RawParameters, ctx: &dyn Context) -> Result<Op, Error> {
    let definition = &parameters.instantiated_as;
    let thesteps = definition.split_into_steps();
    let mut steps = Vec::new();

    for step in thesteps {
        let step_parameters = RawParameters::new(&step, &parameters.globals);
        steps.push(Op::op(step_parameters, ctx)?);
    }

    // params is not really useful in the pipeline case, but needed in order
    // to instantiate the Op. The token/split_into_parameters() function
    // special-cases pipelines, so the `_name` entry becomes the entire
    // definition (`instantiated_as`)
    let params = ParsedParameters::new(parameters, &GAMUT)?;

    let fwd = InnerOp(pipeline_fwd);
    let inv = InnerOp(pipeline_inv);
    let descriptor = OpDescriptor::new(definition, fwd, Some(inv));
    Ok(Op {
        descriptor,
        params,
        steps: Some(steps),
    })
}

// ----- T E S T S ---------------------------------------------------------------------

#[cfg(test)]
mod tests {
    use super::*;
    #[test]
    fn pipeline() -> Result<(), Error> {
        let mut ctx = Minimal::default();

        // Plain pipeline
        let op = ctx.op("addone|addone|addone")?;
        let mut data = crate::test_data::coor2d();

        assert_eq!(2, ctx.apply(op, Fwd, &mut data)?);
        assert_eq!(data[0][0], 58.);
        assert_eq!(data[1][0], 62.);

        ctx.apply(op, Inv, &mut data)?;
        assert_eq!(data[0][0], 55.);
        assert_eq!(data[1][0], 59.);

        // Pipeline with one inverted step
        let op = ctx.op("addone|addone inv|addone")?;
        let mut data = crate::test_data::coor2d();
        assert_eq!(data[0][0], 55.);
        assert_eq!(data[1][0], 59.);

        ctx.apply(op, Fwd, &mut data)?;
        assert_eq!(data[0][0], 56.);
        assert_eq!(data[1][0], 60.);

        ctx.apply(op, Inv, &mut data)?;
        assert_eq!(data[0][0], 55.);
        assert_eq!(data[1][0], 59.);

        // Same, but with prefix modifier syntax
        let op = ctx.op("addone|inv addone|addone")?;
        ctx.apply(op, Fwd, &mut data)?;
        assert_eq!(data[0][0], 56.);
        assert_eq!(data[1][0], 60.);

        ctx.apply(op, Inv, &mut data)?;
        assert_eq!(data[0][0], 55.);
        assert_eq!(data[1][0], 59.);

        // Registered resource
        ctx.register_resource("why:eggs", "helmert x=$eggs | helmert y=$why(1)");
        let op = ctx.op("why:eggs eggs=4")?;
        ctx.apply(op, Fwd, &mut data)?;
        assert_eq!(data[0][0], 59.);
        assert_eq!(data[1][0], 63.);
        assert_eq!(data[0][1], 13.);
        assert_eq!(data[1][1], 19.);

        ctx.apply(op, Inv, &mut data)?;
        assert_eq!(data[0][0], 55.);
        assert_eq!(data[1][0], 59.);

        // Invoke it as inverted
        let op = ctx.op("inv why:eggs eggs=4")?;
        ctx.apply(op, Inv, &mut data)?;
        assert_eq!(data[0][0], 59.);
        assert_eq!(data[1][0], 63.);
        assert_eq!(data[0][1], 13.);
        assert_eq!(data[1][1], 19.);

        ctx.apply(op, Fwd, &mut data)?;
        assert_eq!(data[0][0], 55.);
        assert_eq!(data[1][0], 59.);

        // And with inversion in postfix position
        let op = ctx.op("why:eggs eggs=4 inv")?;
        ctx.apply(op, Inv, &mut data)?;
        assert_eq!(data[0][0], 59.);
        assert_eq!(data[1][0], 63.);
        assert_eq!(data[0][1], 13.);
        assert_eq!(data[1][1], 19.);

        ctx.apply(op, Fwd, &mut data)?;
        assert_eq!(data[0][0], 55.);
        assert_eq!(data[1][0], 59.);

        // Pipeline with registered resource as one step
        let op = ctx.op("helmert x=-2 | why:eggs eggs=1 why=0")?;
        ctx.apply(op, Fwd, &mut data)?;
        assert_eq!(data[0][0], 54.);
        assert_eq!(data[1][0], 58.);
        assert_eq!(data[0][1], 12.);
        assert_eq!(data[1][1], 18.);

        ctx.apply(op, Inv, &mut data)?;
        assert_eq!(data[0][0], 55.);
        assert_eq!(data[1][0], 59.);

        // Pipeline with registered resource as one INVERTED step
        let op = ctx.op("helmert x=-2 | inv why:eggs eggs=1 why=0")?;
        ctx.apply(op, Fwd, &mut data)?;
        assert_eq!(data[0][0], 52.);
        assert_eq!(data[1][0], 56.);
        assert_eq!(data[0][1], 12.);
        assert_eq!(data[1][1], 18.);

        ctx.apply(op, Inv, &mut data)?;
        assert_eq!(data[0][0], 55.);
        assert_eq!(data[1][0], 59.);

        // Try to invoke the registered resource, without a required parameter
        assert!(matches!(ctx.op("why:eggs why=10"), Err(Error::Syntax(_))));

        // Try to invoke garbage as a pipeline step
        assert!(matches!(
            ctx.op("addone|addone|_garbage"),
            Err(Error::NotFound(_, _))
        ));

        Ok(())
    }
}