xtgeo 4.14.0__cp311-cp311-manylinux_2_27_x86_64.manylinux_2_28_x86_64.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/share/eigen3/cmake/Eigen3Config.cmake

@@ -0,0 +1,37 @@
+# This file exports the Eigen3::Eigen CMake target which should be passed to the
+# target_link_libraries command.
+
+
+####### Expanded from @PACKAGE_INIT@ by configure_package_config_file() #######
+####### Any changes to this file will be overwritten by the next CMake run ####
+####### The input file was Eigen3Config.cmake.in                            ########
+
+get_filename_component(PACKAGE_PREFIX_DIR "${CMAKE_CURRENT_LIST_DIR}/../../../" ABSOLUTE)
+
+macro(set_and_check _var _file)
+  set(${_var} "${_file}")
+  if(NOT EXISTS "${_file}")
+    message(FATAL_ERROR "File or directory ${_file} referenced by variable ${_var} does not exist !")
+  endif()
+endmacro()
+
+####################################################################################
+
+if (NOT TARGET eigen)
+  include ("${CMAKE_CURRENT_LIST_DIR}/Eigen3Targets.cmake")
+endif ()
+
+# Legacy variables, do *not* use. May be removed in the future.
+
+set (EIGEN3_FOUND 1)
+set (EIGEN3_USE_FILE    "${CMAKE_CURRENT_LIST_DIR}/UseEigen3.cmake")
+
+set (EIGEN3_DEFINITIONS  "")
+set (EIGEN3_INCLUDE_DIR  "${PACKAGE_PREFIX_DIR}/include/eigen3")
+set (EIGEN3_INCLUDE_DIRS "${PACKAGE_PREFIX_DIR}/include/eigen3")
+set (EIGEN3_ROOT_DIR     "${PACKAGE_PREFIX_DIR}")
+
+set (EIGEN3_VERSION_STRING "3.4.0")
+set (EIGEN3_VERSION_MAJOR  "3")
+set (EIGEN3_VERSION_MINOR  "4")
+set (EIGEN3_VERSION_PATCH  "0")

xtgeo/share/eigen3/cmake/Eigen3ConfigVersion.cmake

@@ -0,0 +1,65 @@
+# This is a basic version file for the Config-mode of find_package().
+# It is used by write_basic_package_version_file() as input file for configure_file()
+# to create a version-file which can be installed along a config.cmake file.
+#
+# The created file sets PACKAGE_VERSION_EXACT if the current version string and
+# the requested version string are exactly the same and it sets
+# PACKAGE_VERSION_COMPATIBLE if the current version is >= requested version,
+# but only if the requested major version is the same as the current one.
+# The variable CVF_VERSION must be set before calling configure_file().
+
+
+set(PACKAGE_VERSION "3.4.0")
+
+if(PACKAGE_VERSION VERSION_LESS PACKAGE_FIND_VERSION)
+  set(PACKAGE_VERSION_COMPATIBLE FALSE)
+else()
+
+  if("3.4.0" MATCHES "^([0-9]+)\\.")
+    set(CVF_VERSION_MAJOR "${CMAKE_MATCH_1}")
+    if(NOT CVF_VERSION_MAJOR VERSION_EQUAL 0)
+      string(REGEX REPLACE "^0+" "" CVF_VERSION_MAJOR "${CVF_VERSION_MAJOR}")
+    endif()
+  else()
+    set(CVF_VERSION_MAJOR "3.4.0")
+  endif()
+
+  if(PACKAGE_FIND_VERSION_RANGE)
+    # both endpoints of the range must have the expected major version
+    math (EXPR CVF_VERSION_MAJOR_NEXT "${CVF_VERSION_MAJOR} + 1")
+    if (NOT PACKAGE_FIND_VERSION_MIN_MAJOR STREQUAL CVF_VERSION_MAJOR
+        OR ((PACKAGE_FIND_VERSION_RANGE_MAX STREQUAL "INCLUDE" AND NOT PACKAGE_FIND_VERSION_MAX_MAJOR STREQUAL CVF_VERSION_MAJOR)
+          OR (PACKAGE_FIND_VERSION_RANGE_MAX STREQUAL "EXCLUDE" AND NOT PACKAGE_FIND_VERSION_MAX VERSION_LESS_EQUAL CVF_VERSION_MAJOR_NEXT)))
+      set(PACKAGE_VERSION_COMPATIBLE FALSE)
+    elseif(PACKAGE_FIND_VERSION_MIN_MAJOR STREQUAL CVF_VERSION_MAJOR
+        AND ((PACKAGE_FIND_VERSION_RANGE_MAX STREQUAL "INCLUDE" AND PACKAGE_VERSION VERSION_LESS_EQUAL PACKAGE_FIND_VERSION_MAX)
+        OR (PACKAGE_FIND_VERSION_RANGE_MAX STREQUAL "EXCLUDE" AND PACKAGE_VERSION VERSION_LESS PACKAGE_FIND_VERSION_MAX)))
+      set(PACKAGE_VERSION_COMPATIBLE TRUE)
+    else()
+      set(PACKAGE_VERSION_COMPATIBLE FALSE)
+    endif()
+  else()
+    if(PACKAGE_FIND_VERSION_MAJOR STREQUAL CVF_VERSION_MAJOR)
+      set(PACKAGE_VERSION_COMPATIBLE TRUE)
+    else()
+      set(PACKAGE_VERSION_COMPATIBLE FALSE)
+    endif()
+
+    if(PACKAGE_FIND_VERSION STREQUAL PACKAGE_VERSION)
+      set(PACKAGE_VERSION_EXACT TRUE)
+    endif()
+  endif()
+endif()
+
+
+# if the installed or the using project don't have CMAKE_SIZEOF_VOID_P set, ignore it:
+if("${CMAKE_SIZEOF_VOID_P}" STREQUAL "" OR "" STREQUAL "")
+  return()
+endif()
+
+# check that the installed version has the same 32/64bit-ness as the one which is currently searching:
+if(NOT CMAKE_SIZEOF_VOID_P STREQUAL "")
+  math(EXPR installedBits " * 8")
+  set(PACKAGE_VERSION "${PACKAGE_VERSION} (${installedBits}bit)")
+  set(PACKAGE_VERSION_UNSUITABLE TRUE)
+endif()

xtgeo/share/eigen3/cmake/Eigen3Targets.cmake

@@ -0,0 +1,106 @@
+# Generated by CMake
+
+if("${CMAKE_MAJOR_VERSION}.${CMAKE_MINOR_VERSION}" LESS 2.8)
+   message(FATAL_ERROR "CMake >= 3.0.0 required")
+endif()
+if(CMAKE_VERSION VERSION_LESS "3.0.0")
+   message(FATAL_ERROR "CMake >= 3.0.0 required")
+endif()
+cmake_policy(PUSH)
+cmake_policy(VERSION 3.0.0...3.31)
+#----------------------------------------------------------------
+# Generated CMake target import file.
+#----------------------------------------------------------------
+
+# Commands may need to know the format version.
+set(CMAKE_IMPORT_FILE_VERSION 1)
+
+# Protect against multiple inclusion, which would fail when already imported targets are added once more.
+set(_cmake_targets_defined "")
+set(_cmake_targets_not_defined "")
+set(_cmake_expected_targets "")
+foreach(_cmake_expected_target IN ITEMS Eigen3::Eigen)
+  list(APPEND _cmake_expected_targets "${_cmake_expected_target}")
+  if(TARGET "${_cmake_expected_target}")
+    list(APPEND _cmake_targets_defined "${_cmake_expected_target}")
+  else()
+    list(APPEND _cmake_targets_not_defined "${_cmake_expected_target}")
+  endif()
+endforeach()
+unset(_cmake_expected_target)
+if(_cmake_targets_defined STREQUAL _cmake_expected_targets)
+  unset(_cmake_targets_defined)
+  unset(_cmake_targets_not_defined)
+  unset(_cmake_expected_targets)
+  unset(CMAKE_IMPORT_FILE_VERSION)
+  cmake_policy(POP)
+  return()
+endif()
+if(NOT _cmake_targets_defined STREQUAL "")
+  string(REPLACE ";" ", " _cmake_targets_defined_text "${_cmake_targets_defined}")
+  string(REPLACE ";" ", " _cmake_targets_not_defined_text "${_cmake_targets_not_defined}")
+  message(FATAL_ERROR "Some (but not all) targets in this export set were already defined.\nTargets Defined: ${_cmake_targets_defined_text}\nTargets not yet defined: ${_cmake_targets_not_defined_text}\n")
+endif()
+unset(_cmake_targets_defined)
+unset(_cmake_targets_not_defined)
+unset(_cmake_expected_targets)
+
+
+# Compute the installation prefix relative to this file.
+get_filename_component(_IMPORT_PREFIX "${CMAKE_CURRENT_LIST_FILE}" PATH)
+get_filename_component(_IMPORT_PREFIX "${_IMPORT_PREFIX}" PATH)
+get_filename_component(_IMPORT_PREFIX "${_IMPORT_PREFIX}" PATH)
+get_filename_component(_IMPORT_PREFIX "${_IMPORT_PREFIX}" PATH)
+if(_IMPORT_PREFIX STREQUAL "/")
+  set(_IMPORT_PREFIX "")
+endif()
+
+# Create imported target Eigen3::Eigen
+add_library(Eigen3::Eigen INTERFACE IMPORTED)
+
+set_target_properties(Eigen3::Eigen PROPERTIES
+  INTERFACE_INCLUDE_DIRECTORIES "${_IMPORT_PREFIX}/include/eigen3"
+)
+
+# Load information for each installed configuration.
+file(GLOB _cmake_config_files "${CMAKE_CURRENT_LIST_DIR}/Eigen3Targets-*.cmake")
+foreach(_cmake_config_file IN LISTS _cmake_config_files)
+  include("${_cmake_config_file}")
+endforeach()
+unset(_cmake_config_file)
+unset(_cmake_config_files)
+
+# Cleanup temporary variables.
+set(_IMPORT_PREFIX)
+
+# Loop over all imported files and verify that they actually exist
+foreach(_cmake_target IN LISTS _cmake_import_check_targets)
+  if(CMAKE_VERSION VERSION_LESS "3.28"
+      OR NOT DEFINED _cmake_import_check_xcframework_for_${_cmake_target}
+      OR NOT IS_DIRECTORY "${_cmake_import_check_xcframework_for_${_cmake_target}}")
+    foreach(_cmake_file IN LISTS "_cmake_import_check_files_for_${_cmake_target}")
+      if(NOT EXISTS "${_cmake_file}")
+        message(FATAL_ERROR "The imported target \"${_cmake_target}\" references the file
+   \"${_cmake_file}\"
+but this file does not exist.  Possible reasons include:
+* The file was deleted, renamed, or moved to another location.
+* An install or uninstall procedure did not complete successfully.
+* The installation package was faulty and contained
+   \"${CMAKE_CURRENT_LIST_FILE}\"
+but not all the files it references.
+")
+      endif()
+    endforeach()
+  endif()
+  unset(_cmake_file)
+  unset("_cmake_import_check_files_for_${_cmake_target}")
+endforeach()
+unset(_cmake_target)
+unset(_cmake_import_check_targets)
+
+# This file does not depend on other imported targets which have
+# been exported from the same project but in a separate export set.
+
+# Commands beyond this point should not need to know the version.
+set(CMAKE_IMPORT_FILE_VERSION)
+cmake_policy(POP)

xtgeo/share/eigen3/cmake/UseEigen3.cmake

@@ -0,0 +1,6 @@
+#                                               -*- cmake -*-
+#
+#  UseEigen3.cmake
+
+add_definitions     ( ${EIGEN3_DEFINITIONS} )
+include_directories ( ${EIGEN3_INCLUDE_DIRS} )

xtgeo/share/pkgconfig/eigen3.pc

@@ -0,0 +1,9 @@
+prefix=/tmp/tmpn0ohmcj_/wheel/platlib/xtgeo
+exec_prefix=${prefix}
+
+Name: Eigen3
+Description: A C++ template library for linear algebra: vectors, matrices, and related algorithms
+Requires:
+Version: 3.4.0
+Libs:
+Cflags: -I${prefix}/include/eigen3

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