subsurface-terra 2025.1.0rc6__tar.gz → 2025.1.0rc8__tar.gz

{subsurface_terra-2025.1.0rc6/subsurface_terra.egg-info → subsurface_terra-2025.1.0rc8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: subsurface_terra
-Version: 2025.1.0rc6
+Version: 2025.1.0rc8
 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.0rc6 → subsurface_terra-2025.1.0rc8}/subsurface/_version.py

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

{subsurface_terra-2025.1.0rc6 → subsurface_terra-2025.1.0rc8}/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.0rc6 → subsurface_terra-2025.1.0rc8}/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.0rc6 → subsurface_terra-2025.1.0rc8}/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.0rc8/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.0rc6 → subsurface_terra-2025.1.0rc8}/subsurface/modules/reader/mesh/dxf_reader.py

@@ -59,7 +59,7 @@ def dxf_file_to_unstruct_input(
     """
     ezdxf = optional_requirements.require_ezdxf()
     dataset = ezdxf.readfile(file)
-    cell_attr_int, cell_attr_map, cells, vertex = _dxf_dataset_to_unstruct_input(dataset)
+    vertex, cells, cell_attr_int, cell_attr_map = _dxf_dataset_to_unstruct_input(dataset)
 
     if vertex.size == 0:
         raise ValueError("The DXF file does not contain any 3DFACE entities.")
@@ -124,7 +124,14 @@ def _extract_vertices_from_dataset(
     return np.unique(vertices, axis=0)
 
 
-def _dxf_dataset_to_unstruct_input(dataset):
+def _dxf_dataset_to_unstruct_input(dataset: 'ezdxf.drawing.Drawing') -> tuple[np.ndarray, np.ndarray, np.ndarray, dict]:
+    """
+    Build unstructured-mesh-like data from 3DFACE entities in a dataset:
+      - vertex coordinates
+      - connectivity in 'cells' array
+      - cell attributes in both integer-coded and mapping (string->int) forms
+
+    """
     """
     Build unstructured-mesh-like data from 3DFACE entities in a dataset:
       - vertex coordinates
@@ -167,4 +174,4 @@ def _dxf_dataset_to_unstruct_input(dataset):
     cells = np.arange(0, vertices.shape[0]).reshape(-1, 3)
 
     cell_attr_int, cell_attr_map = _map_cell_attr_strings_to_integers(cell_attr)
-    return cell_attr_int, cell_attr_map, cells, vertices
+    return vertices, cells, cell_attr_int, cell_attr_map

{subsurface_terra-2025.1.0rc6 → subsurface_terra-2025.1.0rc8}/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.0rc6 → subsurface_terra-2025.1.0rc8}/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.0rc6 → subsurface_terra-2025.1.0rc8}/subsurface/modules/reader/wells/read_borehole_interface.py

@@ -9,7 +9,6 @@ from subsurface.modules.reader.wells.wells_utils import add_tops_from_base_and_a
 
 
 def read_collar(reader_helper: GenericReaderFilesHelper) -> pd.DataFrame:
-    if reader_helper.usecols is None: reader_helper.usecols = [0, 1, 2, 3]
     if reader_helper.index_col is False: reader_helper.index_col = 0
 
     # Check file_or_buffer type
@@ -22,13 +21,16 @@ def read_collar(reader_helper: GenericReaderFilesHelper) -> pd.DataFrame:
     return data_df
 
 
-def read_survey(reader_helper: GenericReaderFilesHelper):
+def read_survey(reader_helper: GenericReaderFilesHelper, validate_survey: bool = True) -> pd.DataFrame:
     if reader_helper.index_col is False: reader_helper.index_col = 0
 
     d = check_format_and_read_to_df(reader_helper)
     _map_rows_and_cols_inplace(d, reader_helper)
 
-    d_no_singles = _validate_survey_data(d)
+    if validate_survey:
+        d_no_singles = _validate_survey_data(d)
+    else:
+        d_no_singles = d
 
     return d_no_singles
 
@@ -37,12 +39,16 @@ def read_lith(reader_helper: GenericReaderFilesHelper) -> pd.DataFrame:
     return read_attributes(reader_helper, is_lith=True)
 
 
-def read_attributes(reader_helper: GenericReaderFilesHelper, is_lith: bool = False) -> pd.DataFrame:
-    if reader_helper.index_col is False: reader_helper.index_col = 0
-
+def read_attributes(reader_helper: GenericReaderFilesHelper, is_lith: bool = False, validate_attr: bool = True) -> pd.DataFrame:
+    if reader_helper.index_col is False:
+        reader_helper.index_col = 0
+        
     d = check_format_and_read_to_df(reader_helper)
 
     _map_rows_and_cols_inplace(d, reader_helper)
+    if validate_attr is False:
+        return d
+    
     if is_lith:
         d = _validate_lith_data(d, reader_helper)
     else:

{subsurface_terra-2025.1.0rc6 → subsurface_terra-2025.1.0rc8/subsurface_terra.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: subsurface_terra
-Version: 2025.1.0rc6
+Version: 2025.1.0rc8
 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