xtgeo 4.13.1__cp313-cp313-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl

xtgeo/cube/_cube_import.py

@@ -0,0 +1,532 @@
+"""Import Cube data via SegyIO library or XTGeo CLIB.
+
+Data model in XTGeo illustrated by example: ncol=3, nrow=4 (non-rotated):
+
+                    3              7                    ^ "J, ~NORTH" direction
+  xline=1022       +--------------+--------------+11    |     (if unrotated)
+                   |              |              |      |
+                   |              |              |      |
+                   |              |              |
+                   |2             |6             |10
+  xline=1020       +--------------+--------------+      Rotation is school angle of
+                   |              |              |      "I east" vs X axis
+                   |              |              |
+                   |              |              |
+                   |1             |5             |9
+  xline=1018       +--------------+--------------+
+                   |              |              |
+                   |              |              |
+                   |              |              |
+                   |0             |4             |8
+  xline=1016       +--------------+--------------+      ------> "I, ~EAST" direction
+
+                iline=4400     iline=4401     iline=4402
+
+Indices is fastest along "J" (C order), and xlines and ilines spacing may vary (2 for
+xline, 1 for iline in this example) but shall be constant per axis
+
+"""
+
+from __future__ import annotations
+
+import json
+from collections import defaultdict
+from copy import deepcopy
+from struct import unpack
+from typing import TYPE_CHECKING
+from warnings import warn
+
+import numpy as np
+import segyio
+from segyio import TraceField as TF
+
+import xtgeo.common.sys as xsys
+from xtgeo import _cxtgeo
+from xtgeo.common import calc
+from xtgeo.common.constants import UNDEF
+from xtgeo.common.log import null_logger
+from xtgeo.common.xtgeo_dialog import XTGeoDialog
+from xtgeo.metadata.metadata import MetaDataRegularCube
+
+if TYPE_CHECKING:
+    from xtgeo.io._file import FileWrapper
+
+xtg = XTGeoDialog()
+logger = null_logger(__name__)
+
+
+def import_segy(sfile: FileWrapper) -> dict:
+    """Import SEGY via the SegyIO library.
+
+    Args:
+        sfile: File object for SEGY file
+    """
+    sfile = sfile.file
+
+    attributes = {}
+
+    try:
+        # cube with all traces present
+        with segyio.open(sfile, "r") as segyfile:
+            attributes = _import_segy_all_traces(segyfile)
+    except ValueError as verr:
+        if any(word in str(verr) for word in ["Invalid dimensions", "inconsistent"]):
+            # cube with missing traces is now handled but his is complex, hence users
+            # shall be warned. With more experience, this warning can be removed.
+            warn(
+                "Missing or inconsistent traces in SEGY detected, xtgeo will try "
+                "to import by infilling, but please check result carefully!",
+                UserWarning,
+            )
+
+            with segyio.open(sfile, "r", ignore_geometry=True) as segyfile:
+                attributes = _import_segy_incomplete_traces(segyfile)
+        else:
+            raise
+    except Exception as anyerror:  # catch the rest
+        raise OSError(f"Cannot parse SEGY file: {str(anyerror)}") from anyerror
+
+    if not attributes:
+        raise ValueError("Could not get attributes for segy file")
+
+    attributes["segyfile"] = sfile
+    return attributes
+
+
+def _import_segy_all_traces(segyfile: segyio.segy.SegyFile) -> dict:
+    """Import a a full cube SEGY via the SegyIO library to xtgeo format spec.
+
+    Here, the segyio.tools.cube function can be applied
+
+    Args:
+        segyfile: Filehandle from segyio
+    """
+    segyfile.mmap()
+
+    values = _process_cube_values(segyio.tools.cube(segyfile))
+
+    ilines = segyfile.ilines
+    xlines = segyfile.xlines
+
+    ncol, nrow, nlay = values.shape
+
+    # get additional but required geometries for xtgeo; xori, yori, xinc, ..., rotation
+    attrs = _segy_all_traces_attributes(segyfile, ncol, nrow, nlay)
+
+    attrs["ilines"] = ilines
+    attrs["xlines"] = xlines
+    attrs["values"] = values
+
+    return attrs
+
+
+def _process_cube_values(values: np.ndarray) -> np.ndarray:
+    """Helper function to validate/check values."""
+    if values.dtype != np.float32:
+        xtg.warnuser(f"Values are converted from {values.dtype} to float32")
+        values = values.astype(np.float32)
+    if np.any(np.isnan(values)):
+        raise ValueError(
+            f"The input values: {values} contains NaN values which is currently "
+            "not handled!"
+        )
+
+    return values
+
+
+def _segy_all_traces_attributes(
+    segyfile: segyio.segy.SegyFile, ncol, nrow, nlay
+) -> dict:
+    """Get the geometrical values xtgeo needs for a cube definition."""
+    trcode = segyio.TraceField.TraceIdentificationCode
+    traceidcodes = segyfile.attributes(trcode)[:].reshape(ncol, nrow)
+
+    # need positions in corners for making vectors to compute geometries
+    c1v = calc.ijk_to_ib(1, 1, 1, ncol, nrow, 1, forder=False)
+    c2v = calc.ijk_to_ib(ncol, 1, 1, ncol, nrow, 1, forder=False)
+    c3v = calc.ijk_to_ib(1, nrow, 1, ncol, nrow, 1, forder=False)
+
+    xori, yori, zori, zinc = _get_coordinate(segyfile, c1v)
+    point_x1, point_y1, _, _ = _get_coordinate(segyfile, c2v)
+    point_x2, point_y2, _, _ = _get_coordinate(segyfile, c3v)
+
+    slen1, _, rotation = calc.vectorinfo2(xori, point_x1, yori, point_y1)
+    xinc = slen1 / (ncol - 1)
+
+    slen2, _, _ = calc.vectorinfo2(xori, point_x2, yori, point_y2)
+    yinc = slen2 / (nrow - 1)
+
+    # find YFLIP by cross products
+    yflip = calc.find_flip(
+        (point_x1 - xori, point_y1 - yori, 0), (point_x2 - xori, point_y2 - yori, 0)
+    )
+
+    return {
+        "ncol": ncol,
+        "nrow": nrow,
+        "nlay": nlay,
+        "xori": xori,
+        "xinc": xinc,
+        "yori": yori,
+        "yinc": yinc,
+        "zori": zori,
+        "zinc": zinc,
+        "rotation": rotation,
+        "yflip": yflip,
+        "traceidcodes": traceidcodes,
+    }
+
+
+def _import_segy_incomplete_traces(segyfile: segyio.segy.SegyFile) -> dict:
+    """Import a a cube SEGY with incomplete traces via the SegyIO library.
+
+    Note that the undefined value will be xtgeo.UNDEF (large number)!
+
+    It is also logical to treat missing traces as dead traces, i.e. the should
+    get value 2 in traceidcodes
+
+    Args:
+        segyfile: Filehandle from segyio
+    """
+    segyfile.mmap()
+    # get data (which will need padding later for missing traces)
+    data = segyfile.trace.raw[:]
+
+    trcode = segyio.TraceField.TraceIdentificationCode
+    traceidcodes_input = segyfile.attributes(trcode)[:]
+
+    ilines_case = np.array([h[TF.INLINE_3D] for h in segyfile.header])
+    xlines_case = np.array([h[TF.CROSSLINE_3D] for h in segyfile.header])
+
+    # detect minimum inline and xline spacing (e.g.sampling could be every second)
+    idiff = np.diff(ilines_case)
+    xdiff = np.diff(xlines_case)
+    ispacing = int(np.abs(idiff[idiff != 0]).min())
+    xspacing = int(np.abs(xdiff[xdiff != 0]).min())
+
+    ncol = int(abs(ilines_case.min() - ilines_case.max()) / ispacing) + 1
+    nrow = int(abs(xlines_case.min() - xlines_case.max()) / xspacing) + 1
+    nlay = data.shape[1]
+
+    values = np.full((ncol, nrow, nlay), UNDEF, dtype=np.float32)
+    traceidcodes = np.full((ncol, nrow), 2, dtype=np.int64)
+
+    ilines_shifted = (ilines_case / ispacing).astype(np.int64)
+    ilines_shifted -= ilines_shifted.min()
+    xlines_shifted = (xlines_case / xspacing).astype(np.int64)
+    xlines_shifted -= xlines_shifted.min()
+
+    values[ilines_shifted, xlines_shifted, :] = data
+    values = _process_cube_values(values)
+    traceidcodes[ilines_shifted, xlines_shifted] = traceidcodes_input
+
+    # generate new ilines, xlines vector with unique values
+    ilines = np.array(
+        range(ilines_case.min(), ilines_case.max() + ispacing, ispacing), dtype=np.int32
+    )
+    xlines = np.array(
+        range(xlines_case.min(), xlines_case.max() + xspacing, xspacing), dtype=np.int32
+    )
+
+    attrs = _geometry_incomplete_traces(
+        segyfile,
+        ncol,
+        nrow,
+        ilines,
+        xlines,
+        ilines_case,
+        xlines_case,
+        ispacing,
+        xspacing,
+    )
+
+    attrs["ncol"] = ncol
+    attrs["nrow"] = nrow
+    attrs["nlay"] = nlay
+    attrs["ilines"] = ilines
+    attrs["xlines"] = xlines
+    attrs["values"] = values
+    attrs["traceidcodes"] = traceidcodes
+    return attrs
+
+
+def _inverse_anyline_map(anylines: list[int]) -> dict:
+    """Small helper function to get e.g. inline 2345: [0, 1, 2, .., 70].
+
+    I.e. to get a mapping between inline number and a list of possible indices
+
+    """
+    anyll = defaultdict(list)
+    for ind, key in enumerate(anylines):
+        anyll[key].append(ind)
+
+    return anyll
+
+
+def _find_long_line(anyll: dict, nany: int) -> list:
+    """Helper function; get index of vectors indices to be used for calculations.
+
+    Look for a "sufficiently" long inline/xline, as long distance between points
+    increases accuracy.
+
+    """
+    minimumlen = int(nany * 0.8)  # get at least 80% length if possible
+    maxlenfound = -1
+
+    keepresult = []
+    for indices in anyll.values():
+        result = [indices[0], indices[-1]]
+        indlen = len(indices)
+        if indlen > maxlenfound:
+            maxlenfound = indlen
+            keepresult = deepcopy(result)
+
+        if indlen >= minimumlen:
+            break
+
+    if not keepresult or abs(keepresult[1] - keepresult[0]) == 0:
+        raise RuntimeError("Not able to get inline or xline vector for geometry")
+    return keepresult
+
+
+def _geometry_incomplete_traces(
+    segyfile: segyio.segy.SegyFile,
+    ncol: int,
+    nrow: int,
+    ilines: list[int],
+    xlines: list[int],
+    ilines_case: list[int],
+    xlines_case: list[int],
+    ispacing: int,
+    xspacing: int,
+) -> list:
+    """Compute xtgeo attributes (mostly geometries) for incomplete trace cube."""
+    attrs = {}
+
+    ill = _inverse_anyline_map(ilines_case)
+    xll = _inverse_anyline_map(xlines_case)
+
+    # need both partial and full reverse lookup of indices vs (iline, xxline)
+    # for computing cube origin later
+    index_case = {
+        ind: (h[TF.INLINE_3D], h[TF.CROSSLINE_3D])
+        for ind, h in enumerate(segyfile.header)
+    }
+
+    reverseindex_full = {
+        (il, xl): (ind, xnd)
+        for ind, il in enumerate(ilines)
+        for xnd, xl in enumerate(xlines)
+    }
+
+    jnd1, jnd2 = _find_long_line(ill, ncol)  # 2 indices along constant iline, aka JY
+    ind1, ind2 = _find_long_line(xll, nrow)  # 2 indices along constant xline, aka IX
+
+    il1x, il1y, zori, zinc = _get_coordinate(segyfile, ind1)
+    il2x, il2y, _, _ = _get_coordinate(segyfile, ind2)
+
+    jl1x, jl1y, _, _ = _get_coordinate(segyfile, jnd1)
+    jl2x, jl2y, _, _ = _get_coordinate(segyfile, jnd2)
+
+    xslen, _, rot1 = calc.vectorinfo2(il1x, il2x, il1y, il2y)
+    xinc = ispacing * xslen / (abs(ilines_case[ind1] - ilines_case[ind2]))
+    yslen, _, _ = calc.vectorinfo2(jl1x, jl2x, jl1y, jl2y)
+    yinc = xspacing * yslen / (abs(xlines_case[jnd1] - xlines_case[jnd2]))
+
+    yflip = calc.find_flip((il2x - il1x, il2y - il1y, 0), (jl2x - jl1x, jl2y - jl1y, 0))
+
+    # need to compute xori and yori from 'case' I J indices with known x y and
+    # (iline, xline); use ind1 with assosiated coordinates il1x il1y
+    i_use, j_use = reverseindex_full[index_case[ind1]]
+    xori, yori = calc.xyori_from_ij(
+        i_use, j_use, il1x, il1y, xinc, yinc, ncol, nrow, yflip, rot1
+    )
+
+    attrs["xori"] = xori
+    attrs["yori"] = yori
+    attrs["zori"] = zori
+    attrs["xinc"] = xinc
+    attrs["yinc"] = yinc
+    attrs["zinc"] = zinc
+    attrs["yflip"] = yflip
+    attrs["rotation"] = rot1
+
+    return attrs
+
+
+def _get_coordinate(
+    segyfile: segyio.segy.SegyFile, segyindex: int
+) -> tuple[float, float, float, float]:
+    """Helper function to get coordinates given a index."""
+    origin = segyfile.header[segyindex][
+        segyio.su.cdpx,
+        segyio.su.cdpy,
+        segyio.su.scalco,
+        segyio.su.delrt,
+        segyio.su.dt,
+        segyio.su.iline,
+        segyio.su.xline,
+    ]
+
+    point_x = origin[segyio.su.cdpx]
+    point_y = origin[segyio.su.cdpy]
+    scaler = origin[segyio.su.scalco]
+    if scaler < 0:
+        point_x = -1 * float(point_x) / scaler
+        point_y = -1 * float(point_y) / scaler
+    else:
+        point_x = point_x * scaler
+        point_y = point_y * scaler
+
+    zori = origin[segyio.su.delrt]
+    zinc = origin[segyio.su.dt] / 1000.0
+
+    return point_x, point_y, zori, zinc
+
+
+def import_stormcube(
+    sfile: FileWrapper,
+) -> dict:
+    """Import on StormCube format."""
+    # The ASCII header has all the metadata on the form:
+    # ---------------------------------------------------------------------
+    # storm_petro_binary       // always
+    #
+    # 0 ModelFile -999 // zonenumber, source_of_file,  undef_value
+    #
+    # UNKNOWN // name_of_parameter?
+    #
+    # 452638.45298827 6262.499 6780706.6462283 10762.4999 1800 2500 0 0
+    # 700 -0.80039470880765
+    #
+    # 501 861 140
+    # ---------------------------------------------------------------------
+    # The rest is float32 binary data, I (column fastest), then J, then K
+    # a total of ncol * nrow * nlay
+
+    # Scan the header with Python; then use CLIB for the binary data
+    sfile = str(sfile.file)
+    with open(sfile, "rb") as stf:
+        iline = 0
+
+        ncol = nrow = nlay = nlines = 1
+        xori = yori = zori = xinc = yinc = rotation = rot = 0.999
+        xlen = ylen = zlen = 0.999
+
+        for line in range(10):
+            xline = stf.readline()
+            if not xline.strip():
+                continue
+
+            iline += 1
+            if iline == 1:
+                pass
+            elif iline == 2:
+                _, _, _ = xline.strip().split()
+            elif iline == 3:
+                pass
+            elif iline == 4:
+                (xori, xlen, yori, ylen, zori, _, _, _) = xline.strip().split()
+            elif iline == 5:
+                zlen, rot = xline.strip().split()
+            elif iline == 6:
+                ncol, nrow, nlay = xline.strip().split()
+                nlines = line + 2
+                break
+
+    ncol = int(ncol)
+    nrow = int(nrow)
+    nlay = int(nlay)
+    nrcl = ncol * nrow * nlay
+
+    xori = float(xori)
+    yori = float(yori)
+    zori = float(zori)
+
+    rotation = float(rot)
+    if rotation < 0:
+        rotation += 360
+
+    xinc = float(xlen) / ncol
+    yinc = float(ylen) / nrow
+    zinc = float(zlen) / nlay
+
+    yflip = 1
+
+    if yinc < 0:
+        yflip = -1
+        yinc = yinc * yflip  # not sure if this will ever happen
+
+    ier, values = _cxtgeo.cube_import_storm(ncol, nrow, nlay, sfile, nlines, nrcl, 0)
+
+    if ier != 0:
+        raise RuntimeError(f"Something went wrong in {__name__}, code is {ier}")
+
+    return {
+        "ncol": ncol,
+        "nrow": nrow,
+        "nlay": nlay,
+        "xori": xori,
+        "xinc": xinc,
+        "yori": yori,
+        "yinc": yinc,
+        "zori": zori,
+        "zinc": zinc,
+        "rotation": rotation,
+        "values": values.reshape((ncol, nrow, nlay)),
+        "yflip": yflip,
+    }
+
+
+def import_xtgregcube(mfile, values=True):
+    """Using pure python for experimental cube import, xtgregsurf format."""
+    logger.info("Importing cube on xtgregcube format...")
+
+    offset = 36
+    with open(mfile.file, "rb") as fhandle:
+        buf = fhandle.read(offset)
+
+    # unpack header
+    swap, magic, nfloat, ncol, nrow, nlay = unpack("= i i i q q q", buf)
+
+    if swap != 1 or magic != 1201:
+        raise ValueError("Invalid file format (wrong swap id or magic number).")
+
+    dtype = np.float32 if nfloat == 4 else np.float64
+
+    vals = None
+    narr = ncol * nrow * nlay
+
+    if values:
+        vals = xsys.npfromfile(mfile.file, dtype=dtype, count=narr, offset=offset)
+
+    # read metadata which will be at position offet + nfloat*narr +13
+    pos = offset + nfloat * narr + 13
+
+    with open(mfile.file, "rb") as fhandle:
+        fhandle.seek(pos)
+        jmeta = fhandle.read().decode()
+
+    meta = json.loads(jmeta, object_pairs_hook=dict)
+    req = meta["_required_"]
+
+    reqattrs = MetaDataRegularCube.REQUIRED
+
+    results = {myattr: req[myattr] for myattr in reqattrs}
+
+    # For backwards compatability, xtgeo outputs files with the undef field set
+    # although we do not support initializing with any other value.
+    # As xtgeo-format is only written/read by xtgeo as far as we know, this should
+    # be unproblematic for now.
+    if results.pop("undef", None) != UNDEF:
+        raise ValueError(
+            f"File {mfile.file} has non-standard undef, not supported by xtgeo"
+        )
+
+    # TODO: dead traces and traceidcodes
+    if values:
+        results["values"] = vals.reshape(
+            results["ncol"], results["nrow"], results["nlay"]
+        )
+
+    return results

xtgeo/cube/_cube_roxapi.py

@@ -0,0 +1,180 @@
+# coding: utf-8
+"""Roxar API functions for XTGeo Cube
+
+Note on rotation:
+
+xtgeo uses rotation of "columns" whick is xline direction counterclockwise
+measured from X axis.
+
+roxarapi uses rotation of inline direction (rows) relative to Y axis.
+api < 1.4: counterclockwise "rotation"
+api >= 1.4 clockwise "orientation"
+
+Seems like self._rotation == roxar.orientation * -1 anyway @ reverse engineering/testing
+
+"""
+
+import numpy as np
+
+from xtgeo.common import XTGeoDialog, null_logger
+from xtgeo.roxutils import RoxUtils
+from xtgeo.roxutils._roxar_loader import roxar
+
+xtg = XTGeoDialog()
+
+logger = null_logger(__name__)
+
+
+def import_cube_roxapi(self, project, name, folder=None):  # pragma: no cover
+    """Import (transfer) a Cube via ROXAR API container to XTGeo.
+
+    .. versionadded:: 2.1
+    """
+    rox = RoxUtils(project, readonly=True)
+
+    proj = rox.project
+
+    _roxapi_import_cube(self, rox, proj, name, folder)
+
+
+def _roxapi_import_cube(self, rox, proj, name, folder):  # pragma: no cover
+    """Short summary.
+
+    Args:
+        proj (object): RMS magic project.
+        name (str): Name of cube.
+        folder (str): Cube folder in RMS.
+
+    """
+    # note that name must be in brackets
+    path = [name]
+    if folder is not None:
+        fld = folder.split("/")
+        path = fld + path
+
+    if path not in proj.seismic.data:
+        raise ValueError(f"Path {path} is not within RMS Seismic Cube container")
+    try:
+        rcube = proj.seismic.data[path]
+        _roxapi_cube_to_xtgeo(self, rox, rcube)
+    except KeyError as emsg:
+        logger.error(emsg)
+        raise
+
+
+def _roxapi_cube_to_xtgeo(self, rox, rcube):  # pragma: no cover
+    """Tranforming cube from ROXAPI to XTGeo object."""
+    logger.info("Cube from roxapi to xtgeo...")
+
+    # roxrotation is cube rotation clockwise from azimuth but not consistent
+    roxrotation = rcube.orientation
+
+    roxhandedness = str(rcube.handedness)
+
+    self._xori, self._yori = rcube.origin
+    self._zori = rcube.first_z
+    self._zinc = rcube.sample_rate
+    self._ncol, self._nrow, self._nlay = rcube.dimensions
+    self._xinc, self._yinc = rcube.increment
+
+    self._rotation = roxrotation * -1
+
+    if self._rotation < 0:
+        self._rotation += 360
+    elif self._rotation > 360:
+        self._rotation -= 360
+
+    self._yflip = 1
+    if roxhandedness == "right":
+        self._yflip = -1
+
+    il_start = rcube.get_inline(0)
+    xl_start = rcube.get_crossline(0)
+    il_incr, xl_incr = rcube.inline_crossline_increment
+    il_end = (self._ncol) * il_incr + il_start
+    xl_end = (self._nrow) * xl_incr + xl_start
+
+    self._ilines = np.array(range(il_start, il_end, il_incr), dtype=np.int32)
+    self._xlines = np.array(range(xl_start, xl_end, xl_incr), dtype=np.int32)
+
+    # roxar API does not store traceid codes, assume 1
+    self._traceidcodes = np.ones((self._ncol, self._nrow), dtype=np.int32)
+
+    if rcube.is_empty:
+        xtg.warn("Cube has no data; assume 0")
+    else:
+        self.values = rcube.get_values()
+
+
+def export_cube_roxapi(
+    self, project, name, folder=None, domain="time", compression=("wavelet", 5)
+):  # pragma: no cover
+    """Export (store) a Seismic cube to RMS via ROXAR API spec."""
+    rox = RoxUtils(project, readonly=False)
+
+    logger.debug("TODO: compression %s", compression)
+
+    _roxapi_export_cube(
+        self,
+        rox.project,
+        rox,
+        name,
+        folder=folder,
+        domain=domain,
+        compression=compression,
+    )
+
+    if rox._roxexternal:
+        rox.project.save()
+
+    rox.safe_close()
+
+
+def _roxapi_export_cube(
+    self, proj, rox, name, folder=None, domain="time", compression=("wavelet", 5)
+):  # type: ignore # pragma: no cover
+    logger.info(
+        "There are issues with compression %s, hence it is ignored", compression
+    )
+
+    path = []
+    if folder is not None:
+        fld = folder.split("/")
+        path = fld + path
+
+    rcube = proj.seismic.data.create_cube(name, path=path)
+
+    # populate
+    origin = (float(self.xori), float(self.yori))
+    first_z = self.zori
+    increment = (self.xinc, self.yinc)
+    sample_rate = self.zinc
+    rotation = self.rotation
+    vertical_domain = roxar.VerticalDomain.time
+    if domain == "depth":
+        vertical_domain = roxar.VerticalDomain.depth
+
+    values = self.values.copy()  # copy() needed?
+
+    handedness = roxar.Direction.left
+    if self.yflip == -1:
+        handedness = roxar.Direction.right
+
+    # inline xline vector
+    ilstart = self.ilines[0]
+    xlstart = self.xlines[0]
+    ilincr = self.ilines[1] - self.ilines[0]
+    xlincr = self.xlines[1] - self.xlines[0]
+
+    rcube.set_seismic(
+        values,
+        origin,
+        increment,
+        first_z,
+        sample_rate,
+        rotation * -1,
+        vertical_domain=vertical_domain,
+        handedness=handedness,
+        inline_crossline_start=(ilstart, xlstart),
+        inline_crossline_increment=(ilincr, xlincr),
+    )