seisvtk 0.1.0__py3-none-any.whl

seisvtk/io/__init__.py

@@ -0,0 +1 @@
+    

seisvtk/io/browse.py

@@ -0,0 +1,128 @@
+"""Server-side directory listing for the viewer's file-picker popup.
+
+The trame viewer renders where the data lives, so files are chosen by browsing
+the *server's* filesystem (its own disk when run locally), not by uploading from
+the browser — which only yields bytes, never a path, and cannot handle multi-GB
+cubes. :func:`browse` turns a directory into a sorted, typed entry list the popup
+renders; it is pure and unit-tested, with the trame dialog kept in the app layer.
+"""
+from __future__ import annotations
+
+import os
+import string
+
+# A Zarr "file" is really a directory; treat ``*.zarr`` as a selectable store
+# rather than a folder to descend into.
+STORE_SUFFIXES = (".zarr",)
+
+_ICON = {"up": "mdi-arrow-up-left", "drive": "mdi-harddisk",
+         "dir": "mdi-folder", "store": "mdi-database", "file": "mdi-file-outline"}
+# Vuetify theme colours, so the list reads at a glance (folders warm, data cool).
+_COLOR = {"up": "grey", "drive": "blue-grey", "dir": "amber-darken-1",
+          "store": "blue", "file": "blue-grey-lighten-1"}
+
+
+def _entry(name, path, kind):
+    return {"name": name, "path": path, "type": kind,
+            "icon": _ICON[kind], "color": _COLOR[kind]}
+
+
+def _crumbs(path: str) -> list[dict]:
+    """Breadcrumb trail for *path*: ``[{label, path}]`` from "This PC" down."""
+    crumbs = [{"label": "This PC", "path": ""}]
+    if not path:
+        return crumbs
+    path = os.path.abspath(path)
+    drive, tail = os.path.splitdrive(path)
+    if drive:
+        acc = drive + os.sep
+        crumbs.append({"label": drive, "path": acc})
+    else:
+        acc = os.sep
+        crumbs.append({"label": "/", "path": acc})
+    for part in [p for p in tail.split(os.sep) if p]:
+        acc = os.path.join(acc, part)
+        crumbs.append({"label": part, "path": acc})
+    return crumbs
+
+
+def list_drives() -> list[str]:
+    """Mounted Windows drive roots (``['C:\\\\', 'D:\\\\', ...]``); ``[]`` off Windows.
+
+    Uses the ``GetLogicalDrives`` bitmask, which reports assigned drive letters
+    instantly without spinning up removable media — probing ``A:\\`` or an empty
+    optical drive with ``os.path.exists`` can block for tens of seconds.
+    """
+    if os.name != "nt":
+        return []
+    import ctypes
+
+    bitmask = ctypes.windll.kernel32.GetLogicalDrives()
+    return [f"{string.ascii_uppercase[i]}:\\" for i in range(26) if bitmask & (1 << i)]
+
+
+def _is_drive_root(path: str) -> bool:
+    drive, tail = os.path.splitdrive(os.path.abspath(path))
+    return bool(drive) and tail in ("", os.sep, "/")
+
+
+def _parent(path: str) -> str | None:
+    """The directory above *path*; ``""`` at a drive root (→ drive list), None at top."""
+    if _is_drive_root(path):
+        return ""                                   # one level up from C:\ is "pick a drive"
+    up = os.path.dirname(os.path.abspath(path).rstrip("\\/"))
+    return up or None
+
+
+def _drives_view() -> dict:
+    """The top level: a row per drive (Windows) or root (POSIX)."""
+    roots = list_drives() or ["/"]
+    entries = [_entry(r, r, "drive") for r in roots]
+    return {"cwd": "", "parent": None, "entries": entries, "crumbs": _crumbs("")}
+
+
+def browse(path: str | None, *, exts=None) -> dict:
+    """List *path* for the picker: ``{cwd, parent, entries}``.
+
+    Each entry is ``{name, path, type, icon}`` with ``type`` one of ``up`` (the
+    parent row), ``dir`` (navigable folder), ``store`` (a selectable ``*.zarr``),
+    or ``file`` (selectable). Files are kept only if their extension is in ``exts``
+    (lowercase, dotted, e.g. ``{'.segy', '.sgy'}``); ``None`` keeps all. Folders
+    are always listed so the user can navigate. Hidden/system entries and
+    unreadable children are skipped rather than raising. An empty/None *path*
+    yields the drive list.
+    """
+    if not path:
+        return _drives_view()
+    path = os.path.abspath(path)
+    entries: list[dict] = []
+    parent = _parent(path)
+    if parent is not None:
+        entries.append(_entry("..", parent, "up"))
+
+    try:
+        children = list(os.scandir(path))
+    except OSError:                                  # permission denied, gone, etc.
+        children = []
+
+    dirs, stores, files = [], [], []
+    exts = {e.lower() for e in exts} if exts else None
+    for e in children:
+        name = e.name
+        if name.startswith(".") or name.startswith("$"):
+            continue
+        try:
+            is_dir = e.is_dir()
+        except OSError:
+            continue
+        if is_dir:
+            if name.lower().endswith(STORE_SUFFIXES):
+                stores.append(_entry(name, e.path, "store"))
+            else:
+                dirs.append(_entry(name, e.path, "dir"))
+        elif exts is None or os.path.splitext(name)[1].lower() in exts:
+            files.append(_entry(name, e.path, "file"))
+
+    key = lambda d: d["name"].lower()
+    entries += sorted(dirs, key=key) + sorted(stores, key=key) + sorted(files, key=key)
+    return {"cwd": path, "parent": parent, "entries": entries, "crumbs": _crumbs(path)}

seisvtk/io/convert_segy.py

@@ -0,0 +1,67 @@
+from seisvtk.io.segy_scan import detect_geometry, open_auto
+import argparse
+import os
+from pathlib import Path
+
+#Logging
+import logging  
+import sys
+import segyio
+import zarr
+from seisvtk.io.logging_config import setup_logging
+from seisvtk.io.segy2zarr import convert_segy_to_zarr
+
+#Find relative path for output files
+REPO_PATH = Path(__file__).resolve().parents[2]
+output_folder=REPO_PATH / "Testing" / "Output"
+
+
+
+def main():
+
+    
+    #Logger setup
+    logger = logging.getLogger(__spec__.name if __spec__ else __name__)
+    setup_logging()
+
+    #Argument Parser (Setup sys.argv to receive script arguments)
+    parser = argparse.ArgumentParser(description="Tool to automatically convert a SEGY to optimized format")
+    parser.add_argument('filepath', help="Full file path to .segy file")
+    parser.add_argument('-o','--out',help="Full output path for converted file")
+
+    parser.add_argument('--auto', action='store_true', help='Autmatically scan SEGY for header information and geometry')
+
+    parser.add_argument('--iline', type=int, help='Byte location for INLINE values in traces')
+    parser.add_argument('--xline', type=int, help='Byte location for CROSSLINE values in traces')
+
+    #Parse sys.argv
+    args = parser.parse_args()
+
+    #Normalizing output path 
+    out = os.path.join(output_folder,args.out+'.zarr')
+
+    #Automatically scan SEGY for geometry
+    # Resolve iline/xline bytes from either --auto or the manual flags.
+    if args.auto:
+        geom = detect_geometry(args.filepath)
+        logger.info(f'Scanned SEGY Geometry: {geom}')
+        iline, xline = geom["iline_byte"], geom["xline_byte"]
+    elif args.iline is not None and args.xline is not None:
+        iline, xline = args.iline, args.xline
+        logger.info(f'Using ILINE:{iline} XLINE:{xline} byte locations')
+    else:
+        parser.error('--iline and --xline are required when --auto is not set.')
+
+
+    convert_segy_to_zarr(args.filepath, iline, xline, out, logger=logger)
+
+
+
+
+if __name__ == '__main__':
+    main()
+
+
+
+
+

seisvtk/io/deviation.py

@@ -0,0 +1,131 @@
+"""Well deviation surveys: turn a trajectory file into XY/TVD along the hole.
+
+A well is rarely a clean vertical line; to drape it on a cube we need the
+horizontal position at every logged depth. Surveys come in two shapes:
+
+* **Directional** — ``(MD, inclination, azimuth)``. The classic minimum-curvature
+  method (:func:`minimum_curvature`) integrates these angle stations into
+  east/north/TVD offsets from the wellhead. This is the industry-standard
+  survey-to-position calculation.
+* **XYZ** — ``(MD, X, Y, Z)`` positions already computed by the acquisition
+  software; read straight through.
+
+Both land in a :class:`Deviation`: measured depth plus east/north offsets from
+the first station and true vertical depth, which :mod:`seisvtk.io.well` combines
+with a wellhead ``(X, Y)`` and a time-depth relation to place the log.
+"""
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+import numpy as np
+
+from seisvtk.io.tables import pick_column, read_table, to_float
+
+
+@dataclass
+class Deviation:
+    """A trajectory sampled on measured depth.
+
+    ``east``/``north`` are horizontal offsets from the first station (metres in
+    the survey's own units); ``tvd`` is true vertical depth below it. Add the
+    wellhead ``(X, Y)`` to ``east``/``north`` for absolute position.
+    """
+
+    md: np.ndarray
+    east: np.ndarray
+    north: np.ndarray
+    tvd: np.ndarray
+
+    def at(self, md) -> tuple[np.ndarray, np.ndarray, np.ndarray]:
+        """``(east, north, tvd)`` offsets at measured depths ``md``.
+
+        Linear within the surveyed interval and *linearly extrapolated* along the
+        end tangents outside it (not clamped): a log sample above the first
+        station continues up the opening trajectory — vertical for a survey that
+        starts vertical — and one below the last station continues down the final
+        tangent, rather than freezing horizontally at the last station.
+        """
+        md = np.asarray(md, float)
+        return (self._interp(md, self.east),
+                self._interp(md, self.north),
+                self._interp(md, self.tvd))
+
+    def _interp(self, md, vals) -> np.ndarray:
+        t = np.interp(md, self.md, vals)
+        if self.md.size >= 2:                                  # extend the end tangents
+            s0 = (vals[1] - vals[0]) / (self.md[1] - self.md[0])
+            s1 = (vals[-1] - vals[-2]) / (self.md[-1] - self.md[-2])
+            t = np.where(md < self.md[0], vals[0] + s0 * (md - self.md[0]), t)
+            t = np.where(md > self.md[-1], vals[-1] + s1 * (md - self.md[-1]), t)
+        return t
+
+
+def minimum_curvature(md, inc_deg, azi_deg) -> Deviation:
+    """Minimum-curvature trajectory from angle stations.
+
+    ``inc_deg`` is inclination from vertical (0 = straight down) and ``azi_deg``
+    is azimuth clockwise from north, both in degrees. Returns cumulative
+    east/north/TVD offsets from the first station (which sits at the origin).
+    """
+    md = np.asarray(md, float)
+    inc = np.radians(np.asarray(inc_deg, float))
+    azi = np.radians(np.asarray(azi_deg, float))
+    n = md.size
+    east = np.zeros(n)
+    north = np.zeros(n)
+    tvd = np.zeros(n)
+
+    for i in range(1, n):
+        dmd = md[i] - md[i - 1]
+        i1, i2 = inc[i - 1], inc[i]
+        a1, a2 = azi[i - 1], azi[i]
+        # dogleg angle between the two station directions
+        cos_dl = np.cos(i2 - i1) - np.sin(i1) * np.sin(i2) * (1.0 - np.cos(a2 - a1))
+        dl = np.arccos(np.clip(cos_dl, -1.0, 1.0))
+        rf = 1.0 if dl < 1e-9 else (2.0 / dl) * np.tan(dl / 2.0)  # ratio factor
+        half = dmd / 2.0 * rf
+        north[i] = north[i - 1] + half * (np.sin(i1) * np.cos(a1) + np.sin(i2) * np.cos(a2))
+        east[i] = east[i - 1] + half * (np.sin(i1) * np.sin(a1) + np.sin(i2) * np.sin(a2))
+        tvd[i] = tvd[i - 1] + half * (np.cos(i1) + np.cos(i2))
+
+    return Deviation(md, east, north, tvd)
+
+
+def read_deviation(path: str, *, kind: str = "directional",
+                   cols: tuple[int, ...] | None = None,
+                   delimiter: str | None = None) -> Deviation:
+    """Read a deviation survey file into a :class:`Deviation`.
+
+    ``kind="directional"`` expects ``(MD, inc, azi)`` columns (default columns
+    1,2,3); ``kind="xyz"`` expects ``(MD, X, Y, Z)`` (default 1,2,3,4) and the
+    XY are stored as offsets from the first row so the model stays wellhead-
+    relative. ``cols`` overrides the 1-based column numbers; ``delimiter`` is
+    sniffed when ``None``. Rows with a non-finite value are dropped and the
+    survey is sorted by measured depth, since minimum-curvature accumulates down
+    the hole and :meth:`Deviation.at` needs ``md`` ascending.
+    """
+    df = read_table(path, delimiter=delimiter)
+
+    if kind == "directional":
+        c = cols or (1, 2, 3)
+        md, (inc, azi) = _clean_survey(df, c[0], (c[1], c[2]))
+        return minimum_curvature(md, inc, azi)
+
+    if kind == "xyz":
+        c = cols or (1, 2, 3, 4)
+        md, (x, y, z) = _clean_survey(df, c[0], (c[1], c[2], c[3]))
+        return Deviation(md, x - x[0], y - y[0], z - z[0])
+
+    raise ValueError(f"kind must be 'directional' or 'xyz', got {kind!r}")
+
+
+def _clean_survey(df, md_col, value_cols):
+    """Pull MD + value columns, drop non-finite rows, sort ascending by MD."""
+    md = to_float(df[pick_column(df, md_col)])
+    values = [to_float(df[pick_column(df, c)]) for c in value_cols]
+    good = np.isfinite(md)
+    for v in values:
+        good &= np.isfinite(v)
+    order = np.argsort(md[good], kind="stable")
+    return md[good][order], tuple(v[good][order] for v in values)

seisvtk/io/horizon.py

@@ -0,0 +1,157 @@
+"""Interpreted horizon surfaces: read common export formats into one model.
+
+A :class:`Horizon` is a set of interpreted picks in *survey coordinates* —
+``(inline, crossline, z)`` where ``z`` is the vertical value in the cube's unit
+(two-way time in ms, or depth). It is deliberately scene-independent: the same
+horizon drapes onto any cube that shares the survey, and the viewer converts
+line numbers to array indices when it builds the surface actor.
+
+Readers cover the usual interpretation exports:
+
+* :func:`read_horizon_xyz` — ``X Y Z`` world coordinates (no line numbers); needs
+  a :class:`~seisvtk.io.survey.GridTransform` to invert world -> grid. This is
+  the OpendTect / Petrel "XYZ" point export (e.g. the F3 horizons).
+* :func:`read_horizon_ilxl` — columns that already include inline/crossline.
+* :meth:`Horizon.from_arrays` — build directly from arrays, for a host app that
+  reads its own internal horizon type (map it to ``il/xl/z`` and hand it over).
+"""
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+import numpy as np
+
+from seisvtk.io.survey import GridTransform
+from seisvtk.io.tables import read_table, to_float
+
+# Common "no value" sentinels in interpretation exports.
+NULLS = (-999.25, 999.25, 1.0e30, -1.0e30)
+
+
+@dataclass
+class Horizon:
+    """Interpreted picks on a survey grid: parallel ``il``, ``xl``, ``z`` arrays."""
+
+    name: str
+    il: np.ndarray  # inline line numbers (int)
+    xl: np.ndarray  # crossline line numbers (int)
+    z: np.ndarray   # vertical value (ms or m), same units as the cube's z axis
+
+    @classmethod
+    def from_arrays(cls, name, il, xl, z) -> "Horizon":
+        il = np.asarray(il).astype(np.int64)
+        xl = np.asarray(xl).astype(np.int64)
+        z = np.asarray(z).astype(float)
+        keep = np.isfinite(z) & ~np.isin(z, NULLS)
+        return cls(name, il[keep], xl[keep], z[keep])
+
+    def to_grid(self):
+        """Scatter the picks onto their ``(inline, crossline)`` lattice.
+
+        Returns ``(il_axis, xl_axis, Z)`` where ``il_axis`` / ``xl_axis`` are the
+        sorted unique line numbers and ``Z`` is a ``(n_il, n_xl)`` array of ``z``
+        with ``NaN`` in cells that were never picked (the surface's holes).
+        """
+        iu = np.unique(self.il)
+        xu = np.unique(self.xl)
+        Z = np.full((iu.size, xu.size), np.nan, dtype=float)
+        Z[np.searchsorted(iu, self.il), np.searchsorted(xu, self.xl)] = self.z
+        return iu, xu, Z
+
+    @property
+    def z_range(self) -> tuple[float, float]:
+        return float(np.nanmin(self.z)), float(np.nanmax(self.z))
+
+
+def _load_columns(path: str, cols: tuple[int, ...], *,
+                  delimiter: str | None = None) -> np.ndarray:
+    """Read numeric columns ``cols`` (0-based) as a float array, in that order.
+
+    Any delimiter (comma/tab/semicolon/whitespace) is sniffed, and a header row,
+    comment lines and null sentinels are handled by :mod:`seisvtk.io.tables`.
+    """
+    df = read_table(path, delimiter=delimiter)
+    return np.column_stack([to_float(df.iloc[:, c]) for c in cols])
+
+
+def read_horizon_xyz(path: str, transform: GridTransform, *,
+                     name: str | None = None,
+                     cols: tuple[int, int, int] = (0, 1, 2),
+                     z_scale: float = 1.0,
+                     delimiter: str | None = None) -> Horizon:
+    """Read an ``X Y Z`` world-coordinate horizon, inverting ``transform`` to grid.
+
+    ``z_scale`` converts the file's vertical unit to the cube's (e.g. ``1000`` for
+    a seconds export against a millisecond cube). Line numbers are rounded to the
+    nearest bin. ``delimiter`` is sniffed when ``None``.
+    """
+    data = _load_columns(path, cols, delimiter=delimiter)
+    x, y, z = data[:, 0], data[:, 1], data[:, 2] * z_scale
+    il_f, xl_f = transform.world_to_grid(x, y)
+    il = np.rint(il_f).astype(np.int64)
+    xl = np.rint(xl_f).astype(np.int64)
+    return Horizon.from_arrays(name or _stem(path), il, xl, z)
+
+
+def read_horizon_ilxl(path: str, *,
+                      name: str | None = None,
+                      cols: tuple[int, int, int] = (0, 1, 2),
+                      z_scale: float = 1.0,
+                      delimiter: str | None = None) -> Horizon:
+    """Read a horizon whose columns already carry inline/crossline.
+
+    ``cols`` selects ``(inline, crossline, z)`` column indices (0-based); the
+    default suits an ``IL XL Z`` file, and e.g. ``cols=(2, 3, 4)`` an
+    ``X Y IL XL Z`` Petrel/Kingdom grid. ``delimiter`` is sniffed when ``None``.
+    """
+    data = _load_columns(path, cols, delimiter=delimiter)
+    return Horizon.from_arrays(name or _stem(path),
+                               data[:, 0], data[:, 1], data[:, 2] * z_scale)
+
+
+def read_horizon_rows(path: str, *, cols: tuple[int, int, int, int] = (0, 1, 2, 3),
+                      z_scale: float = 1.0,
+                      delimiter: str | None = None) -> list[Horizon]:
+    """Read a ``Name  IL  XL  Z`` file holding one or more horizons.
+
+    ``cols`` is the 0-based ``(name, inline, crossline, z)`` columns. Rows are
+    grouped by the name column, so a single file can carry several horizons;
+    returns one :class:`Horizon` per distinct name, in first-seen order.
+    """
+    df = read_table(path, delimiter=delimiter)
+    name_c, il_c, xl_c, z_c = (df.columns[c] for c in cols)
+    il = to_float(df[il_c])
+    xl = to_float(df[xl_c])
+    z = to_float(df[z_c]) * z_scale
+    names = df[name_c].astype(str).to_numpy()
+    out = []
+    for nm in dict.fromkeys(names):              # distinct, first-seen order
+        m = names == nm
+        out.append(Horizon.from_arrays(nm.strip(), il[m], xl[m], z[m]))
+    return out
+
+
+def read_horizon_columns(path: str, *, il_col: int = 0, xl_col: int = 1,
+                         z_scale: float = 1.0,
+                         delimiter: str | None = None) -> list[Horizon]:
+    """Read an ``IL  XL  H1  H2  ...`` file: one horizon per Z column.
+
+    Needs a header row naming the horizon columns; ``il_col``/``xl_col`` are the
+    0-based inline/crossline columns and every *other* column is a horizon whose
+    name is its header. Cells holding a null become holes in that surface.
+    """
+    df = read_table(path, header=True, delimiter=delimiter)
+    il = to_float(df.iloc[:, il_col])
+    xl = to_float(df.iloc[:, xl_col])
+    out = []
+    for j, col in enumerate(df.columns):
+        if j in (il_col, xl_col):
+            continue
+        out.append(Horizon.from_arrays(str(col).strip(), il, xl,
+                                       to_float(df[col]) * z_scale))
+    return out
+
+
+def _stem(path: str) -> str:
+    import os
+    return os.path.splitext(os.path.basename(path))[0]

seisvtk/io/ingest.py

@@ -0,0 +1,188 @@
+"""Generic volume -> chunked Zarr ingest, shared by every input format.
+
+``convert_segy_to_zarr`` (ragged SEG-Y traces) and any other source — a dense
+numpy cube, an HDF5 dataset, a property volume produced by a modelling tool —
+all funnel through here, so every store ends up with identical chunking,
+compression, ``live`` mask and geometry-attribute conventions. Downstream
+readers (:class:`seisvtk.io.volume.Volume`) therefore never care where a cube
+came from.
+
+Two entry points:
+
+* :func:`write_bands_to_zarr` — the low-level writer. The caller supplies an
+  iterator of inline bands ``(b0, b1, buf, mask)``; this creates the arrays,
+  writes each band once, and stamps the geometry attributes. Ragged sources
+  (SEG-Y) that must scatter traces into a grid use this directly.
+* :func:`write_array_to_zarr` — convenience for a source that is already a
+  dense ``(n_inline, n_crossline, n_sample)`` array-like (a numpy array or a
+  lazily-sliceable ``h5py``/``zarr`` dataset). It streams one inline band at a
+  time, so peak memory is a single band, never the whole cube.
+"""
+from __future__ import annotations
+
+import logging
+import math
+from typing import Any, Iterable, Mapping
+
+import numpy as np
+import zarr
+from zarr.codecs import BloscCodec, BloscShuffle
+
+# (inline, crossline, sample). The sample axis is short and read whole far more
+# often than the lateral axes, so it gets the largest chunk.
+DEFAULT_CHUNKS: tuple[int, int, int] = (64, 64, 128)
+
+
+def default_compressor() -> BloscCodec:
+    """The shared on-disk codec: Blosc+zstd, byte-shuffled, level 3."""
+    return BloscCodec(cname="zstd", clevel=3, shuffle=BloscShuffle.shuffle)
+
+
+def _logger(logger: logging.Logger | None) -> logging.Logger:
+    return logger or logging.getLogger(__name__)
+
+
+def _json_fill(fill: float) -> float | str:
+    """Zarr attributes are JSON, which has no NaN literal; store it as a string."""
+    return "nan" if (isinstance(fill, float) and math.isnan(fill)) else float(fill)
+
+
+def _geometry_attrs(
+    geometry: Mapping[str, Any],
+    shape: tuple[int, int, int],
+    fill: float,
+    n_live: int,
+    extra: Mapping[str, Any] | None,
+) -> dict:
+    """Assemble the canonical attribute dict every store carries.
+
+    ``geometry`` must provide survey-coordinate ranges and the vertical sampling
+    so a reader can translate inline/crossline/z *labels* to array indices:
+    ``iline_range``, ``xline_range``, ``z_range``, ``sample_interval`` (and
+    optionally ``z_start``, defaulting to ``z_range[0]``).
+    """
+    n_il, n_xl, n_samp = shape
+    il_lo, il_hi = geometry["iline_range"]
+    xl_lo, xl_hi = geometry["xline_range"]
+    z_lo, z_hi = geometry["z_range"]
+    attrs = {
+        "iline_range": [int(il_lo), int(il_hi)],
+        "xline_range": [int(xl_lo), int(xl_hi)],
+        "z_range": [float(z_lo), float(z_hi)],
+        "sample_interval": float(geometry["sample_interval"]),
+        "z_start": float(geometry.get("z_start", z_lo)),
+        "n_samples": int(n_samp),
+        "grid_cells": int(n_il * n_xl),
+        "live_traces": int(n_live),
+        "missing_traces": int(n_il * n_xl - n_live),
+        "fill_value": _json_fill(fill),
+    }
+    transform = geometry.get("transform")
+    if transform is not None:                   # a host that knows its georeference
+        from seisvtk.io.survey import GridTransform
+        attrs["survey_transform"] = GridTransform.from_dict(transform).as_dict()
+    if extra:
+        attrs.update(dict(extra))
+    return attrs
+
+
+def write_bands_to_zarr(
+    out: str,
+    *,
+    shape: tuple[int, int, int],
+    geometry: Mapping[str, Any],
+    bands: Iterable[tuple[int, int, np.ndarray, np.ndarray]],
+    chunks: tuple[int, int, int] = DEFAULT_CHUNKS,
+    fill: float = 0.0,
+    dtype: str = "float32",
+    compressor: BloscCodec | None = None,
+    extra_attrs: Mapping[str, Any] | None = None,
+    logger: logging.Logger | None = None,
+) -> dict:
+    """Write a cube to a chunked, compressed Zarr from an iterator of inline bands.
+
+    Each item in ``bands`` is ``(b0, b1, buf, mask)``: the half-open inline range
+    ``[b0, b1)``, the dense samples ``buf`` of shape ``(b1 - b0, n_xl, n_samp)``,
+    and a boolean ``mask`` of shape ``(b1 - b0, n_xl)`` marking which (inline,
+    crossline) cells hold a real trace. Bands are written once, in order; nothing
+    is accumulated, so memory is bounded by the largest band the caller yields.
+
+    Returns the store's final attribute dict.
+    """
+    n_il, n_xl, n_samp = shape
+    comp = compressor or default_compressor()
+    log = _logger(logger)
+
+    cube = zarr.create_array(
+        store=out, shape=(n_il, n_xl, n_samp), chunks=chunks,
+        dtype=dtype, fill_value=fill, compressors=[comp],
+    )
+    live = zarr.create_array(
+        store=f"{out}/live", shape=(n_il, n_xl),
+        chunks=(chunks[0], n_xl), dtype="bool", fill_value=False,
+    )
+
+    log.info(f"Writing {n_il} x {n_xl} x {n_samp} -> {out}")
+    written = 0
+    for b0, b1, buf, mask in bands:
+        cube[b0:b1] = buf
+        live[b0:b1] = mask
+        written += b1 - b0
+        log.info(f"  inlines {b0}..{b1} ({written}/{n_il})")
+
+    n_live = int(live[:].sum())
+    attrs = _geometry_attrs(geometry, shape, fill, n_live, extra_attrs)
+    cube.attrs.update(attrs)
+    log.info(f"Done. live {n_live}/{n_il * n_xl}, missing {n_il * n_xl - n_live}")
+    return dict(cube.attrs)
+
+
+def write_array_to_zarr(
+    out: str,
+    array: Any,
+    geometry: Mapping[str, Any],
+    *,
+    chunk_il: int = 64,
+    chunk_xl: int = 64,
+    chunk_samp: int = 128,
+    fill: float = float("nan"),
+    stride: tuple[int, int, int] = (1, 1, 1),
+    logger: logging.Logger | None = None,
+    extra_attrs: Mapping[str, Any] | None = None,
+) -> dict:
+    """Stream a dense ``(n_inline, n_crossline, n_sample)`` array into a Zarr.
+
+    ``array`` is anything that supports lazy band slicing ``array[b0:b1]`` and has
+    ``.shape`` — a numpy array, an ``h5py`` dataset, another ``zarr`` array. Only
+    one inline band is in memory at a time.
+
+    Undefined cells are expected to be ``NaN`` (the natural "no data" marker for a
+    property volume living between horizons). ``fill`` defaults to ``NaN`` so the
+    stored cube preserves them exactly, and a cell is ``live`` if any sample in its
+    column is finite. ``stride`` decimates ``(il, xl, z)`` for a quick preview.
+
+    Note: geometry ``iline_range``/``xline_range``/``z_range`` describe the data
+    *as written*, so a caller that strides must pass already-strided ranges/step.
+    """
+    log = _logger(logger)
+    si, sj, sk = stride
+    n_il = len(range(0, array.shape[0], si))
+    n_xl = len(range(0, array.shape[1], sj))
+    n_samp = len(range(0, array.shape[2], sk))
+    chunks = (chunk_il, chunk_xl, chunk_samp)
+    src_band = chunk_il * si  # source inlines consumed per written band
+
+    def bands():
+        for b0 in range(0, n_il, chunk_il):
+            s0 = b0 * si
+            s1 = min(s0 + src_band, array.shape[0])
+            raw = np.asarray(array[s0:s1], dtype="float32")
+            buf = raw[::si, ::sj, ::sk]
+            b1 = b0 + buf.shape[0]
+            mask = np.isfinite(buf).any(axis=2)
+            yield b0, b1, buf, mask
+
+    return write_bands_to_zarr(
+        out, shape=(n_il, n_xl, n_samp), geometry=geometry, bands=bands(),
+        chunks=chunks, fill=fill, logger=logger, extra_attrs=extra_attrs,
+    )