oxigeo-gpu 0.2.2

GPU-accelerated geospatial operations for OxiGeo using WGPU
Documentation
// GPU raster algebra evaluation.
// Supported operations (params.operation):
//   0=add, 1=sub, 2=mul, 3=div, 4=min, 5=max, 6=sqrt, 7=abs,
//   8=pow(a, scalar0), 9=clamp(a, scalar0, scalar1),
//   10=normalize(a; src_min=scalar0, src_max=scalar1, dst_min=scalar2, dst_max=scalar3)
// Unary ops (6..=10) ignore band_b. Binary ops (0..=5) require has_b != 0.
// An unrecognized operation code writes NaN as an explicit sentinel rather than
// silently passing the input through unchanged.

struct AlgebraParams {
    width: u32,
    height: u32,
    operation: u32,
    use_nodata: u32,
    // Whether band_b holds real data (binary op) vs. a zeroed placeholder.
    has_b: u32,
    _p0: u32,
    _p1: u32,
    _p2: u32,
    nodata_a: f32,
    nodata_b: f32,
    output_nodata: f32,
    scalar0: f32,
    scalar1: f32,
    scalar2: f32,
    scalar3: f32,
    _p3: f32,
};

@group(0) @binding(0) var<uniform> params: AlgebraParams;
@group(0) @binding(1) var<storage, read> band_a: array<f32>;
@group(0) @binding(2) var<storage, read> band_b: array<f32>;
@group(0) @binding(3) var<storage, read_write> output: array<f32>;

@compute @workgroup_size(256)
fn main(@builtin(global_invocation_id) gid: vec3<u32>) {
    let idx = gid.x;
    let total = params.width * params.height;
    if idx >= total { return; }

    let a = band_a[idx];
    let b = band_b[idx];

    // Nodata masking (matches the CPU `is_nodata` 1e-6 threshold).
    if params.use_nodata != 0u {
        let a_masked = abs(a - params.nodata_a) < 1e-6;
        let b_masked = params.has_b != 0u && abs(b - params.nodata_b) < 1e-6;
        if a_masked || b_masked {
            output[idx] = params.output_nodata;
            return;
        }
    }

    var result: f32;
    switch params.operation {
        case 0u: { result = a + b; }
        case 1u: { result = a - b; }
        case 2u: { result = a * b; }
        case 3u: { result = select(params.output_nodata, a / b, abs(b) > 1e-10); }
        case 4u: { result = min(a, b); }
        case 5u: { result = max(a, b); }
        case 6u: { result = sqrt(max(0.0, a)); }
        case 7u: { result = abs(a); }
        case 8u: { result = pow(a, params.scalar0); }
        case 9u: { result = clamp(a, params.scalar0, params.scalar1); }
        case 10u: {
            let range = params.scalar1 - params.scalar0;
            result = select(
                params.scalar2,
                (a - params.scalar0) / range * (params.scalar3 - params.scalar2) + params.scalar2,
                abs(range) >= 1e-10
            );
        }
        // Unknown operation code: explicit NaN sentinel (never silent identity).
        default: { result = bitcast<f32>(0x7fc00000u); }
    }

    output[idx] = result;
}