seisvtk 0.1.0__tar.gz

seisvtk-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Aashrit
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

seisvtk-0.1.0/PKG-INFO

@@ -0,0 +1,90 @@
+Metadata-Version: 2.4
+Name: seisvtk
+Version: 0.1.0
+Summary: Server-side 3D seismic cross-section viewer (trame + VTK) with a VTK-free I/O core
+Author-email: Aashrit <aashrith12345@gmail.com>
+License: MIT
+Project-URL: Homepage, https://github.com/aashrith48/seisvtk
+Project-URL: Repository, https://github.com/aashrith48/seisvtk
+Keywords: seismic,visualization,vtk,trame,segy,zarr,geoscience
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Classifier: Topic :: Scientific/Engineering :: Visualization
+Classifier: Intended Audience :: Science/Research
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy
+Requires-Dist: pandas
+Requires-Dist: segyio
+Requires-Dist: lasio
+Requires-Dist: zarr>=3
+Provides-Extra: viz
+Requires-Dist: vtk; extra == "viz"
+Requires-Dist: trame; extra == "viz"
+Requires-Dist: trame-vtk; extra == "viz"
+Requires-Dist: trame-vuetify; extra == "viz"
+Provides-Extra: s3
+Requires-Dist: fsspec; extra == "s3"
+Requires-Dist: s3fs; extra == "s3"
+Provides-Extra: test
+Requires-Dist: pytest; extra == "test"
+Dynamic: license-file
+
+# seisvtk
+
+Server-side 3D seismic cross-section viewer (trame + VTK) with a lightweight,
+VTK-free I/O core. The viewer renders inline / crossline / Z slices of a cube and
+streams the rendered frames to the browser, so the client stays thin and the cube
+is read **out-of-core** — only the chunks a visible slice touches are loaded, from
+local disk or straight from object storage (`s3://`). Wells (including deviated)
+and horizons drape on the same grid.
+
+## Install
+
+```bash
+pip install seisvtk            # I/O core: SEG-Y -> Zarr, wells, horizons, geometry
+pip install "seisvtk[viz]"     # + the trame/VTK viewer
+pip install "seisvtk[s3]"      # + read cubes directly from s3://
+```
+
+The core has no VTK dependency, so a data producer (e.g. a pipeline step that
+only converts SEG-Y and writes overlays) installs just `seisvtk`. For a **headless
+/ CPU** render host, install the `vtk-osmesa` wheel in place of `vtk` (see
+`docker/Dockerfile`).
+
+## Use
+
+Serve a single cube:
+
+```bash
+python -m seisvtk.viz.app path/to/cube.zarr --mode property --port 8910
+```
+
+Serve a scene manifest (a cube plus well/horizon overlays — `s3://` cubes work):
+
+```bash
+seisvtk-viewer scene.json --port 8910
+```
+
+Convert a SEG-Y to a chunked Zarr from Python:
+
+```python
+from seisvtk.io.loaders import convert_segy
+convert_segy("survey.segy", "survey.zarr")   # geometry auto-detected from headers
+```
+
+## What's in the box
+
+- **I/O (`seisvtk.io`, no VTK):** streaming SEG-Y→Zarr conversion with survey-geometry
+  recovery; an out-of-core `Volume` reader (local or `s3://`); readers for wells
+  (LAS/CSV, deviation surveys, checkshots), horizons, and the survey affine
+  (`GridTransform`).
+- **Viewer (`seisvtk.viz`):** a trame app streaming inline/crossline/Z slice planes,
+  well tubes coloured by a log, and horizon surfaces; amplitude and property
+  colormaps; vertical exaggeration; runtime cube swap.
+
+## License
+
+[MIT](LICENSE) © 2026 Aashrit

seisvtk-0.1.0/README.md

@@ -0,0 +1,56 @@
+# seisvtk
+
+Server-side 3D seismic cross-section viewer (trame + VTK) with a lightweight,
+VTK-free I/O core. The viewer renders inline / crossline / Z slices of a cube and
+streams the rendered frames to the browser, so the client stays thin and the cube
+is read **out-of-core** — only the chunks a visible slice touches are loaded, from
+local disk or straight from object storage (`s3://`). Wells (including deviated)
+and horizons drape on the same grid.
+
+## Install
+
+```bash
+pip install seisvtk            # I/O core: SEG-Y -> Zarr, wells, horizons, geometry
+pip install "seisvtk[viz]"     # + the trame/VTK viewer
+pip install "seisvtk[s3]"      # + read cubes directly from s3://
+```
+
+The core has no VTK dependency, so a data producer (e.g. a pipeline step that
+only converts SEG-Y and writes overlays) installs just `seisvtk`. For a **headless
+/ CPU** render host, install the `vtk-osmesa` wheel in place of `vtk` (see
+`docker/Dockerfile`).
+
+## Use
+
+Serve a single cube:
+
+```bash
+python -m seisvtk.viz.app path/to/cube.zarr --mode property --port 8910
+```
+
+Serve a scene manifest (a cube plus well/horizon overlays — `s3://` cubes work):
+
+```bash
+seisvtk-viewer scene.json --port 8910
+```
+
+Convert a SEG-Y to a chunked Zarr from Python:
+
+```python
+from seisvtk.io.loaders import convert_segy
+convert_segy("survey.segy", "survey.zarr")   # geometry auto-detected from headers
+```
+
+## What's in the box
+
+- **I/O (`seisvtk.io`, no VTK):** streaming SEG-Y→Zarr conversion with survey-geometry
+  recovery; an out-of-core `Volume` reader (local or `s3://`); readers for wells
+  (LAS/CSV, deviation surveys, checkshots), horizons, and the survey affine
+  (`GridTransform`).
+- **Viewer (`seisvtk.viz`):** a trame app streaming inline/crossline/Z slice planes,
+  well tubes coloured by a log, and horizon surfaces; amplitude and property
+  colormaps; vertical exaggeration; runtime cube swap.
+
+## License
+
+[MIT](LICENSE) © 2026 Aashrit

seisvtk-0.1.0/pyproject.toml

@@ -0,0 +1,55 @@
+[build-system]
+requires = ["setuptools>=68"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "seisvtk"
+version = "0.1.0"
+description = "Server-side 3D seismic cross-section viewer (trame + VTK) with a VTK-free I/O core"
+readme = "README.md"
+requires-python = ">=3.10"
+authors = [{ name = "Aashrit", email = "aashrith12345@gmail.com" }]
+license = { text = "MIT" }
+keywords = ["seismic", "visualization", "vtk", "trame", "segy", "zarr", "geoscience"]
+classifiers = [
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+    "Operating System :: OS Independent",
+    "Topic :: Scientific/Engineering :: Visualization",
+    "Intended Audience :: Science/Research",
+]
+
+# Core = the VTK-free I/O layer (seisvtk.io): read/convert SEG-Y, Zarr, wells,
+# horizons, survey geometry. This is all a producer (e.g. a one-shot pipeline
+# node) needs, and it stays light — no VTK, no trame.
+dependencies = [
+    "numpy",
+    "pandas",
+    "segyio",
+    "lasio",
+    "zarr>=3",
+]
+
+[project.urls]
+Homepage = "https://github.com/aashrith48/seisvtk"
+Repository = "https://github.com/aashrith48/seisvtk"
+
+[project.scripts]
+seisvtk-viewer = "seisvtk.viz.service:main"
+
+[project.optional-dependencies]
+# Rendering/serving: the trame+VTK viewer (seisvtk.viz). Add this only where you
+# actually render. Use the vtk-osmesa wheel instead of vtk for headless/CPU hosts.
+viz = ["vtk", "trame", "trame-vtk", "trame-vuetify"]
+# Reading a cube straight from object storage (s3://…) via an fsspec backend.
+s3 = ["fsspec", "s3fs"]
+test = ["pytest"]
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.pytest.ini_options]
+pythonpath = ["src"]
+testpaths = ["tests"]
+
+

seisvtk-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

seisvtk-0.1.0/src/seisvtk/io/__init__.py

@@ -0,0 +1 @@
+    

seisvtk-0.1.0/src/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-0.1.0/src/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-0.1.0/src/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)