openrelief 0.1.0__py3-none-any.whl

openrelief/__init__.py

@@ -0,0 +1,22 @@
+"""rrim - Red Relief Image Map generation from Digital Elevation Models.
+
+Public API
+----------
+    from openrelief import ReliefConfig, relief_from_dems, relief_array
+
+`relief_from_dems` is the high-level entry point: give it one or more DEM files
+and it builds a seamless RRIM mosaic GeoTIFF (and optional PNG preview),
+processing windows in parallel and using a GPU automatically when available.
+"""
+from .config import ReliefConfig
+from .backend import gpu_available
+from .core import relief_from_dems, relief_array
+
+__version__ = "0.1.0"
+__all__ = [
+    "ReliefConfig",
+    "relief_from_dems",
+    "relief_array",
+    "gpu_available",
+    "__version__",
+]

openrelief/backend.py

@@ -0,0 +1,66 @@
+"""Array-backend selection: NumPy (CPU) or CuPy (GPU).
+
+The rest of the package is written against a generic array module ``xp`` so the
+exact same kernels run on CPU and GPU.  GPU is used automatically when CuPy is
+installed *and* a CUDA device is visible, unless the caller forces a backend.
+"""
+from __future__ import annotations
+
+import os
+from typing import Any, Tuple
+
+import numpy as np
+
+_FORCE = os.environ.get("OPENRELIEF_BACKEND", "").lower()  # "cpu", "gpu", or ""
+
+
+def gpu_available() -> bool:
+    """True if CuPy is importable and at least one CUDA device is present."""
+    if _FORCE == "cpu":
+        return False
+    try:
+        import cupy as cp  # noqa: F401
+
+        return cp.cuda.runtime.getDeviceCount() > 0
+    except Exception:
+        return False
+
+
+def get_backend(use_gpu: bool | None = None) -> Tuple[Any, bool]:
+    """Return ``(xp, is_gpu)``.
+
+    Parameters
+    ----------
+    use_gpu : bool | None
+        None  -> auto-detect (GPU if available)
+        True  -> require GPU (raises if unavailable)
+        False -> force CPU / NumPy
+    """
+    if _FORCE == "gpu":
+        use_gpu = True
+    elif _FORCE == "cpu":
+        use_gpu = False
+
+    if use_gpu is None:
+        use_gpu = gpu_available()
+
+    if use_gpu:
+        try:
+            import cupy as cp
+
+            if cp.cuda.runtime.getDeviceCount() == 0:
+                raise RuntimeError("No CUDA device visible")
+            return cp, True
+        except Exception as exc:  # pragma: no cover - depends on hardware
+            if _FORCE == "gpu" or use_gpu is True:
+                raise RuntimeError(f"GPU backend requested but unavailable: {exc}")
+            return np, False
+    return np, False
+
+
+def to_cpu(arr: Any) -> "np.ndarray":
+    """Bring an array back to host memory as a NumPy array."""
+    get = getattr(arr, "get", None)
+    if callable(get):
+        return get()
+    return np.asarray(arr)

openrelief/cli.py

@@ -0,0 +1,112 @@
+"""Command-line interface:  rrim INPUT... -o OUTPUT [options]"""
+from __future__ import annotations
+
+import argparse
+import sys
+
+from .config import ReliefConfig
+from .backend import gpu_available
+from .core import relief_from_dems
+
+
+def build_parser() -> argparse.ArgumentParser:
+    d = ReliefConfig()
+    p = argparse.ArgumentParser(
+        prog="openrelief",
+        description="Generate a Red Relief Image Map (RRIM) from DEM(s). "
+                    "Accepts a file, a folder, a glob, or several paths; "
+                    "multiple tiles are mosaicked seamlessly.",
+        formatter_class=argparse.ArgumentDefaultsHelpFormatter,
+    )
+    p.add_argument("inputs", nargs="+",
+                   help="DEM file(s), a directory of DEMs, or a glob pattern.")
+    p.add_argument("-o", "--output", required=True,
+                   help="Output RGB GeoTIFF path.")
+    p.add_argument("--preview", default=None,
+                   help="PNG preview path (default: OUTPUT with .png suffix).")
+    p.add_argument("--no-preview", action="store_true",
+                   help="Skip the PNG preview.")
+
+    g = p.add_argument_group("openness")
+    g.add_argument("--radius", type=int, default=d.openness_radius,
+                   help="Openness search length in pixels.")
+    g.add_argument("--directions", type=int, default=d.n_directions,
+                   choices=[4, 8, 16], help="Azimuth directions for openness.")
+    g.add_argument("--openness-range", type=float, default=d.openness_range,
+                   help="Differential openness (deg) mapped to black..white.")
+    g.add_argument("--openness-gamma", type=float, default=d.openness_gamma)
+
+    g = p.add_argument_group("slope / colour")
+    g.add_argument("--slope-max", type=float, default=d.slope_max,
+                   help="Slope (deg) mapped to full red.")
+    g.add_argument("--slope-gamma", type=float, default=d.slope_gamma)
+    g.add_argument("--opacity", type=float, default=d.opacity,
+                   help="Openness layer opacity over the slope layer (0..1).")
+    g.add_argument("--z-factor", type=float, default=d.z_factor,
+                   help="Elevation unit -> ground unit multiplier "
+                        "(e.g. 0.3048 if Z is feet and XY metres).")
+
+    g = p.add_argument_group("performance")
+    g.add_argument("--window", type=int, default=d.window_size,
+                   help="Processing window size in pixels (when not --auto-window).")
+    g.add_argument("--jobs", type=int, default=d.n_jobs,
+                   help="CPU worker processes (-1 = all cores).")
+    g.add_argument("--auto-window", action="store_true",
+                   help="Size windows from the core count instead of --window.")
+    g.add_argument("--tiles-per-core", type=int, default=d.tiles_per_core,
+                   help="With --auto-window, tiles per core (1 = one tile per "
+                        "processor; higher = better load balancing).")
+    mx = g.add_mutually_exclusive_group()
+    mx.add_argument("--gpu", action="store_true", help="Force GPU (CuPy).")
+    mx.add_argument("--cpu", action="store_true", help="Force CPU.")
+
+    g = p.add_argument_group("output")
+    g.add_argument("--compress", default=d.compress,
+                   choices=["deflate", "lzw", "zstd", "none"])
+    g.add_argument("--preview-size", type=int, default=d.preview_max_size,
+                   help="Longest side of the PNG preview in pixels.")
+    g.add_argument("-q", "--quiet", action="store_true")
+    p.add_argument("--check-gpu", action="store_true",
+                   help="Report whether a GPU backend is available and exit.")
+    return p
+
+
+def main(argv=None) -> int:
+    argv = list(sys.argv[1:] if argv is None else argv)
+    if "--check-gpu" in argv:
+        print("GPU available:", gpu_available())
+        return 0
+
+    args = build_parser().parse_args(argv)
+
+    use_gpu = True if args.gpu else (False if args.cpu else None)
+    cfg = ReliefConfig(
+        openness_radius=args.radius,
+        n_directions=args.directions,
+        openness_range=args.openness_range,
+        openness_gamma=args.openness_gamma,
+        slope_max=args.slope_max,
+        slope_gamma=args.slope_gamma,
+        opacity=args.opacity,
+        z_factor=args.z_factor,
+        window_size=args.window,
+        n_jobs=args.jobs,
+        auto_window=args.auto_window,
+        tiles_per_core=args.tiles_per_core,
+        use_gpu=use_gpu,
+        compress=args.compress,
+        make_preview=not args.no_preview,
+        preview_max_size=args.preview_size,
+    )
+
+    try:
+        relief_from_dems(args.inputs, args.output, cfg,
+                       preview=args.preview, verbose=not args.quiet)
+    except Exception as exc:
+        print(f"openrelief: error: {exc}", file=sys.stderr)
+        return 1
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

openrelief/color.py

@@ -0,0 +1,42 @@
+"""Compose the RRIM RGB image from slope and openness layers."""
+from __future__ import annotations
+
+from typing import Any
+
+from .config import ReliefConfig
+
+
+def compose_rgb(slope, pos_open, neg_open, cfg: ReliefConfig, xp: Any):
+    """Return a uint8 array of shape (3, H, W) = the RRIM (R, G, B).
+
+    Red/slope layer : flat = white (255,255,255), steep = red (255,0,0).
+    Grey/openness   : differential openness (pos-neg)/2, ridge bright / valley dark.
+    Blend           : grey layer multiplied onto red layer at ``opacity``.
+    """
+    # --- slope -> red saturation -------------------------------------------
+    s = xp.clip(slope / cfg.slope_max, 0.0, 1.0)
+    if cfg.slope_gamma != 1.0:
+        s = s ** cfg.slope_gamma
+    r = xp.full_like(slope, 255.0)
+    gb = 255.0 * (1.0 - s)          # green & blue channels fade out with slope
+
+    # --- differential openness -> brightness -------------------------------
+    diff = 0.5 * (pos_open - neg_open)
+    rng = cfg.openness_range
+    g = xp.clip((diff + rng) / (2.0 * rng), 0.0, 1.0)
+    if cfg.openness_gamma != 1.0:
+        g = g ** cfg.openness_gamma
+
+    # --- multiply blend with opacity ---------------------------------------
+    a = cfg.opacity
+    factor = (1.0 - a) + a * g       # in [1-a, 1]
+
+    R = r * factor
+    G = gb * factor
+    B = gb * factor
+
+    # No-data (NaN anywhere) -> black; clip and cast.
+    rgb = xp.stack([R, G, B], axis=0)
+    rgb = xp.where(xp.isfinite(rgb), rgb, 0.0)
+    rgb = xp.clip(rgb + 0.5, 0.0, 255.0).astype(xp.uint8)
+    return rgb

openrelief/config.py

@@ -0,0 +1,89 @@
+"""Configuration for RRIM generation.
+
+Defaults reproduce the classic Asia Air Survey "Red Relief Image Map" look
+(Chiba, Kaneta & Suzuki, 2008) built on topographic openness
+(Yokoyama, Shirasawa & Pike, 2002):
+
+    * slope          -> red saturation (flat = white, steep = red)
+    * differential   -> brightness     (ridge = light, valley = dark)
+      openness
+    * combined with a 50% "multiply" blend.
+
+Every visual knob is exposed so the output can be tuned for a given terrain.
+"""
+from __future__ import annotations
+
+from dataclasses import dataclass, asdict
+from typing import Optional
+
+
+@dataclass
+class ReliefConfig:
+    # --- Openness -----------------------------------------------------------
+    openness_radius: int = 30
+    """Search length L for openness, in pixels. Larger = broader relief,
+    more compute (cost is ~ O(8 * radius))."""
+
+    n_directions: int = 8
+    """Number of azimuth directions sampled for openness (8 is standard)."""
+
+    # --- Elevation / units --------------------------------------------------
+    z_factor: float = 1.0
+    """Multiplier applied to elevation values so they match the horizontal
+    ground unit of the DEM (e.g. set 0.3048 if Z is in feet but XY in metres,
+    or 3.28084 for the reverse). 1.0 means Z and XY already share a unit."""
+
+    # --- Slope -> red -------------------------------------------------------
+    slope_max: float = 50.0
+    """Slope (degrees) that maps to fully saturated red. Steeper is clipped."""
+
+    slope_gamma: float = 1.0
+    """Gamma applied to the normalised slope before colouring (<1 boosts gentle
+    slopes, >1 suppresses them)."""
+
+    # --- Differential openness -> brightness --------------------------------
+    openness_range: float = 30.0
+    """Differential openness (degrees) mapped to the black..white range.
+    Brightness = clip(((pos-neg)/2 + range) / (2*range), 0, 1).
+    Using a fixed value keeps a multi-tile mosaic seam-free."""
+
+    openness_gamma: float = 1.0
+    """Gamma applied to the normalised brightness layer."""
+
+    # --- Compositing --------------------------------------------------------
+    opacity: float = 0.5
+    """Opacity of the grey openness layer multiplied onto the red slope layer
+    (0 = pure slope colour, 1 = pure openness shading). 0.5 is the AAS default."""
+
+    # --- Pipeline / performance --------------------------------------------
+    window_size: int = 2048
+    """Side length (pixels) of the processing windows. Each window is handled
+    independently, enabling parallelism and bounded memory use."""
+
+    n_jobs: int = -1
+    """Parallel worker processes for CPU windows (-1 = all cores). Ignored on
+    GPU, where windows are streamed sequentially to one device."""
+
+    auto_window: bool = False
+    """If True, ignore ``window_size`` and size the windows from the worker
+    count so there are about ``n_jobs * tiles_per_core`` tiles in total."""
+
+    tiles_per_core: int = 4
+    """Oversubscription factor for ``auto_window``. 4 keeps every core fed while
+    bounding memory; set to 1 for exactly one tile per processor (less balanced,
+    larger per-worker memory). Higher values balance better but add halo
+    overhead."""
+
+    use_gpu: Optional[bool] = None
+    """None = auto (GPU if CuPy + CUDA present); True = force GPU; False = CPU."""
+
+    # --- Output -------------------------------------------------------------
+    compress: str = "deflate"
+    """GeoTIFF compression (deflate, lzw, zstd, none)."""
+
+    make_preview: bool = True
+    preview_max_size: int = 4000
+    """Longest side (pixels) of the PNG quick-look preview."""
+
+    def to_dict(self) -> dict:
+        return asdict(self)

openrelief/core.py

@@ -0,0 +1,253 @@
+"""High-level orchestration: DEM(s) -> seamless RRIM mosaic GeoTIFF + preview.
+
+Works with any DEM rasterio can read (GeoTIFF, USGS .dem, IMG, ASC, VRT, ...),
+any CRS, and any pixel/elevation unit. Nothing about a particular dataset is
+hard-coded: CRS, no-data, pixel size, dtype and extent are all read from the
+source. Horizontal distances are derived in ground units (metres) so the same
+algorithm is correct for projected and geographic DEMs alike.
+"""
+from __future__ import annotations
+
+import glob
+import math
+import os
+import tempfile
+import time
+from typing import List, Optional, Sequence, Tuple, Union
+
+import numpy as np
+import rasterio
+
+from .backend import get_backend, to_cpu, gpu_available
+from .config import ReliefConfig
+from . import terrain, color, raster
+
+PathLike = Union[str, os.PathLike]
+
+_DEM_EXTS = (".tif", ".tiff", ".dem", ".img", ".asc", ".vrt", ".bil",
+             ".flt", ".dt0", ".dt1", ".dt2", ".hgt", ".nc", ".grd")
+
+
+# --------------------------------------------------------------------------- #
+# Input resolution & geodesy helpers
+# --------------------------------------------------------------------------- #
+def _collect_inputs(inputs: Union[PathLike, Sequence[PathLike]]) -> List[str]:
+    """Normalise a file, directory, glob, or list into a sorted file list."""
+    if isinstance(inputs, (str, os.PathLike)):
+        inputs = [inputs]
+    files: List[str] = []
+    for item in inputs:
+        item = os.fspath(item)
+        if os.path.isdir(item):
+            for f in sorted(os.listdir(item)):
+                if f.lower().endswith(_DEM_EXTS):
+                    files.append(os.path.join(item, f))
+        elif any(ch in item for ch in "*?[") and not os.path.exists(item):
+            files.extend(sorted(glob.glob(item)))
+        else:
+            files.append(item)
+    if not files:
+        raise FileNotFoundError(f"No DEM files found in: {inputs}")
+    return files
+
+
+def ground_resolution(ds) -> Tuple[float, float]:
+    """Pixel size in ground metres, regardless of CRS.
+
+    * projected CRS -> native pixel size scaled by the linear unit (m/ft/...);
+    * geographic CRS -> degrees converted to metres at the dataset centre.
+    """
+    t = ds.transform
+    rx = abs(t.a)
+    ry = abs(t.e)
+    crs = ds.crs
+    if crs is None:
+        return rx, ry  # unknown -> assume already metres
+    if crs.is_geographic:
+        lat = math.radians((ds.bounds.top + ds.bounds.bottom) / 2.0)
+        m_per_deg_lat = 111132.92 - 559.82 * math.cos(2 * lat) + 1.175 * math.cos(4 * lat)
+        m_per_deg_lon = 111412.84 * math.cos(lat) - 93.5 * math.cos(3 * lat)
+        return rx * m_per_deg_lon, ry * m_per_deg_lat
+    # projected: scale by linear unit (metres per CRS unit)
+    try:
+        factor = crs.linear_units_factor[1]
+    except Exception:
+        factor = 1.0
+    return rx * factor, ry * factor
+
+
+def _choose_window(width: int, height: int, cfg: ReliefConfig,
+                   is_gpu: bool) -> int:
+    """Pick a window side length in pixels.
+
+    With ``cfg.auto_window`` (CPU only) the window is derived from the worker
+    count so the raster splits into roughly ``n_jobs * tiles_per_core`` square
+    tiles -- set ``tiles_per_core=1`` for one tile per processor. Otherwise the
+    explicit ``cfg.window_size`` is used.
+    """
+    if not cfg.auto_window or is_gpu:
+        return cfg.window_size
+    n_jobs = cfg.n_jobs if cfg.n_jobs and cfg.n_jobs > 0 else (os.cpu_count() or 1)
+    target_tiles = max(1, n_jobs * max(1, cfg.tiles_per_core))
+    win = int(math.ceil(math.sqrt((width * height) / target_tiles)))
+    # round to a multiple of 256 for tidy I/O, keep within sane bounds
+    win = max(256, int(round(win / 256.0)) * 256)
+    return min(win, max(width, height))
+
+
+# --------------------------------------------------------------------------- #
+# Pure array kernel (public API)
+# --------------------------------------------------------------------------- #
+def relief_array(z, res_x: float, res_y: float, cfg: Optional[ReliefConfig] = None,
+               xp=None):
+    """Compute an RRIM RGB array (3, H, W) uint8 from a 2-D elevation array.
+
+    ``z`` may contain NaN for no-data. ``res_x``/``res_y`` are ground sample
+    distances in the same unit as the (z_factor-scaled) elevations.
+    """
+    cfg = cfg or ReliefConfig()
+    if xp is None:
+        xp, _ = get_backend(cfg.use_gpu)
+
+    z = xp.asarray(z, dtype=xp.float32)
+    if cfg.z_factor != 1.0:
+        z = z * cfg.z_factor
+
+    slope = terrain.slope_degrees(z, res_x, res_y, xp)
+    pos, neg = terrain.openness(z, res_x, res_y, cfg.openness_radius, xp,
+                                cfg.n_directions)
+    rgb = color.compose_rgb(slope, pos, neg, cfg, xp)
+    return to_cpu(rgb)
+
+
+# --------------------------------------------------------------------------- #
+# Per-window worker (top-level so it pickles for multiprocessing)
+# --------------------------------------------------------------------------- #
+def _process_tile(src_path: str, tile: raster.Tile, cfg: ReliefConfig,
+                  res_x: float, res_y: float, use_gpu: bool):
+    xp, _ = get_backend(use_gpu)
+    with rasterio.open(src_path) as ds:
+        arr = ds.read(1, window=tile.read_window).astype("float32")
+        nodata = ds.nodata
+    if nodata is not None:
+        arr[arr == np.float32(nodata)] = np.nan
+    arr[~np.isfinite(arr)] = np.nan
+
+    # Skip windows that hold no data (common in sparse mosaics of scattered
+    # tiles): the output stays black without paying for the openness scan.
+    if not np.isfinite(arr).any():
+        inner = np.zeros((3, tile.height, tile.width), dtype=np.uint8)
+        return (tile.col_off, tile.row_off, tile.width, tile.height), inner
+
+    rgb = relief_array(arr, res_x, res_y, cfg, xp=xp)  # full padded window
+    r0, r1 = tile.inner_slice[0].start, tile.inner_slice[0].stop
+    c0, c1 = tile.inner_slice[1].start, tile.inner_slice[1].stop
+    inner = rgb[:, r0:r1, c0:c1]
+    return (tile.col_off, tile.row_off, tile.width, tile.height), inner
+
+
+# --------------------------------------------------------------------------- #
+# Main entry point
+# --------------------------------------------------------------------------- #
+def relief_from_dems(inputs: Union[PathLike, Sequence[PathLike]],
+                   output: PathLike,
+                   cfg: Optional[ReliefConfig] = None,
+                   preview: Optional[PathLike] = None,
+                   verbose: bool = True) -> dict:
+    """Generate an RRIM GeoTIFF (and PNG preview) from one or more DEMs.
+
+    Parameters
+    ----------
+    inputs  : DEM file, directory of DEMs, glob, or list of paths.
+    output  : destination RGB GeoTIFF path.
+    cfg     : ReliefConfig (defaults reproduce the Asia Air Survey style).
+    preview : PNG path; defaults to ``output`` with a .png suffix when
+              ``cfg.make_preview`` is True.
+
+    Returns a small summary dict.
+    """
+    cfg = cfg or ReliefConfig()
+    output = os.fspath(output)
+    files = _collect_inputs(inputs)
+
+    xp, is_gpu = get_backend(cfg.use_gpu)
+    if verbose:
+        dev = "GPU (CuPy)" if is_gpu else f"CPU ({cfg.n_jobs if cfg.n_jobs>0 else os.cpu_count()} workers)"
+        print(f"[openrelief] {len(files)} input(s) -> {output}")
+        print(f"[openrelief] backend: {dev}")
+
+    workdir = tempfile.mkdtemp(prefix="openrelief_")
+    src_path, is_tmp_vrt = raster.open_source(files, workdir)
+
+    t_start = time.time()
+    with rasterio.open(src_path) as ds:
+        profile = ds.profile
+        width, height = ds.width, ds.height
+        res_x, res_y = ground_resolution(ds)
+        if verbose:
+            print(f"[openrelief] mosaic: {width} x {height} px, "
+                  f"ground res ~{res_x:.3f} x {res_y:.3f} m, "
+                  f"openness radius {cfg.openness_radius} px")
+
+    halo = cfg.openness_radius + 1
+    window = _choose_window(width, height, cfg, is_gpu)
+    tiles = raster.make_tiles(width, height, window, halo)
+    if verbose:
+        mode = "auto" if (cfg.auto_window and not is_gpu) else "fixed"
+        print(f"[openrelief] {len(tiles)} window(s) of {window} px ({mode}) "
+              f"(+{halo} px halo)")
+
+    os.makedirs(os.path.dirname(os.path.abspath(output)), exist_ok=True)
+    dst = raster.create_rgb_geotiff(output, profile, cfg.compress)
+    try:
+        done = 0
+        if is_gpu:
+            # One CUDA device: stream windows sequentially.
+            for tile in tiles:
+                (co, ro, w, h), inner = _process_tile(
+                    src_path, tile, cfg, res_x, res_y, True)
+                dst.write(inner, window=rasterio.windows.Window(co, ro, w, h))
+                done += 1
+                if verbose and done % 10 == 0:
+                    print(f"[openrelief]   {done}/{len(tiles)} windows", flush=True)
+        else:
+            from joblib import Parallel, delayed
+            results = Parallel(n_jobs=cfg.n_jobs, backend="loky",
+                               return_as="generator_unordered")(
+                delayed(_process_tile)(src_path, tile, cfg, res_x, res_y, False)
+                for tile in tiles)
+            for (co, ro, w, h), inner in results:
+                dst.write(inner, window=rasterio.windows.Window(co, ro, w, h))
+                done += 1
+                if verbose and done % 10 == 0:
+                    print(f"[openrelief]   {done}/{len(tiles)} windows", flush=True)
+    finally:
+        dst.close()
+
+    elapsed = time.time() - t_start
+    if verbose:
+        print(f"[openrelief] wrote {output} in {elapsed:.1f}s")
+
+    preview_path = None
+    if cfg.make_preview:
+        preview_path = os.fspath(preview) if preview else os.path.splitext(output)[0] + ".png"
+        raster.write_preview(output, preview_path, cfg.preview_max_size)
+        if verbose:
+            print(f"[openrelief] preview -> {preview_path}")
+
+    if is_tmp_vrt and os.path.exists(src_path):
+        try:
+            os.remove(src_path)
+        except OSError:
+            pass
+
+    return {
+        "output": output,
+        "preview": preview_path,
+        "inputs": files,
+        "width": width,
+        "height": height,
+        "ground_res": (res_x, res_y),
+        "backend": "gpu" if is_gpu else "cpu",
+        "seconds": elapsed,
+    }

openrelief/raster.py

@@ -0,0 +1,183 @@
+"""Raster I/O: virtual mosaicking, windowing, GeoTIFF output, PNG preview.
+
+A multi-tile DEM is exposed as one seamless dataset through a GDAL .vrt that we
+write directly as XML -- this needs only rasterio (no gdalbuildvrt binary).
+Windows are then read from the VRT with a halo so openness never sees a tile
+edge, eliminating mosaic seams.
+"""
+from __future__ import annotations
+
+import os
+import xml.etree.ElementTree as ET
+from dataclasses import dataclass
+from typing import Iterator, List, Optional, Sequence, Tuple
+
+import numpy as np
+import rasterio
+from rasterio.windows import Window
+
+
+# --------------------------------------------------------------------------- #
+# Virtual mosaic
+# --------------------------------------------------------------------------- #
+def build_vrt(dem_paths: Sequence[str], vrt_path: str) -> str:
+    """Write a GDAL VRT mosaicking ``dem_paths`` into one virtual raster.
+
+    Assumes north-up, non-rotated tiles sharing CRS and pixel size (true for a
+    standard DEM tile set). Returns ``vrt_path``.
+    """
+    if not dem_paths:
+        raise ValueError("No DEM files supplied.")
+
+    metas = []
+    for p in dem_paths:
+        with rasterio.open(p) as ds:
+            t = ds.transform
+            if t.b != 0 or t.d != 0:
+                raise ValueError(f"{p}: rotated rasters are not supported.")
+            metas.append({
+                "path": os.path.abspath(p),
+                "w": ds.width, "h": ds.height,
+                "left": t.c, "top": t.f,
+                "rx": t.a, "ry": t.e,             # ry is negative (north-up)
+                "dtype": ds.dtypes[0],
+                "nodata": ds.nodata,
+                "crs": ds.crs,
+            })
+
+    rx = metas[0]["rx"]
+    ry = metas[0]["ry"]
+    dtype = metas[0]["dtype"]
+    nodata = metas[0]["nodata"]
+    crs = metas[0]["crs"]
+    for m in metas:
+        if abs(m["rx"] - rx) > 1e-6 or abs(m["ry"] - ry) > 1e-6:
+            raise ValueError("All DEM tiles must share the same pixel size.")
+
+    minx = min(m["left"] for m in metas)
+    maxy = max(m["top"] for m in metas)
+    maxx = max(m["left"] + m["w"] * m["rx"] for m in metas)
+    miny = min(m["top"] + m["h"] * m["ry"] for m in metas)
+
+    width = int(round((maxx - minx) / rx))
+    height = int(round((maxy - miny) / -ry))
+
+    dt_map = {"float32": "Float32", "float64": "Float64", "int16": "Int16",
+              "int32": "Int32", "uint16": "UInt16", "uint8": "Byte"}
+    gdal_dt = dt_map.get(str(dtype), "Float32")
+
+    ds_el = ET.Element("VRTDataset", rasterXSize=str(width), rasterYSize=str(height))
+    if crs is not None:
+        ET.SubElement(ds_el, "SRS").text = crs.to_wkt()
+    ET.SubElement(ds_el, "GeoTransform").text = (
+        f"{minx:.10f}, {rx:.10f}, 0.0, {maxy:.10f}, 0.0, {ry:.10f}")
+
+    band = ET.SubElement(ds_el, "VRTRasterBand", dataType=gdal_dt, band="1")
+    if nodata is not None:
+        ET.SubElement(band, "NoDataValue").text = repr(nodata)
+
+    for m in metas:
+        dst_xoff = int(round((m["left"] - minx) / rx))
+        dst_yoff = int(round((maxy - m["top"]) / -ry))
+        src = ET.SubElement(band, "ComplexSource")
+        sp = ET.SubElement(src, "SourceFilename", relativeToVRT="0")
+        sp.text = m["path"]
+        ET.SubElement(src, "SourceBand").text = "1"
+        ET.SubElement(src, "SrcRect", xOff="0", yOff="0",
+                      xSize=str(m["w"]), ySize=str(m["h"]))
+        ET.SubElement(src, "DstRect", xOff=str(dst_xoff), yOff=str(dst_yoff),
+                      xSize=str(m["w"]), ySize=str(m["h"]))
+        if m["nodata"] is not None:
+            ET.SubElement(src, "NODATA").text = repr(m["nodata"])
+
+    ET.ElementTree(ds_el).write(vrt_path, encoding="utf-8", xml_declaration=False)
+    return vrt_path
+
+
+def open_source(dem_paths: Sequence[str], workdir: str) -> Tuple[str, bool]:
+    """Return (path_to_open, is_temp_vrt). One file -> itself; many -> a VRT."""
+    dem_paths = list(dem_paths)
+    if len(dem_paths) == 1:
+        return dem_paths[0], False
+    vrt = os.path.join(workdir, "_rrim_mosaic.vrt")
+    build_vrt(dem_paths, vrt)
+    return vrt, True
+
+
+# --------------------------------------------------------------------------- #
+# Windowing
+# --------------------------------------------------------------------------- #
+@dataclass
+class Tile:
+    """A processing window plus its halo. Coordinates are in source pixels."""
+    # interior (output) region
+    col_off: int
+    row_off: int
+    width: int
+    height: int
+    # padded read region (interior + halo, clipped to raster)
+    read_col_off: int
+    read_row_off: int
+    read_width: int
+    read_height: int
+
+    @property
+    def read_window(self) -> Window:
+        return Window(self.read_col_off, self.read_row_off,
+                      self.read_width, self.read_height)
+
+    @property
+    def write_window(self) -> Window:
+        return Window(self.col_off, self.row_off, self.width, self.height)
+
+    @property
+    def inner_slice(self) -> Tuple[slice, slice]:
+        """Slice that extracts the interior from a processed padded array."""
+        r0 = self.row_off - self.read_row_off
+        c0 = self.col_off - self.read_col_off
+        return (slice(r0, r0 + self.height), slice(c0, c0 + self.width))
+
+
+def make_tiles(width: int, height: int, window: int, halo: int) -> List[Tile]:
+    tiles: List[Tile] = []
+    for row in range(0, height, window):
+        h = min(window, height - row)
+        rr0 = max(0, row - halo)
+        rr1 = min(height, row + h + halo)
+        for col in range(0, width, window):
+            w = min(window, width - col)
+            cc0 = max(0, col - halo)
+            cc1 = min(width, col + w + halo)
+            tiles.append(Tile(col, row, w, h,
+                              cc0, rr0, cc1 - cc0, rr1 - rr0))
+    return tiles
+
+
+# --------------------------------------------------------------------------- #
+# Output
+# --------------------------------------------------------------------------- #
+def create_rgb_geotiff(path: str, src_profile: dict, compress: str = "deflate"):
+    profile = dict(src_profile)
+    profile.update(
+        driver="GTiff", count=3, dtype="uint8", nodata=None,
+        tiled=True, blockxsize=512, blockysize=512,
+        compress=(None if compress.lower() == "none" else compress),
+        photometric="RGB", BIGTIFF="IF_SAFER",
+    )
+    profile.pop("nbits", None)
+    return rasterio.open(path, "w", **profile)
+
+
+def write_preview(geotiff_path: str, png_path: str, max_size: int = 4000) -> str:
+    """Downsample the RGB GeoTIFF to a PNG quick-look."""
+    from PIL import Image
+
+    with rasterio.open(geotiff_path) as ds:
+        scale = max(1, int(np.ceil(max(ds.width, ds.height) / max_size)))
+        out_w = max(1, ds.width // scale)
+        out_h = max(1, ds.height // scale)
+        data = ds.read(out_shape=(3, out_h, out_w),
+                       resampling=rasterio.enums.Resampling.average)
+    img = np.transpose(data, (1, 2, 0)).astype("uint8")
+    Image.fromarray(img, mode="RGB").save(png_path)
+    return png_path

openrelief/terrain.py

@@ -0,0 +1,87 @@
+"""Backend-agnostic terrain kernels: slope and topographic openness.
+
+Both functions accept an array module ``xp`` (numpy or cupy) and operate on a
+single 2-D elevation tile (already scaled by ``z_factor``). NaN marks no-data
+and is propagated/ignored throughout.
+"""
+from __future__ import annotations
+
+import math
+from typing import Any, Tuple
+
+# 8 compass directions as (dy, dx) unit steps.
+_DIRS8 = [
+    (0, 1), (1, 1), (1, 0), (1, -1),
+    (0, -1), (-1, -1), (-1, 0), (-1, 1),
+]
+
+
+def _directions(n: int):
+    if n == 8:
+        return _DIRS8
+    if n == 4:
+        return [(0, 1), (1, 0), (0, -1), (-1, 0)]
+    if n == 16:
+        # 8 principal + 8 "knight"-style intermediates for finer azimuth cover
+        base = list(_DIRS8)
+        extra = [(1, 2), (2, 1), (2, -1), (1, -2),
+                 (-1, -2), (-2, -1), (-2, 1), (-1, 2)]
+        return base + extra
+    return _DIRS8
+
+
+def _shift(z, sy: int, sx: int, xp: Any):
+    """Return an array s where s[i, j] = z[i + sy, j + sx], NaN out of bounds."""
+    h, w = z.shape
+    out = xp.full_like(z, xp.nan)
+    di0 = max(0, -sy)
+    di1 = min(h, h - sy)
+    dj0 = max(0, -sx)
+    dj1 = min(w, w - sx)
+    if di0 < di1 and dj0 < dj1:
+        out[di0:di1, dj0:dj1] = z[di0 + sy:di1 + sy, dj0 + sx:dj1 + sx]
+    return out
+
+
+def slope_degrees(z, res_x: float, res_y: float, xp: Any):
+    """Slope magnitude in degrees via central differences (Horn-style 2-cell)."""
+    dzdx = (_shift(z, 0, 1, xp) - _shift(z, 0, -1, xp)) / (2.0 * res_x)
+    dzdy = (_shift(z, 1, 0, xp) - _shift(z, -1, 0, xp)) / (2.0 * res_y)
+    return xp.degrees(xp.arctan(xp.sqrt(dzdx * dzdx + dzdy * dzdy)))
+
+
+def openness(z, res_x: float, res_y: float, radius: int, xp: Any,
+             n_directions: int = 8) -> Tuple[Any, Any]:
+    """Positive and negative topographic openness (degrees).
+
+    Yokoyama et al. (2002):
+        positive openness = mean_dir( 90 - max_L(elevation_angle) )
+        negative openness = mean_dir( 90 + min_L(elevation_angle) )
+    where elevation_angle is the angle (deg) from horizontal to the cell at
+    distance L along the azimuth (positive looking up).
+
+    Ridges yield high positive / low negative openness; valleys the reverse.
+    """
+    dirs = _directions(n_directions)
+    pos_sum = xp.zeros_like(z)
+    neg_sum = xp.zeros_like(z)
+
+    for dy, dx in dirs:
+        step = math.hypot(dx * res_x, dy * res_y)  # ground distance per step
+        max_ang = xp.full_like(z, -xp.inf)  # steepest upward angle
+        min_ang = xp.full_like(z, xp.inf)   # steepest downward angle
+        for k in range(1, radius + 1):
+            zs = _shift(z, dy * k, dx * k, xp)
+            ang = xp.degrees(xp.arctan((zs - z) / (step * k)))
+            # fmax/fmin ignore NaN, so out-of-bounds / no-data cells drop out.
+            max_ang = xp.fmax(max_ang, ang)
+            min_ang = xp.fmin(min_ang, ang)
+        # Cells that never saw a valid neighbour in this direction stay at
+        # +/-inf; mark them NaN so they don't poison the mean or the blend.
+        max_ang = xp.where(xp.isfinite(max_ang), max_ang, xp.nan)
+        min_ang = xp.where(xp.isfinite(min_ang), min_ang, xp.nan)
+        pos_sum = pos_sum + (90.0 - max_ang)
+        neg_sum = neg_sum + (90.0 + min_ang)
+
+    n = float(len(dirs))
+    return pos_sum / n, neg_sum / n

openrelief-0.1.0.dist-info/METADATA

@@ -0,0 +1,208 @@
+Metadata-Version: 2.4
+Name: openrelief
+Version: 0.1.0
+Summary: Red-shaded terrain relief (the Red Relief Image Map / RRIM technique) from Digital Elevation Models, with parallel CPU and optional GPU acceleration.
+Author-email: Naveen <nvnsudharsan@gmail.com>
+License: MIT
+Project-URL: Homepage, https://github.com/nvnsudharsan/openrelief
+Project-URL: Repository, https://github.com/nvnsudharsan/openrelief
+Project-URL: Issues, https://github.com/nvnsudharsan/openrelief/issues
+Keywords: red relief,RRIM,DEM,topographic openness,terrain,hillshade,lidar,GIS,raster,visualization
+Classifier: Development Status :: 4 - Beta
+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 :: GIS
+Classifier: Topic :: Scientific/Engineering :: Visualization
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+License-File: NOTICE
+Requires-Dist: numpy>=1.21
+Requires-Dist: rasterio>=1.3
+Requires-Dist: scipy>=1.7
+Requires-Dist: joblib>=1.4
+Requires-Dist: Pillow>=9.0
+Provides-Extra: gpu
+Requires-Dist: cupy-cuda12x; extra == "gpu"
+Provides-Extra: dev
+Requires-Dist: pytest; extra == "dev"
+Requires-Dist: build; extra == "dev"
+Requires-Dist: twine; extra == "dev"
+Dynamic: license-file
+
+# openrelief — red-shaded terrain relief from DEMs
+
+`openrelief` turns any Digital Elevation Model into a **red-shaded relief image**
+that combines topographic slope with positive/negative **topographic openness** —
+the visualization widely known as the *Red Relief Image Map* (RRIM). Give it a
+DEM (or a folder/glob of DEM tiles) and it produces a seamless georeferenced RGB
+GeoTIFF plus a PNG preview.
+
+> **Note on naming and IP.** This is an independent, open-source reimplementation
+> of a published method. The package is intentionally named `openrelief` and
+> avoids the *RRIM* / *Red Relief Image Map* trademarks as branding. The RRIM
+> method was developed and patented by Asia Air Survey Co., Ltd.; those patents
+> appear to have expired, but you should verify this yourself before publishing
+> or commercializing. See [NOTICE](NOTICE) for attribution, citation, trademark
+> and patent details, and [LICENSE](LICENSE) for the code license.
+
+* **Any DEM** rasterio can read: GeoTIFF, USGS `.dem`, ERDAS `.img`, ArcInfo
+  `.asc`, `.bil/.flt`, SRTM `.hgt`, `.vrt`, … — CRS, no-data, pixel size and
+  elevation unit are all read from the file, nothing is hard-coded.
+* **Seamless mosaics** — multiple tiles are stitched through an in-memory VRT and
+  processed in overlapping windows (a halo equal to the openness radius), so
+  there are no seams at tile boundaries.
+* **Parallel** across windows on the CPU (joblib) and **GPU-accelerated**
+  automatically when [CuPy](https://cupy.dev) + a CUDA device are present.
+* **Fully tunable** — every visual knob (openness radius, slope clip, gammas,
+  blend opacity, …) is exposed, with defaults matching the classic look.
+
+---
+
+## How the image is built
+
+For every cell the package computes:
+
+1. **Slope** (degrees) → red saturation. Flat = white `(255,255,255)`, steep =
+   pure red `(255,0,0)`.
+2. **Topographic openness** (Yokoyama et al., 2002) in `--directions` azimuths
+   out to `--radius` pixels: positive openness (high on ridges) and negative
+   openness (high in valleys).
+3. **Differential openness** `(positive − negative) / 2` → brightness. Ridges
+   render light, valleys dark — this gives the floating-3D relief.
+4. The grey openness layer is **multiply-blended** onto the red slope layer at
+   `--opacity` (0.5 by default). Method reference: Chiba, Kaneta & Suzuki (2008).
+
+Horizontal distances are converted to **ground metres** automatically (linear
+unit for projected CRSs; degrees→metres at the scene latitude for geographic
+CRSs), so the relief is geometrically correct for any projection. If your
+elevation unit differs from the horizontal unit, set `--z-factor` (e.g. `0.3048`
+for feet-Z over metre-XY).
+
+---
+
+## Install
+
+```bash
+pip install -e .            # from this folder
+```
+
+Core deps: `numpy`, `rasterio`, `scipy`, `joblib`, `Pillow`.
+
+**GPU (optional):** install the CuPy wheel for your CUDA toolkit, e.g.
+
+```bash
+pip install cupy-cuda12x        # CUDA 12.x   (or cupy-cuda11x)
+```
+
+When CuPy and a GPU are present the GPU is used automatically. Check with:
+
+```bash
+openrelief --check-gpu
+```
+
+---
+
+## Command line
+
+```bash
+# Single DEM
+openrelief dem.tif -o relief.tif
+
+# A whole folder of tiles -> one seamless mosaic + preview
+openrelief /path/to/dems/ -o area_relief.tif
+
+# A glob, tuned for flat terrain, forced GPU
+openrelief "tiles/*.dem" -o relief.tif --slope-max 15 --openness-range 12 --radius 40 --gpu
+```
+
+Useful options (`openrelief -h` for all):
+
+| Option | Meaning | Default |
+|---|---|---|
+| `--radius` | openness search length (px) | 30 |
+| `--directions` | azimuths sampled (4/8/16) | 8 |
+| `--openness-range` | diff-openness deg → black..white | 30 |
+| `--slope-max` | slope deg → full red | 50 |
+| `--slope-gamma` / `--openness-gamma` | tone curves | 1.0 |
+| `--opacity` | openness layer blend (0..1) | 0.5 |
+| `--z-factor` | elevation→ground unit multiplier | 1.0 |
+| `--window` | processing window (px) | 2048 |
+| `--jobs` | CPU workers (-1 = all cores) | -1 |
+| `--auto-window` | size windows from the core count | off |
+| `--tiles-per-core` | with `--auto-window`, tiles/core (1 = one tile per processor) | 4 |
+| `--gpu` / `--cpu` | force a backend | auto |
+| `--compress` | deflate/lzw/zstd/none | deflate |
+| `--no-preview` / `--preview-size` | PNG quick-look | on / 4000 |
+
+**Tuning tip:** flatter terrain wants smaller `--slope-max` and
+`--openness-range` (more contrast); rugged terrain wants larger values. A larger
+`--radius` broadens the relief but costs ~linearly more compute.
+
+---
+
+## Python API
+
+```python
+from openrelief import ReliefConfig, relief_from_dems, relief_array
+
+# High-level: DEM(s) -> GeoTIFF + PNG
+relief_from_dems("tiles/", "out.tif",
+                 ReliefConfig(openness_radius=40, slope_max=20))
+
+# Low-level: a NumPy elevation array -> (3, H, W) uint8 relief
+import numpy as np
+rgb = relief_array(dem_array, res_x=1.0, res_y=1.0,
+                   cfg=ReliefConfig(openness_radius=24))
+```
+
+`ReliefConfig` carries every parameter above; `use_gpu=None/True/False` controls
+the backend. You can also force a backend globally with the
+`OPENRELIEF_BACKEND=cpu|gpu` environment variable.
+
+---
+
+## How it scales
+
+Cost is roughly `O(8 · radius · pixels)`. The raster is split into independent
+`--window`-sized tiles with a `radius`-pixel halo:
+
+* **CPU:** windows are distributed over processes with joblib and streamed to the
+  output as they finish, so memory stays bounded regardless of mosaic size. By
+  default there are more windows than cores so a freed worker immediately picks
+  up the next one (dynamic load balancing). `--auto-window` instead sizes the
+  windows from the core count: `--tiles-per-core 1` gives one tile per
+  processor (simplest, but prone to stragglers and high per-worker memory),
+  while the default of 4 keeps every core fed. The pixels produced are identical
+  either way — only the scheduling changes.
+* **GPU:** windows are streamed to the device sequentially; the per-window size
+  keeps GPU memory in check while still giving a large speed-up.
+
+Output GeoTIFFs are tiled and compressed (`BIGTIFF=IF_SAFER`), so very large
+mosaics are handled gracefully. Empty windows in a sparse mosaic are skipped.
+
+---
+
+## Attribution & citation
+
+This package reimplements published methods. Please credit the original authors;
+full details and references are in [NOTICE](NOTICE).
+
+* Chiba, T., Kaneta, S., & Suzuki, Y. (2008). *Red relief image map: new
+  visualization method for three-dimensional data.* ISPRS Archives,
+  XXXVII(B2), 1071–1076.
+* Yokoyama, R., Shirasawa, M., & Pike, R. J. (2002). *Visualizing topography by
+  openness.* PE&RS 68(3), 257–265.
+* Asia Air Survey — https://www.rrim.jp/en/
+
+## License
+
+Source code: MIT (see [LICENSE](LICENSE)). The MIT license covers this code only
+and is not a patent grant; see [NOTICE](NOTICE) for the intellectual-property
+note.

openrelief-0.1.0.dist-info/RECORD

@@ -0,0 +1,16 @@
+openrelief/__init__.py,sha256=5l3qcGgpiSK_aXhiwNvD-I2tjrgG5VSpSHa2JQs-Ik8,661
+openrelief/backend.py,sha256=RYaWvXxrNyqnCTcXqglVgybCbRV4MiTDem9H-EXBTM0,1904
+openrelief/cli.py,sha256=OH3K5ZMSOGzkIZPdqy5EkuKumKMSBlVufBXQIrNID2c,4835
+openrelief/color.py,sha256=wZbFPRkM_28zUe00B-Gg50_ZzKvLETSO62DGkPxJiZk,1543
+openrelief/config.py,sha256=XBtTVdAnit4v6jHHgEpuhyReuH1LDvmXB1fumd81_BY,3662
+openrelief/core.py,sha256=vlRWe8ZlHV4aBQCkY-yZEBPfFYQe8QdRW5GUSl7a1fo,10214
+openrelief/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+openrelief/raster.py,sha256=MLvHISnwlfEYZxwPYCIujSGBRXkR_uW9KAjX-bW0Cpo,7005
+openrelief/terrain.py,sha256=0fVjgJARltP7Y31Bu7y-T0WG-59n9bs2cIJtmdsN-Qo,3296
+openrelief-0.1.0.dist-info/licenses/LICENSE,sha256=eq1u1IgZ8RHVKtunQpYMYIxRV00VdevUV4d_JZRgtlQ,1362
+openrelief-0.1.0.dist-info/licenses/NOTICE,sha256=4POho4FmCMgSU7_ickQkYLwjSoZQiV4tpO9dpvU_JAI,2541
+openrelief-0.1.0.dist-info/METADATA,sha256=rZQfSGuhgqi12D_6Bkq7B2BOECormJU14AlnWRqMDdQ,8476
+openrelief-0.1.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+openrelief-0.1.0.dist-info/entry_points.txt,sha256=W90Bvy4XYqn_RtmJLsWgoT2INoKIjZc7uV-lrLGQYhg,51
+openrelief-0.1.0.dist-info/top_level.txt,sha256=2Y3SrTxUdOn4cfUsuyqfrTWyHkDtXcIKKNUreT_hfM0,11
+openrelief-0.1.0.dist-info/RECORD,,

openrelief-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

openrelief-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+openrelief = openrelief.cli:main

openrelief-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,28 @@
+MIT License
+
+Copyright (c) 2026 Naveen
+
+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.
+
+---
+
+The MIT license above covers the source code of this package only. It is not a
+patent grant and makes no representation about third-party intellectual
+property. See NOTICE for attribution and an intellectual-property note about
+the red-relief visualization technique this software implements.

openrelief-0.1.0.dist-info/licenses/NOTICE

@@ -0,0 +1,50 @@
+openrelief
+==========
+
+This software is an independent, open-source implementation of a terrain
+visualization technique that combines topographic slope with positive and
+negative topographic openness, rendered as a red-shaded relief image. The
+technique is commonly known as the "Red Relief Image Map" (RRIM).
+
+Attribution
+-----------
+The red-relief image map method was developed by Tatsuro Chiba, Shin-ichi
+Kaneta and Yusuke Suzuki at Asia Air Survey Co., Ltd. The topographic openness
+measure it builds on was introduced by Ryuzo Yokoyama, Michio Shirasawa and
+Richard J. Pike. This package reimplements those published methods from the
+academic literature; it is not produced, endorsed by, or affiliated with Asia
+Air Survey Co., Ltd.
+
+Trademarks
+----------
+"RRIM", "Red Relief Image Map", and "赤色立体地図" are used or claimed as
+trademarks of Asia Air Survey Co., Ltd. Those names are referenced here only to
+describe the method this software implements (nominative use). This package is
+deliberately named "openrelief" and does not use those marks as its product
+name or branding. Do not market derivatives of this software under those marks.
+
+Intellectual-property note
+--------------------------
+The RRIM method was patented by Asia Air Survey Co., Ltd., with patent family
+members filed in Japan, the United States, China and Taiwan (e.g. JP 3670274).
+These patents derive from filings in the early 2000s and, based on the standard
+~20-year patent term, the relevant patents appear to have expired. Patent
+status is jurisdiction-specific and time-sensitive, and nothing here is legal
+advice. Before publishing, redistributing, or building a commercial product on
+this software, independently verify the current legal status of the relevant
+patents in every jurisdiction that matters to you (e.g. J-PlatPat for Japan,
+the USPTO / Google Patents for the United States), and consult a qualified
+intellectual-property attorney if anything material depends on it.
+
+Citation
+--------
+If you use this software in academic work, please cite the original methods:
+
+  Chiba, T., Kaneta, S., & Suzuki, Y. (2008). Red relief image map: new
+  visualization method for three-dimensional data. International Archives of
+  the Photogrammetry, Remote Sensing and Spatial Information Sciences,
+  XXXVII(B2), 1071-1076.
+
+  Yokoyama, R., Shirasawa, M., & Pike, R. J. (2002). Visualizing topography by
+  openness: a new application of image processing to digital elevation models.
+  Photogrammetric Engineering & Remote Sensing, 68(3), 257-265.

openrelief-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+openrelief