differt-core 0.10.0__tar.gz → 0.11.0__tar.gz

{differt_core-0.10.0 → differt_core-0.11.0}/Cargo.lock

@@ -247,7 +247,7 @@ checksum = "43da5946c66ffcc7745f48db692ffbb10a83bfe0afd96235c5c2a4fb23994929"
 
 [[package]]
 name = "differt-core"
-version = "0.10.0"
+version = "0.11.0"
 dependencies = [
  "criterion",
  "indexmap",

{differt_core-0.10.0 → differt_core-0.11.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: differt-core
-Version: 0.10.0
+Version: 0.11.0
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12

{differt_core-0.10.0 → differt_core-0.11.0}/differt-core/Cargo.toml

@@ -37,5 +37,5 @@ unexpected_cfgs = {level = "warn", check-cfg = ['cfg(tarpaulin_include)']}
 edition = "2021"
 name = "differt-core"
 rust-version = "1.78.0"
-version = "0.10.0"
+version = "0.11.0"
 readme = "README.md"

{differt_core-0.10.0 → differt_core-0.11.0}/differt-core/src/geometry/mesh.rs

@@ -1,4 +1,8 @@
-use std::{fs::File, io::BufReader, path::PathBuf};
+use std::{
+    fs::File,
+    io::BufReader,
+    path::{Path, PathBuf},
+};
 
 use indexmap::IndexMap;
 use numpy::{PyArray1, PyArray2, ndarray::arr2};
@@ -273,22 +277,48 @@ impl Mesh {
     /// vertices.
     ///
     /// Args:
-    ///     file (str): The path to the Wavefront .obj file.
+    ///     file (str | os.PathLike[str]): The path to the Wavefront .obj file.
     ///
     /// Returns:
     ///     Mesh: The corresponding mesh containing only triangles.
     #[classmethod]
-    pub(crate) fn load_obj(_: &Bound<'_, PyType>, filename: &str) -> PyResult<Self> {
-        let input = BufReader::new(File::open(filename)?);
+    #[pyo3(name = "load_obj")]
+    pub(crate) fn py_load_obj(_: &Bound<'_, PyType>, file: PathBuf) -> PyResult<Self> {
+        Self::load_obj(&file)
+    }
+
+    /// Load a triangle mesh from a Stanford PLY .ply file.
+    ///
+    /// Currently, only vertices and triangles are loaded. Triangle normals
+    /// are ignored because they are computed with
+    /// :attr:`differt.geometry.Mesh.normals` using
+    /// JAX so that they can be differentiated with respect to triangle
+    /// vertices.
+    ///
+    /// Args:
+    ///     file (str | os.PathLike[str]): The path to the Stanford PLY .ply file.
+    ///
+    /// Returns:
+    ///     Mesh: The corresponding mesh containing only triangles.
+    #[classmethod]
+    #[pyo3(name = "load_ply")]
+    pub(crate) fn py_load_ply(_: &Bound<'_, PyType>, file: PathBuf) -> PyResult<Self> {
+        Self::load_ply(&file)
+    }
+}
+
+impl Mesh {
+    pub(crate) fn load_obj(file: &Path) -> PyResult<Self> {
+        let input = BufReader::new(File::open(file)?);
         let mut obj: RawObj = parse_obj(input).map_err(|err| {
             PyValueError::new_err(format!(
-                "An error occurred while reading obj file {filename:#?}: {}",
+                "An error occurred while reading obj file {file:#?}: {}",
                 err
             ))
         })?;
 
         for material_file in obj.material_libraries.iter_mut() {
-            let mut path = PathBuf::from(filename);
+            let mut path = file.to_path_buf();
             path.set_file_name(&material_file);
             if let Some(path_str) = path.to_str() {
                 *material_file = path_str.to_string();
@@ -298,29 +328,15 @@ impl Mesh {
         Ok(obj.into())
     }
 
-    /// Load a triangle mesh from a Stanford PLY .ply file.
-    ///
-    /// Currently, only vertices and triangles are loaded. Triangle normals
-    /// are ignored because they are computed with
-    /// :attr:`differt.geometry.Mesh.normals` using
-    /// JAX so that they can be differentiated with respect to triangle
-    /// vertices.
-    ///
-    /// Args:
-    ///     file (str): The path to the Stanford PLY .ply file.
-    ///
-    /// Returns:
-    ///     Mesh: The corresponding mesh containing only triangles.
-    #[classmethod]
-    pub(crate) fn load_ply(_: &Bound<'_, PyType>, filename: &str) -> PyResult<Self> {
-        let mut input = BufReader::new(File::open(filename)?);
+    pub(crate) fn load_ply(file: &Path) -> PyResult<Self> {
+        let mut input = BufReader::new(File::open(file)?);
 
         let vertex_parser = parser::Parser::<PlyVertex>::new();
         let face_parser = parser::Parser::<PlyFace>::new();
 
         let header = vertex_parser.read_header(&mut input).map_err(|err| {
             PyValueError::new_err(format!(
-                "An error occurred while reading the header of ply file {filename:#?}: {}",
+                "An error occurred while reading the header of ply file {file:#?}: {}",
                 err
             ))
         })?;
@@ -337,7 +353,7 @@ impl Mesh {
                             .map_err(|err| {
                                 PyValueError::new_err(format!(
                                     "An error occurred while reading the vertex elements of ply \
-                                     file {filename:#?}: {}",
+                                     file {file:#?}: {}",
                                     err
                                 ))
                             })?
@@ -352,7 +368,7 @@ impl Mesh {
                             .map_err(|err| {
                                 PyValueError::new_err(format!(
                                     "An error occurred while reading the face elements of PLY \
-                                     file {filename:#?}: {}",
+                                     file {file:#?}: {}",
                                     err
                                 ))
                             })?

{differt_core-0.10.0 → differt_core-0.11.0}/differt-core/src/geometry/scene.rs

@@ -1,4 +1,4 @@
-use std::path::PathBuf;
+use std::path::{Path, PathBuf};
 
 use pyo3::{exceptions::PyValueError, prelude::*, types::PyType};
 
@@ -22,38 +22,33 @@ impl Scene {
     /// Load a scene from a Sionna-compatible XML file.
     ///
     /// Args:
-    ///     file (str): The path to the XML file.
+    ///     file (str | os.PathLike[str]): The path to the XML file.
     ///
     /// Returns:
     ///     Scene: The corresponding scene.
     #[classmethod]
-    fn load_xml(cls: &Bound<'_, PyType>, file: &str) -> PyResult<Self> {
-        // TODO: create a Rust variant without PyType?
-        let sionna_scene_py_type = PyType::new::<SionnaScene>(cls.py());
-        let sionna = SionnaScene::load_xml(&sionna_scene_py_type, file)?;
+    #[pyo3(name = "load_xml")]
+    fn py_load_xml(_cls: &Bound<'_, PyType>, file: PathBuf) -> PyResult<Self> {
+        Self::load_xml(&file)
+    }
+}
+impl Scene {
+    fn load_xml(file: &Path) -> PyResult<Self> {
+        let sionna = SionnaScene::load_xml(&file)?;
 
-        let path = PathBuf::from(file);
-        let folder = path.parent().ok_or_else(|| {
+        let folder = file.parent().ok_or_else(|| {
             PyValueError::new_err(format!(
-                "Could not determine parent folder of file: {}",
-                file
+                "Could not determine parent folder of file: {file:#?}",
             ))
         })?;
 
         let mut mesh = Mesh::default();
 
-        let mesh_py_type = PyType::new::<Mesh>(cls.py());
-
         for (_, shape) in sionna.shapes.into_iter() {
             let mesh_file_path = folder.join(shape.file);
-            let mesh_file = mesh_file_path.to_str().ok_or_else(|| {
-                PyValueError::new_err(format!(
-                    "Could not convert path {mesh_file_path:?} to valid unicode string"
-                ))
-            })?;
             let mut other_mesh = match shape.r#type.as_str() {
-                "obj" => Mesh::load_obj(&mesh_py_type, mesh_file)?,
-                "ply" => Mesh::load_ply(&mesh_py_type, mesh_file)?,
+                "obj" => Mesh::load_obj(&mesh_file_path)?,
+                "ply" => Mesh::load_ply(&mesh_file_path)?,
                 ty => {
                     log::warn!("Unsupported shape type {ty}, skipping.");
                     continue;

{differt_core-0.10.0 → differt_core-0.11.0/differt-core}/src/geometry/sionna.rs

@@ -1,4 +1,8 @@
-use std::{fs::File, io::BufReader};
+use std::{
+    fs::File,
+    io::BufReader,
+    path::{Path, PathBuf},
+};
 
 use indexmap::IndexMap;
 use pyo3::{exceptions::PyValueError, prelude::*, types::PyType};
@@ -248,7 +252,7 @@ impl<'de> Deserialize<'de> for Material {
                 let color = match r#type.as_str() {
                     // Copied from Sionna-RT's code, to match their colors:
                     // https://github.com/NVlabs/sionna-rt/blob/main/src/sionna/rt/radio_materials/itu_material.py
-                    // v1.0.0
+                    "vacuum" => [0.8, 0.8, 0.8],
                     "marble" => [0.701, 0.644, 0.485],
                     "concrete" => [0.539, 0.539, 0.539],
                     "wood" => [0.266, 0.109, 0.060],
@@ -263,6 +267,10 @@ impl<'de> Deserialize<'de> for Material {
                     "very_dry_ground" => [0.539, 0.319, 0.223],
                     "medium_dry_ground" => [0.539, 0.181, 0.076],
                     "wet_ground" => [0.539, 0.027, 0.147],
+                    "clear_acrylic" => [0.8, 0.9, 0.95],
+                    "vinyl_tile" => [0.75, 0.75, 0.72],
+                    "carpet_tile" => [0.32, 0.35, 0.42],
+                    "asphalt_concrete" => [0.18, 0.18, 0.18],
                     _ => {
                         log::warn!(
                             "unknown material type: {type:#?}, using default color, i.e., black",
@@ -353,12 +361,19 @@ impl SionnaScene {
     /// Load a Sionna scene from a XML file.
     ///
     /// Args:
-    ///     file (str): The path to the XML file.
+    ///     file (os.PathLike[str] | str): The path to the XML file.
     ///
     /// Returns:
     ///     SionnaScene: The corresponding scene.
     #[classmethod]
-    pub(crate) fn load_xml(_: &Bound<'_, PyType>, file: &str) -> PyResult<Self> {
+    #[pyo3(name = "load_xml")]
+    pub(crate) fn py_load_xml(_: &Bound<'_, PyType>, file: PathBuf) -> PyResult<Self> {
+        Self::load_xml(&file)
+    }
+}
+
+impl SionnaScene {
+    pub(crate) fn load_xml(file: &Path) -> PyResult<Self> {
         let input = BufReader::new(File::open(file)?);
         quick_xml::de::from_reader(input).map_err(|err| {
             PyValueError::new_err(format!(
@@ -662,6 +677,76 @@ mod tests {
         assert_eq!(material.color, [0.539, 0.027, 0.147]);
     }
 
+    #[test]
+    fn deserializes_itu_vacuum() {
+        let xml = r#"
+            <bsdf type="itu-radio-material" id="vacuum">
+                <string name="type" value="vacuum"/>
+            </bsdf>
+        "#;
+
+        let material: Material = quick_xml::de::from_str(xml).expect("material should parse");
+
+        assert_eq!(material.name, "itu_vacuum");
+        assert_eq!(material.color, [0.8, 0.8, 0.8]);
+    }
+
+    #[test]
+    fn deserializes_itu_clear_acrylic() {
+        let xml = r#"
+            <bsdf type="itu-radio-material" id="acrylic">
+                <string name="type" value="clear_acrylic"/>
+            </bsdf>
+        "#;
+
+        let material: Material = quick_xml::de::from_str(xml).expect("material should parse");
+
+        assert_eq!(material.name, "itu_clear_acrylic");
+        assert_eq!(material.color, [0.8, 0.9, 0.95]);
+    }
+
+    #[test]
+    fn deserializes_itu_vinyl_tile() {
+        let xml = r#"
+            <bsdf type="itu-radio-material" id="vinyl">
+                <string name="type" value="vinyl_tile"/>
+            </bsdf>
+        "#;
+
+        let material: Material = quick_xml::de::from_str(xml).expect("material should parse");
+
+        assert_eq!(material.name, "itu_vinyl_tile");
+        assert_eq!(material.color, [0.75, 0.75, 0.72]);
+    }
+
+    #[test]
+    fn deserializes_itu_carpet_tile() {
+        let xml = r#"
+            <bsdf type="itu-radio-material" id="carpet">
+                <string name="type" value="carpet_tile"/>
+            </bsdf>
+        "#;
+
+        let material: Material = quick_xml::de::from_str(xml).expect("material should parse");
+
+        assert_eq!(material.name, "itu_carpet_tile");
+        assert_eq!(material.color, [0.32, 0.35, 0.42]);
+    }
+
+    #[test]
+    fn deserializes_itu_asphalt_concrete() {
+        let xml = r#"
+            <bsdf type="itu-radio-material" id="asphalt">
+                <string name="type" value="asphalt_concrete"/>
+            </bsdf>
+        "#;
+
+        let material: Material = quick_xml::de::from_str(xml).expect("material should parse");
+
+        assert_eq!(material.name, "itu_asphalt_concrete");
+        assert_eq!(material.color, [0.18, 0.18, 0.18]);
+    }
+
     #[test]
     fn deserializes_itu_unknown_type() {
         let xml = r#"

{differt_core-0.10.0 → differt_core-0.11.0}/differt-core/tests/geometry/test_graph.py

@@ -1,4 +1,3 @@
-import logging
 import re
 
 import numpy as np
@@ -197,29 +196,3 @@ class TestDiGraph:
         assert num_paths == num_nodes * (num_nodes - 1) ** (depth - 1)
         array = graph.all_paths_array(from_, to, depth + 2, include_from_and_to=False)
         assert array.shape == (num_paths, depth)
-
-    @pytest.mark.parametrize(
-        ("num_nodes", "depth"),
-        [
-            (10, 100),
-            (50_000, 10),
-        ],
-    )
-    def test_all_paths_count_from_complete_graph_overflow(
-        self,
-        num_nodes: int,
-        depth: int,
-        caplog: pytest.LogCaptureFixture,
-    ) -> None:
-        graph = CompleteGraph(num_nodes)
-        from_, to = num_nodes, num_nodes + 1
-
-        caplog.clear()
-
-        with caplog.at_level(logging.WARNING):
-            _ = graph.all_paths(from_, to, depth + 2, include_from_and_to=False)
-
-            assert (
-                "OverflowError: overflow occurred when computing the total number of paths"
-                in caplog.text
-            )

{differt_core-0.10.0 → differt_core-0.11.0}/python/differt_core/_differt_core/geometry/graph.pyi

@@ -1,4 +1,3 @@
-# pyright: reportMissingTypeArgument=false
 from collections.abc import Iterator, Sized
 
 import numpy as np

{differt_core-0.10.0 → differt_core-0.11.0}/python/differt_core/_differt_core/geometry/mesh.pyi

@@ -1,4 +1,5 @@
-# pyright: reportMissingTypeArgument=false
+from os import PathLike
+
 import numpy as np
 from jaxtyping import Float, Int, UInt
 
@@ -12,6 +13,6 @@ class Mesh:
 
     def append(self, other: Mesh) -> None: ...
     @classmethod
-    def load_obj(cls, file: str) -> Mesh: ...
+    def load_obj(cls, file: str | PathLike[str]) -> Mesh: ...
     @classmethod
-    def load_ply(cls, file: str) -> Mesh: ...
+    def load_ply(cls, file: str | PathLike[str]) -> Mesh: ...

{differt_core-0.10.0 → differt_core-0.11.0}/python/differt_core/_differt_core/geometry/scene.pyi

@@ -1,7 +1,9 @@
+from os import PathLike
+
 from differt_core.geometry import TriangleMesh
 
 class Scene:
     mesh: list[TriangleMesh]
 
     @classmethod
-    def load_xml(cls, file: str) -> Scene: ...
+    def load_xml(cls, file: str | PathLike[str]) -> Scene: ...

{differt_core-0.10.0 → differt_core-0.11.0}/python/differt_core/_differt_core/geometry/sionna.pyi

@@ -1,9 +1,11 @@
+from os import PathLike
+
 class SionnaScene:
     shapes: dict[str, Shape]
     materials: dict[str, Material]
 
     @classmethod
-    def load_xml(cls, file: str) -> SionnaScene: ...
+    def load_xml(cls, file: str | PathLike[str]) -> SionnaScene: ...
 
 class Material:
     name: str

{differt_core-0.10.0 → differt_core-0.11.0}/src/geometry/mesh.rs

@@ -1,4 +1,8 @@
-use std::{fs::File, io::BufReader, path::PathBuf};
+use std::{
+    fs::File,
+    io::BufReader,
+    path::{Path, PathBuf},
+};
 
 use indexmap::IndexMap;
 use numpy::{PyArray1, PyArray2, ndarray::arr2};
@@ -273,22 +277,48 @@ impl Mesh {
     /// vertices.
     ///
     /// Args:
-    ///     file (str): The path to the Wavefront .obj file.
+    ///     file (str | os.PathLike[str]): The path to the Wavefront .obj file.
     ///
     /// Returns:
     ///     Mesh: The corresponding mesh containing only triangles.
     #[classmethod]
-    pub(crate) fn load_obj(_: &Bound<'_, PyType>, filename: &str) -> PyResult<Self> {
-        let input = BufReader::new(File::open(filename)?);
+    #[pyo3(name = "load_obj")]
+    pub(crate) fn py_load_obj(_: &Bound<'_, PyType>, file: PathBuf) -> PyResult<Self> {
+        Self::load_obj(&file)
+    }
+
+    /// Load a triangle mesh from a Stanford PLY .ply file.
+    ///
+    /// Currently, only vertices and triangles are loaded. Triangle normals
+    /// are ignored because they are computed with
+    /// :attr:`differt.geometry.Mesh.normals` using
+    /// JAX so that they can be differentiated with respect to triangle
+    /// vertices.
+    ///
+    /// Args:
+    ///     file (str | os.PathLike[str]): The path to the Stanford PLY .ply file.
+    ///
+    /// Returns:
+    ///     Mesh: The corresponding mesh containing only triangles.
+    #[classmethod]
+    #[pyo3(name = "load_ply")]
+    pub(crate) fn py_load_ply(_: &Bound<'_, PyType>, file: PathBuf) -> PyResult<Self> {
+        Self::load_ply(&file)
+    }
+}
+
+impl Mesh {
+    pub(crate) fn load_obj(file: &Path) -> PyResult<Self> {
+        let input = BufReader::new(File::open(file)?);
         let mut obj: RawObj = parse_obj(input).map_err(|err| {
             PyValueError::new_err(format!(
-                "An error occurred while reading obj file {filename:#?}: {}",
+                "An error occurred while reading obj file {file:#?}: {}",
                 err
             ))
         })?;
 
         for material_file in obj.material_libraries.iter_mut() {
-            let mut path = PathBuf::from(filename);
+            let mut path = file.to_path_buf();
             path.set_file_name(&material_file);
             if let Some(path_str) = path.to_str() {
                 *material_file = path_str.to_string();
@@ -298,29 +328,15 @@ impl Mesh {
         Ok(obj.into())
     }
 
-    /// Load a triangle mesh from a Stanford PLY .ply file.
-    ///
-    /// Currently, only vertices and triangles are loaded. Triangle normals
-    /// are ignored because they are computed with
-    /// :attr:`differt.geometry.Mesh.normals` using
-    /// JAX so that they can be differentiated with respect to triangle
-    /// vertices.
-    ///
-    /// Args:
-    ///     file (str): The path to the Stanford PLY .ply file.
-    ///
-    /// Returns:
-    ///     Mesh: The corresponding mesh containing only triangles.
-    #[classmethod]
-    pub(crate) fn load_ply(_: &Bound<'_, PyType>, filename: &str) -> PyResult<Self> {
-        let mut input = BufReader::new(File::open(filename)?);
+    pub(crate) fn load_ply(file: &Path) -> PyResult<Self> {
+        let mut input = BufReader::new(File::open(file)?);
 
         let vertex_parser = parser::Parser::<PlyVertex>::new();
         let face_parser = parser::Parser::<PlyFace>::new();
 
         let header = vertex_parser.read_header(&mut input).map_err(|err| {
             PyValueError::new_err(format!(
-                "An error occurred while reading the header of ply file {filename:#?}: {}",
+                "An error occurred while reading the header of ply file {file:#?}: {}",
                 err
             ))
         })?;
@@ -337,7 +353,7 @@ impl Mesh {
                             .map_err(|err| {
                                 PyValueError::new_err(format!(
                                     "An error occurred while reading the vertex elements of ply \
-                                     file {filename:#?}: {}",
+                                     file {file:#?}: {}",
                                     err
                                 ))
                             })?
@@ -352,7 +368,7 @@ impl Mesh {
                             .map_err(|err| {
                                 PyValueError::new_err(format!(
                                     "An error occurred while reading the face elements of PLY \
-                                     file {filename:#?}: {}",
+                                     file {file:#?}: {}",
                                     err
                                 ))
                             })?

{differt_core-0.10.0 → differt_core-0.11.0}/src/geometry/scene.rs

@@ -1,4 +1,4 @@
-use std::path::PathBuf;
+use std::path::{Path, PathBuf};
 
 use pyo3::{exceptions::PyValueError, prelude::*, types::PyType};
 
@@ -22,38 +22,33 @@ impl Scene {
     /// Load a scene from a Sionna-compatible XML file.
     ///
     /// Args:
-    ///     file (str): The path to the XML file.
+    ///     file (str | os.PathLike[str]): The path to the XML file.
     ///
     /// Returns:
     ///     Scene: The corresponding scene.
     #[classmethod]
-    fn load_xml(cls: &Bound<'_, PyType>, file: &str) -> PyResult<Self> {
-        // TODO: create a Rust variant without PyType?
-        let sionna_scene_py_type = PyType::new::<SionnaScene>(cls.py());
-        let sionna = SionnaScene::load_xml(&sionna_scene_py_type, file)?;
+    #[pyo3(name = "load_xml")]
+    fn py_load_xml(_cls: &Bound<'_, PyType>, file: PathBuf) -> PyResult<Self> {
+        Self::load_xml(&file)
+    }
+}
+impl Scene {
+    fn load_xml(file: &Path) -> PyResult<Self> {
+        let sionna = SionnaScene::load_xml(&file)?;
 
-        let path = PathBuf::from(file);
-        let folder = path.parent().ok_or_else(|| {
+        let folder = file.parent().ok_or_else(|| {
             PyValueError::new_err(format!(
-                "Could not determine parent folder of file: {}",
-                file
+                "Could not determine parent folder of file: {file:#?}",
             ))
         })?;
 
         let mut mesh = Mesh::default();
 
-        let mesh_py_type = PyType::new::<Mesh>(cls.py());
-
         for (_, shape) in sionna.shapes.into_iter() {
             let mesh_file_path = folder.join(shape.file);
-            let mesh_file = mesh_file_path.to_str().ok_or_else(|| {
-                PyValueError::new_err(format!(
-                    "Could not convert path {mesh_file_path:?} to valid unicode string"
-                ))
-            })?;
             let mut other_mesh = match shape.r#type.as_str() {
-                "obj" => Mesh::load_obj(&mesh_py_type, mesh_file)?,
-                "ply" => Mesh::load_ply(&mesh_py_type, mesh_file)?,
+                "obj" => Mesh::load_obj(&mesh_file_path)?,
+                "ply" => Mesh::load_ply(&mesh_file_path)?,
                 ty => {
                     log::warn!("Unsupported shape type {ty}, skipping.");
                     continue;

{differt_core-0.10.0/differt-core → differt_core-0.11.0}/src/geometry/sionna.rs

@@ -1,4 +1,8 @@
-use std::{fs::File, io::BufReader};
+use std::{
+    fs::File,
+    io::BufReader,
+    path::{Path, PathBuf},
+};
 
 use indexmap::IndexMap;
 use pyo3::{exceptions::PyValueError, prelude::*, types::PyType};
@@ -248,7 +252,7 @@ impl<'de> Deserialize<'de> for Material {
                 let color = match r#type.as_str() {
                     // Copied from Sionna-RT's code, to match their colors:
                     // https://github.com/NVlabs/sionna-rt/blob/main/src/sionna/rt/radio_materials/itu_material.py
-                    // v1.0.0
+                    "vacuum" => [0.8, 0.8, 0.8],
                     "marble" => [0.701, 0.644, 0.485],
                     "concrete" => [0.539, 0.539, 0.539],
                     "wood" => [0.266, 0.109, 0.060],
@@ -263,6 +267,10 @@ impl<'de> Deserialize<'de> for Material {
                     "very_dry_ground" => [0.539, 0.319, 0.223],
                     "medium_dry_ground" => [0.539, 0.181, 0.076],
                     "wet_ground" => [0.539, 0.027, 0.147],
+                    "clear_acrylic" => [0.8, 0.9, 0.95],
+                    "vinyl_tile" => [0.75, 0.75, 0.72],
+                    "carpet_tile" => [0.32, 0.35, 0.42],
+                    "asphalt_concrete" => [0.18, 0.18, 0.18],
                     _ => {
                         log::warn!(
                             "unknown material type: {type:#?}, using default color, i.e., black",
@@ -353,12 +361,19 @@ impl SionnaScene {
     /// Load a Sionna scene from a XML file.
     ///
     /// Args:
-    ///     file (str): The path to the XML file.
+    ///     file (os.PathLike[str] | str): The path to the XML file.
     ///
     /// Returns:
     ///     SionnaScene: The corresponding scene.
     #[classmethod]
-    pub(crate) fn load_xml(_: &Bound<'_, PyType>, file: &str) -> PyResult<Self> {
+    #[pyo3(name = "load_xml")]
+    pub(crate) fn py_load_xml(_: &Bound<'_, PyType>, file: PathBuf) -> PyResult<Self> {
+        Self::load_xml(&file)
+    }
+}
+
+impl SionnaScene {
+    pub(crate) fn load_xml(file: &Path) -> PyResult<Self> {
         let input = BufReader::new(File::open(file)?);
         quick_xml::de::from_reader(input).map_err(|err| {
             PyValueError::new_err(format!(
@@ -662,6 +677,76 @@ mod tests {
         assert_eq!(material.color, [0.539, 0.027, 0.147]);
     }
 
+    #[test]
+    fn deserializes_itu_vacuum() {
+        let xml = r#"
+            <bsdf type="itu-radio-material" id="vacuum">
+                <string name="type" value="vacuum"/>
+            </bsdf>
+        "#;
+
+        let material: Material = quick_xml::de::from_str(xml).expect("material should parse");
+
+        assert_eq!(material.name, "itu_vacuum");
+        assert_eq!(material.color, [0.8, 0.8, 0.8]);
+    }
+
+    #[test]
+    fn deserializes_itu_clear_acrylic() {
+        let xml = r#"
+            <bsdf type="itu-radio-material" id="acrylic">
+                <string name="type" value="clear_acrylic"/>
+            </bsdf>
+        "#;
+
+        let material: Material = quick_xml::de::from_str(xml).expect("material should parse");
+
+        assert_eq!(material.name, "itu_clear_acrylic");
+        assert_eq!(material.color, [0.8, 0.9, 0.95]);
+    }
+
+    #[test]
+    fn deserializes_itu_vinyl_tile() {
+        let xml = r#"
+            <bsdf type="itu-radio-material" id="vinyl">
+                <string name="type" value="vinyl_tile"/>
+            </bsdf>
+        "#;
+
+        let material: Material = quick_xml::de::from_str(xml).expect("material should parse");
+
+        assert_eq!(material.name, "itu_vinyl_tile");
+        assert_eq!(material.color, [0.75, 0.75, 0.72]);
+    }
+
+    #[test]
+    fn deserializes_itu_carpet_tile() {
+        let xml = r#"
+            <bsdf type="itu-radio-material" id="carpet">
+                <string name="type" value="carpet_tile"/>
+            </bsdf>
+        "#;
+
+        let material: Material = quick_xml::de::from_str(xml).expect("material should parse");
+
+        assert_eq!(material.name, "itu_carpet_tile");
+        assert_eq!(material.color, [0.32, 0.35, 0.42]);
+    }
+
+    #[test]
+    fn deserializes_itu_asphalt_concrete() {
+        let xml = r#"
+            <bsdf type="itu-radio-material" id="asphalt">
+                <string name="type" value="asphalt_concrete"/>
+            </bsdf>
+        "#;
+
+        let material: Material = quick_xml::de::from_str(xml).expect("material should parse");
+
+        assert_eq!(material.name, "itu_asphalt_concrete");
+        assert_eq!(material.color, [0.18, 0.18, 0.18]);
+    }
+
     #[test]
     fn deserializes_itu_unknown_type() {
         let xml = r#"