subsurface-terra 2025.1.0rc15__py3-none-any.whl → 2025.1.0rc17__py3-none-any.whl

subsurface/modules/reader/volume/segy_reader.py

@@ -1,105 +1,105 @@
-from typing import Union
-
-from subsurface import optional_requirements
-from ....core.structs.base_structures import StructuredData
-import numpy as np
-
-
-def read_in_segy(filepath: str, ignore_geometry: bool = True, flip_y_axis: bool = True) -> StructuredData:
-    """
-    Reads a SEG-Y file and processes its data into a structured format.
-
-    This function opens a SEG-Y file using the `segyio` library and extracts 
-    the trace data. The data is optionally flipped along the y-axis and its 
-    axes are rearranged before being converted into a `StructuredData` object. 
-    The `ignore_geometry` option determines whether SEG-Y header geometry 
-    information is considered during file read.
-
-    Args:
-        filepath (str): The path to the SEG-Y file to be read.
-        ignore_geometry (bool): Whether to ignore the geometry information 
-            from the SEG-Y header. Defaults to True.
-        flip_y_axis (bool): Whether to flip the data vertically (on the y-axis). 
-            Defaults to True.
-
-    Returns:
-        StructuredData: An instance of `StructuredData` containing the 
-        processed trace data from the SEG-Y file.
-
-    Raises:
-        IOError: If there is an error in opening or reading the SEG-Y file.
-        ValueError: If the data cannot be processed into the expected format.
-    """
-    segyio = optional_requirements.require_segyio()
-    segyfile = segyio.open(filepath, ignore_geometry=ignore_geometry)
-
-    data = np.asarray([np.copy(tr) for tr in segyfile.trace[:]])
-    
-    if flip_y_axis:
-        data = np.flip(data, axis=1)
-        
-    data = np.swapaxes(data, 0, 1)
-    
-    sd = StructuredData.from_numpy(data)  # data holds traces * (samples per trace) values
-    segyfile.close()
-    return sd
-
-
-def create_mesh_from_coords(coords: dict, zmin: Union[float, int], zmax: Union[float, int] = 0.0):
-    """Creates a mesh for plotting StructuredData
-
-    Args:
-        coords (Union[dict, LineString]): the x and y, i.e. latitude and longitude, location of the traces of the seismic profile
-        zmax (float): the maximum elevation of the seismic profile, by default 0.0
-        zmin (float): the location in z where the lowest sample was taken
-
-    Returns: vertices and faces for creating an UnstructuredData object
-
-    """
-    n = len(coords['x'])
-    coords = np.array([coords['x'], coords['y']]).T
-    # duplicating the line, once with z=lower and another with z=upper values
-    vertices = np.zeros((2 * n, 3))
-    vertices[:n, :2] = coords
-    vertices[:n, 2] = zmin
-    vertices[n:, :2] = coords
-    vertices[n:, 2] = zmax
-    # i+n --- i+n+1
-    # |\      |
-    # | \     |
-    # |  \    |
-    # |   \   |
-    # i  --- i+1
-
-    scipy = optional_requirements.require_scipy()
-    tri = scipy.spatial.qhull.Delaunay(vertices[:, [0, 2]])
-    faces = tri.simplices
-    return vertices, faces
-
-
-def apply_colormap_to_texture(texture: StructuredData, cmap_name="bwr"):
-    """
-    Convert a single-channel seismic texture.data array into RGB
-    using a Matplotlib colormap (e.g., 'bwr', 'jet', 'RdBu_r', etc.).
-    """
-    # 'texture.data' should be a 2D array of amplitudes: shape = (height, width)
-    import matplotlib.colors as colors
-    import matplotlib.pyplot as plt
-    data = texture.values
-    # 1. Normalize data to [0,1] range based on its min/max
-    min_val, max_val = data.min(), data.max()
-    norm = colors.Normalize(vmin=min_val, vmax=max_val)
-
-    norm = colors.Normalize(vmin=-6, vmax=6)
-
-    # 2. Get a Matplotlib colormap
-    cmap = plt.get_cmap(cmap_name)
-
-    # 3. Map normalized data -> RGBA, shape becomes (height, width, 4)
-    rgba_data = cmap(norm(data))
-
-    # 4. Convert from float in [0,1] to uint8 in [0,255], and drop alpha channel
-    rgb_data = (rgba_data[..., :3] * 255).astype(np.uint8)
-
-    texture = StructuredData.from_numpy(rgb_data)
-    return texture
+from typing import Union
+
+from subsurface import optional_requirements
+from ....core.structs.base_structures import StructuredData
+import numpy as np
+
+
+def read_in_segy(filepath: str, ignore_geometry: bool = True, flip_y_axis: bool = True) -> StructuredData:
+    """
+    Reads a SEG-Y file and processes its data into a structured format.
+
+    This function opens a SEG-Y file using the `segyio` library and extracts 
+    the trace data. The data is optionally flipped along the y-axis and its 
+    axes are rearranged before being converted into a `StructuredData` object. 
+    The `ignore_geometry` option determines whether SEG-Y header geometry 
+    information is considered during file read.
+
+    Args:
+        filepath (str): The path to the SEG-Y file to be read.
+        ignore_geometry (bool): Whether to ignore the geometry information 
+            from the SEG-Y header. Defaults to True.
+        flip_y_axis (bool): Whether to flip the data vertically (on the y-axis). 
+            Defaults to True.
+
+    Returns:
+        StructuredData: An instance of `StructuredData` containing the 
+        processed trace data from the SEG-Y file.
+
+    Raises:
+        IOError: If there is an error in opening or reading the SEG-Y file.
+        ValueError: If the data cannot be processed into the expected format.
+    """
+    segyio = optional_requirements.require_segyio()
+    segyfile = segyio.open(filepath, ignore_geometry=ignore_geometry)
+
+    data = np.asarray([np.copy(tr) for tr in segyfile.trace[:]])
+    
+    if flip_y_axis:
+        data = np.flip(data, axis=1)
+        
+    data = np.swapaxes(data, 0, 1)
+    
+    sd = StructuredData.from_numpy(data)  # data holds traces * (samples per trace) values
+    segyfile.close()
+    return sd
+
+
+def create_mesh_from_coords(coords: dict, zmin: Union[float, int], zmax: Union[float, int] = 0.0):
+    """Creates a mesh for plotting StructuredData
+
+    Args:
+        coords (Union[dict, LineString]): the x and y, i.e. latitude and longitude, location of the traces of the seismic profile
+        zmax (float): the maximum elevation of the seismic profile, by default 0.0
+        zmin (float): the location in z where the lowest sample was taken
+
+    Returns: vertices and faces for creating an UnstructuredData object
+
+    """
+    n = len(coords['x'])
+    coords = np.array([coords['x'], coords['y']]).T
+    # duplicating the line, once with z=lower and another with z=upper values
+    vertices = np.zeros((2 * n, 3))
+    vertices[:n, :2] = coords
+    vertices[:n, 2] = zmin
+    vertices[n:, :2] = coords
+    vertices[n:, 2] = zmax
+    # i+n --- i+n+1
+    # |\      |
+    # | \     |
+    # |  \    |
+    # |   \   |
+    # i  --- i+1
+
+    scipy = optional_requirements.require_scipy()
+    tri = scipy.spatial.qhull.Delaunay(vertices[:, [0, 2]])
+    faces = tri.simplices
+    return vertices, faces
+
+
+def apply_colormap_to_texture(texture: StructuredData, cmap_name="bwr"):
+    """
+    Convert a single-channel seismic texture.data array into RGB
+    using a Matplotlib colormap (e.g., 'bwr', 'jet', 'RdBu_r', etc.).
+    """
+    # 'texture.data' should be a 2D array of amplitudes: shape = (height, width)
+    import matplotlib.colors as colors
+    import matplotlib.pyplot as plt
+    data = texture.values
+    # 1. Normalize data to [0,1] range based on its min/max
+    min_val, max_val = data.min(), data.max()
+    norm = colors.Normalize(vmin=min_val, vmax=max_val)
+
+    norm = colors.Normalize(vmin=-6, vmax=6)
+
+    # 2. Get a Matplotlib colormap
+    cmap = plt.get_cmap(cmap_name)
+
+    # 3. Map normalized data -> RGBA, shape becomes (height, width, 4)
+    rgba_data = cmap(norm(data))
+
+    # 4. Convert from float in [0,1] to uint8 in [0,255], and drop alpha channel
+    rgb_data = (rgba_data[..., :3] * 255).astype(np.uint8)
+
+    texture = StructuredData.from_numpy(rgb_data)
+    return texture

subsurface/modules/reader/volume/seismic.py

@@ -1,173 +1,173 @@
-"""
-TODO: This is legacy code waiting to be updated to the new ideas
-
-"""
-
-import xarray as xr
-import numpy as np
-
-from subsurface import optional_requirements
-
-
-class Seismic:
-    def __init__(self, data: np.ndarray, *args, **kwargs):
-        """Seismic data object based on xarray.DataArray.
-        
-        Args:
-            data (Array): np.ndarray of the seismic cube / section.
-        """
-        self.n_shp = len(data.shape)
-        self._xarray = xr.DataArray(self._flip(data), *args, **kwargs)
-
-    def __getattr__(self, attr):
-        if attr in self.__dict__:
-            return getattr(self, attr)
-        return getattr(self._xarray, attr)
-    
-    def __getitem__(self, item):
-        if isinstance(item, str):
-            return self._xarray._getitem_coord(item)
-
-        # preserve coordinates 
-        cp = list(self._xarray.coords.items())  # parent coordinates
-        coords = [(cp[i]) for i, it in enumerate(item) if not type(it) == int]
-        return Seismic(self._xarray[item].data, coords=coords)
-    
-    def __repr__(self):
-        return self._xarray.__repr__()
-    
-    def __str__(self):
-        return "Seismic"
-
-    def _flip(self, data: np.ndarray) -> np.ndarray:
-        """Flip SEGY data to fit with numpy array orientation.
-
-        Args:
-            data (np.ndarray): Seismic data.
-
-        Returns:
-            (np.ndarray) Flipped seismic data.
-        """
-        if self.n_shp == 1:
-            return data
-        if self.n_shp == 2:
-            return data
-        if self.n_shp == 3:
-            return np.flip(data, axis=2)
-
-    def add_coords(self):
-        """Ability to easily add physical coordinates."""
-        raise NotImplementedError
-
-    def to_segy(self, filepath: str) -> None:
-        """Write given Seismic to SEGY file using segyio.tools.from_array().
-        
-        Args:
-            filepath (str): Filepath for SEGY file.
-        """
-        segyio = optional_requirements.require_segyio()
-        segyio.tools.from_array(filepath, self._xarray.data)
-
-    def plot_(self):
-        return xr.plot.plot._PlotMethods(self)
-
-    def plot(self):
-        if self.n_shp == 1:
-            return _plot_1d(self)
-        elif self.n_shp == 2:
-            pass
-            # TODO: plot seismic section using imshow for correct orientation
-        elif self.n_shp >= 3:
-            _plot_3d(self)
-
-    def create_pyvista_grid(self) -> 'pyvista.grid.UniformGrid':
-        """Generate UniformGrid object for 3D plotting of the seismic.
-
-        Args:
-            seismic (Seismic): Seismic object.
-
-        Returns:
-            (pv.grid.UniformGrid)
-        """
-        pv = optional_requirements.require_pyvista()
-        grid = pv.UniformGrid()
-        grid.spacing = (1, 1, 1)  # TODO: cell sizes? vertical exaggeration etc
-        grid.dimensions = np.array(self.data.shape) + 1
-        grid.cell_data["values"] = self.data.flatten(order="F")
-        # TODO: correct orientation of cube
-        return grid
-
-    def plot_3d_slices(self):
-        pv = optional_requirements.require_pyvista()
-        if self.n_shp != 3:
-            raise AssertionError("Seismic data needs to be a 3-D volume.")
-        # TODO: cmap, kwarg passthrough
-        pv.OrthogonalSlicer(self.grid)
-
-
-def _plot_1d(seismic: Seismic, linekwargs={}, fillkwargs={}):
-    import matplotlib.pyplot as plt
-    fig, ax = plt.subplots(figsize=(2,8))
-    
-    lkwargs = dict(
-        color="black",
-        linewidth=1
-    )
-    lkwargs.update(linekwargs)
-
-    fkwargs = dict(
-        color="grey"
-    )
-    fkwargs.update(fillkwargs)
-
-    y = np.arange(0, *seismic.data.shape)
-    ax.plot(seismic.data, y, **lkwargs)
-    x1 = seismic.data.copy()
-    x1[x1<=0] = 0
-    ax.fill_betweenx(y, x1=x1, **fkwargs)
-    return ax
-
-
-def _plot_3d(seismic: Seismic):
-    if not hasattr(seismic, "grid"):
-        seismic.grid = seismic.create_pyvista_grid()
-
-    seismic.grid.plot(cmap="seismic")
-
-
-def _plot_2d(seismic: Seismic):
-    pass
-
-
-def _plot_hist(seismic: Seismic):
-    pass
-        
-
-def from_segy(filepath:str, coords=None) -> Seismic:
-    """Create a Seismic data object from a SEGY file.
-    
-    Args:
-        filepath (str): Filepath to the SEGY file.
-    
-    Returns:
-        Seismic: Seismic data object based on xarray.DataArray.
-    """
-    segyio = optional_requirements.require_segyio()
-    with segyio.open(filepath) as sf:
-        sf.mmap()  # memory mapping
-        xlines = sf.xlines
-        ilines = sf.ilines
-        samples = sf.samples
-        header = sf.bin
-
-    if not coords:
-        coords = [
-            ("ilines", ilines), 
-            ("xlines", xlines),
-            ("samples", samples)
-        ]
-
-    cube = segyio.tools.cube(filepath)
-    seismic = Seismic(cube, coords=coords)
-    seismic.header = header
-    return seismic
+"""
+TODO: This is legacy code waiting to be updated to the new ideas
+
+"""
+
+import xarray as xr
+import numpy as np
+
+from subsurface import optional_requirements
+
+
+class Seismic:
+    def __init__(self, data: np.ndarray, *args, **kwargs):
+        """Seismic data object based on xarray.DataArray.
+        
+        Args:
+            data (Array): np.ndarray of the seismic cube / section.
+        """
+        self.n_shp = len(data.shape)
+        self._xarray = xr.DataArray(self._flip(data), *args, **kwargs)
+
+    def __getattr__(self, attr):
+        if attr in self.__dict__:
+            return getattr(self, attr)
+        return getattr(self._xarray, attr)
+    
+    def __getitem__(self, item):
+        if isinstance(item, str):
+            return self._xarray._getitem_coord(item)
+
+        # preserve coordinates 
+        cp = list(self._xarray.coords.items())  # parent coordinates
+        coords = [(cp[i]) for i, it in enumerate(item) if not type(it) == int]
+        return Seismic(self._xarray[item].data, coords=coords)
+    
+    def __repr__(self):
+        return self._xarray.__repr__()
+    
+    def __str__(self):
+        return "Seismic"
+
+    def _flip(self, data: np.ndarray) -> np.ndarray:
+        """Flip SEGY data to fit with numpy array orientation.
+
+        Args:
+            data (np.ndarray): Seismic data.
+
+        Returns:
+            (np.ndarray) Flipped seismic data.
+        """
+        if self.n_shp == 1:
+            return data
+        if self.n_shp == 2:
+            return data
+        if self.n_shp == 3:
+            return np.flip(data, axis=2)
+
+    def add_coords(self):
+        """Ability to easily add physical coordinates."""
+        raise NotImplementedError
+
+    def to_segy(self, filepath: str) -> None:
+        """Write given Seismic to SEGY file using segyio.tools.from_array().
+        
+        Args:
+            filepath (str): Filepath for SEGY file.
+        """
+        segyio = optional_requirements.require_segyio()
+        segyio.tools.from_array(filepath, self._xarray.data)
+
+    def plot_(self):
+        return xr.plot.plot._PlotMethods(self)
+
+    def plot(self):
+        if self.n_shp == 1:
+            return _plot_1d(self)
+        elif self.n_shp == 2:
+            pass
+            # TODO: plot seismic section using imshow for correct orientation
+        elif self.n_shp >= 3:
+            _plot_3d(self)
+
+    def create_pyvista_grid(self) -> 'pyvista.grid.UniformGrid':
+        """Generate UniformGrid object for 3D plotting of the seismic.
+
+        Args:
+            seismic (Seismic): Seismic object.
+
+        Returns:
+            (pv.grid.UniformGrid)
+        """
+        pv = optional_requirements.require_pyvista()
+        grid = pv.UniformGrid()
+        grid.spacing = (1, 1, 1)  # TODO: cell sizes? vertical exaggeration etc
+        grid.dimensions = np.array(self.data.shape) + 1
+        grid.cell_data["values"] = self.data.flatten(order="F")
+        # TODO: correct orientation of cube
+        return grid
+
+    def plot_3d_slices(self):
+        pv = optional_requirements.require_pyvista()
+        if self.n_shp != 3:
+            raise AssertionError("Seismic data needs to be a 3-D volume.")
+        # TODO: cmap, kwarg passthrough
+        pv.OrthogonalSlicer(self.grid)
+
+
+def _plot_1d(seismic: Seismic, linekwargs={}, fillkwargs={}):
+    import matplotlib.pyplot as plt
+    fig, ax = plt.subplots(figsize=(2,8))
+    
+    lkwargs = dict(
+        color="black",
+        linewidth=1
+    )
+    lkwargs.update(linekwargs)
+
+    fkwargs = dict(
+        color="grey"
+    )
+    fkwargs.update(fillkwargs)
+
+    y = np.arange(0, *seismic.data.shape)
+    ax.plot(seismic.data, y, **lkwargs)
+    x1 = seismic.data.copy()
+    x1[x1<=0] = 0
+    ax.fill_betweenx(y, x1=x1, **fkwargs)
+    return ax
+
+
+def _plot_3d(seismic: Seismic):
+    if not hasattr(seismic, "grid"):
+        seismic.grid = seismic.create_pyvista_grid()
+
+    seismic.grid.plot(cmap="seismic")
+
+
+def _plot_2d(seismic: Seismic):
+    pass
+
+
+def _plot_hist(seismic: Seismic):
+    pass
+        
+
+def from_segy(filepath:str, coords=None) -> Seismic:
+    """Create a Seismic data object from a SEGY file.
+    
+    Args:
+        filepath (str): Filepath to the SEGY file.
+    
+    Returns:
+        Seismic: Seismic data object based on xarray.DataArray.
+    """
+    segyio = optional_requirements.require_segyio()
+    with segyio.open(filepath) as sf:
+        sf.mmap()  # memory mapping
+        xlines = sf.xlines
+        ilines = sf.ilines
+        samples = sf.samples
+        header = sf.bin
+
+    if not coords:
+        coords = [
+            ("ilines", ilines), 
+            ("xlines", xlines),
+            ("samples", samples)
+        ]
+
+    cube = segyio.tools.cube(filepath)
+    seismic = Seismic(cube, coords=coords)
+    seismic.header = header
+    return seismic

subsurface/modules/reader/volume/volume_utils.py

@@ -1,43 +1,43 @@
-import enum
-from typing import List
-import numpy as np
-from subsurface.optional_requirements import require_scipy
-
-from ....core.structs import UnstructuredData, StructuredData
-
-__all__ = ['interpolate_unstructured_data_to_structured_data', ]
-
-
-class InterpolationMethod(enum.Enum):
-    linear = "linear"
-    nearest = "nearest"
-
-
-def interpolate_unstructured_data_to_structured_data(
-        ud: UnstructuredData, attr_name: str,
-        resolution: List[int] = None,
-        interpolation_method: InterpolationMethod = InterpolationMethod.nearest) -> StructuredData:
-    if resolution is None:
-        resolution = [50, 50, 50]
-    boundaries_max = ud.vertex.max(axis=0)
-    boundaries_min = ud.vertex.min(axis=0)
-    coords = dict()
-    dims = ['x', 'y', 'z']
-    for e, i in enumerate(dims):
-        coords[i] = np.linspace(boundaries_min[e], boundaries_max[e], resolution[e], endpoint=False)
-
-    grid = np.meshgrid(*coords.values())
-    scipy = require_scipy()
-    interpolated_attributes = scipy.interpolate.griddata(
-        points=ud.vertex,
-        values=ud.attributes.loc[:, attr_name],
-        xi=tuple(grid),
-        method=interpolation_method.value
-    )
-
-    sd = StructuredData.from_numpy(
-        array=interpolated_attributes,
-        data_array_name=attr_name,
-        coords=coords
-    )
-    return sd
+import enum
+from typing import List
+import numpy as np
+from subsurface.optional_requirements import require_scipy
+
+from ....core.structs import UnstructuredData, StructuredData
+
+__all__ = ['interpolate_unstructured_data_to_structured_data', ]
+
+
+class InterpolationMethod(enum.Enum):
+    linear = "linear"
+    nearest = "nearest"
+
+
+def interpolate_unstructured_data_to_structured_data(
+        ud: UnstructuredData, attr_name: str,
+        resolution: List[int] = None,
+        interpolation_method: InterpolationMethod = InterpolationMethod.nearest) -> StructuredData:
+    if resolution is None:
+        resolution = [50, 50, 50]
+    boundaries_max = ud.vertex.max(axis=0)
+    boundaries_min = ud.vertex.min(axis=0)
+    coords = dict()
+    dims = ['x', 'y', 'z']
+    for e, i in enumerate(dims):
+        coords[i] = np.linspace(boundaries_min[e], boundaries_max[e], resolution[e], endpoint=False)
+
+    grid = np.meshgrid(*coords.values())
+    scipy = require_scipy()
+    interpolated_attributes = scipy.interpolate.griddata(
+        points=ud.vertex,
+        values=ud.attributes.loc[:, attr_name],
+        xi=tuple(grid),
+        method=interpolation_method.value
+    )
+
+    sd = StructuredData.from_numpy(
+        array=interpolated_attributes,
+        data_array_name=attr_name,
+        coords=coords
+    )
+    return sd