calzone 1.1.6__tar.gz → 1.1.8__tar.gz

{calzone-1.1.6 → calzone-1.1.8}/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "calzone"
-version = "1.1.6"
+version = "1.1.8"
 edition = "2021"
 
 [lib]
@@ -13,6 +13,8 @@ cxx = "1.0"
 derive_more = "0.99"
 enum-variants-strings = "0.3"
 flate2.workspace = true
+geotiff = "0.1"
+geo-types = "0.7"
 getrandom = "0.2"
 indexmap = "2.2"
 indicatif = "0.17"

{calzone-1.1.6/src/python/calzone.egg-info → calzone-1.1.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: calzone
-Version: 1.1.6
+Version: 1.1.8
 Summary: A Geant4 Python wrapper.
 Author-email: Valentin Niess <valentin.niess@gmail.com>
 License: LGPLv3

{calzone-1.1.6 → calzone-1.1.8}/pyproject.toml

@@ -15,7 +15,7 @@ classifiers = [
     "Intended Audience :: Science/Research",
     "Topic :: Scientific/Engineering :: Physics"
 ]
-version = "1.1.6"
+version = "1.1.8"
 requires-python = ">=3.7.0"
 dependencies = [
     "numpy >= 1.6.0",

{calzone-1.1.6 → calzone-1.1.8}/src/geometry/map.rs

@@ -1,12 +1,16 @@
 use crate::utils::error::Error;
-use crate::utils::error::ErrorKind::{NotImplementedError, ValueError};
+use crate::utils::error::ErrorKind::{IOError, NotImplementedError, TypeError, ValueError};
 use crate::utils::extract::{Extractor, Property, Tag};
 use crate::utils::float::f64x3;
 use crate::utils::io::{dump_stl, PathString};
 use crate::utils::numpy::{PyArray, PyArrayMethods, PyUntypedArray};
+use geotiff::{GeoTiff, RasterType};
+use geo_types::geometry::Coord;
 use pyo3::prelude::*;
 use pyo3::types::PyDict;
 use std::ffi::OsStr;
+use std::fs::File;
+use std::io::{BufRead, BufReader, BufWriter, Write};
 use std::path::Path;
 
 
@@ -62,7 +66,7 @@ impl Map {
                 let geotiff = py.import_bound("geotiff")
                     .and_then(|module| module.getattr("GeoTiff"))?;
                 if any.is_instance(&geotiff)? {
-                    Self::from_geotiff(&any)
+                    Self::from_geotiff_object(&any)
                 } else {
                     let why = format!(
                         "unimplemented conversion from '{}'",
@@ -129,6 +133,23 @@ impl Map {
         let filename = filename.to_string();
         let path = Path::new(&filename);
         match path.extension().and_then(OsStr::to_str) {
+            Some("asc") | Some("ASC") => {
+                let mut nodata: Option<f32> = None;
+                let mut precision: Option<usize> = None;
+                if let Some(kwargs) = kwargs {
+                    const EXTRACTOR: Extractor<2> = Extractor::new([
+                        Property::optional_f64("nodata"),
+                        Property::optional_u32("precision"),
+                    ]);
+                    let tag = Tag::new("dump", "", None);
+                    let [nodata_value, prec] = EXTRACTOR.extract_any(&tag, kwargs, None)?;
+                    let nodata_value: Option<f64> = nodata_value.into();
+                    nodata = nodata_value.map(|value| value as f32);
+                    let prec: Option<u32> = prec.into();
+                    precision = prec.map(|value| value as usize);
+                }
+                self.to_ascii(py, &filename, nodata, precision)
+            },
             Some("png") | Some("PNG") => {
                 if let Some(kwargs) = kwargs {
                     const EXTRACTOR: Extractor<0> = Extractor::new([]); // No arguments.
@@ -194,6 +215,7 @@ impl Map {
     pub fn from_file(py: Python, path: &Path) -> PyResult<Self> {
         let filename = path.to_str().unwrap();
         match path.extension().and_then(OsStr::to_str) {
+            Some("asc") | Some("ASC") => Self::from_ascii(py, filename),
             Some("png") | Some("PNG") => Self::from_png(py, filename),
             Some("tif") | Some("TIF") => Self::from_geotiff_file(py, filename),
             Some(other) => {
@@ -445,7 +467,73 @@ impl Map {
 // ===============================================================================================
 
 impl Map {
-    fn from_geotiff<'py>(geotiff: &Bound<'py, PyAny>) -> PyResult<Self> {
+    fn from_geotiff_file<'py>(py: Python, path: &str) -> PyResult<Self> {
+        let geotiff = GeoTiff::read(File::open(path)?)
+            .map_err(|err| Error::new(IOError)
+                .what("GeoTIFF file")
+                .why(&err.to_string())
+                .to_err()
+            )?;
+        let crs = geotiff.geo_key_directory.projected_type.map(|crs| crs as usize);
+        let nx = geotiff.raster_width;
+        let ny = geotiff.raster_height;
+        let ([x0, x1], [y0, y1]) = {
+            let extent = geotiff.model_extent();
+            let min = extent.min();
+            let max = extent.max();
+            let x = [ min.x, max.x ];
+            let y = [ min.y, max.y ];
+            (x, y)
+        };
+
+        let raster_type = match geotiff.geo_key_directory.raster_type
+            .unwrap_or(RasterType::Undefined) {
+            RasterType::RasterPixelIsArea => RasterType::RasterPixelIsArea,
+            RasterType::RasterPixelIsPoint => RasterType::RasterPixelIsPoint,
+            _ => if geotiff
+                .get_value_at::<f64>(&Coord { x: x0, y: y0 }, 0)
+                .or_else(|| geotiff.get_value_at::<f64>(&Coord { x: x1, y: y0 }, 0))
+                .or_else(|| geotiff.get_value_at::<f64>(&Coord { x: x0, y: y1 }, 0))
+                .or_else(|| geotiff.get_value_at::<f64>(&Coord { x: x1, y: y1 }, 0))
+                .is_none() {
+                RasterType::RasterPixelIsPoint
+            } else {
+                RasterType::RasterPixelIsArea
+            },
+        };
+        let (x0, x1, dx, y0, y1, dy) = match raster_type {
+            RasterType::RasterPixelIsArea => {
+                let dx = (x1 - x0) / (nx as f64);
+                let dy = (y1 - y0) / (ny as f64);
+                (x0 + 0.5 * dx, x1 - 0.5 * dx, dx, y0 + 0.5 * dy, y1 - 0.5 * dy, dy)
+            },
+            RasterType::RasterPixelIsPoint => {
+                let dx = (x1 - x0) / ((nx - 1) as f64);
+                let dy = (y1 - y0) / ((ny - 1) as f64);
+                (x0, x1, dx, y0, y1, dy)
+            },
+            _ => unreachable!(),
+        };
+
+        let array = PyArray::<f32>::empty(py, &[ny, nx])?;
+        let size = nx * ny;
+        if size > 0 {
+            let z = unsafe { array.slice_mut()? };
+            for iy in 0..ny {
+                let y = if iy == ny - 1 { y1 } else { y0 + iy as f64 * dy };
+                for ix in 0..nx {
+                    let x = if ix == nx - 1 { x1 } else { x0 + ix as f64 * dx };
+                    z[iy * nx + ix] = geotiff.get_value_at(&Coord { x, y }, 0)
+                        .unwrap_or_else(|| 0.0);
+                }
+            }
+        }
+        let z = array.into_any().unbind();
+
+        Ok(Self { crs, nx, ny, x0, x1, y0, y1, z })
+    }
+
+    fn from_geotiff_object<'py>(geotiff: &Bound<'py, PyAny>) -> PyResult<Self> {
         // Get metadata.
         let crs = geotiff.getattr("crs_code")
             .and_then(|crs| {
@@ -495,13 +583,6 @@ impl Map {
         };
         Ok(map)
     }
-
-    fn from_geotiff_file<'py>(py: Python, path: &str) -> PyResult<Self> {
-        py.import_bound("geotiff")
-            .and_then(|module| module.getattr("GeoTiff"))
-            .and_then(|constr| constr.call1((path,)))
-            .and_then(|object| Self::from_geotiff(&object))
-    }
 }
 
 
@@ -660,3 +741,310 @@ impl Map {
         Ok(())
     }
 }
+
+
+// ===============================================================================================
+//
+// ASCII Grid serialisation.
+//
+// ===============================================================================================
+
+impl Map {
+    fn from_ascii<'py>(py: Python, path: &str) -> PyResult<Self> {
+        #[derive(Clone, Copy)]
+        enum MetaType {
+            Nx,
+            Ny,
+            X0,
+            Y0,
+            Delta,
+            NoData,
+        }
+
+        enum MetaValue {
+            NRows(usize),
+            NCols(usize),
+            XLLCenter(f64),
+            XLLCorner(f64),
+            YLLCenter(f64),
+            YLLCorner(f64),
+            CellSize(f64),
+            NoData(Result<f32, String>),
+        }
+
+        impl MetaValue {
+            fn into_f64(self) -> f64 {
+                match self {
+                    Self::CellSize(value) => value,
+                    _ => unreachable!(),
+                }
+            }
+
+            fn into_usize(self) -> usize {
+                match self {
+                    Self::NRows(value) => value,
+                    Self::NCols(value) => value,
+                    _ => unreachable!(),
+                }
+            }
+        }
+
+        const WHAT: &str = "ASCII Grid file";
+
+        impl MetaType {
+            const fn lineno(&self) -> usize {
+                match self {
+                    Self::Nx => 1,
+                    Self::Ny => 2,
+                    Self::X0 => 3,
+                    Self::Y0 => 4,
+                    Self::Delta => 5,
+                    Self::NoData => 6,
+                }
+            }
+
+            fn parse(
+                &self,
+                lines: &mut impl Iterator<Item=Result<String, std::io::Error>>,
+                path: &str,
+            ) -> PyResult<MetaValue> {
+                let badname = |expected: &str, found: &str| -> PyErr {
+                    let why = format!(
+                        "{}:{}: expected {}, found {}", path, self.lineno(), expected, found
+                    );
+                    Error::new(TypeError).what(WHAT).why(&why).to_err()
+                };
+
+                let badvalue = |err: String, value: &str| -> PyErr {
+                    let why = format!("{}:{}: {}: {}", path, self.lineno(), err, value);
+                    Error::new(TypeError).what(WHAT).why(&why).to_err()
+                };
+
+                let eol = || -> PyErr {
+                    let why = format!("{}:{}: unexpected end-of-line", path, self.lineno());
+                    Error::new(TypeError).what(WHAT).why(&why).to_err()
+                };
+
+                let Some(line) = lines.next() else { return Err(eol()) };
+                let Ok(line) = line else { return Err(eol()) };
+                let mut tokens = line.split_ascii_whitespace();
+                let Some(name) = tokens.next() else { return Err(eol()) };
+                let name = name.to_uppercase();
+                let Some(value) = tokens.next() else { return Err(eol()) };
+                if let Some(token) = tokens.next() {
+                    let why = format!("{}:{}: unexpected token: {}", path, self.lineno(), token);
+                    return Err(Error::new(TypeError).what(WHAT).why(&why).to_err())
+                }
+                let value = match self {
+                    Self::Nx => {
+                        if name.as_str() != "NCOLS" { return Err(badname("ncols", name.as_str())) }
+                        match value.parse::<usize>() {
+                            Ok(value) => MetaValue::NCols(value),
+                            Err(err) => { return Err(badvalue(err.to_string(), value)) },
+                        }
+                    },
+                    Self::Ny => {
+                        if name.as_str() != "NROWS" { return Err(badname("nrows", name.as_str())) }
+                        match value.parse::<usize>() {
+                            Ok(value) => MetaValue::NRows(value),
+                            Err(err) => { return Err(badvalue(err.to_string(), value)) },
+                        }
+                    },
+                    Self::X0 => {
+                        if name.as_str() == "XLLCENTER" {
+                            match value.parse::<f64>() {
+                                Ok(value) => MetaValue::XLLCenter(value),
+                                Err(err) => { return Err(badvalue(err.to_string(), value)) },
+                            }
+                        } else if name.as_str() == "XLLCORNER" {
+                            match value.parse::<f64>() {
+                                Ok(value) => MetaValue::XLLCorner(value),
+                                Err(err) => { return Err(badvalue(err.to_string(), value)) },
+                            }
+                        } else {
+                            return Err(badname("xllcenter or xllcorner", name.as_str()))
+                        }
+                    },
+                    Self::Y0 => {
+                        if name.as_str() == "YLLCENTER" {
+                            match value.parse::<f64>() {
+                                Ok(value) => MetaValue::YLLCenter(value),
+                                Err(err) => { return Err(badvalue(err.to_string(), value)) },
+                            }
+                        } else if name.as_str() == "YLLCORNER" {
+                            match value.parse::<f64>() {
+                                Ok(value) => MetaValue::YLLCorner(value),
+                                Err(err) => { return Err(badvalue(err.to_string(), value)) },
+                            }
+                        } else {
+                            return Err(badname("yllcenter or yllcorner", name.as_str()))
+                        }
+                    },
+                    Self::Delta => {
+                        if name.as_str() != "CELLSIZE" {
+                            return Err(badname("cellsize", name.as_str()))
+                        }
+                        match value.parse::<f64>() {
+                            Ok(value) => MetaValue::CellSize(value),
+                            Err(err) => { return Err(badvalue(err.to_string(), value)) },
+                        }
+                    },
+                    Self::NoData => {
+                        if name.as_str() == "NODATA_VALUE" {
+                            match value.parse::<f32>() {
+                                Ok(value) => MetaValue::NoData(Ok(value)),
+                                Err(err) => { return Err(badvalue(err.to_string(), value)) },
+                            }
+                        } else {
+                            MetaValue::NoData(Err(line))
+                        }
+                    },
+                };
+                Ok(value)
+            }
+        }
+
+        let file = File::open(path)?;
+        let mut lines = BufReader::new(file).lines();
+
+        let nx = MetaType::Nx.parse(&mut lines, path)?.into_usize();
+        let ny = MetaType::Ny.parse(&mut lines, path)?.into_usize();
+        let x0 = MetaType::X0.parse(&mut lines, path)?;
+        let y0 = MetaType::Y0.parse(&mut lines, path)?;
+        let dx = MetaType::Delta.parse(&mut lines, path)?.into_f64();
+        let dy = dx;
+        let x0 = match x0 {
+            MetaValue::XLLCorner(x0) => x0 + 0.5 * dx,
+            MetaValue::XLLCenter(x0) => x0,
+            _ => unreachable!(),
+        };
+        let y0 = match y0 {
+            MetaValue::YLLCorner(y0) => y0 + 0.5 * dy,
+            MetaValue::YLLCenter(y0) => y0,
+            _ => unreachable!(),
+        };
+        let nodata = MetaType::NoData.parse(&mut lines, path)?;
+
+        let (mut lineno, mut line, nodata) = match nodata {
+            MetaValue::NoData(value) => match value {
+                Ok(value) => (MetaType::NoData.lineno() + 1, lines.next(), value),
+                Err(line) => (MetaType::NoData.lineno(), Some(Ok(line)), -f32::INFINITY),
+            },
+            _ => unreachable!()
+        };
+        let array = PyArray::<f32>::empty(py, &[ny, nx])?;
+        let size = nx * ny;
+        if size > 0 {
+            let z = unsafe { array.slice_mut()? };
+            let mut index: usize = 0;
+            'outer: loop {
+                let Some(content) = line else { break };
+                let Ok(content) = content else {
+                    let why = format!("{}:{}: unexpected end-of-line", path, lineno);
+                    return Err(Error::new(TypeError).what(WHAT).why(&why).to_err())
+                };
+                for token in content.split_ascii_whitespace() {
+                    if index >= size { break 'outer }
+                    let row = ny - 1 - (index / nx);
+                    let col = index % nx;
+                    z[row * nx + col] = token.parse::<f32>()
+                        .map(|zi| if zi == nodata { f32::NAN } else { zi })
+                        .map_err(|err| {
+                            let why = format!("{}:{}: {}: {}", path, lineno, err, token);
+                            Error::new(TypeError).what(WHAT).why(&why).to_err()
+                        })?;
+                    index += 1;
+                }
+                lineno += 1;
+                line = lines.next();
+            }
+            if index < size {
+                let why = format!("{}: expected {} z-values, found {}", path, size, index);
+                return Err(Error::new(TypeError).what(WHAT).why(&why).to_err())
+            }
+        }
+
+        let map = Self {
+            crs: None,
+            nx,
+            x0,
+            x1: x0 + dx * ((nx - 1) as f64),
+            ny,
+            y0,
+            y1: y0 + dy * ((ny - 1) as f64),
+            z: array.into_any().unbind(),
+        };
+        Ok(map)
+    }
+
+    fn to_ascii(
+        &self,
+        py: Python,
+        path: &str,
+        nodata: Option<f32>,
+        precision: Option<usize>,
+    ) -> PyResult<()> {
+        let dx = if self.nx > 1 { (self.x1 - self.x0) / ((self.nx - 1) as f64) } else { 0.0 };
+        let dy = if self.ny > 1 { (self.y1 - self.y0) / ((self.ny - 1) as f64) } else { 0.0 };
+        if (dx.abs() - dy.abs()).abs() > f64::EPSILON {
+            return Err(Error::new(TypeError).what("cells").why("not squared").to_err())
+        }
+        enum Order {
+            Decreasing,
+            Increasing,
+        }
+        let xorder = if dx < 0.0 { Order::Decreasing } else { Order::Increasing };
+        let yorder = if dy < 0.0 { Order::Decreasing } else { Order::Increasing };
+
+        let file = File::create(path)?;
+        let mut stream = BufWriter::new(file);
+        write!(stream,
+            "\
+            ncols {}\n\
+            nrows {}\n\
+            xllcenter {}\n\
+            yllcenter {}\n\
+            cellsize {}\n",
+            self.nx,
+            self.ny,
+            if dx > 0.0 { self.x0 } else { self.x1 },
+            if dy > 0.0 { self.y0 } else { self.y1 },
+            dx.abs(),
+        )?;
+        if let Some(nodata) = nodata {
+            match precision {
+                Some(precision) => write!(
+                    stream, "nodata_value {:.prec$}\n", nodata, prec=precision
+                )?,
+                None => write!(stream, "nodata_value {}\n", nodata)?,
+            }
+        }
+
+        let z: &PyArray<f32> = self.z.extract(py)?;
+        let z = unsafe { z.slice()? };
+        for i in 0..self.ny {
+            let i = match yorder {
+                Order::Increasing => self.ny - 1 - i,
+                Order::Decreasing => i,
+            };
+            for j in 0..self.nx {
+                let jj = match xorder {
+                    Order::Increasing => j,
+                    Order::Decreasing => self.nx - 1 - j,
+                };
+                let mut zij = z[i * self.nx + jj];
+                if let Some(nodata) = nodata {
+                    if zij.is_nan() { zij = nodata }
+                }
+                match precision {
+                    Some(precision) => write!(stream, "{:.prec$}", zij, prec=precision)?,
+                    None => write!(stream, "{}", zij)?,
+                }
+                let sep = if j < self.nx - 1 { ' ' } else { '\n' };
+                write!(stream, "{}", sep)?
+            }
+        }
+
+        Ok(())
+    }
+}

{calzone-1.1.6 → calzone-1.1.8}/src/geometry/volume.rs

@@ -745,7 +745,7 @@ impl TryFromBound for MeshShape {
                     None
                 }
             },
-            Some("png") | Some("tif") => {
+            Some("asc") | Some("ASC") | Some("png") | Some("PNG") | Some("tif") | Some("TIF") => {
                 let regular = regular.unwrap_or(false);
                 let map = MapParameters::new(padding, origin, regular);
                 Some(map)

{calzone-1.1.6 → calzone-1.1.8}/src/python/calzone/__init__.py

@@ -11,4 +11,4 @@ def init():
 init()
 del init
 
-VERSION = "1.1.6"
+VERSION = "1.1.8"

{calzone-1.1.6 → calzone-1.1.8/src/python/calzone.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: calzone
-Version: 1.1.6
+Version: 1.1.8
 Summary: A Geant4 Python wrapper.
 Author-email: Valentin Niess <valentin.niess@gmail.com>
 License: LGPLv3

{calzone-1.1.6 → calzone-1.1.8}/tests/test_geometry.py

@@ -204,6 +204,25 @@ def test_Map():
     A = calzone.Geometry(data)["A"]
     assert_allclose(A.surface_area, 6 * 4.0)
 
+    dem1 = calzone.Map(PREFIX / "assets/map.asc")
+    path = Path(TMPDIR.name) / "map.asc"
+    dem1.dump(path, nodata=-9999)
+    dem2 = calzone.Map(path)
+
+    for dem in (dem1, dem2):
+        assert dem.nx == 4
+        assert dem.ny == 3
+        assert dem.x0 == -1.5
+        assert dem.x1 == 1.5
+        assert dem.y0 == -1.0
+        assert dem.y1 == 1.0
+        expected = (
+            (0, 1, 2, 3),
+            (4, 5, 6, 7),
+            (8, 9, 10, 11),
+        )
+        assert_allclose(dem.z, expected)
+
 
 def test_Mesh():
     """Test the mesh shape."""