interpies-lite 0.1.0__py3-none-any.whl

interpies_lite/__init__.py

@@ -0,0 +1,24 @@
+"""
+interpies_lite
+==============
+
+A from-scratch, dependency-light re-implementation of the key features of
+the original ``interpies`` library: loading geophysical grids, applying
+potential-field transforms (derivatives, ISVD, upward continuation,
+edge-enhancement filters like tilt / HGM / TDR / local wavenumber) and
+plotting with hillshading.
+
+Example
+-------
+>>> import interpies_lite as ip
+>>> g = ip.open("data/brtpgrd.gxf")
+>>> g.info()
+>>> g.detrend().tilt().show()
+"""
+from __future__ import annotations
+
+from interpies_lite.grid import Grid
+from interpies_lite.io import open_rasterio as open
+
+__version__ = "0.1.0"
+__all__ = ["Grid", "open", "open_rasterio"]

interpies_lite/colors.py

@@ -0,0 +1,58 @@
+"""
+interpies_lite.colors
+=====================
+
+Minimal built-in colormaps: Geosoft clra-style, parula, and access to
+matplotlib built-ins.  Avoids shipping the 35 KB lookup tables of the
+original library; perceptually uniform maps from matplotlib (viridis,
+plasma, inferno, magma, cividis) are recommended.
+"""
+from __future__ import annotations
+
+import matplotlib.pyplot as plt
+from matplotlib.colors import LinearSegmentedColormap
+
+# Geosoft "clra" approximate ramp: blue -> cyan -> green -> yellow -> red
+_CLRA_NODES = [
+    (0.00, (0.00, 0.00, 0.50)),
+    (0.15, (0.00, 0.00, 1.00)),
+    (0.35, (0.00, 0.75, 1.00)),
+    (0.50, (0.00, 1.00, 0.50)),
+    (0.65, (0.75, 1.00, 0.00)),
+    (0.85, (1.00, 0.75, 0.00)),
+    (1.00, (0.50, 0.00, 0.00)),
+]
+
+# MATLAB parula key stops
+_PARULA_NODES = [
+    (0.00, (0.208, 0.166, 0.529)),
+    (0.25, (0.00, 0.387, 0.882)),
+    (0.50, (0.00, 0.68, 0.6)),
+    (0.75, (0.65, 0.82, 0.25)),
+    (1.00, (0.98, 0.90, 0.13)),
+]
+
+
+def _make(name: str, nodes) -> LinearSegmentedColormap:
+    return LinearSegmentedColormap.from_list(name, nodes)
+
+
+# register builtins
+_BUILTINS = {
+    "geosoft": _make("geosoft", _CLRA_NODES),
+    "clra": _make("clra", _CLRA_NODES),
+    "parula": _make("parula", _PARULA_NODES),
+}
+
+
+def load_cmap(name: str = "geosoft"):
+    """Return a colormap by name; falls back to matplotlib built-ins."""
+    if name in _BUILTINS:
+        return _BUILTINS[name]
+    if name in plt.colormaps():
+        return plt.get_cmap(name)
+    raise ValueError(f"Unknown colormap: {name}")
+
+
+def list_cmaps() -> list[str]:
+    return sorted(list(_BUILTINS.keys()) + [c for c in plt.colormaps() if not c.endswith("_r")])

interpies_lite/graphics.py

@@ -0,0 +1,162 @@
+"""
+interpies_lite.graphics
+=======================
+
+Plotting: hillshaded 2D grids with configurable colormap normalisation,
+contours and colorbar.
+"""
+from __future__ import annotations
+
+from typing import Literal
+
+import numpy as np
+import matplotlib.pyplot as plt
+from matplotlib.colors import Normalize, ListedColormap, BoundaryNorm
+
+from interpies_lite import colors as icolors
+from interpies_lite import transforms as T
+
+
+# ---------------------------------------------------------------------------
+# normalisation helpers
+# ---------------------------------------------------------------------------
+
+def _auto_norm(data: np.ndarray, mode: str = "equalize") -> Normalize:
+    finite = data[np.isfinite(data)]
+    if mode == "equalize":
+        # histogram-equalise the lookup: resample colors at quantiles
+        lo, hi = np.percentile(finite, [2, 98])
+        return Normalize(vmin=lo, vmax=hi)
+    if mode == "autolevels":
+        lo, hi = np.percentile(finite, [2, 98])
+        return Normalize(vmin=lo, vmax=hi)
+    if mode == "linear":
+        return Normalize(vmin=finite.min(), vmax=finite.max())
+    raise ValueError(mode)
+
+
+# ---------------------------------------------------------------------------
+# hillshade
+# ---------------------------------------------------------------------------
+
+def _hillshade(
+    data: np.ndarray,
+    cellsize: float,
+    zf: float = 10.0,
+    azdeg: float = 45.0,
+    altdeg: float = 45.0,
+) -> np.ndarray:
+    """Simple hillshade; returns values in [0, 1]."""
+    az = np.radians(360.0 - azdeg)
+    alt = np.radians(altdeg)
+    dy, dx = np.gradient(np.nan_to_num(data) * zf, cellsize, cellsize)
+    slope = np.pi / 2.0 - np.arctan(np.sqrt(dx**2 + dy**2))
+    aspect = np.arctan2(-dx, dy)
+    shaded = np.sin(alt) * np.sin(slope) + np.cos(alt) * np.cos(slope) * np.cos(az - aspect)
+    return np.clip(shaded, 0, 1)
+
+
+# ---------------------------------------------------------------------------
+# main show function
+# ---------------------------------------------------------------------------
+
+def show_grid(
+    grid,
+    ax=None,
+    cmap: str = "geosoft",
+    cmap_norm: Literal["equalize", "autolevels", "linear"] = "equalize",
+    hs: bool = True,
+    zf: float = 10.0,
+    azdeg: float = 45.0,
+    altdeg: float = 45.0,
+    hs_contrast: float = 1.5,
+    cmap_brightness: float = 1.0,
+    alpha: float = 0.7,
+    contours: bool | int = False,
+    colorbar: bool = True,
+    cb_contours: bool = False,
+    std_range: float = 1.0,
+    figsize: tuple[float, float] = (8, 8),
+    title: str | None = None,
+    **kwargs,
+):
+    """Display a Grid with hillshading and optional contours.
+
+    Parameters mirror the original interpies ``Grid.show()``.
+    """
+    data = grid.data
+    extent = grid.extent
+    cmap_obj = icolors.load_cmap(cmap)
+
+    # optional brightness tweak
+    if cmap_brightness != 1.0:
+        arr = cmap_obj(np.linspace(0, 1, 256))
+        arr[:, :3] = np.clip(arr[:, :3] * cmap_brightness, 0, 1)
+        cmap_obj = ListedColormap(arr)
+
+    norm = _auto_norm(data, cmap_norm)
+
+    if ax is None:
+        _, ax = plt.subplots(figsize=figsize)
+
+    # colour layer
+    im = ax.imshow(
+        np.ma.masked_invalid(data),
+        extent=extent,
+        origin="upper",
+        cmap=cmap_obj,
+        norm=norm,
+        alpha=alpha if hs else 1.0,
+        **kwargs,
+    )
+
+    # hillshade overlay
+    if hs:
+        shade = _hillshade(data, grid.cellsize, zf=zf, azdeg=azdeg, altdeg=altdeg)
+        shade = np.clip((shade - 0.5) * hs_contrast + 0.5, 0, 1)
+        ax.imshow(
+            shade,
+            extent=extent,
+            origin="upper",
+            cmap="gray",
+            alpha=1.0 - alpha,
+            zorder=im.get_zorder() - 0.1,
+        )
+
+    # contours
+    if contours:
+        n_levels = 32 if contours is True else int(contours)
+        cs = ax.contour(
+            np.ma.masked_invalid(data),
+            extent=extent,
+            origin="upper",
+            levels=n_levels,
+            colors="k",
+            linewidths=0.4,
+            alpha=0.6,
+        )
+        if cb_contours:
+            # draw contour level ticks on the colorbar later
+            pass
+
+    if colorbar:
+        cb = plt.colorbar(im, ax=ax, fraction=0.046, pad=0.04)
+        cb.set_label(grid.name)
+
+    ax.set_title(title or grid.name)
+    ax.set_xlabel("Easting")
+    ax.set_ylabel("Northing")
+    return ax
+
+
+def save_grid_image(grid, output_file: str, dpi: int = 150, **kwargs) -> None:
+    """Render the grid without title/colorbar/annotations and save to file."""
+    kwargs.setdefault("colorbar", False)
+    kwargs.setdefault("title", "")
+    ax = show_grid(grid, **kwargs)
+    ax.set_xlabel("")
+    ax.set_ylabel("")
+    ax.set_xticks([])
+    ax.set_yticks([])
+    ax.figure.savefig(output_file, dpi=dpi, bbox_inches="tight", pad_inches=0)
+    plt.close(ax.figure)

interpies_lite/grid.py

@@ -0,0 +1,318 @@
+"""
+interpies_lite.grid
+===================
+
+The :class:`Grid` object: a 2D array with georeferencing, plus all the
+potential-field methods (derivatives, enhancements, continuation) that make
+interpies useful.
+"""
+from __future__ import annotations
+
+import os
+from dataclasses import dataclass, field
+from typing import Any
+
+import numpy as np
+
+from interpies_lite import transforms as T
+
+
+@dataclass
+class Grid:
+    """A single-band georeferenced raster.
+
+    Attributes
+    ----------
+    data : 2D float array (nodata -> NaN)
+    transform : 6-tuple or affine.Affine
+        Affine mapping (row, col) -> (x, y).
+    crs : str or None
+        Coordinate reference system (EPSG:xxxx string or PROJ.4).
+    name, filename : str
+    nodata : float or None
+    """
+
+    data: np.ndarray
+    transform: Any = None
+    crs: str | None = None
+    name: str = "Unknown"
+    filename: str = "Unknown"
+    nodata: float | None = None
+
+    # ---------- post-init derived attributes ----------
+    def __post_init__(self) -> None:
+        self.data = np.asarray(self.data, dtype=float)
+        if self.nodata is not None:
+            self.data[self.data == self.nodata] = np.nan
+        if self.transform is None:
+            # default: origin (0,0), 100 m cells
+            self.transform = (100.0, 0.0, 0.0, 0.0, -100.0, 0.0)
+
+    # ---------- derived properties ----------
+    @property
+    def nrows(self) -> int:
+        return self.data.shape[0]
+
+    @property
+    def ncols(self) -> int:
+        return self.data.shape[1]
+
+    @property
+    def cellsize(self) -> float:
+        return abs(float(self.transform[0]))
+
+    @property
+    def y_cellsize(self) -> float:
+        return abs(float(self.transform[4]))
+
+    @property
+    def x_origin(self) -> float:
+        """X of upper-left corner."""
+        return float(self.transform[2])
+
+    @property
+    def y_origin(self) -> float:
+        """Y of upper-left corner."""
+        return float(self.transform[5])
+
+    @property
+    def extent(self) -> list[float]:
+        """matplotlib-style extent: [left, right, bottom, top]."""
+        left = self.x_origin
+        right = left + self.ncols * self.cellsize
+        top = self.y_origin
+        bottom = top - self.nrows * self.y_cellsize
+        return [left, right, bottom, top]
+
+    @property
+    def mask(self) -> np.ndarray:
+        return ~np.isfinite(self.data)
+
+    # ---------- constructors ----------
+    @classmethod
+    def from_array(
+        cls,
+        array: np.ndarray,
+        west: float = 0.0,
+        north: float = 0.0,
+        cellsize: float = 100.0,
+        y_cellsize: float | None = None,
+        crs: str | None = None,
+        name: str = "Unknown",
+    ) -> "Grid":
+        ys = y_cellsize if y_cellsize is not None else cellsize
+        transform = (cellsize, 0.0, west, 0.0, -ys, north)
+        return cls(data=np.asarray(array), transform=transform, crs=crs, name=name)
+
+    @classmethod
+    def from_dataset(cls, dataset, band: int = 1, name: str | None = None) -> "Grid":
+        """Build a Grid from an open rasterio dataset."""
+        data = dataset.read(band).astype(float)
+        crs = dataset.crs.to_string() if dataset.crs is not None else None
+        return cls(
+            data=data,
+            transform=dataset.transform,
+            crs=crs,
+            name=name or os.path.splitext(os.path.basename(dataset.name))[0],
+            filename=dataset.name,
+            nodata=dataset.nodata,
+        )
+
+    # ---------- IO ----------
+    def save(self, output_file: str) -> None:
+        """Write as GeoTIFF."""
+        try:
+            import rasterio
+        except ImportError as e:
+            raise RuntimeError(
+                "rasterio is required for save(); install with `pip install rasterio`"
+            ) from e
+        profile = {
+            "driver": "GTiff",
+            "height": self.nrows,
+            "width": self.ncols,
+            "count": 1,
+            "dtype": "float64",
+            "crs": self.crs,
+            "transform": self.transform,
+        }
+        with rasterio.open(output_file, "w", **profile) as dst:
+            dst.write(np.nan_to_num(self.data), 1)
+
+    # ---------- geometry / preprocessing ----------
+    def _new(self, data: np.ndarray, name: str | None = None, **kw) -> "Grid":
+        base = dict(transform=self.transform, crs=self.crs, filename=self.filename, nodata=self.nodata)
+        base.update(kw)
+        return Grid(data=data, name=name or self.name, **base)
+
+    def clip(self, xmin: float, xmax: float, ymin: float, ymax: float) -> "Grid":
+        left, right, bottom, top = self.extent
+        c1 = max(0, int(np.floor((xmin - left) / self.cellsize)))
+        c2 = min(self.ncols, int(np.ceil((xmax - left) / self.cellsize)))
+        r1 = max(0, int(np.floor((top - ymax) / self.y_cellsize)))
+        r2 = min(self.nrows, int(np.ceil((top - ymin) / self.y_cellsize)))
+        sub = self.data[r1:r2, c1:c2]
+        new_left = left + c1 * self.cellsize
+        new_top = top - r1 * self.y_cellsize
+        new_transform = (self.transform[0], 0.0, new_left, 0.0, self.transform[4], new_top)
+        return self._new(sub, name=f"{self.name}_clip", transform=new_transform)
+
+    def resample(self, sampling: int = 2) -> "Grid":
+        sub = T.simple_resample(self.data, sampling)
+        new_cs = self.cellsize * sampling
+        new_ycs = self.y_cellsize * sampling
+        new_transform = (new_cs, 0.0, self.x_origin, 0.0, -new_ycs, self.y_origin)
+        return self._new(sub, name=f"{self.name}_res{sampling}", transform=new_transform)
+
+    def scale(self, factor: float) -> "Grid":
+        return self._new(self.data * factor, name=f"{self.name}_scaled")
+
+    def detrend(self, degree: int = 1, sampling: int = 4) -> "Grid":
+        sub = T.simple_resample(np.nan_to_num(self.data), sampling)
+        ny, nx = sub.shape
+        ys = np.linspace(self.y_origin, self.y_origin - ny * self.y_cellsize * sampling, ny)
+        xs = np.linspace(self.x_origin, self.x_origin + nx * self.cellsize * sampling, nx)
+        XX, YY = np.meshgrid(xs, ys)
+        trend_sub = T.find_trend(np.c_[XX.ravel(), YY.ravel()], sub.ravel(), degree=degree)
+        # resize trend back to original shape
+        from scipy.ndimage import zoom
+        zy = self.nrows / ny
+        zx = self.ncols / nx
+        trend_full = zoom(trend_sub.reshape(ny, nx), (zy, zx), order=1)
+        return self._new(self.data - trend_full, name=f"{self.name}_detrend{degree}")
+
+    def fill_nodata(self) -> "Grid":
+        return self._new(T.fill_nodata(self.data), name=f"{self.name}_filled")
+
+    def smooth(self, method: str = "SG", deg: int = 3, win: int = 5, sigma: float = 1.0) -> "Grid":
+        if method.upper() == "SG":
+            out = T.savgol_smooth(self.data, deg=deg, win=win)
+        else:
+            out = T.gauss(self.data, sigma=sigma)
+        return self._new(out, name=f"{self.name}_smooth")
+
+    def laplacian(self) -> "Grid":
+        return self._new(T.laplacian(self.data, self.cellsize), name=f"{self.name}_lap")
+
+    def info(self) -> None:
+        s = T.stats(self.data)
+        print(f"Grid: {self.name}")
+        print(f"  file      : {self.filename}")
+        print(f"  shape     : {self.nrows} rows x {self.ncols} cols")
+        print(f"  cellsize  : {self.cellsize} x {self.y_cellsize}")
+        print(f"  extent    : {self.extent}")
+        print(f"  crs       : {self.crs}")
+        print(f"  min/max   : {s['min']:.3f} / {s['max']:.3f}")
+        print(f"  mean/std  : {s['mean']:.3f} +/- {s['std']:.3f}")
+
+    # ---------- derivatives ----------
+    def dx(self, method: str = "SG", deg: int = 3, win: int = 5, fs_tap: int = 5) -> "Grid":
+        if method.upper() == "FS":
+            out = T.fs_deriv(self.data, self.cellsize, "dx", tap=fs_tap)
+        elif method.lower() == "fourier":
+            out = T.fourier_transform(self.data, self.cellsize, trans="dx", order=1)
+        else:
+            out = T.savgol_deriv(self.data, self.cellsize, "dx", deg=deg, win=win)
+        return self._new(out, name=f"{self.name}_dx")
+
+    def dy(self, method: str = "SG", deg: int = 3, win: int = 5, fs_tap: int = 5) -> "Grid":
+        if method.upper() == "FS":
+            out = T.fs_deriv(self.data, self.cellsize, "dy", tap=fs_tap)
+        elif method.lower() == "fourier":
+            out = T.fourier_transform(self.data, self.cellsize, trans="dy", order=1)
+        else:
+            out = T.savgol_deriv(self.data, self.cellsize, "dy", deg=deg, win=win)
+        return self._new(out, name=f"{self.name}_dy")
+
+    def dx2(self, method: str = "SG", deg: int = 4, win: int = 5, fs_tap: int = 5) -> "Grid":
+        return self.dx(method=method, deg=deg, win=win, fs_tap=fs_tap).dx(method=method, deg=deg, win=win, fs_tap=fs_tap)
+
+    def dy2(self, method: str = "SG", deg: int = 4, win: int = 5, fs_tap: int = 5) -> "Grid":
+        return self.dy(method=method, deg=deg, win=win, fs_tap=fs_tap).dy(method=method, deg=deg, win=win, fs_tap=fs_tap)
+
+    def dxdy(self, method: str = "SG", deg: int = 3, win: int = 5, fs_tap: int = 5) -> "Grid":
+        return self.dx(method=method, deg=deg, win=win, fs_tap=fs_tap).dy(method=method, deg=deg, win=win, fs_tap=fs_tap)
+
+    def dz(self, method: str = "fourier", order: int = 1, **kw) -> "Grid":
+        if method.lower() == "fourier":
+            out = T.fourier_transform(self.data, self.cellsize, trans="dz", order=order, **kw)
+        else:
+            out = T.isvd(self.data, self.cellsize, method=method, order=order, **kw)
+        return self._new(out, name=f"{self.name}_dz{order}")
+
+    def isvd(self, method: str = "SG", order: int = 1, deg: int = 3, win: int = 5, fs_tap: int = 5) -> "Grid":
+        out = T.isvd(self.data, self.cellsize, method=method, order=order, deg=deg, win=win, fs_tap=fs_tap)
+        return self._new(out, name=f"{self.name}_dz{order}")
+
+    def vi(self, order: int = 1, eps: float = 1e-6) -> "Grid":
+        out = T.fourier_transform(self.data, self.cellsize, trans="vi", order=order, eps=eps)
+        return self._new(out, name=f"{self.name}_vi{order}")
+
+    # ---------- enhancement transforms ----------
+    def hgm(self, method: str = "SG", deg: int = 3, win: int = 5, fs_tap: int = 5) -> "Grid":
+        gx = self.dx(method=method, deg=deg, win=win, fs_tap=fs_tap).data
+        gy = self.dy(method=method, deg=deg, win=win, fs_tap=fs_tap).data
+        return self._new(np.sqrt(gx * gx + gy * gy), name=f"{self.name}_HGM")
+
+    def tilt(self, hgm_method: str = "SG", dz_method: str = "isvd",
+             deg: int = 3, win: int = 5, fs_tap: int = 5, alpha: float = 1.0) -> "Grid":
+        hgm_grid = self.hgm(method=hgm_method, deg=deg, win=win, fs_tap=fs_tap)
+        if dz_method.lower() == "isvd":
+            dz_grid = self.isvd(method=hgm_method, order=1, deg=deg, win=win, fs_tap=fs_tap)
+        else:
+            dz_grid = self.dz(method="fourier", order=1)
+        out = np.arctan(alpha * dz_grid.data / hgm_grid.data) * 180.0 / np.pi
+        return self._new(out, name=f"{self.name}_tilt")
+
+    def tg(self, method: str = "SG", dz_method: str = "isvd",
+           deg: int = 3, win: int = 5, fs_tap: int = 5) -> "Grid":
+        gx = self.dx(method=method, deg=deg, win=win, fs_tap=fs_tap).data
+        gy = self.dy(method=method, deg=deg, win=win, fs_tap=fs_tap).data
+        if dz_method.lower() == "isvd":
+            gz = self.isvd(method=method, order=1, deg=deg, win=win, fs_tap=fs_tap).data
+        else:
+            gz = self.dz(method="fourier", order=1).data
+        return self._new(np.sqrt(gx**2 + gy**2 + gz**2), name=f"{self.name}_TG")
+
+    def lw(self, method: str = "SG", dz_method: str = "isvd",
+           deg: int = 4, win: int = 5, fs_tap: int = 5) -> "Grid":
+        gx = self.dx(method=method, deg=deg, win=win, fs_tap=fs_tap).data
+        gy = self.dy(method=method, deg=deg, win=win, fs_tap=fs_tap).data
+        if dz_method.lower() == "isvd":
+            gz = self.isvd(method=method, order=1, deg=deg, win=win, fs_tap=fs_tap).data
+            gzz = self.isvd(method=method, order=2, deg=deg, win=win, fs_tap=fs_tap).data
+        else:
+            gz = self.dz(method="fourier", order=1).data
+            gzz = self.dz(method="fourier", order=2).data
+        # d/dx(dz) via a follow-up dx on gz
+        gzx = T.savgol_deriv(gz, self.cellsize, "dx", deg=deg, win=win)
+        gzy = T.savgol_deriv(gz, self.cellsize, "dy", deg=deg, win=win)
+        num = gzx * gx + gzy * gy + gzz * gz
+        den = gx * gx + gy * gy + gz * gz
+        return self._new(num / den, name=f"{self.name}_LW")
+
+    def tahg(self, method: str = "SG", dz_method: str = "isvd",
+             deg: int = 4, win: int = 5, fs_tap: int = 5, alpha: float = 1.0) -> "Grid":
+        hgm_grid = self.hgm(method=method, deg=deg, win=win, fs_tap=fs_tap)
+        out = hgm_grid.tilt(hgm_method=method, dz_method=dz_method,
+                           deg=deg, win=win, fs_tap=fs_tap, alpha=alpha)
+        out.name = f"{self.name}_TAHG"
+        return out
+
+    # ---------- continuation / filtering ----------
+    def up(self, z: float = 500.0) -> "Grid":
+        out = T.fourier_transform(self.data, self.cellsize, trans="upcont", z=z)
+        return self._new(out, name=f"{self.name}_UC{z}")
+
+    def hp_filter_uc(self, z: float = 5000.0) -> "Grid":
+        regional = T.fourier_transform(self.data, self.cellsize, trans="upcont", z=z)
+        return self._new(self.data - regional, name=f"{self.name}_HPUC{z}")
+
+    # ---------- display ----------
+    def show(self, **kwargs):
+        from interpies_lite.graphics import show_grid
+        return show_grid(self, **kwargs)
+
+    def save_image(self, output_file: str, **kwargs) -> None:
+        from interpies_lite.graphics import save_grid_image
+        save_grid_image(self, output_file, **kwargs)

interpies_lite/io.py

@@ -0,0 +1,20 @@
+"""
+interpies_lite.io
+=================
+
+Thin wrapper around rasterio for opening single-band rasters.
+"""
+from __future__ import annotations
+
+from interpies_lite.grid import Grid
+
+
+def open_rasterio(path: str, band: int = 1, name: str | None = None) -> Grid:
+    try:
+        import rasterio
+    except ImportError as e:
+        raise RuntimeError(
+            "rasterio is required to open rasters. Install with `pip install rasterio`."
+        ) from e
+    with rasterio.open(path) as ds:
+        return Grid.from_dataset(ds, band=band, name=name)

interpies_lite/smoke_test.py

@@ -0,0 +1,64 @@
+"""Smoke test: build a synthetic grid and run every transform end-to-end."""
+import sys
+from pathlib import Path
+
+import numpy as np
+
+# make the package importable when running from the repo root
+sys.path.insert(0, str(Path(__file__).resolve().parent))
+
+from interpies_lite import Grid
+import interpies_lite as ip
+
+
+def make_synthetic(n=120):
+    x = np.linspace(-5000, 5000, n)
+    y = np.linspace(-5000, 5000, n)
+    XX, YY = np.meshgrid(x, y)
+    # two Gaussian anomalies + a linear trend + noise
+    g1 = 80 * np.exp(-((XX - 1500) ** 2 + (YY - 800) ** 2) / (2 * 800**2))
+    g2 = -50 * np.exp(-((XX + 1800) ** 2 + (YY + 1200) ** 2) / (2 * 1000**2))
+    trend = 0.002 * XX + 0.001 * YY
+    rng = np.random.default_rng(0)
+    data = g1 + g2 + trend + rng.normal(0, 0.5, size=XX.shape)
+    return Grid.from_array(data, west=0, north=10000, cellsize=100, crs="EPSG:32633", name="synth")
+
+
+def main():
+    g = make_synthetic()
+    print("== grid.info() ==")
+    g.info()
+
+    print("\n== derivatives ==")
+    for m in [g.dx(), g.dy(), g.dx2(), g.dy2(), g.dxdy(), g.dz(method="fourier"), g.isvd()]:
+        print(f"  {m.name:20s}  range=({np.nanmin(m.data):8.2f}, {np.nanmax(m.data):8.2f})")
+
+    print("\n== enhancement transforms ==")
+    for m in [g.hgm(), g.tilt(), g.tg(), g.lw(), g.tahg()]:
+        print(f"  {m.name:20s}  range=({np.nanmin(m.data):8.2f}, {np.nanmax(m.data):8.2f})")
+
+    print("\n== continuation / filtering ==")
+    for m in [g.up(z=500), g.hp_filter_uc(z=2000), g.smooth(), g.laplacian(), g.vi()]:
+        print(f"  {m.name:20s}  range=({np.nanmin(m.data):8.2f}, {np.nanmax(m.data):8.2f})")
+
+    print("\n== preprocessing ==")
+    g2 = g.detrend(degree=1).clip(1000, 8000, -8000, -1000).resample(2)
+    print(f"  clipped/resampled shape: {g2.data.shape}, extent={g2.extent}")
+
+    print("\n== plotting (headless) ==")
+    import matplotlib
+    matplotlib.use("Agg")
+    import matplotlib.pyplot as plt
+    fig, axes = plt.subplots(2, 3, figsize=(15, 9))
+    for ax, m in zip(axes.ravel(), [g, g.hgm(), g.tilt(), g.tg(), g.up(500), g.hp_filter_uc(2000)]):
+        m.show(ax=ax, hs=True, colorbar=False)
+    out = Path(__file__).parent / "smoke_test_output.png"
+    fig.savefig(out, dpi=100, bbox_inches="tight")
+    print(f"  saved -> {out}")
+    plt.close(fig)
+
+    print("\nALL OK")
+
+
+if __name__ == "__main__":
+    main()

interpies_lite/spatial.py

@@ -0,0 +1,27 @@
+"""
+interpies_lite.spatial
+======================
+
+Lightweight coordinate helpers.  Uses pyproj when available; falls back to
+a no-op with a warning.
+"""
+from __future__ import annotations
+
+import numpy as np
+
+
+def project_points(points, src_srs: str = "EPSG:4326", dst_srs: str = "EPSG:32633"):
+    """Reproject an (N, 2) array of points from src_srs to dst_srs."""
+    try:
+        from pyproj import Transformer
+    except ImportError:
+        raise RuntimeError("pyproj is required: pip install pyproj")
+    t = Transformer.from_crs(src_srs, dst_srs, always_xy=True)
+    pts = np.asarray(points, dtype=float)
+    x, y = t.transform(pts[:, 0], pts[:, 1])
+    return np.column_stack([x, y])
+
+
+def grid_extent(west: float, north: float, cellsize: float, nrows: int, ncols: float):
+    """Return matplotlib-style [left, right, bottom, top]."""
+    return [west, west + ncols * cellsize, north - nrows * cellsize, north]

interpies_lite/transforms.py

@@ -0,0 +1,227 @@
+"""
+interpies_lite.transforms
+==========================
+
+Pure-numpy/scipy implementations of potential-field transforms:
+derivatives (Savitzky-Golay / finite-sample / Fourier), vertical derivative
+via the ISVD (integrated second vertical derivative) method, upward
+continuation, vertical integration, detrending and padding helpers.
+
+No rasterio / GDAL / obspy dependency here.
+"""
+from __future__ import annotations
+
+from typing import Literal
+
+import numpy as np
+from numpy.typing import ArrayLike
+from scipy import ndimage as ndi
+from scipy import signal
+from sklearn.linear_model import LinearRegression
+from sklearn.pipeline import Pipeline
+from sklearn.preprocessing import PolynomialFeatures
+
+
+def replace_edges(data: np.ndarray, ncells: int = 1) -> np.ndarray:
+    out = data.copy()
+    for i in range(ncells):
+        out[i, :] = out[ncells, :]
+        out[-1 - i, :] = out[-1 - ncells, :]
+        out[:, i] = out[:, ncells]
+        out[:, -1 - i] = out[:, -1 - ncells]
+    return out
+
+
+def fill_nodata(data: np.ndarray, invalid: np.ndarray | None = None) -> np.ndarray:
+    if invalid is None:
+        invalid = ~np.isfinite(data)
+    if not invalid.any():
+        return data.copy()
+    return ndi.generic_filter(
+        np.where(invalid, np.nan, data),
+        lambda v: np.nanmean(v),
+        size=3,
+        mode="nearest",
+    )
+
+
+def simple_resample(data: np.ndarray, sampling: int = 2) -> np.ndarray:
+    return data[::sampling, ::sampling]
+
+
+def stats(data: np.ndarray) -> dict:
+    arr = data[np.isfinite(data)]
+    return {
+        "min": float(np.min(arr)),
+        "max": float(np.max(arr)),
+        "mean": float(np.mean(arr)),
+        "std": float(np.std(arr)),
+        "median": float(np.median(arr)),
+        "p02": float(np.percentile(arr, 2)),
+        "p98": float(np.percentile(arr, 98)),
+    }
+
+
+def find_trend(point_coords: ArrayLike, data: ArrayLike, degree: int = 1, return_model: bool = False):
+    X = np.asarray(point_coords)
+    y = np.asarray(data).ravel()
+    mask = np.isfinite(y)
+    model = Pipeline([("poly", PolynomialFeatures(degree=degree)), ("reg", LinearRegression())])
+    model.fit(X[mask], y[mask])
+    if return_model:
+        return model
+    return model.predict(X).reshape(np.asarray(data).shape)
+
+
+def savgol2d(degree: int, window_size: int) -> np.ndarray:
+    if window_size % 2 == 0:
+        raise ValueError("window_size must be odd")
+    half = window_size // 2
+    x = np.arange(-half, half + 1)
+    order = np.arange(degree + 1)
+    V = x[:, None] ** order[None, :]
+    coef_0 = np.linalg.pinv(V)[0]
+    kernel = np.outer(coef_0, coef_0)
+    return kernel / kernel.sum()
+
+
+def savgol_smooth(data: np.ndarray, deg: int = 3, win: int = 5, do_edges: bool = False) -> np.ndarray:
+    kernel = savgol2d(deg, win)
+    out = signal.convolve2d(np.nan_to_num(data), kernel, mode="same", boundary="symm")
+    if do_edges:
+        out = replace_edges(out, ncells=win // 2)
+    return out
+
+
+def savgol_deriv(
+    data: np.ndarray,
+    cellsize: float,
+    direction: Literal["dx", "dy"] = "dx",
+    deg: int = 3,
+    win: int = 5,
+    do_edges: bool = True,
+) -> np.ndarray:
+    if win % 2 == 0:
+        raise ValueError("win must be odd")
+    c_dx = signal.savgol_coeffs(win, deg, deriv=1, use="dot")
+    c_smooth = signal.savgol_coeffs(win, deg, deriv=0, use="dot")
+    if direction == "dx":
+        kx, ky = c_dx.reshape(1, -1), c_smooth.reshape(-1, 1)
+    else:
+        kx, ky = c_smooth.reshape(1, -1), c_dx.reshape(-1, 1)
+    kernel = ky @ kx
+    out = signal.convolve2d(np.nan_to_num(data), kernel, mode="same", boundary="symm") / cellsize
+    if do_edges:
+        out = replace_edges(out, ncells=win // 2)
+    return out
+
+
+def fs_coefficients(tap: int = 5) -> np.ndarray:
+    x = np.arange(-tap, tap + 1, dtype=float)
+    A = np.vstack([np.ones_like(x), x]).T
+    return np.linalg.pinv(A)[1]
+
+
+def fs_deriv(data: np.ndarray, cellsize: float, direction: Literal["dx", "dy"] = "dx", tap: int = 5) -> np.ndarray:
+    c = fs_coefficients(tap)
+    kernel = c.reshape(1, -1) if direction == "dx" else c.reshape(-1, 1)
+    return signal.convolve2d(np.nan_to_num(data), kernel, mode="same", boundary="symm") / cellsize
+
+
+def next_pow2(x: int) -> int:
+    p = 1
+    while p < x:
+        p <<= 1
+    return p
+
+
+def getk(nx: int, ny: int, dx: float, dy: float):
+    fx = np.fft.fftfreq(nx, d=dx)
+    fy = np.fft.fftfreq(ny, d=dy)
+    kx, ky = np.meshgrid(2 * np.pi * fx, 2 * np.pi * fy)
+    return kx, ky, np.sqrt(kx**2 + ky**2)
+
+
+def pad_full(data: np.ndarray, mode: str = "reflect") -> np.ndarray:
+    ny, nx = data.shape
+    return np.pad(data, ((ny // 2, ny // 2), (nx // 2, nx // 2)), mode=mode)
+
+
+def unpad_full(data: np.ndarray, nrows: int, ncols: int) -> np.ndarray:
+    return data[nrows // 2:nrows // 2 + nrows, ncols // 2:ncols // 2 + ncols]
+
+
+def fourier_transform(
+    data: np.ndarray,
+    cellsize: float,
+    trans: Literal["dx", "dy", "dxdy", "dz", "vi", "upcont"] = "dx",
+    order: int = 1,
+    z: float = 0.0,
+    eps: float = 1e-6,
+    pad: bool = True,
+) -> np.ndarray:
+    work = pad_full(data) if pad else data.copy()
+    ny, nx = work.shape
+    kx, ky, k = getk(nx, ny, cellsize, cellsize)
+    F = np.fft.fft2(np.nan_to_num(work))
+
+    if trans == "dx":
+        factor = (1j * kx) ** order
+    elif trans == "dy":
+        factor = (1j * ky) ** order
+    elif trans == "dxdy":
+        factor = (1j * kx) ** order * (1j * ky) ** order
+    elif trans == "dz":
+        factor = k**order
+    elif trans == "vi":
+        k_safe = k.copy()
+        k_safe[k_safe == 0] = eps
+        factor = k_safe ** (-order)
+    elif trans == "upcont":
+        factor = np.exp(-z * k)
+    else:
+        raise ValueError(f"Unknown transform: {trans}")
+
+    out = np.real(np.fft.ifft2(F * factor))
+    if pad:
+        out = unpad_full(out, data.shape[0], data.shape[1])
+    return out
+
+
+def isvd(
+    data: np.ndarray,
+    cellsize: float,
+    method: Literal["SG", "FS", "fourier"] = "SG",
+    order: int = 1,
+    deg: int = 4,
+    win: int = 5,
+    fs_tap: int = 5,
+    do_edges: bool = True,
+    **kwargs,
+) -> np.ndarray:
+    if method.upper() == "SG":
+        dx2 = savgol_deriv(data, cellsize, "dx", deg=deg, win=win, do_edges=do_edges)
+        dx2 = savgol_deriv(dx2, cellsize, "dx", deg=deg, win=win, do_edges=do_edges)
+        dy2 = savgol_deriv(data, cellsize, "dy", deg=deg, win=win, do_edges=do_edges)
+        dy2 = savgol_deriv(dy2, cellsize, "dy", deg=deg, win=win, do_edges=do_edges)
+    elif method.upper() == "FS":
+        dx2 = fs_deriv(fs_deriv(data, cellsize, "dx", tap=fs_tap), cellsize, "dx", tap=fs_tap)
+        dy2 = fs_deriv(fs_deriv(data, cellsize, "dy", tap=fs_tap), cellsize, "dy", tap=fs_tap)
+    else:
+        dx2 = fourier_transform(data, cellsize, trans="dx", order=2, **kwargs)
+        dy2 = fourier_transform(data, cellsize, trans="dy", order=2, **kwargs)
+
+    dz2 = -(dx2 + dy2)
+    if order == 2:
+        return dz2
+    if order == 1:
+        return fourier_transform(dz2, cellsize, trans="vi", order=1, pad=True)
+    raise NotImplementedError(f"ISVD order={order} not implemented")
+
+
+def gauss(data: np.ndarray, sigma: float = 1.0) -> np.ndarray:
+    return ndi.gaussian_filter(np.nan_to_num(data), sigma=sigma)
+
+
+def laplacian(data: np.ndarray, cellsize: float) -> np.ndarray:
+    return ndi.laplace(np.nan_to_num(data)) / (cellsize**2)

interpies_lite-0.1.0.dist-info/METADATA

@@ -0,0 +1,189 @@
+Metadata-Version: 2.5
+Name: interpies-lite
+Version: 0.1.0
+Summary: Lightweight reimplementation of interpies: potential-field grid transforms and plotting (derivatives, ISVD, upward continuation, edge enhancement).
+Project-URL: Homepage, https://github.com/xyt556/interpies-lite
+Project-URL: Repository, https://github.com/xyt556/interpies-lite
+Project-URL: Issues, https://github.com/xyt556/interpies-lite/issues
+Author-email: Yantao XI <xyt556@gmail.com>
+License: BSD 3-Clause License
+        
+        Copyright (c) 2026, interpies-lite contributors
+        All rights reserved.
+        
+        Redistribution and use in source and binary forms, with or without
+        modification, are permitted provided that the following conditions are met:
+        
+        1. Redistributions of source code must retain the above copyright notice, this
+           list of conditions and the following disclaimer.
+        
+        2. Redistributions in binary form must reproduce the above copyright notice,
+           this list of conditions and the following disclaimer in the documentation
+           and/or other materials provided with the distribution.
+        
+        3. Neither the name of the copyright holder nor the names of its
+           contributors may be used to endorse or promote products derived from
+           this software without specific prior written permission.
+        
+        THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+        AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+        IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+        DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+        FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+        DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+        SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+        CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+        OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+        OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+License-File: LICENSE
+Keywords: derivatives,edge-detection,geophysics,gravity,isvd,magnetics,potential-field,raster,remote-sensing,tilt,upward-continuation
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: BSD License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Scientific/Engineering :: GIS
+Classifier: Topic :: Scientific/Engineering :: Physics
+Requires-Python: >=3.10
+Requires-Dist: matplotlib>=3.7
+Requires-Dist: numpy>=1.24
+Requires-Dist: scikit-learn>=1.2
+Requires-Dist: scipy>=1.10
+Provides-Extra: dev
+Requires-Dist: build>=1.2; extra == 'dev'
+Requires-Dist: pytest>=8.0; extra == 'dev'
+Requires-Dist: twine>=5.0; extra == 'dev'
+Provides-Extra: geo
+Requires-Dist: pyproj>=3.5; extra == 'geo'
+Requires-Dist: rasterio>=1.3; extra == 'geo'
+Description-Content-Type: text/markdown
+
+# interpies_lite
+
+对原 `interpies` 库的轻量重实现。目标：解决原库依赖钉死（`gdal==3.8.4`）、久未更新的问题，保留核心功能与 API 习惯。
+
+## 与原库的差异
+
+| 维度 | 原 interpies | interpies_lite |
+| --- | --- | --- |
+| 栅格读写 | rasterio + 钉死 gdal==3.8.4 | rasterio>=1.3（可选，未装时只能用 `Grid.from_array`） |
+| SEGY 模块 | obspy 依赖 | 砍掉 |
+| 色表数据 | 35 KB 硬编码 LUT | 内置 Geosoft clra / parula 近似色表，其他直接用 matplotlib 色表 |
+| Grid 实现 | 普通类 + 手写属性 | `@dataclass` + property，类型注解完整 |
+| 依赖 | numpy/scipy/matplotlib/rasterio/gdal/scikit-image/scikit-learn | numpy/scipy/matplotlib/scikit-learn（rasterio/pyproj 可选） |
+| Python | >=3.10 | >=3.10 |
+
+## 模块
+
+```
+interpies_lite/
+├── __init__.py     # open() / Grid
+├── grid.py         # Grid 类：IO、几何、预处理、全部位场方法
+├── transforms.py   # 纯算法：导数、ISVD、傅里叶变换、延拓、平滑
+├── graphics.py     # show / save_image：晕渲、色图、等值线
+├── colors.py       # 内置色表
+├── spatial.py      # pyproj 点投影（可选）
+└── io.py           # rasterio 封装
+```
+
+## 快速开始
+
+```python
+import interpies_lite as ip
+
+# 从文件加载（需要 rasterio）
+g = ip.open("data/brtpgrd.gxf")
+g.info()
+
+# 从 numpy 数组构造（无任何重依赖）
+import numpy as np
+data = np.random.randn(100, 100)
+g = ip.Grid.from_array(data, west=0, north=0, cellsize=100, crs="EPSG:32633")
+
+# 链式调用：去趋势 → 平滑 → 边界识别
+out = g.detrend(degree=1).smooth(win=5).tilt()
+out.show()
+
+# 可用变换（全部返回新 Grid）：
+#   dx / dy / dx2 / dy2 / dxdy / dz / isvd / vi
+#   hgm / tilt / tg / lw / tahg
+#   up(z) / hp_filter_uc(z) / laplacian
+#   clip / resample / scale / detrend / fill_nodata / smooth
+```
+
+## 安装
+
+本包暂未发布到 PyPI，可通过以下任一方式安装：
+
+### 方式 1：从 GitHub 直接安装（推荐）
+
+公开仓库，无需下载，pip 自动拉取最新代码：
+
+```bash
+pip install git+https://github.com/xyt556/interpies-lite.git
+```
+
+指定版本/分支：
+
+```bash
+pip install git+https://github.com/xyt556/interpies-lite.git@main
+```
+
+### 方式 2：从本地目录安装
+
+```bash
+cd path/to/interpies_lite
+pip install .
+```
+
+### 方式 3：从 wheel 文件安装
+
+```bash
+pip install dist/interpies_lite-0.1.0-py3-none-any.whl
+```
+
+### 方式 4：开发模式（可编辑，改代码即时生效）
+
+```bash
+cd path/to/interpies_lite
+pip install -e .
+```
+
+### 可选依赖（读写 GeoTIFF/GXF）
+
+```bash
+pip install "interpies-lite[geo]"
+# 等价于
+pip install rasterio pyproj
+```
+
+核心依赖（必装）：numpy、scipy、matplotlib、scikit-learn。
+
+## 示例
+
+仓库自带两个 notebook：
+
+| Notebook | 数据 | 内容 |
+| --- | --- | --- |
+| `notebooks/interpies_lite_demo.ipynb` | 合成数据 | 快速上手，无需 rasterio，开箱即跑 |
+| `notebooks/interpies_lite_brtpgrd_demo.ipynb` | `data/brtpgrd.gxf`（真实航磁） | 课堂版完整教程，含算法原理与公式 |
+
+克隆仓库后：
+
+```bash
+cd interpies_lite
+pip install -e .[geo]
+jupyter notebook notebooks/
+```
+
+`data/brtpgrd.gxf` 为 Colorado 地区航磁数据（707×629，50 m，NAD27/UTM13N），来自原 interpies 项目示例。
+
+## 冒烟测试
+
+```bash
+python smoke_test.py
+# 在合成网格上跑通全部变换，输出 smoke_test_output.png
+```

interpies_lite-0.1.0.dist-info/RECORD

@@ -0,0 +1,12 @@
+interpies_lite/__init__.py,sha256=2Dfz8DgJjVgB2w6yLMQh5MWSDEtZFjfUla52z3klrjo,671
+interpies_lite/colors.py,sha256=Q8AY5CWIHJ8NXNVbB7lT3a93guaqqpVOHyzhxFrrTzE,1665
+interpies_lite/graphics.py,sha256=UTXzzSdpRtuPyfSW-l_Ot_rFlTCwUVOlEiM54TrTflo,4844
+interpies_lite/grid.py,sha256=aqRN0RqKwyZKdjxlBBMbaN4w7TD3b6pAiw19l2KvuaA,13727
+interpies_lite/io.py,sha256=EAmkaXC9MX9gI17PCFCRMNKP4tluSUu9xcCDzRkI3ZE,551
+interpies_lite/smoke_test.py,sha256=RFXtdAwOUOkizQIKoLkKQ0XtYhhJvmWwxEpKWRbHgVk,2348
+interpies_lite/spatial.py,sha256=6uF3Kz59MgJfePfYjWaIwMrycHMaH6iI2BbSUwmPkRo,920
+interpies_lite/transforms.py,sha256=oxGqJtgj-GwXZlchPNHOH4xxqfymH-LxnpArd1omM5Q,7325
+interpies_lite-0.1.0.dist-info/METADATA,sha256=7Bl3MUNqbGLD7bOYTdp9nwwLduXgQ0EpkRQ2GQBSszg,6830
+interpies_lite-0.1.0.dist-info/WHEEL,sha256=W3fkpkm7-wf9vBI5Z-7s0eWkeM-spu78I8Neb98DeEg,87
+interpies_lite-0.1.0.dist-info/licenses/LICENSE,sha256=KvHyl_BBFqqqQRqfXJ3SuUL09PYyJzTmS2Nqt8CMCPk,1535
+interpies_lite-0.1.0.dist-info/RECORD,,

interpies_lite-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.32.4
+Root-Is-Purelib: true
+Tag: py3-none-any

interpies_lite-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,29 @@
+BSD 3-Clause License
+
+Copyright (c) 2026, interpies-lite contributors
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+
+3. Neither the name of the copyright holder nor the names of its
+   contributors may be used to endorse or promote products derived from
+   this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.