ezu-paint 0.3.0

Paint GIS features onto a hokusai surface for ezu
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

//! `map-range` — `ScalarField -> ScalarField`. Linearly remap values
//! from `[in_min, in_max]` to `[out_min, out_max]`. Optionally clamps
//! results into the output range. Useful for normalising a DEM or
//! distance field into `[0, 1]` before feeding `color-ramp`, or for
//! amplifying / inverting a scalar signal before another scalar op.

use std::sync::Arc;

use ezu_graph::{
    schema_frag, take_input_ref, BuiltNode, Connection, EvalCtx, EvalError, FactoryCtx,
    FactoryError, GeoScale, Node, NodeFactory, PortKind, PortSpec, PortValue, ScalarField,
};
use serde_json::Value;
use xxhash_rust::xxh3::Xxh3;

use crate::nodes::common::read_number_or;

struct MapRangeNode {
    in_min: f32,
    in_max: f32,
    out_min: f32,
    out_max: f32,
    clamp: bool,
}

impl Node for MapRangeNode {
    fn op_name(&self) -> &'static str {
        "map-range"
    }
    fn inputs(&self) -> &[PortSpec] {
        static SPECS: &[PortSpec] = &[PortSpec {
            name: "field",
            accepts: &[PortKind::ScalarField],
            optional: false,
        }];
        SPECS
    }
    fn output(&self, _input_kinds: &[Option<PortKind>]) -> PortKind {
        PortKind::ScalarField
    }
    fn eval(
        &self,
        _ctx: &EvalCtx<'_>,
        inputs: &[Option<PortValue>],
    ) -> Result<PortValue, EvalError> {
        let field = inputs[0]
            .as_ref()
            .and_then(PortValue::as_scalar_field)
            .ok_or_else(|| EvalError::MissingInput("field".into()))?;
        let span = self.in_max - self.in_min;
        // Degenerate input range: emit the output midpoint everywhere.
        // Avoids NaN from div-by-zero without forcing the caller to
        // special-case it.
        let inv_span = if span.abs() < 1e-9 { 0.0 } else { 1.0 / span };
        let mid = 0.5 * (self.out_min + self.out_max);
        let mut out: Vec<f32> = Vec::with_capacity(field.values.len());
        for &v in field.values.iter() {
            let t = (v - self.in_min) * inv_span;
            let mut y = self.out_min + t * (self.out_max - self.out_min);
            if inv_span == 0.0 {
                y = mid;
            }
            if self.clamp {
                let (lo, hi) = if self.out_min <= self.out_max {
                    (self.out_min, self.out_max)
                } else {
                    (self.out_max, self.out_min)
                };
                y = y.clamp(lo, hi);
            }
            out.push(y);
        }
        Ok(PortValue::ScalarField(Arc::new(ScalarField {
            width: field.width,
            height: field.height,
            values: out.into(),
            nodata: field.nodata,
            // Remapping values doesn't change geographic spacing —
            // a remapped DEM still has the same metres-per-pixel.
            geo_scale: field.geo_scale.map(|g| GeoScale {
                metres_per_pixel_x: g.metres_per_pixel_x,
                metres_per_pixel_y: g.metres_per_pixel_y,
            }),
        })))
    }
    fn param_hash(&self, h: &mut Xxh3) {
        h.update(b"map-range");
        h.update(&self.in_min.to_le_bytes());
        h.update(&self.in_max.to_le_bytes());
        h.update(&self.out_min.to_le_bytes());
        h.update(&self.out_max.to_le_bytes());
        h.update(&[self.clamp as u8]);
    }
}

pub(super) struct MapRangeFactory;
impl NodeFactory for MapRangeFactory {
    fn op_name(&self) -> &'static str {
        "map-range"
    }
    fn build(
        &self,
        fields: &serde_json::Map<String, Value>,
        ctx: &FactoryCtx<'_>,
    ) -> Result<BuiltNode, FactoryError> {
        let input = take_input_ref(fields, "field")?;
        let in_min = read_number_or(fields, "in-min", ctx, 0.0)? as f32;
        let in_max = read_number_or(fields, "in-max", ctx, 1.0)? as f32;
        let out_min = read_number_or(fields, "out-min", ctx, 0.0)? as f32;
        let out_max = read_number_or(fields, "out-max", ctx, 1.0)? as f32;
        let clamp = fields
            .get("clamp")
            .and_then(|v| v.as_bool())
            .unwrap_or(false);
        Ok(BuiltNode {
            node: Box::new(MapRangeNode {
                in_min,
                in_max,
                out_min,
                out_max,
                clamp,
            }),
            connections: vec![Connection {
                port: "field".into(),
                src: input,
            }],
        })
    }
    fn schema(&self) -> Value {
        serde_json::json!({
            "description": "Linearly remap scalar field values from [in-min, in-max] to [out-min, out-max]. With `clamp: true`, results outside the output range are pinned to the range bounds. Useful for normalising elevation or distance fields before a `color-ramp`.",
            "properties": {
                "field": schema_frag::node_ref(),
                "in-min": { "type": "number", "default": 0.0 },
                "in-max": { "type": "number", "default": 1.0 },
                "out-min": { "type": "number", "default": 0.0 },
                "out-max": { "type": "number", "default": 1.0 },
                "clamp": { "type": "boolean", "default": false },
            },
            "required": ["field"],
        })
    }
}

ezu_graph::submit_node!(MapRangeFactory);