xtgeo 4.14.1__cp313-cp313-win_amd64.whl

xtgeo/roxutils/roxutils.py

@@ -0,0 +1,207 @@
+"""Module for simplifying various operation in the Roxar python interface."""
+
+from packaging.version import parse as versionparse
+
+from xtgeo.common.log import null_logger
+from xtgeo.common.xtgeo_dialog import XTGeoDialog
+
+from . import _roxutils_etc
+from ._roxar_loader import roxar
+
+xtg = XTGeoDialog()
+logger = null_logger(__name__)
+
+
+class RoxUtils(object):
+    """Class RoxUtils, for accessing project level methods::
+
+     import xtgeo
+
+     xr = xtgeo.RoxUtils(project)
+     xr.create_horizon_category('DS_extracted_run3')
+     xr.delete_horizon_category('DS_extracted_run2')
+
+    The project itself can be a reference to an existing project, typically
+    the magic ``project`` wording inside RMS python,
+    or a file path to a RMS project (for external access).
+
+    Args:
+        project (roxar.Project or str): Reference to a RMS project
+            either an existing instance or a RMS project folder path.
+        readonly (bool). Default is False. If readonly, then it cannot be
+            saved to this project (which is the case for "secondary" projects).
+
+    Examples::
+
+        import xgeo
+        path = '/some/path/to/rmsprject.rmsx'
+
+        ext = xtgeo.RoxUtils(path, readonly=True)
+        # ...do something
+        ext.safe_close()
+
+    """
+
+    def __init__(self, project, readonly=False):
+        self._project = None
+
+        self._version = roxar.__version__
+
+        if versionparse(self._version) < versionparse("1.5"):
+            raise RuntimeError("XTGeo >= 3.0 requires Roxar API >= 1.5")
+
+        self._roxexternal = True
+
+        self._versions = {
+            "1.0": ["10.0.x"],
+            "1.1": ["10.1.0", "10.1.1", "10.1.2"],
+            "1.1.1": ["10.1.3"],
+            "1.2": ["11.0.0"],
+            "1.2.1": ["11.0.1"],
+            "1.3": ["11.1.0", "11.1.1", "11.1.2"],
+            "1.4": ["12.0.0", "12.0.1", "12.0.2"],
+            "1.5": ["12.1"],
+            "1.6": ["13.0"],
+            "1.7": ["13.1"],
+        }
+
+        if project is not None and isinstance(project, str):
+            projectname = project
+            self._project = roxar.Project.open(projectname, readonly=readonly)
+            logger.info("Open RMS project from %s", projectname)
+
+        elif isinstance(project, roxar.Project):
+            # this will happen for _current_ project inside RMS or if
+            # project is opened already e.g. by roxar.Project.open(). In the latter
+            # case, the user should also close the project by project.close() as
+            # an explicit action.
+
+            self._roxexternal = False
+            self._project = project
+            logger.info("RMS project instance is already open as <%s>", project)
+        else:
+            raise RuntimeError("Project is not valid")
+
+    @property
+    def roxversion(self):
+        """Roxar API version (read only)"""
+        return self._version
+
+    @property
+    def project(self):
+        """The Roxar project instance (read only)"""
+        return self._project
+
+    def safe_close(self):
+        """Close the project but only if roxarapps (external) mode, i.e.
+        not current RMS project
+
+        In case roxar.Project.open() is done explicitly, safe_close() will do nothing.
+
+        """
+        if self._roxexternal:
+            try:
+                self._project.close()
+                logger.info("RMS project instance is closed")
+            except TypeError as msg:
+                xtg.warn(msg)
+        else:
+            logger.info("Close request, but skip for good reasons...")
+            logger.debug("... either in RMS GUI or in a sequence of running roxarapps")
+
+    def version_required(self, targetversion):
+        """Defines a minimum ROXAPI version for some feature (True or False).
+
+        Args:
+            targetversion (str): Minimum version to compare with.
+
+        Example::
+
+            rox = RoxUtils(project)
+            if rox.version_required('1.5'):
+                somefunction()
+            else:
+                print('Not supported in this version')
+
+        """
+        return versionparse(self._version) >= versionparse(targetversion)
+
+    def rmsversion(self, apiversion):
+        """Get the actual RMS version(s) given an API version.
+
+        Args:
+            apiversion (str): ROXAPI version to ask for
+
+        Returns:
+            A list of RMS version(s) for the given API version, None if
+                not any match.
+
+        Example::
+
+            rox = RoxUtils(project)
+            rmsver = rox.rmsversion('1.5')
+            print('The supported RMS version are {}'.format(rmsver))
+
+        """
+
+        return self._versions.get(apiversion, None)
+
+    def create_horizons_category(self, category, domain="depth", htype="surface"):
+        """Create one or more a Horizons category entries.
+
+        Args:
+            category (str or list): Name(s) of category to make, either as
+                a simple string or a list of strings.
+            domain (str): 'depth' (default) or 'time'
+            htype (str): Horizon type: surface/lines/points
+        """
+
+        _roxutils_etc.create_whatever_category(
+            self, category, stype="horizons", domain=domain, htype=htype
+        )
+
+    def create_zones_category(self, category, domain="thickness", htype="surface"):
+        """Create one or more a Horizons category entries.
+
+        Args:
+            category (str or list): Name(s) of category to make, either as
+                a simple string or a list of strings.
+            domain (str): 'thickness' (default) or ...?
+            htype (str): Horizon type: surface/lines/points
+        """
+
+        _roxutils_etc.create_whatever_category(
+            self, category, stype="zones", domain=domain, htype=htype
+        )
+
+    def delete_horizons_category(self, category):
+        """Delete on or more horizons or zones categories"""
+
+        _roxutils_etc.delete_whatever_category(self, category, stype="horizons")
+
+    def delete_zones_category(self, category):
+        """Delete on or more horizons or zones categories. See previous"""
+
+        _roxutils_etc.delete_whatever_category(self, category, stype="zones")
+
+    def clear_horizon_category(self, category):
+        """Clear (or make empty) the content of one or more horizon categories.
+
+        Args:
+            category (str or list): Name(s) of category to empty, either as
+                 a simple string or a list of strings.
+
+        .. versionadded:: 2.1
+        """
+        _roxutils_etc.clear_whatever_category(self, category, stype="horizons")
+
+    def clear_zone_category(self, category):
+        """Clear (or make empty) the content of one or more zone categories.
+
+        Args:
+            category (str or list): Name(s) of category to empty, either as
+                 a simple string or a list of strings.
+
+        .. versionadded:: 2.1
+        """
+        _roxutils_etc.clear_whatever_category(self, category, stype="zones")

xtgeo/surface/__init__.py

@@ -0,0 +1,20 @@
+"""XTGeo surface package"""
+
+from .regular_surface import (
+    RegularSurface,
+    surface_from_file,
+    surface_from_grid3d,
+    surface_from_rms,
+    surface_from_roxar,
+)
+from .surfaces import Surfaces, surfaces_from_grid
+
+__all__ = [
+    "RegularSurface",
+    "surface_from_file",
+    "surface_from_rms",
+    "surface_from_roxar",
+    "surface_from_grid3d",
+    "Surfaces",
+    "surfaces_from_grid",
+]

xtgeo/surface/_regsurf_boundary.py

@@ -0,0 +1,26 @@
+import math
+
+from xtgeo.xyz.points import points_from_surface
+from xtgeo.xyz.polygons import Polygons
+
+
+def create_boundary(self, alpha_factor, is_convex, simplify):
+    """Create boundary polygons for a surface."""
+
+    # make into points
+    points = points_from_surface(self)
+
+    # compute minimum alpha based on surface resolution
+    alpha = math.ceil(math.sqrt(self.xinc**2 + self.yinc**2) / 2)
+
+    pol = Polygons.boundary_from_points(points, alpha_factor, alpha, is_convex)
+
+    if simplify:
+        if isinstance(simplify, bool):
+            pol.simplify(tolerance=0.1)
+        elif isinstance(simplify, dict) and "tolerance" in simplify:
+            pol.simplify(**simplify)
+        else:
+            raise ValueError("Invalid values for simplify keyword")
+
+    return pol

xtgeo/surface/_regsurf_cube.py

@@ -0,0 +1,210 @@
+"""Regular surface vs Cube"""
+
+import numpy as np
+
+from xtgeo import _cxtgeo
+from xtgeo.common.constants import UNDEF
+from xtgeo.common.log import null_logger
+
+logger = null_logger(__name__)
+
+
+def slice_cube(
+    self,
+    cube,
+    scube,
+    zsurf=None,
+    sampling="nearest",
+    mask=True,
+    snapxy=False,
+    deadtraces=True,
+    algorithm=1,
+):
+    """Slicing a cube, using different algorithms"""
+
+    if algorithm == 2:
+        if snapxy:
+            return _slice_cube_v2(
+                self,
+                cube,
+                zsurf=zsurf,
+                sampling=sampling,
+                mask=mask,
+                deadtraces=deadtraces,
+            )
+        return _slice_cube_v2_resample(
+            self,
+            cube,
+            scube,
+            zsurf=zsurf,
+            sampling=sampling,
+            mask=mask,
+            deadtraces=deadtraces,
+        )
+
+    # legacy version:
+    return _slice_cube_v1(
+        self,
+        cube,
+        zsurf=zsurf,
+        sampling=sampling,
+        mask=mask,
+        snapxy=snapxy,
+        deadtraces=deadtraces,
+    )
+
+
+def _slice_cube_v1(
+    self, cube, zsurf=None, sampling="nearest", mask=True, snapxy=False, deadtraces=True
+):
+    """
+    Private function for the Cube slicing. This is the legacy version up to version
+    2.8.x but may remain default for a while
+    """
+
+    logger.info("Slice cube algorithm 1")
+    if zsurf is not None:
+        other = zsurf
+    else:
+        logger.info("The current surface is copied as 'other'")
+        other = self.copy()
+
+    if not self.compare_topology(other, strict=False):
+        raise RuntimeError("Topology of maps differ. Stop!")
+
+    opt2 = 0 if mask else 1
+
+    if deadtraces:
+        # set dead traces to cxtgeo UNDEF -> special treatment in the C code
+        olddead = cube.values_dead_traces(UNDEF)
+
+    cubeval1d = np.ravel(cube.values, order="C")
+
+    nsurf = self.ncol * self.nrow
+
+    usesampling = 0
+    if sampling == "trilinear":
+        usesampling = 1
+        if snapxy:
+            usesampling = 2
+
+    logger.debug("Running method from C... (using typemaps for numpies!:")
+    istat, v1d = _cxtgeo.surf_slice_cube(
+        cube.ncol,
+        cube.nrow,
+        cube.nlay,
+        cube.xori,
+        cube.xinc,
+        cube.yori,
+        cube.yinc,
+        cube.zori,
+        cube.zinc,
+        cube.rotation,
+        cube.yflip,
+        cubeval1d,
+        self.ncol,
+        self.nrow,
+        self.xori,
+        self.xinc,
+        self.yori,
+        self.yinc,
+        self.yflip,
+        self.rotation,
+        other.get_values1d(),
+        nsurf,
+        usesampling,
+        opt2,
+    )
+
+    self.set_values1d(v1d)
+
+    if deadtraces:
+        cube.values_dead_traces(olddead)  # reset value for dead traces
+
+    return istat
+
+
+def _slice_cube_v2(
+    self, cube, zsurf=None, sampling="nearest", mask=True, deadtraces=True
+):
+    """
+    This is the new version, optimised for the case where the surface has exact same
+    topology as the cube. This should both simplify and speed up calculations
+
+    From xtgeo 2.9
+    """
+
+    logger.info("Slice cube algorithm 2 with sampling %s", sampling)
+    other = zsurf if zsurf is not None else self.copy()
+
+    if not self.compare_topology(other, strict=False):
+        raise RuntimeError("Topology of maps differ. Stop!")
+
+    optmask = 0
+    if mask:
+        optmask = 1
+
+    if deadtraces:
+        # set dead traces to cxtgeo UNDEF -> special treatment in the C code
+        olddead = cube.values_dead_traces(UNDEF)
+
+    optnearest = 1
+    if sampling == "trilinear":
+        optnearest = 0
+
+    # cube and surf shall share same topology, e.g. cube.col == surf.ncol etc
+    # print(self.values.mask)
+    istat = _cxtgeo.surf_slice_cube_v3(
+        cube.ncol,
+        cube.nrow,
+        cube.nlay,
+        cube.zori,
+        cube.zinc,
+        cube.values,
+        other.values.data,
+        self.values.data,
+        self.values.mask,
+        optnearest,
+        optmask,
+    )
+
+    if istat != 0:
+        logger.warning("Problem, ISTAT = %s", istat)
+
+    if deadtraces:
+        cube.values_dead_traces(olddead)  # reset value for dead traces
+
+    return istat
+
+
+def _slice_cube_v2_resample(
+    self, cube, scube, zsurf=None, sampling="nearest", mask=True, deadtraces=True
+):
+    """Slicing with surfaces that not match the cube geometry, snapxy=False
+
+    The idea here is to resample the surface to the cube, then afterwards
+    do an inverse sampling
+    """
+    if self.compare_topology(scube, strict=False):
+        return _slice_cube_v2(self, cube, zsurf, sampling, mask, deadtraces)
+
+    scube.resample(self)
+
+    zcube = None
+    if zsurf:
+        zcube = scube.copy()
+        zcube.resample(zsurf)
+
+    istat = _slice_cube_v2(
+        scube,
+        cube=cube,
+        zsurf=zcube,
+        sampling=sampling,
+        mask=mask,
+        deadtraces=deadtraces,
+    )
+
+    # sample back
+    self.resample(scube, mask=mask)
+
+    return istat