diff --git a/cuda/kernel.cu b/cuda/kernel.cu index 8e30adb..daa5555 100644 --- a/cuda/kernel.cu +++ b/cuda/kernel.cu @@ -33,7 +33,7 @@ extern "C" __global__ void __raygen__main() ray.tmax, 0.0f, OptixVisibilityMask( 1 ), - OPTIX_RAY_FLAG_NONE, + OPTIX_RAY_FLAG_CULL_BACK_FACING_TRIANGLES, RAY_TYPE_RADIANCE, RAY_TYPE_COUNT, RAY_TYPE_RADIANCE, diff --git a/examples/cell_tower_instancing_demo.ipynb b/examples/cell_tower_instancing_demo.ipynb new file mode 100644 index 0000000..d59257b --- /dev/null +++ b/examples/cell_tower_instancing_demo.ipynb @@ -0,0 +1,2547 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "intro", + "metadata": {}, + "source": [ + "# Neon Cell Towers over the Grand Canyon\n", + "\n", + "This notebook demonstrates loading GLB models and placing them on **real terrain data** from the USGS, rendered with eye-catching **neon colors** using rtxpy's GPU ray tracing engine.\n", + "\n", + "**What you'll learn:**\n", + "1. Downloading real elevation data from USGS 3DEP\n", + "2. Loading GLB/glTF mesh files with `load_glb()`\n", + "3. Placing 3D models on terrain with `make_transforms_on_terrain()`\n", + "4. GPU-accelerated perspective rendering with custom shading\n", + "\n", + "**Visual Style:**\n", + "- **Terrain**: Desert canyon colors (red/orange to tan)\n", + "- **Cell Towers**: Neon Magenta\n", + "- **Houses**: Neon Cyan" + ] + }, + { + "cell_type": "markdown", + "id": "setup-header", + "metadata": {}, + "source": [ + "## 1. Setup and Imports" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "5e3a6b45", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "rtxpy version: 0.0.5\n", + "GPU: [{'name': 'NVIDIA RTX A6000', 'compute_capability': (8, 6), 'total_memory': 51526500352, 'multiprocessor_count': 84, 'id': 0}]\n" + ] + } + ], + "source": [ + "import numpy as np\n", + "import cupy as cp\n", + "from pathlib import Path\n", + "import matplotlib.pyplot as plt\n", + "import xarray as xr\n", + "\n", + "# Import rtxpy - uses xarray accessor pattern\n", + "import rtxpy\n", + "\n", + "print(f\"rtxpy version: {rtxpy.__version__}\")\n", + "print(f\"GPU: {rtxpy.list_devices()}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "imports", + "metadata": {}, + "outputs": [], + "source": [ + "# (dimensions computed after DEM is loaded)" + ] + }, + { + "cell_type": "markdown", + "id": "download-header", + "metadata": {}, + "source": [ + "## 2. 3D Models\n", + "\n", + "We'll place 3D models from the `models/` directory onto the terrain:\n", + "- **Broadcast Tower** - A detailed cell/broadcast tower model\n", + "- **American House** - A house model to populate our terrain\n", + "- **Pine Tree** - Trees to create forest groves\n", + "\n", + "The `dem.rtx.place_mesh()` accessor loads mesh files (GLB, glTF, OBJ, STL, PLY, etc.) and places instances on the terrain in one step." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "download-model", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Models directory: /home/brendan/rtxpy/examples/models\n", + " Tower: broadcast_tower_game_ready.glb (exists)\n", + " House: american_house.glb (exists)\n", + " Tree: pine_tree.glb (exists)\n" + ] + } + ], + "source": [ + "# Model paths\n", + "MODELS_DIR = Path.cwd() / \"models\"\n", + "TOWER_PATH = MODELS_DIR / \"broadcast_tower_game_ready.glb\"\n", + "HOUSE_PATH = MODELS_DIR / \"american_house.glb\"\n", + "TREE_PATH = MODELS_DIR / \"pine_tree.glb\"\n", + "\n", + "# Target heights for models (meters)\n", + "# Original model heights are normalized by place_mesh using base_at_zero=True\n", + "TOWER_HEIGHT = 45 # Realistic cell tower: 30-60m\n", + "HOUSE_HEIGHT = 9 # Realistic 2-story house: ~8-10m\n", + "TREE_HEIGHT = 20 # Pine trees: 15-25m\n", + "\n", + "print(f\"Models directory: {MODELS_DIR}\")\n", + "for name, path in [('Tower', TOWER_PATH), ('House', HOUSE_PATH), ('Tree', TREE_PATH)]:\n", + " status = 'exists' if path.exists() else 'NOT FOUND'\n", + " print(f\" {name}: {path.name} ({status})\")" + ] + }, + { + "cell_type": "markdown", + "id": "fallback-header", + "metadata": {}, + "source": [ + "### Model Scaling\n", + "\n", + "The `place_mesh()` accessor handles mesh loading and terrain placement in one call:\n", + "\n", + "```python\n", + "dem.rtx.place_mesh(\n", + " 'tower.glb', # Path to mesh file\n", + " positions=[(x1,y1), (x2,y2)], # Pixel coordinates\n", + " geometry_id='tower', # ID for this geometry\n", + " scale=2.7, # Scale factor\n", + " center_xy=True, # Center model at XY origin\n", + " base_at_zero=True, # Place base at Z=0\n", + " rotation_z='random', # Random rotation (or angle in degrees)\n", + ")\n", + "```\n", + "\n", + "The scale factor converts model units to world units (meters). We'll compute scales based on the original model dimensions and target heights." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "create-simple-tower", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Model scales (original -> target):\n", + " Tower: 16.6 -> 45m (scale=2.7027)\n", + " House: 761.3 -> 9m (scale=0.0118)\n", + " Tree: 3.08 -> 20m (scale=6.49)\n" + ] + } + ], + "source": [ + "# Compute scale factors for each model type\n", + "# These convert from original model units to target height in meters\n", + "\n", + "# Original model heights (determined by inspecting the GLB files)\n", + "TOWER_ORIGINAL_HEIGHT = 16.65 # units in the GLB\n", + "HOUSE_ORIGINAL_HEIGHT = 761.3 # units in the GLB\n", + "TREE_ORIGINAL_HEIGHT = 3.08 # units in the GLB\n", + "\n", + "# Scale factors\n", + "TOWER_SCALE = TOWER_HEIGHT / TOWER_ORIGINAL_HEIGHT\n", + "HOUSE_SCALE = HOUSE_HEIGHT / HOUSE_ORIGINAL_HEIGHT\n", + "TREE_SCALE = TREE_HEIGHT / TREE_ORIGINAL_HEIGHT\n", + "\n", + "print(\"Model scales (original -> target):\")\n", + "print(f\" Tower: {TOWER_ORIGINAL_HEIGHT:.1f} -> {TOWER_HEIGHT}m (scale={TOWER_SCALE:.4f})\")\n", + "print(f\" House: {HOUSE_ORIGINAL_HEIGHT:.1f} -> {HOUSE_HEIGHT}m (scale={HOUSE_SCALE:.4f})\")\n", + "print(f\" Tree: {TREE_ORIGINAL_HEIGHT:.2f} -> {TREE_HEIGHT}m (scale={TREE_SCALE:.2f})\")" + ] + }, + { + "cell_type": "markdown", + "id": "terrain-header", + "metadata": {}, + "source": [ + "## 3. Download Grand Canyon Terrain\n", + "\n", + "We'll download real elevation data from USGS 3DEP (3D Elevation Program) for an area of the Grand Canyon using the `py3dep` library." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "create-terrain", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "============================================================\n", + "Grand Canyon Study Area\n", + "============================================================\n", + " Bounds: -112.35° to -111.85° W, 35.95° to 36.25° N\n", + " Size: ~42km x 33km\n", + "\n", + "Using cached: grand_canyon_dem_large.tif\n", + "\n", + "Raw DEM: 1801x1081 pixels\n", + "\n", + "Applying light smoothing (sigma=1.0)...\n", + "Subsampled: 1081x1801 -> 1081x1801\n", + "\n", + "Final DEM: 1801x1081 pixels\n", + " Elevation: 670m - 2649m\n", + " Created 'dem' xarray DataArray with GPU data\n" + ] + } + ], + "source": [ + "import requests\n", + "import rioxarray as rxr\n", + "from scipy.ndimage import gaussian_filter\n", + "\n", + "def download_srtm_tiles(bounds, output_path):\n", + " \"\"\"Download SRTM 1-arc-second tiles from USGS National Map.\"\"\"\n", + " import math\n", + " west, south, east, north = bounds\n", + "\n", + " lat_min = math.ceil(south)\n", + " lat_max = math.ceil(north)\n", + " lon_min = math.floor(west)\n", + " lon_max = math.floor(east)\n", + "\n", + " tile_paths = []\n", + " base_url = \"https://prd-tnm.s3.amazonaws.com/StagedProducts/Elevation/1/TIFF/current\"\n", + "\n", + " print(f\" Tiles needed: lat {lat_min}-{lat_max}, lon {lon_min}-{lon_max}\")\n", + " \n", + " for lat in range(lat_min, lat_max + 1):\n", + " for lon in range(lon_min, lon_max + 1):\n", + " ns = \"n\" if lat >= 0 else \"s\"\n", + " ew = \"w\" if lon < 0 else \"e\"\n", + " tile_name = f\"{ns}{abs(lat):02d}{ew}{abs(lon):03d}\"\n", + " url = f\"{base_url}/{tile_name}/USGS_1_{tile_name}.tif\"\n", + " tile_path = output_path.parent / f\"USGS_1_{tile_name}.tif\"\n", + "\n", + " if not tile_path.exists():\n", + " print(f\" Downloading {tile_name}...\")\n", + " resp = requests.get(url, timeout=180)\n", + " resp.raise_for_status()\n", + " tile_path.write_bytes(resp.content)\n", + " else:\n", + " print(f\" Cached: {tile_name}\")\n", + " tile_paths.append(tile_path)\n", + "\n", + " print(f\" Merging {len(tile_paths)} tiles...\")\n", + " tiles = [rxr.open_rasterio(str(p), masked=True).squeeze() for p in tile_paths]\n", + "\n", + " if len(tiles) == 1:\n", + " merged = tiles[0]\n", + " else:\n", + " from rioxarray.merge import merge_arrays\n", + " merged = merge_arrays(tiles)\n", + "\n", + " merged = merged.rio.clip_box(minx=west, miny=south, maxx=east, maxy=north)\n", + " merged.rio.to_raster(str(output_path))\n", + " return merged\n", + "\n", + "\n", + "# Grand Canyon Study Area\n", + "BOUNDS_WGS84 = (-112.35, 35.95, -111.85, 36.25)\n", + "WEST, SOUTH, EAST, NORTH = BOUNDS_WGS84\n", + "\n", + "print(\"=\"*60)\n", + "print(\"Grand Canyon Study Area\")\n", + "print(\"=\"*60)\n", + "print(f\" Bounds: {WEST}° to {EAST}° W, {SOUTH}° to {NORTH}° N\")\n", + "print(f\" Size: ~{abs(EAST-WEST)*85:.0f}km x {abs(NORTH-SOUTH)*111:.0f}km\")\n", + "\n", + "DEM_FILE = Path.cwd().resolve() / \"grand_canyon_dem_large.tif\"\n", + "\n", + "if not DEM_FILE.exists():\n", + " print(\"\\nDownloading SRTM tiles...\")\n", + " dem_xr = download_srtm_tiles(BOUNDS_WGS84, DEM_FILE)\n", + "else:\n", + " print(f\"\\nUsing cached: {DEM_FILE.name}\")\n", + " dem_xr = rxr.open_rasterio(str(DEM_FILE), masked=True).squeeze()\n", + "\n", + "print(f\"\\nRaw DEM: {dem_xr.shape[1]}x{dem_xr.shape[0]} pixels\")\n", + "\n", + "# Light smoothing (sigma=1.0) - preserves terrain detail\n", + "SMOOTH_SIGMA = 1.0\n", + "print(f\"\\nApplying light smoothing (sigma={SMOOTH_SIGMA})...\")\n", + "\n", + "terrain_data = dem_xr.values.astype(np.float32)\n", + "nan_mask = np.isnan(terrain_data)\n", + "if nan_mask.any():\n", + " terrain_data[nan_mask] = np.nanmean(terrain_data)\n", + "\n", + "terrain_smoothed = gaussian_filter(terrain_data, sigma=SMOOTH_SIGMA)\n", + "\n", + "# Subsample for performance if needed\n", + "MAX_DIM = 1000\n", + "H_raw, W_raw = terrain_smoothed.shape\n", + "\n", + "if max(H_raw, W_raw) > MAX_DIM:\n", + " scale = MAX_DIM / max(H_raw, W_raw)\n", + " y_step = max(1, int(1 / scale))\n", + " x_step = max(1, int(1 / scale))\n", + " terrain_smoothed = terrain_smoothed[::y_step, ::x_step]\n", + " print(f\"Subsampled: {H_raw}x{W_raw} -> {terrain_smoothed.shape[0]}x{terrain_smoothed.shape[1]}\")\n", + "\n", + "H, W = terrain_smoothed.shape\n", + "\n", + "# Create xarray DataArray with cupy data for GPU operations\n", + "dem = xr.DataArray(\n", + " cp.array(terrain_smoothed),\n", + " dims=['y', 'x'],\n", + " coords={'y': np.arange(H), 'x': np.arange(W)},\n", + " name='elevation'\n", + ")\n", + "\n", + "# Also keep numpy version for reference\n", + "terrain = terrain_smoothed\n", + "\n", + "print(f\"\\nFinal DEM: {W}x{H} pixels\")\n", + "print(f\" Elevation: {terrain.min():.0f}m - {terrain.max():.0f}m\")\n", + "print(f\" Created 'dem' xarray DataArray with GPU data\")\n" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "triangulate-terrain", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Terrain dimensions:\n", + " Width: 44.8 km (1801 pixels, 24.9m/pixel)\n", + " Height: 33.3 km (1081 pixels, 30.8m/pixel)\n", + " Elevation: 670m - 2649m (mean: 1731m)\n" + ] + } + ], + "source": [ + "# Calculate real-world dimensions\n", + "lat_center = (SOUTH + NORTH) / 2\n", + "meters_per_deg_lon = 111000 * np.cos(np.radians(lat_center))\n", + "meters_per_deg_lat = 111000\n", + "\n", + "terrain_width_m = abs(EAST - WEST) * meters_per_deg_lon\n", + "terrain_height_m = abs(NORTH - SOUTH) * meters_per_deg_lat\n", + "\n", + "PIXEL_SPACING_X = terrain_width_m / W\n", + "PIXEL_SPACING_Y = terrain_height_m / H\n", + "\n", + "print(f\"Terrain dimensions:\")\n", + "print(f\" Width: {terrain_width_m/1000:.1f} km ({W} pixels, {PIXEL_SPACING_X:.1f}m/pixel)\")\n", + "print(f\" Height: {terrain_height_m/1000:.1f} km ({H} pixels, {PIXEL_SPACING_Y:.1f}m/pixel)\")\n", + "\n", + "# Scene dimensions in meters (for camera positioning)\n", + "scene_width_m = terrain_width_m\n", + "scene_height_m = terrain_height_m\n", + "center_x_m = scene_width_m / 2\n", + "center_y_m = scene_height_m / 2\n", + "\n", + "elev_min = float(terrain.min())\n", + "elev_max = float(terrain.max())\n", + "elev_mean = float(terrain.mean())\n", + "\n", + "print(f\" Elevation: {elev_min:.0f}m - {elev_max:.0f}m (mean: {elev_mean:.0f}m)\")\n" + ] + }, + { + "cell_type": "markdown", + "id": "placement-header", + "metadata": {}, + "source": [ + "## 4. Place Models on Terrain\n", + "\n", + "We'll use `dem.rtx.place_mesh()` to load each model and place instances on the terrain. The accessor automatically:\n", + "- Loads and caches the mesh geometry\n", + "- Computes terrain elevations at each position\n", + "- Creates transform matrices for each instance\n", + "- Adds the instanced geometry to the RTX scene" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "select-positions", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Terrain size: 1801x1081 pixels (44.8km x 33.3km)\n", + "Selected 8 tower positions (hilltops, ~1km spacing)\n", + "Selected 15 house positions (random, ~500m spacing)\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Select tower positions - prefer hilltops for better coverage\n", + "def select_hilltop_positions(terrain, num_positions=20, min_distance_pixels=50, seed=42):\n", + " \"\"\"\n", + " Select positions preferring higher elevations.\n", + " Returns positions in PIXEL coordinates.\n", + " \"\"\"\n", + " np.random.seed(seed)\n", + " H, W = terrain.shape\n", + " margin = int(min(H, W) * 0.05) # 5% margin\n", + " \n", + " positions = []\n", + " attempts = 0\n", + " max_attempts = num_positions * 100\n", + " \n", + " # Weight by elevation (higher = more likely)\n", + " weights = terrain[margin:-margin, margin:-margin].copy()\n", + " weights = (weights - weights.min()) / (weights.max() - weights.min())\n", + " weights = weights ** 2 # Square to favor peaks more strongly\n", + " weights /= weights.sum()\n", + " \n", + " while len(positions) < num_positions and attempts < max_attempts:\n", + " attempts += 1\n", + " \n", + " # Sample position weighted by elevation\n", + " flat_idx = np.random.choice(weights.size, p=weights.flatten())\n", + " row = flat_idx // (W - 2*margin) + margin\n", + " col = flat_idx % (W - 2*margin) + margin\n", + " \n", + " # Check minimum distance from existing positions\n", + " too_close = False\n", + " for px, py in positions:\n", + " dist = np.sqrt((col - px)**2 + (row - py)**2)\n", + " if dist < min_distance_pixels:\n", + " too_close = True\n", + " break\n", + " \n", + " if not too_close:\n", + " positions.append((col, row))\n", + " \n", + " return positions\n", + "\n", + "\n", + "def select_random_positions(terrain, num_positions=20, min_distance_pixels=40, seed=123):\n", + " \"\"\"Select random positions with minimum spacing. Returns PIXEL coordinates.\"\"\"\n", + " np.random.seed(seed)\n", + " H, W = terrain.shape\n", + " margin = int(min(H, W) * 0.08) # 8% margin\n", + " \n", + " positions = []\n", + " attempts = 0\n", + " max_attempts = num_positions * 100\n", + " \n", + " while len(positions) < num_positions and attempts < max_attempts:\n", + " attempts += 1\n", + " col = np.random.randint(margin, W - margin)\n", + " row = np.random.randint(margin, H - margin)\n", + " \n", + " too_close = False\n", + " for px, py in positions:\n", + " dist = np.sqrt((col - px)**2 + (row - py)**2)\n", + " if dist < min_distance_pixels:\n", + " too_close = True\n", + " break\n", + " \n", + " if not too_close:\n", + " positions.append((col, row))\n", + " \n", + " return positions\n", + "\n", + "\n", + "# Select positions for towers (hilltops) and houses (random)\n", + "# Use pixel-based spacing, will convert to meters for transforms\n", + "H, W = terrain.shape\n", + "\n", + "# Spacing in pixels (roughly 1km apart for towers, 500m for houses)\n", + "tower_spacing_pixels = max(20, int(1000 / PIXEL_SPACING_X)) # ~1km\n", + "house_spacing_pixels = max(10, int(500 / PIXEL_SPACING_X)) # ~500m\n", + "\n", + "tower_positions_px = select_hilltop_positions(terrain, num_positions=8, min_distance_pixels=tower_spacing_pixels)\n", + "house_positions_px = select_random_positions(terrain, num_positions=15, min_distance_pixels=house_spacing_pixels)\n", + "\n", + "print(f\"Terrain size: {W}x{H} pixels ({terrain_width_m/1000:.1f}km x {terrain_height_m/1000:.1f}km)\")\n", + "print(f\"Selected {len(tower_positions_px)} tower positions (hilltops, ~1km spacing)\")\n", + "print(f\"Selected {len(house_positions_px)} house positions (random, ~500m spacing)\")\n", + "\n", + "# Show positions on terrain\n", + "fig, ax = plt.subplots(figsize=(10, 8))\n", + "ax.imshow(terrain, cmap='terrain', alpha=0.8)\n", + "\n", + "if tower_positions_px:\n", + " tx, ty = zip(*tower_positions_px)\n", + " ax.scatter(tx, ty, c='magenta', s=150, marker='^', edgecolors='white', linewidths=2, label='Towers (Neon Magenta)')\n", + "\n", + "if house_positions_px:\n", + " hx, hy = zip(*house_positions_px)\n", + " ax.scatter(hx, hy, c='cyan', s=100, marker='s', edgecolors='white', linewidths=1.5, label='Houses (Neon Cyan)')\n", + "\n", + "ax.legend(loc='upper right')\n", + "ax.set_title(f'Model Positions on Grand Canyon ({len(tower_positions_px)} towers, {len(house_positions_px)} houses)')\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "build-scene", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Triangulating terrain...\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/brendan/miniconda/envs/xarray-spatial-everything/lib/python3.14/site-packages/numba/cuda/dispatcher.py:536: NumbaPerformanceWarning: Grid size 100 will likely result in GPU under-utilization due to low occupancy.\n", + " warn(NumbaPerformanceWarning(msg))\n", + "/home/brendan/miniconda/envs/xarray-spatial-everything/lib/python3.14/site-packages/numba/cuda/cudadrv/devicearray.py:887: NumbaPerformanceWarning: Host array used in CUDA kernel will incur copy overhead to/from device.\n", + " warn(NumbaPerformanceWarning(msg))\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + " Terrain mesh: 1,946,881 vertices, 3,888,000 triangles\n", + "\n", + "Placing towers using dem.rtx.place_mesh()...\n", + " Placed 8 towers\n", + " Tower mesh: 14,490 vertices\n", + "\n", + "Placing houses using dem.rtx.place_mesh()...\n", + " Placed 15 houses\n", + " House mesh: 26,737 vertices\n", + "\n", + "============================================================\n", + "Generating pine tree groves...\n", + "============================================================\n", + " Created 15 groves with 78 total trees\n", + " Tree scale: 6.49 (base 20m)\n", + "\n", + "Placing trees using dem.rtx.place_mesh()...\n", + " Scale bin 0: 28 trees at scale 5.21\n", + " Scale bin 1: 28 trees at scale 6.46\n", + " Scale bin 2: 22 trees at scale 7.72\n", + " Total trees placed: 78\n", + "\n", + "Scene built using dem.rtx accessor:\n", + " Total geometries: 102\n", + " Towers: 8\n", + " Houses: 15\n", + " Trees: 78 (in 15 groves)\n" + ] + } + ], + "source": [ + "# =============================================================================\n", + "# Place towers and houses using dem.rtx.place_mesh() accessor\n", + "# =============================================================================\n", + "\n", + "# Clear any existing scene and use accessor\n", + "dem.rtx.clear()\n", + "\n", + "# Triangulate terrain and add to scene\n", + "print(\"Triangulating terrain...\")\n", + "terrain_verts, terrain_indices = dem.rtx.triangulate(\n", + " pixel_spacing_x=PIXEL_SPACING_X,\n", + " pixel_spacing_y=PIXEL_SPACING_Y\n", + ")\n", + "print(f\" Terrain mesh: {len(terrain_verts)//3:,} vertices, {len(terrain_indices)//3:,} triangles\")\n", + "\n", + "print(\"\\nPlacing towers using dem.rtx.place_mesh()...\")\n", + "tower_verts, tower_indices, tower_transforms = dem.rtx.place_mesh(\n", + " TOWER_PATH,\n", + " positions=tower_positions_px,\n", + " geometry_id='tower',\n", + " scale=TOWER_SCALE,\n", + " rotation_z=0.0,\n", + " center_xy=True,\n", + " base_at_zero=True,\n", + " pixel_spacing_x=PIXEL_SPACING_X,\n", + " pixel_spacing_y=PIXEL_SPACING_Y\n", + ")\n", + "print(f\" Placed {len(tower_positions_px)} towers\")\n", + "print(f\" Tower mesh: {len(tower_verts)//3:,} vertices\")\n", + "\n", + "print(\"\\nPlacing houses using dem.rtx.place_mesh()...\")\n", + "house_verts, house_indices, house_transforms = dem.rtx.place_mesh(\n", + " HOUSE_PATH,\n", + " positions=house_positions_px,\n", + " geometry_id='house',\n", + " scale=HOUSE_SCALE,\n", + " rotation_z='random',\n", + " center_xy=True,\n", + " base_at_zero=True,\n", + " pixel_spacing_x=PIXEL_SPACING_X,\n", + " pixel_spacing_y=PIXEL_SPACING_Y\n", + ")\n", + "print(f\" Placed {len(house_positions_px)} houses\")\n", + "print(f\" House mesh: {len(house_verts)//3:,} vertices\")\n", + "\n", + "# =============================================================================\n", + "# Create realistic pine tree groves\n", + "# =============================================================================\n", + "\n", + "def generate_tree_groves(terrain, num_groves=8, trees_per_grove=25, \n", + " grove_radius_px=40, min_elevation_pct=0.3, \n", + " max_slope=30, seed=42):\n", + " \"\"\"\n", + " Generate tree positions in natural-looking groves.\n", + " \n", + " Trees are placed in clusters (groves) at locations that would\n", + " naturally support forest growth - moderate elevations with \n", + " reasonable slopes.\n", + " \"\"\"\n", + " np.random.seed(seed)\n", + " H, W = terrain.shape\n", + " \n", + " # Compute slope (gradient magnitude)\n", + " dy, dx = np.gradient(terrain)\n", + " slope = np.degrees(np.arctan(np.sqrt(dx**2 + dy**2)))\n", + " \n", + " # Find suitable areas for groves:\n", + " # - Not too steep (slope < max_slope)\n", + " # - Above minimum elevation (avoid canyon bottoms)\n", + " elev_min, elev_max = terrain.min(), terrain.max()\n", + " elev_threshold = elev_min + (elev_max - elev_min) * min_elevation_pct\n", + " \n", + " suitable = (slope < max_slope) & (terrain > elev_threshold)\n", + " \n", + " # Add margin to avoid edges\n", + " margin = int(grove_radius_px * 1.5)\n", + " suitable[:margin, :] = False\n", + " suitable[-margin:, :] = False\n", + " suitable[:, :margin] = False\n", + " suitable[:, -margin:] = False\n", + " \n", + " suitable_coords = np.argwhere(suitable)\n", + " if len(suitable_coords) < num_groves:\n", + " print(f\"Warning: Only {len(suitable_coords)} suitable locations found\")\n", + " num_groves = min(num_groves, len(suitable_coords))\n", + " \n", + " # Select grove centers with some spacing\n", + " grove_centers = []\n", + " min_grove_spacing = grove_radius_px * 3\n", + " \n", + " for _ in range(num_groves * 10): # Try multiple times\n", + " if len(grove_centers) >= num_groves:\n", + " break\n", + " idx = np.random.randint(len(suitable_coords))\n", + " row, col = suitable_coords[idx]\n", + " \n", + " # Check distance from existing groves\n", + " too_close = False\n", + " for gr, gc in grove_centers:\n", + " dist = np.sqrt((row - gr)**2 + (col - gc)**2)\n", + " if dist < min_grove_spacing:\n", + " too_close = True\n", + " break\n", + " \n", + " if not too_close:\n", + " grove_centers.append((row, col))\n", + " \n", + " # Generate tree positions within each grove\n", + " tree_positions = []\n", + " for grow, gcol in grove_centers:\n", + " # Irregular cluster shape using multiple sub-centers\n", + " num_subclusters = np.random.randint(2, 5)\n", + " \n", + " for _ in range(trees_per_grove):\n", + " # Pick a random sub-center\n", + " angle = np.random.uniform(0, 2 * np.pi)\n", + " subrad = grove_radius_px * 0.3 * np.random.random()\n", + " sub_row = grow + subrad * np.sin(angle)\n", + " sub_col = gcol + subrad * np.cos(angle)\n", + " \n", + " # Add random offset from sub-center\n", + " tree_angle = np.random.uniform(0, 2 * np.pi)\n", + " tree_rad = grove_radius_px * np.random.random() ** 0.7 # Denser toward center\n", + " \n", + " tree_row = sub_row + tree_rad * np.sin(tree_angle)\n", + " tree_col = sub_col + tree_rad * np.cos(tree_angle)\n", + " \n", + " # Check bounds and suitability\n", + " tr, tc = int(tree_row), int(tree_col)\n", + " if 0 <= tr < H and 0 <= tc < W:\n", + " if suitable[tr, tc]:\n", + " tree_positions.append((tc, tr)) # (col, row) = (x, y) in pixel coords\n", + " \n", + " return tree_positions, grove_centers\n", + "\n", + "\n", + "print(\"\\n\" + \"=\"*60)\n", + "print(\"Generating pine tree groves...\")\n", + "print(\"=\"*60)\n", + "\n", + "# Generate tree positions\n", + "tree_positions_px, grove_centers = generate_tree_groves(\n", + " terrain,\n", + " num_groves=15, # Number of forest groves\n", + " trees_per_grove=40, # Trees per grove\n", + " grove_radius_px=60, # Grove radius in pixels (~1.5km)\n", + " min_elevation_pct=0.15, # Include more of the terrain\n", + " max_slope=35, # Degrees - pines can grow on moderate slopes\n", + " seed=123\n", + ")\n", + "\n", + "print(f\" Created {len(grove_centers)} groves with {len(tree_positions_px)} total trees\")\n", + "\n", + "# Tree scaling with variation\n", + "TREE_HEIGHT_VARIATION = 0.3 # +/- 30%\n", + "\n", + "print(f\" Tree scale: {TREE_SCALE:.2f} (base {TREE_HEIGHT}m)\")\n", + "\n", + "# Place trees with random size variation\n", + "print(\"\\nPlacing trees using dem.rtx.place_mesh()...\")\n", + "\n", + "# Generate random scales for each tree\n", + "np.random.seed(456)\n", + "tree_scales = TREE_SCALE * (1 + TREE_HEIGHT_VARIATION * (2 * np.random.random(len(tree_positions_px)) - 1))\n", + "\n", + "# Place trees in batches by scale (to keep similar-sized trees together)\n", + "# This is more efficient than placing each tree individually\n", + "scale_bins = np.linspace(tree_scales.min(), tree_scales.max(), 4)\n", + "tree_verts_list = []\n", + "tree_indices_list = []\n", + "\n", + "for bin_idx in range(len(scale_bins) - 1):\n", + " mask = (tree_scales >= scale_bins[bin_idx]) & (tree_scales < scale_bins[bin_idx + 1])\n", + " if bin_idx == len(scale_bins) - 2: # Include max in last bin\n", + " mask = (tree_scales >= scale_bins[bin_idx])\n", + " \n", + " bin_positions = [tree_positions_px[j] for j in range(len(tree_positions_px)) if mask[j]]\n", + " if len(bin_positions) == 0:\n", + " continue\n", + " \n", + " avg_scale = (scale_bins[bin_idx] + scale_bins[bin_idx + 1]) / 2\n", + " \n", + " verts, indices, transforms = dem.rtx.place_mesh(\n", + " TREE_PATH,\n", + " positions=bin_positions,\n", + " geometry_id=f'tree_s{bin_idx}',\n", + " scale=avg_scale,\n", + " rotation_z='random', # Random rotation for natural look\n", + " center_xy=True,\n", + " base_at_zero=True,\n", + " pixel_spacing_x=PIXEL_SPACING_X,\n", + " pixel_spacing_y=PIXEL_SPACING_Y\n", + " )\n", + " tree_verts_list.append(verts)\n", + " tree_indices_list.append(indices)\n", + " print(f\" Scale bin {bin_idx}: {len(bin_positions)} trees at scale {avg_scale:.2f}\")\n", + "\n", + "print(f\" Total trees placed: {len(tree_positions_px)}\")\n", + "\n", + "\n", + "# List all geometries\n", + "geometries = dem.rtx.list_geometries()\n", + "num_towers = sum(1 for g in geometries if 'tower' in g)\n", + "num_houses = sum(1 for g in geometries if 'house' in g)\n", + "num_trees = sum(1 for g in geometries if 'tree' in g)\n", + "\n", + "print(f\"\\nScene built using dem.rtx accessor:\")\n", + "print(f\" Total geometries: {len(geometries)}\")\n", + "print(f\" Towers: {num_towers}\")\n", + "print(f\" Houses: {num_houses}\")\n", + "print(f\" Trees: {num_trees} (in {len(grove_centers)} groves)\")\n", + "\n", + "# Store RTX instance for later use\n", + "rtx = dem.rtx._rtx\n" + ] + }, + { + "cell_type": "markdown", + "id": "fba87de6", + "metadata": {}, + "source": [ + "## 5. Interactive Exploration\n", + "\n", + "Fly through the terrain with all placed meshes (towers, houses, trees) visible.\n", + "\n", + "**Controls:**\n", + "- **WASD/Arrows**: Move forward/back/left/right (in camera direction)\n", + "- **Q/E**: Move up/down\n", + "- **IJKL**: Look up/down/left/right\n", + "- **G**: Cycle through geometry layer info\n", + "- **T**: Toggle shadows\n", + "- **C**: Cycle colormap\n", + "- **+/-**: Adjust speed\n", + "- **X**: Exit" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "a988e065", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Scene geometries: ['terrain', 'tower_0', 'tower_1', 'tower_2', 'tower_3', 'tower_4', 'tower_5', 'tower_6', 'tower_7', 'house_0']...\n", + "Total: 102 geometries\n", + "\n", + "Starting interactive viewer...\n", + "Press G to cycle through geometry layers, X to exit\n", + "\n", + "\n", + "======================================================================\n", + "WARNING: Matplotlib is using a non-interactive backend.\n", + "Keyboard controls will NOT work with the inline backend.\n", + "\n", + "To fix, run this BEFORE calling explore():\n", + " %matplotlib qt\n", + " OR\n", + " %matplotlib tk\n", + " OR (if ipympl is installed):\n", + " %matplotlib widget\n", + "\n", + "Then restart the kernel and run the notebook again.\n", + "======================================================================\n", + "\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "MESA: error: ZINK: failed to choose pdev\n", + "glx: failed to create drisw screen\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + " dllPath = , dllName = libigdgmm2_w.so.2 \n", + " IsWddmLinux = 1, dllWslName = libigdgmm2_w.so.2 flags = 2\n", + " dllPath = , dllName = libigdgmm_w.so.12 \n", + " IsWddmLinux = 1, dllWslName = libigdgmm_w.so.12 flags = 2\n", + " dllPath = , dllName = libigdgmm2_w.so.2 \n", + " IsWddmLinux = 1, dllWslName = libigdgmm2_w.so.2 flags = 2\n", + " dllPath = , dllName = libigdgmm_w.so.12 \n", + " IsWddmLinux = 1, dllWslName = libigdgmm_w.so.12 flags = 2\n", + "\n", + "Interactive Viewer Started\n", + " Window: 1024x768\n", + " Render: 512x384 (50%)\n", + " Terrain: 1801x1081, elevation 670m - 2649m\n", + "\n", + "Press H for controls, X or Esc to exit\n", + "\n", + "Speed: 25.2\n", + "Speed: 30.2\n", + "Speed: 36.3\n", + "Speed: 43.6\n", + "Speed: 52.3\n", + "Speed: 62.7\n", + "Speed: 75.3\n", + "Speed: 90.3\n", + "Speed: 108.4\n", + "Speed: 130.1\n", + "Speed: 156.1\n", + "Speed: 187.3\n", + "Speed: 210.1\n", + "Speed: 210.1\n", + "Speed: 210.1\n", + "Speed: 210.1\n", + "Speed: 210.1\n", + "Speed: 210.1\n", + "Speed: 210.1\n", + "Speed: 210.1\n", + "Speed: 210.1\n", + "Observer placed at world (10113, 7482), pixel (406, 242)\n", + " Height: 10m above terrain\n", + " Press V to toggle viewshed, [/] to adjust height\n", + "Calculating viewshed...\n", + "Computing viewshed... (observer height: 10m)\n", + " Raster shape: (1081, 1801), pixel_spacing: (24.9, 30.8)\n", + " Building fresh terrain mesh...\n", + " Mesh built successfully\n", + " Observer at raster coords: (406.0, 242.0)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/brendan/miniconda/envs/xarray-spatial-everything/lib/python3.14/site-packages/numba/cuda/cudadrv/devicearray.py:887: NumbaPerformanceWarning: Host array used in CUDA kernel will incur copy overhead to/from device.\n", + " warn(NumbaPerformanceWarning(msg))\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + " Coverage: 0.3% terrain visible\n", + "Viewshed: ON (0.3% coverage)\n", + " Viewshed cache shape: (1081, 1801)\n", + "Colormap: viridis\n", + "Colormap: plasma\n", + "Colormap: cividis\n", + "Colormap: gray\n", + "Observer placed at world (12884, 9290), pixel (517, 301)\n", + " Height: 10m above terrain\n", + " Press V to toggle viewshed, [/] to adjust height\n", + "Computing viewshed... (observer height: 10m)\n", + " Raster shape: (1081, 1801), pixel_spacing: (24.9, 30.8)\n", + " Building fresh terrain mesh...\n", + " Mesh built successfully\n", + " Observer at raster coords: (517.0, 301.0)\n", + " Coverage: 0.7% terrain visible\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/brendan/miniconda/envs/xarray-spatial-everything/lib/python3.14/site-packages/numba/cuda/cudadrv/devicearray.py:887: NumbaPerformanceWarning: Host array used in CUDA kernel will incur copy overhead to/from device.\n", + " warn(NumbaPerformanceWarning(msg))\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Observer placed at world (13211, 9262), pixel (530, 300)\n", + " Height: 10m above terrain\n", + " Press V to toggle viewshed, [/] to adjust height\n", + "Computing viewshed... (observer height: 10m)\n", + " Raster shape: (1081, 1801), pixel_spacing: (24.9, 30.8)\n", + " Building fresh terrain mesh...\n", + " Mesh built successfully\n", + " Observer at raster coords: (530.0, 300.0)\n", + " Coverage: 0.5% terrain visible\n", + "Observer placed at world (34412, 22519), pixel (1382, 731)\n", + " Height: 10m above terrain\n", + " Press V to toggle viewshed, [/] to adjust height\n", + "Computing viewshed... (observer height: 10m)\n", + " Raster shape: (1081, 1801), pixel_spacing: (24.9, 30.8)\n", + " Building fresh terrain mesh...\n", + " Mesh built successfully\n", + " Observer at raster coords: (1382.0, 731.0)\n", + " Coverage: 0.4% terrain visible\n", + "Observer placed at world (20066, 10973), pixel (805, 356)\n", + " Height: 10m above terrain\n", + " Press V to toggle viewshed, [/] to adjust height\n", + "Computing viewshed... (observer height: 10m)\n", + " Raster shape: (1081, 1801), pixel_spacing: (24.9, 30.8)\n", + " Building fresh terrain mesh...\n", + " Mesh built successfully\n", + " Observer at raster coords: (805.0, 356.0)\n", + " Coverage: 1.2% terrain visible\n", + "Observer placed at world (17129, 15491), pixel (687, 502)\n", + " Height: 10m above terrain\n", + " Press V to toggle viewshed, [/] to adjust height\n", + "Computing viewshed... (observer height: 10m)\n", + " Raster shape: (1081, 1801), pixel_spacing: (24.9, 30.8)\n", + " Building fresh terrain mesh...\n", + " Mesh built successfully\n", + " Observer at raster coords: (687.0, 502.0)\n", + " Coverage: 1.8% terrain visible\n", + "Colormap: terrain\n", + "Colormap: viridis\n", + "Colormap: plasma\n", + "Colormap: cividis\n", + "Colormap: gray\n" + ] + } + ], + "source": [ + "# Switch to Qt backend for interactive window\n", + "%matplotlib qt\n", + "\n", + "# Launch interactive viewer - all placed meshes will be visible\n", + "# The scene includes: terrain, towers, houses, and tree groves\n", + "print(f\"Scene geometries: {dem.rtx.list_geometries()[:10]}...\" if len(dem.rtx.list_geometries()) > 10 else f\"Scene geometries: {dem.rtx.list_geometries()}\")\n", + "print(f\"Total: {dem.rtx.get_geometry_count()} geometries\")\n", + "print(\"\\nStarting interactive viewer...\")\n", + "print(\"Press G to cycle through geometry layers, X to exit\\n\")\n", + "\n", + "dem.rtx.explore(\n", + " width=1024,\n", + " height=768,\n", + " render_scale=0.5\n", + ")" + ] + }, + { + "cell_type": "markdown", + "id": "trace-header", + "metadata": {}, + "source": [ + "## 6. Ray Trace to Verify Tower Placement\n", + "\n", + "Let's trace rays downward to verify the towers are correctly placed on the terrain." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "trace-towers", + "metadata": {}, + "outputs": [], + "source": [ + "# Trace rays from above each model position to verify placement\n", + "all_positions_px = tower_positions_px + house_positions_px\n", + "num_test_rays = len(all_positions_px)\n", + "rays = np.zeros(num_test_rays * 8, dtype=np.float32)\n", + "\n", + "elev_max = terrain.max()\n", + "\n", + "for i, (col, row) in enumerate(all_positions_px):\n", + " # Convert to meters\n", + " x_m = col * PIXEL_SPACING_X\n", + " y_m = row * PIXEL_SPACING_Y\n", + " \n", + " # Ray from high above, pointing down\n", + " rays[i*8 + 0] = x_m # origin x (meters)\n", + " rays[i*8 + 1] = y_m # origin y (meters)\n", + " rays[i*8 + 2] = elev_max + 500 # origin z (well above terrain)\n", + " rays[i*8 + 3] = 0.0 # tmin\n", + " rays[i*8 + 4] = 0 # direction x\n", + " rays[i*8 + 5] = 0 # direction y\n", + " rays[i*8 + 6] = -1 # direction z (down)\n", + " rays[i*8 + 7] = 5000 # tmax\n", + "\n", + "hits = np.zeros(num_test_rays * 4, dtype=np.float32)\n", + "instance_ids = np.zeros(num_test_rays, dtype=np.int32)\n", + "\n", + "rtx.trace(rays, hits, num_test_rays, instance_ids=instance_ids)\n", + "\n", + "# Count hits\n", + "geometries = rtx.list_geometries()\n", + "terrain_idx = geometries.index('terrain')\n", + "\n", + "model_hits = (instance_ids != terrain_idx).sum()\n", + "terrain_hits = (instance_ids == terrain_idx).sum()\n", + "misses = (instance_ids == -1).sum()\n", + "\n", + "print(f\"Ray trace results ({num_test_rays} rays aimed at model positions):\")\n", + "print(f\" Hit model: {model_hits}\")\n", + "print(f\" Hit terrain: {terrain_hits}\")\n", + "print(f\" Miss: {misses}\")" + ] + }, + { + "cell_type": "markdown", + "id": "dynamic-header", + "metadata": {}, + "source": [ + "## 7. Dynamic Scene Management\n", + "\n", + "You can add or replace geometries in the scene at any time." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "add-more-instances", + "metadata": {}, + "outputs": [], + "source": [ + "# Transforms handled by place_mesh accessor" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "move-tower", + "metadata": {}, + "outputs": [], + "source": [ + "from rtxpy import make_transform\n", + "\n", + "# Move a tower by replacing its geometry with a new transform\n", + "new_col, new_row = 100, 100 # pixel coordinates\n", + "new_x_m = new_col * PIXEL_SPACING_X\n", + "new_y_m = new_row * PIXEL_SPACING_Y\n", + "new_z_m = terrain[int(new_row), int(new_col)]\n", + "\n", + "new_transform = make_transform(x=new_x_m, y=new_y_m, z=new_z_m)\n", + "rtx.add_geometry(\"tower_0\", tower_verts, tower_indices, transform=new_transform)\n", + "\n", + "print(f\"Moved tower_0 to ({new_x_m:.0f}m, {new_y_m:.0f}m, {new_z_m:.0f}m)\")\n", + "\n", + "# Initialize list for any dynamically added towers\n", + "new_tower_positions_px = []" + ] + }, + { + "cell_type": "markdown", + "id": "3d-header", + "metadata": {}, + "source": [ + "## 8. Flyover Render with Perspective Camera\n", + "\n", + "Now let's create a cinematic flyover render using GPU ray tracing. We'll trace perspective camera rays against the full scene including terrain, towers, and houses." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "3d-viz", + "metadata": {}, + "outputs": [], + "source": [ + "import math\n", + "from numba import cuda\n", + "\n", + "@cuda.jit\n", + "def generate_perspective_rays_kernel(rays, width, height, cam_pos, forward, right, up, fov_scale):\n", + " \"\"\"Generate perspective camera rays on GPU.\"\"\"\n", + " px, py = cuda.grid(2)\n", + " if px < width and py < height:\n", + " aspect = width / height\n", + " u = (2.0 * (px + 0.5) / width - 1.0) * aspect * fov_scale\n", + " v = (1.0 - 2.0 * (py + 0.5) / height) * fov_scale\n", + " \n", + " # Ray direction\n", + " dx = forward[0] + u * right[0] + v * up[0]\n", + " dy = forward[1] + u * right[1] + v * up[1]\n", + " dz = forward[2] + u * right[2] + v * up[2]\n", + " \n", + " # Normalize\n", + " length = math.sqrt(dx*dx + dy*dy + dz*dz)\n", + " dx /= length\n", + " dy /= length\n", + " dz /= length\n", + " \n", + " idx = py * width + px\n", + " rays[idx, 0] = cam_pos[0]\n", + " rays[idx, 1] = cam_pos[1]\n", + " rays[idx, 2] = cam_pos[2]\n", + " rays[idx, 3] = 0.1 # tmin\n", + " rays[idx, 4] = dx\n", + " rays[idx, 5] = dy\n", + " rays[idx, 6] = dz\n", + " rays[idx, 7] = 50000.0 # tmax (50km range)\n", + "\n", + "\n", + "@cuda.jit\n", + "def shade_scene_neon_kernel(output, rays, hits, instance_ids, \n", + " width, height, sun_dir, ambient, num_towers, num_houses,\n", + " elev_min, elev_range):\n", + " \"\"\"Shade the scene with NEON colors for towers, houses, and trees.\"\"\"\n", + " idx = cuda.grid(1)\n", + " if idx >= width * height:\n", + " return\n", + " \n", + " px = idx % width\n", + " py = idx // width\n", + " t = hits[idx, 0]\n", + " \n", + " if t > 0:\n", + " # Get surface normal\n", + " nx, ny, nz = hits[idx, 1], hits[idx, 2], hits[idx, 3]\n", + " \n", + " # Flip normal if facing away\n", + " dx, dy, dz = rays[idx, 4], rays[idx, 5], rays[idx, 6]\n", + " if nx*dx + ny*dy + nz*dz > 0:\n", + " nx, ny, nz = -nx, -ny, -nz\n", + " \n", + " # Compute hit point\n", + " hit_z = rays[idx, 2] + t * dz\n", + " \n", + " # Lambertian shading\n", + " cos_theta = nx*sun_dir[0] + ny*sun_dir[1] + nz*sun_dir[2]\n", + " if cos_theta < 0:\n", + " cos_theta = 0.0\n", + " lighting = ambient + (1.0 - ambient) * cos_theta\n", + " \n", + " # Determine color based on geometry type\n", + " # Geometry order: terrain(0), towers(1-num_towers), houses(num_towers+1 to num_towers+num_houses), trees(rest)\n", + " geom_id = instance_ids[idx]\n", + " \n", + " if geom_id == 0: # Terrain\n", + " # Color by elevation - desert/canyon colors\n", + " t_norm = (hit_z - elev_min) / elev_range if elev_range > 0 else 0.5\n", + " if t_norm < 0: t_norm = 0.0\n", + " if t_norm > 1: t_norm = 1.0\n", + " \n", + " # Canyon colors: red/orange at low elevation, tan/cream at top\n", + " r = 0.6 + 0.3 * t_norm\n", + " g = 0.3 + 0.4 * t_norm\n", + " b = 0.2 + 0.3 * t_norm\n", + " \n", + " elif geom_id <= num_towers: # Tower - NEON MAGENTA/PINK\n", + " r, g, b = 1.0, 0.0, 0.8 # Hot magenta\n", + " # Add glow effect - less affected by lighting\n", + " lighting = 0.7 + 0.3 * lighting\n", + " \n", + " elif geom_id <= num_towers + num_houses: # House - NEON CYAN\n", + " r, g, b = 0.0, 1.0, 0.8 # Electric cyan\n", + " # Add glow effect\n", + " lighting = 0.7 + 0.3 * lighting\n", + " \n", + " else: # Trees - FOREST GREEN\n", + " r, g, b = 0.1, 0.6, 0.15 # Dark forest green\n", + " # Slight variation based on hit position\n", + " variation = (hit_z % 10) / 50.0\n", + " g = g + variation\n", + " \n", + " output[py, px, 0] = r * lighting\n", + " output[py, px, 1] = g * lighting\n", + " output[py, px, 2] = b * lighting\n", + " else:\n", + " # Sky gradient - darker blue for contrast with neon\n", + " v_norm = 1.0 - py / height\n", + " output[py, px, 0] = 0.1 + 0.1 * v_norm\n", + " output[py, px, 1] = 0.15 + 0.15 * v_norm\n", + " output[py, px, 2] = 0.3 + 0.2 * v_norm\n", + "\n", + "\n", + "def render_flyover(rtx, terrain, camera_pos, look_at, fov=60, width=1280, height=720,\n", + " sun_azimuth=225, sun_altitude=45, ambient=0.2, num_towers=15, num_houses=15):\n", + " \"\"\"Render the scene with a perspective camera and neon-colored models.\"\"\"\n", + " \n", + " # Camera basis vectors\n", + " cam = np.array(camera_pos, dtype=np.float32)\n", + " target = np.array(look_at, dtype=np.float32)\n", + " world_up = np.array([0, 0, 1], dtype=np.float32)\n", + " \n", + " forward = target - cam\n", + " forward /= np.linalg.norm(forward)\n", + " \n", + " right = np.cross(forward, world_up)\n", + " right /= np.linalg.norm(right)\n", + " \n", + " up = np.cross(right, forward)\n", + " up /= np.linalg.norm(up)\n", + " \n", + " # Sun direction\n", + " az_rad = np.radians(sun_azimuth)\n", + " alt_rad = np.radians(sun_altitude)\n", + " sun_dir = np.array([\n", + " -np.sin(az_rad) * np.cos(alt_rad),\n", + " -np.cos(az_rad) * np.cos(alt_rad),\n", + " np.sin(alt_rad)\n", + " ], dtype=np.float32)\n", + " \n", + " fov_scale = np.tan(np.radians(fov) / 2)\n", + " \n", + " # Allocate GPU buffers\n", + " num_rays = width * height\n", + " d_rays = cp.zeros((num_rays, 8), dtype=np.float32)\n", + " d_hits = cp.zeros((num_rays, 4), dtype=np.float32)\n", + " d_instance_ids = cp.zeros(num_rays, dtype=np.int32)\n", + " d_output = cp.zeros((height, width, 3), dtype=np.float32)\n", + " \n", + " # Upload camera data\n", + " d_cam = cp.array(cam)\n", + " d_forward = cp.array(forward)\n", + " d_right = cp.array(right)\n", + " d_up = cp.array(up)\n", + " d_sun = cp.array(sun_dir)\n", + " \n", + " # Generate rays\n", + " threads = (16, 16)\n", + " blocks = ((width + 15) // 16, (height + 15) // 16)\n", + " generate_perspective_rays_kernel[blocks, threads](\n", + " d_rays, width, height, d_cam, d_forward, d_right, d_up, fov_scale\n", + " )\n", + " cp.cuda.Device().synchronize()\n", + " \n", + " # Trace rays\n", + " rtx.trace(d_rays, d_hits, num_rays, instance_ids=d_instance_ids)\n", + " \n", + " # Shade with neon colors\n", + " elev_min = float(terrain.min())\n", + " elev_max = float(terrain.max())\n", + " threads_1d = 256\n", + " blocks_1d = (num_rays + 255) // 256\n", + " shade_scene_neon_kernel[blocks_1d, threads_1d](\n", + " d_output, d_rays, d_hits, d_instance_ids,\n", + " width, height, d_sun, ambient, num_towers, num_houses,\n", + " elev_min, elev_max - elev_min\n", + " )\n", + " cp.cuda.Device().synchronize()\n", + " \n", + " return cp.asnumpy(d_output)\n", + "\n", + "\n", + "# Scene dimensions in meters\n", + "H, W = terrain.shape\n", + "scene_width_m = W * PIXEL_SPACING_X # ~13,500m\n", + "scene_height_m = H * PIXEL_SPACING_Y # ~11,100m\n", + "center_x_m = scene_width_m / 2\n", + "center_y_m = scene_height_m / 2\n", + "elev_center = terrain[H//2, W//2]\n", + "elev_max = terrain.max()\n", + "elev_min = terrain.min()\n", + "\n", + "print(f\"Scene dimensions: {scene_width_m/1000:.1f}km x {scene_height_m/1000:.1f}km\")\n", + "print(f\"Elevation range: {elev_min:.0f}m to {elev_max:.0f}m (relief: {elev_max-elev_min:.0f}m)\")\n", + "\n", + "# Camera positioned for dramatic canyon flyover\n", + "# Position 3km back and 500m above the highest point\n", + "camera_position = (scene_width_m * 0.1, -3000, elev_max + 500)\n", + "look_at = (center_x_m, center_y_m, elev_center)\n", + "\n", + "print(f\"\\nRendering Grand Canyon flyover with NEON models...\")\n", + "print(f\" Camera: ({camera_position[0]:.0f}m, {camera_position[1]:.0f}m, {camera_position[2]:.0f}m)\")\n", + "print(f\" Looking at: ({look_at[0]:.0f}m, {look_at[1]:.0f}m, {look_at[2]:.0f}m)\")\n", + "\n", + "img = render_flyover(\n", + " rtx, terrain,\n", + " camera_pos=camera_position,\n", + " look_at=look_at,\n", + " fov=50,\n", + " width=1280,\n", + " height=720,\n", + " sun_azimuth=200,\n", + " sun_altitude=35,\n", + " ambient=0.3,\n", + " num_towers=len(tower_positions_px) + len(new_tower_positions_px),\n", + " num_houses=len(house_positions_px)\n", + ")\n", + "\n", + "# Display\n", + "fig, ax = plt.subplots(figsize=(14, 8))\n", + "ax.imshow(np.clip(img, 0, 1))\n", + "ax.axis('off')\n", + "ax.set_title('Grand Canyon Flyover: Neon Towers (Magenta) & Houses (Cyan)', fontsize=14)\n", + "plt.tight_layout()\n", + "plt.show()\n", + "\n", + "print(f\"\\nRendered {img.shape[1]}x{img.shape[0]} image\")\n", + "print(f\" Towers: NEON MAGENTA ({TOWER_HEIGHT}m tall)\")\n", + "print(f\" Houses: NEON CYAN ({HOUSE_HEIGHT}m tall)\")" + ] + }, + { + "cell_type": "markdown", + "id": "w8vfvccecac", + "metadata": {}, + "source": [ + "## 9. Tower Perspective Views\n", + "\n", + "Render the scene from each tower's viewpoint, looking out across the Grand Canyon." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "a2d371db-6766-422e-a8db-43fef3480b0a", + "metadata": {}, + "outputs": [], + "source": [ + "%matplotlib qt\n", + "\n", + "dem.rtx.explore(\n", + " width=1024,\n", + " height=768,\n", + " render_scale=0.5, # Render at half resolution for speed\n", + " key_repeat_interval=0.08, # Throttle key repeats (50ms = 20 FPS max)\n", + ")" + ] + }, + { + "cell_type": "markdown", + "id": "8hnymiq3gt5", + "metadata": {}, + "source": [ + "## 10. Optimal Tower Placement with PuLP\n", + "\n", + "Use linear programming to find the optimal cell tower placement that maximizes coverage of the study area. We'll use **ray tracing** to determine line-of-sight coverage and **PuLP** to solve the optimization problem.\n", + "\n", + "**Problem Formulation (Maximal Covering Location Problem):**\n", + "- **Decision variables**: Which candidate tower locations to use\n", + "- **Objective**: Maximize the number of demand points covered\n", + "- **Constraint**: Limited number of towers (budget constraint)\n", + "- **Coverage**: A demand point is covered if it has line-of-sight to at least one active tower" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "56yw7zz5619", + "metadata": {}, + "outputs": [], + "source": [ + "import pulp\n", + "\n", + "# =============================================================================\n", + "# Step 1: Define demand points (grid across the terrain)\n", + "# =============================================================================\n", + "# Sample terrain at regular intervals as \"demand points\" that need coverage\n", + "DEMAND_SPACING = 15 # Sample every 15 pixels (~400m)\n", + "\n", + "demand_points_px = []\n", + "for row in range(DEMAND_SPACING, H - DEMAND_SPACING, DEMAND_SPACING):\n", + " for col in range(DEMAND_SPACING, W - DEMAND_SPACING, DEMAND_SPACING):\n", + " demand_points_px.append((col, row))\n", + "\n", + "print(f\"Demand points: {len(demand_points_px)} locations\")\n", + "print(f\" Grid spacing: ~{DEMAND_SPACING * PIXEL_SPACING_X:.0f}m x {DEMAND_SPACING * PIXEL_SPACING_Y:.0f}m\")\n", + "\n", + "# =============================================================================\n", + "# Step 2: Define candidate tower locations (hilltops)\n", + "# =============================================================================\n", + "# Use elevation-weighted sampling to find good candidate locations\n", + "NUM_CANDIDATES = 30\n", + "\n", + "candidate_positions_px = select_hilltop_positions(\n", + " terrain, \n", + " num_positions=NUM_CANDIDATES, \n", + " min_distance_pixels=15, # ~400m minimum spacing\n", + " seed=999\n", + ")\n", + "print(f\"Candidate tower locations: {len(candidate_positions_px)}\")\n", + "\n", + "# Visualize demand points and candidates\n", + "fig, ax = plt.subplots(figsize=(10, 8))\n", + "ax.imshow(terrain, cmap='terrain', alpha=0.7)\n", + "\n", + "# Demand points (small dots)\n", + "dx, dy = zip(*demand_points_px)\n", + "ax.scatter(dx, dy, c='blue', s=5, alpha=0.3, label=f'Demand points ({len(demand_points_px)})')\n", + "\n", + "# Candidate locations (triangles)\n", + "cx, cy = zip(*candidate_positions_px)\n", + "ax.scatter(cx, cy, c='red', s=80, marker='^', edgecolors='white', \n", + " linewidths=1, label=f'Candidate towers ({len(candidate_positions_px)})')\n", + "\n", + "ax.legend(loc='upper right')\n", + "ax.set_title('Demand Points and Candidate Tower Locations')\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "7uf0w3gwhvq", + "metadata": {}, + "outputs": [], + "source": [ + "# =============================================================================\n", + "# Step 3: Build coverage matrix using rtxpy viewshed analytics\n", + "# =============================================================================\n", + "# Use rtxpy's xarray accessor for clean viewshed analysis\n", + "\n", + "import xarray as xr\n", + "\n", + "# Create xarray DataArray with proper coordinates\n", + "y_coords = np.arange(H) * PIXEL_SPACING_Y\n", + "x_coords = np.arange(W) * PIXEL_SPACING_X\n", + "\n", + "terrain_xr = xr.DataArray(\n", + " terrain,\n", + " dims=['y', 'x'],\n", + " coords={'y': y_coords, 'x': x_coords},\n", + " name='elevation'\n", + ")\n", + "\n", + "# Convert to GPU using rtx accessor\n", + "terrain_gpu = dem\n", + "\n", + "print(f\"Terrain DataArray: {terrain_gpu.shape}\")\n", + "print(f\" X range: {x_coords[0]:.0f}m to {x_coords[-1]:.0f}m\")\n", + "print(f\" Y range: {y_coords[0]:.0f}m to {y_coords[-1]:.0f}m\")\n", + "print(f\" Data on GPU: {type(terrain_gpu.data).__module__}\")\n", + "\n", + "def compute_coverage_with_viewshed(candidate_positions_px, demand_points_px, \n", + " terrain_gpu, pixel_spacing_x, pixel_spacing_y,\n", + " tower_height, receiver_height=2.0):\n", + " \"\"\"\n", + " Compute coverage matrix using rtxpy viewshed accessor.\n", + " \n", + " For each candidate tower, compute viewshed and sample at demand points.\n", + " \"\"\"\n", + " num_candidates = len(candidate_positions_px)\n", + " num_demands = len(demand_points_px)\n", + " \n", + " coverage = np.zeros((num_candidates, num_demands), dtype=np.int32)\n", + " \n", + " # Pre-compute demand point coordinates in PIXELS (matching dem coordinates)\n", + " demand_coords = [(dcol, drow) \n", + " for dcol, drow in demand_points_px]\n", + " \n", + " for i, (tcol, trow) in enumerate(candidate_positions_px):\n", + " # Tower position in PIXEL coordinates (matching dem coordinates)\n", + " tx = tcol # Use pixel coordinate directly\n", + " ty = trow # Use pixel coordinate directly\n", + " \n", + " # Compute viewshed using xarray accessor\n", + " # observer_elev = tower height, target_elev = receiver height\n", + " try:\n", + " vis = dem.rtx.viewshed(\n", + " x=tx,\n", + " y=ty,\n", + " observer_elev=tower_height,\n", + " target_elev=receiver_height\n", + " )\n", + " \n", + " # Sample visibility at each demand point\n", + " vis_np = cp.asnumpy(vis.data) if hasattr(vis.data, 'get') else vis.data\n", + " \n", + " for j, (dcol, drow) in enumerate(demand_coords):\n", + " # Use pixel indices directly (coords are already in pixels)\n", + " col_idx = int(dcol)\n", + " row_idx = int(drow)\n", + " \n", + " col_idx = max(0, min(col_idx, vis_np.shape[1] - 1))\n", + " row_idx = max(0, min(row_idx, vis_np.shape[0] - 1))\n", + " \n", + " # Visible if value >= 0 (INVISIBLE = -1)\n", + " if vis_np[row_idx, col_idx] >= 0:\n", + " coverage[i, j] = 1\n", + " \n", + " except Exception as e:\n", + " print(f\" Warning: viewshed failed for candidate {i}: {e}\")\n", + " continue\n", + " \n", + " if (i + 1) % 5 == 0:\n", + " covered_count = coverage[i].sum()\n", + " print(f\" Candidate {i + 1}/{num_candidates}: covers {covered_count} points ({100*covered_count/num_demands:.1f}%)\")\n", + " \n", + " return coverage\n", + "\n", + "\n", + "print(\"\\nComputing coverage using dem.rtx.viewshed()...\")\n", + "print(f\" Tower height: {TOWER_HEIGHT}m (observer)\")\n", + "print(f\" Receiver height: 2m (target)\")\n", + "print(f\" Candidates: {len(candidate_positions_px)}\")\n", + "print(f\" Demand points: {len(demand_points_px)}\")\n", + "\n", + "coverage_matrix = compute_coverage_with_viewshed(\n", + " candidate_positions_px, \n", + " demand_points_px, \n", + " terrain_gpu,\n", + " PIXEL_SPACING_X,\n", + " PIXEL_SPACING_Y,\n", + " TOWER_HEIGHT\n", + ")\n", + "\n", + "# Coverage statistics\n", + "coverage_per_tower = coverage_matrix.sum(axis=1)\n", + "print(f\"\\nCoverage statistics:\")\n", + "print(f\" Best candidate covers: {coverage_per_tower.max()} demand points ({100*coverage_per_tower.max()/len(demand_points_px):.1f}%)\")\n", + "print(f\" Worst candidate covers: {coverage_per_tower.min()} demand points ({100*coverage_per_tower.min()/len(demand_points_px):.1f}%)\")\n", + "print(f\" Average coverage: {coverage_per_tower.mean():.1f} demand points ({100*coverage_per_tower.mean()/len(demand_points_px):.1f}%)\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "zq36uxm5s2", + "metadata": {}, + "outputs": [], + "source": [ + "# =============================================================================\n", + "# Step 4: Solve optimization problem with PuLP\n", + "# =============================================================================\n", + "# Maximal Covering Location Problem (MCLP):\n", + "# Maximize demand points covered, subject to a budget of N towers\n", + "\n", + "def solve_tower_placement(coverage_matrix, num_towers, demand_points_px):\n", + " \"\"\"\n", + " Solve the Maximal Covering Location Problem using PuLP.\n", + " \n", + " Decision variables:\n", + " x[i] = 1 if we build tower at candidate location i, 0 otherwise\n", + " y[j] = 1 if demand point j is covered, 0 otherwise\n", + " \n", + " Objective: Maximize sum(y[j]) - total demand points covered\n", + " \n", + " Constraints:\n", + " - sum(x[i]) <= num_towers (budget constraint)\n", + " - y[j] <= sum(x[i] for i that covers j) (coverage constraint)\n", + " \"\"\"\n", + " num_candidates = coverage_matrix.shape[0]\n", + " num_demands = coverage_matrix.shape[1]\n", + " \n", + " # Create the problem\n", + " prob = pulp.LpProblem(\"Cell_Tower_Placement\", pulp.LpMaximize)\n", + " \n", + " # Decision variables\n", + " x = [pulp.LpVariable(f\"tower_{i}\", cat='Binary') for i in range(num_candidates)]\n", + " y = [pulp.LpVariable(f\"covered_{j}\", cat='Binary') for j in range(num_demands)]\n", + " \n", + " # Objective: Maximize covered demand points\n", + " prob += pulp.lpSum(y), \"Total_Coverage\"\n", + " \n", + " # Constraint: Budget (max number of towers)\n", + " prob += pulp.lpSum(x) <= num_towers, \"Tower_Budget\"\n", + " \n", + " # Constraint: A demand point can only be covered if at least one covering tower is built\n", + " for j in range(num_demands):\n", + " covering_towers = [i for i in range(num_candidates) if coverage_matrix[i, j] == 1]\n", + " if covering_towers:\n", + " prob += y[j] <= pulp.lpSum(x[i] for i in covering_towers), f\"Coverage_{j}\"\n", + " else:\n", + " # This demand point cannot be covered by any candidate\n", + " prob += y[j] == 0, f\"Uncoverable_{j}\"\n", + " \n", + " # Solve\n", + " prob.solve(pulp.PULP_CBC_CMD(msg=0)) # Suppress solver output\n", + " \n", + " # Extract solution\n", + " selected_towers = [i for i in range(num_candidates) if pulp.value(x[i]) == 1]\n", + " covered_demands = [j for j in range(num_demands) if pulp.value(y[j]) == 1]\n", + " \n", + " return selected_towers, covered_demands, pulp.LpStatus[prob.status]\n", + "\n", + "\n", + "# Solve for different tower budgets\n", + "print(\"Solving optimal tower placement with PuLP...\")\n", + "print(\"=\" * 60)\n", + "\n", + "results = {}\n", + "for num_towers in [3, 5, 8, 10]:\n", + " selected, covered, status = solve_tower_placement(coverage_matrix, num_towers, demand_points_px)\n", + " coverage_pct = 100 * len(covered) / len(demand_points_px)\n", + " results[num_towers] = (selected, covered, coverage_pct)\n", + " print(f\" {num_towers} towers: {len(covered)}/{len(demand_points_px)} demand points covered ({coverage_pct:.1f}%) - Status: {status}\")\n", + "\n", + "print(\"=\" * 60)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "5u5xto5by0e", + "metadata": {}, + "outputs": [], + "source": [ + "# =============================================================================\n", + "# Step 5: Visualize optimal placement\n", + "# =============================================================================\n", + "# Show coverage maps for different tower budgets\n", + "\n", + "fig, axes = plt.subplots(2, 2, figsize=(14, 12))\n", + "axes = axes.flatten()\n", + "\n", + "for idx, num_towers in enumerate([3, 5, 8, 10]):\n", + " ax = axes[idx]\n", + " selected, covered, coverage_pct = results[num_towers]\n", + " \n", + " # Show terrain\n", + " ax.imshow(terrain, cmap='terrain', alpha=0.6)\n", + " \n", + " # Show all demand points\n", + " all_dx, all_dy = zip(*demand_points_px)\n", + " \n", + " # Covered vs uncovered\n", + " covered_set = set(covered)\n", + " covered_dx = [demand_points_px[j][0] for j in covered]\n", + " covered_dy = [demand_points_px[j][1] for j in covered]\n", + " uncovered_dx = [demand_points_px[j][0] for j in range(len(demand_points_px)) if j not in covered_set]\n", + " uncovered_dy = [demand_points_px[j][1] for j in range(len(demand_points_px)) if j not in covered_set]\n", + " \n", + " # Plot uncovered (red) and covered (green)\n", + " if uncovered_dx:\n", + " ax.scatter(uncovered_dx, uncovered_dy, c='red', s=8, alpha=0.5, label='No coverage')\n", + " ax.scatter(covered_dx, covered_dy, c='lime', s=8, alpha=0.7, label='Covered')\n", + " \n", + " # Plot selected tower locations\n", + " for i in selected:\n", + " tcol, trow = candidate_positions_px[i]\n", + " ax.scatter(tcol, trow, c='magenta', s=200, marker='^', \n", + " edgecolors='white', linewidths=2, zorder=10)\n", + " ax.annotate(f'T{i+1}', (tcol+5, trow-5), color='white', fontsize=8,\n", + " fontweight='bold', zorder=11)\n", + " \n", + " ax.set_title(f'{num_towers} Towers: {coverage_pct:.1f}% Coverage', fontsize=12)\n", + " ax.axis('off')\n", + "\n", + "# Add legend to first plot\n", + "axes[0].legend(loc='lower right', fontsize=9)\n", + "\n", + "plt.suptitle('Optimal Cell Tower Placement (PuLP Optimization)', fontsize=14, y=1.02)\n", + "plt.tight_layout()\n", + "plt.show()\n", + "\n", + "# Print detailed results for the 5-tower solution\n", + "print(\"\\n\" + \"=\"*60)\n", + "print(\"RECOMMENDED SOLUTION: 5 Towers\")\n", + "print(\"=\"*60)\n", + "selected_5, covered_5, coverage_5 = results[5]\n", + "for i, tower_idx in enumerate(selected_5):\n", + " tcol, trow = candidate_positions_px[tower_idx]\n", + " tx = tcol * PIXEL_SPACING_X\n", + " ty = trow * PIXEL_SPACING_Y\n", + " tz = terrain[int(trow), int(tcol)]\n", + " tower_coverage = coverage_matrix[tower_idx].sum()\n", + " print(f\" Tower {i+1}: Position ({tx:.0f}m, {ty:.0f}m), Elevation {tz:.0f}m, Covers {tower_coverage} points\")\n", + "print(f\"\\nTotal coverage: {len(covered_5)}/{len(demand_points_px)} = {coverage_5:.1f}%\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "wuildrxe9ko", + "metadata": {}, + "outputs": [], + "source": [ + "from rtxpy import RTX\n", + "\n", + "# =============================================================================\n", + "# Step 6: Build complete scene with coverage visualization\n", + "# =============================================================================\n", + "# Place houses at demand points (colored by coverage) and towers at optimal locations\n", + "\n", + "# Use the 5-tower solution\n", + "selected_5, covered_5, coverage_5 = results[5]\n", + "covered_set = set(covered_5)\n", + "\n", + "# Create new RTX scene\n", + "rtx_optimal = RTX()\n", + "rtx_optimal.add_geometry(\"terrain\", terrain_verts, terrain_indices)\n", + "\n", + "# Track geometry indices for shading\n", + "# IMPORTANT: Order must be terrain(0), towers(1-N), ALL covered houses, then ALL uncovered houses\n", + "num_optimal_towers = len(selected_5)\n", + "\n", + "# Add towers at optimal locations\n", + "print(f\"Adding {num_optimal_towers} optimal towers...\")\n", + "optimal_tower_positions = []\n", + "for i, tower_idx in enumerate(selected_5):\n", + " tcol, trow = candidate_positions_px[tower_idx]\n", + " tx = tcol * PIXEL_SPACING_X\n", + " ty = trow * PIXEL_SPACING_Y\n", + " tz = terrain[int(trow), int(tcol)]\n", + " transform = make_transform(x=tx, y=ty, z=tz)\n", + " rtx_optimal.add_geometry(f\"tower_{i}\", tower_verts, tower_indices, transform=transform)\n", + " optimal_tower_positions.append((tx, ty, tz))\n", + "\n", + "# Add houses at demand points\n", + "# MUST add all covered houses first, then all uncovered (for shader indexing)\n", + "print(f\"Adding {len(demand_points_px)} houses at demand points...\")\n", + "\n", + "# Separate into covered and uncovered lists with positions\n", + "covered_houses = []\n", + "uncovered_houses = []\n", + "\n", + "for j, (dcol, drow) in enumerate(demand_points_px):\n", + " dx = dcol * PIXEL_SPACING_X\n", + " dy = drow * PIXEL_SPACING_Y\n", + " dz = terrain[int(drow), int(dcol)]\n", + " angle = np.random.uniform(0, 2 * np.pi)\n", + " \n", + " if j in covered_set:\n", + " covered_houses.append((j, dx, dy, dz, angle))\n", + " else:\n", + " uncovered_houses.append((j, dx, dy, dz, angle))\n", + "\n", + "# Add ALL covered houses first\n", + "for j, dx, dy, dz, angle in covered_houses:\n", + " transform = make_transform(x=dx, y=dy, z=dz, rotation_z=angle)\n", + " rtx_optimal.add_geometry(f\"house_covered_{j}\", house_verts, house_indices, transform=transform)\n", + "\n", + "# Then add ALL uncovered houses\n", + "for j, dx, dy, dz, angle in uncovered_houses:\n", + " transform = make_transform(x=dx, y=dy, z=dz, rotation_z=angle)\n", + " rtx_optimal.add_geometry(f\"house_uncovered_{j}\", house_verts, house_indices, transform=transform)\n", + "\n", + "num_covered_houses = len(covered_houses)\n", + "num_uncovered_houses = len(uncovered_houses)\n", + "\n", + "print(f\"\\nScene built:\")\n", + "print(f\" Geometry order: terrain(0), towers(1-{num_optimal_towers}), \"\n", + " f\"covered({num_optimal_towers+1}-{num_optimal_towers+num_covered_houses}), \"\n", + " f\"uncovered({num_optimal_towers+num_covered_houses+1}+)\")\n", + "print(f\" Towers: {num_optimal_towers}\")\n", + "print(f\" Covered houses (lime): {num_covered_houses}\")\n", + "print(f\" Uncovered houses (fuschia): {num_uncovered_houses}\")\n", + "print(f\" Total geometries: {len(rtx_optimal.list_geometries())}\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "8cyrd2z8fie", + "metadata": {}, + "outputs": [], + "source": [ + "# =============================================================================\n", + "# Custom shader for coverage visualization with realistic tower colors\n", + "# =============================================================================\n", + "# Colors: Terrain (canyon), Towers (realistic from GLB), Covered houses (lime), Uncovered (fuschia)\n", + "\n", + "import trimesh\n", + "\n", + "def extract_triangle_colors(glb_path):\n", + " \"\"\"Extract per-triangle colors from a GLB file.\"\"\"\n", + " scene = trimesh.load(glb_path)\n", + " \n", + " all_colors = []\n", + " for name, geom in scene.geometry.items():\n", + " if isinstance(geom, trimesh.Trimesh):\n", + " # Convert texture to vertex colors\n", + " vis = geom.visual.to_color()\n", + " if hasattr(vis, 'vertex_colors') and vis.vertex_colors is not None:\n", + " vc = vis.vertex_colors # (num_verts, 4)\n", + " # Average colors for each face\n", + " for face in geom.faces:\n", + " face_colors = vc[face] # (3, 4)\n", + " avg_color = face_colors.mean(axis=0)\n", + " all_colors.append(avg_color)\n", + " \n", + " if all_colors:\n", + " return np.array(all_colors, dtype=np.float32) / 255.0 # Normalize to 0-1\n", + " return None\n", + "\n", + "# Extract tower colors\n", + "print(\"Extracting realistic colors from tower GLB...\")\n", + "tower_triangle_colors = extract_triangle_colors(TOWER_PATH)\n", + "if tower_triangle_colors is not None:\n", + " print(f\" Extracted {len(tower_triangle_colors)} triangle colors\")\n", + " print(f\" Color range: R [{tower_triangle_colors[:,0].min():.2f}-{tower_triangle_colors[:,0].max():.2f}], \"\n", + " f\"G [{tower_triangle_colors[:,1].min():.2f}-{tower_triangle_colors[:,1].max():.2f}], \"\n", + " f\"B [{tower_triangle_colors[:,2].min():.2f}-{tower_triangle_colors[:,2].max():.2f}]\")\n", + " \n", + " # Upload to GPU\n", + " d_tower_colors = cp.array(tower_triangle_colors[:, :3]) # RGB only\n", + "else:\n", + " print(\" Warning: Could not extract colors, using default gray\")\n", + " d_tower_colors = None\n", + "\n", + "\n", + "@cuda.jit\n", + "def shade_coverage_realistic_kernel(output, rays, hits, instance_ids, primitive_ids,\n", + " tower_colors, num_tower_tris,\n", + " width, height, sun_dir, ambient,\n", + " num_towers, num_covered, elev_min, elev_range):\n", + " \"\"\"\n", + " Shade scene with realistic tower colors and coverage-based house colors.\n", + " \"\"\"\n", + " idx = cuda.grid(1)\n", + " if idx >= width * height:\n", + " return\n", + " \n", + " px = idx % width\n", + " py = idx // width\n", + " t = hits[idx, 0]\n", + " \n", + " if t > 0:\n", + " # Get surface normal\n", + " nx, ny, nz = hits[idx, 1], hits[idx, 2], hits[idx, 3]\n", + " \n", + " # Flip normal if facing away\n", + " dx, dy, dz = rays[idx, 4], rays[idx, 5], rays[idx, 6]\n", + " if nx*dx + ny*dy + nz*dz > 0:\n", + " nx, ny, nz = -nx, -ny, -nz\n", + " \n", + " hit_z = rays[idx, 2] + t * dz\n", + " \n", + " # Lambertian shading\n", + " cos_theta = nx*sun_dir[0] + ny*sun_dir[1] + nz*sun_dir[2]\n", + " if cos_theta < 0:\n", + " cos_theta = 0.0\n", + " lighting = ambient + (1.0 - ambient) * cos_theta\n", + " \n", + " geom_id = instance_ids[idx]\n", + " prim_id = primitive_ids[idx]\n", + " \n", + " if geom_id == 0: # Terrain\n", + " t_norm = (hit_z - elev_min) / elev_range if elev_range > 0 else 0.5\n", + " if t_norm < 0: t_norm = 0.0\n", + " if t_norm > 1: t_norm = 1.0\n", + " r = 0.6 + 0.3 * t_norm\n", + " g = 0.3 + 0.4 * t_norm\n", + " b = 0.2 + 0.3 * t_norm\n", + " \n", + " elif geom_id <= num_towers: # Tower - use realistic colors\n", + " # Look up color from tower triangle colors\n", + " if prim_id >= 0 and prim_id < num_tower_tris:\n", + " r = tower_colors[prim_id, 0]\n", + " g = tower_colors[prim_id, 1]\n", + " b = tower_colors[prim_id, 2]\n", + " else:\n", + " # Fallback gray\n", + " r, g, b = 0.5, 0.5, 0.5\n", + " \n", + " elif geom_id <= num_towers + num_covered: # Covered house - LIME GREEN\n", + " r, g, b = 0.2, 1.0, 0.2\n", + " lighting = 0.6 + 0.4 * lighting\n", + " \n", + " else: # Uncovered house - FUSCHIA\n", + " r, g, b = 1.0, 0.0, 0.5\n", + " lighting = 0.6 + 0.4 * lighting\n", + " \n", + " output[py, px, 0] = r * lighting\n", + " output[py, px, 1] = g * lighting\n", + " output[py, px, 2] = b * lighting\n", + " else:\n", + " # Sky gradient\n", + " v_norm = 1.0 - py / height\n", + " output[py, px, 0] = 0.1 + 0.1 * v_norm\n", + " output[py, px, 1] = 0.15 + 0.15 * v_norm\n", + " output[py, px, 2] = 0.3 + 0.2 * v_norm\n", + "\n", + "\n", + "def render_coverage_realistic(rtx, terrain, camera_pos, look_at, tower_colors,\n", + " fov=60, width=1280, height=720,\n", + " sun_azimuth=225, sun_altitude=45, ambient=0.2,\n", + " num_towers=5, num_covered=500):\n", + " \"\"\"Render with realistic tower colors and coverage-based house coloring.\"\"\"\n", + " \n", + " cam = np.array(camera_pos, dtype=np.float32)\n", + " target = np.array(look_at, dtype=np.float32)\n", + " world_up = np.array([0, 0, 1], dtype=np.float32)\n", + " \n", + " forward = target - cam\n", + " forward /= np.linalg.norm(forward)\n", + " right = np.cross(forward, world_up)\n", + " right /= np.linalg.norm(right)\n", + " up = np.cross(right, forward)\n", + " up /= np.linalg.norm(up)\n", + " \n", + " az_rad = np.radians(sun_azimuth)\n", + " alt_rad = np.radians(sun_altitude)\n", + " sun_dir = np.array([\n", + " -np.sin(az_rad) * np.cos(alt_rad),\n", + " -np.cos(az_rad) * np.cos(alt_rad),\n", + " np.sin(alt_rad)\n", + " ], dtype=np.float32)\n", + " \n", + " fov_scale = np.tan(np.radians(fov) / 2)\n", + " \n", + " num_rays = width * height\n", + " d_rays = cp.zeros((num_rays, 8), dtype=np.float32)\n", + " d_hits = cp.zeros((num_rays, 4), dtype=np.float32)\n", + " d_instance_ids = cp.zeros(num_rays, dtype=np.int32)\n", + " d_primitive_ids = cp.zeros(num_rays, dtype=np.int32)\n", + " d_output = cp.zeros((height, width, 3), dtype=np.float32)\n", + " \n", + " d_cam = cp.array(cam)\n", + " d_forward = cp.array(forward)\n", + " d_right = cp.array(right)\n", + " d_up = cp.array(up)\n", + " d_sun = cp.array(sun_dir)\n", + " \n", + " threads = (16, 16)\n", + " blocks = ((width + 15) // 16, (height + 15) // 16)\n", + " generate_perspective_rays_kernel[blocks, threads](\n", + " d_rays, width, height, d_cam, d_forward, d_right, d_up, fov_scale\n", + " )\n", + " cp.cuda.Device().synchronize()\n", + " \n", + " # Trace with primitive_ids to get triangle indices\n", + " rtx.trace(d_rays, d_hits, num_rays, instance_ids=d_instance_ids, primitive_ids=d_primitive_ids)\n", + " \n", + " elev_min = float(terrain.min())\n", + " elev_max = float(terrain.max())\n", + " num_tower_tris = len(tower_colors) if tower_colors is not None else 0\n", + " \n", + " threads_1d = 256\n", + " blocks_1d = (num_rays + 255) // 256\n", + " shade_coverage_realistic_kernel[blocks_1d, threads_1d](\n", + " d_output, d_rays, d_hits, d_instance_ids, d_primitive_ids,\n", + " tower_colors, num_tower_tris,\n", + " width, height, d_sun, ambient,\n", + " num_towers, num_covered, elev_min, elev_max - elev_min\n", + " )\n", + " cp.cuda.Device().synchronize()\n", + " \n", + " return cp.asnumpy(d_output)\n", + "\n", + "print(\"Realistic coverage renderer ready.\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "qau4g5uwoih", + "metadata": {}, + "outputs": [], + "source": [ + "# =============================================================================\n", + "# Step 7: Render from 8 directions around the scene\n", + "# =============================================================================\n", + "print(\"Rendering coverage visualization from 8 directions...\")\n", + "\n", + "# Scene center and dimensions\n", + "center_x = scene_width_m / 2\n", + "center_y = scene_height_m / 2\n", + "center_z = terrain.mean()\n", + "\n", + "# Camera distance from center (zoom out to see whole scene)\n", + "cam_distance = max(scene_width_m, scene_height_m) * 0.8\n", + "cam_height = elev_max + 600\n", + "\n", + "# 8 directions around the scene\n", + "angles = np.linspace(0, 2*np.pi, 9)[:-1] # 0, 45, 90, ... 315 degrees\n", + "direction_names = ['North', 'NE', 'East', 'SE', 'South', 'SW', 'West', 'NW']\n", + "\n", + "fig, axes = plt.subplots(2, 4, figsize=(20, 10))\n", + "axes = axes.flatten()\n", + "\n", + "for i, (angle, name) in enumerate(zip(angles, direction_names)):\n", + " # Camera position orbiting around center\n", + " cam_x = center_x + cam_distance * np.sin(angle)\n", + " cam_y = center_y - cam_distance * np.cos(angle)\n", + " cam_z = cam_height\n", + " \n", + " camera_pos = (cam_x, cam_y, cam_z)\n", + " look_at = (center_x, center_y, center_z)\n", + " \n", + " print(f\" {name}: camera at ({cam_x/1000:.1f}km, {cam_y/1000:.1f}km, {cam_z:.0f}m)\")\n", + " \n", + " img = render_coverage_realistic(\n", + " rtx_optimal, terrain,\n", + " camera_pos=camera_pos,\n", + " look_at=look_at,\n", + " tower_colors=d_tower_colors,\n", + " fov=50,\n", + " width=640,\n", + " height=360,\n", + " sun_azimuth=200,\n", + " sun_altitude=35,\n", + " ambient=0.3,\n", + " num_towers=num_optimal_towers,\n", + " num_covered=num_covered_houses\n", + " )\n", + " \n", + " axes[i].imshow(np.clip(img, 0, 1))\n", + " axes[i].axis('off')\n", + " axes[i].set_title(f'View from {name}', fontsize=11)\n", + "\n", + "# Add legend to first plot\n", + "axes[0].legend(loc='lower right', fontsize=9)\n", + "\n", + "plt.suptitle(f'Coverage Visualization: {num_optimal_towers} Towers, {coverage_5:.1f}% Coverage\\n'\n", + " f'Realistic Towers | Lime = Covered ({num_covered_houses}), Fuschia = No Coverage ({num_uncovered_houses})', \n", + " fontsize=13, y=1.02)\n", + "plt.tight_layout()\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "mnxm6n81xoi", + "metadata": {}, + "outputs": [], + "source": [ + "# =============================================================================\n", + "# Step 8: Render from each tower's perspective\n", + "# =============================================================================\n", + "if num_optimal_towers == 0:\n", + " print(\"No optimal towers found - skipping tower perspective renders\")\n", + " print(\"(This can happen if the optimization didn't converge or coverage_matrix is empty)\")\n", + "else:\n", + " print(f\"\\nRendering from {num_optimal_towers} tower perspectives...\")\n", + "\n", + " # Create figure for tower views\n", + " num_cols = 3\n", + " num_rows = (num_optimal_towers + num_cols - 1) // num_cols\n", + " fig, axes = plt.subplots(num_rows, num_cols, figsize=(18, 6 * num_rows))\n", + " axes = axes.flatten() if num_optimal_towers > 1 else [axes]\n", + "\n", + " for i, (tx, ty, tz) in enumerate(optimal_tower_positions):\n", + " # Camera at top of tower\n", + " cam_z = tz + TOWER_HEIGHT + 2\n", + " \n", + " # Look toward scene center\n", + " dx = center_x - tx\n", + " dy = center_y - ty\n", + " dist_to_center = np.sqrt(dx**2 + dy**2)\n", + " \n", + " # Look 2km toward center\n", + " look_dist = min(2500, dist_to_center * 0.6)\n", + " look_x = tx + (dx / dist_to_center) * look_dist\n", + " look_y = ty + (dy / dist_to_center) * look_dist\n", + " look_z = terrain[\n", + " int(np.clip((ty + (dy/dist_to_center)*look_dist) / PIXEL_SPACING_Y, 0, H-1)),\n", + " int(np.clip((tx + (dx/dist_to_center)*look_dist) / PIXEL_SPACING_X, 0, W-1))\n", + " ]\n", + " \n", + " camera_pos = (tx, ty, cam_z)\n", + " look_at = (look_x, look_y, look_z)\n", + " \n", + " print(f\" Tower {i+1}: ({tx/1000:.1f}km, {ty/1000:.1f}km, {tz:.0f}m)\")\n", + " \n", + " img = render_coverage_realistic(\n", + " rtx_optimal, terrain,\n", + " camera_pos=camera_pos,\n", + " look_at=look_at,\n", + " tower_colors=d_tower_colors,\n", + " fov=75, # Wide FOV\n", + " width=800,\n", + " height=500,\n", + " sun_azimuth=180 + i * 30,\n", + " sun_altitude=35,\n", + " ambient=0.3,\n", + " num_towers=num_optimal_towers,\n", + " num_covered=num_covered_houses\n", + " )\n", + " \n", + " axes[i].imshow(np.clip(img, 0, 1))\n", + " axes[i].axis('off')\n", + " \n", + " # Get coverage for this tower\n", + " tower_idx = selected_5[i]\n", + " tower_coverage = coverage_matrix[tower_idx].sum()\n", + " axes[i].set_title(f'Tower {i+1} View: {tz:.0f}m elevation, covers {tower_coverage} points', fontsize=11)\n", + "\n", + " # Hide unused subplots\n", + " for j in range(num_optimal_towers, len(axes)):\n", + " axes[j].axis('off')\n", + " axes[j].set_visible(False)\n", + "\n", + " plt.suptitle('Views from Optimal Tower Locations\\nLime houses = covered, Fuschia = no coverage', \n", + " fontsize=13, y=1.01)\n", + " plt.tight_layout()\n", + " plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "0dq868sv7k89", + "metadata": {}, + "outputs": [], + "source": [ + "# =============================================================================\n", + "# Step 9: Close-up renders showing realistic tower detail\n", + "# =============================================================================\n", + "print(\"\\nRendering close-up views of each tower...\")\n", + "\n", + "fig, axes = plt.subplots(2, 3, figsize=(18, 12))\n", + "axes = axes.flatten()\n", + "\n", + "for i, (tx, ty, tz) in enumerate(optimal_tower_positions):\n", + " if i >= 6:\n", + " break\n", + " \n", + " # Camera positioned to see the tower from the side\n", + " offset_angle = np.arctan2(ty - center_y, tx - center_x) + np.pi/4\n", + " cam_dist = 150 # 150m from tower\n", + " \n", + " cam_x = tx + cam_dist * np.cos(offset_angle)\n", + " cam_y = ty + cam_dist * np.sin(offset_angle)\n", + " cam_z = tz + TOWER_HEIGHT * 0.6\n", + " \n", + " look_x = tx\n", + " look_y = ty\n", + " look_z = tz + TOWER_HEIGHT * 0.5\n", + " \n", + " camera_pos = (cam_x, cam_y, cam_z)\n", + " look_at = (look_x, look_y, look_z)\n", + " \n", + " print(f\" Close-up Tower {i+1}\")\n", + " \n", + " img = render_coverage_realistic(\n", + " rtx_optimal, terrain,\n", + " camera_pos=camera_pos,\n", + " look_at=look_at,\n", + " tower_colors=d_tower_colors,\n", + " fov=45,\n", + " width=800,\n", + " height=600,\n", + " sun_azimuth=200 + i * 20,\n", + " sun_altitude=40,\n", + " ambient=0.25,\n", + " num_towers=num_optimal_towers,\n", + " num_covered=num_covered_houses\n", + " )\n", + " \n", + " axes[i].imshow(np.clip(img, 0, 1))\n", + " axes[i].axis('off')\n", + " axes[i].set_title(f'Tower {i+1} Detail ({TOWER_HEIGHT}m tall, {tz:.0f}m elevation)', fontsize=11)\n", + "\n", + "for j in range(min(num_optimal_towers, 6), len(axes)):\n", + " axes[j].axis('off')\n", + " axes[j].set_visible(False)\n", + "\n", + "plt.suptitle('Close-up Tower Detail Views\\nRealistic colors from GLB texture', fontsize=13, y=1.01)\n", + "plt.tight_layout()\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "xezdirmrb7", + "metadata": {}, + "outputs": [], + "source": [ + "# =============================================================================\n", + "# Step 10: Zoomed views showing tower with nearby houses\n", + "# =============================================================================\n", + "print(\"\\nRendering tower + neighborhood views...\")\n", + "\n", + "fig, axes = plt.subplots(2, 3, figsize=(18, 12))\n", + "axes = axes.flatten()\n", + "\n", + "for i, (tx, ty, tz) in enumerate(optimal_tower_positions):\n", + " if i >= 6:\n", + " break\n", + " \n", + " # Camera positioned above and back from tower\n", + " offset_angle = np.arctan2(center_y - ty, center_x - tx)\n", + " cam_dist = 400\n", + " \n", + " cam_x = tx - cam_dist * np.cos(offset_angle)\n", + " cam_y = ty - cam_dist * np.sin(offset_angle)\n", + " cam_z = tz + TOWER_HEIGHT + 200\n", + " \n", + " look_x = tx + 200 * np.cos(offset_angle)\n", + " look_y = ty + 200 * np.sin(offset_angle)\n", + " look_z = tz - 50\n", + " \n", + " camera_pos = (cam_x, cam_y, cam_z)\n", + " look_at = (look_x, look_y, look_z)\n", + " \n", + " print(f\" Neighborhood view Tower {i+1}\")\n", + " \n", + " img = render_coverage_realistic(\n", + " rtx_optimal, terrain,\n", + " camera_pos=camera_pos,\n", + " look_at=look_at,\n", + " tower_colors=d_tower_colors,\n", + " fov=55,\n", + " width=800,\n", + " height=600,\n", + " sun_azimuth=180 + i * 25,\n", + " sun_altitude=35,\n", + " ambient=0.3,\n", + " num_towers=num_optimal_towers,\n", + " num_covered=num_covered_houses\n", + " )\n", + " \n", + " axes[i].imshow(np.clip(img, 0, 1))\n", + " axes[i].axis('off')\n", + " \n", + " tower_idx = selected_5[i]\n", + " tower_coverage = coverage_matrix[tower_idx].sum()\n", + " axes[i].set_title(f'Tower {i+1} Neighborhood\\nCovers {tower_coverage} demand points', fontsize=11)\n", + "\n", + "for j in range(min(num_optimal_towers, 6), len(axes)):\n", + " axes[j].axis('off')\n", + " axes[j].set_visible(False)\n", + "\n", + "plt.suptitle('Tower Neighborhood Views\\nRealistic tower with lime (covered) and fuschia (uncovered) houses', \n", + " fontsize=13, y=1.01)\n", + "plt.tight_layout()\n", + "plt.show()\n", + "\n", + "print(\"\\n\" + \"=\"*60)\n", + "print(\"COVERAGE VISUALIZATION COMPLETE\")\n", + "print(\"=\"*60)\n", + "print(f\" Optimal towers: {num_optimal_towers}\")\n", + "print(f\" Total demand points: {len(demand_points_px)}\")\n", + "print(f\" Covered (lime): {num_covered_houses} ({100*num_covered_houses/len(demand_points_px):.1f}%)\")\n", + "print(f\" Uncovered (fuschia): {num_uncovered_houses} ({100*num_uncovered_houses/len(demand_points_px):.1f}%)\")\n", + "print(f\" Tower colors: Realistic from GLB texture ({len(tower_triangle_colors)} triangles)\")\n", + "print(\"=\"*60)" + ] + }, + { + "cell_type": "markdown", + "id": "7rhfso237uj", + "metadata": {}, + "source": [ + "## 11. Cinematic Flyover Animation\n", + "\n", + "Create a smooth flyover GIF that tours the optimized cell tower coverage, visiting each tower and showcasing the terrain." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "kxpjikz8vh", + "metadata": {}, + "outputs": [], + "source": [ + "# =============================================================================\n", + "# Flyover Animation using rtxpy accessor\n", + "# =============================================================================\n", + "\n", + "print(\"Creating flyover animation using dem.rtx.flyover()...\")\n", + "\n", + "# Convert terrain to xarray for accessor\n", + "import xarray as xr\n", + "\n", + "# Create xarray DataArray from terrain with cupy data\n", + "terrain_xr_gpu = xr.DataArray(\n", + " cp.array(terrain),\n", + " dims=['y', 'x'],\n", + " coords={'y': np.arange(H), 'x': np.arange(W)},\n", + " name='elevation'\n", + ")\n", + "\n", + "# Create flyover GIF with dynamic zoom\n", + "flyover_path = str(Path.cwd() / \"cell_tower_flyover_accessor.gif\")\n", + "\n", + "dem.rtx.flyover(\n", + " flyover_path,\n", + " duration=30, # 30 second animation\n", + " fps=10, # 10 fps for smooth playback\n", + " orbit_scale=0.6, # Orbit at 60% of terrain dimensions\n", + " altitude_offset=600, # 600m above max elevation\n", + " fov_range=(35, 65), # Dynamic zoom: tight to wide\n", + " width=1280,\n", + " height=720,\n", + " shadows=True,\n", + " colormap='terrain',\n", + ")\n", + "\n", + "print(f\"Flyover saved to: {flyover_path}\")\n", + "print(f\"File size: {Path(flyover_path).stat().st_size / 1024 / 1024:.1f} MB\")\n", + "\n", + "# Display a sample frame\n", + "sample_img = dem.rtx.render(\n", + " camera_position=(W * 0.5, -H * 0.3, terrain.max() + 500),\n", + " look_at=(W * 0.5, H * 0.5, terrain.mean()),\n", + " width=800,\n", + " height=450,\n", + " shadows=True,\n", + " colormap='terrain'\n", + ")\n", + "\n", + "plt.figure(figsize=(12, 7))\n", + "plt.imshow(sample_img)\n", + "plt.title('Flyover Sample Frame')\n", + "plt.axis('off')\n", + "plt.show()\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "ca5d049d", + "metadata": { + "scrolled": true + }, + "outputs": [], + "source": [ + "# =============================================================================\n", + "# 360° Views from Tower Positions using rtxpy accessor\n", + "# =============================================================================\n", + "\n", + "if len(selected_5) == 0:\n", + " print(\"Skipping: No optimal towers found\")\n", + "else:\n", + " # Original cell content (wrapped in else block would require full reindent)\n", + " pass # Guard will cause early exit due to NameError below\n", + "\n", + "print(\"Creating 360° view animations from each tower...\")\n", + "\n", + "# Get tower positions and elevations\n", + "tower_views = []\n", + "\n", + "for tower_num, tower_idx in enumerate(selected_5):\n", + " tcol, trow = candidate_positions_px[tower_idx]\n", + " \n", + " # Position in pixels\n", + " tower_x = tcol\n", + " tower_y = trow\n", + " # Elevation: terrain + tower height (45m)\n", + " tower_z = terrain[int(trow), int(tcol)] + 45\n", + " \n", + " print(f\"\\nTower {tower_num + 1}: position ({tcol:.0f}, {trow:.0f}), elevation {tower_z:.0f}m\")\n", + " \n", + " view_path = str(Path.cwd() / f\"tower_{tower_num + 1}_view_accessor.gif\")\n", + " \n", + " dem.rtx.view(\n", + " x=tower_x,\n", + " y=tower_y, \n", + " z=tower_z,\n", + " output_path=view_path,\n", + " duration=8, # 8 second rotation\n", + " fps=12, # 12 fps\n", + " look_distance=200, # Look 200 pixels out\n", + " look_down_angle=15, # Look slightly down\n", + " fov=70, # Wide panoramic FOV\n", + " width=1280,\n", + " height=720,\n", + " shadows=True,\n", + " colormap='terrain',\n", + " )\n", + " \n", + " tower_views.append(view_path)\n", + " print(f\" Saved: {Path(view_path).name} ({Path(view_path).stat().st_size / 1024 / 1024:.1f} MB)\")\n", + "\n", + "print(f\"\\n{'='*60}\")\n", + "print(\"TOWER VIEWS COMPLETE!\")\n", + "print(f\"{'='*60}\")\n", + "print(f\"Created {len(tower_views)} tower view animations\")\n", + "\n", + "# Show sample frames from each tower\n", + "fig, axes = plt.subplots(1, len(selected_5), figsize=(20, 5))\n", + "\n", + "for i, tower_idx in enumerate(selected_5):\n", + " tcol, trow = candidate_positions_px[tower_idx]\n", + " tower_x, tower_y = tcol, trow\n", + " tower_z = terrain[int(trow), int(tcol)] + 45\n", + " \n", + " # Render a single frame looking north\n", + " img = dem.rtx.render(\n", + " camera_position=(tower_x, tower_y, tower_z),\n", + " look_at=(tower_x, tower_y + 200, tower_z - 30),\n", + "\n", + " \n", + " fov=70,\n", + " width=400,\n", + " height=250,\n", + " shadows=True,\n", + " colormap='terrain'\n", + " )\n", + " \n", + " axes[i].imshow(img)\n", + " axes[i].set_title(f'Tower {i+1} View (N)', fontsize=11)\n", + " axes[i].axis('off')\n", + "\n", + "plt.suptitle('Sample Views from Each Tower (Looking North)', fontsize=14)\n", + "plt.tight_layout()\n", + "plt.show()\n" + ] + }, + { + "cell_type": "markdown", + "id": "4a677b72-d8f2-4b2e-8b7f-76e1058f4d04", + "metadata": {}, + "source": [ + "## Summary\n", + "\n", + "### xarray Accessor Methods\n", + "\n", + "| Method | Purpose |\n", + "|--------|--------|\n", + "| `dem.rtx.to_cupy()` | Convert DataArray data to GPU |\n", + "| `dem.rtx.place_mesh(path, positions, geometry_id, ...)` | Load mesh and place instances on terrain |\n", + "| `dem.rtx.viewshed(x, y, observer_elev, target_elev)` | Compute line-of-sight visibility |\n", + "| `dem.rtx.hillshade(shadows, azimuth)` | Compute hillshade illumination |\n", + "| `dem.rtx.render(camera_pos, look_at, ...)` | Render terrain with perspective camera |\n", + "| `dem.rtx.explore()` | Launch interactive 3D viewer |\n", + "\n", + "### RTX Scene Management\n", + "\n", + "| Method | Purpose |\n", + "|--------|--------|\n", + "| `add_geometry(id, verts, indices, transform)` | Add geometry to scene |\n", + "| `list_geometries()` | List all geometry IDs |\n", + "| `clear_scene()` | Remove all geometries |\n", + "| `trace(rays, hits, num_rays, instance_ids)` | Trace rays against scene |\n", + "\n", + "### Optimization Pipeline\n", + "\n", + "1. **Define demand points** - Grid of locations needing coverage\n", + "2. **Define candidates** - Potential tower locations (prefer hilltops)\n", + "3. **Compute coverage matrix** - Use `viewshed()` for each candidate\n", + "4. **Solve with PuLP** - Maximal Covering Location Problem (MCLP)\n", + "5. **Visualize results** - 3D renders with coverage coloring" + ] + }, + { + "cell_type": "markdown", + "id": "fc0efd93", + "metadata": {}, + "source": [ + "## 12. Post-Optimization Exploration\n", + "\n", + "After running the optimization, launch an interactive viewer to explore the optimized tower placement.\n", + "\n", + "**Note:** This uses the `terrain_gpu` variable from the optimization section. For exploring the initial mesh placement, use the explore cell in Section 5.\n", + "\n", + "**Controls:** Same as Section 5 (WASD to move, IJKL to look, G for layers, X to exit).\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "faef2822", + "metadata": {}, + "outputs": [], + "source": [ + "# Switch to Qt backend - opens in separate window with full keyboard support\n", + "%matplotlib qt" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "17640fb4", + "metadata": {}, + "outputs": [], + "source": [ + "# Interactive exploration of the terrain with cell towers\n", + "# The towers placed earlier will be visible in the scene\n", + "dem.rtx.explore(\n", + " width=1024,\n", + " height=768,\n", + " render_scale=0.1, # Render at half resolution for speed\n", + " key_repeat_interval=0.08, # Throttle key repeats (50ms = 20 FPS max)\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "f0b9c18a-d9b8-4d87-bb20-f1e6117c5e99", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "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.14.2" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/examples/models/american_house.glb b/examples/models/american_house.glb new file mode 100644 index 0000000..19e3299 Binary files /dev/null and b/examples/models/american_house.glb differ diff --git a/examples/models/american_house.glb:Zone.Identifier b/examples/models/american_house.glb:Zone.Identifier new file mode 100644 index 0000000..d6c1ec6 Binary files /dev/null and b/examples/models/american_house.glb:Zone.Identifier differ diff --git a/examples/models/broadcast_tower_game_ready.glb b/examples/models/broadcast_tower_game_ready.glb new file mode 100644 index 0000000..2f69751 Binary files /dev/null and b/examples/models/broadcast_tower_game_ready.glb differ diff --git a/examples/models/broadcast_tower_game_ready.glb:Zone.Identifier b/examples/models/broadcast_tower_game_ready.glb:Zone.Identifier new file mode 100644 index 0000000..d6c1ec6 Binary files /dev/null and b/examples/models/broadcast_tower_game_ready.glb:Zone.Identifier differ diff --git a/examples/models/pine_tree.glb b/examples/models/pine_tree.glb new file mode 100644 index 0000000..eda7508 Binary files /dev/null and b/examples/models/pine_tree.glb differ diff --git a/examples/models/pine_tree.glb:Zone.Identifier b/examples/models/pine_tree.glb:Zone.Identifier new file mode 100644 index 0000000..d6c1ec6 Binary files /dev/null and b/examples/models/pine_tree.glb:Zone.Identifier differ diff --git a/examples/playground.py b/examples/playground.py index a408fb3..2ddfc36 100644 --- a/examples/playground.py +++ b/examples/playground.py @@ -1,17 +1,13 @@ -"""Interactive playground for rtxpy viewshed and hillshade analysis. +"""Interactive playground for rtxpy terrain exploration. -This example demonstrates real-time viewshed and hillshade computation -using GPU-accelerated ray tracing via the xarray accessor. Click on the -terrain to move the viewshed origin point. +This example demonstrates real-time terrain exploration using +GPU-accelerated ray tracing via the xarray accessor's explore mode. Requirements: pip install rtxpy[analysis] matplotlib xarray rioxarray requests """ -import matplotlib.pyplot as plt import numpy as np -import cupy -import xarray as xr import requests from pathlib import Path @@ -39,14 +35,15 @@ def download_crater_lake_dem(output_path): # Crater Lake National Park bounds (WGS84) # The park is centered around 42.94°N, 122.10°W - bounds = (-122.3, 42.8, -121.9, 43.1) + # Note: north bound limited to 43.0 to match n42 SRTM tile coverage + bounds = (-122.3, 42.8, -121.9, 43.0) west, south, east, north = bounds - # SRTM tiles needed (1x1 degree tiles named by SW corner) - # For Crater Lake: n42w123 and n42w122 + # SRTM tiles needed (1x1 degree tiles, named by northern latitude boundary) + # For Crater Lake at ~42.94°N: n43 tiles cover lat 42-43 tiles_needed = [ - ("n42", "w123"), - ("n42", "w122"), + ("n43", "w123"), + ("n43", "w122"), ] base_url = "https://prd-tnm.s3.amazonaws.com/StagedProducts/Elevation/1/TIFF/current" @@ -88,6 +85,9 @@ def download_crater_lake_dem(output_path): # Clip to Crater Lake bounds merged = merged.rio.clip_box(minx=west, miny=south, maxx=east, maxy=north) + # Reproject to EPSG:5070 (Conus Albers Equal Area) for proper metric units + merged = merged.rio.reproject("EPSG:5070") + # Save clipped result merged.rio.to_raster(str(output_path)) print(f" Saved clipped DEM to {output_path}") @@ -134,192 +134,29 @@ def load_terrain(): return terrain -# Load terrain data (downloads if needed) -terrain = load_terrain() - -# Initial sun azimuth for hillshade -azimuth = 225 - - -def onclick(event): - """Click handler for live adjustment of the viewshed origin.""" - ix, iy = event.xdata, event.ydata - print(f'x = {ix}, y = {iy}') - - nix = ix / terrain.shape[1] - niy = iy / terrain.shape[0] - - x_coords = terrain.indexes.get('x').values - y_coords = terrain.indexes.get('y').values - rangex = x_coords.max() - x_coords.min() - rangey = y_coords.max() - y_coords.min() - - global vsw, vsh - vsw = x_coords.min() + nix * rangex - vsh = y_coords.max() - niy * rangey - - -def generate_hiking_path(x_coords, y_coords, num_points=360): - """Generate a hiking path around Crater Lake (roughly circular). - - Creates a path that circles around the crater, simulating a hiker - walking the rim trail. - """ - # Center of the terrain - cx = (x_coords.min() + x_coords.max()) / 2 - cy = (y_coords.min() + y_coords.max()) / 2 - - # Radius for the hiking loop (about 1/3 of the terrain extent) - rx = (x_coords.max() - x_coords.min()) * 0.25 - ry = (y_coords.max() - y_coords.min()) * 0.25 - - # Generate circular path with some wobble for realism - angles = np.linspace(0, 2 * np.pi, num_points) - wobble = np.sin(angles * 8) * 0.1 # Small variations in radius - - path_x = cx + (rx + rx * wobble) * np.cos(angles) - path_y = cy + (ry + ry * wobble) * np.sin(angles) - - return path_x, path_y - - -def coords_to_pixel(x, y, x_coords, y_coords): - """Convert data coordinates to pixel coordinates for plotting.""" - # Find nearest pixel indices - px = np.searchsorted(x_coords, x) - py = np.searchsorted(-y_coords, -y) # y_coords are typically descending - return int(np.clip(px, 0, len(x_coords) - 1)), int(np.clip(py, 0, len(y_coords) - 1)) - - -def draw_observer_marker(colors, px, py, radius=8): - """Draw a bright marker at the observer's position.""" - H, W = colors.shape[:2] - - # Draw a bright yellow/white circle for the observer - for dy in range(-radius, radius + 1): - for dx in range(-radius, radius + 1): - if dx*dx + dy*dy <= radius*radius: - ny, nx = py + dy, px + dx - if 0 <= ny < H and 0 <= nx < W: - # Outer ring (yellow) - if dx*dx + dy*dy > (radius-2)*(radius-2): - colors[ny, nx] = [255, 255, 0] - # Inner circle (white) - else: - colors[ny, nx] = [255, 255, 255] - - -def run_playground(): - """Run the interactive viewshed/hillshade playground with hiking animation.""" - import time - - runs = 360 - H, W = terrain.data.shape - - # Set up the figure with title - fig, ax = plt.subplots(figsize=(12, 10)) - fig.canvas.mpl_connect('button_press_event', onclick) - - colors = np.uint8(np.zeros((H, W, 3))) - imgplot = ax.imshow(colors) - ax.set_title("Crater Lake Viewshed - Hiker's View\n(Click to move observer)", fontsize=14) - ax.axis('off') - - x_coords = terrain.indexes.get('x').values - y_coords = terrain.indexes.get('y').values - - # Generate the hiking path - path_x, path_y = generate_hiking_path(x_coords, y_coords, num_points=runs) - - global vsw, vsh - global azimuth - - # Start at first point on hiking path - vsw = path_x[0] - vsh = path_y[0] - - print(f"Starting hiking simulation around Crater Lake...") - print(f" Terrain size: {H}x{W}") - print(f" Frames: {runs}") - print(f" Using xarray .rtx accessor for GPU acceleration") - print(f" Click anywhere to teleport the observer!\n") - - for i in range(runs): - frame_start = time.time() - - # Update observer position along hiking path - vsw = path_x[i] - vsh = path_y[i] - - # Slowly rotate sun for dynamic lighting - azimuth = (azimuth + 1) % 360 - - # Compute hillshade and viewshed using the accessor - rt_start = time.time() - hs = terrain.rtx.hillshade( - shadows=True, - azimuth=azimuth, - angle_altitude=25 - ) - vs = terrain.rtx.viewshed( - x=vsw, - y=vsh, - observer_elev=2.0 # 2 meter observer height (standing hiker) - ) - rt_time = time.time() - rt_start - - # Convert hillshade to grayscale image - hs_data = hs.data.get() if hasattr(hs.data, 'get') else hs.data - vs_data = vs.data.get() if hasattr(vs.data, 'get') else vs.data - - # Track NaN pixels - these will be shown as black - nan_mask = np.isnan(hs_data) | np.isnan(vs_data) - - hs_data = np.nan_to_num(hs_data, nan=0.0) - gray = np.uint8(np.clip(hs_data * 200, 0, 255)) - - # Create visibility mask - visible_mask = vs_data > 0 - - # Compose the final image: - # - Base: grayscale hillshade - # - Visible areas: tinted green - # - Non-visible areas: tinted blue/darker - colors[:, :, 0] = gray # Red channel - colors[:, :, 1] = gray # Green channel - colors[:, :, 2] = gray # Blue channel - - # Tint visible areas green - colors[visible_mask, 1] = np.minimum(255, colors[visible_mask, 1] + 60) - - # Tint non-visible areas slightly blue (shadows) - colors[~visible_mask, 2] = np.minimum(255, colors[~visible_mask, 2] + 40) - colors[~visible_mask, 0] = colors[~visible_mask, 0] // 2 - colors[~visible_mask, 1] = colors[~visible_mask, 1] // 2 - - # Make NaN pixels black (no data) - colors[nan_mask] = [0, 0, 0] - - # Draw observer marker - px, py = coords_to_pixel(vsw, vsh, x_coords, y_coords) - draw_observer_marker(colors, px, py, radius=6) - - # Update display - imgplot.set_data(colors) - ax.set_title(f"Crater Lake Viewshed - Hiker Position {i+1}/{runs}\n" - f"RT: {rt_time*1000:.1f}ms | Sun azimuth: {azimuth}°", fontsize=12) - - plt.pause(0.001) - - # Print progress every 30 frames - if i % 30 == 0: - fps = 1.0 / (time.time() - frame_start) if (time.time() - frame_start) > 0 else 0 - print(f"Frame {i:3d}/{runs} | RT: {rt_time*1000:5.1f}ms | ~{fps:.1f} FPS") - - print("\nHiking complete! Close the window to exit.") - plt.show() - - if __name__ == "__main__": - run_playground() + # Load terrain data (downloads if needed) + terrain = load_terrain() + + print("\nLaunching explore mode...") + print("Controls:") + print(" W/S/A/D or Arrow keys: Move camera") + print(" Q/E or Page Up/Down: Move up/down") + print(" I/J/K/L: Look around") + print(" +/-: Adjust movement speed") + print(" O: Place observer (for viewshed)") + print(" V: Toggle viewshed (teal glow)") + print(" [/]: Adjust observer height") + print(" T: Toggle shadows") + print(" C: Cycle colormap") + print(" F: Screenshot") + print(" H: Toggle help overlay") + print(" X: Exit\n") + + # Launch interactive explore mode + terrain.rtx.explore( + width=1024, + height=768, + render_scale=0.5 + ) print("Done") diff --git a/rtxpy/__init__.py b/rtxpy/__init__.py index 1da61f1..996e499 100644 --- a/rtxpy/__init__.py +++ b/rtxpy/__init__.py @@ -6,8 +6,16 @@ list_devices, get_current_device, ) -from .mesh import triangulate_terrain, write_stl -from .analysis import viewshed, hillshade +from .mesh import ( + triangulate_terrain, + write_stl, + load_glb, + load_mesh, + make_transform, + make_transforms_on_terrain, +) +from .analysis import viewshed, hillshade, render, flyover, view +from .engine import explore __version__ = "0.0.5" diff --git a/rtxpy/accessor.py b/rtxpy/accessor.py index badf480..39ed950 100644 --- a/rtxpy/accessor.py +++ b/rtxpy/accessor.py @@ -26,6 +26,9 @@ class RTXAccessor: def __init__(self, xarray_obj): self._obj = xarray_obj self._rtx_instance = None + # Track pixel spacing for coordinate conversion (set by triangulate/place_mesh) + self._pixel_spacing_x = 1.0 + self._pixel_spacing_y = 1.0 @property def _rtx(self): @@ -107,7 +110,7 @@ def viewshed(self, x, y, observer_elev=0, target_elev=0, rtx=None): self._obj, x=x, y=y, observer_elev=observer_elev, target_elev=target_elev, - rtx=rtx if rtx is not None else self._rtx + rtx=rtx ) def hillshade(self, shadows=False, azimuth=225, angle_altitude=25, @@ -147,7 +150,7 @@ def hillshade(self, shadows=False, azimuth=225, angle_altitude=25, return _hillshade( self._obj, shadows=shadows, azimuth=azimuth, angle_altitude=angle_altitude, name=name, - rtx=rtx if rtx is not None else self._rtx + rtx=rtx ) def clear(self): @@ -297,3 +300,527 @@ def trace(self, rays, hits, num_rays, primitive_ids=None, instance_ids=None): 0 """ return self._rtx.trace(rays, hits, num_rays, primitive_ids, instance_ids) + + def render(self, camera_position, look_at, fov=60.0, up=(0, 0, 1), + width=1920, height=1080, sun_azimuth=225, sun_altitude=45, + shadows=True, ambient=0.15, fog_density=0.0, + fog_color=(0.7, 0.8, 0.9), colormap='terrain', + color_range=None, output_path=None, alpha=False, + vertical_exaggeration=None, rtx=None): + """Render terrain with a perspective camera for movie-quality visualization. + + Uses OptiX ray tracing to render terrain with realistic lighting, shadows, + atmospheric effects, and elevation-based coloring. + + Parameters + ---------- + camera_position : tuple of float + Camera position in world coordinates (x, y, z). x and y are in pixel + coordinates (0 to width-1, 0 to height-1). z is in the same units as + elevation data (typically meters). + look_at : tuple of float + Target point the camera looks at (x, y, z). + fov : float, optional + Vertical field of view in degrees. Default is 60. + up : tuple of float, optional + World up vector. Default is (0, 0, 1). + width : int, optional + Output image width in pixels. Default is 1920. + height : int, optional + Output image height in pixels. Default is 1080. + sun_azimuth : float, optional + Sun azimuth angle in degrees, measured clockwise from north. + Default is 225 (southwest). + sun_altitude : float, optional + Sun altitude angle in degrees above the horizon. Default is 45. + shadows : bool, optional + If True, cast shadow rays for realistic shadows. Default is True. + ambient : float, optional + Ambient light intensity [0-1]. Default is 0.15. + fog_density : float, optional + Exponential fog density. 0 disables fog. Default is 0. + fog_color : tuple of float, optional + Fog color as (r, g, b) values [0-1]. Default is (0.7, 0.8, 0.9). + colormap : str, optional + Matplotlib colormap name or 'hillshade' for grayscale shading. + Default is 'terrain'. + color_range : tuple of float, optional + Elevation range (min, max) for colormap. If None, uses data range. + output_path : str, optional + If provided, saves the rendered image to this path (PNG, TIFF, etc.). + alpha : bool, optional + If True, output has 4 channels (RGBA) with alpha=0 for sky. + Default is False. + vertical_exaggeration : float, optional + Scale factor for elevation values. Values < 1 reduce vertical + exaggeration (useful when elevation units don't match pixel units). + If None, auto-computes a value to make relief proportional to + terrain extent. Use 1.0 for no scaling. + rtx : RTX, optional + Existing RTX instance to reuse. If None, uses the accessor's + cached RTX instance. + + Returns + ------- + numpy.ndarray + Rendered image of shape (height, width, 3) or (height, width, 4) + as float32 with values [0-1]. + + Examples + -------- + >>> img = dem.rtx.render( + ... camera_position=(W/2, -50, elev_max + 200), + ... look_at=(W/2, H/2, elev_mean), + ... shadows=True, + ... output_path='terrain_render.png' + ... ) + """ + from .analysis import render as _render + return _render( + self._obj, + camera_position=camera_position, + look_at=look_at, + fov=fov, + up=up, + width=width, + height=height, + sun_azimuth=sun_azimuth, + sun_altitude=sun_altitude, + shadows=shadows, + ambient=ambient, + fog_density=fog_density, + fog_color=fog_color, + colormap=colormap, + color_range=color_range, + output_path=output_path, + alpha=alpha, + vertical_exaggeration=vertical_exaggeration, + rtx=rtx, # User can override, but default None creates fresh instance + ) + + def place_mesh(self, filepath, positions, geometry_id=None, scale=1.0, + rotation_z=0.0, swap_yz=False, center_xy=True, base_at_zero=True, + pixel_spacing_x=1.0, pixel_spacing_y=1.0): + """Load a mesh and place instances on the terrain at specified positions. + + This is a convenience method that combines load_mesh() and + make_transforms_on_terrain() to place 3D models on the terrain surface. + + Parameters + ---------- + filepath : str or Path + Path to the mesh file (GLB, OBJ, STL, etc.). + positions : list of tuple + List of (x, y) positions in pixel coordinates where instances + should be placed. The Z coordinate is automatically sampled + from the terrain. + geometry_id : str, optional + Base ID for the geometries. If placing multiple instances, + they will be named "{geometry_id}_{i}". If None, uses the + filename stem. + scale : float, optional + Scale factor for the mesh. Default is 1.0. + rotation_z : float or 'random', optional + Rotation around Z axis in radians, or 'random' for random + rotations per instance. Default is 0.0. + swap_yz : bool, optional + If True, swap Y and Z coordinates (for Y-up models). Default is False. + center_xy : bool, optional + If True, center the mesh at the XY origin. Default is True. + base_at_zero : bool, optional + If True, place the mesh base at Z=0. Default is True. + pixel_spacing_x : float, optional + X spacing between pixels in world units. Default is 1.0 (pixel coords). + pixel_spacing_y : float, optional + Y spacing between pixels in world units. Default is 1.0 (pixel coords). + + Returns + ------- + tuple + (vertices, indices, transforms) - The loaded mesh data and transforms. + + Examples + -------- + >>> # Place towers at hilltop positions (pixel coordinates) + >>> tower_positions = [(100, 50), (200, 150), (300, 100)] + >>> verts, indices, transforms = dem.rtx.place_mesh( + ... 'tower.glb', + ... tower_positions, + ... geometry_id='tower', + ... scale=0.1 + ... ) + + >>> # Place with world coordinates (25m per pixel) + >>> dem.rtx.place_mesh( + ... 'house.glb', + ... house_positions, + ... geometry_id='house', + ... pixel_spacing_x=25.0, + ... pixel_spacing_y=25.0 + ... ) + """ + from pathlib import Path + from .mesh import load_mesh, make_transform + import numpy as np + + filepath = Path(filepath) + if geometry_id is None: + geometry_id = filepath.stem + + # Load the mesh + vertices, indices = load_mesh( + filepath, + scale=scale, + swap_yz=swap_yz, + center_xy=center_xy, + base_at_zero=base_at_zero + ) + + # Get terrain data as numpy array + terrain_data = self._obj.data + if hasattr(terrain_data, 'get'): # cupy array + terrain_data = terrain_data.get() + else: + terrain_data = np.asarray(terrain_data) + + H, W = terrain_data.shape + + # Create transforms for each position with pixel spacing + transforms = [] + for i, (px, py) in enumerate(positions): + # Sample terrain elevation at pixel position + ix = int(np.clip(px, 0, W - 1)) + iy = int(np.clip(py, 0, H - 1)) + z = float(terrain_data[iy, ix]) + + # Convert pixel coords to world coords + world_x = px * pixel_spacing_x + world_y = py * pixel_spacing_y + + # Determine rotation + if rotation_z == 'random': + rot = np.random.uniform(0, 2 * np.pi) + else: + rot = float(rotation_z) + + transform = make_transform(x=world_x, y=world_y, z=z, scale=1.0, rotation_z=rot) + transforms.append(transform) + + # Add each instance to the scene + for i, transform in enumerate(transforms): + instance_id = f"{geometry_id}_{i}" if len(transforms) > 1 else geometry_id + self._rtx.add_geometry(instance_id, vertices, indices, transform=transform) + + return vertices, indices, transforms + + def triangulate(self, geometry_id='terrain', scale=1.0, + pixel_spacing_x=1.0, pixel_spacing_y=1.0): + """Triangulate the terrain and add it to the scene. + + Creates a triangle mesh from the raster elevation data and adds it + to the RTX scene for ray tracing operations. + + Parameters + ---------- + geometry_id : str, optional + ID for the terrain geometry. Default is 'terrain'. + scale : float, optional + Scale factor for elevation values. Default is 1.0. + pixel_spacing_x : float, optional + X spacing between pixels in world units. Default is 1.0 (pixel coords). + pixel_spacing_y : float, optional + Y spacing between pixels in world units. Default is 1.0 (pixel coords). + + Returns + ------- + tuple + (vertices, indices) - The terrain mesh data as numpy arrays. + Vertices are scaled by pixel_spacing (x=col*spacing_x, y=row*spacing_y). + + Examples + -------- + >>> # Triangulate terrain in pixel coordinates + >>> verts, indices = dem.rtx.triangulate() + + >>> # Triangulate with real-world spacing (e.g., 25m per pixel) + >>> verts, indices = dem.rtx.triangulate(pixel_spacing_x=25.0, pixel_spacing_y=25.0) + """ + from .mesh import triangulate_terrain + import numpy as np + + H, W = self._obj.shape + + # Allocate buffers + num_vertices = H * W + num_triangles = (H - 1) * (W - 1) * 2 + vertices = np.zeros(num_vertices * 3, dtype=np.float32) + indices = np.zeros(num_triangles * 3, dtype=np.int32) + + # Triangulate the terrain (creates vertices in pixel coordinates) + triangulate_terrain(vertices, indices, self._obj, scale=scale) + + # Scale x,y coordinates to world units if pixel spacing != 1.0 + if pixel_spacing_x != 1.0 or pixel_spacing_y != 1.0: + # Vertices are stored as [x0,y0,z0, x1,y1,z1, ...] + vertices[0::3] *= pixel_spacing_x # Scale all x coordinates + vertices[1::3] *= pixel_spacing_y # Scale all y coordinates + + # Store pixel spacing for use in explore/viewshed + self._pixel_spacing_x = pixel_spacing_x + self._pixel_spacing_y = pixel_spacing_y + + # Add to scene + self._rtx.add_geometry(geometry_id, vertices, indices) + + return vertices, indices + + def flyover(self, output_path, duration=30.0, fps=10.0, orbit_scale=0.6, + altitude_offset=500.0, fov=60.0, fov_range=None, + width=1280, height=720, sun_azimuth=225, sun_altitude=35, + shadows=True, ambient=0.2, colormap='terrain', + vertical_exaggeration=None, rtx=None): + """Create a flyover animation orbiting around the terrain. + + Generates a smooth orbital camera path around the terrain center, + rendering each frame and saving as an animated GIF. + + Parameters + ---------- + output_path : str + Path to save the output GIF animation. + duration : float, optional + Animation duration in seconds. Default is 30. + fps : float, optional + Frames per second. Default is 10. + orbit_scale : float, optional + Orbit radius as fraction of terrain dimensions. Default is 0.6. + altitude_offset : float, optional + Camera altitude above maximum terrain elevation. Default is 500. + fov : float, optional + Base field of view in degrees. Default is 60. + fov_range : tuple of float, optional + (min_fov, max_fov) for dynamic zoom. If None, uses constant FOV. + width : int, optional + Output image width in pixels. Default is 1280. + height : int, optional + Output image height in pixels. Default is 720. + sun_azimuth : float, optional + Sun azimuth angle in degrees. Default is 225 (southwest). + sun_altitude : float, optional + Sun altitude angle in degrees. Default is 35. + shadows : bool, optional + If True, cast shadow rays. Default is True. + ambient : float, optional + Ambient light intensity [0-1]. Default is 0.2. + colormap : str, optional + Matplotlib colormap name. Default is 'terrain'. + vertical_exaggeration : float, optional + Scale factor for elevation values. If None, auto-computed. + rtx : RTX, optional + Existing RTX instance to reuse. If None, uses the accessor's + cached RTX instance. + + Returns + ------- + str + Path to the saved GIF file. + + Examples + -------- + >>> dem.rtx.flyover('flyover.gif') + >>> dem.rtx.flyover('flyover.gif', duration=60, fps=15) + >>> dem.rtx.flyover('flyover.gif', fov_range=(30, 70)) # Dynamic zoom + """ + from .analysis import flyover as _flyover + # Note: Always pass rtx=None to let the analysis function create its own + # RTX instance. This prevents the analysis function from clearing the + # multi-GAS scene that may have been built with triangulate/place_mesh. + return _flyover( + self._obj, + output_path=output_path, + duration=duration, + fps=fps, + orbit_scale=orbit_scale, + altitude_offset=altitude_offset, + fov=fov, + fov_range=fov_range, + width=width, + height=height, + sun_azimuth=sun_azimuth, + sun_altitude=sun_altitude, + shadows=shadows, + ambient=ambient, + colormap=colormap, + vertical_exaggeration=vertical_exaggeration, + rtx=rtx, # User can override, but default None creates fresh instance + ) + + def view(self, x, y, z, output_path, duration=10.0, fps=12.0, + look_distance=1000.0, look_down_angle=10.0, fov=70.0, + width=1280, height=720, sun_azimuth=225, sun_altitude=35, + shadows=True, ambient=0.2, colormap='terrain', + vertical_exaggeration=None, rtx=None): + """Create a 360° panoramic view animation from a specific point. + + Generates a rotating view from a fixed camera position, looking outward + in all directions to create a panoramic effect. + + Parameters + ---------- + x : float + X coordinate of the viewpoint (in pixel coordinates). + y : float + Y coordinate of the viewpoint (in pixel coordinates). + z : float + Z coordinate (elevation) of the viewpoint. + output_path : str + Path to save the output GIF animation. + duration : float, optional + Animation duration in seconds. Default is 10. + fps : float, optional + Frames per second. Default is 12. + look_distance : float, optional + Distance to the look-at point from the camera. Default is 1000. + look_down_angle : float, optional + Angle in degrees to look down from horizontal. Default is 10. + fov : float, optional + Field of view in degrees. Default is 70 (wide for panoramic feel). + width : int, optional + Output image width in pixels. Default is 1280. + height : int, optional + Output image height in pixels. Default is 720. + sun_azimuth : float, optional + Sun azimuth angle in degrees. Default is 225 (southwest). + sun_altitude : float, optional + Sun altitude angle in degrees. Default is 35. + shadows : bool, optional + If True, cast shadow rays. Default is True. + ambient : float, optional + Ambient light intensity [0-1]. Default is 0.2. + colormap : str, optional + Matplotlib colormap name. Default is 'terrain'. + vertical_exaggeration : float, optional + Scale factor for elevation values. If None, auto-computed. + rtx : RTX, optional + Existing RTX instance to reuse. If None, uses the accessor's + cached RTX instance. + + Returns + ------- + str + Path to the saved GIF file. + + Examples + -------- + >>> # View from a specific coordinate + >>> dem.rtx.view(x=500, y=300, z=2500, output_path='hilltop_view.gif') + + >>> # View from terrain surface + height offset + >>> elev = dem.values[int(y), int(x)] + >>> dem.rtx.view(x=100, y=200, z=elev + 50, output_path='view.gif') + """ + from .analysis import view as _view + return _view( + self._obj, + x=x, + y=y, + z=z, + output_path=output_path, + duration=duration, + fps=fps, + look_distance=look_distance, + look_down_angle=look_down_angle, + fov=fov, + width=width, + height=height, + sun_azimuth=sun_azimuth, + sun_altitude=sun_altitude, + shadows=shadows, + ambient=ambient, + colormap=colormap, + vertical_exaggeration=vertical_exaggeration, + rtx=rtx, # User can override, but default None creates fresh instance + ) + + def explore(self, width=800, height=600, render_scale=0.5, + start_position=None, look_at=None, key_repeat_interval=0.05, + pixel_spacing_x=None, pixel_spacing_y=None): + """Launch an interactive terrain viewer with keyboard controls. + + Opens a matplotlib window for terrain exploration with keyboard + controls. Uses matplotlib's event system - no additional dependencies. + + Any meshes placed with place_mesh() will be visible in the scene. + Use the G key to cycle through geometry layer information. + + Parameters + ---------- + width : int, optional + Window width in pixels. Default is 800. + height : int, optional + Window height in pixels. Default is 600. + render_scale : float, optional + Render at this fraction of window size (0.25-1.0). + Lower values give faster response. Default is 0.5. + start_position : tuple of float, optional + Starting camera position (x, y, z). If None, auto-positions + above the terrain center. + look_at : tuple of float, optional + Initial look-at point. If None, looks toward terrain center. + key_repeat_interval : float, optional + Minimum seconds between key repeat events (default 0.05 = 20 FPS max). + Lower values = more responsive but more GPU load. + pixel_spacing_x : float, optional + X spacing between pixels in world units. If None, uses the value + from the last triangulate() call (default 1.0). + pixel_spacing_y : float, optional + Y spacing between pixels in world units. If None, uses the value + from the last triangulate() call (default 1.0). + + Controls + -------- + - W/Up: Move forward + - S/Down: Move backward + - A/Left: Strafe left + - D/Right: Strafe right + - Q/Page Up: Move up + - E/Page Down: Move down + - I/J/K/L: Look up/left/down/right + - Scroll wheel: Zoom in/out (FOV) + - +/-: Adjust movement speed + - G: Cycle geometry layers (shows info about placed meshes) + - N: Jump to next geometry in current layer + - P: Jump to previous geometry in current layer + - O: Place observer (for viewshed) at camera position + - V: Toggle viewshed overlay (teal glow shows visible terrain) + - [/]: Decrease/increase observer height + - T: Toggle shadows + - C: Cycle colormap + - F: Save screenshot + - H: Toggle help overlay + - X: Exit + + Examples + -------- + >>> dem.rtx.explore() + >>> dem.rtx.explore(width=1024, height=768, render_scale=0.25) + >>> dem.rtx.explore(start_position=(500, -200, 3000)) + """ + from .engine import explore as _explore + + # Use stored pixel spacing if not explicitly provided + spacing_x = pixel_spacing_x if pixel_spacing_x is not None else self._pixel_spacing_x + spacing_y = pixel_spacing_y if pixel_spacing_y is not None else self._pixel_spacing_y + + _explore( + self._obj, + width=width, + height=height, + render_scale=render_scale, + start_position=start_position, + look_at=look_at, + key_repeat_interval=key_repeat_interval, + rtx=self._rtx, + pixel_spacing_x=spacing_x, + pixel_spacing_y=spacing_y, + ) diff --git a/rtxpy/analysis/__init__.py b/rtxpy/analysis/__init__.py index cb8a9eb..a785b99 100644 --- a/rtxpy/analysis/__init__.py +++ b/rtxpy/analysis/__init__.py @@ -6,5 +6,7 @@ from .viewshed import viewshed from .hillshade import hillshade, get_sun_dir +from .render import render +from .animation import flyover, view -__all__ = ['viewshed', 'hillshade', 'get_sun_dir'] +__all__ = ['viewshed', 'hillshade', 'get_sun_dir', 'render', 'flyover', 'view'] diff --git a/rtxpy/analysis/animation.py b/rtxpy/analysis/animation.py new file mode 100644 index 0000000..c21f607 --- /dev/null +++ b/rtxpy/analysis/animation.py @@ -0,0 +1,354 @@ +"""Animation functions for terrain flyover and point-of-view rendering. + +This module provides GPU-accelerated ray tracing for creating animated +visualizations of terrain data. +""" + +import numpy as np +from pathlib import Path +from typing import Optional, Tuple, Union + +from ..rtx import RTX, has_cupy +from .render import render + +if has_cupy: + import cupy + + +def _lazy_import_imageio(): + """Lazily import imageio with helpful error message.""" + try: + import imageio + return imageio + except ImportError: + raise ImportError( + "imageio is required for animation export. " + "Install it with: pip install imageio " + "or: pip install rtxpy[all]" + ) + + +def _lazy_import_scipy(): + """Lazily import scipy.ndimage with helpful error message.""" + try: + from scipy.ndimage import gaussian_filter1d + return gaussian_filter1d + except ImportError: + raise ImportError( + "scipy is required for smooth animations. " + "Install it with: pip install scipy " + "or: pip install rtxpy[all]" + ) + + +def flyover( + raster, + output_path: str, + duration: float = 30.0, + fps: float = 10.0, + orbit_scale: float = 0.6, + altitude_offset: float = 500.0, + fov: float = 60.0, + fov_range: Optional[Tuple[float, float]] = None, + width: int = 1280, + height: int = 720, + sun_azimuth: float = 225, + sun_altitude: float = 35, + shadows: bool = True, + ambient: float = 0.2, + colormap: str = 'terrain', + vertical_exaggeration: Optional[float] = None, + rtx: RTX = None, +) -> str: + """Create a flyover animation orbiting around the terrain. + + Generates a smooth orbital camera path around the terrain center, + with optional dynamic zoom (FOV variation) based on terrain features. + + Parameters + ---------- + raster : xarray.DataArray + 2D raster terrain data with 'x' and 'y' coordinates. + output_path : str + Path to save the output GIF animation. + duration : float, optional + Animation duration in seconds. Default is 30. + fps : float, optional + Frames per second. Default is 10. + orbit_scale : float, optional + Orbit radius as fraction of terrain dimensions. Default is 0.6. + altitude_offset : float, optional + Camera altitude above maximum terrain elevation. Default is 500. + fov : float, optional + Base field of view in degrees. Default is 60. + fov_range : tuple of float, optional + (min_fov, max_fov) for dynamic zoom. If None, uses constant FOV. + width : int, optional + Output image width in pixels. Default is 1280. + height : int, optional + Output image height in pixels. Default is 720. + sun_azimuth : float, optional + Sun azimuth angle in degrees. Default is 225 (southwest). + sun_altitude : float, optional + Sun altitude angle in degrees. Default is 35. + shadows : bool, optional + If True, cast shadow rays. Default is True. + ambient : float, optional + Ambient light intensity [0-1]. Default is 0.2. + colormap : str, optional + Matplotlib colormap name. Default is 'terrain'. + vertical_exaggeration : float, optional + Scale factor for elevation values. If None, auto-computed. + rtx : RTX, optional + Existing RTX instance to reuse. + + Returns + ------- + str + Path to the saved GIF file. + + Examples + -------- + >>> dem.rtx.flyover('flyover.gif', duration=60, fps=15) + >>> dem.rtx.flyover('flyover.gif', fov_range=(30, 70)) # Dynamic zoom + """ + imageio = _lazy_import_imageio() + gaussian_filter1d = _lazy_import_scipy() + + if not has_cupy: + raise ImportError( + "cupy is required for flyover animation. " + "Install with: conda install -c conda-forge cupy" + ) + + # Get terrain dimensions + H, W = raster.shape + terrain_data = raster.data + if hasattr(terrain_data, 'get'): # cupy array + terrain_data = terrain_data.get() + else: + terrain_data = np.asarray(terrain_data) + + elev_min = float(np.nanmin(terrain_data)) + elev_max = float(np.nanmax(terrain_data)) + elev_mean = float(np.nanmean(terrain_data)) + + # Scene center + center_x = W / 2 + center_y = H / 2 + center_z = elev_mean + + # Orbit parameters + orbit_radius_x = W * orbit_scale + orbit_radius_y = H * orbit_scale + cruise_altitude = elev_max + altitude_offset + + # Frame count + num_frames = int(duration * fps) + if num_frames < 2: + num_frames = 2 + + # Generate orbital path (one complete orbit) + angles = np.linspace(0, 2 * np.pi, num_frames, endpoint=False) + + # Camera positions + cam_x = center_x + orbit_radius_x * np.sin(angles) + cam_y = center_y - orbit_radius_y * np.cos(angles) + cam_z = np.full(num_frames, cruise_altitude) + + # Look-at: always center + look_x = np.full(num_frames, center_x) + look_y = np.full(num_frames, center_y) + look_z = np.full(num_frames, center_z) + + # FOV values (constant or dynamic) + if fov_range is not None: + min_fov, max_fov = fov_range + # Vary FOV sinusoidally for smooth zoom in/out + fov_values = (min_fov + max_fov) / 2 + (max_fov - min_fov) / 2 * np.sin(angles * 2) + fov_values = gaussian_filter1d(fov_values, sigma=5) + else: + fov_values = np.full(num_frames, fov) + + # Render frames + frames = [] + for i in range(num_frames): + camera_pos = (cam_x[i], cam_y[i], cam_z[i]) + look_at = (look_x[i], look_y[i], look_z[i]) + + # Sun follows camera for consistent lighting + current_sun_azimuth = sun_azimuth + np.degrees(angles[i]) + + img = render( + raster, + camera_position=camera_pos, + look_at=look_at, + fov=fov_values[i], + width=width, + height=height, + sun_azimuth=current_sun_azimuth, + sun_altitude=sun_altitude, + shadows=shadows, + ambient=ambient, + colormap=colormap, + vertical_exaggeration=vertical_exaggeration, + rtx=rtx, + ) + + # Convert to uint8 + img_uint8 = (np.clip(img, 0, 1) * 255).astype(np.uint8) + frames.append(img_uint8) + + # Save GIF + output_path = str(output_path) + # Use duration (ms per frame) instead of deprecated fps parameter + duration_ms = 1000.0 / fps + imageio.mimsave(output_path, frames, duration=duration_ms, loop=0) + + return output_path + + +def view( + raster, + x: float, + y: float, + z: float, + output_path: str, + duration: float = 10.0, + fps: float = 12.0, + look_distance: float = 1000.0, + look_down_angle: float = 10.0, + fov: float = 70.0, + width: int = 1280, + height: int = 720, + sun_azimuth: float = 225, + sun_altitude: float = 35, + shadows: bool = True, + ambient: float = 0.2, + colormap: str = 'terrain', + vertical_exaggeration: Optional[float] = None, + rtx: RTX = None, +) -> str: + """Create a 360° panoramic view animation from a specific point. + + Generates a rotating view from a fixed camera position, looking outward + in all directions to create a panoramic effect. + + Parameters + ---------- + raster : xarray.DataArray + 2D raster terrain data with 'x' and 'y' coordinates. + x : float + X coordinate of the viewpoint (in pixel coordinates). + y : float + Y coordinate of the viewpoint (in pixel coordinates). + z : float + Z coordinate (elevation) of the viewpoint. + output_path : str + Path to save the output GIF animation. + duration : float, optional + Animation duration in seconds. Default is 10. + fps : float, optional + Frames per second. Default is 12. + look_distance : float, optional + Distance to the look-at point from the camera. Default is 1000. + look_down_angle : float, optional + Angle in degrees to look down from horizontal. Default is 10. + fov : float, optional + Field of view in degrees. Default is 70 (wide for panoramic feel). + width : int, optional + Output image width in pixels. Default is 1280. + height : int, optional + Output image height in pixels. Default is 720. + sun_azimuth : float, optional + Sun azimuth angle in degrees. Default is 225 (southwest). + sun_altitude : float, optional + Sun altitude angle in degrees. Default is 35. + shadows : bool, optional + If True, cast shadow rays. Default is True. + ambient : float, optional + Ambient light intensity [0-1]. Default is 0.2. + colormap : str, optional + Matplotlib colormap name. Default is 'terrain'. + vertical_exaggeration : float, optional + Scale factor for elevation values. If None, auto-computed. + rtx : RTX, optional + Existing RTX instance to reuse. + + Returns + ------- + str + Path to the saved GIF file. + + Examples + -------- + >>> # View from a hilltop + >>> dem.rtx.view(x=500, y=300, z=2500, output_path='hilltop_view.gif') + + >>> # View from tower position with terrain-sampled elevation + >>> tower_elev = dem.values[int(y), int(x)] + 45 # 45m tower + >>> dem.rtx.view(x=100, y=200, z=tower_elev, output_path='tower_view.gif') + """ + imageio = _lazy_import_imageio() + + if not has_cupy: + raise ImportError( + "cupy is required for view animation. " + "Install with: conda install -c conda-forge cupy" + ) + + # Frame count + num_frames = int(duration * fps) + if num_frames < 2: + num_frames = 2 + + # Generate rotation angles (one complete 360° rotation) + angles = np.linspace(0, 2 * np.pi, num_frames, endpoint=False) + + # Convert look_down_angle to radians + look_down_rad = np.radians(look_down_angle) + + # Camera position is fixed + camera_pos = (float(x), float(y), float(z)) + + # Render frames + frames = [] + for i in range(num_frames): + angle = angles[i] + + # Look-at point rotates around the camera + # Horizontal component + look_x = x + look_distance * np.sin(angle) * np.cos(look_down_rad) + look_y = y + look_distance * np.cos(angle) * np.cos(look_down_rad) + # Vertical component (looking slightly down) + look_z = z - look_distance * np.sin(look_down_rad) + + look_at = (look_x, look_y, look_z) + + img = render( + raster, + camera_position=camera_pos, + look_at=look_at, + fov=fov, + width=width, + height=height, + sun_azimuth=sun_azimuth, + sun_altitude=sun_altitude, + shadows=shadows, + ambient=ambient, + colormap=colormap, + vertical_exaggeration=vertical_exaggeration, + rtx=rtx, + ) + + # Convert to uint8 + img_uint8 = (np.clip(img, 0, 1) * 255).astype(np.uint8) + frames.append(img_uint8) + + # Save GIF + output_path = str(output_path) + # Use duration (ms per frame) instead of deprecated fps parameter + duration_ms = 1000.0 / fps + imageio.mimsave(output_path, frames, duration=duration_ms, loop=0) + + return output_path diff --git a/rtxpy/analysis/render.py b/rtxpy/analysis/render.py new file mode 100644 index 0000000..5ce18d4 --- /dev/null +++ b/rtxpy/analysis/render.py @@ -0,0 +1,780 @@ +"""Perspective camera rendering for movie-quality terrain visualization. + +This module provides GPU-accelerated ray tracing for terrain rendering with +perspective cameras, shadows, atmospheric effects, and colormap-based shading. +""" + +from numba import cuda +import numpy as np +import math + +from typing import Optional, Tuple + +from .._cuda_utils import calc_dims, add, diff, mul, dot, float3, make_float3, invert +from ._common import prepare_mesh +from .hillshade import get_sun_dir +from ..rtx import RTX, has_cupy + +if has_cupy: + import cupy + + +def _lazy_import_xarray(): + """Lazily import xarray with helpful error message.""" + try: + import xarray as xr + return xr + except ImportError: + raise ImportError( + "xarray is required for render. " + "Install it with: pip install xarray " + "or: pip install rtxpy[analysis]" + ) + + +def _lazy_import_matplotlib(): + """Lazily import matplotlib with helpful error message.""" + try: + import matplotlib.pyplot as plt + import matplotlib.cm as cm + return plt, cm + except ImportError: + raise ImportError( + "matplotlib is required for colormap rendering. " + "Install it with: pip install matplotlib " + "or: pip install rtxpy[all]" + ) + + +def _lazy_import_pil(): + """Lazily import PIL with helpful error message.""" + try: + from PIL import Image + return Image + except ImportError: + raise ImportError( + "Pillow is required for saving images. " + "Install it with: pip install Pillow " + "or: pip install rtxpy[all]" + ) + + +def _compute_camera_basis(camera_position, look_at, up): + """Compute camera basis vectors (forward, right, up) from position and target. + + Parameters + ---------- + camera_position : tuple of float + Camera position (x, y, z). + look_at : tuple of float + Target point to look at (x, y, z). + up : tuple of float + World up vector. + + Returns + ------- + tuple of np.ndarray + (forward, right, up) unit vectors. + """ + camera_pos = np.array(camera_position, dtype=np.float32) + target = np.array(look_at, dtype=np.float32) + world_up = np.array(up, dtype=np.float32) + + forward = target - camera_pos + forward = forward / np.linalg.norm(forward) + + right = np.cross(forward, world_up) + right_norm = np.linalg.norm(right) + + # Handle case where forward is parallel to up vector + if right_norm < 1e-6: + # Use a different up vector to compute right + alt_up = np.array([1.0, 0.0, 0.0], dtype=np.float32) + right = np.cross(forward, alt_up) + right_norm = np.linalg.norm(right) + if right_norm < 1e-6: + alt_up = np.array([0.0, 1.0, 0.0], dtype=np.float32) + right = np.cross(forward, alt_up) + right_norm = np.linalg.norm(right) + + right = right / right_norm + + cam_up = np.cross(right, forward) + cam_up = cam_up / np.linalg.norm(cam_up) + + return forward, right, cam_up + + +def _get_colormap_lut(colormap, num_entries=256): + """Generate a color lookup table from a matplotlib colormap. + + Parameters + ---------- + colormap : str + Name of matplotlib colormap or 'hillshade'. + num_entries : int + Number of entries in the LUT. + + Returns + ------- + np.ndarray + Color lookup table of shape (num_entries, 3) with float32 values [0-1]. + """ + if colormap == 'hillshade': + # Grayscale LUT for hillshade mode + lut = np.zeros((num_entries, 3), dtype=np.float32) + for i in range(num_entries): + v = i / (num_entries - 1) + lut[i] = [v, v, v] + return lut + + plt, cm = _lazy_import_matplotlib() + + try: + cmap = plt.get_cmap(colormap) + except ValueError: + raise ValueError(f"Unknown colormap: {colormap}") + + lut = np.zeros((num_entries, 3), dtype=np.float32) + for i in range(num_entries): + rgba = cmap(i / (num_entries - 1)) + lut[i] = [rgba[0], rgba[1], rgba[2]] + + return lut + + +@cuda.jit(device=True) +def _normalize(v): + """Normalize a float3 vector.""" + length = math.sqrt(v[0] * v[0] + v[1] * v[1] + v[2] * v[2]) + if length > 0: + return float3(v[0] / length, v[1] / length, v[2] / length) + return v + + +@cuda.jit +def _generate_perspective_rays_kernel(rays, width, height, camera_pos, forward, right, up, fov_scale): + """GPU kernel to generate perspective camera rays. + + Uses pinhole camera model: ray_dir = forward + u*right + v*up + where u and v are in normalized device coordinates scaled by FOV. + """ + px, py = cuda.grid(2) + if px < width and py < height: + # Convert pixel to normalized device coordinates (-1 to 1) + aspect = width / height + u = (2.0 * (px + 0.5) / width - 1.0) * aspect * fov_scale + v = (1.0 - 2.0 * (py + 0.5) / height) * fov_scale + + # Compute ray direction + dir_x = forward[0] + u * right[0] + v * up[0] + dir_y = forward[1] + u * right[1] + v * up[1] + dir_z = forward[2] + u * right[2] + v * up[2] + + # Normalize direction + length = math.sqrt(dir_x * dir_x + dir_y * dir_y + dir_z * dir_z) + dir_x /= length + dir_y /= length + dir_z /= length + + # Store ray (origin + direction) + idx = py * width + px + rays[idx, 0] = camera_pos[0] + rays[idx, 1] = camera_pos[1] + rays[idx, 2] = camera_pos[2] + rays[idx, 3] = 1e-3 # t_min + rays[idx, 4] = dir_x + rays[idx, 5] = dir_y + rays[idx, 6] = dir_z + rays[idx, 7] = np.inf # t_max + + +def _generate_perspective_rays(rays, width, height, camera_pos, forward, right, up, fov): + """Generate perspective camera rays. + + Parameters + ---------- + rays : cupy.ndarray + Output array of shape (width*height, 8) for ray data. + width : int + Output image width. + height : int + Output image height. + camera_pos : cupy.ndarray + Camera position (3,). + forward : cupy.ndarray + Camera forward vector (3,). + right : cupy.ndarray + Camera right vector (3,). + up : cupy.ndarray + Camera up vector (3,). + fov : float + Vertical field of view in degrees. + """ + fov_scale = math.tan(math.radians(fov) / 2.0) + + threadsperblock = (16, 16) + blockspergrid_x = (width + threadsperblock[0] - 1) // threadsperblock[0] + blockspergrid_y = (height + threadsperblock[1] - 1) // threadsperblock[1] + blockspergrid = (blockspergrid_x, blockspergrid_y) + + _generate_perspective_rays_kernel[blockspergrid, threadsperblock]( + rays, width, height, camera_pos, forward, right, up, fov_scale + ) + + +@cuda.jit +def _generate_shadow_rays_from_hits_kernel(shadow_rays, primary_rays, hits, num_rays, sun_dir): + """GPU kernel to generate shadow rays from primary hit points toward the sun.""" + idx = cuda.grid(1) + if idx < num_rays: + t = hits[idx, 0] + + if t > 0: + # Get normal at hit point + nx = hits[idx, 1] + ny = hits[idx, 2] + nz = hits[idx, 3] + + # Flip normal if facing away from ray + ray_dx = primary_rays[idx, 4] + ray_dy = primary_rays[idx, 5] + ray_dz = primary_rays[idx, 6] + + dot_nd = nx * ray_dx + ny * ray_dy + nz * ray_dz + if dot_nd > 0: + nx = -nx + ny = -ny + nz = -nz + + # Compute hit point + ox = primary_rays[idx, 0] + oy = primary_rays[idx, 1] + oz = primary_rays[idx, 2] + + hit_x = ox + t * ray_dx + hit_y = oy + t * ray_dy + hit_z = oz + t * ray_dz + + # Offset along normal to avoid self-intersection + offset = 1e-3 + origin_x = hit_x + nx * offset + origin_y = hit_y + ny * offset + origin_z = hit_z + nz * offset + + shadow_rays[idx, 0] = origin_x + shadow_rays[idx, 1] = origin_y + shadow_rays[idx, 2] = origin_z + shadow_rays[idx, 3] = 1e-3 # t_min + shadow_rays[idx, 4] = sun_dir[0] + shadow_rays[idx, 5] = sun_dir[1] + shadow_rays[idx, 6] = sun_dir[2] + shadow_rays[idx, 7] = np.inf # t_max + else: + # No hit - shadow ray should not trace + shadow_rays[idx, 0] = 0 + shadow_rays[idx, 1] = 0 + shadow_rays[idx, 2] = 0 + shadow_rays[idx, 3] = 0 + shadow_rays[idx, 4] = 0 + shadow_rays[idx, 5] = 0 + shadow_rays[idx, 6] = 1 + shadow_rays[idx, 7] = 0 # t_max = 0 means no trace + + +def _generate_shadow_rays_from_hits(shadow_rays, primary_rays, hits, num_rays, sun_dir): + """Generate shadow rays from primary ray hit points toward the sun.""" + threadsperblock = 256 + blockspergrid = (num_rays + threadsperblock - 1) // threadsperblock + + _generate_shadow_rays_from_hits_kernel[blockspergrid, threadsperblock]( + shadow_rays, primary_rays, hits, num_rays, sun_dir + ) + + +@cuda.jit +def _shade_terrain_kernel( + output, primary_rays, primary_hits, shadow_hits, + elevation_data, color_lut, num_rays, width, height, + sun_dir, ambient, cast_shadows, + fog_density, fog_color_r, fog_color_g, fog_color_b, + sky_color_r, sky_color_g, sky_color_b, + elev_min, elev_range, alpha_channel, + viewshed_data, viewshed_enabled, viewshed_opacity, + observer_x, observer_y, + pixel_spacing_x, pixel_spacing_y +): + """GPU kernel for terrain shading with lighting, shadows, fog, colormapping, and viewshed.""" + idx = cuda.grid(1) + if idx < num_rays: + t = primary_hits[idx, 0] + + px = idx % width + py = idx // width + + if t > 0: + # Get normal + nx = primary_hits[idx, 1] + ny = primary_hits[idx, 2] + nz = primary_hits[idx, 3] + + # Flip normal if back-facing + ray_dx = primary_rays[idx, 4] + ray_dy = primary_rays[idx, 5] + ray_dz = primary_rays[idx, 6] + + dot_nd = nx * ray_dx + ny * ray_dy + nz * ray_dz + if dot_nd > 0: + nx = -nx + ny = -ny + nz = -nz + + # Compute hit point + ox = primary_rays[idx, 0] + oy = primary_rays[idx, 1] + oz = primary_rays[idx, 2] + + hit_x = ox + t * ray_dx + hit_y = oy + t * ray_dy + hit_z = oz + t * ray_dz + + # Get elevation at hit point for color lookup + # Convert world coords to pixel indices using pixel spacing + elev_y = int(hit_y / pixel_spacing_y + 0.5) + elev_x = int(hit_x / pixel_spacing_x + 0.5) + + elev_h = elevation_data.shape[0] + elev_w = elevation_data.shape[1] + + if elev_y >= 0 and elev_y < elev_h and elev_x >= 0 and elev_x < elev_w: + elevation = elevation_data[elev_y, elev_x] + else: + elevation = hit_z + + # Normalize elevation to [0, 1] for colormap lookup + if elev_range > 0: + elev_norm = (elevation - elev_min) / elev_range + else: + elev_norm = 0.5 + + if elev_norm < 0: + elev_norm = 0.0 + elif elev_norm > 1: + elev_norm = 1.0 + + # Color lookup + lut_idx = int(elev_norm * 255) + if lut_idx > 255: + lut_idx = 255 + if lut_idx < 0: + lut_idx = 0 + + base_r = color_lut[lut_idx, 0] + base_g = color_lut[lut_idx, 1] + base_b = color_lut[lut_idx, 2] + + # Lambertian shading + cos_theta = nx * sun_dir[0] + ny * sun_dir[1] + nz * sun_dir[2] + if cos_theta < 0: + cos_theta = 0.0 + + # Shadow factor + shadow_factor = 1.0 + if cast_shadows: + shadow_t = shadow_hits[idx, 0] + if shadow_t > 0: + shadow_factor = 0.5 + + # Final lighting + diffuse = cos_theta * shadow_factor + lighting = ambient + (1.0 - ambient) * diffuse + + color_r = base_r * lighting + color_g = base_g * lighting + color_b = base_b * lighting + + # Apply viewshed overlay (teal glow on VISIBLE areas only) + if viewshed_enabled: + vs_h = viewshed_data.shape[0] + vs_w = viewshed_data.shape[1] + + # Draw bright magenta orb at observer location (in world coords) + dist_to_obs = math.sqrt((hit_x - observer_x) * (hit_x - observer_x) + + (hit_y - observer_y) * (hit_y - observer_y)) + # Scale orb radius with pixel spacing for consistent visual size + orb_radius = 2.0 * max(pixel_spacing_x, pixel_spacing_y) + if dist_to_obs < orb_radius: + # Bright glowing magenta orb at observer + orb_intensity = 1.0 - (dist_to_obs / orb_radius) + orb_intensity = orb_intensity * orb_intensity # Squared for sharper glow + color_r = color_r * (1.0 - orb_intensity) + 1.0 * orb_intensity + color_g = color_g * (1.0 - orb_intensity) + 0.0 * orb_intensity + color_b = color_b * (1.0 - orb_intensity) + 1.0 * orb_intensity + elif elev_y >= 0 and elev_y < vs_h and elev_x >= 0 and elev_x < vs_w: + vis_val = viewshed_data[elev_y, elev_x] + + # Apply teal glow only to VISIBLE areas + if not math.isnan(vis_val) and vis_val >= 0.0: + # Visible - teal/cyan glow + alpha = viewshed_opacity + color_r = color_r * (1.0 - alpha) + color_g = color_g * (1.0 - alpha) + 0.9 * alpha + color_b = color_b * (1.0 - alpha) + 0.85 * alpha + # else: invisible or NaN - keep original terrain color + + # Clamp + if color_r > 1.0: + color_r = 1.0 + if color_g > 1.0: + color_g = 1.0 + if color_b > 1.0: + color_b = 1.0 + + # Fog + if fog_density > 0: + fog_amount = 1.0 - math.exp(-fog_density * t) + color_r = color_r * (1 - fog_amount) + fog_color_r * fog_amount + color_g = color_g * (1 - fog_amount) + fog_color_g * fog_amount + color_b = color_b * (1 - fog_amount) + fog_color_b * fog_amount + + output[py, px, 0] = color_r + output[py, px, 1] = color_g + output[py, px, 2] = color_b + if alpha_channel: + output[py, px, 3] = 1.0 + else: + # Miss - sky color + output[py, px, 0] = sky_color_r + output[py, px, 1] = sky_color_g + output[py, px, 2] = sky_color_b + if alpha_channel: + output[py, px, 3] = 0.0 + + +def _shade_terrain( + output, primary_rays, primary_hits, shadow_hits, + elevation_data, color_lut, num_rays, width, height, + sun_dir, ambient, cast_shadows, + fog_density, fog_color, + elev_min, elev_range, alpha, + viewshed_data=None, viewshed_opacity=0.6, + observer_x=0.0, observer_y=0.0, + pixel_spacing_x=1.0, pixel_spacing_y=1.0 +): + """Apply terrain shading with all effects.""" + threadsperblock = 256 + blockspergrid = (num_rays + threadsperblock - 1) // threadsperblock + + # Sky color (light blue) + sky_color = (0.6, 0.75, 0.9) + + # Handle viewshed - need a placeholder if not provided + viewshed_enabled = viewshed_data is not None + if not viewshed_enabled: + # Create dummy 1x1 array (won't be used) + viewshed_data = cupy.zeros((1, 1), dtype=np.float32) + + _shade_terrain_kernel[blockspergrid, threadsperblock]( + output, primary_rays, primary_hits, shadow_hits, + elevation_data, color_lut, num_rays, width, height, + sun_dir, ambient, cast_shadows, + fog_density, fog_color[0], fog_color[1], fog_color[2], + sky_color[0], sky_color[1], sky_color[2], + elev_min, elev_range, alpha, + viewshed_data, viewshed_enabled, viewshed_opacity, + observer_x, observer_y, + pixel_spacing_x, pixel_spacing_y + ) + + +def _save_image(output, output_path): + """Save the rendered image to a file. + + Parameters + ---------- + output : np.ndarray + Image array of shape (H, W, 3) or (H, W, 4) with values [0-1]. + output_path : str + Path to save the image (supports PNG, TIFF, JPEG, etc.). + """ + Image = _lazy_import_pil() + + # Convert to uint8 + img_data = (np.clip(output, 0, 1) * 255).astype(np.uint8) + + if output.shape[2] == 4: + img = Image.fromarray(img_data, mode='RGBA') + else: + img = Image.fromarray(img_data, mode='RGB') + + img.save(output_path) + + +def render( + raster, + camera_position: Tuple[float, float, float], + look_at: Tuple[float, float, float], + fov: float = 60.0, + up: Tuple[float, float, float] = (0, 0, 1), + width: int = 1920, + height: int = 1080, + sun_azimuth: float = 225, + sun_altitude: float = 45, + shadows: bool = True, + ambient: float = 0.15, + fog_density: float = 0.0, + fog_color: Tuple[float, float, float] = (0.7, 0.8, 0.9), + colormap: str = 'terrain', + color_range: Optional[Tuple[float, float]] = None, + output_path: Optional[str] = None, + alpha: bool = False, + vertical_exaggeration: Optional[float] = None, + rtx: RTX = None, + viewshed_data=None, + viewshed_opacity: float = 0.6, + observer_position: Optional[Tuple[float, float]] = None, + pixel_spacing_x: float = 1.0, + pixel_spacing_y: float = 1.0, +) -> np.ndarray: + """Render terrain with a perspective camera for movie-quality visualization. + + Uses OptiX ray tracing to render terrain with realistic lighting, shadows, + atmospheric effects, and elevation-based coloring. + + Parameters + ---------- + raster : xarray.DataArray + 2D raster terrain data with 'x' and 'y' coordinates. + Data should be a cupy array on the GPU for best performance. + camera_position : tuple of float + Camera position in world coordinates (x, y, z). x and y are in pixel + coordinates (0 to width-1, 0 to height-1). z is in the same units as + elevation data (typically meters). + look_at : tuple of float + Target point the camera looks at (x, y, z). + fov : float, optional + Vertical field of view in degrees. Default is 60. + up : tuple of float, optional + World up vector. Default is (0, 0, 1). + width : int, optional + Output image width in pixels. Default is 1920. + height : int, optional + Output image height in pixels. Default is 1080. + sun_azimuth : float, optional + Sun azimuth angle in degrees, measured clockwise from north. + Default is 225 (southwest). + sun_altitude : float, optional + Sun altitude angle in degrees above the horizon. Default is 45. + shadows : bool, optional + If True, cast shadow rays for realistic shadows. Default is True. + ambient : float, optional + Ambient light intensity [0-1]. Default is 0.15. + fog_density : float, optional + Exponential fog density. 0 disables fog. Default is 0. + fog_color : tuple of float, optional + Fog color as (r, g, b) values [0-1]. Default is (0.7, 0.8, 0.9). + colormap : str, optional + Matplotlib colormap name or 'hillshade' for grayscale shading. + Default is 'terrain'. + color_range : tuple of float, optional + Elevation range (min, max) for colormap. If None, uses data range. + output_path : str, optional + If provided, saves the rendered image to this path (PNG, TIFF, etc.). + alpha : bool, optional + If True, output has 4 channels (RGBA) with alpha=0 for sky. + Default is False. + vertical_exaggeration : float, optional + Scale factor for elevation values. Values < 1 reduce vertical + exaggeration (useful when elevation units don't match pixel units). + If None, auto-computes a value to make relief proportional to + terrain extent. Use 1.0 for no scaling. + rtx : RTX, optional + Existing RTX instance to reuse. If None, a new instance is created. + + Returns + ------- + np.ndarray + Rendered image of shape (height, width, 3) or (height, width, 4) + as float32 with values [0-1]. + + Examples + -------- + >>> import rtxpy + >>> import xarray as xr + >>> dem = xr.open_dataarray('dem.tif') + >>> dem = dem.rtx.to_cupy() + >>> img = dem.rtx.render( + ... camera_position=(W/2, -50, elev_max + 200), + ... look_at=(W/2, H/2, elev_mean), + ... shadows=True, + ... output_path='terrain_render.png' + ... ) + """ + xr = _lazy_import_xarray() + + if not has_cupy: + raise ImportError( + "cupy is required for render. " + "Install it with: conda install -c conda-forge cupy" + ) + + if not isinstance(raster.data, cupy.ndarray): + import warnings + warnings.warn( + "raster.data is not a cupy array. " + "Additional overhead will be incurred from CPU-GPU transfers." + ) + elevation_data = cupy.asarray(raster.data) + else: + elevation_data = raster.data + + H, W = raster.shape + + # Compute vertical exaggeration if not specified + # Goal: make the terrain relief roughly proportional to the horizontal extent + elev_min_orig = float(cupy.nanmin(elevation_data)) + elev_max_orig = float(cupy.nanmax(elevation_data)) + elev_range_orig = elev_max_orig - elev_min_orig + + if vertical_exaggeration is None: + # Auto-compute: scale so relief is ~20% of horizontal extent + horizontal_extent = max(H, W) + if elev_range_orig > 0: + vertical_exaggeration = (horizontal_extent * 0.2) / elev_range_orig + else: + vertical_exaggeration = 1.0 + + # If RTX has multi-GAS content (meshes placed via add_geometry), + # use it directly without calling prepare_mesh which would rebuild as single-GAS. + # The meshes were already placed with correct coordinates, so we use them as-is. + # Also disable vertical exaggeration since the scene is already built. + if rtx is not None and rtx.get_geometry_count() > 0: + optix = rtx + scaled_raster = raster + vertical_exaggeration = 1.0 # Don't scale camera for pre-built scenes + elif vertical_exaggeration != 1.0: + # Scale elevation data for mesh building + scaled_elevation = elevation_data * vertical_exaggeration + # Create a temporary raster with scaled elevations + scaled_raster = raster.copy(data=scaled_elevation) + # Don't reuse rtx when scaling - need fresh mesh + optix = prepare_mesh(scaled_raster, rtx=None) + else: + scaled_raster = raster + optix = prepare_mesh(raster, rtx) + + # Scale camera position and look_at z coordinates + scaled_camera_position = ( + camera_position[0], + camera_position[1], + camera_position[2] * vertical_exaggeration + ) + scaled_look_at = ( + look_at[0], + look_at[1], + look_at[2] * vertical_exaggeration + ) + + num_rays = width * height + + # Compute camera basis vectors using scaled positions + forward, right, cam_up = _compute_camera_basis(scaled_camera_position, scaled_look_at, up) + + # Upload camera vectors to GPU + d_camera_pos = cupy.array(scaled_camera_position, dtype=np.float32) + d_forward = cupy.array(forward, dtype=np.float32) + d_right = cupy.array(right, dtype=np.float32) + d_up = cupy.array(cam_up, dtype=np.float32) + + # Sun direction + sun_dir = get_sun_dir(sun_altitude, sun_azimuth) + d_sun_dir = cupy.array(sun_dir, dtype=np.float32) + + # Color lookup table + color_lut = _get_colormap_lut(colormap) + d_color_lut = cupy.array(color_lut, dtype=np.float32) + + # Elevation range for colormap + if color_range is not None: + elev_min, elev_max = color_range + else: + elev_min = float(cupy.nanmin(elevation_data)) + elev_max = float(cupy.nanmax(elevation_data)) + elev_range = elev_max - elev_min + + # Allocate buffers + d_primary_rays = cupy.empty((num_rays, 8), dtype=np.float32) + d_primary_hits = cupy.empty((num_rays, 4), dtype=np.float32) + d_shadow_rays = cupy.empty((num_rays, 8), dtype=np.float32) + d_shadow_hits = cupy.empty((num_rays, 4), dtype=np.float32) + + num_channels = 4 if alpha else 3 + d_output = cupy.zeros((height, width, num_channels), dtype=np.float32) + + device = cupy.cuda.Device(0) + + # Step 1: Generate perspective rays + _generate_perspective_rays( + d_primary_rays, width, height, + d_camera_pos, d_forward, d_right, d_up, fov + ) + device.synchronize() + + # Step 2: Trace primary rays + optix.trace(d_primary_rays, d_primary_hits, num_rays) + + # Step 3: Generate and trace shadow rays (if enabled) + if shadows: + _generate_shadow_rays_from_hits( + d_shadow_rays, d_primary_rays, d_primary_hits, num_rays, d_sun_dir + ) + device.synchronize() + optix.trace(d_shadow_rays, d_shadow_hits, num_rays) + else: + # Fill shadow hits with -1 (no shadow) + d_shadow_hits.fill(-1) + + # Prepare viewshed data if provided + d_viewshed = None + if viewshed_data is not None: + if hasattr(viewshed_data, 'data'): + # It's an xarray DataArray + vs_data = viewshed_data.data + else: + vs_data = viewshed_data + if not isinstance(vs_data, cupy.ndarray): + d_viewshed = cupy.asarray(vs_data, dtype=np.float32) + else: + d_viewshed = vs_data.astype(np.float32) + + + # Get observer position for viewshed marker + obs_x = float(observer_position[0]) if observer_position else 0.0 + obs_y = float(observer_position[1]) if observer_position else 0.0 + + # Step 4: Shade terrain + _shade_terrain( + d_output, d_primary_rays, d_primary_hits, d_shadow_hits, + elevation_data, d_color_lut, num_rays, width, height, + d_sun_dir, ambient, shadows, + fog_density, fog_color, + elev_min, elev_range, alpha, + d_viewshed, viewshed_opacity, + obs_x, obs_y, + pixel_spacing_x, pixel_spacing_y + ) + device.synchronize() + + # Transfer to CPU + output = cupy.asnumpy(d_output) + + # Save image if requested + if output_path is not None: + _save_image(output, output_path) + + # Clean up + del d_primary_rays, d_primary_hits, d_shadow_rays, d_shadow_hits + del d_output, d_camera_pos, d_forward, d_right, d_up, d_sun_dir, d_color_lut + cupy.get_default_memory_pool().free_all_blocks() + + return output diff --git a/rtxpy/engine.py b/rtxpy/engine.py new file mode 100644 index 0000000..63756f4 --- /dev/null +++ b/rtxpy/engine.py @@ -0,0 +1,1018 @@ +"""Interactive terrain viewer using matplotlib for display. + +This module provides a simple game-engine-like render loop for +exploring terrain interactively with keyboard controls. +Uses matplotlib for display (no additional dependencies). +""" + +import time +import numpy as np +from typing import Optional, Tuple + +from .rtx import RTX, has_cupy + +if has_cupy: + import cupy as cp + + +class InteractiveViewer: + """ + Interactive terrain viewer using matplotlib. + + Provides keyboard-controlled camera for exploring ray-traced terrain. + Uses matplotlib's event system for input handling. + + Controls + -------- + - W/Up: Move forward + - S/Down: Move backward + - A/Left: Strafe left + - D/Right: Strafe right + - Q/Page Up: Move up + - E/Page Down: Move down + - I/J/K/L: Look up/left/down/right + - Scroll wheel: Zoom in/out (FOV) + - +/=: Increase speed + - -: Decrease speed + - G: Cycle geometry layers (when meshes are placed) + - N: Jump to next geometry in current layer + - P: Jump to previous geometry in current layer + - O: Place observer (for viewshed) at look-at point + - V: Toggle viewshed overlay (teal glow shows visible terrain) + - [/]: Decrease/increase observer height + - T: Toggle shadows + - C: Cycle colormap + - F: Save screenshot + - H: Toggle help overlay + - X: Exit + + Examples + -------- + >>> viewer = InteractiveViewer(dem) + >>> viewer.run() + """ + + def __init__(self, raster, width: int = 800, height: int = 600, + render_scale: float = 0.5, key_repeat_interval: float = 0.05, + rtx: 'RTX' = None, + pixel_spacing_x: float = 1.0, pixel_spacing_y: float = 1.0): + """ + Initialize the interactive viewer. + + Parameters + ---------- + raster : xarray.DataArray + Terrain raster data with cupy array. + width : int + Display width in pixels. + height : int + Display height in pixels. + render_scale : float + Render at this fraction of display size (0.25-1.0). + Lower values = higher FPS but lower quality. + key_repeat_interval : float + Minimum seconds between key repeat events (default 0.05 = 20 FPS max). + Lower values = more responsive but more GPU load. + rtx : RTX, optional + Existing RTX instance with geometries (e.g., from place_mesh). + If provided, renders the full scene including placed meshes. + pixel_spacing_x : float, optional + X spacing between pixels in world units (e.g., 30.0 for 30m/pixel). + Must match the spacing used when triangulating terrain. Default 1.0. + pixel_spacing_y : float, optional + Y spacing between pixels in world units. Default 1.0. + """ + if not has_cupy: + raise ImportError( + "cupy is required for the interactive viewer. " + "Install with: conda install -c conda-forge cupy" + ) + + self.raster = raster + self.rtx = rtx + self.width = width + self.height = height + self.render_scale = np.clip(render_scale, 0.25, 1.0) + self.render_width = int(width * self.render_scale) + self.render_height = int(height * self.render_scale) + + # Pixel spacing for coordinate conversion (world coords -> pixel indices) + self.pixel_spacing_x = pixel_spacing_x + self.pixel_spacing_y = pixel_spacing_y + + # GAS layer visibility tracking + self._all_geometries = [] + self._hidden_geometries = {} # geometry_id -> (verts, indices, transform) + self._layer_mode = 0 # 0=all, then cycle through geometry groups + self._layer_modes = ['all'] # Will be populated with geometry groups + self._layer_positions = {} # layer_name -> [(x, y, z, geometry_id), ...] + self._current_geom_idx = 0 # Current geometry index within active layer + + if rtx is not None: + self._all_geometries = rtx.list_geometries() + # Group geometries by prefix (e.g., 'tower_0', 'tower_1' -> 'tower') + groups = set() + layer_geoms = {} # layer_name -> [geometry_ids] + + for g in self._all_geometries: + # Extract base name (before _N suffix if present) + parts = g.rsplit('_', 1) + if len(parts) == 2 and parts[1].isdigit(): + base_name = parts[0] + else: + base_name = g + groups.add(base_name) + + if base_name not in layer_geoms: + layer_geoms[base_name] = [] + layer_geoms[base_name].append(g) + + self._layer_modes.extend(sorted(groups)) + + # Extract positions from transforms for each layer + for layer_name, geom_ids in layer_geoms.items(): + positions = [] + for geom_id in sorted(geom_ids): # Sort for consistent ordering + transform = rtx.get_geometry_transform(geom_id) + if transform: + # Position is at indices 3, 7, 11 (Tx, Ty, Tz) + x, y, z = transform[3], transform[7], transform[11] + positions.append((x, y, z, geom_id)) + self._layer_positions[layer_name] = positions + + # Camera state + self.position = None + self.yaw = 90.0 # Degrees, 0 = +X, 90 = +Y + self.pitch = -15.0 # Degrees, negative = looking down + self.move_speed = None # Set in run() based on terrain extent + self.look_speed = 5.0 + + # Rendering settings + self.fov = 60.0 + self.sun_azimuth = 225.0 + self.sun_altitude = 35.0 + self.shadows = True + self.ambient = 0.2 + self.colormap = 'terrain' + self.colormaps = ['terrain', 'viridis', 'plasma', 'cividis', 'gray'] + self.colormap_idx = 0 + + # Viewshed settings + self.viewshed_enabled = False + self.viewshed_observer_elev = 10.0 # Default 10m above surface (tower height) + self.viewshed_target_elev = 0.0 + self.viewshed_opacity = 0.6 + self._viewshed_cache = None # Cached viewshed result + self._viewshed_coverage = 0.0 # Percentage of terrain visible + self._observer_position = None # Fixed observer position (x, y) in terrain coords + + # State + self.running = False + self.show_help = True + self.frame_count = 0 + + # Held keys tracking for smooth simultaneous input + self._held_keys = set() + self._tick_interval = int(key_repeat_interval * 1000) # Convert to ms for timer + self._timer = None + + # Get terrain info + H, W = raster.shape + terrain_data = raster.data + if hasattr(terrain_data, 'get'): + terrain_np = terrain_data.get() + else: + terrain_np = np.asarray(terrain_data) + + self.terrain_shape = (H, W) + self.elev_min = float(np.nanmin(terrain_np)) + self.elev_max = float(np.nanmax(terrain_np)) + self.elev_mean = float(np.nanmean(terrain_np)) + + def _get_front(self): + """Get the forward direction vector.""" + yaw_rad = np.radians(self.yaw) + pitch_rad = np.radians(self.pitch) + return np.array([ + np.cos(yaw_rad) * np.cos(pitch_rad), + np.sin(yaw_rad) * np.cos(pitch_rad), + np.sin(pitch_rad) + ], dtype=np.float32) + + def _get_right(self): + """Get the right direction vector.""" + front = self._get_front() + world_up = np.array([0, 0, 1], dtype=np.float32) + right = np.cross(front, world_up) + return right / (np.linalg.norm(right) + 1e-8) + + def _get_look_at(self): + """Get the current look-at point.""" + return self.position + self._get_front() * 1000.0 + + def _handle_key_press(self, event): + """Handle key press - add to held keys or handle instant actions.""" + key = event.key.lower() if event.key else '' + + # Movement/look keys are tracked as held + movement_keys = {'w', 's', 'a', 'd', 'up', 'down', 'left', 'right', + 'q', 'e', 'pageup', 'pagedown', 'i', 'j', 'k', 'l'} + + if key in movement_keys: + self._held_keys.add(key) + return + + # Instant actions (not held) + # Speed (limits scale with terrain size) + if key in ('+', '='): + terrain_diagonal = np.sqrt(self.terrain_shape[0]**2 + self.terrain_shape[1]**2) + max_speed = terrain_diagonal * 0.1 # Max 10% of terrain per keystroke + self.move_speed = min(max_speed, self.move_speed * 1.2) + print(f"Speed: {self.move_speed:.1f}") + elif key == '-': + terrain_diagonal = np.sqrt(self.terrain_shape[0]**2 + self.terrain_shape[1]**2) + min_speed = terrain_diagonal * 0.001 # Min 0.1% of terrain per keystroke + self.move_speed = max(min_speed, self.move_speed / 1.2) + print(f"Speed: {self.move_speed:.1f}") + + # Toggles + elif key == 't': + self.shadows = not self.shadows + print(f"Shadows: {'ON' if self.shadows else 'OFF'}") + self._update_frame() + elif key == 'c': + self.colormap_idx = (self.colormap_idx + 1) % len(self.colormaps) + self.colormap = self.colormaps[self.colormap_idx] + print(f"Colormap: {self.colormap}") + self._update_frame() + elif key == 'g': + self._cycle_layer() + elif key == 'n': + self._jump_to_geometry(1) # Next geometry + elif key == 'p': + self._jump_to_geometry(-1) # Previous geometry + elif key == 'h': + self.show_help = not self.show_help + self._update_frame() + + # Viewshed controls + elif key == 'o': + self._place_observer() + elif key == 'v': + self._toggle_viewshed() + elif key == '[': + self._adjust_observer_elevation(-5.0) + elif key == ']': + self._adjust_observer_elevation(5.0) + + # Screenshot + elif key == 'f': + self._save_screenshot() + + # Exit + elif key in ('escape', 'x'): + self.running = False + if self._timer is not None: + self._timer.stop() + import matplotlib.pyplot as plt + plt.close(self.fig) + + def _handle_key_release(self, event): + """Handle key release - remove from held keys.""" + key = event.key.lower() if event.key else '' + self._held_keys.discard(key) + + def _tick(self): + """Process all held keys and update frame (called by timer).""" + if not self.running or not self._held_keys: + return + + # Get direction vectors (computed once per tick) + front = self._get_front() + right = self._get_right() + + # Process all held movement keys + if 'w' in self._held_keys or 'up' in self._held_keys: + self.position += front * self.move_speed + if 's' in self._held_keys or 'down' in self._held_keys: + self.position -= front * self.move_speed + if 'a' in self._held_keys or 'left' in self._held_keys: + self.position -= right * self.move_speed + if 'd' in self._held_keys or 'right' in self._held_keys: + self.position += right * self.move_speed + if 'q' in self._held_keys or 'pageup' in self._held_keys: + self.position[2] += self.move_speed + if 'e' in self._held_keys or 'pagedown' in self._held_keys: + self.position[2] -= self.move_speed + + # Process all held look keys + if 'i' in self._held_keys: + self.pitch = min(89, self.pitch + self.look_speed) + if 'k' in self._held_keys: + self.pitch = max(-89, self.pitch - self.look_speed) + if 'j' in self._held_keys: + self.yaw += self.look_speed + if 'l' in self._held_keys: + self.yaw -= self.look_speed + + # Trigger redraw + self._update_frame() + + def _cycle_layer(self): + """Cycle through GAS layer visibility modes.""" + if not self._layer_modes or self.rtx is None: + print("No geometries in scene") + return + + self._layer_mode = (self._layer_mode + 1) % len(self._layer_modes) + mode = self._layer_modes[self._layer_mode] + + if mode == 'all': + # Restore all hidden geometries + for geom_id, (verts, indices, transform) in self._hidden_geometries.items(): + self.rtx.add_geometry(geom_id, verts, indices, transform) + self._hidden_geometries.clear() + print(f"Layer: ALL ({len(self._all_geometries)} geometries)") + else: + # Hide geometries that don't match this group + # First restore any previously hidden + for geom_id, (verts, indices, transform) in self._hidden_geometries.items(): + self.rtx.add_geometry(geom_id, verts, indices, transform) + self._hidden_geometries.clear() + + # Now hide non-matching geometries + visible_count = 0 + for geom_id in self._all_geometries: + # Check if this geometry belongs to the current group + parts = geom_id.rsplit('_', 1) + base_name = parts[0] if len(parts) == 2 and parts[1].isdigit() else geom_id + + if base_name != mode and geom_id != mode: + # Hide this geometry - need to get its data first + # Note: RTX doesn't have get_geometry, so we can't truly hide/show + # For now, just report what would be visible + pass + else: + visible_count += 1 + + # Since we can't easily hide/show, just print info + print(f"Layer: {mode} ({visible_count} visible)") + + # Reset geometry index when changing layers + self._current_geom_idx = 0 + self._update_frame() + + def _jump_to_geometry(self, direction): + """Jump camera to next/previous geometry in current layer. + + Parameters + ---------- + direction : int + 1 for next, -1 for previous. + """ + if self.rtx is None: + print("No geometries in scene") + return + + # Get current layer name + mode = self._layer_modes[self._layer_mode] + + if mode == 'all': + print("Select a specific layer with G first (e.g., 'tower', 'house')") + return + + # Get positions for current layer + if mode not in self._layer_positions: + print(f"No positions for layer: {mode}") + return + + positions = self._layer_positions[mode] + if not positions: + print(f"No geometries in layer: {mode}") + return + + # Cycle through geometries + self._current_geom_idx = (self._current_geom_idx + direction) % len(positions) + x, y, z, geom_id = positions[self._current_geom_idx] + + # Position camera at geometry location, slightly above and behind + # Calculate offset based on current viewing direction + height_offset = 50 # Height above geometry + distance_back = 100 # Distance behind geometry + + # Get current forward direction (but level, no pitch) + yaw_rad = np.radians(self.yaw) + forward_level = np.array([np.cos(yaw_rad), np.sin(yaw_rad), 0], dtype=np.float32) + + # Position camera behind and above the geometry + self.position = np.array([ + x - forward_level[0] * distance_back, + y - forward_level[1] * distance_back, + z + height_offset + ], dtype=np.float32) + + # Look at the geometry + self.pitch = -15.0 # Look slightly down + + print(f"Jumped to {geom_id} ({self._current_geom_idx + 1}/{len(positions)})") + print(f" Position: ({x:.0f}, {y:.0f}, {z:.0f})") + self._update_frame() + + def _place_observer(self): + """Place a viewshed observer at the current camera position on terrain. + + The observer is placed at the camera's x,y location, projected onto + the terrain surface. This becomes the fixed point for viewshed analysis. + Observer position is stored in world coordinates (same as camera). + """ + H, W = self.terrain_shape + + # Use camera position (in world coordinates if pixel_spacing != 1.0) + cam_x = self.position[0] + cam_y = self.position[1] + + # Compute terrain bounds in world coordinates + max_x = (W - 1) * self.pixel_spacing_x + max_y = (H - 1) * self.pixel_spacing_y + + # Clamp to terrain bounds (in world coordinates) + obs_x = float(np.clip(cam_x, 0, max_x)) + obs_y = float(np.clip(cam_y, 0, max_y)) + + # Store in world coordinates (for orb rendering) + self._observer_position = (obs_x, obs_y) + + # Also compute pixel indices for display + px_x = int(obs_x / self.pixel_spacing_x) + px_y = int(obs_y / self.pixel_spacing_y) + + print(f"Observer placed at world ({obs_x:.0f}, {obs_y:.0f}), pixel ({px_x}, {px_y})") + print(f" Height: {self.viewshed_observer_elev:.0f}m above terrain") + print(f" Press V to toggle viewshed, [/] to adjust height") + + # If viewshed is already enabled, recalculate + if self.viewshed_enabled: + self._calculate_viewshed() + + self._update_frame() + + def _calculate_viewshed(self): + """Calculate viewshed from the placed observer position. + + Uses GPU ray tracing to compute visibility from the fixed observer. + Observer position is in world coordinates; this method converts to + pixel indices for the viewshed calculation. + """ + from .analysis.viewshed import _viewshed_rt + from .analysis._common import prepare_mesh + + if self._observer_position is None: + print("No observer placed. Press O to place an observer first.") + return None + + # Observer position is in world coordinates + world_x, world_y = self._observer_position + H, W = self.terrain_shape + + # Convert world coords to pixel indices + px_x = world_x / self.pixel_spacing_x + px_y = world_y / self.pixel_spacing_y + + # Validate coordinates are within terrain bounds (in pixel space) + if px_x < 0 or px_x >= W or px_y < 0 or px_y >= H: + print(f"Observer position pixel ({px_x:.1f}, {px_y:.1f}) outside terrain bounds") + return None + + print(f"Computing viewshed... (observer height: {self.viewshed_observer_elev:.0f}m)") + print(f" Raster shape: {self.raster.shape}, pixel_spacing: ({self.pixel_spacing_x:.1f}, {self.pixel_spacing_y:.1f})") + + try: + # Always use a fresh mesh for viewshed calculation + # (self.rtx might have placed meshes that interfere with viewshed rays) + print(" Building fresh terrain mesh...") + rtx = prepare_mesh(self.raster, rtx=None) + print(" Mesh built successfully") + + # Convert pixel indices to raster coords + y_coords = self.raster.indexes.get('y').values + x_coords = self.raster.indexes.get('x').values + + # Clamp to valid range and get actual coord values + x_idx = int(np.clip(px_x, 0, W - 1)) + y_idx = int(np.clip(px_y, 0, H - 1)) + x_coord = x_coords[x_idx] if x_idx < len(x_coords) else x_coords[-1] + y_coord = y_coords[y_idx] if y_idx < len(y_coords) else y_coords[-1] + + print(f" Observer at raster coords: ({x_coord:.1f}, {y_coord:.1f})") + + viewshed = _viewshed_rt( + self.raster, rtx, + x_coord, y_coord, + self.viewshed_observer_elev, + self.viewshed_target_elev + ) + + # Calculate coverage percentage + vis_data = viewshed.data + if hasattr(vis_data, 'get'): + vis_np = vis_data.get() + else: + vis_np = vis_data + visible_cells = np.sum(vis_np >= 0) + total_cells = vis_np.size + self._viewshed_coverage = 100.0 * visible_cells / total_cells + + # Cache result + self._viewshed_cache = viewshed + + print(f" Coverage: {self._viewshed_coverage:.1f}% terrain visible") + return viewshed + + except Exception as e: + import traceback + print(f"Viewshed calculation failed: {e}") + traceback.print_exc() + return None + + def _apply_viewshed_overlay(self, img): + """Apply viewshed overlay to rendered image. + + Visible areas get a teal glow, invisible areas remain unchanged. + + Parameters + ---------- + img : ndarray + RGB image array (H, W, 3) with values 0-255. + + Returns + ------- + ndarray + Image with viewshed overlay applied. + """ + if self._viewshed_cache is None: + return img + + vis_data = self._viewshed_cache.data + if hasattr(vis_data, 'get'): + vis_np = vis_data.get() + else: + vis_np = np.asarray(vis_data) + + # Resize viewshed to match render resolution + scale_y = img.shape[0] / vis_np.shape[0] + scale_x = img.shape[1] / vis_np.shape[1] + if scale_y != 1.0 or scale_x != 1.0: + try: + from scipy.ndimage import zoom + vis_resized = zoom(vis_np, (scale_y, scale_x), order=0) + except ImportError: + # Fallback: use cv2 for resizing + try: + import cv2 + vis_resized = cv2.resize(vis_np, (img.shape[1], img.shape[0]), + interpolation=cv2.INTER_NEAREST) + except ImportError: + # Last resort: nearest neighbor with numpy + y_idx = np.linspace(0, vis_np.shape[0]-1, img.shape[0]).astype(int) + x_idx = np.linspace(0, vis_np.shape[1]-1, img.shape[1]).astype(int) + vis_resized = vis_np[np.ix_(y_idx, x_idx)] + else: + vis_resized = vis_np + + # Create result image + img_float = img.astype(np.float32) + result = img_float.copy() + + # Visible areas: apply teal glow + # Teal color: RGB(0, 200, 200) - cyan/teal + visible_mask = vis_resized >= 0 + + # Intensity based on viewing angle (0-90 degrees) + # Lower angle = more direct view = brighter glow + vis_angles = np.clip(vis_resized, 0, 90) + glow_intensity = 1.0 - (vis_angles / 90.0) # 1.0 at 0°, 0.0 at 90° + glow_intensity = np.clip(glow_intensity, 0.4, 1.0) # Min glow level + + # Teal glow color + teal_r, teal_g, teal_b = 0, 220, 210 # Bright teal/cyan + + # Apply glow only to visible areas using additive blending + alpha = self.viewshed_opacity + for c, teal_val in enumerate([teal_r, teal_g, teal_b]): + channel = result[:, :, c] + glow = glow_intensity * teal_val * alpha + channel[visible_mask] = np.clip( + channel[visible_mask] * (1 - alpha * 0.3) + glow[visible_mask], + 0, 255 + ) + + return result.astype(np.uint8) + + def _toggle_viewshed(self): + """Toggle viewshed overlay on/off.""" + if self._observer_position is None: + print("No observer placed. Press O to place an observer first.") + return + + self.viewshed_enabled = not self.viewshed_enabled + + if self.viewshed_enabled: + print("Calculating viewshed...") + viewshed = self._calculate_viewshed() + if viewshed is None: + self.viewshed_enabled = False + print("Viewshed: OFF (calculation failed)") + else: + print(f"Viewshed: ON ({self._viewshed_coverage:.1f}% coverage)") + # Debug: verify viewshed cache + if self._viewshed_cache is not None: + print(f" Viewshed cache shape: {self._viewshed_cache.shape}") + else: + print(" WARNING: Viewshed cache is None!") + else: + print("Viewshed: OFF") + + self._update_frame() + + def _clear_observer(self): + """Clear the placed observer and viewshed.""" + self._observer_position = None + self._viewshed_cache = None + self.viewshed_enabled = False + print("Observer cleared") + self._update_frame() + + def _adjust_observer_elevation(self, delta): + """Adjust observer elevation for viewshed calculation.""" + self.viewshed_observer_elev = max(0, self.viewshed_observer_elev + delta) + print(f"Observer height: {self.viewshed_observer_elev:.0f}m") + + # Clear cache and recalculate viewshed if enabled + if self.viewshed_enabled and self._observer_position is not None: + self._viewshed_cache = None # Clear cache to force recalculation + self._calculate_viewshed() + self._update_frame() + + def _save_screenshot(self): + """Save current view as PNG image.""" + import datetime + timestamp = datetime.datetime.now().strftime("%Y%m%d_%H%M%S") + filename = f"rtxpy_screenshot_{timestamp}.png" + + # Pass viewshed data directly to render if enabled + viewshed_data = None + observer_pos = None + if self.viewshed_enabled and self._viewshed_cache is not None: + viewshed_data = self._viewshed_cache + if self._observer_position is not None: + observer_pos = self._observer_position + + # Render at full resolution for screenshot + from .analysis import render as render_func + img = render_func( + self.raster, + camera_position=tuple(self.position), + look_at=tuple(self._get_look_at()), + fov=self.fov, + width=self.width, + height=self.height, + sun_azimuth=self.sun_azimuth, + sun_altitude=self.sun_altitude, + shadows=self.shadows, + ambient=self.ambient, + colormap=self.colormap, + rtx=self.rtx, + viewshed_data=viewshed_data, + viewshed_opacity=self.viewshed_opacity, + observer_position=observer_pos, + pixel_spacing_x=self.pixel_spacing_x, + pixel_spacing_y=self.pixel_spacing_y, + ) + + # Convert from float [0-1] to uint8 [0-255] + img_uint8 = (np.clip(img, 0, 1) * 255).astype(np.uint8) + + # Save using PIL or matplotlib + try: + from PIL import Image + Image.fromarray(img_uint8).save(filename) + except ImportError: + import matplotlib.pyplot as plt + plt.imsave(filename, img) + + print(f"Screenshot saved: {filename}") + + def _render_frame(self): + """Render a frame using rtxpy.""" + from .analysis import render + + # Pass viewshed data directly to render if enabled + viewshed_data = None + observer_pos = None + if self.viewshed_enabled: + if self._viewshed_cache is not None: + viewshed_data = self._viewshed_cache + if self._observer_position is not None: + observer_pos = self._observer_position + else: + # Debug: viewshed enabled but no cache + if self.frame_count % 100 == 0: # Only print occasionally + print(f"[DEBUG] Viewshed enabled but cache is None") + + img = render( + self.raster, + camera_position=tuple(self.position), + look_at=tuple(self._get_look_at()), + fov=self.fov, + width=self.render_width, + height=self.render_height, + sun_azimuth=self.sun_azimuth, + sun_altitude=self.sun_altitude, + shadows=self.shadows, + ambient=self.ambient, + colormap=self.colormap, + rtx=self.rtx, + viewshed_data=viewshed_data, + viewshed_opacity=self.viewshed_opacity, + observer_position=observer_pos, + pixel_spacing_x=self.pixel_spacing_x, + pixel_spacing_y=self.pixel_spacing_y, + ) + + return img + + def _update_frame(self): + """Render and display a new frame.""" + img = self._render_frame() + self.frame_count += 1 + + # Update the image + self.im.set_data(img) + + # Update title with position info + pos = self.position + title = f"Pos: ({pos[0]:.0f}, {pos[1]:.0f}, {pos[2]:.0f}) | Speed: {self.move_speed:.0f}" + if self._observer_position is not None: + obs_x, obs_y = self._observer_position + title += f" | Observer: ({obs_x:.0f}, {obs_y:.0f}) @ {self.viewshed_observer_elev:.0f}m" + if self.viewshed_enabled: + title += f" | Coverage: {self._viewshed_coverage:.1f}%" + self.ax.set_title(title, fontsize=10, color='white') + + # Update help text + if self.show_help: + self.help_text.set_visible(True) + else: + self.help_text.set_visible(False) + + self.fig.canvas.draw_idle() + self.fig.canvas.flush_events() + + def _handle_scroll(self, event): + """Handle mouse scroll wheel for zoom.""" + if event.step > 0: + self.fov = max(20, self.fov - 3) + else: + self.fov = min(120, self.fov + 3) + print(f"FOV: {self.fov:.0f}") + self._update_frame() + + def run(self, start_position: Optional[Tuple[float, float, float]] = None, + look_at: Optional[Tuple[float, float, float]] = None): + """ + Run the interactive viewer. + + Parameters + ---------- + start_position : tuple, optional + Starting camera position (x, y, z). If None, positions + camera above terrain center. + look_at : tuple, optional + Initial look-at point. If None, looks toward terrain center. + """ + import matplotlib + import matplotlib.pyplot as plt + + # Check if we're in a Jupyter notebook and need to switch backends + current_backend = matplotlib.get_backend().lower() + in_notebook = False + try: + from IPython import get_ipython + ipy = get_ipython() + if ipy is not None and 'IPKernelApp' in ipy.config: + in_notebook = True + except (ImportError, AttributeError): + pass + + # Warn if using a non-interactive backend + non_interactive_backends = ['agg', 'module://matplotlib_inline.backend_inline', 'inline'] + if any(nb in current_backend for nb in non_interactive_backends): + if in_notebook: + print("\n" + "="*70) + print("WARNING: Matplotlib is using a non-interactive backend.") + print("Keyboard controls will NOT work with the inline backend.") + print("\nTo fix, run this BEFORE calling explore():") + print(" %matplotlib qt") + print(" OR") + print(" %matplotlib tk") + print(" OR (if ipympl is installed):") + print(" %matplotlib widget") + print("\nThen restart the kernel and run the notebook again.") + print("="*70 + "\n") + else: + print("WARNING: Non-interactive matplotlib backend detected.") + print("Keyboard controls may not work.") + + # Disable default matplotlib keybindings that conflict with our controls + for key in ['s', 'q', 'l', 'k', 'a', 'w', 'e', 'c', 'h', 't']: + if key in plt.rcParams.get('keymap.save', []): + plt.rcParams['keymap.save'].remove(key) + if key in plt.rcParams.get('keymap.quit', []): + plt.rcParams['keymap.quit'].remove(key) + if key in plt.rcParams.get('keymap.xscale', []): + plt.rcParams['keymap.xscale'].remove(key) + if key in plt.rcParams.get('keymap.yscale', []): + plt.rcParams['keymap.yscale'].remove(key) + # Clear all default keymaps to avoid conflicts + for param in list(plt.rcParams.keys()): + if param.startswith('keymap.'): + plt.rcParams[param] = [] + + H, W = self.terrain_shape + + # Set initial move speed based on terrain extent (~1% of diagonal per keystroke) + terrain_diagonal = np.sqrt(W**2 + H**2) + if self.move_speed is None: + self.move_speed = terrain_diagonal * 0.01 + + # Default start position + if start_position is None: + start_position = ( + W / 2, + -H * 0.3, + self.elev_max + terrain_diagonal * 0.1 + ) + + self.position = np.array(start_position, dtype=np.float32) + + # Calculate initial yaw/pitch from look_at + if look_at is not None: + direction = np.array(look_at) - self.position + direction = direction / (np.linalg.norm(direction) + 1e-8) + self.yaw = np.degrees(np.arctan2(direction[1], direction[0])) + self.pitch = np.degrees(np.arcsin(np.clip(direction[2], -1, 1))) + else: + # Look toward terrain center + center = np.array([W / 2, H / 2, self.elev_mean]) + direction = center - self.position + direction = direction / (np.linalg.norm(direction) + 1e-8) + self.yaw = np.degrees(np.arctan2(direction[1], direction[0])) + self.pitch = np.degrees(np.arcsin(np.clip(direction[2], -1, 1))) + + # Create figure + plt.ion() # Interactive mode + self.fig, self.ax = plt.subplots(1, 1, figsize=(self.width/100, self.height/100), dpi=100) + self.fig.patch.set_facecolor('black') + self.ax.set_facecolor('black') + self.ax.axis('off') + self.fig.subplots_adjust(left=0, right=1, top=0.95, bottom=0) + + # Render initial frame + img = self._render_frame() + self.im = self.ax.imshow(img, aspect='auto') + + # Help text + help_str = ( + "WASD/Arrows: Move | Q/E: Up/Down | IJKL: Look | Scroll: Zoom | +/-: Speed\n" + "G: Layers | N/P: Geometry | O: Place Observer | V: Toggle Viewshed | [/]: Height\n" + "T: Shadows | C: Colormap | F: Screenshot | H: Help | X: Exit" + ) + self.help_text = self.ax.text( + 0.01, 0.02, help_str, + transform=self.ax.transAxes, + fontsize=8, + color='white', + alpha=0.8, + verticalalignment='bottom', + fontfamily='monospace', + bbox=dict(boxstyle='round', facecolor='black', alpha=0.5) + ) + + # Connect event handlers + self.fig.canvas.mpl_connect('key_press_event', self._handle_key_press) + self.fig.canvas.mpl_connect('key_release_event', self._handle_key_release) + self.fig.canvas.mpl_connect('scroll_event', self._handle_scroll) + + # Set up timer for smooth key repeat + self._timer = self.fig.canvas.new_timer(interval=self._tick_interval) + self._timer.add_callback(self._tick) + self._timer.start() + + # Window title + self.fig.canvas.manager.set_window_title('rtxpy Interactive Viewer') + + print(f"\nInteractive Viewer Started") + print(f" Window: {self.width}x{self.height}") + print(f" Render: {self.render_width}x{self.render_height} ({self.render_scale:.0%})") + print(f" Terrain: {W}x{H}, elevation {self.elev_min:.0f}m - {self.elev_max:.0f}m") + print(f"\nPress H for controls, X or Esc to exit\n") + + self.running = True + self._update_frame() + + # Keep window open until closed + plt.show(block=True) + + # Clean up timer + if self._timer is not None: + self._timer.stop() + self._timer = None + + print(f"Viewer closed after {self.frame_count} frames") + + +def explore(raster, width: int = 800, height: int = 600, + render_scale: float = 0.5, + start_position: Optional[Tuple[float, float, float]] = None, + look_at: Optional[Tuple[float, float, float]] = None, + key_repeat_interval: float = 0.05, + rtx: 'RTX' = None, + pixel_spacing_x: float = 1.0, pixel_spacing_y: float = 1.0): + """ + Launch an interactive terrain viewer. + + Uses matplotlib for display - no additional dependencies required. + Keyboard controls allow flying through the terrain. + + Parameters + ---------- + raster : xarray.DataArray + Terrain raster data with cupy array. + width : int + Display width in pixels. Default is 800. + height : int + Display height in pixels. Default is 600. + render_scale : float + Render at this fraction of display size (0.25-1.0). + Lower values give higher FPS. Default is 0.5. + start_position : tuple, optional + Starting camera position (x, y, z). + look_at : tuple, optional + Initial look-at point. + key_repeat_interval : float + Minimum seconds between key repeat events (default 0.05 = 20 FPS max). + Lower values = more responsive but more GPU load. + rtx : RTX, optional + Existing RTX instance with geometries (e.g., from place_mesh). + If provided, renders the full scene including placed meshes. + pixel_spacing_x : float, optional + X spacing between pixels in world units (e.g., 30.0 for 30m/pixel). + Must match the spacing used when triangulating terrain. Default 1.0. + pixel_spacing_y : float, optional + Y spacing between pixels in world units. Default 1.0. + + Controls + -------- + - W/Up: Move forward + - S/Down: Move backward + - A/Left: Strafe left + - D/Right: Strafe right + - Q/Page Up: Move up + - E/Page Down: Move down + - I/J/K/L: Look up/left/down/right + - Scroll wheel: Zoom in/out (FOV) + - +/=: Increase speed + - -: Decrease speed + - G: Cycle geometry layers (when meshes are placed) + - N: Jump to next geometry in current layer + - P: Jump to previous geometry in current layer + - O: Place observer (for viewshed) at look-at point + - V: Toggle viewshed overlay (teal glow shows visible terrain) + - [/]: Decrease/increase observer height + - T: Toggle shadows + - C: Cycle colormap + - F: Save screenshot + - H: Toggle help overlay + - X: Exit + + Examples + -------- + >>> import rtxpy + >>> dem = xr.open_dataarray('terrain.tif') + >>> dem = dem.copy(data=cupy.asarray(dem.data)) + >>> rtxpy.explore(dem) + + >>> # Or via accessor + >>> dem.rtx.explore() + """ + viewer = InteractiveViewer( + raster, + width=width, + height=height, + render_scale=render_scale, + key_repeat_interval=key_repeat_interval, + rtx=rtx, + pixel_spacing_x=pixel_spacing_x, + pixel_spacing_y=pixel_spacing_y, + ) + viewer.run(start_position=start_position, look_at=look_at) diff --git a/rtxpy/kernel.ptx b/rtxpy/kernel.ptx index 75b5295..63d728e 100644 --- a/rtxpy/kernel.ptx +++ b/rtxpy/kernel.ptx @@ -53,11 +53,12 @@ ld.global.f32 %f8, [%rd8+28]; ld.const.u64 %rd4, [params]; mov.f32 %f9, 0f00000000; + mov.u32 %r72, 16; mov.u32 %r74, 1; mov.u32 %r76, 6; mov.u32 %r108, 0; // begin inline asm - call(%r38,%r39,%r40,%r41,%r42,%r43,%r44,%r45,%r46,%r47,%r48,%r49,%r50,%r51,%r52,%r53,%r54,%r55,%r56,%r57,%r58,%r59,%r60,%r61,%r62,%r63,%r64,%r65,%r66,%r67,%r68,%r69),_optix_trace_typed_32,(%r108,%rd4,%f1,%f2,%f3,%f4,%f5,%f6,%f7,%f8,%f9,%r74,%r108,%r108,%r74,%r108,%r76,%r111,%r112,%r113,%r114,%r115,%r116,%r108,%r108,%r108,%r108,%r108,%r108,%r108,%r108,%r108,%r108,%r108,%r108,%r108,%r108,%r108,%r108,%r108,%r108,%r108,%r108,%r108,%r108,%r108,%r108,%r108,%r108); + call(%r38,%r39,%r40,%r41,%r42,%r43,%r44,%r45,%r46,%r47,%r48,%r49,%r50,%r51,%r52,%r53,%r54,%r55,%r56,%r57,%r58,%r59,%r60,%r61,%r62,%r63,%r64,%r65,%r66,%r67,%r68,%r69),_optix_trace_typed_32,(%r108,%rd4,%f1,%f2,%f3,%f4,%f5,%f6,%f7,%f8,%f9,%r74,%r72,%r108,%r74,%r108,%r76,%r111,%r112,%r113,%r114,%r115,%r116,%r108,%r108,%r108,%r108,%r108,%r108,%r108,%r108,%r108,%r108,%r108,%r108,%r108,%r108,%r108,%r108,%r108,%r108,%r108,%r108,%r108,%r108,%r108,%r108,%r108,%r108); // end inline asm ld.const.u64 %rd9, [params+16]; cvta.to.global.u64 %rd10, %rd9; @@ -129,7 +130,7 @@ $L__BB0_4: // .globl __closesthit__chit .visible .entry __closesthit__chit() { - .reg .f32 %f<37>; + .reg .f32 %f<38>; .reg .b32 %r<19>; .reg .b64 %rd<3>; @@ -137,7 +138,7 @@ $L__BB0_4: // begin inline asm call (%f1), _optix_get_ray_tmax, (); // end inline asm - cvt.rzi.ftz.u32.f32 %r18, %f1; + cvt.rzi.u32.f32 %r18, %f1; // begin inline asm call (%rd1), _optix_get_gas_traversable_handle, (); // end inline asm @@ -153,46 +154,47 @@ $L__BB0_4: // begin inline asm call (%f3, %f4, %f5, %f6, %f7, %f8, %f9, %f10, %f11), _optix_get_triangle_vertex_data, (%rd1, %r1, %r2, %f2); // end inline asm - sub.ftz.f32 %f13, %f6, %f3; - sub.ftz.f32 %f14, %f7, %f4; - sub.ftz.f32 %f15, %f8, %f5; - sub.ftz.f32 %f16, %f9, %f3; - sub.ftz.f32 %f17, %f10, %f4; - sub.ftz.f32 %f18, %f11, %f5; - mul.ftz.f32 %f19, %f14, %f18; - mul.ftz.f32 %f20, %f15, %f17; - sub.ftz.f32 %f21, %f19, %f20; - mul.ftz.f32 %f22, %f13, %f18; - mul.ftz.f32 %f23, %f15, %f16; - sub.ftz.f32 %f24, %f22, %f23; - mul.ftz.f32 %f25, %f13, %f17; - mul.ftz.f32 %f26, %f14, %f16; - sub.ftz.f32 %f27, %f25, %f26; - mul.ftz.f32 %f28, %f24, %f24; - fma.rn.ftz.f32 %f29, %f21, %f21, %f28; - fma.rn.ftz.f32 %f30, %f27, %f27, %f29; - rsqrt.approx.ftz.f32 %f31, %f30; - mul.ftz.f32 %f32, %f31, %f21; - mul.ftz.f32 %f33, %f24, %f31; - neg.ftz.f32 %f34, %f33; - mul.ftz.f32 %f35, %f31, %f27; - cvt.rn.f32.u32 %f36, %r18; - mov.b32 %r6, %f36; + sub.f32 %f13, %f6, %f3; + sub.f32 %f14, %f7, %f4; + sub.f32 %f15, %f8, %f5; + sub.f32 %f16, %f9, %f3; + sub.f32 %f17, %f10, %f4; + sub.f32 %f18, %f11, %f5; + mul.f32 %f19, %f14, %f18; + mul.f32 %f20, %f15, %f17; + sub.f32 %f21, %f19, %f20; + mul.f32 %f22, %f13, %f18; + mul.f32 %f23, %f15, %f16; + sub.f32 %f24, %f22, %f23; + mul.f32 %f25, %f13, %f17; + mul.f32 %f26, %f14, %f16; + sub.f32 %f27, %f25, %f26; + mul.f32 %f28, %f24, %f24; + fma.rn.f32 %f29, %f21, %f21, %f28; + fma.rn.f32 %f30, %f27, %f27, %f29; + sqrt.rn.f32 %f31, %f30; + rcp.rn.f32 %f32, %f31; + mul.f32 %f33, %f32, %f21; + mul.f32 %f34, %f24, %f32; + neg.f32 %f35, %f34; + mul.f32 %f36, %f32, %f27; + cvt.rn.f32.u32 %f37, %r18; + mov.b32 %r6, %f37; mov.u32 %r5, 0; // begin inline asm call _optix_set_payload, (%r5, %r6); // end inline asm - mov.b32 %r8, %f32; + mov.b32 %r8, %f33; mov.u32 %r7, 1; // begin inline asm call _optix_set_payload, (%r7, %r8); // end inline asm - mov.b32 %r10, %f34; + mov.b32 %r10, %f35; mov.u32 %r9, 2; // begin inline asm call _optix_set_payload, (%r9, %r10); // end inline asm - mov.b32 %r12, %f35; + mov.b32 %r12, %f36; mov.u32 %r11, 3; // begin inline asm call _optix_set_payload, (%r11, %r12); diff --git a/rtxpy/mesh.py b/rtxpy/mesh.py index 514a2ac..51a884c 100644 --- a/rtxpy/mesh.py +++ b/rtxpy/mesh.py @@ -1,12 +1,14 @@ -"""Mesh utilities for terrain triangulation and STL export. +"""Mesh utilities for terrain triangulation, mesh loading, and STL export. This module provides functions for converting raster terrain data into -triangle meshes suitable for ray tracing, and for exporting meshes to STL format. +triangle meshes suitable for ray tracing, loading 3D model files (GLB, OBJ, etc.), +and exporting meshes to STL format. """ import numba as nb from numba import cuda import numpy as np +from pathlib import Path from .rtx import has_cupy @@ -32,12 +34,13 @@ def _triangulate_terrain_gpu(verts, triangles, data, H, W, scale, stride): if w != W - 1 and h != H - 1: offset = 6 * (h * (W - 1) + w) - triangles[offset + 0] = np.int32(meshMapIndex + W) + # Counter-clockwise winding for upward-facing normals (+Z) + triangles[offset + 0] = np.int32(meshMapIndex) triangles[offset + 1] = np.int32(meshMapIndex + W + 1) - triangles[offset + 2] = np.int32(meshMapIndex) - triangles[offset + 3] = np.int32(meshMapIndex + W + 1) + triangles[offset + 2] = np.int32(meshMapIndex + W) + triangles[offset + 3] = np.int32(meshMapIndex) triangles[offset + 4] = np.int32(meshMapIndex + 1) - triangles[offset + 5] = np.int32(meshMapIndex) + triangles[offset + 5] = np.int32(meshMapIndex + W + 1) @nb.njit(parallel=True) @@ -56,12 +59,13 @@ def _triangulate_terrain_cpu(verts, triangles, data, H, W, scale): if w != W - 1 and h != H - 1: offset = 6 * (h * (W - 1) + w) - triangles[offset + 0] = np.int32(meshMapIndex + W) + # Counter-clockwise winding for upward-facing normals (+Z) + triangles[offset + 0] = np.int32(meshMapIndex) triangles[offset + 1] = np.int32(meshMapIndex + W + 1) - triangles[offset + 2] = np.int32(meshMapIndex) - triangles[offset + 3] = np.int32(meshMapIndex + W + 1) + triangles[offset + 2] = np.int32(meshMapIndex + W) + triangles[offset + 3] = np.int32(meshMapIndex) triangles[offset + 4] = np.int32(meshMapIndex + 1) - triangles[offset + 5] = np.int32(meshMapIndex) + triangles[offset + 5] = np.int32(meshMapIndex + W + 1) def triangulate_terrain(verts, triangles, terrain, scale=1.0): @@ -204,3 +208,283 @@ def write_stl(filename, verts, triangles): content = np.empty(numTris * 50, np.uint8) _fill_stl_contents(content, vb, ib, numTris) f.write(content) + + +def _lazy_import_trimesh(): + """Lazily import trimesh with helpful error message.""" + try: + import trimesh + return trimesh + except ImportError: + raise ImportError( + "trimesh is required for loading GLB/glTF files. " + "Install it with: pip install trimesh" + ) + + +def load_glb(filepath, scale=1.0, swap_yz=False, center_xy=False, base_at_zero=False): + """Load a GLB/glTF mesh file and return vertices and indices for ray tracing. + + Uses trimesh to load the mesh and extracts geometry suitable for use with + RTX.add_geometry(). + + Parameters + ---------- + filepath : str or Path + Path to the GLB or glTF file. + scale : float, optional + Scale factor applied to all vertex positions. Default is 1.0. + swap_yz : bool, optional + If True, swap Y and Z coordinates. Useful when models use Y-up + convention but rtxpy expects Z-up. Default is False. + center_xy : bool, optional + If True, center the model at the XY origin. Default is False. + base_at_zero : bool, optional + If True, translate the model so its lowest Z coordinate is at 0. + Default is False. + + Returns + ------- + vertices : np.ndarray + Flat float32 array of vertex positions with shape (num_verts * 3,). + Contains x, y, z coordinates for each vertex. + indices : np.ndarray + Flat int32 array of triangle indices with shape (num_tris * 3,). + Each group of 3 indices defines a triangle. + + Examples + -------- + >>> verts, indices = load_glb('model.glb', scale=0.1, swap_yz=True) + >>> rtx.add_geometry('model', verts, indices) + + >>> # With instancing + >>> verts, indices = load_glb('tower.glb', swap_yz=True, base_at_zero=True) + >>> transforms = make_transforms_on_terrain(positions, terrain) + >>> rtx.add_geometry('towers', verts, indices, transforms=transforms) + + Notes + ----- + GLB files may contain multiple meshes in a scene. This function combines + all meshes into a single vertex/index buffer. Materials and textures are + ignored - only geometry is extracted. + """ + trimesh = _lazy_import_trimesh() + + filepath = Path(filepath) + if not filepath.exists(): + raise FileNotFoundError(f"File not found: {filepath}") + + # Load the scene/mesh + scene_or_mesh = trimesh.load(filepath) + + # Handle scenes with multiple meshes + if isinstance(scene_or_mesh, trimesh.Scene): + # Combine all meshes in the scene + meshes = [] + for name, geometry in scene_or_mesh.geometry.items(): + if isinstance(geometry, trimesh.Trimesh): + meshes.append(geometry) + + if not meshes: + raise ValueError(f"No triangle meshes found in: {filepath}") + + # Concatenate all meshes + mesh = trimesh.util.concatenate(meshes) + else: + mesh = scene_or_mesh + + if not isinstance(mesh, trimesh.Trimesh): + raise ValueError(f"Could not extract triangle mesh from: {filepath}") + + # Get vertices and faces + vertices = mesh.vertices.copy().astype(np.float32) + faces = mesh.faces.copy().astype(np.int32) + + # Apply coordinate transforms + if swap_yz: + # Swap Y and Z (convert Y-up to Z-up) + vertices[:, [1, 2]] = vertices[:, [2, 1]] + + if center_xy: + # Center at XY origin + center = (vertices[:, :2].min(axis=0) + vertices[:, :2].max(axis=0)) / 2 + vertices[:, 0] -= center[0] + vertices[:, 1] -= center[1] + + if base_at_zero: + # Move base to Z=0 + vertices[:, 2] -= vertices[:, 2].min() + + # Apply scale + if scale != 1.0: + vertices *= scale + + # Flatten arrays for rtxpy format + vertices_flat = vertices.flatten().astype(np.float32) + indices_flat = faces.flatten().astype(np.int32) + + return vertices_flat, indices_flat + + +def load_mesh(filepath, scale=1.0, swap_yz=False, center_xy=False, base_at_zero=False): + """Load a mesh file in any supported format (GLB, glTF, OBJ, STL, PLY, etc.). + + This is a convenience wrapper that uses trimesh to load meshes in various + formats. For GLB/glTF files specifically, you can also use load_glb(). + + Parameters + ---------- + filepath : str or Path + Path to the mesh file. Supported formats include: + GLB, glTF, OBJ, STL, PLY, OFF, and others supported by trimesh. + scale : float, optional + Scale factor applied to all vertex positions. Default is 1.0. + swap_yz : bool, optional + If True, swap Y and Z coordinates. Useful when models use Y-up + convention but rtxpy expects Z-up. Default is False. + center_xy : bool, optional + If True, center the model at the XY origin. Default is False. + base_at_zero : bool, optional + If True, translate the model so its lowest Z coordinate is at 0. + Default is False. + + Returns + ------- + vertices : np.ndarray + Flat float32 array of vertex positions with shape (num_verts * 3,). + indices : np.ndarray + Flat int32 array of triangle indices with shape (num_tris * 3,). + + See Also + -------- + load_glb : Specifically for GLB/glTF files. + """ + return load_glb(filepath, scale=scale, swap_yz=swap_yz, + center_xy=center_xy, base_at_zero=base_at_zero) + + +def make_transform(x=0.0, y=0.0, z=0.0, scale=1.0, rotation_z=0.0): + """Create a 3x4 transform matrix for positioning an instance. + + The transform matrix is stored as a flat list of 12 floats in row-major order, + representing a 3x4 matrix [R|T] where R is the 3x3 rotation/scale matrix + and T is the translation vector. + + Parameters + ---------- + x : float, optional + X position. Default is 0. + y : float, optional + Y position. Default is 0. + z : float, optional + Z position (elevation). Default is 0. + scale : float, optional + Uniform scale factor. Default is 1.0. + rotation_z : float, optional + Rotation around the Z axis in radians. Default is 0. + + Returns + ------- + list of float + 12-element list representing the 3x4 transform matrix in row-major order: + [r00, r01, r02, tx, r10, r11, r12, ty, r20, r21, r22, tz] + + Examples + -------- + >>> transform = make_transform(x=100, y=50, z=200) + >>> rtx.add_geometry("obj", verts, indices, transforms=[transform]) + + >>> # With rotation and scale + >>> transform = make_transform(x=10, y=20, z=5, scale=2.0, rotation_z=np.pi/4) + """ + cos_z = np.cos(rotation_z) + sin_z = np.sin(rotation_z) + + # Rotation matrix around Z axis, with scale + # [cos -sin 0] [s 0 0] [s*cos -s*sin 0] + # [sin cos 0] * [0 s 0] = [s*sin s*cos 0] + # [0 0 1] [0 0 s] [0 0 s] + r00 = scale * cos_z + r01 = -scale * sin_z + r02 = 0.0 + r10 = scale * sin_z + r11 = scale * cos_z + r12 = 0.0 + r20 = 0.0 + r21 = 0.0 + r22 = scale + + return [r00, r01, r02, float(x), + r10, r11, r12, float(y), + r20, r21, r22, float(z)] + + +def make_transforms_on_terrain(positions, terrain, scale=1.0, rotation_z=0.0): + """Create transform matrices for placing objects on terrain. + + For each (x, y) position, samples the terrain elevation and creates + a transform matrix that places an object at that location on the terrain surface. + + Parameters + ---------- + positions : list of tuple + List of (x, y) positions in terrain pixel coordinates. + terrain : array-like + 2D terrain elevation array with shape (H, W). + scale : float, optional + Uniform scale factor for all instances. Default is 1.0. + rotation_z : float or str, optional + Rotation around Z axis. Can be: + - A float: same rotation (in radians) for all instances + - 'random': random rotation for each instance + Default is 0.0. + + Returns + ------- + list of list + List of 12-element transform matrices, one per position. + + Examples + -------- + >>> positions = [(10, 20), (30, 40), (50, 60)] + >>> transforms = make_transforms_on_terrain(positions, terrain) + >>> rtx.add_geometry("trees", tree_verts, tree_indices, transforms=transforms) + + >>> # With random rotations + >>> transforms = make_transforms_on_terrain(positions, terrain, rotation_z='random') + """ + # Handle xarray DataArray + if hasattr(terrain, 'data'): + terrain_data = terrain.data + if has_cupy: + import cupy + if isinstance(terrain_data, cupy.ndarray): + terrain_data = cupy.asnumpy(terrain_data) + else: + terrain_data = terrain + + if has_cupy: + import cupy + if isinstance(terrain_data, cupy.ndarray): + terrain_data = cupy.asnumpy(terrain_data) + + H, W = terrain_data.shape + transforms = [] + + for i, (x, y) in enumerate(positions): + # Sample terrain elevation at this position + # Clamp to valid range + ix = int(np.clip(x, 0, W - 1)) + iy = int(np.clip(y, 0, H - 1)) + z = float(terrain_data[iy, ix]) + + # Determine rotation + if rotation_z == 'random': + rot = np.random.uniform(0, 2 * np.pi) + else: + rot = float(rotation_z) + + transform = make_transform(x=x, y=y, z=z, scale=scale, rotation_z=rot) + transforms.append(transform) + + return transforms diff --git a/rtxpy/rtx.py b/rtxpy/rtx.py index e229a5b..6172004 100644 --- a/rtxpy/rtx.py +++ b/rtxpy/rtx.py @@ -1181,6 +1181,22 @@ def has_geometry(self, geometry_id: str) -> bool: """ return geometry_id in self._geom_state.gas_entries + def get_geometry_transform(self, geometry_id: str) -> Optional[List[float]]: + """ + Get the transform of a geometry. + + Args: + geometry_id: The ID of the geometry. + + Returns: + 12-float list representing the 3x4 transform matrix, or None if not found. + Format: [Xx, Xy, Xz, Tx, Yx, Yy, Yz, Ty, Zx, Zy, Zz, Tz] + The translation (position) is at indices 3, 7, 11 (Tx, Ty, Tz). + """ + if geometry_id not in self._geom_state.gas_entries: + return None + return self._geom_state.gas_entries[geometry_id].transform.copy() + def clear_scene(self) -> None: """ Remove all geometries and reset to single-GAS mode. diff --git a/rtxpy/tests/test_animation.py b/rtxpy/tests/test_animation.py new file mode 100644 index 0000000..db32142 --- /dev/null +++ b/rtxpy/tests/test_animation.py @@ -0,0 +1,477 @@ +"""Tests for animation functions (flyover and view).""" + +import numpy as np +import pytest +import os +import tempfile + +from rtxpy.rtx import has_cupy + +# Skip all tests if cupy is not available (required for analysis) +pytestmark = pytest.mark.skipif(not has_cupy, reason="cupy required for animation") + + +def has_xarray(): + """Check if xarray is available.""" + try: + import xarray # noqa: F401 + return True + except ImportError: + return False + + +def has_scipy(): + """Check if scipy is available.""" + try: + import scipy # noqa: F401 + return True + except ImportError: + return False + + +def has_matplotlib(): + """Check if matplotlib is available.""" + try: + import matplotlib # noqa: F401 + return True + except ImportError: + return False + + +def has_imageio(): + """Check if imageio is available.""" + try: + import imageio # noqa: F401 + return True + except ImportError: + return False + + +@pytest.fixture +def sample_terrain(): + """Create a sample terrain DataArray for testing.""" + if not has_xarray(): + pytest.skip("xarray not available") + + import xarray as xr + import cupy + + # Create a gaussian hill terrain + H, W = 100, 100 + y = np.linspace(0, 99, H) + x = np.linspace(0, 99, W) + yy, xx = np.meshgrid(y, x, indexing='ij') + # Gaussian hill centered at (50, 50) + elevation = 100 * np.exp(-((xx - 50) ** 2 + (yy - 50) ** 2) / 500) + elevation = elevation.astype(np.float32) + + da = xr.DataArray( + cupy.array(elevation), + dims=['y', 'x'], + coords={'y': y, 'x': x}, + name='elevation' + ) + return da + + +class TestFlyoverBasic: + """Basic tests for flyover function.""" + + @pytest.mark.skipif(not has_xarray(), reason="xarray not available") + @pytest.mark.skipif(not has_scipy(), reason="scipy not available") + @pytest.mark.skipif(not has_matplotlib(), reason="matplotlib not available") + @pytest.mark.skipif(not has_imageio(), reason="imageio not available") + def test_flyover_basic(self, sample_terrain): + """Test basic flyover animation creation.""" + from rtxpy import flyover + + with tempfile.TemporaryDirectory() as tmpdir: + output_path = os.path.join(tmpdir, 'flyover.gif') + + result = flyover( + sample_terrain, + output_path=output_path, + duration=2.0, # Short for testing + fps=5.0, + width=160, + height=120, + ) + + assert result == output_path + assert os.path.exists(output_path) + # Verify file size is non-zero + assert os.path.getsize(output_path) > 0 + + @pytest.mark.skipif(not has_xarray(), reason="xarray not available") + @pytest.mark.skipif(not has_scipy(), reason="scipy not available") + @pytest.mark.skipif(not has_matplotlib(), reason="matplotlib not available") + @pytest.mark.skipif(not has_imageio(), reason="imageio not available") + def test_flyover_with_fov_range(self, sample_terrain): + """Test flyover with dynamic zoom (FOV range).""" + from rtxpy import flyover + + with tempfile.TemporaryDirectory() as tmpdir: + output_path = os.path.join(tmpdir, 'flyover_zoom.gif') + + result = flyover( + sample_terrain, + output_path=output_path, + duration=2.0, + fps=5.0, + width=160, + height=120, + fov_range=(40, 80), # Dynamic zoom + ) + + assert os.path.exists(output_path) + + @pytest.mark.skipif(not has_xarray(), reason="xarray not available") + @pytest.mark.skipif(not has_scipy(), reason="scipy not available") + @pytest.mark.skipif(not has_matplotlib(), reason="matplotlib not available") + @pytest.mark.skipif(not has_imageio(), reason="imageio not available") + def test_flyover_custom_orbit(self, sample_terrain): + """Test flyover with custom orbit parameters.""" + from rtxpy import flyover + + with tempfile.TemporaryDirectory() as tmpdir: + output_path = os.path.join(tmpdir, 'flyover_orbit.gif') + + result = flyover( + sample_terrain, + output_path=output_path, + duration=2.0, + fps=5.0, + width=160, + height=120, + orbit_scale=0.8, + altitude_offset=200.0, + ) + + assert os.path.exists(output_path) + + +class TestFlyoverAccessor: + """Tests for flyover via xarray accessor.""" + + @pytest.mark.skipif(not has_xarray(), reason="xarray not available") + @pytest.mark.skipif(not has_scipy(), reason="scipy not available") + @pytest.mark.skipif(not has_matplotlib(), reason="matplotlib not available") + @pytest.mark.skipif(not has_imageio(), reason="imageio not available") + def test_accessor_flyover(self, sample_terrain): + """Test flyover via accessor interface.""" + with tempfile.TemporaryDirectory() as tmpdir: + output_path = os.path.join(tmpdir, 'flyover_accessor.gif') + + result = sample_terrain.rtx.flyover( + output_path, + duration=2.0, + fps=5.0, + width=160, + height=120, + ) + + assert result == output_path + assert os.path.exists(output_path) + + @pytest.mark.skipif(not has_xarray(), reason="xarray not available") + @pytest.mark.skipif(not has_scipy(), reason="scipy not available") + @pytest.mark.skipif(not has_matplotlib(), reason="matplotlib not available") + @pytest.mark.skipif(not has_imageio(), reason="imageio not available") + def test_accessor_flyover_with_options(self, sample_terrain): + """Test flyover via accessor with various options.""" + with tempfile.TemporaryDirectory() as tmpdir: + output_path = os.path.join(tmpdir, 'flyover_options.gif') + + result = sample_terrain.rtx.flyover( + output_path, + duration=2.0, + fps=5.0, + width=160, + height=120, + shadows=True, + colormap='viridis', + fov_range=(30, 70), + ) + + assert os.path.exists(output_path) + + +class TestViewBasic: + """Basic tests for view function.""" + + @pytest.mark.skipif(not has_xarray(), reason="xarray not available") + @pytest.mark.skipif(not has_scipy(), reason="scipy not available") + @pytest.mark.skipif(not has_matplotlib(), reason="matplotlib not available") + @pytest.mark.skipif(not has_imageio(), reason="imageio not available") + def test_view_basic(self, sample_terrain): + """Test basic view animation creation.""" + from rtxpy import view + + with tempfile.TemporaryDirectory() as tmpdir: + output_path = os.path.join(tmpdir, 'view.gif') + + result = view( + sample_terrain, + x=50, + y=50, + z=150, + output_path=output_path, + duration=2.0, + fps=6.0, + width=160, + height=120, + ) + + assert result == output_path + assert os.path.exists(output_path) + assert os.path.getsize(output_path) > 0 + + @pytest.mark.skipif(not has_xarray(), reason="xarray not available") + @pytest.mark.skipif(not has_scipy(), reason="scipy not available") + @pytest.mark.skipif(not has_matplotlib(), reason="matplotlib not available") + @pytest.mark.skipif(not has_imageio(), reason="imageio not available") + def test_view_custom_look_params(self, sample_terrain): + """Test view with custom look distance and angle.""" + from rtxpy import view + + with tempfile.TemporaryDirectory() as tmpdir: + output_path = os.path.join(tmpdir, 'view_look.gif') + + result = view( + sample_terrain, + x=50, + y=50, + z=150, + output_path=output_path, + duration=2.0, + fps=6.0, + width=160, + height=120, + look_distance=500.0, + look_down_angle=20.0, + ) + + assert os.path.exists(output_path) + + @pytest.mark.skipif(not has_xarray(), reason="xarray not available") + @pytest.mark.skipif(not has_scipy(), reason="scipy not available") + @pytest.mark.skipif(not has_matplotlib(), reason="matplotlib not available") + @pytest.mark.skipif(not has_imageio(), reason="imageio not available") + def test_view_from_terrain_surface(self, sample_terrain): + """Test view from terrain surface with height offset.""" + from rtxpy import view + + with tempfile.TemporaryDirectory() as tmpdir: + output_path = os.path.join(tmpdir, 'view_surface.gif') + + # Get terrain elevation at viewpoint + terrain_data = sample_terrain.data + if hasattr(terrain_data, 'get'): # cupy array + terrain_data = terrain_data.get() + else: + terrain_data = np.asarray(terrain_data) + + x, y = 50, 50 + terrain_elev = terrain_data[int(y), int(x)] + observer_height = 10 # 10 units above terrain + + result = view( + sample_terrain, + x=x, + y=y, + z=terrain_elev + observer_height, + output_path=output_path, + duration=2.0, + fps=6.0, + width=160, + height=120, + ) + + assert os.path.exists(output_path) + + +class TestViewAccessor: + """Tests for view via xarray accessor.""" + + @pytest.mark.skipif(not has_xarray(), reason="xarray not available") + @pytest.mark.skipif(not has_scipy(), reason="scipy not available") + @pytest.mark.skipif(not has_matplotlib(), reason="matplotlib not available") + @pytest.mark.skipif(not has_imageio(), reason="imageio not available") + def test_accessor_view(self, sample_terrain): + """Test view via accessor interface.""" + with tempfile.TemporaryDirectory() as tmpdir: + output_path = os.path.join(tmpdir, 'view_accessor.gif') + + result = sample_terrain.rtx.view( + x=50, + y=50, + z=150, + output_path=output_path, + duration=2.0, + fps=6.0, + width=160, + height=120, + ) + + assert result == output_path + assert os.path.exists(output_path) + + @pytest.mark.skipif(not has_xarray(), reason="xarray not available") + @pytest.mark.skipif(not has_scipy(), reason="scipy not available") + @pytest.mark.skipif(not has_matplotlib(), reason="matplotlib not available") + @pytest.mark.skipif(not has_imageio(), reason="imageio not available") + def test_accessor_view_with_options(self, sample_terrain): + """Test view via accessor with various options.""" + with tempfile.TemporaryDirectory() as tmpdir: + output_path = os.path.join(tmpdir, 'view_options.gif') + + result = sample_terrain.rtx.view( + x=50, + y=50, + z=150, + output_path=output_path, + duration=2.0, + fps=6.0, + width=160, + height=120, + shadows=True, + colormap='terrain', + fov=60, + ) + + assert os.path.exists(output_path) + + +class TestAnimationGifValidity: + """Tests to verify generated GIFs are valid.""" + + @pytest.mark.skipif(not has_xarray(), reason="xarray not available") + @pytest.mark.skipif(not has_scipy(), reason="scipy not available") + @pytest.mark.skipif(not has_matplotlib(), reason="matplotlib not available") + @pytest.mark.skipif(not has_imageio(), reason="imageio not available") + def test_flyover_gif_readable(self, sample_terrain): + """Test that flyover GIF can be read back.""" + import imageio + + with tempfile.TemporaryDirectory() as tmpdir: + output_path = os.path.join(tmpdir, 'flyover.gif') + + sample_terrain.rtx.flyover( + output_path, + duration=2.0, + fps=5.0, + width=160, + height=120, + ) + + # Read back the GIF + reader = imageio.get_reader(output_path) + frames = list(reader) + reader.close() + + # Should have frames + assert len(frames) >= 2 + # Each frame should be correct size + for frame in frames: + assert frame.shape[0] == 120 # height + assert frame.shape[1] == 160 # width + assert frame.shape[2] in [3, 4] # RGB or RGBA + + @pytest.mark.skipif(not has_xarray(), reason="xarray not available") + @pytest.mark.skipif(not has_scipy(), reason="scipy not available") + @pytest.mark.skipif(not has_matplotlib(), reason="matplotlib not available") + @pytest.mark.skipif(not has_imageio(), reason="imageio not available") + def test_view_gif_readable(self, sample_terrain): + """Test that view GIF can be read back.""" + import imageio + + with tempfile.TemporaryDirectory() as tmpdir: + output_path = os.path.join(tmpdir, 'view.gif') + + sample_terrain.rtx.view( + x=50, + y=50, + z=150, + output_path=output_path, + duration=2.0, + fps=6.0, + width=160, + height=120, + ) + + # Read back the GIF + reader = imageio.get_reader(output_path) + frames = list(reader) + reader.close() + + # Should have frames + assert len(frames) >= 2 + # Each frame should be correct size + for frame in frames: + assert frame.shape[0] == 120 + assert frame.shape[1] == 160 + + +class TestAnimationFrameCount: + """Tests to verify animation frame counts.""" + + @pytest.mark.skipif(not has_xarray(), reason="xarray not available") + @pytest.mark.skipif(not has_scipy(), reason="scipy not available") + @pytest.mark.skipif(not has_matplotlib(), reason="matplotlib not available") + @pytest.mark.skipif(not has_imageio(), reason="imageio not available") + def test_flyover_frame_count(self, sample_terrain): + """Test flyover produces correct number of frames.""" + import imageio + + with tempfile.TemporaryDirectory() as tmpdir: + output_path = os.path.join(tmpdir, 'flyover.gif') + + duration = 3.0 + fps = 5.0 + expected_frames = int(duration * fps) + + sample_terrain.rtx.flyover( + output_path, + duration=duration, + fps=fps, + width=80, + height=60, + ) + + reader = imageio.get_reader(output_path) + frames = list(reader) + reader.close() + + assert len(frames) == expected_frames + + @pytest.mark.skipif(not has_xarray(), reason="xarray not available") + @pytest.mark.skipif(not has_scipy(), reason="scipy not available") + @pytest.mark.skipif(not has_matplotlib(), reason="matplotlib not available") + @pytest.mark.skipif(not has_imageio(), reason="imageio not available") + def test_view_frame_count(self, sample_terrain): + """Test view produces correct number of frames.""" + import imageio + + with tempfile.TemporaryDirectory() as tmpdir: + output_path = os.path.join(tmpdir, 'view.gif') + + duration = 2.0 + fps = 8.0 + expected_frames = int(duration * fps) + + sample_terrain.rtx.view( + x=50, + y=50, + z=150, + output_path=output_path, + duration=duration, + fps=fps, + width=80, + height=60, + ) + + reader = imageio.get_reader(output_path) + frames = list(reader) + reader.close() + + assert len(frames) == expected_frames diff --git a/rtxpy/tests/test_render.py b/rtxpy/tests/test_render.py new file mode 100644 index 0000000..77d6d59 --- /dev/null +++ b/rtxpy/tests/test_render.py @@ -0,0 +1,640 @@ +"""Tests for render function (perspective camera terrain rendering).""" + +import numpy as np +import pytest +import os +import tempfile + +from rtxpy.rtx import has_cupy + +# Skip all tests if cupy is not available (required for analysis) +pytestmark = pytest.mark.skipif(not has_cupy, reason="cupy required for render") + + +def has_xarray(): + """Check if xarray is available.""" + try: + import xarray # noqa: F401 + return True + except ImportError: + return False + + +def has_scipy(): + """Check if scipy is available.""" + try: + import scipy # noqa: F401 + return True + except ImportError: + return False + + +def has_matplotlib(): + """Check if matplotlib is available.""" + try: + import matplotlib # noqa: F401 + return True + except ImportError: + return False + + +def has_pil(): + """Check if PIL/Pillow is available.""" + try: + from PIL import Image # noqa: F401 + return True + except ImportError: + return False + + +@pytest.fixture +def sample_terrain(): + """Create a sample terrain DataArray for testing.""" + if not has_xarray(): + pytest.skip("xarray not available") + + import xarray as xr + import cupy + + # Create a gaussian hill terrain + H, W = 100, 100 + y = np.linspace(0, 99, H) + x = np.linspace(0, 99, W) + yy, xx = np.meshgrid(y, x, indexing='ij') + # Gaussian hill centered at (50, 50) + elevation = 100 * np.exp(-((xx - 50) ** 2 + (yy - 50) ** 2) / 500) + elevation = elevation.astype(np.float32) + + da = xr.DataArray( + cupy.array(elevation), + dims=['y', 'x'], + coords={'y': y, 'x': x}, + name='elevation' + ) + return da + + +class TestRenderBasic: + """Basic tests for render function.""" + + @pytest.mark.skipif(not has_xarray(), reason="xarray not available") + @pytest.mark.skipif(not has_scipy(), reason="scipy not available") + @pytest.mark.skipif(not has_matplotlib(), reason="matplotlib not available") + def test_render_basic(self, sample_terrain): + """Test basic render output.""" + from rtxpy import render + + result = render( + sample_terrain, + camera_position=(50, 0, 150), + look_at=(50, 50, 0), + width=320, + height=240, + ) + + assert result is not None + assert result.shape == (240, 320, 3) + assert result.dtype == np.float32 + + @pytest.mark.skipif(not has_xarray(), reason="xarray not available") + @pytest.mark.skipif(not has_scipy(), reason="scipy not available") + @pytest.mark.skipif(not has_matplotlib(), reason="matplotlib not available") + def test_render_output_range(self, sample_terrain): + """Test that render output values are in [0, 1] range.""" + from rtxpy import render + + result = render( + sample_terrain, + camera_position=(50, 0, 150), + look_at=(50, 50, 0), + width=320, + height=240, + ) + + # Check no NaN or inf + assert not np.any(np.isnan(result)) + assert not np.any(np.isinf(result)) + + # Check range + assert np.all(result >= 0) + assert np.all(result <= 1) + + @pytest.mark.skipif(not has_xarray(), reason="xarray not available") + @pytest.mark.skipif(not has_scipy(), reason="scipy not available") + @pytest.mark.skipif(not has_matplotlib(), reason="matplotlib not available") + def test_render_with_alpha(self, sample_terrain): + """Test render with alpha channel.""" + from rtxpy import render + + result = render( + sample_terrain, + camera_position=(50, 0, 150), + look_at=(50, 50, 0), + width=320, + height=240, + alpha=True, + ) + + assert result.shape == (240, 320, 4) + # Alpha should be 0 or 1 + assert np.all((result[:, :, 3] == 0) | (result[:, :, 3] == 1)) + + +class TestRenderLighting: + """Tests for render lighting and shadows.""" + + @pytest.mark.skipif(not has_xarray(), reason="xarray not available") + @pytest.mark.skipif(not has_scipy(), reason="scipy not available") + @pytest.mark.skipif(not has_matplotlib(), reason="matplotlib not available") + def test_render_with_shadows(self, sample_terrain): + """Test render with shadow casting.""" + from rtxpy import render + + result = render( + sample_terrain, + camera_position=(50, 0, 150), + look_at=(50, 50, 0), + width=320, + height=240, + shadows=True, + ) + + assert result is not None + assert result.shape == (240, 320, 3) + + @pytest.mark.skipif(not has_xarray(), reason="xarray not available") + @pytest.mark.skipif(not has_scipy(), reason="scipy not available") + @pytest.mark.skipif(not has_matplotlib(), reason="matplotlib not available") + def test_render_without_shadows(self, sample_terrain): + """Test render without shadow casting.""" + from rtxpy import render + + result = render( + sample_terrain, + camera_position=(50, 0, 150), + look_at=(50, 50, 0), + width=320, + height=240, + shadows=False, + ) + + assert result is not None + assert result.shape == (240, 320, 3) + + @pytest.mark.skipif(not has_xarray(), reason="xarray not available") + @pytest.mark.skipif(not has_scipy(), reason="scipy not available") + @pytest.mark.skipif(not has_matplotlib(), reason="matplotlib not available") + def test_render_custom_sun_position(self, sample_terrain): + """Test render with custom sun position.""" + from rtxpy import render + + result = render( + sample_terrain, + camera_position=(50, 0, 150), + look_at=(50, 50, 0), + width=320, + height=240, + sun_azimuth=90, + sun_altitude=30, + ) + + assert result is not None + assert result.shape == (240, 320, 3) + + @pytest.mark.skipif(not has_xarray(), reason="xarray not available") + @pytest.mark.skipif(not has_scipy(), reason="scipy not available") + @pytest.mark.skipif(not has_matplotlib(), reason="matplotlib not available") + def test_render_high_ambient(self, sample_terrain): + """Test render with high ambient light.""" + from rtxpy import render + + result = render( + sample_terrain, + camera_position=(50, 0, 150), + look_at=(50, 50, 0), + width=320, + height=240, + ambient=0.8, + ) + + assert result is not None + # With high ambient, average brightness should be higher + assert np.mean(result) > 0.3 + + +class TestRenderColormap: + """Tests for render colormap functionality.""" + + @pytest.mark.skipif(not has_xarray(), reason="xarray not available") + @pytest.mark.skipif(not has_scipy(), reason="scipy not available") + @pytest.mark.skipif(not has_matplotlib(), reason="matplotlib not available") + def test_render_terrain_colormap(self, sample_terrain): + """Test render with terrain colormap.""" + from rtxpy import render + + result = render( + sample_terrain, + camera_position=(50, 0, 150), + look_at=(50, 50, 0), + width=320, + height=240, + colormap='terrain', + ) + + assert result is not None + # Terrain colormap should produce color variation + assert result.shape == (240, 320, 3) + + @pytest.mark.skipif(not has_xarray(), reason="xarray not available") + @pytest.mark.skipif(not has_scipy(), reason="scipy not available") + @pytest.mark.skipif(not has_matplotlib(), reason="matplotlib not available") + def test_render_hillshade_colormap(self, sample_terrain): + """Test render with hillshade (grayscale) colormap.""" + from rtxpy import render + + result = render( + sample_terrain, + camera_position=(50, 0, 150), + look_at=(50, 50, 0), + width=320, + height=240, + colormap='hillshade', + ) + + assert result is not None + assert result.shape == (240, 320, 3) + # With hillshade colormap, terrain pixels should be grayscale (R=G=B) + # Sky pixels have a different color, so we need to check only terrain hits + # Find pixels where we have terrain hits (not sky) + # Sky has specific color (0.6, 0.75, 0.9) - terrain will be different + # Just verify the render completes and has valid values + assert not np.any(np.isnan(result)) + assert np.all(result >= 0) and np.all(result <= 1) + + @pytest.mark.skipif(not has_xarray(), reason="xarray not available") + @pytest.mark.skipif(not has_scipy(), reason="scipy not available") + @pytest.mark.skipif(not has_matplotlib(), reason="matplotlib not available") + def test_render_viridis_colormap(self, sample_terrain): + """Test render with viridis colormap.""" + from rtxpy import render + + result = render( + sample_terrain, + camera_position=(50, 0, 150), + look_at=(50, 50, 0), + width=320, + height=240, + colormap='viridis', + ) + + assert result is not None + assert result.shape == (240, 320, 3) + + @pytest.mark.skipif(not has_xarray(), reason="xarray not available") + @pytest.mark.skipif(not has_scipy(), reason="scipy not available") + @pytest.mark.skipif(not has_matplotlib(), reason="matplotlib not available") + def test_render_invalid_colormap(self, sample_terrain): + """Test that invalid colormap raises ValueError.""" + from rtxpy import render + + with pytest.raises(ValueError, match="Unknown colormap"): + render( + sample_terrain, + camera_position=(50, 0, 150), + look_at=(50, 50, 0), + width=320, + height=240, + colormap='not_a_real_colormap', + ) + + @pytest.mark.skipif(not has_xarray(), reason="xarray not available") + @pytest.mark.skipif(not has_scipy(), reason="scipy not available") + @pytest.mark.skipif(not has_matplotlib(), reason="matplotlib not available") + def test_render_custom_color_range(self, sample_terrain): + """Test render with custom elevation color range.""" + from rtxpy import render + + result = render( + sample_terrain, + camera_position=(50, 0, 150), + look_at=(50, 50, 0), + width=320, + height=240, + color_range=(0, 200), + ) + + assert result is not None + assert result.shape == (240, 320, 3) + + +class TestRenderFog: + """Tests for render fog/atmosphere effects.""" + + @pytest.mark.skipif(not has_xarray(), reason="xarray not available") + @pytest.mark.skipif(not has_scipy(), reason="scipy not available") + @pytest.mark.skipif(not has_matplotlib(), reason="matplotlib not available") + def test_render_with_fog(self, sample_terrain): + """Test render with fog enabled.""" + from rtxpy import render + + result = render( + sample_terrain, + camera_position=(50, 0, 150), + look_at=(50, 50, 0), + width=320, + height=240, + fog_density=0.01, + ) + + assert result is not None + assert result.shape == (240, 320, 3) + + @pytest.mark.skipif(not has_xarray(), reason="xarray not available") + @pytest.mark.skipif(not has_scipy(), reason="scipy not available") + @pytest.mark.skipif(not has_matplotlib(), reason="matplotlib not available") + def test_render_custom_fog_color(self, sample_terrain): + """Test render with custom fog color.""" + from rtxpy import render + + result = render( + sample_terrain, + camera_position=(50, 0, 150), + look_at=(50, 50, 0), + width=320, + height=240, + fog_density=0.05, + fog_color=(1.0, 0.9, 0.8), + ) + + assert result is not None + assert result.shape == (240, 320, 3) + + +class TestRenderCamera: + """Tests for render camera positioning.""" + + @pytest.mark.skipif(not has_xarray(), reason="xarray not available") + @pytest.mark.skipif(not has_scipy(), reason="scipy not available") + @pytest.mark.skipif(not has_matplotlib(), reason="matplotlib not available") + def test_render_different_angles(self, sample_terrain): + """Test render from different camera angles.""" + from rtxpy import render + + # Top-down view + result1 = render( + sample_terrain, + camera_position=(50, 50, 200), + look_at=(50, 50, 0), + width=320, + height=240, + ) + + # Side view + result2 = render( + sample_terrain, + camera_position=(0, 50, 50), + look_at=(50, 50, 50), + width=320, + height=240, + ) + + assert result1 is not None + assert result2 is not None + # Results should be different + assert not np.allclose(result1, result2) + + @pytest.mark.skipif(not has_xarray(), reason="xarray not available") + @pytest.mark.skipif(not has_scipy(), reason="scipy not available") + @pytest.mark.skipif(not has_matplotlib(), reason="matplotlib not available") + def test_render_custom_fov(self, sample_terrain): + """Test render with custom field of view.""" + from rtxpy import render + + # Narrow FOV (telephoto) + result1 = render( + sample_terrain, + camera_position=(50, 0, 150), + look_at=(50, 50, 0), + width=320, + height=240, + fov=30, + ) + + # Wide FOV + result2 = render( + sample_terrain, + camera_position=(50, 0, 150), + look_at=(50, 50, 0), + width=320, + height=240, + fov=90, + ) + + assert result1 is not None + assert result2 is not None + # Results should be different + assert not np.allclose(result1, result2) + + @pytest.mark.skipif(not has_xarray(), reason="xarray not available") + @pytest.mark.skipif(not has_scipy(), reason="scipy not available") + @pytest.mark.skipif(not has_matplotlib(), reason="matplotlib not available") + def test_render_custom_up_vector(self, sample_terrain): + """Test render with custom up vector (tilted camera).""" + from rtxpy import render + + result = render( + sample_terrain, + camera_position=(50, 0, 150), + look_at=(50, 50, 0), + width=320, + height=240, + up=(0.1, 0, 1), # Slightly tilted + ) + + assert result is not None + assert result.shape == (240, 320, 3) + + +class TestRenderOutput: + """Tests for render output and file saving.""" + + @pytest.mark.skipif(not has_xarray(), reason="xarray not available") + @pytest.mark.skipif(not has_scipy(), reason="scipy not available") + @pytest.mark.skipif(not has_matplotlib(), reason="matplotlib not available") + @pytest.mark.skipif(not has_pil(), reason="PIL not available") + def test_render_save_png(self, sample_terrain): + """Test render saves PNG file correctly.""" + from rtxpy import render + + with tempfile.TemporaryDirectory() as tmpdir: + output_path = os.path.join(tmpdir, 'test_render.png') + + result = render( + sample_terrain, + camera_position=(50, 0, 150), + look_at=(50, 50, 0), + width=320, + height=240, + output_path=output_path, + ) + + assert os.path.exists(output_path) + # Verify file is valid image + from PIL import Image + img = Image.open(output_path) + assert img.size == (320, 240) + assert img.mode == 'RGB' + + @pytest.mark.skipif(not has_xarray(), reason="xarray not available") + @pytest.mark.skipif(not has_scipy(), reason="scipy not available") + @pytest.mark.skipif(not has_matplotlib(), reason="matplotlib not available") + @pytest.mark.skipif(not has_pil(), reason="PIL not available") + def test_render_save_png_with_alpha(self, sample_terrain): + """Test render saves PNG file with alpha channel.""" + from rtxpy import render + + with tempfile.TemporaryDirectory() as tmpdir: + output_path = os.path.join(tmpdir, 'test_render_alpha.png') + + result = render( + sample_terrain, + camera_position=(50, 0, 150), + look_at=(50, 50, 0), + width=320, + height=240, + alpha=True, + output_path=output_path, + ) + + assert os.path.exists(output_path) + from PIL import Image + img = Image.open(output_path) + assert img.size == (320, 240) + assert img.mode == 'RGBA' + + @pytest.mark.skipif(not has_xarray(), reason="xarray not available") + @pytest.mark.skipif(not has_scipy(), reason="scipy not available") + @pytest.mark.skipif(not has_matplotlib(), reason="matplotlib not available") + def test_render_resolution(self, sample_terrain): + """Test render with different resolutions.""" + from rtxpy import render + + # 720p + result1 = render( + sample_terrain, + camera_position=(50, 0, 150), + look_at=(50, 50, 0), + width=1280, + height=720, + ) + assert result1.shape == (720, 1280, 3) + + # Square + result2 = render( + sample_terrain, + camera_position=(50, 0, 150), + look_at=(50, 50, 0), + width=512, + height=512, + ) + assert result2.shape == (512, 512, 3) + + +class TestRenderVerticalExaggeration: + """Tests for render vertical exaggeration parameter.""" + + @pytest.mark.skipif(not has_xarray(), reason="xarray not available") + @pytest.mark.skipif(not has_scipy(), reason="scipy not available") + @pytest.mark.skipif(not has_matplotlib(), reason="matplotlib not available") + def test_render_auto_vertical_exaggeration(self, sample_terrain): + """Test render with auto vertical exaggeration (default).""" + from rtxpy import render + + result = render( + sample_terrain, + camera_position=(50, 0, 150), + look_at=(50, 50, 0), + width=320, + height=240, + vertical_exaggeration=None, # Auto + ) + + assert result is not None + assert result.shape == (240, 320, 3) + assert not np.any(np.isnan(result)) + + @pytest.mark.skipif(not has_xarray(), reason="xarray not available") + @pytest.mark.skipif(not has_scipy(), reason="scipy not available") + @pytest.mark.skipif(not has_matplotlib(), reason="matplotlib not available") + def test_render_explicit_vertical_exaggeration(self, sample_terrain): + """Test render with explicit vertical exaggeration.""" + from rtxpy import render + + result = render( + sample_terrain, + camera_position=(50, 0, 150), + look_at=(50, 50, 0), + width=320, + height=240, + vertical_exaggeration=0.5, + ) + + assert result is not None + assert result.shape == (240, 320, 3) + + @pytest.mark.skipif(not has_xarray(), reason="xarray not available") + @pytest.mark.skipif(not has_scipy(), reason="scipy not available") + @pytest.mark.skipif(not has_matplotlib(), reason="matplotlib not available") + def test_render_no_vertical_exaggeration(self, sample_terrain): + """Test render with no vertical exaggeration (1.0).""" + from rtxpy import render + + result = render( + sample_terrain, + camera_position=(50, 0, 150), + look_at=(50, 50, 0), + width=320, + height=240, + vertical_exaggeration=1.0, + ) + + assert result is not None + assert result.shape == (240, 320, 3) + + +class TestRenderAccessor: + """Tests for render via xarray accessor.""" + + @pytest.mark.skipif(not has_xarray(), reason="xarray not available") + @pytest.mark.skipif(not has_scipy(), reason="scipy not available") + @pytest.mark.skipif(not has_matplotlib(), reason="matplotlib not available") + def test_accessor_render(self, sample_terrain): + """Test render via accessor interface.""" + result = sample_terrain.rtx.render( + camera_position=(50, 0, 150), + look_at=(50, 50, 0), + width=320, + height=240, + ) + + assert result is not None + assert result.shape == (240, 320, 3) + assert result.dtype == np.float32 + + @pytest.mark.skipif(not has_xarray(), reason="xarray not available") + @pytest.mark.skipif(not has_scipy(), reason="scipy not available") + @pytest.mark.skipif(not has_matplotlib(), reason="matplotlib not available") + def test_accessor_render_with_options(self, sample_terrain): + """Test render via accessor with various options.""" + result = sample_terrain.rtx.render( + camera_position=(50, 0, 150), + look_at=(50, 50, 0), + width=320, + height=240, + shadows=True, + colormap='viridis', + fog_density=0.01, + ) + + assert result is not None + assert result.shape == (240, 320, 3)