subsurface-terra 2025.1.0rc7__py3-none-any.whl → 2025.1.0rc10__py3-none-any.whl

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/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/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/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/modules/reader/mesh/_trimesh_reader.py

@@ -1,229 +1,433 @@
-from typing import Union
+import enum
+from typing import Union, TextIO, Optional
+import io
+import os
 
 import numpy as np
-from subsurface.core.structs import UnstructuredData
+from ....core.structs import UnstructuredData
+from .... import optional_requirements
+from ....core.structs import TriSurf, StructuredData
 
-import subsurface
-from subsurface import optional_requirements, StructuredData, TriSurf
 
+class TriMeshTransformations(enum.Enum):
+    RIGHT_HANDED_Z_UP = "right_handed_z_up"
+    ORIGINAL = "original"
 
-def _load_with_trimesh(path_to_obj, plot=False):
-    trimesh = optional_requirements.require_trimesh()
-    # Load the OBJ with Trimesh using the specified options
-    scene_or_mesh = trimesh.load(path_to_obj)
-    # Process single mesh vs. scene
-    if isinstance(scene_or_mesh, trimesh.Scene):
-        print("Loaded a Scene with multiple geometries.")
-        _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)}")
-        _handle_material_info(scene_or_mesh)
-        if plot:
-            scene_or_mesh.show()
-    return scene_or_mesh
 
-
-def trimesh_to_unstruct(scene_or_mesh: Union["trimesh.Trimesh", "trimesh.Scene"]) -> subsurface.TriSurf:
+def load_with_trimesh(path_to_file_or_buffer, file_type: Optional[str] = None,
+                      coordinate_system: TriMeshTransformations = TriMeshTransformations.RIGHT_HANDED_Z_UP, *, plot=False):
     """
-    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.
+    Load a mesh with trimesh and convert to the specified coordinate system.
+
     """
     trimesh = optional_requirements.require_trimesh()
-    if isinstance(scene_or_mesh, trimesh.Scene):
-        # Process scene with multiple geometries
-        ts = _trisurf_from_scene(scene_or_mesh, trimesh)
-
-    elif isinstance(scene_or_mesh, trimesh.Trimesh):
-        ts = _trisurf_from_trimesh(scene_or_mesh)
-
-
-    else:
-        raise ValueError("Input must be a Trimesh object or a Scene with multiple geometries.")
-
-    return ts
-
-
-def _trisurf_from_trimesh(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 = _extract_texture_from_material(tri)
-
-    ts = TriSurf(
-        mesh=unstruct,
-        texture=texture,
-    )
-    return ts
-
-
-def _trisurf_from_scene(scene_or_mesh: 'Scene', trimesh: 'trimesh') -> subsurface.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
-        _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
+    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}")
 
-        # 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 = _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
-
-
-def _extract_texture_from_material(geom):
-    from PIL.JpegImagePlugin import JpegImageFile
-    from PIL.PngImagePlugin import PngImageFile
-    import trimesh
-
-    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'))
+    return scene_or_mesh
 
-        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
+def trimesh_to_unstruct(scene_or_mesh: Union["trimesh.Trimesh", "trimesh.Scene"]) -> TriSurf:
+    return TrimeshToSubsurface.trimesh_to_unstruct(scene_or_mesh)
 
 
-def _validate_texture_path(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 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)
 
-def _handle_material_info(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
+        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(),
+            },
+        )
 
-        print("Trimesh material:", material)
+        # If there is a texture
+        ts = TriSurf(
+            mesh=unstruct,
+            texture=texture,
+        )
 
-        # 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.")
+        return ts
 
+    @classmethod
+    def _extract_texture_from_material(cls, geom):
+        from PIL.JpegImagePlugin import JpegImageFile
+        from PIL.PngImagePlugin import PngImageFile
+        import trimesh
 
-def _process_scene(scene):
-    """Process a scene with multiple geometries."""
-    geometries = scene.geometry
-    assert len(geometries) > 0, "No geometries found in the scene."
+        if geom.visual is None or getattr(geom.visual, 'material', None) is None:
+            return None
 
-    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)}")
+        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
+            )
 
-        print(f"Geometry '{geom_name}':")
-        _handle_material_info(geom)
+            # 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/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/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/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/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

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.0rc7.dist-info → subsurface_terra-2025.1.0rc10.dist-info}/METADATA

@@ -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.dist-info → subsurface_terra-2025.1.0rc10.dist-info}/RECORD

@@ -1,9 +1,9 @@
 subsurface/__init__.py,sha256=0D2rCUem3fiHsXFXXSmwheLiPS4cXxEdfWdFBj0b-cY,930
-subsurface/_version.py,sha256=SudUzgQuG7m0d1waiGLEVcfEklQt-vkrNoj5cLAIYoU,541
+subsurface/_version.py,sha256=FcQPFS21SJ4lyiZc0tXWa590ajfkakU3g4UuBjnhZoI,542
 subsurface/optional_requirements.py,sha256=Wg36RqxzPiLtN-3qSg5K9QVEeXCB0-EjSzHERAoO8EE,2883
-subsurface/api/__init__.py,sha256=DUc2LzlVtWjsGyZAyiJY4yxBRTGb-w8kcuAA5ag1s0M,285
+subsurface/api/__init__.py,sha256=UiOBKQcZJGMeh_5ZNhXqT2iEdiIk721djLX30aFxEa4,341
 subsurface/api/interfaces/__init__.py,sha256=rqUtJyMLicobcyhmr74TepjmUQAEmlazKT3vjV_n3aA,6
-subsurface/api/interfaces/stream.py,sha256=MNOSI_Dk1ol0uD2Hxb3EOie4WrqjUje4fDu28kx137w,3856
+subsurface/api/interfaces/stream.py,sha256=i-ieGJbf5a2dskmiOezHMifPoUXf4VQESqEIChHWuoM,4621
 subsurface/api/reader/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 subsurface/api/reader/read_wells.py,sha256=bu6fAdj8WTMPWYVZwBdn7vNt00vfdJ3nqJsZ4o1V25U,2731
 subsurface/core/__init__.py,sha256=73SzsVXHiiWt_215bgIqWWy2t0XgvyOxDPxuq0NyktM,32
@@ -37,7 +37,7 @@ subsurface/core/structs/unstructured_elements/triangular_surface.py,sha256=58Cpu
 subsurface/core/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 subsurface/core/utils/utils_core.py,sha256=lRzLlE11JCH-GCjhbIoKZ-WfARSmI_yhmJkqLMMNmTo,1110
 subsurface/modules/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-subsurface/modules/reader/__init__.py,sha256=KLvtdXVZEHSaQwDzahHBLU0bM73GuemnWK2F7eUQtzw,343
+subsurface/modules/reader/__init__.py,sha256=bD5l951Zzw6xDuzyMSKKqiX5SBpm85iv4QJPwqIbdbQ,483
 subsurface/modules/reader/from_binary.py,sha256=AtBzLCJJRZ0exgfUfv1Rfp1tVMUCfSLuAwTCb_Ieqfs,1341
 subsurface/modules/reader/read_netcdf.py,sha256=zAqRhckeGjlh95Ar-IPbSlUPbbLVignXu-DC9FY7XUk,1019
 subsurface/modules/reader/faults/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -45,12 +45,12 @@ subsurface/modules/reader/faults/faults.py,sha256=s144Gq0tFvjSUkB66dB86kYjW2l2e1
 subsurface/modules/reader/geo_object/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 subsurface/modules/reader/mesh/_GOCAD_mesh.py,sha256=_MwNy4iVMGnemvT01hhB-nbCc8a1r8ETEAkD-AWcBz4,3304
 subsurface/modules/reader/mesh/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-subsurface/modules/reader/mesh/_trimesh_reader.py,sha256=DMRWZg_amcse9kDB-OdI72ZhUVzQdPJwUPi8AQLpr90,8232
+subsurface/modules/reader/mesh/_trimesh_reader.py,sha256=-cmm-BYIUC9x6tqABNgKzNMSrDfuoTdZ7YpfB1nNPh0,17260
 subsurface/modules/reader/mesh/csv_mesh_reader.py,sha256=0iXYg-JOLUg7yH6Rw6qCoxXvKh0hOUTwjYxbhSlGfGM,1969
 subsurface/modules/reader/mesh/dxf_reader.py,sha256=JDhzFRE46sdwMGBB8enHNluH07ohqt6LhgLHiSQRL-I,6525
-subsurface/modules/reader/mesh/glb_reader.py,sha256=9UJiq-YAwZcoiC8Pd8w2iru-GSvOvbb-CUBC47mcrpA,975
-subsurface/modules/reader/mesh/mx_reader.py,sha256=o1OPnGSSOjJCpLCzazRsmjhFxhbYrCi6zTTRnKtCJ30,8419
-subsurface/modules/reader/mesh/obj_reader.py,sha256=srrCYPygqndEOOIbv6vf6jUftBQ0IY9i9vtmUHEZWuk,1681
+subsurface/modules/reader/mesh/glb_reader.py,sha256=dierR9AYM5Q2szLuemfLlM_JcPRNtDrD5fpF8zNjBS8,1118
+subsurface/modules/reader/mesh/mx_reader.py,sha256=YQqvOJ4FuPrlz_3bHIdqT-9YKkirF_Vbjnv6cVQnwAw,8587
+subsurface/modules/reader/mesh/obj_reader.py,sha256=LXf-N-So5xWhnZ6uHJPjcCfQM71a_mqJa3hQEikOGzU,2207
 subsurface/modules/reader/mesh/omf_mesh_reader.py,sha256=0gewosxlLVTQQoUyvYB91AOZ_SByQqxw53coSwCKeMI,1436
 subsurface/modules/reader/mesh/surface_reader.py,sha256=EcRjr3sAJbwZpqm7WHHe1bnMZyGO5MSgF6qm5bSBLtQ,2420
 subsurface/modules/reader/mesh/surfaces_api.py,sha256=3mwB0aU2FNNhIXD_yMyjBR7k2YW-NTXKkbXMg5UfGy0,1557
@@ -60,13 +60,13 @@ subsurface/modules/reader/profiles/profiles_core.py,sha256=kqlt79hjdWWQNBjWqLGlu
 subsurface/modules/reader/topography/__init__.py,sha256=zkaTX5JxsNfjF-dFeEbHfUB58vhPMjm6Iiqx9HgJOrY,14
 subsurface/modules/reader/topography/topo_core.py,sha256=6rkDp9XrUSif8ZuraDrUK2I8-yqEp8CRm4r4l2lQuw0,3542
 subsurface/modules/reader/volume/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-subsurface/modules/reader/volume/read_volume.py,sha256=Dlv7G5GYikdZCp9H5SMfL9vSsUAKpc4b3vBB-P7IVBM,4025
+subsurface/modules/reader/volume/read_volume.py,sha256=nn0C047jsty_kusZZ-nfZ2bWbyfkaakLsDy_ADxb5sw,6368
 subsurface/modules/reader/volume/segy_reader.py,sha256=oBS1FwwzFTMBmAR3odJMvW-as_0YMudPcFmndpcApW4,3958
 subsurface/modules/reader/volume/seismic.py,sha256=dRA7YKw9fkrkAYS7Bnfm7GfCPdfxVsDyfM7frQK56V4,4950
 subsurface/modules/reader/volume/volume_utils.py,sha256=7ToIdVwq04lMyYGJE9PzYVQt9xl9mjbXXrzvMfM6wGw,1367
 subsurface/modules/reader/wells/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 subsurface/modules/reader/wells/_read_to_df.py,sha256=PFs5ottnm7LtzmJgPh8UN3cdR4j2y734RTDPoks16ls,2294
-subsurface/modules/reader/wells/read_borehole_interface.py,sha256=Z4QU0aYzmdNB26_GTlh2ZAyiRSVsEpi90sRBLmIC79w,5411
+subsurface/modules/reader/wells/read_borehole_interface.py,sha256=iyoaee00vfSzqF4sWy9WA4a92VtEb16ERbrkdWgWszE,5548
 subsurface/modules/reader/wells/wells_utils.py,sha256=CoVF9Qtba8Qu42JcVmtsyaSS_PA80lcJ6mzh6-TQt2Q,2206
 subsurface/modules/reader/wells/DEP/__init__.py,sha256=8PES2m_HqZtZ-jFhPynJWpk8dovKAh1UyVnfAxg_NXY,1887
 subsurface/modules/reader/wells/DEP/_well_files_reader.py,sha256=QYZ9p7iyGt1JDlkrFpYPFaMnXwLj7wdFZmTYiO2niSY,6216
@@ -86,8 +86,8 @@ subsurface/modules/writer/to_rex/material_encoder.py,sha256=zGlqF9X_Civ9VvtGwo-I
 subsurface/modules/writer/to_rex/mesh_encoder.py,sha256=6TBtJhYJEAMEBHxQkbweXrJO1jIUx1ClM8l5ajVCrLc,6443
 subsurface/modules/writer/to_rex/to_rex.py,sha256=njsm2d3e69pRVfF_TOC_hexvXPmgNTZdJvhbnXcvyIo,3800
 subsurface/modules/writer/to_rex/utils.py,sha256=HEpJ95LjHOK24ePpmLpPP5uFyv6i_kN3AWh031q-1Uc,379
-subsurface_terra-2025.1.0rc7.dist-info/licenses/LICENSE,sha256=GSXh9K5TZauM89BeGbYg07oST_HMhOTiZoEGaUeKBtA,11606
-subsurface_terra-2025.1.0rc7.dist-info/METADATA,sha256=Mkf-RKKa_AWVljSLXC2HwEhaDVcDBNH7t3zoj5jLB2w,7093
-subsurface_terra-2025.1.0rc7.dist-info/WHEEL,sha256=CmyFI0kx5cdEMTLiONQRbGQwjIoR1aIYB7eCAQ4KPJ0,91
-subsurface_terra-2025.1.0rc7.dist-info/top_level.txt,sha256=f32R_tUSf83CfkpB4vjv5m2XcD8TmDX9h7F4rnEXt5A,11
-subsurface_terra-2025.1.0rc7.dist-info/RECORD,,
+subsurface_terra-2025.1.0rc10.dist-info/licenses/LICENSE,sha256=GSXh9K5TZauM89BeGbYg07oST_HMhOTiZoEGaUeKBtA,11606
+subsurface_terra-2025.1.0rc10.dist-info/METADATA,sha256=jBJ-O1dvs0h0JLz8AC8pa_DvztAmPpJk5f_CivFG0n4,7094
+subsurface_terra-2025.1.0rc10.dist-info/WHEEL,sha256=CmyFI0kx5cdEMTLiONQRbGQwjIoR1aIYB7eCAQ4KPJ0,91
+subsurface_terra-2025.1.0rc10.dist-info/top_level.txt,sha256=f32R_tUSf83CfkpB4vjv5m2XcD8TmDX9h7F4rnEXt5A,11
+subsurface_terra-2025.1.0rc10.dist-info/RECORD,,