pyseiskit 0.1.0__tar.gz

pyseiskit-0.1.0/.gitignore

@@ -0,0 +1,34 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# Distribution / packaging
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+
+# Virtual environments
+venv/
+env/
+ENV/
+env.bak/
+venv.bak/
+
+# mock data
+*.su
+*.segy
+*.sgy

pyseiskit-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 PETROGEO
+
+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.

pyseiskit-0.1.0/PKG-INFO

@@ -0,0 +1,43 @@
+Metadata-Version: 2.5
+Name: pyseiskit
+Version: 0.1.0
+Summary: A Python library for seismic data processing and pre-visualization.
+Project-URL: Homepage, https://github.com/PETROGEO-UFRN/pyseiskit
+Project-URL: Repository, https://github.com/PETROGEO-UFRN/pyseiskit
+Author-email: JorbFreire <jorbfreire@gmail.com>
+License: MIT
+License-File: LICENSE
+Keywords: SU,data processing,geophysics,seismic,seismic unix,wiggle
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Scientific/Engineering :: Physics
+Requires-Python: >=3.9
+Requires-Dist: numpy
+Requires-Dist: scipy
+Description-Content-Type: text/markdown
+
+# pyseiskit
+
+A Python library for seismic data processing.
+
+Includes *wiggle* helpers, wich can be used together with common plot libraries such as:
+
+ - Matplotlib
+ - Bokeh
+ - Plotly 
+
+## Installation
+```bash
+pip install pyseiskit
+```
+
+## [Available Demos](/demos) 
+  - [Wiggle plotting with common libraries](/demos/wiggle.ipynb)
+  - [Gain methods](/demos/gain.ipynb)

pyseiskit-0.1.0/README.md

@@ -0,0 +1,18 @@
+# pyseiskit
+
+A Python library for seismic data processing.
+
+Includes *wiggle* helpers, wich can be used together with common plot libraries such as:
+
+ - Matplotlib
+ - Bokeh
+ - Plotly 
+
+## Installation
+```bash
+pip install pyseiskit
+```
+
+## [Available Demos](/demos) 
+  - [Wiggle plotting with common libraries](/demos/wiggle.ipynb)
+  - [Gain methods](/demos/gain.ipynb)

pyseiskit-0.1.0/demos/gain.ipynb

@@ -0,0 +1,169 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# PySeis Gain & AGC Demo\n",
+    "This notebook demonstrates how to replicate Seismic Unix processing pipelines (like `sugain` and `suxwigb` clipping) using PySeis."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "%pip install bokeh segyio"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Install pyseiskit from PyPI\n",
+    "%pip install pyseiskit\n",
+    "# Install for local development\n",
+    "# %pip install -e .."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 1A. Option 1: Create Simple Synthetic Data\n",
+    "Run this cell to generate a small 2D array representing 5 seismic traces, each with 100 time samples."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import numpy as np\n",
+    "\n",
+    "# 100 samples, 5 traces\n",
+    "data = np.random.randn(100, 5) \n",
+    "times = np.arange(100)\n",
+    "offsets = np.arange(5, dtype=float)\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 1B. Option 2: Load Real `.su` or `.sgy` Data\n",
+    "Run this cell instead if you have the file `tac-204RL239.su` in the same folder as this notebook."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import segyio\n",
+    "from seismic_reader import read_seismic_file\n",
+    "\n",
+    "filename = 'tac-204RL239.su'\n",
+    "\n",
+    "# We only want to plot a single gather to avoid rendering thousands of traces.\n",
+    "# FieldRecord corresponds to the 'fldr' header in SU/SEGY.\n",
+    "gather_key = segyio.TraceField.FieldRecord\n",
+    "gather_index = 50  # Change this to a valid fldr number from your dataset!\n",
+    "\n",
+    "try:\n",
+    "    data, offsets, times = read_seismic_file(filename, gather_key=gather_key, gather_index=gather_index)\n",
+    "    print(f\"Loaded {data.shape[1]} traces for fldr {gather_index} with {data.shape[0]} samples each.\")\n",
+    "except FileNotFoundError:\n",
+    "    print(f\"File '{filename}' not found. Please place it in the 'demos' folder or stick to Option 1A.\")\n",
+    "except ValueError as e:\n",
+    "    print(f\"Error: {e}\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 2. Process Data for Wiggles\n",
+    "Regardless of how you loaded the data above, we now pass it through PySeis."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from pyseiskit import sourceData\n",
+    "from pyseiskit import gain\n",
+    "from pyseiskit import clip\n",
+    "\n",
+    "# Replicating SU pipeline: suwind | sugain agc=1 wagc=1.0 | suxwigb perc=99\n",
+    "dt = times[1] - times[0]\n",
+    "\n",
+    "# 1. Apply AGC (Optional, just like sugain agc=1 wagc=1.0)\n",
+    "data_gained = gain.applyAGC(data, wagc=1.0, intervalTimeSamples=dt)\n",
+    "# data_gained = data  # uncomment above to apply AGC\n",
+    "\n",
+    "# 2. Apply Percentile Clipping (Like suxwigb perc=99 flat-topping)\n",
+    "data_clipped = clip.applyPercentileClip(data_gained, percentile=99.0)\n",
+    "\n",
+    "# 3. Scale physical dimensions (overlap=1.0 is SU default xcur/overlap)\n",
+    "scaled_data = sourceData.rescaleDataForWiggle(data_clipped, offsets, overlap=1.0)\n",
+    "\n",
+    "# 4. Generate geometry\n",
+    "line_data = sourceData.wiggleLinesDataFactory(scaled_data, offsets, times)\n",
+    "patch_data = sourceData.wigglePatchesDataFactory(scaled_data, offsets, times, fill_mode='positive')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 3. Visualize Results\n",
+    "Here we use Bokeh to visualize the gained results interactively."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from bokeh.plotting import figure, show, output_notebook\n",
+    "output_notebook()\n",
+    "\n",
+    "bokeh_plot = figure(width=600, height=400, y_range=(times[-1], times[0]))\n",
+    "bokeh_plot.multi_line(**line_data, color='black', line_width=0.5)\n",
+    "bokeh_plot.patches(**patch_data, color='black', line_width=0)\n",
+    "\n",
+    "show(bokeh_plot)"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "pyseis (3.12.2)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.12.2"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 4
+}

pyseiskit-0.1.0/demos/seismic_reader.py

@@ -0,0 +1,76 @@
+import numpy as np
+import segyio
+from pathlib import Path
+
+def read_seismic_file(filepath, gather_key=None, gather_index=None):
+    """
+    Reads a .su or .sgy file and returns the data, times, and offsets.
+    If gather_key and gather_index are provided, it only loads traces
+    matching that specific gather (e.g. a specific fldr or cdp).
+    """
+    path = Path(filepath)
+    if not path.is_file():
+        raise FileNotFoundError(f"File not found: {path}")
+
+    is_su = path.suffix.lower() == '.su'
+    
+    # Open the file depending on its extension
+    if is_su:
+        dataset = segyio.su.open(str(path), "r", ignore_geometry=True, endian='little')
+    else:
+        dataset = segyio.open(str(path), "r", ignore_geometry=True)
+        
+    try:
+        if gather_key is not None and gather_index is not None:
+            # Group traces by their gather key (e.g. all traces sharing the same fldr)
+            key_to_trace_indices = {}
+            for i in range(dataset.tracecount):
+                val = int(dataset.header[i][gather_key])
+                if val not in key_to_trace_indices:
+                    key_to_trace_indices[val] = []
+                key_to_trace_indices[val].append(i)
+                
+            available_gathers = sorted(key_to_trace_indices.keys())
+            if not available_gathers:
+                raise ValueError(f"No valid values found for header key {gather_key}")
+                
+            # Safely select the requested gather index
+            safe_index = max(0, min(gather_index, len(available_gathers) - 1))
+            selected_gather_val = available_gathers[safe_index]
+            trace_indices = key_to_trace_indices[selected_gather_val]
+            
+            print(f"Selected gather {safe_index} (Header value: {selected_gather_val}) containing {len(trace_indices)} traces.")
+                
+            raw_traces = np.stack([dataset.trace[i] for i in trace_indices])
+            
+            offsets = np.array([
+                dataset.header[i][segyio.TraceField.offset] 
+                for i in trace_indices
+            ], dtype=float)
+            
+            # If the offset header is missing or all zero, fallback to trace indices
+            if len(offsets) > 1 and np.all(offsets == offsets[0]):
+                print("Warning: Trace offsets are all identical (likely missing header). Falling back to trace indices.")
+                offsets = np.arange(len(trace_indices), dtype=float)
+        else:
+            # Load all traces into memory
+            raw_traces = dataset.trace.raw[:]
+            offsets = np.arange(raw_traces.shape[0], dtype=float)
+            
+        # We transpose so that data is (samples x traces) for wiggle plotting
+        data = raw_traces.T
+        
+        # Calculate times based on sample interval
+        if is_su:
+            dt_micros = dataset.header[0][segyio.TraceField.TRACE_SAMPLE_INTERVAL]
+        else:
+            dt_micros = dataset.bin[segyio.BinField.Interval]
+            
+        dt_seconds = dt_micros / 1e6
+        num_samples = len(dataset.samples)
+        times = np.arange(num_samples) * dt_seconds
+        
+        return data, offsets, times
+        
+    finally:
+        dataset.close()

pyseiskit-0.1.0/demos/wiggle.ipynb

@@ -0,0 +1,209 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# PySeis Wiggle Plots Demo\n",
+    "This notebook demonstrates how to plot wiggle traces using PySeis with Matplotlib, Bokeh, and Plotly."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "%pip install matplotlib bokeh plotly segyio"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Install pyseiskit from PyPI\n",
+    "%pip install pyseiskit\n",
+    "# Install for local development\n",
+    "# %pip install -e .."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 1A. Option 1: Create Simple Synthetic Data\n",
+    "Run this cell to generate a small 2D array representing 5 seismic traces, each with 100 time samples."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import numpy as np\n",
+    "\n",
+    "# 100 samples, 5 traces\n",
+    "data = np.random.randn(100, 5) \n",
+    "times = np.arange(100)\n",
+    "offsets = np.arange(5, dtype=float)\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 1B. Option 2: Load Real `.su` or `.sgy` Data\n",
+    "Run this cell instead if you have the file `tac-204RL239.su` in the same folder as this notebook."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import segyio\n",
+    "from seismic_reader import read_seismic_file\n",
+    "\n",
+    "filename = 'tac-204RL239.su'\n",
+    "\n",
+    "# We only want to plot a single gather to avoid rendering thousands of traces.\n",
+    "# FieldRecord corresponds to the 'fldr' header in SU/SEGY.\n",
+    "gather_key = segyio.TraceField.FieldRecord\n",
+    "gather_index = 50  # Change this to a valid fldr number from your dataset!\n",
+    "\n",
+    "try:\n",
+    "    data, offsets, times = read_seismic_file(filename, gather_key=gather_key, gather_index=gather_index)\n",
+    "    print(f\"Loaded {data.shape[1]} traces for fldr {gather_index} with {data.shape[0]} samples each.\")\n",
+    "except FileNotFoundError:\n",
+    "    print(f\"File '{filename}' not found. Please place it in the 'demos' folder or stick to Option 1A.\")\n",
+    "except ValueError as e:\n",
+    "    print(f\"Error: {e}\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 2. Process Data for Wiggles\n",
+    "Regardless of how you loaded the data above, we now pass it through PySeis."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from pyseiskit import sourceData\n",
+    "\n",
+    "scaled_data = sourceData.rescaleDataForWiggle(data, offsets, overlap=1.0)\n",
+    "line_data = sourceData.wiggleLinesDataFactory(scaled_data, offsets, times)\n",
+    "patch_data = sourceData.wigglePatchesDataFactory(scaled_data, offsets, times, fill_mode='positive')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 3. Plotting with Matplotlib"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import matplotlib.pyplot as plt\n",
+    "\n",
+    "matplotlib_figure, matplotlib_axes = plt.subplots(figsize=(6, 4))\n",
+    "\n",
+    "# Plot filled areas\n",
+    "for x, y in zip(patch_data['xs'], patch_data['ys']):\n",
+    "    matplotlib_axes.fill(x, y, color='black')\n",
+    "\n",
+    "# Plot trace lines\n",
+    "for x, y in zip(line_data['xs'], line_data['ys']):\n",
+    "    matplotlib_axes.plot(x, y, color='black', linewidth=0.5)\n",
+    "\n",
+    "matplotlib_axes.invert_yaxis() # Time goes down\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 4. Plotting with Bokeh"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from bokeh.plotting import figure, show, output_notebook\n",
+    "output_notebook()\n",
+    "\n",
+    "bokeh_plot = figure(width=600, height=400, y_range=(times[-1], times[0]))\n",
+    "bokeh_plot.multi_line(**line_data, color='black', line_width=0.5)\n",
+    "bokeh_plot.patches(**patch_data, color='black', line_width=0)\n",
+    "\n",
+    "show(bokeh_plot)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 5. Plotting with Plotly"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import plotly.graph_objects as go\n",
+    "\n",
+    "plotly_figure = go.Figure()\n",
+    "\n",
+    "for x, y in zip(line_data['xs'], line_data['ys']):\n",
+    "    plotly_figure.add_trace(go.Scatter(x=x, y=y, mode='lines', line=dict(color='black', width=0.5), showlegend=False))\n",
+    "\n",
+    "for x, y in zip(patch_data['xs'], patch_data['ys']):\n",
+    "    plotly_figure.add_trace(go.Scatter(x=x, y=y, fill='toself', fillcolor='black', line=dict(width=0), showlegend=False))\n",
+    "\n",
+    "plotly_figure.update_layout(yaxis=dict(autorange='reversed'), height=500)\n",
+    "plotly_figure.show()"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "pyseis (3.12.2)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.12.2"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 4
+}

pyseiskit-0.1.0/legacy/boto/BaseVisualization.py

@@ -0,0 +1,104 @@
+import numpy as np
+import numpy.typing as np_types
+from seismicio.Models.SuDataModel import SuFile
+
+from ...constants.VISUALIZATION import FIRST_TIME_SAMPLE
+from ...services.sufile import get_stack_sufile, get_multi_gather_sufile
+from .BasePlotOptionsState import BasePlotOptionsState
+
+def debug(message: str):
+    print(f"DEBUG: {message}", flush=True)
+
+
+class BaseVisualization:
+    sufile: SuFile
+    plot_options_state: BasePlotOptionsState
+    gather_offsets: np_types.NDArray | None
+
+    def __init__(
+        self,
+        filename: str,
+        plot_options_state: BasePlotOptionsState,
+        gather_key: str | None = None,
+    ) -> None:
+        self.plot_options_state = plot_options_state
+        if gather_key:
+            self.sufile: SuFile = get_multi_gather_sufile(
+                plot_options=self.plot_options_state.__dict__,
+                filename=filename,
+                gather_key=gather_key,
+            )
+        else:
+            self.sufile = get_stack_sufile(
+                plot_options=self.plot_options_state.__dict__,
+                filename=filename,
+            )
+
+    def getShotGathersData(
+        self,
+        index_start: int | None = None
+    ):
+        if index_start is None:
+            index_start = self.plot_options_state.gather_index_start
+        index_stop = index_start + self.plot_options_state.num_loadedgathers
+        # ! igather VS gather
+        selected_gathers = self.sufile.igather[
+            index_start:index_stop
+        ]
+
+        last_time_sample = \
+            FIRST_TIME_SAMPLE + \
+            (self.plot_options_state.num_time_samples - 1) * \
+            self.plot_options_state.interval_time_samples
+
+        width_time_samples = np.abs(
+            last_time_sample - FIRST_TIME_SAMPLE
+        )
+        self.plot_options_state.updatePlotOptionsState(
+            width_time_samples=width_time_samples,
+        )
+
+        if (index_stop - 1 == index_start):
+            # *** Single gather
+            self.gather_offsets = selected_gathers.headers["offset"]
+        else:
+            # *** Multiple gathers
+            self.gather_offsets = None
+
+        # --- DEBUG LOGS START ---
+        debug(f"DEBUG: index_start = {index_start}, index_stop = {index_stop}")
+        debug(f"DEBUG: num_loadedgathers = {self.plot_options_state.num_loadedgathers}")
+        debug(f"DEBUG: Data type (dtype) = {selected_gathers.data.dtype}")
+        debug(f"DEBUG: Data shape = {selected_gathers.data.shape}")
+
+        # Check for non-standard values that might break VTK color mapping
+        debug(f"DEBUG: Contains NaNs? = {np.isnan(selected_gathers.data).any()}")
+        debug(f"DEBUG: Min Amplitude = {np.nanmin(selected_gathers.data)}")
+        debug(f"DEBUG: Max Amplitude = {np.nanmax(selected_gathers.data)}")
+
+        if self.gather_offsets is not None:
+             debug(f"DEBUG: gather_offsets shape = {self.gather_offsets.shape}")
+        # --- DEBUG LOGS END ---
+        return selected_gathers.data
+
+    def getBaseData(self) -> np_types.NDArray:
+        """
+        Get Numpy NDArray for data section on display
+
+        Handles stack or sectioned data (shot gathers)
+        """
+        # *** "gather_keyword"  must exist for shot gathers
+        if self.sufile.gather_keyword:
+            data = self.getShotGathersData()
+        else:
+            data = self.sufile.traces
+            self.gather_offsets = None
+        return data
+
+    def handle_state_change(self):
+        raise NotImplementedError(
+            """
+            Missing custom handle_state_change() for this Visualization
+            handle_state_change() method must be re-implmented when extending BaseVisualization
+            """
+        )