subsurface-terra 2025.1.0rc7__tar.gz → 2025.1.0rc10__tar.gz

{subsurface_terra-2025.1.0rc7/subsurface_terra.egg-info → subsurface_terra-2025.1.0rc10}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: subsurface_terra
-Version: 2025.1.0rc7
+Version: 2025.1.0rc10
 Summary: Subsurface data types and utilities. This version is the one used by Terranigma Solutions. Please feel free to take anything in this repository for the original one.
 Home-page: https://softwareunderground.github.io/subsurface
 Author: Software Underground

{subsurface_terra-2025.1.0rc7 → subsurface_terra-2025.1.0rc10}/subsurface/_version.py

@@ -17,5 +17,5 @@ __version__: str
 __version_tuple__: VERSION_TUPLE
 version_tuple: VERSION_TUPLE
 
-__version__ = version = '2025.1.0rc7'
+__version__ = version = '2025.1.0rc10'
 __version_tuple__ = version_tuple = (2025, 1, 0)

{subsurface_terra-2025.1.0rc7 → subsurface_terra-2025.1.0rc10}/subsurface/api/__init__.py

@@ -7,4 +7,6 @@ from .interfaces.stream import (
     CSV_volume_stream_to_struct,
     VTK_stream_to_struct,  
     MX_stream_to_unstruc,
+    OBJ_stream_to_trisurf,
+    GLTF_stream_to_trisurf
 )

{subsurface_terra-2025.1.0rc7 → subsurface_terra-2025.1.0rc10}/subsurface/api/interfaces/stream.py

@@ -1,17 +1,20 @@
+import io
 from io import BytesIO
 from typing import TextIO
 
 import pandas
-from subsurface.modules.reader.volume.volume_utils import interpolate_unstructured_data_to_structured_data
 
+from ...core.structs import TriSurf
 from ...core.reader_helpers.reader_unstruct import ReaderUnstructuredHelper
 from ...core.reader_helpers.readers_data import GenericReaderFilesHelper
 from ...core.geological_formats import BoreholeSet
 from ...core.structs.base_structures import UnstructuredData, StructuredData
 
 from ...modules import reader
+from ...modules.reader.mesh._trimesh_reader import TriMeshTransformations
 from ...modules.reader.volume.read_volume import read_volumetric_mesh_to_subsurface, read_VTK_structured_grid
 from ...modules.reader.mesh.surfaces_api import read_2d_mesh_to_unstruct
+from ...modules.reader.volume.volume_utils import interpolate_unstructured_data_to_structured_data
 
 from ..reader.read_wells import read_wells
 
@@ -39,6 +42,21 @@ def MX_stream_to_unstruc(stream: TextIO) -> list[UnstructuredData]:
     return list_unstruct
 
 
+def OBJ_stream_to_trisurf(obj_stream: TextIO, mtl_stream: list[TextIO],
+                          texture_stream: list[io.BytesIO], coordinate_system: TriMeshTransformations) -> TriSurf:
+    tri_mesh: TriSurf = reader.load_obj_with_trimesh_from_binary(
+        obj_stream=obj_stream,
+        mtl_stream=mtl_stream,
+        texture_stream=texture_stream,
+        coord_system=coordinate_system
+    )
+    return tri_mesh
+
+
+def GLTF_stream_to_trisurf(gltf_stream: io.BytesIO, coordinate_system: TriMeshTransformations) -> TriSurf:
+    tri_mesh: TriSurf = reader.load_gltf_with_trimesh(gltf_stream, coordinate_system)
+    return tri_mesh
+
 def VTK_stream_to_struct(stream: BytesIO, attribute_name: str) -> list[StructuredData]:
     struct = read_VTK_structured_grid(stream, attribute_name)
     return [struct]

{subsurface_terra-2025.1.0rc7 → subsurface_terra-2025.1.0rc10}/subsurface/modules/reader/__init__.py

@@ -7,3 +7,5 @@ from .topography.topo_core import read_structured_topography, read_unstructured_
 from .mesh.omf_mesh_reader import omf_stream_to_unstructs
 from .mesh.dxf_reader import dxf_stream_to_unstruct_input, dxf_file_to_unstruct_input
 from .mesh.mx_reader import mx_to_unstruc_from_binary
+from .mesh.obj_reader import load_obj_with_trimesh, load_obj_with_trimesh_from_binary
+from .mesh.glb_reader import load_gltf_with_trimesh

subsurface_terra-2025.1.0rc10/subsurface/modules/reader/mesh/_trimesh_reader.py

@@ -0,0 +1,433 @@
+import enum
+from typing import Union, TextIO, Optional
+import io
+import os
+
+import numpy as np
+from ....core.structs import UnstructuredData
+from .... import optional_requirements
+from ....core.structs import TriSurf, StructuredData
+
+
+class TriMeshTransformations(enum.Enum):
+    RIGHT_HANDED_Z_UP = "right_handed_z_up"
+    ORIGINAL = "original"
+
+
+def load_with_trimesh(path_to_file_or_buffer, file_type: Optional[str] = None,
+                      coordinate_system: TriMeshTransformations = TriMeshTransformations.RIGHT_HANDED_Z_UP, *, plot=False):
+    """
+    Load a mesh with trimesh and convert to the specified coordinate system.
+
+    """
+    trimesh = optional_requirements.require_trimesh()
+    scene_or_mesh = LoadWithTrimesh.load_with_trimesh(path_to_file_or_buffer, file_type, plot)
+
+    # Compute a -90° rotation around the X axis
+    angle_rad = np.deg2rad(-90)
+    transform = trimesh.transformations.rotation_matrix(angle_rad, [1, 0, 0])
+    
+    match coordinate_system:
+        case TriMeshTransformations.ORIGINAL:
+            return scene_or_mesh
+        case TriMeshTransformations.RIGHT_HANDED_Z_UP:
+            # Transform from Y-up (modeling software) to Z-up (scientific)
+            # This rotates the model so that:
+            # Old Y axis → New Z axis (pointing up)
+            # Old Z axis → New -Y axis
+            # Old X axis → Remains as X axis
+            transform = np.array([
+                    [1, 0, 0, 0],  # X → X
+                    [0, 0, 1, 0],  # Y → Z 
+                    [0, 1, 0, 0],  # Z → -Y
+                    [0, 0, 0, 1]
+            ])
+
+            # Apply the coordinate transformation
+            if isinstance(scene_or_mesh, trimesh.Scene):
+                for geometry in scene_or_mesh.geometry.values():
+                    geometry.apply_transform(transform)
+            else:
+                scene_or_mesh.apply_transform(transform)
+        case _:
+            raise ValueError(f"Invalid coordinate system: {coordinate_system}")
+
+    return scene_or_mesh
+
+
+def trimesh_to_unstruct(scene_or_mesh: Union["trimesh.Trimesh", "trimesh.Scene"]) -> TriSurf:
+    return TrimeshToSubsurface.trimesh_to_unstruct(scene_or_mesh)
+
+
+class LoadWithTrimesh:
+    @classmethod
+    def load_with_trimesh(cls, path_to_file_or_buffer, file_type: Optional[str] = None, plot=False):
+        trimesh = optional_requirements.require_trimesh()
+        # Load the OBJ with Trimesh using the specified options
+        scene_or_mesh = trimesh.load(
+            file_obj=path_to_file_or_buffer,
+            file_type=file_type,
+            force="mesh"
+        )
+        # Process single mesh vs. scene
+        if isinstance(scene_or_mesh, trimesh.Scene):
+            print("Loaded a Scene with multiple geometries.")
+            cls._process_scene(scene_or_mesh)
+            if plot:
+                scene_or_mesh.show()
+        else:
+            print("Loaded a single Trimesh object.")
+            print(f" - Vertices: {len(scene_or_mesh.vertices)}")
+            print(f" - Faces: {len(scene_or_mesh.faces)}")
+            cls.handle_material_info(scene_or_mesh)
+            if plot:
+                scene_or_mesh.show()
+
+        return scene_or_mesh
+
+    @classmethod
+    def handle_material_info(cls, geometry):
+        """
+        Handle and print material information for a single geometry,
+        explicitly injecting the PIL image if provided.
+        """
+        if geometry.visual and hasattr(geometry.visual, 'material'):
+            material = geometry.visual.material
+
+            print("Trimesh material:", material)
+
+            # If there's already an image reference in the material, let the user know
+            if hasattr(material, 'image') and material.image is not None:
+                print("  -> Material already has an image:", material.image)
+        else:
+            print("No material found or no 'material' attribute on this geometry.")
+
+    @classmethod
+    def _process_scene(cls, scene):
+        """Process a scene with multiple geometries."""
+        geometries = scene.geometry
+        assert len(geometries) > 0, "No geometries found in the scene."
+
+        print(f"Loaded a Scene with {len(scene.geometry)} geometry object(s).")
+        for geom_name, geom in geometries.items():
+            print(f" Submesh: {geom_name}")
+            print(f"  - Vertices: {len(geom.vertices)}")
+            print(f"  - Faces: {len(geom.faces)}")
+
+            print(f"Geometry '{geom_name}':")
+            cls.handle_material_info(geom)
+
+
+class TrimeshToSubsurface:
+    @classmethod
+    def trimesh_to_unstruct(cls, scene_or_mesh: Union["trimesh.Trimesh", "trimesh.Scene"]) -> TriSurf:
+        """
+        Convert a Trimesh or Scene object to a subsurface TriSurf object.
+
+        This function takes either a `trimesh.Trimesh` object or a `trimesh.Scene` 
+        object and converts it to a `subsurface.TriSurf` object. If the input is 
+        a scene containing multiple geometries, it processes all geometries and 
+        combines them into a single TriSurf object. If the input is a single 
+        Trimesh object, it directly converts it to a TriSurf object. An error 
+        is raised if the input is neither a `trimesh.Trimesh` nor a `trimesh.Scene` 
+        object.
+
+        Parameters:
+            scene_or_mesh (Union[trimesh.Trimesh, trimesh.Scene]): 
+                Input geometry data, either as a Trimesh object representing 
+                a single mesh or a Scene object containing multiple geometries.
+
+        Note:
+            ! Multimesh with multiple materials will read the uvs but not the textures since in that case is better
+            ! to read directly the multiple images (compressed) whenever the user wants to work with them. 
+
+        Returns:
+            subsurface.TriSurf: Converted subsurface representation of the 
+            provided geometry data.
+
+        Raises:
+            ValueError: If the input is neither a `trimesh.Trimesh` object nor 
+            a `trimesh.Scene` object.
+        """
+        trimesh = optional_requirements.require_trimesh()
+        if isinstance(scene_or_mesh, trimesh.Scene):
+            # Process scene with multiple geometries
+            ts = cls._trisurf_from_scene(scene_or_mesh, trimesh)
+
+        elif isinstance(scene_or_mesh, trimesh.Trimesh):
+            ts = cls._trisurf_from_trimesh(scene_or_mesh)
+
+
+        else:
+            raise ValueError("Input must be a Trimesh object or a Scene with multiple geometries.")
+
+        return ts
+
+    @classmethod
+    def _trisurf_from_trimesh(cls, scene_or_mesh):
+        # Process single mesh
+        tri = scene_or_mesh
+        pandas = optional_requirements.require_pandas()
+        frame = pandas.DataFrame(tri.face_attributes)
+        # Check frame has a valid shape for cells_attr if not make None
+        if frame.shape[0] != tri.faces.shape[0]:
+            frame = None
+        # Get UV coordinates if they exist
+        vertex_attr = None
+        if hasattr(tri.visual, 'uv') and tri.visual.uv is not None:
+            vertex_attr = pandas.DataFrame(
+                tri.visual.uv,
+                columns=['u', 'v']
+            )
+        unstruct = UnstructuredData.from_array(
+            np.array(tri.vertices),
+            np.array(tri.faces),
+            cells_attr=frame,
+            vertex_attr=vertex_attr,
+            xarray_attributes={
+                    "bounds": tri.bounds.tolist(),
+            },
+        )
+
+        texture = cls._extract_texture_from_material(tri)
+
+        ts = TriSurf(
+            mesh=unstruct,
+            texture=texture,
+        )
+        return ts
+
+    @classmethod
+    def _trisurf_from_scene(cls, scene_or_mesh: 'Scene', trimesh: 'trimesh') -> TriSurf:
+        pandas = optional_requirements.require_pandas()
+        geometries = scene_or_mesh.geometry
+        assert len(geometries) > 0, "No geometries found in the scene."
+        all_vertex = []
+        all_cells = []
+        cell_attr = []
+        all_vertex_attr = []
+        _last_cell = 0
+        texture = None
+        for i, (geom_name, geom) in enumerate(geometries.items()):
+            geom: trimesh.Trimesh
+            LoadWithTrimesh.handle_material_info(geom)
+
+            # Append vertices
+            all_vertex.append(np.array(geom.vertices))
+
+            # Adjust cell indices and append
+            cells = np.array(geom.faces)
+            if len(all_cells) > 0:
+                cells = cells + _last_cell
+            all_cells.append(cells)
+
+            # Create attribute array for this geometry
+            cell_attr.append(np.ones(len(cells)) * i)
+
+            _last_cell = cells.max() + 1
+
+            # Get UV coordinates if they exist
+            if hasattr(geom.visual, 'uv') and geom.visual.uv is not None:
+                vertex_attr = pandas.DataFrame(
+                    geom.visual.uv,
+                    columns=['u', 'v']
+                )
+                all_vertex_attr.append(vertex_attr)
+
+            # Extract texture from material if it is only one geometry
+            if len(geometries) == 1:
+                texture = cls._extract_texture_from_material(geom)
+
+        # Create the combined UnstructuredData
+        unstruct = UnstructuredData.from_array(
+            vertex=np.vstack(all_vertex),
+            cells=np.vstack(all_cells),
+            vertex_attr=pandas.concat(all_vertex_attr, ignore_index=True) if len(all_vertex_attr) > 0 else None,
+            cells_attr=pandas.DataFrame(np.hstack(cell_attr), columns=["Geometry id"]),
+            xarray_attributes={
+                    "bounds": scene_or_mesh.bounds.tolist(),
+            },
+        )
+
+        # If there is a texture
+        ts = TriSurf(
+            mesh=unstruct,
+            texture=texture,
+        )
+
+        return ts
+
+    @classmethod
+    def _extract_texture_from_material(cls, geom):
+        from PIL.JpegImagePlugin import JpegImageFile
+        from PIL.PngImagePlugin import PngImageFile
+        import trimesh
+
+        if geom.visual is None or getattr(geom.visual, 'material', None) is None:
+            return None
+
+        array = np.empty(0)
+        if isinstance(geom.visual.material, trimesh.visual.material.SimpleMaterial):
+            image: JpegImageFile = geom.visual.material.image
+            if image is None:
+                return None
+            array = np.array(image)
+        elif isinstance(geom.visual.material, trimesh.visual.material.PBRMaterial):
+            image: PngImageFile = geom.visual.material.baseColorTexture
+            array = np.array(image.convert('RGBA'))
+
+            if image is None:
+                return None
+        else:
+            raise ValueError(f"Unsupported material type: {type(geom.visual.material)}")
+
+        # Asser that image has 3 channels    assert array.shape[2] == 3    from PIL.PngImagePlugin import PngImageFile
+        assert array.shape[2] == 3 or array.shape[2] == 4
+        texture = StructuredData.from_numpy(array)
+        return texture
+
+    @classmethod
+    def _validate_texture_path(cls, texture_path):
+        """Validate the texture file path."""
+        if texture_path and not texture_path.lower().endswith(('.png', '.jpg', '.jpeg')):
+            raise ValueError("Texture path must be a PNG or JPEG file")
+
+
+class TriMeshReaderFromBlob:
+    @classmethod
+    def OBJ_stream_to_trisurf(cls, obj_stream: TextIO, mtl_stream: list[TextIO],
+                              texture_stream: list[io.BytesIO], coord_system: TriMeshTransformations) -> TriSurf:
+        """
+        Load an OBJ file from a stream and convert it to a TriSurf object.
+        
+        Parameters:
+            obj_stream: TextIO containing the OBJ file data (text format)
+            mtl_stream: TextIO containing the MTL file data (text format)
+            texture_stream: BytesIO containing the texture file data (binary format)
+        
+        Returns:
+            TriSurf: The loaded mesh with textures if available
+        """
+        trimesh = optional_requirements.require_trimesh()
+        import tempfile
+
+        path_in = "file.obj"
+
+        # Create a temporary directory to store associated files
+        with tempfile.TemporaryDirectory() as temp_dir:
+            # Write the OBJ content to a temp file
+            obj_path = os.path.join(temp_dir, os.path.basename(path_in))
+            with open(obj_path, 'w') as f:  # Use text mode 'w' for text files
+                obj_stream.seek(0)
+                f.write(obj_stream.read())
+                obj_stream.seek(0)
+
+            if mtl_stream is not None:
+                cls.write_material_files(
+                    mtl_streams=mtl_stream,
+                    obj_stream=obj_stream,
+                    temp_dir=temp_dir,
+                    texture_streams=texture_stream
+                )
+
+            # Now load the OBJ with all associated files available
+            scene_or_mesh = load_with_trimesh(
+                path_to_file_or_buffer=obj_path,
+                file_type="obj",
+                coordinate_system=coord_system
+            )
+
+            # Convert to a TriSurf object
+            tri_surf = TrimeshToSubsurface.trimesh_to_unstruct(scene_or_mesh)
+
+        return tri_surf
+
+    @classmethod
+    def write_material_files(cls, mtl_streams: list[TextIO], obj_stream: TextIO, temp_dir, texture_streams: list[io.BytesIO]):
+        # Extract mtl references from the OBJ file
+        mtl_files = cls._extract_mtl_references(obj_stream)
+        # Download and save MTL files
+        for e, mtl_file in enumerate(mtl_files):
+            mtl_path = f"{temp_dir}/{mtl_file}" if temp_dir else mtl_file
+            mtl_stream = mtl_streams[e] if mtl_streams else None
+            try:
+                # Save the MTL file to temp directory
+                mtl_temp_path = os.path.join(temp_dir, mtl_file)
+                with open(mtl_temp_path, 'w') as f:  # Use text mode 'w' for text files
+                    mtl_stream.seek(0)
+                    f.write(mtl_stream.read())
+
+                # Extract texture references from MTL
+                mtl_stream.seek(0)
+                texture_files = cls._extract_texture_references(mtl_stream)
+
+                if texture_streams is None:
+                    continue
+
+                # Download texture files
+                for ee, texture_file in enumerate(texture_files):
+                    texture_path = f"{temp_dir}/{texture_file}" if temp_dir else texture_file
+                    texture_stream = texture_streams[ee] if texture_streams else None
+                    try:
+                        # Save the texture file to temp directory
+                        with open(os.path.join(temp_dir, texture_file), 'wb') as f:  # Binary mode for textures
+                            texture_stream.seek(0)
+                            f.write(texture_stream.read())
+                    except Exception as e:
+                        print(f"Failed to load texture {texture_file}: {e}")
+            except Exception as e:
+                print(f"Failed to load MTL file {mtl_file}: {e}")
+
+    @classmethod
+    def _extract_mtl_references(cls, obj_stream):
+        """Extract MTL file references from an OBJ file."""
+        obj_stream.seek(0)
+        mtl_files = []
+
+        # TextIO stream already contains decoded text, so no need to decode
+        obj_text = obj_stream.read()
+        obj_stream.seek(0)
+
+        for line in obj_text.splitlines():
+            if line.startswith('mtllib '):
+                mtl_name = line.split(None, 1)[1].strip()
+                mtl_files.append(mtl_name)
+
+        return mtl_files
+
+    @classmethod
+    def _extract_texture_references(cls, mtl_stream):
+        """
+        Extract texture file references from an MTL file.
+        Works with both TextIO and BytesIO streams.
+        
+        Parameters:
+            mtl_stream: TextIO or BytesIO containing the MTL file data
+            
+        Returns:
+            list[str]: List of texture file names referenced in the MTL
+        """
+        mtl_stream.seek(0)
+        texture_files = []
+
+        # Handle both TextIO and BytesIO
+        if isinstance(mtl_stream, io.TextIOWrapper):
+            # TextIO stream already contains decoded text
+            mtl_text = mtl_stream.read()
+        else:
+            # BytesIO stream needs to be decoded
+            mtl_text = mtl_stream.read().decode('utf-8', errors='replace')
+
+        mtl_stream.seek(0)
+
+        for line in mtl_text.splitlines():
+            # Check for texture map definitions
+            for prefix in ['map_Kd ', 'map_Ka ', 'map_Ks ', 'map_Bump ', 'map_d ']:
+                if line.startswith(prefix):
+                    parts = line.split(None, 1)
+                    if len(parts) > 1:
+                        texture_name = parts[1].strip()
+                        texture_files.append(texture_name)
+                    break
+
+        return texture_files

{subsurface_terra-2025.1.0rc7 → subsurface_terra-2025.1.0rc10}/subsurface/modules/reader/mesh/glb_reader.py

@@ -1,8 +1,11 @@
-import subsurface
-from subsurface.modules.reader.mesh._trimesh_reader import _load_with_trimesh, trimesh_to_unstruct
+import io
+from typing import Union
 
+from ....core.structs import TriSurf
+from ._trimesh_reader import load_with_trimesh, trimesh_to_unstruct, TriMeshTransformations
 
-def load_glb_with_trimesh(path_to_glb: str, plot: bool = False) -> subsurface.TriSurf:
+
+def load_gltf_with_trimesh(path_to_glb: Union[str | io.BytesIO], coordinate_system: TriMeshTransformations) -> TriSurf:
     """
     load_obj_with_trimesh(path_to_glb, plot=False)
 
@@ -22,6 +25,6 @@ def load_glb_with_trimesh(path_to_glb: str, plot: bool = False) -> subsurface.Tr
     subsurface.TriSurf
         A TriSurf object representing the processed 3D surface geometry.
     """
-    trimesh = _load_with_trimesh(path_to_glb, plot)
+    trimesh = load_with_trimesh(path_to_glb, file_type="glb", coordinate_system=coordinate_system, plot=False)
     trisurf = trimesh_to_unstruct(trimesh)
     return trisurf

{subsurface_terra-2025.1.0rc7 → subsurface_terra-2025.1.0rc10}/subsurface/modules/reader/mesh/mx_reader.py

@@ -157,7 +157,7 @@ def _process_mesh(mesh_lines) -> Optional[GOCADMesh]:
             continue
 
         if in_tface:
-            if line.startswith('VRTX'):
+            if line.startswith('VRTX') or line.startswith('PVRTX'):
                 # Parse vertex line
                 parts = line.split()
                 if len(parts) >= 5:
@@ -167,6 +167,7 @@ def _process_mesh(mesh_lines) -> Optional[GOCADMesh]:
                     vertex_indices.append(vid)
                     vertex_list.append([x, y, z])
                     vid_to_index[vid] = len(vertex_list) - 1
+                    # If PVRTX then there could be more columns with property values. For now, we are just parsing the vertex coordinates.
                 continue
             elif line.startswith('ATOM'):
                 # Parse ATOM line

{subsurface_terra-2025.1.0rc7 → subsurface_terra-2025.1.0rc10}/subsurface/modules/reader/mesh/obj_reader.py

@@ -1,10 +1,24 @@
-from typing import Union
+from typing import Union, TextIO
+import io
 
-import subsurface
-from subsurface.modules.reader.mesh._trimesh_reader import _load_with_trimesh, trimesh_to_unstruct
+from ._trimesh_reader import load_with_trimesh, trimesh_to_unstruct, TriMeshReaderFromBlob, TriMeshTransformations
+from ....core.structs import TriSurf
 
 
-def load_obj_with_trimesh(path_to_obj: str, plot: bool = False) -> subsurface.TriSurf:
+
+def load_obj_with_trimesh_from_binary(obj_stream: TextIO, mtl_stream: list[TextIO], 
+                                      texture_stream: list[io.BytesIO], coord_system: TriMeshTransformations) -> TriSurf:
+    tri_surf: TriSurf = TriMeshReaderFromBlob.OBJ_stream_to_trisurf(
+        obj_stream=obj_stream,
+        mtl_stream=mtl_stream,
+        texture_stream=texture_stream,
+        coord_system=coord_system
+    )
+    
+    return tri_surf
+    
+
+def load_obj_with_trimesh(path_to_obj: str, plot: bool = False) -> TriSurf:
     """
     Load and process an OBJ file, returning trimesh-compatible objects.
 
@@ -34,6 +48,6 @@ def load_obj_with_trimesh(path_to_obj: str, plot: bool = False) -> subsurface.Tr
         `ValueError`: If the OBJ file could not be properly processed.
 
     """
-    trimesh = _load_with_trimesh(path_to_obj, plot)
+    trimesh = load_with_trimesh(path_to_obj, file_type="obj", plot=plot)
     trisurf = trimesh_to_unstruct(trimesh)
     return trisurf

{subsurface_terra-2025.1.0rc7 → subsurface_terra-2025.1.0rc10}/subsurface/modules/reader/volume/read_volume.py

@@ -7,6 +7,7 @@ from subsurface.core.structs import StructuredData
 from .... import optional_requirements
 from ....core.structs import UnstructuredData
 from subsurface.core.reader_helpers.readers_data import GenericReaderFilesHelper
+import numpy as np
 import pandas as pd
 
 
@@ -32,7 +33,7 @@ def read_VTK_structured_grid(file_or_buffer: Union[str, BytesIO], active_scalars
         # If it's a file path, read directly
         pyvista_obj = pv.read(file_or_buffer)
     try:
-        pyvista_struct: pv.ExplicitStructuredGrid = pyvista_obj.cast_to_explicit_structured_grid()
+        pyvista_struct: pv.ExplicitStructuredGrid = pv_cast_to_explicit_structured_grid(pyvista_obj)
     except Exception as e:
         raise f"The file is not a structured grid: {e}"
 
@@ -99,3 +100,71 @@ def read_volumetric_mesh_attr_file(reader_helper: GenericReaderFilesHelper) -> p
     df = pd.read_table(reader_helper.file_or_buffer, **reader_helper.pandas_reader_kwargs)
     df.columns = df.columns.astype(str).str.strip()
     return df
+
+
+def pv_cast_to_explicit_structured_grid(pyvista_object):
+
+    pv = optional_requirements.require_pyvista()
+
+    match pyvista_object:
+
+        case pv.RectilinearGrid() as rectl_grid:
+
+            return __pv_convert_rectilinear_to_explicit(rectl_grid)
+
+        case _:
+
+            return pyvista_object.cast_to_explicit_structured_grid()
+
+
+def __pv_convert_rectilinear_to_explicit(rectl_grid):
+
+    pv = optional_requirements.require_pyvista()
+
+    # Extract the coordinate arrays from the input RectilinearGrid.
+    x = np.asarray(rectl_grid.x)
+    y = np.asarray(rectl_grid.y)
+    z = np.asarray(rectl_grid.z)
+
+    # Helper function: "double" the coordinates to produce an expanded set
+    # that, when processed internally via np.unique, returns the original nodal values.
+    def doubled_coords(arr):
+        return np.repeat(arr, 2)[1:-1]
+
+    # Double the coordinate arrays.
+    xcorn = doubled_coords(x)
+    ycorn = doubled_coords(y)
+    zcorn = doubled_coords(z)
+
+    # Build a complete grid of corner points via meshgrid. Fortran ('F') order ensures
+    # the connectivity ordering aligns with VTK's expectations.
+    xx, yy, zz = np.meshgrid(xcorn, ycorn, zcorn, indexing='ij')
+    corners = np.column_stack((xx.ravel(order='F'),
+                               yy.ravel(order='F'),
+                               zz.ravel(order='F')))
+
+    # The dimensions to pass to the ExplicitStructuredGrid constructor should be
+    # the counts of unique coordinates in each direction.
+    dims = (len(np.unique(xcorn)),
+            len(np.unique(ycorn)),
+            len(np.unique(zcorn)))
+
+    # Create the ExplicitStructuredGrid.
+    explicit_grid = pv.ExplicitStructuredGrid(dims, corners)
+    explicit_grid.compute_connectivity()
+
+    # --- Copy associated data arrays ---
+
+    # Transfer all cell data arrays.
+    for name, array in rectl_grid.cell_data.items():
+        explicit_grid.cell_data[name] = array.copy()
+
+    # Transfer all point data arrays.
+    for name, array in rectl_grid.point_data.items():
+        explicit_grid.point_data[name] = array.copy()
+
+    # (Optional) Transfer field data as well.
+    for name, array in rectl_grid.field_data.items():
+        explicit_grid.field_data[name] = array.copy()
+
+    return explicit_grid