subsurface-terra 2025.1.0rc10__py3-none-any.whl → 2025.1.0rc12__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.0rc10'
-__version_tuple__ = version_tuple = (2025, 1, 0)
+__version__ = version = '2025.1.0rc12'
+__version_tuple__ = version_tuple = (2025, 1, 0, 'rc12')

subsurface/api/__init__.py

@@ -8,5 +8,6 @@ from .interfaces.stream import (
     VTK_stream_to_struct,  
     MX_stream_to_unstruc,
     OBJ_stream_to_trisurf,
-    GLTF_stream_to_trisurf
+    GLTF_stream_to_trisurf,
+    MSH_stream_to_struct,
 )

subsurface/api/interfaces/stream.py

@@ -1,6 +1,6 @@
 import io
 from io import BytesIO
-from typing import TextIO
+from typing import TextIO, Optional
 
 import pandas
 
@@ -57,11 +57,17 @@ def GLTF_stream_to_trisurf(gltf_stream: io.BytesIO, coordinate_system: TriMeshTr
     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]
 
 
+def MSH_stream_to_struct(grid_stream: TextIO, values_stream: TextIO, missing_value: Optional[float], attr_name: Optional[str]) -> list[StructuredData]:
+    struct = reader.read_msh_structured_grid(grid_stream, values_stream, missing_value, attr_name)
+    return [struct]
+
+
 def CSV_wells_stream_to_unstruc(
         collars_reader: GenericReaderFilesHelper,
         surveys_reader: GenericReaderFilesHelper,

subsurface/core/geological_formats/boreholes/survey.py

@@ -111,9 +111,11 @@ def _map_attrs_to_measured_depths(attrs: pd.DataFrame, survey: Survey) -> pd.Dat
 
     # Start with a copy of the existing attributes DataFrame
     new_attrs = survey.survey_trajectory.data.points_attributes.copy()
-    if 'component lith' in attrs.columns:
+    if 'component lith' in attrs.columns and 'lith_ids' not in attrs.columns:
         # Factorize lith components directly in-place
         attrs['lith_ids'], _ = pd.factorize(attrs['component lith'], use_na_sentinel=True)
+    else:
+        pass
 
     # Add missing columns from attrs, preserving their dtypes
     for col in attrs.columns.difference(new_attrs.columns):
@@ -152,7 +154,7 @@ def _map_attrs_to_measured_depths(attrs: pd.DataFrame, survey: Survey) -> pd.Dat
                 continue
             attr_to_interpolate = attrs_well[col]
             # make sure the attr_to_interpolate is not a string
-            if attr_to_interpolate.dtype == 'O':
+            if attr_to_interpolate.dtype == 'O' or isinstance(attr_to_interpolate.dtype, pd.CategoricalDtype): 
                 continue
             if col in ['lith_ids', 'component lith']:
                 interp_kind = 'nearest'

subsurface/core/structs/structured_elements/structured_grid.py

@@ -33,6 +33,10 @@ class StructuredGrid:
         grid_3d = np.meshgrid(*cart_coord, indexing='ij')
         return grid_3d
 
+    @property
+    def active_attributes(self) -> np.ndarray:
+        return self.ds.data[self.ds.active_data_array_name].values
+
     def meshgrid_2d(self, attribute_name_coord_name: str = None) -> list:
         """
 

subsurface/modules/reader/__init__.py

@@ -9,3 +9,5 @@ from .mesh.dxf_reader import dxf_stream_to_unstruct_input, dxf_file_to_unstruct_
 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
+
+from .volume.read_grav3d import read_msh_structured_grid

subsurface/modules/reader/mesh/_trimesh_reader.py

@@ -9,9 +9,14 @@ from .... import optional_requirements
 from ....core.structs import TriSurf, StructuredData
 
 
-class TriMeshTransformations(enum.Enum):
-    RIGHT_HANDED_Z_UP = "right_handed_z_up"
-    ORIGINAL = "original"
+class TriMeshTransformations(enum.Flag):
+    UP_Z = 2**1
+    UP_Y = 2**2
+    FORWARD_MINUS_Z = 2**3
+    FORWARD_PLUS_Z = 2**4
+    RIGHT_HANDED_Z_UP_Y_REVERSED = UP_Y | FORWARD_MINUS_Z
+    RIGHT_HANDED_Z_UP = UP_Y | FORWARD_PLUS_Z
+    ORIGINAL = UP_Z | FORWARD_MINUS_Z
 
 
 def load_with_trimesh(path_to_file_or_buffer, file_type: Optional[str] = None,
@@ -23,13 +28,10 @@ def load_with_trimesh(path_to_file_or_buffer, file_type: Optional[str] = None,
     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
+        # * Forward -Z up Y
         case TriMeshTransformations.RIGHT_HANDED_Z_UP:
             # Transform from Y-up (modeling software) to Z-up (scientific)
             # This rotates the model so that:
@@ -37,21 +39,29 @@ def load_with_trimesh(path_to_file_or_buffer, file_type: Optional[str] = None,
             # 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
+                    [1, 0, 0, 0],  
+                    [0, 0, -1, 0],  
+                    [0, 1, 0, 0], 
                     [0, 0, 0, 1]
             ])
-
+        case TriMeshTransformations.RIGHT_HANDED_Z_UP_Y_REVERSED:
+            # * Forward Z Up Y
+            transform=np.array([
+                    [1, 0, 0, 0],
+                    [0, 0, 1, 0],
+                    [0, 1, 0, 0],
+                    [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)
+        # TODO: Add all the options of blender
         case _:
             raise ValueError(f"Invalid coordinate system: {coordinate_system}")
 
+    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)
     return scene_or_mesh
 
 

subsurface/modules/reader/volume/read_grav3d.py

@@ -0,0 +1,428 @@
+from dataclasses import dataclass, field
+from typing import List, Dict, Any, Tuple, Optional, Union, TextIO
+import numpy as np
+import xarray as xr
+from pathlib import Path
+
+from ....core.structs import StructuredData
+
+
+@dataclass
+class GridDimensions:
+    """
+    Represents the dimensions of a 3D grid.
+
+    Attributes:
+        nx (int): Number of cells in the x-direction
+        ny (int): Number of cells in the y-direction
+        nz (int): Number of cells in the z-direction
+    """
+    nx: int
+    ny: int
+    nz: int
+
+
+@dataclass
+class GridOrigin:
+    """
+    Represents the origin point of a 3D grid.
+
+    Attributes:
+        x (float): X-coordinate of the origin
+        y (float): Y-coordinate of the origin
+        z (float): Z-coordinate of the origin
+    """
+    x: float
+    y: float
+    z: float
+
+
+@dataclass
+class GridCellSizes:
+    """
+    Represents the cell sizes in each direction of a 3D grid.
+
+    Attributes:
+        x (List[float]): Cell sizes in the x-direction
+        y (List[float]): Cell sizes in the y-direction
+        z (List[float]): Cell sizes in the z-direction
+    """
+    x: List[float]
+    y: List[float]
+    z: List[float]
+
+
+@dataclass
+class GridData:
+    """
+    Represents a 3D grid with dimensions, origin, and cell sizes.
+
+    Attributes:
+        dimensions (GridDimensions): The dimensions of the grid
+        origin (GridOrigin): The origin point of the grid
+        cell_sizes (GridCellSizes): The cell sizes in each direction
+        metadata (Dict[str, Any]): Optional metadata about the grid
+    """
+    dimensions: GridDimensions
+    origin: GridOrigin
+    cell_sizes: GridCellSizes
+    metadata: Dict[str, Any] = field(default_factory=dict)
+
+    @classmethod
+    def from_dict(cls, grid_dict: Dict[str, Any]) -> 'GridData':
+        """
+        Converts a dictionary containing grid information into a GridData instance.
+
+        Args:
+            grid_dict: Dictionary with grid information
+
+        Returns:
+            GridData: A new GridData instance
+        """
+        dims = grid_dict["dimensions"]
+        origin_dict = grid_dict["origin"]
+        cell_sizes_dict = grid_dict["cell_sizes"]
+
+        # Handle both new and legacy key names
+        nx = dims.get("nx", dims.get("ne"))
+        ny = dims.get("ny", dims.get("nn"))
+        nz = dims.get("nz", dims.get("nz"))
+
+        x = origin_dict.get("x", origin_dict.get("x0"))
+        y = origin_dict.get("y", origin_dict.get("y0"))
+        z = origin_dict.get("z", origin_dict.get("z0"))
+
+        x_sizes = cell_sizes_dict.get("x", cell_sizes_dict.get("easting"))
+        y_sizes = cell_sizes_dict.get("y", cell_sizes_dict.get("northing"))
+        z_sizes = cell_sizes_dict.get("z", cell_sizes_dict.get("vertical"))
+
+        metadata = grid_dict.get("metadata", {})
+
+        return cls(
+            dimensions=GridDimensions(nx=nx, ny=ny, nz=nz),
+            origin=GridOrigin(x=x, y=y, z=z),
+            cell_sizes=GridCellSizes(x=x_sizes, y=y_sizes, z=z_sizes),
+            metadata=metadata
+        )
+
+
+def read_msh_structured_grid(grid_stream: TextIO, values_stream: TextIO, missing_value: Optional[float],
+                             attr_name: Optional[str]) -> StructuredData:
+    """
+    Read a structured grid mesh and values from streams and return a StructuredData object.
+
+    This function is designed to work with streams (e.g., from Azure blob storage)
+    rather than file paths.
+
+    Args:
+        grid_stream: TextIO stream containing the grid definition (.msh format)
+        values_stream: TextIO stream containing the property values (.mod format)
+
+    Returns:
+        StructuredData object containing the grid and property values
+
+    Raises:
+        ValueError: If the stream format is invalid
+    """
+    # Read all lines from the grid stream
+    lines = [line.strip() for line in grid_stream if line.strip()]
+
+    # Create metadata for the grid
+    metadata = {
+            'file_format': 'grav3d',
+            'source'     : 'stream'
+    }
+
+    # Parse grid information from lines
+    try:
+        grid = _parse_grid_from_lines(lines, metadata)
+    except ValueError as e:
+        # Add context about the stream to the error message
+        raise ValueError(f"Error parsing grid stream: {e}") from e
+
+    # Read values from the values stream
+    try:
+        # Read all values from the stream
+        lines = [line.strip() for line in values_stream if line.strip()]
+
+        model_array = _parse_mod_file(grid, lines, missing_value=missing_value)
+
+    except Exception as e:
+        # Add context to any errors
+        raise ValueError(f"Error reading model stream: {str(e)}") from e
+
+    # Create and return a StructuredData object
+    return structured_data_from(model_array, grid, data_name=attr_name)
+
+
+def read_msh_file(filepath: Union[str, Path]) -> GridData:
+    """
+    Read a structured grid mesh file and return a GridData object.
+
+    Currently supports Grav3D mesh file format (.msh):
+    - First line: NX NY NZ (number of cells in X, Y, Z directions)
+    - Second line: X Y Z (coordinates of origin in meters)
+    - Next section: X cell widths (either expanded or using N*value notation)
+    - Next section: Y cell widths (either expanded or using N*value notation)
+    - Next section: Z cell thicknesses (either expanded or using N*value notation)
+
+    Args:
+        filepath: Path to the mesh file
+
+    Returns:
+        GridData object containing the mesh information
+
+    Raises:
+        FileNotFoundError: If the file doesn't exist
+        ValueError: If the file format is invalid
+    """
+    filepath = Path(filepath)
+    if not filepath.exists():
+        raise FileNotFoundError(f"Mesh file not found: {filepath}")
+
+    with open(filepath, 'r') as f:
+        lines = [line.strip() for line in f.readlines() if line.strip()]
+
+    metadata = {
+            'file_format': 'grav3d',
+            'filepath'   : str(filepath)
+    }
+
+    try:
+        return _parse_grid_from_lines(lines, metadata)
+    except ValueError as e:
+        # Add context about the file to the error message
+        raise ValueError(f"Error parsing mesh file {filepath}: {e}") from e
+
+
+def read_mod_file(filepath: Union[str, Path], grid: GridData,
+                  missing_value: float = -99_999.0) -> np.ndarray:
+    """
+    Read a model file containing property values for a 3D grid.
+
+    Currently supports Grav3D model file format (.mod) where each line contains
+    a single property value. The values are ordered with the z-direction changing
+    fastest, then x, then y.
+
+    Args:
+        filepath: Path to the model file
+        grid: GridData object containing the grid dimensions
+        missing_value: Value to replace with NaN in the output array (default: -99_999.0)
+
+    Returns:
+        3D numpy array of property values with shape (ny, nx, nz)
+
+    Raises:
+        FileNotFoundError: If the file doesn't exist
+        ValueError: If the number of values doesn't match the grid dimensions
+    """
+    filepath = Path(filepath)
+    if not filepath.exists():
+        raise FileNotFoundError(f"Model file not found: {filepath}")
+
+    try:
+        # Read all values from the file
+        with open(filepath, 'r') as f:
+            lines = [line.strip() for line in f if line.strip()]
+
+        model_array = _parse_mod_file(grid, lines, missing_value)
+
+        return model_array
+
+    except Exception as e:
+        # Add context to any errors
+        raise ValueError(f"Error reading model file {filepath}: {str(e)}") from e
+
+
+def _parse_mod_file(grid: GridData, lines: List[str], missing_value: Optional[float]) -> np.ndarray:
+    # Convert each line to a float
+    values = np.array([float(line) for line in lines], dtype=float)
+    # Calculate expected number of values based on grid dimensions
+    nx, ny, nz = grid.dimensions.nx, grid.dimensions.ny, grid.dimensions.nz
+    expected_count = nx * ny * nz
+    if len(values) != expected_count:
+        raise ValueError(
+            f"Invalid model file: expected {expected_count} values, got {len(values)}"
+        )
+    # Reshape to (ny, nx, nz) with z changing fastest
+    model_array = values.reshape((ny, nx, nz))
+    # Replace missing values with NaN
+    if missing_value is not None:
+        model_array[model_array == missing_value] = np.nan
+    return model_array
+
+
+def structured_data_from(array: np.ndarray, grid: GridData,
+                         data_name: str = 'model') -> StructuredData:
+    """
+    Convert a 3D numpy array and grid information into a StructuredData object.
+
+    Args:
+        array: 3D numpy array of property values with shape (ny, nx, nz)
+        grid: GridData object containing grid dimensions, origin, and cell sizes
+        data_name: Name for the data array (default: 'model')
+
+    Returns:
+        StructuredData object containing the data array with proper coordinates
+
+    Raises:
+        ValueError: If array shape doesn't match grid dimensions
+    """
+    # Verify array shape matches grid dimensions
+    expected_shape = (grid.dimensions.ny, grid.dimensions.nx, grid.dimensions.nz)
+    if array.shape != expected_shape:
+        raise ValueError(
+            f"Array shape {array.shape} doesn't match grid dimensions {expected_shape}"
+        )
+
+    # Calculate cell center coordinates
+    centers = _calculate_cell_centers(grid)
+
+    # Create the xarray DataArray with proper coordinates
+    xr_data_array = xr.DataArray(
+        data=array,
+        dims=['y', 'x', 'z'],  # Dimensions in the order they appear in the array
+        coords={
+                'x': centers['x'],
+                'y': centers['y'],
+                'z': centers['z'],
+        },
+        name=data_name,
+        attrs=grid.metadata  # Include grid metadata in the data array
+    )
+
+    # Create a StructuredData instance from the xarray DataArray
+    struct = StructuredData.from_data_array(
+        data_array=xr_data_array,
+        data_array_name=data_name
+    )
+
+    return struct
+
+
+def _parse_grid_from_lines(lines: List[str], metadata: Dict[str, Any] = None) -> GridData:
+    """
+    Parse grid information from a list of lines.
+
+    Args:
+        lines: List of lines containing grid information
+        metadata: Optional metadata to include in the GridData object
+
+    Returns:
+        GridData object containing the parsed grid information
+
+    Raises:
+        ValueError: If the lines format is invalid
+    """
+    if len(lines) < 2:
+        raise ValueError("Invalid format: insufficient data")
+
+    # Parse dimensions (first line)
+    try:
+        dims = lines[0].split()
+        nx, ny, nz = int(dims[0]), int(dims[1]), int(dims[2])
+    except (IndexError, ValueError) as e:
+        raise ValueError(f"Invalid dimensions: {e}")
+
+    # Parse origin coordinates (second line)
+    try:
+        origin = lines[1].split()
+        x, y, z = float(origin[0]), float(origin[1]), float(origin[2])
+    except (IndexError, ValueError) as e:
+        raise ValueError(f"Invalid origin: {e}")
+
+    # Parse cell sizes
+    try:
+        current_line = 2
+        x_sizes, current_line = _parse_cell_sizes(lines, current_line, nx)
+        y_sizes, current_line = _parse_cell_sizes(lines, current_line, ny)
+        z_sizes, _ = _parse_cell_sizes(lines, current_line, nz)
+    except (IndexError, ValueError) as e:
+        raise ValueError(f"Error parsing cell sizes: {e}")
+
+    # Create a GridData object with the parsed information
+    grid_data_dict = {
+            'dimensions': {'nx': nx, 'ny': ny, 'nz': nz},
+            'origin'    : {'x': x, 'y': y, 'z': z},
+            'cell_sizes': {
+                    'x': x_sizes,
+                    'y': y_sizes,
+                    'z': z_sizes
+            },
+            'metadata'  : metadata or {}
+    }
+
+    return GridData.from_dict(grid_data_dict)
+
+
+def _parse_cell_sizes(lines: List[str], start_index: int, count: int) -> Tuple[List[float], int]:
+    """
+    Parse cell sizes from file lines, handling both compact (N*value) and expanded notation.
+
+    Args:
+        lines: List of lines from the file
+        start_index: Index to start parsing from
+        count: Number of values to parse
+
+    Returns:
+        Tuple containing:
+            - List of parsed values
+            - Next line index after parsing
+    """
+    line = lines[start_index]
+
+    # Check for compact notation (N*value)
+    if '*' in line:
+        parts = line.split('*')
+        repetition = int(parts[0])
+        value = float(parts[1])
+        values = [value] * repetition
+        return values, start_index + 1
+
+    # Handle expanded notation across multiple lines
+    values = []
+    line_index = start_index
+
+    while len(values) < count and line_index < len(lines):
+        current_line = lines[line_index]
+
+        # If we encounter a line with compact notation while parsing expanded, 
+        # it's likely the next section
+        if '*' in current_line and len(values) > 0:
+            break
+
+        # Add all numbers from the current line
+        values.extend([float(x) for x in current_line.split()])
+        line_index += 1
+
+    # Take only the required number of values
+    return values[:count], line_index
+
+
+def _calculate_cell_centers(grid: GridData) -> Dict[str, np.ndarray]:
+    """
+    Calculate the center coordinates of each cell in the grid.
+
+    Args:
+        grid: GridData object containing grid dimensions, origin, and cell sizes
+
+    Returns:
+        Dictionary with 'x', 'y', and 'z' keys containing arrays of cell center coordinates
+    """
+    # Convert cell sizes to numpy arrays for vectorized operations
+    x_sizes = np.array(grid.cell_sizes.x)
+    y_sizes = np.array(grid.cell_sizes.y)
+    z_sizes = np.array(grid.cell_sizes.z)
+
+    # Calculate cell centers by adding cumulative sizes and offsetting by half the first cell size
+    x_centers = grid.origin.x + np.cumsum(x_sizes) - x_sizes[0] / 2
+    y_centers = grid.origin.y + np.cumsum(y_sizes) - y_sizes[0] / 2
+
+    # For z, cells typically extend downward from the origin
+    z_centers = grid.origin.z - (np.cumsum(z_sizes) - z_sizes[0] / 2)
+
+    return {
+            'x': x_centers,
+            'y': y_centers,
+            'z': z_centers
+    }

subsurface/modules/reader/volume/read_volume.py

@@ -102,21 +102,81 @@ def read_volumetric_mesh_attr_file(reader_helper: GenericReaderFilesHelper) -> p
     return df
 
 
-def pv_cast_to_explicit_structured_grid(pyvista_object):
-
+def pv_cast_to_explicit_structured_grid(pyvista_object: 'pv.DataSet') -> 'pv.ExplicitStructuredGrid':
     pv = optional_requirements.require_pyvista()
 
     match pyvista_object:
-
         case pv.RectilinearGrid() as rectl_grid:
-
             return __pv_convert_rectilinear_to_explicit(rectl_grid)
-
+        case pv.UnstructuredGrid() as unstr_grid:
+            return __pv_convert_unstructured_to_explicit(unstr_grid)
         case _:
-
             return pyvista_object.cast_to_explicit_structured_grid()
 
 
+def __pv_convert_unstructured_to_explicit(unstr_grid):
+    """
+    Convert a PyVista UnstructuredGrid to an ExplicitStructuredGrid if possible.
+    """
+    pv = optional_requirements.require_pyvista()
+
+    # First check if the grid has the necessary attributes to be treated as structured
+    if not hasattr(unstr_grid, 'n_cells') or unstr_grid.n_cells == 0:
+        raise ValueError("The unstructured grid has no cells.")
+    
+    # Try to detect if the grid has a structured topology
+    # Check if the grid has cell type 11 (VTK_VOXEL) or 12 (VTK_HEXAHEDRON)
+    cell_types = unstr_grid.celltypes
+    
+    # Voxels (11) and hexahedra (12) are the cell types used in structured grids
+    if not all(ct in [11, 12] for ct in cell_types):
+        raise ValueError("The unstructured grid contains non-hexahedral cells and cannot be converted to explicit structured.")
+    
+    # Try to infer dimensions from the grid
+    try:
+        # Method 1: Try PyVista's built-in conversion if available
+        return unstr_grid.cast_to_explicit_structured_grid()
+    except (AttributeError, TypeError):
+        pass
+    
+    try:
+        # Method 2: If the grid has dimensions stored as field data
+        if "dimensions" in unstr_grid.field_data:
+            dims = unstr_grid.field_data["dimensions"]
+            if len(dims) == 3:
+                nx, ny, nz = dims
+                # Verify that dimensions match the number of cells
+                if (nx-1)*(ny-1)*(nz-1) != unstr_grid.n_cells:
+                    raise ValueError("Stored dimensions do not match the number of cells.")
+                
+                # Extract points and reorder if needed
+                points = unstr_grid.points.reshape((nx, ny, nz, 3))
+                
+                # Create explicit structured grid
+                explicit_grid = pv.ExplicitStructuredGrid((nx, ny, nz), points.reshape((-1, 3)))
+                explicit_grid.compute_connectivity()
+                
+                # Transfer data arrays
+                for name, array in unstr_grid.cell_data.items():
+                    explicit_grid.cell_data[name] = array.copy()
+                for name, array in unstr_grid.point_data.items():
+                    explicit_grid.point_data[name] = array.copy()
+                for name, array in unstr_grid.field_data.items():
+                    if name != "dimensions":  # Skip dimensions field
+                        explicit_grid.field_data[name] = array.copy()
+                
+                return explicit_grid
+    except (ValueError, KeyError):
+        pass
+    
+    # If none of the above methods work, use PyVista's extract_cells function
+    # to reconstruct the structured grid if possible
+    try:
+        # This is a best-effort approach that tries multiple strategies
+        return pv.core.filters.convert_unstructured_to_structured_grid(unstr_grid)
+    except Exception as e:
+        raise ValueError(f"Failed to convert unstructured grid to explicit structured grid: {e}")
+    
 def __pv_convert_rectilinear_to_explicit(rectl_grid):
 
     pv = optional_requirements.require_pyvista()

subsurface/modules/reader/wells/read_borehole_interface.py

@@ -100,6 +100,16 @@ def _validate_lith_data(d: pd.DataFrame, reader_helper: GenericReaderFilesHelper
         raise AttributeError('If wells attributes represent lithology, `component lith` column must be present in the file. '
                              'Use columns_map to assign column names to these fields. Maybe you are marking as lithology'
                              'the wrong file?')
+    else:
+        # TODO: Add categories to reader helper
+        categories = sorted(d['component lith'].dropna().unique())
+        d['component lith'] = pd.Categorical(
+            d['component lith'],
+            categories=categories,
+            ordered=True
+        )
+        
+        d['lith_ids'] = d['component lith'].cat.codes + 1
 
     given_top = np.isin(['top', 'base'], d.columns).all()
     given_altitude_and_base = np.isin(['altitude', 'base'], d.columns).all()

subsurface/modules/tools/mocking_aux.py

@@ -0,0 +1,104 @@
+import numpy as np
+import pyvista as pv
+
+
+def transform_gaussian_blur(grid, sigma=20.0):
+    """
+    Applies a Gaussian blur to the 'model_name' field of the structured grid.
+
+    Parameters:
+        grid - PyVista grid with 'model_name' field
+        sigma - Standard deviation for the Gaussian kernel
+    """
+    from scipy.ndimage import gaussian_filter
+
+    # Get the original dimensions of the grid
+    dims = grid.dimensions
+
+    # Reshape the data to 3D array matching grid dimensions
+    values = np.array(grid['model_name'])
+    values_3d = values.reshape(dims[2] - 1, dims[1] - 1, dims[0] - 1).transpose(2, 1, 0)
+
+    # Apply Gaussian filter
+    blurred_values = gaussian_filter(values_3d, sigma=sigma, axes=(2,))
+
+    # Reshape back to 1D array
+    grid['model_name'] = blurred_values.transpose(2, 1, 0).flatten()
+    return grid
+
+
+def transform_sinusoidal(values, amplitude=1.0, frequency=0.01, phase=0):
+    """
+    Apply a sinusoidal transformation to the values.
+    """
+    return values + amplitude * np.sin(frequency * values + phase)
+
+
+def obfuscate_model_name(grid, transform_functions, attr):
+    """
+    Applies transformation functions to the 'model_name' field.
+    Functions can operate on either the grid or the values array.
+    """
+    for func in transform_functions:
+        if 'grid' in func.__code__.co_varnames:
+            # Function expects the full grid
+            grid = func(grid)
+        else:
+            # Function expects just the values array
+            values = np.array(grid[attr])
+            grid[attr] = func(values)
+
+    return grid
+
+
+# pyvista_struct = transform_xy_to_z_propagation(pyvista_struct, z_factor=0.3, noise_level=0.1)
+def transform_subtract_mean(values):
+    """
+    Subtract the mean of the array from each element.
+    """
+    return values - np.mean(values)
+
+
+def transform_scale(values, scale_factor=0.003):
+    """
+    Multiply each value by scale_factor.
+    """
+    return values * scale_factor
+
+
+
+
+def update_extent(pyvista_grid, new_extent):
+    # new_extent: array-like with 6 elements [xmin, xmax, ymin, ymax, zmin, zmax]
+    old_bounds = np.array(pyvista_grid.bounds)  # [xmin, xmax, ymin, ymax, zmin, zmax]
+
+    # Check for valid extents
+    if any(new_extent[i] >= new_extent[i + 1] for i in range(0, 6, 2)):
+        raise ValueError("Each min value must be less than the corresponding max value in the new extent.")
+
+    # Compute old ranges and new ranges for each axis
+    old_ranges = old_bounds[1::2] - old_bounds[0::2]  # [x_range, y_range, z_range]
+    new_ranges = np.array([new_extent[1] - new_extent[0],
+                           new_extent[3] - new_extent[2],
+                           new_extent[5] - new_extent[4]])
+
+    # Avoid division by zero if any old range is zero
+    if np.any(old_ranges == 0):
+        raise ValueError("One of the dimensions in the current grid has zero length.")
+
+    # Get the old points and reshape for easier manipulation
+    old_points = pyvista_grid.points  # shape (N, 3)
+
+    # Compute normalized coordinates within the old extent
+    norm_points = (old_points - old_bounds[0::2]) / old_ranges
+
+    # Compute new points based on new extent
+    new_mins = np.array([new_extent[0], new_extent[2], new_extent[4]])
+    new_points = new_mins + norm_points * new_ranges
+
+    # Update the grid's points
+    pyvista_grid.points = new_points
+
+    # Updating bounds is implicit once the points are modified.
+    pyvista_grid.Modified()
+    return pyvista_grid

{subsurface_terra-2025.1.0rc10.dist-info → subsurface_terra-2025.1.0rc12.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: subsurface_terra
-Version: 2025.1.0rc10
+Version: 2025.1.0rc12
 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.0rc10.dist-info → subsurface_terra-2025.1.0rc12.dist-info}/RECORD

@@ -1,9 +1,9 @@
 subsurface/__init__.py,sha256=0D2rCUem3fiHsXFXXSmwheLiPS4cXxEdfWdFBj0b-cY,930
-subsurface/_version.py,sha256=FcQPFS21SJ4lyiZc0tXWa590ajfkakU3g4UuBjnhZoI,542
+subsurface/_version.py,sha256=D_1QY4RtsEm2Eew8rPYqG7jASO3oDCF7p_cXgYN2Qzg,550
 subsurface/optional_requirements.py,sha256=Wg36RqxzPiLtN-3qSg5K9QVEeXCB0-EjSzHERAoO8EE,2883
-subsurface/api/__init__.py,sha256=UiOBKQcZJGMeh_5ZNhXqT2iEdiIk721djLX30aFxEa4,341
+subsurface/api/__init__.py,sha256=E3R1fNn_d5XQdlZyjtzBcH_bYRzAvOc3xV38qFLqbZY,369
 subsurface/api/interfaces/__init__.py,sha256=rqUtJyMLicobcyhmr74TepjmUQAEmlazKT3vjV_n3aA,6
-subsurface/api/interfaces/stream.py,sha256=i-ieGJbf5a2dskmiOezHMifPoUXf4VQESqEIChHWuoM,4621
+subsurface/api/interfaces/stream.py,sha256=fCoroYYIzbHbCi-JlThwEtw-JegKnEacYdD11QCO-bA,4911
 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
@@ -13,7 +13,7 @@ subsurface/core/geological_formats/boreholes/__init__.py,sha256=47DEQpj8HBSa-_TI
 subsurface/core/geological_formats/boreholes/_combine_trajectories.py,sha256=U5VribebcMAag0DOKnna983g1BXAGLKCddGra2g3Nos,5246
 subsurface/core/geological_formats/boreholes/boreholes.py,sha256=Q7KBYIk9M4-SZjDOVx5dMp8DnHBo4VTFrJ4jAKCmrJ8,5256
 subsurface/core/geological_formats/boreholes/collars.py,sha256=o1I8bS0XqWa2fS0n6XZVKXsuBHknXO2Z_5sdlFc_GAE,750
-subsurface/core/geological_formats/boreholes/survey.py,sha256=6UJRFCp-WAEgTB1YboTGrSyrtKhJNCm1R31jjssqrkA,16095
+subsurface/core/geological_formats/boreholes/survey.py,sha256=aaENR0ksT_lK0BYR7HL73KNZ44eo3Ag353xQdVcLOz0,16219
 subsurface/core/reader_helpers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 subsurface/core/reader_helpers/reader_unstruct.py,sha256=Lme1ano-dQrKhLCwrokcpKqa28DFxDaGAs3ub8MAHtY,397
 subsurface/core/reader_helpers/readers_data.py,sha256=Vewi8pqv-zooRIhffTM52eWZeP6l9MnHkD9LZj6c1LU,4995
@@ -27,7 +27,7 @@ subsurface/core/structs/base_structures/structured_data.py,sha256=iaVmCMIwkxiGXt
 subsurface/core/structs/base_structures/unstructured_data.py,sha256=_cB64U0d8VlWgod0eHNluLmtLQZKLOwJYkmdtqYocXs,12904
 subsurface/core/structs/structured_elements/__init__.py,sha256=wQ8z6vioC98TNwnqMHlDMVFJ1yOKsmlVa6kHL1SOfZQ,43
 subsurface/core/structs/structured_elements/octree_mesh.py,sha256=vI30DW46oGP_h_3v85MiFmwFDoKh1HWdVBATdTmC-yA,240
-subsurface/core/structs/structured_elements/structured_grid.py,sha256=2MTkTUI8gBIYyYdHpmjQJ7lvHrZbU3tP76pbU2iDv0s,1669
+subsurface/core/structs/structured_elements/structured_grid.py,sha256=hSIBkLjEF-_INVUA7w66CoTDWYISmbwjLOP43zL5r10,1802
 subsurface/core/structs/structured_elements/structured_mesh.py,sha256=GfFKwmIqxVe9qSxepxK5PdSNf320c14r13WYLYVwaEo,265
 subsurface/core/structs/unstructured_elements/__init__.py,sha256=BcrnAs207rFTl0hZp8D_LdmpUJ_8G_hoK4b7EMFTKJw,144
 subsurface/core/structs/unstructured_elements/line_set.py,sha256=cXLje8ep7dJnzGiFVgLzCazbYocqY5z1t-jyDCYHInY,2214
@@ -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=bD5l951Zzw6xDuzyMSKKqiX5SBpm85iv4QJPwqIbdbQ,483
+subsurface/modules/reader/__init__.py,sha256=H51ReyQbadZ4813AZ_W6yZmfg_Osp7Tbn7VdzJ1YsnM,543
 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,7 +45,7 @@ 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=-cmm-BYIUC9x6tqABNgKzNMSrDfuoTdZ7YpfB1nNPh0,17260
+subsurface/modules/reader/mesh/_trimesh_reader.py,sha256=D28DrNuC8QDZpmmctjf6KRHWeHPidvavn2V8NIF9roo,17549
 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=dierR9AYM5Q2szLuemfLlM_JcPRNtDrD5fpF8zNjBS8,1118
@@ -60,19 +60,22 @@ 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=nn0C047jsty_kusZZ-nfZ2bWbyfkaakLsDy_ADxb5sw,6368
+subsurface/modules/reader/volume/read_grav3d.py,sha256=Zg5zCnSbcNLNOL-Yj_lePpnueFFLBPJQUyp3B7TD99E,14513
+subsurface/modules/reader/volume/read_volume.py,sha256=GvlYIROefskHkqpwvSu60jQIzev54jBfbrL74CYT7TU,9580
 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=iyoaee00vfSzqF4sWy9WA4a92VtEb16ERbrkdWgWszE,5548
+subsurface/modules/reader/wells/read_borehole_interface.py,sha256=1Kq_IjHhhPgxQKjk5B655CT9wCYCYz5T4UjggF8Pdfg,5899
 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
 subsurface/modules/reader/wells/DEP/_wells_api.py,sha256=SZU0cwfbn-bqKaAIG94be9Azxyx0pnvZrE2yXxIIJD4,2334
 subsurface/modules/reader/wells/DEP/_welly_reader.py,sha256=ktBEswaQSj0mzubFME8oTP7sTPDI1r65zVfT91LORMI,6468
 subsurface/modules/reader/wells/DEP/pandas_to_welly.py,sha256=Z67LE6K4Dy5LkR6ZrAmQx9u0UbLJj8oWxAALVx_eyDc,6925
+subsurface/modules/tools/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+subsurface/modules/tools/mocking_aux.py,sha256=DcavlyWV5pFl31MHUgOxAXW2I_y8bKqbyesBfCDWnLs,3581
 subsurface/modules/visualization/__init__.py,sha256=Y9SUj2cflk0ulCj1F1cJAeoCQJOD0eN4E98wxZ5Zhj0,65
 subsurface/modules/visualization/to_pyvista.py,sha256=_xM4Xx3PD0wyxtUrMHS5k6xbiDQ5k_Kis8dE-wnM77M,10514
 subsurface/modules/writer/__init__.py,sha256=1oDGj2X1G-R2ZRi_8sMBfq1QHkUarbycmMVvSdSTk-g,50
@@ -86,8 +89,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.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,,
+subsurface_terra-2025.1.0rc12.dist-info/licenses/LICENSE,sha256=GSXh9K5TZauM89BeGbYg07oST_HMhOTiZoEGaUeKBtA,11606
+subsurface_terra-2025.1.0rc12.dist-info/METADATA,sha256=-JXdGryaR_k9plZ3-3GoFQKbYYS2kVZfe_4oH6haLkw,7094
+subsurface_terra-2025.1.0rc12.dist-info/WHEEL,sha256=SmOxYU7pzNKBqASvQJ7DjX3XGUF92lrGhMb3R6_iiqI,91
+subsurface_terra-2025.1.0rc12.dist-info/top_level.txt,sha256=f32R_tUSf83CfkpB4vjv5m2XcD8TmDX9h7F4rnEXt5A,11
+subsurface_terra-2025.1.0rc12.dist-info/RECORD,,

{subsurface_terra-2025.1.0rc10.dist-info → subsurface_terra-2025.1.0rc12.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (78.1.0)
+Generator: setuptools (79.0.1)
 Root-Is-Purelib: true
 Tag: py3-none-any