diff --git a/CHANGELOG.md b/CHANGELOG.md
index 3235332a..d2ee400a 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -2,13 +2,14 @@
 
 ## 3.6.0
 
-Added new observing capabilities for limb sounding, ground-based radar, and regions (polygons), with support for shapely points. Changed how general perturbations orbits are propagated, with options to model orbits maintained on a repeat ground track. Also changed the tangent point for GNSS radio occultation (RO) and limb sounding to the point of minimum WGS 84 geodetic altitude along the line of sight.
+Added new observing capabilities for limb sounding, ground-based radar, fixed surface platforms, and regions (polygons), with support for shapely points. Changed how general perturbations orbits are propagated, with options to model orbits maintained on a repeat ground track. Also changed the tangent point for GNSS radio occultation (RO) and limb sounding to the point of minimum WGS 84 geodetic altitude along the line of sight.
 
 Added:
  - Analysis method `collect_limb_observations` (with enumeration `ScanDirection`) for limb sounding observations from periodic scans at a constant angular rate.
  - Analysis method `collect_space_observations` for the periods when satellites can observe other satellites (as by a sensor or a radio frequency link), subject to slant range limits and Earth occlusion (a minimum WGS 84 geodetic altitude of the line of sight). Each observation records the lines of sight at its start and end as its geometry.
  - Object schemas `RadarStation` (with `RadarBand` and `RadarStation.from_band`) and `TerrainMask`, and analysis methods `collect_radar_track` and `compute_radar_track`, for ground-based radar coverage. `AllSurfaceObjects` includes `RadarStation`.
- - Module `preprocess` to derive inputs from external datasets, including terrain masks from Copernicus DEM data (`compute_terrain_mask`, `compute_terrain_mask_for_station`, `get_copernicus_dem_tile_urls`, and `sample_dem_elevation`), and gridded weights from GeoTIFF rasters (`read_raster_weights`).
+ - Object schema `SurfacePlatform` (included in `AllSurfaceObjects`) for instruments on platforms fixed above the Earth's surface, such as towers or tethered balloons, with a `heading` that orients their views, and analysis methods `collect_platform_track` and `compute_platform_track` for the static footprints of their `Instrument` and `PointedInstrument` views at a target elevation, either below the instruments (looking down) or above them (looking up, as at clouds), with views clipped to the horizon of the ground below (argument `ground_elevation` of the footprint and pixel methods) and to an optional `terrain_mask` (a `TerrainMask`, as for a `RadarStation`), with method `SurfacePlatform.compute_visible_region` for the region of a target above the instruments visible over them. Utility method `compute_static_track` gives a fixed position the form of an orbit track, from which instruments project their views as from a satellite.
+ - Module `preprocess` to derive inputs from external datasets, including terrain masks from Copernicus DEM data (`compute_terrain_mask`, `compute_terrain_mask_for_station`, `compute_terrain_mask_for_platform`, `get_copernicus_dem_tile_urls`, and `sample_dem_elevation`, with an `effective_earth_radius_factor` for refraction, also an argument of `compute_terrain_elevation_angle`), and gridded weights from GeoTIFF rasters (`read_raster_weights`).
  - Generation method `generate_points_random` for random points, uniform by area or weighted by a raster (for example, of population counts or densities), optionally within a mask, with a seed for reproducibility.
  - Analysis methods `collect_region_observations` and `collect_multi_region_observations` to collect the periods (start and end) when an instrument observes any part of a region (shapely `Polygon` or `MultiPolygon`), using the footprints of pointed and conical instruments and the field of regard of other instruments. Each observation records its swath (the part of the region swept by the footprint) as its geometry and identifies the region by the hash of its geometry (`target_hash`). Methods `aggregate_observations` and `reduce_observations` combine the swaths of a region into the part of it observed.
  - Analysis methods `compute_access_periods`, the periods when a satellite is in view of a point above a minimum elevation angle, and `compute_region_access_periods`, a conservative superset of the periods when an instrument's field of regard may observe any part of a region (for example, to cull analysis times).
@@ -50,6 +51,7 @@ Changed:
  - Fixed `SunSynchronousOrbit` to place the ascending node in local mean solar time and to keep the local time of its equator crossings constant as propagated.
  - Fixed `TrainConstellation` for long intervals between members, and `MolniyaOrbit` and `TundraOrbit` periods to repeat the ground track as propagated.
  - Fixed rectangular footprints of wide, elongated views.
+ - Fixed `PointedInstrument.compute_footprint_pixel_array` for a single-time (scalar) orbit track.
  - Fixed `split_polygon` for longitudes beyond 180 degrees, for polygons spanning -180 to 180 degrees of longitude, and for holes across the anti-meridian or around a pole (holes are now split like exteriors), and to drop degenerate (zero-area) parts left by repairing invalid polygons.
  - Fixed cached orbit computations for copies with changed fields, and orbits and satellites to be picklable after propagation.
  - Fixed numba-compiled utility methods (in `tatc.utils.orbital`, `observation`, `radar`, `atmosphere`, and `surface`) returning `nan` for integer inputs, which overflowed in compiled integer arithmetic (for example, `semimajor_axis_to_mean_motion(7000000)`): inputs are now converted to floats.
diff --git a/docs/api_reference/analysis/track.rst b/docs/api_reference/analysis/track.rst
index ee4a7a7e..a3c33b94 100644
--- a/docs/api_reference/analysis/track.rst
+++ b/docs/api_reference/analysis/track.rst
@@ -28,3 +28,19 @@ Compute Ground Track
 Collect Ground Pixels
 ----------------------
 .. autofunction:: tatc.analysis.collect_ground_pixels
+
+Collect Platform Track
+----------------------
+.. autofunction:: tatc.analysis.collect_platform_track
+
+Compute Platform Track
+----------------------
+.. autofunction:: tatc.analysis.compute_platform_track
+
+Collect Radar Track
+-------------------
+.. autofunction:: tatc.analysis.collect_radar_track
+
+Compute Radar Track
+-------------------
+.. autofunction:: tatc.analysis.compute_radar_track
diff --git a/docs/api_reference/generation/index.rst b/docs/api_reference/generation/index.rst
index 4b9e85cd..a376c326 100644
--- a/docs/api_reference/generation/index.rst
+++ b/docs/api_reference/generation/index.rst
@@ -27,10 +27,9 @@ Random
 
 .. autofunction:: tatc.generation.generate_points_random
 
-Weights for random points can be read from a GeoTIFF raster (requires the
-optional `preprocess` dependencies, ``pip install tatc[preprocess]``):
-
-.. autofunction:: tatc.preprocess.read_raster_weights
+Weights for random points can be read from a GeoTIFF raster with
+:func:`tatc.preprocess.read_raster_weights` (requires the optional
+`preprocess` dependencies, ``pip install tatc[preprocess]``).
 
 Cells
 =====
diff --git a/docs/api_reference/index.rst b/docs/api_reference/index.rst
index f4d2d142..8169b7f9 100644
--- a/docs/api_reference/index.rst
+++ b/docs/api_reference/index.rst
@@ -10,4 +10,5 @@ The following provide documentation on the Python API to TAT-C.
   schemas/index
   generation/index
   analysis/index
+  preprocess/index
   utils/index
diff --git a/docs/api_reference/preprocess/index.rst b/docs/api_reference/preprocess/index.rst
new file mode 100644
index 00000000..235ec99c
--- /dev/null
+++ b/docs/api_reference/preprocess/index.rst
@@ -0,0 +1,47 @@
+=======================
+Preprocessing Functions
+=======================
+
+Preprocessing functions derive TAT-C model inputs from external geospatial
+datasets. They require the optional `preprocess` dependencies
+(``pip install tatc[preprocess]``).
+
+Terrain Masks
+=============
+
+Terrain masks (:class:`tatc.schemas.TerrainMask`) for radar stations and
+surface platforms are derived by ray-tracing a digital elevation model (DEM),
+such as the public Copernicus DEM GLO-30.
+
+Copernicus DEM Tiles
+--------------------
+
+.. autofunction:: tatc.preprocess.get_copernicus_dem_tile_urls
+
+Sample DEM Elevation
+--------------------
+
+.. autofunction:: tatc.preprocess.sample_dem_elevation
+
+Compute Terrain Mask
+--------------------
+
+.. autofunction:: tatc.preprocess.compute_terrain_mask
+
+Compute Terrain Mask for Station
+--------------------------------
+
+.. autofunction:: tatc.preprocess.compute_terrain_mask_for_station
+
+Compute Terrain Mask for Platform
+---------------------------------
+
+.. autofunction:: tatc.preprocess.compute_terrain_mask_for_platform
+
+Rasters
+=======
+
+Read Raster Weights
+-------------------
+
+.. autofunction:: tatc.preprocess.read_raster_weights
diff --git a/docs/api_reference/schemas/surface.rst b/docs/api_reference/schemas/surface.rst
index a3749b44..45cf3254 100644
--- a/docs/api_reference/schemas/surface.rst
+++ b/docs/api_reference/schemas/surface.rst
@@ -12,3 +12,24 @@ Ground Station
 
 .. autopydantic_model:: tatc.schemas.GroundStation
   :members:
+
+Radar Station
+-------------
+
+.. autopydantic_model:: tatc.schemas.RadarStation
+  :members:
+
+.. autoclass:: tatc.schemas.RadarBand
+  :members:
+
+Surface Platform
+----------------
+
+.. autopydantic_model:: tatc.schemas.SurfacePlatform
+  :members:
+
+Terrain Mask
+------------
+
+.. autopydantic_model:: tatc.schemas.TerrainMask
+  :members:
diff --git a/docs/api_reference/utils/index.rst b/docs/api_reference/utils/index.rst
index 9ea19b22..d9ad5133 100644
--- a/docs/api_reference/utils/index.rst
+++ b/docs/api_reference/utils/index.rst
@@ -24,8 +24,12 @@ Utility Functions
 
 .. autofunction:: tatc.utils.compute_projected_ray_position
 
+.. autofunction:: tatc.utils.compute_static_track
+
 .. autofunction:: tatc.utils.compute_view_tangents
 
+.. autofunction:: tatc.utils.compute_view_angles
+
 .. autofunction:: tatc.utils.compute_cone_and_azimuth
 
 .. autoclass:: tatc.utils.VelocityFrame
@@ -34,6 +38,9 @@ Utility Functions
 .. autoclass:: tatc.utils.NadirReference
   :members:
 
+.. autoclass:: tatc.utils.ViewGeometry
+  :members:
+
 .. autofunction:: tatc.utils.compute_field_of_regard
 
 .. autofunction:: tatc.utils.compute_min_elevation_angle
@@ -56,6 +63,8 @@ Utility Functions
 
 .. autofunction:: tatc.utils.compute_vnb_frame
 
+.. autofunction:: tatc.utils.compute_argument_of_latitude
+
 .. autofunction:: tatc.utils.compute_j2_raan_rate
 
 .. autofunction:: tatc.utils.compute_j2_aop_rate
@@ -80,6 +89,8 @@ Utility Functions
 
 .. autofunction:: tatc.utils.geodesic_distance
 
+.. autofunction:: tatc.utils.geodesic_destination
+
 .. autofunction:: tatc.utils.get_planar_bounds
 
 .. autofunction:: tatc.utils.to_datetime64_ns
@@ -97,3 +108,17 @@ Utility Functions
 .. autofunction:: tatc.utils.compute_ellipsoid_intersection
 
 .. autofunction:: tatc.utils.compute_tangent_point
+
+.. autofunction:: tatc.utils.compute_radar_beam_height
+
+.. autofunction:: tatc.utils.compute_radar_ground_range
+
+.. autofunction:: tatc.utils.compute_radar_slant_range
+
+.. autofunction:: tatc.utils.compute_radar_ground_range_bounds
+
+.. autofunction:: tatc.utils.compute_terrain_elevation_angle
+
+.. autofunction:: tatc.utils.compute_radar_footprint
+
+.. autofunction:: tatc.utils.compute_radar_footprint_profile
diff --git a/docs/examples/CollectPlatformTrack.ipynb b/docs/examples/CollectPlatformTrack.ipynb
new file mode 100644
index 00000000..c9362f9c
--- /dev/null
+++ b/docs/examples/CollectPlatformTrack.ipynb
@@ -0,0 +1,1208 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "b316e72d",
+   "metadata": {},
+   "source": [
+    "# Collect Fixed Platform Coverage (Towers and Tethered Balloons)\n",
+    "\n",
+    "This example demonstrates how to use direct function calls of the low-level TAT-C library to collect the coverage footprints of instruments on fixed surface platforms, such as towers and tethered balloons, using the `SurfacePlatform` schema and the `collect_platform_track`/`compute_platform_track` analysis functions.\n",
+    "\n",
+    "A fixed platform combines features of two other TAT-C observing systems. Like a ground-based radar (see the [Collect Radar Coverage](CollectRadarTrack.ipynb) example), it does not move in the Earth-fixed frame, so these functions report one static footprint per platform and instrument rather than a time series. Like a satellite (see the [Collect Orbit and Ground Track](CollectOrbitGroundTrack.ipynb) example), it hosts generic (`Instrument`) or pointed (`PointedInstrument`) instruments, whose views are projected onto a target elevation exactly as a satellite's ground track is.\n",
+    "\n",
+    "The platforms in this example are hypothetical, sited around Phoenix, Arizona."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "ef5ec39d",
+   "metadata": {},
+   "source": [
+    "## Tethered Balloon\n",
+    "\n",
+    "A `SurfacePlatform` is located by its `latitude`, `longitude`, and ground `elevation`, with its instruments a `height` above the ground (for example, a tower's height or a tethered balloon's altitude above its tether point). Elevations are heights above the WGS 84 ellipsoid, the surface onto which footprints are projected. Around Phoenix, these are about 30 m less than heights above mean sea level (the geoid undulation).\n",
+    "\n",
+    "The first platform is a tethered balloon flying 1,000 m above downtown Phoenix, where the ground is about 330 m above mean sea level (300 m above the ellipsoid). It carries two generic instruments, each observing a cone around nadir:\n",
+    "\n",
+    " * `Camera`: a 60 degree field of regard, as for a downward-looking camera.\n",
+    " * `Horizon`: a 180 degree field of regard, which observes everything below the horizon."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "4e280cf3",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2026-10-16T23:46:28.491343Z",
+     "iopub.status.busy": "2026-10-16T23:46:28.491343Z",
+     "iopub.status.idle": "2026-10-16T23:46:29.874721Z",
+     "shell.execute_reply": "2026-10-16T23:46:29.874721Z"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "from tatc.schemas import Instrument, SurfacePlatform\n",
+    "\n",
+    "balloon = SurfacePlatform(\n",
+    "    name=\"Balloon\",\n",
+    "    latitude=33.4484,\n",
+    "    longitude=-112.0740,\n",
+    "    elevation=300,\n",
+    "    height=1000,\n",
+    "    instruments=[\n",
+    "        Instrument(name=\"Camera\", field_of_regard=60),\n",
+    "        Instrument(name=\"Horizon\", field_of_regard=180),\n",
+    "    ],\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "24c69568",
+   "metadata": {},
+   "source": [
+    "The `collect_platform_track` method computes each instrument's footprint. By default it projects onto the platform's ground elevation; pass `elevation` to use another target elevation, either below the instruments (looking down) or above them (looking up, see [Looking Up](#Looking-Up)). As in `collect_ground_track`, `instrument_index` selects one instrument of each platform (the first by default), or `None` selects all of them. Results are formatted as a flat GeoDataFrame, similar to a regular pandas DataFrame with a geospatial column labeled `geometry`. Other columns:\n",
+    " * `platform`: platform name\n",
+    " * `instrument`: instrument name\n",
+    " * `elevation`: target elevation (m) onto which the footprint is projected"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "92f7d098",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2026-10-16T23:46:29.874721Z",
+     "iopub.status.busy": "2026-10-16T23:46:29.874721Z",
+     "iopub.status.idle": "2026-10-16T23:46:29.890997Z",
+     "shell.execute_reply": "2026-10-16T23:46:29.890521Z"
+    }
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "<div>\n",
+       "<style scoped>\n",
+       "    .dataframe tbody tr th:only-of-type {\n",
+       "        vertical-align: middle;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe tbody tr th {\n",
+       "        vertical-align: top;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe thead th {\n",
+       "        text-align: right;\n",
+       "    }\n",
+       "</style>\n",
+       "<table border=\"1\" class=\"dataframe\">\n",
+       "  <thead>\n",
+       "    <tr style=\"text-align: right;\">\n",
+       "      <th></th>\n",
+       "      <th>platform</th>\n",
+       "      <th>instrument</th>\n",
+       "      <th>elevation</th>\n",
+       "      <th>geometry</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>0</th>\n",
+       "      <td>Balloon</td>\n",
+       "      <td>Camera</td>\n",
+       "      <td>300.0</td>\n",
+       "      <td>POLYGON Z ((-112.08021 33.4484 300, -112.08008...</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>1</th>\n",
+       "      <td>Balloon</td>\n",
+       "      <td>Horizon</td>\n",
+       "      <td>300.0</td>\n",
+       "      <td>POLYGON Z ((-113.2892 33.44245 300, -113.26703...</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "  platform instrument  elevation  \\\n",
+       "0  Balloon     Camera      300.0   \n",
+       "1  Balloon    Horizon      300.0   \n",
+       "\n",
+       "                                            geometry  \n",
+       "0  POLYGON Z ((-112.08021 33.4484 300, -112.08008...  \n",
+       "1  POLYGON Z ((-113.2892 33.44245 300, -113.26703...  "
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "from tatc.analysis import collect_platform_track\n",
+    "\n",
+    "results = collect_platform_track(balloon, instrument_index=None)\n",
+    "display(results)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "a9df813e",
+   "metadata": {},
+   "source": [
+    "To measure footprints, it helps to transform them into a local azimuthal equidistant projection centered on the platform, in which coordinates are distances (m) east and north of it. From 1,000 m, the camera's footprint is a disk of radius 1,000 tan(30°) = 577 m. The horizon instrument sees out to the horizon, about √(2Rh) ≈ 113 km away for a height h and Earth radius R. Rays that miss the target surface (looking above the horizon) are projected onto the horizon, as for a satellite's view of the Earth's limb."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "a14b6e6d",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2026-10-16T23:46:29.892649Z",
+     "iopub.status.busy": "2026-10-16T23:46:29.892001Z",
+     "iopub.status.idle": "2026-10-16T23:46:29.907688Z",
+     "shell.execute_reply": "2026-10-16T23:46:29.907688Z"
+    }
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "<div>\n",
+       "<style scoped>\n",
+       "    .dataframe tbody tr th:only-of-type {\n",
+       "        vertical-align: middle;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe tbody tr th {\n",
+       "        vertical-align: top;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe thead th {\n",
+       "        text-align: right;\n",
+       "    }\n",
+       "</style>\n",
+       "<table border=\"1\" class=\"dataframe\">\n",
+       "  <thead>\n",
+       "    <tr style=\"text-align: right;\">\n",
+       "      <th></th>\n",
+       "      <th>platform</th>\n",
+       "      <th>instrument</th>\n",
+       "      <th>elevation</th>\n",
+       "      <th>radius (km)</th>\n",
+       "      <th>area (km2)</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>0</th>\n",
+       "      <td>Balloon</td>\n",
+       "      <td>Camera</td>\n",
+       "      <td>300.0</td>\n",
+       "      <td>0.577</td>\n",
+       "      <td>1.040</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>1</th>\n",
+       "      <td>Balloon</td>\n",
+       "      <td>Horizon</td>\n",
+       "      <td>300.0</td>\n",
+       "      <td>112.863</td>\n",
+       "      <td>39741.534</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "  platform instrument  elevation  radius (km)  area (km2)\n",
+       "0  Balloon     Camera      300.0        0.577       1.040\n",
+       "1  Balloon    Horizon      300.0      112.863   39741.534"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "import numpy as np\n",
+    "\n",
+    "\n",
+    "def local_crs(platform):\n",
+    "    \"\"\"Azimuthal equidistant projection (m) centered on a platform.\"\"\"\n",
+    "    return f\"+proj=aeqd +lat_0={platform.latitude} +lon_0={platform.longitude} +datum=WGS84 +units=m\"\n",
+    "\n",
+    "\n",
+    "def mean_radius(track, platform):\n",
+    "    \"\"\"Mean distance (m) from a platform to the boundary of each footprint.\"\"\"\n",
+    "    local = track.to_crs(local_crs(platform))\n",
+    "    return local.geometry.apply(lambda g: np.hypot(*np.array(g.exterior.coords)[:, :2].T).mean())\n",
+    "\n",
+    "\n",
+    "summary = results[[\"platform\", \"instrument\", \"elevation\"]].copy()\n",
+    "summary[\"radius (km)\"] = mean_radius(results, balloon) / 1e3\n",
+    "summary[\"area (km2)\"] = results.to_crs(local_crs(balloon)).area / 1e6\n",
+    "display(summary.round(3))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "a376c645",
+   "metadata": {},
+   "source": [
+    "The footprints can be plotted on a map and, for the small camera footprint, in local coordinates."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "50ac04df",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2026-10-16T23:46:29.907688Z",
+     "iopub.status.busy": "2026-10-16T23:46:29.907688Z",
+     "iopub.status.idle": "2026-10-16T23:46:31.908557Z",
+     "shell.execute_reply": "2026-10-16T23:46:31.908195Z"
+    }
+   },
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 1300x600 with 2 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "import cartopy.crs as ccrs\n",
+    "import cartopy.feature as cfeature\n",
+    "import matplotlib.pyplot as plt\n",
+    "\n",
+    "fig = plt.figure(figsize=(13, 6))\n",
+    "ax = fig.add_subplot(1, 2, 1, projection=ccrs.PlateCarree())\n",
+    "results[results.instrument == \"Horizon\"].plot(\n",
+    "    facecolor=\"tab:blue\", edgecolor=\"k\", alpha=0.3, ax=ax, transform=ccrs.PlateCarree()\n",
+    ")\n",
+    "ax.plot(balloon.longitude, balloon.latitude, \"k^\", transform=ccrs.PlateCarree())\n",
+    "ax.stock_img()\n",
+    "ax.add_feature(cfeature.STATES, edgecolor=\"gray\")\n",
+    "ax.set_extent([-113.7, -110.4, 32.2, 34.7], crs=ccrs.PlateCarree())\n",
+    "ax.set_title(\"Horizon Footprint from 1,000 m\")\n",
+    "\n",
+    "ax = fig.add_subplot(1, 2, 2)\n",
+    "results[results.instrument == \"Camera\"].to_crs(local_crs(balloon)).plot(\n",
+    "    facecolor=\"tab:orange\", edgecolor=\"k\", alpha=0.5, ax=ax\n",
+    ")\n",
+    "ax.plot(0, 0, \"k^\")\n",
+    "ax.set(xlabel=\"East (m)\", ylabel=\"North (m)\", title=\"Camera Footprint from 1,000 m\", aspect=\"equal\")\n",
+    "ax.grid(True, alpha=0.3)\n",
+    "plt.tight_layout()\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "7bb649c1",
+   "metadata": {},
+   "source": [
+    "## Platform Height\n",
+    "\n",
+    "A platform's height governs how much it can see. The radius of a narrow view's footprint grows in proportion to height, while the distance to the horizon grows only with its square root. Collecting the balloon's footprints at several heights shows both trends: the camera footprint's radius doubles from 1,000 m to 2,000 m, while the horizon moves out by only about 40%."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "f2c84fa0",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2026-10-16T23:46:31.909517Z",
+     "iopub.status.busy": "2026-10-16T23:46:31.909517Z",
+     "iopub.status.idle": "2026-10-16T23:46:31.940817Z",
+     "shell.execute_reply": "2026-10-16T23:46:31.940817Z"
+    }
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "<div>\n",
+       "<style scoped>\n",
+       "    .dataframe tbody tr th:only-of-type {\n",
+       "        vertical-align: middle;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe tbody tr th {\n",
+       "        vertical-align: top;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe thead th {\n",
+       "        text-align: right;\n",
+       "    }\n",
+       "</style>\n",
+       "<table border=\"1\" class=\"dataframe\">\n",
+       "  <thead>\n",
+       "    <tr style=\"text-align: right;\">\n",
+       "      <th>instrument</th>\n",
+       "      <th>Camera</th>\n",
+       "      <th>Horizon</th>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>platform</th>\n",
+       "      <th></th>\n",
+       "      <th></th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>100 m</th>\n",
+       "      <td>0.058</td>\n",
+       "      <td>35.694</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>250 m</th>\n",
+       "      <td>0.144</td>\n",
+       "      <td>56.434</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>500 m</th>\n",
+       "      <td>0.289</td>\n",
+       "      <td>79.809</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>1000 m</th>\n",
+       "      <td>0.577</td>\n",
+       "      <td>112.863</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2000 m</th>\n",
+       "      <td>1.155</td>\n",
+       "      <td>159.602</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "instrument  Camera  Horizon\n",
+       "platform                   \n",
+       "100 m        0.058   35.694\n",
+       "250 m        0.144   56.434\n",
+       "500 m        0.289   79.809\n",
+       "1000 m       0.577  112.863\n",
+       "2000 m       1.155  159.602"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "heights = [100, 250, 500, 1000, 2000]\n",
+    "balloons = [balloon.model_copy(update={\"name\": f\"{height} m\", \"height\": height}) for height in heights]\n",
+    "by_height = collect_platform_track(balloons, instrument_index=None)\n",
+    "by_height[\"radius (km)\"] = mean_radius(by_height, balloon) / 1e3\n",
+    "display(\n",
+    "    by_height.pivot(index=\"platform\", columns=\"instrument\", values=\"radius (km)\")\n",
+    "    .loc[[balloon.name for balloon in balloons]]\n",
+    "    .round(3)\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "2b474bfe",
+   "metadata": {},
+   "source": [
+    "## Tower with Pointed Instruments\n",
+    "\n",
+    "A `PointedInstrument` rotates its view away from nadir by a roll angle (positive to the left) and then a pitch angle (positive forward). On a satellite, left and forward are relative to its direction of motion; on a platform, they are relative to its `heading`, the azimuth (clockwise from north) of its forward direction.\n",
+    "\n",
+    "The next platform is a 30 m tower in Tempe, Arizona, where the ground is about 350 m above mean sea level (320 m above the ellipsoid). Its heading is north (the default), and it hosts three pointed instruments:\n",
+    "\n",
+    " * `North camera`: a rectangular frame camera with a 60 degree horizontal and 40 degree vertical field of view. A 60 degree forward pitch points it north, 30 degrees below horizontal, so it views from 40 to 80 degrees from nadir. Pitching about the cross-track axis keeps the horizontal field of view across track.\n",
+    " * `West camera`: the same camera rolled 60 degrees to the left (west). Rolling about the along-track axis turns the cross-track field of view vertical, so its fields of view are swapped (40 degrees across track and 60 degrees along track).\n",
+    " * `Scanner`: a cross-track scanner (`ViewGeometry.SCAN`) sweeping 60 degrees to either side of nadir (east and west), with a 2 degree along-track field of view, as for a scanning radiometer."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "id": "580b18c9",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2026-10-16T23:46:31.942810Z",
+     "iopub.status.busy": "2026-10-16T23:46:31.942810Z",
+     "iopub.status.idle": "2026-10-16T23:46:31.956348Z",
+     "shell.execute_reply": "2026-10-16T23:46:31.956348Z"
+    }
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "<div>\n",
+       "<style scoped>\n",
+       "    .dataframe tbody tr th:only-of-type {\n",
+       "        vertical-align: middle;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe tbody tr th {\n",
+       "        vertical-align: top;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe thead th {\n",
+       "        text-align: right;\n",
+       "    }\n",
+       "</style>\n",
+       "<table border=\"1\" class=\"dataframe\">\n",
+       "  <thead>\n",
+       "    <tr style=\"text-align: right;\">\n",
+       "      <th></th>\n",
+       "      <th>platform</th>\n",
+       "      <th>instrument</th>\n",
+       "      <th>elevation</th>\n",
+       "      <th>geometry</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>0</th>\n",
+       "      <td>Tower</td>\n",
+       "      <td>North camera</td>\n",
+       "      <td>320.0</td>\n",
+       "      <td>POLYGON Z ((-111.92833 33.42443 320, -111.9283...</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>1</th>\n",
+       "      <td>Tower</td>\n",
+       "      <td>West camera</td>\n",
+       "      <td>320.0</td>\n",
+       "      <td>POLYGON Z ((-111.92993 33.42335 320, -111.9299...</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2</th>\n",
+       "      <td>Tower</td>\n",
+       "      <td>Scanner</td>\n",
+       "      <td>320.0</td>\n",
+       "      <td>POLYGON Z ((-111.92866 33.42419 320, -111.9286...</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "  platform    instrument  elevation  \\\n",
+       "0    Tower  North camera      320.0   \n",
+       "1    Tower   West camera      320.0   \n",
+       "2    Tower       Scanner      320.0   \n",
+       "\n",
+       "                                            geometry  \n",
+       "0  POLYGON Z ((-111.92833 33.42443 320, -111.9283...  \n",
+       "1  POLYGON Z ((-111.92993 33.42335 320, -111.9299...  \n",
+       "2  POLYGON Z ((-111.92866 33.42419 320, -111.9286...  "
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "from tatc.schemas import PointedInstrument\n",
+    "from tatc.utils import ViewGeometry\n",
+    "\n",
+    "tower = SurfacePlatform(\n",
+    "    name=\"Tower\",\n",
+    "    latitude=33.4242,\n",
+    "    longitude=-111.9281,\n",
+    "    elevation=320,\n",
+    "    height=30,\n",
+    "    instruments=[\n",
+    "        PointedInstrument(\n",
+    "            name=\"North camera\",\n",
+    "            cross_track_field_of_view=60,\n",
+    "            along_track_field_of_view=40,\n",
+    "            pitch_angle=60,\n",
+    "            is_rectangular=True,\n",
+    "        ),\n",
+    "        PointedInstrument(\n",
+    "            name=\"West camera\",\n",
+    "            cross_track_field_of_view=40,\n",
+    "            along_track_field_of_view=60,\n",
+    "            roll_angle=60,\n",
+    "            is_rectangular=True,\n",
+    "        ),\n",
+    "        PointedInstrument(\n",
+    "            name=\"Scanner\",\n",
+    "            cross_track_field_of_view=120,\n",
+    "            along_track_field_of_view=2,\n",
+    "            view_geometry=ViewGeometry.SCAN,\n",
+    "            is_rectangular=True,\n",
+    "        ),\n",
+    "    ],\n",
+    ")\n",
+    "\n",
+    "tower_results = collect_platform_track(tower, instrument_index=None)\n",
+    "display(tower_results)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "76048340",
+   "metadata": {},
+   "source": [
+    "In local coordinates, each camera's footprint is a trapezoid that widens with distance. Its near edge is 30 tan(40°) = 25 m from the tower, and its far edge 30 tan(80°) = 170 m. The scanner's footprint is a strip 30 tan(60°) = 52 m to either side of the tower, widening away from nadir because its along-track field of view is a constant angle."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "id": "69dcfcaa",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2026-10-16T23:46:31.958340Z",
+     "iopub.status.busy": "2026-10-16T23:46:31.958340Z",
+     "iopub.status.idle": "2026-10-16T23:46:32.059000Z",
+     "shell.execute_reply": "2026-10-16T23:46:32.059000Z"
+    }
+   },
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 800x800 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "fig, ax = plt.subplots(figsize=(8, 8))\n",
+    "tower_results.to_crs(local_crs(tower)).plot(\n",
+    "    column=\"instrument\", cmap=\"tab10\", edgecolor=\"k\", alpha=0.5, legend=True, ax=ax\n",
+    ")\n",
+    "ax.plot(0, 0, \"k^\")\n",
+    "ax.set(xlabel=\"East (m)\", ylabel=\"North (m)\", title=\"Tower Footprints (heading north)\", aspect=\"equal\")\n",
+    "ax.grid(True, alpha=0.3)\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "26747fc0",
+   "metadata": {},
+   "source": [
+    "### Pixels\n",
+    "\n",
+    "A `PointedInstrument` with `cross_track_pixels` and `along_track_pixels` defines a pixel array, and its `compute_footprint_pixel_array` method projects the pixel centers from the platform's track (`SurfacePlatform.get_track`). Seen at a slant from a tower, ground pixels stretch with distance. Here the north camera has 12 by 8 pixels. Along its central columns, rows are about 5 m apart near the tower and about 40 m apart at the far edge, and rows bow away from the tower at their ends, where off-axis pixels look farther from nadir."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "id": "b7308a3b",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2026-10-16T23:46:32.061245Z",
+     "iopub.status.busy": "2026-10-16T23:46:32.060246Z",
+     "iopub.status.idle": "2026-10-16T23:46:32.175402Z",
+     "shell.execute_reply": "2026-10-16T23:46:32.175402Z"
+    }
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "row distances (m): [ 27.5  32.7  39.1  47.1  57.6  72.4  95.2 135.4]\n",
+      "row spacing (m): [ 5.3  6.4  8.  10.5 14.8 22.8 40.3]\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAk4AAAIjCAYAAAD1M5RxAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjEsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvc2/+5QAAAAlwSFlzAAAPYQAAD2EBqD+naQAAXZhJREFUeJzt3QmYE1X29/HTDdIIyr4ryCYu7KIyKCIKiuigAq7oCCgIgisKCC4ICo0KuDCo6LDogAoOuI6CCigqiICiIorYsog0sij7Tud9zp03/U/S6e5Kp5LU8v08T2iSVJK6VUnq5Fe3bqUFAoGAAAAAoFDphU8CAAAAReEEAABgEYUTAACARRROAAAAFlE4AQAAWEThBAAAYBGFEwAAgEUUTgAAABZROAEAAFhE4QR4wCOPPCJpaWmybdu2VM+Kr5d/onzyySfm+fUvgNSicAKKYOrUqWZDVrJkSfn999/z3N+2bVtp1KiR7a87atQoeeuttyRRdMPcpUsXqVatmpQoUUKqVKkinTp1ktmzZ4sfBQuW4OWYY46RunXryk033SS//vqrOFVWVpb06dPHzKu+R8uUKSPnnnuuPPPMM7J///6Eve6mTZtMEblixYqEvQaQahROQBwOHjwoo0ePTtrrJbJwGjZsmFxwwQWycuVKs9F94YUXZODAgbJnzx7p2rWrvPrqq+JXd955p/z73/+WF198US677DKZMWOGnHXWWaZQUA8++GBCC5JY/Pe//5XGjRvLzJkzTdE7fvx4yczMlFq1apn1eddddyXstXV5DB8+nMIJnlY81TMAuFmzZs3kpZdekiFDhkiNGjUS8hp6Hu4DBw7IscceK4nyn//8R0aMGCFXXXWVKZA0WQnSje3cuXPl8OHD4iZ79+6V0qVL2/Jc5513nlk2qmfPntKgQQNTTL388stm3RcvXtxcUm3t2rVy3XXXyUknnSTz58+X6tWr597Xv39/+eWXX0xh5TZ2rksgXiROQByGDh0qR48etZQ6HTlyRB599FGpV6+eZGRkSO3atc3jNbUKpbf//e9/N8XKmWeeaQqmiRMnml1FugHRjXVw11GPHj3CHrtjxw5zW7ly5aRs2bJmI79v375C5+2hhx6SChUqyOTJk8OKpqAOHTqYeVKHDh2Shx9+WFq0aGFeQzdoWlgsWLAg7DHr1q0z8zhmzBiZMGGC2W1UqlQpufjii+W3334zBaEujxNPPNG08YorrpA///wzz2t/8MEH5vn1dY4//niT+Pzwww9h02ibjzvuOLOL6tJLLzXT3XDDDea+zz77TK6++mqTuOhyr1mzptxzzz1xJUQXXnhhbqESrY/TlClTzHVdnpGJod7+/vvv5972008/maJMl7/uVtN1/s477xRpvp544gmTEE6aNCmsaAqqX79+nsRp2rRpZl3qOtB50MJL10+0Xc+rVq0yqaSuxxNOOMG8XuhuTU3hlL7vgu9R3a0dtGTJErnkkkvM+0af4/zzz5cvvvgi7LWCy1Jfq1u3blK+fHlp3bq1uW/z5s3mufU9o+tS26jvG32vAclC4QTEoU6dOqa/i6ZOwd02+enVq5cpOM444wx56qmnzEZDd6HohirS6tWr5frrr5eLLrrI9EvRZEt3FenGQosI/b9edJdaqGuuuUZ2795tnlf/rxst3XVSkDVr1piN95VXXmkKjsLs2rVL/vWvf5mN6eOPP242dFu3bjXFVbRdNNOnT5fnnntO7rjjDrn33nvl008/NfOmu7fmzJkjgwcPlltvvVXeffddue+++8Ieq23UQkmLIn0tLfB0g6ob0siNpRamOg/aL0uLNd29qN544w1TPN52221mt5VOo391vRWVFmiqYsWKUe/XjbsWmgMGDMgtQr7//nuzLm655RZT3CktAP/2t7/Jjz/+KPfff7+MHTvWFIi6Lt58882Y50uXoRao55xzjqXpR44caZbDySefLOPGjZO7775b5s2bJ23atDFFeKi//vrLFD1NmzY183nqqaeadaeFrTrttNNMaql0fQbfo/pcShMw/b++f3S3sBaR+hpahH711Vd55k2LXV1vOl3v3r3NbbpOdbno8tX3lKZ++n7fsGFDzMsKKLIAgJhNmTIloB+fpUuXBrKysgLFixcP3Hnnnbn3n3/++YGGDRvmXl+xYoWZvlevXmHPc99995nb58+fn3vbSSedZG6bM2dOntctXbp0oHv37nluHzZsmHnMzTffHHZ7586dAxUrViywLW+//bZ57FNPPWWp7UeOHAkcPHgw7La//vorULVq1bDXX7t2rXneypUrB3bs2JF7+5AhQ8ztTZs2DRw+fDj39uuvvz5QokSJwIEDB8z13bt3B8qVKxfo3bt32Gtt3rw5ULZs2bDbdZnoc95///155nffvn15bsvMzAykpaUF1q9fX2BbFyxYYJ538uTJga1btwY2bdoU+O9//xuoXbu2ebyu/9DlHyo7OztQoUKFwEUXXWSWV/PmzQO1atUK7Ny5M3eadu3aBRo3bpzbZpWTkxM455xzAieffHKe+dC/+dHn1WmuuOKKgBXr1q0LFCtWLDBy5Miw27///nvzfg69Xd/P+tyvvPJK7m3apmrVqgW6du2ae5suD51OPx+htE3ang4dOpj/h66bOnXqmGUUFFyW+n6IfI/p7U8++aSl9gGJQuIExEl/4f/jH/8wHYezs7OjThPcNaMJRChNYFRkvxNNsjQZiVXfvn3Drms6tX37dvMrPz/B+6ykTapYsWLmiDuVk5Njdq9p2qO7mL7++uuoyYHumglq2bKl+XvjjTeG9QvS23U3YPAoxY8++sgkEpq86TALwYu+vk4buWtQaaoUKbRvmO7q1OfQREZ3FX7zzTeW2nzzzTdL5cqVTT82TcCCu0y1zfnRIxN1F6W2Q9eDpnG6606PcFO63DSFCaaEwfbp+tJ1r0lgtCM27VqPeqSkrj99/dDlq/OtCVTk8tXUT9dZkL4Hzj77bEtHF2rbtT26603bF3wtXY7t2rWThQsXmnkp6L2s61FfU3cJavoFpErqezMCHqC7nXS3hPZ10l1rkdavXy/p6emmj0ko3UhpfyS9P7JwKgrtxxNK+4co3dAEN9iRgrfrxtsqLRp0d43u4gvtNB5tviPnKVhEaV+jaLcHN4q6oQ3tT5TffAdpEaZ9XyLpbhzdRar9hiI3uDt37hQr9PFa/GjRVqlSJbNbykpncN0Nq32ItDDW3VdaJARpR20t3nT3o16i2bJli+lLZEWs61GXr76+FknRRPZ102UbOVaVvr++++47S6+lunfvnu80ui6C79do7yXdTa27a/XHRtWqVc0uTt0dqrsa9XMEJAuFE2BT6qS/xjV10r4q+bE6SGJRj6DTDXs0uoHMj/ZVCfbBsUILAe2Mrf1w9Ig77VOkr6v9qoJ9f6zMU2HzGkwgtCCNtmGMLFx0w6rFaSjtuK/9xDTd0f442lbtQ6RJjrYhMuXIjx7e3759e4mVpivLli0z/9e+Wfp6wXkMvrb268ovXYwstAsrnDQR0+EkrNDX1/ej9lGKti40YYr3vRX6WurJJ580/fWiiXy9aJ8B7YOlQyzokBx68IQWnPq+0+SuefPmhc4HYAcKJ8DG1EmLCv1VHEkPD9eNh/7y1rQi6I8//jC7o/R+KxIxOrUeWn/KKafI22+/bdKyyA1YtKELtFDUXT2h86Mdfu2kRx8qLcyKUrQEi8Gff/7ZJGShncF191ky6BAAwc76OmzB008/nbu7VpdhMNkpavsiaQKjxfvixYulVatWhS5fLXo02dH3gB3ye38G16UWd/G2VZ9LUye96OdJCzFNP/WzByQDfZwAm+gXuqZOOnSAHjYdKngUlW44Q+mRTEr7zVihaUnk0U520KO9NB3RI/+0v1KkDz/8UN57772w5CE0adDDzHVjbSdNYXRDq0dVRRtDSo/kK0y0edX/R9udajctMHWgTN19qymk7rbT4loLuWBBqEcm6vslWt84K+2LNGjQIPMe0fWoRXkkTQSDbdcR4nX56LqPTI30ur4fYhUcaynyParDHejnQ4921OESitJWPcJOxzMLpc+pfboih/QAEonECbDRAw88YHYt6XACDRs2zL1dD+HW/h2aBuhGRYci0EOwNQnRXV46No4VugH6+OOPTcGlu2U0LQh2to7Htddea9IZPTxdO0xrh2xNwXTjqUMG6CHqwZHDNdXQtKlz586m4NOxjHSU8dNPPz3qRrGotGh6/vnnTcd7HcJBCw/toK19lrTPkJ5C5J///GeBz6G75nTjqrvDdPecPuesWbMS3rlY+yZpR3Vdr7fffru5TedVO1zrLsLPP//c7LLTzuM6tILuCtRD7jWF0oJHi9CNGzfKt99+G9Pralt1Pen61GRTUzYdf0k73S9atMgMzRAc+0unfeyxx0wSpkM7BIej0PWph/xrn6zI4SGsvL722dP3gz6XFlL6/tT3qQ5h0bFjR/O50OEEtO+WrhNdJrpedCiFgmjBqX3EtDO7vtd0V63Opy6vaEN6AAmTsOP1AJ8MRxApeGh86HAESg+9Hz58uDn8+phjjgnUrFnTHJofeih6cDiCyy67LOrr/vTTT4E2bdoEjj32WPMawaEJgodw6yHz0eZThwawYt68eeZw9ipVqphD0nUogU6dOpkhC4L0cPJRo0aZ+czIyDCH2b/33ntmXvS2yOEIIg8fDx5a/8Ybb1hapjq9HsauQxCULFkyUK9evUCPHj0Cy5Yty51GX1uHaohm1apVgfbt2weOO+64QKVKlcwwBt9++23Uw+Yj5TevkSKHI+jSpUvg+OOPN4f8Rxv64fHHH8+9TYezuOmmm8yh/fq+OOGEEwJ///vfA//5z39iGo4g1M8//2zaqcMm6BAPOi/nnntuYPz48Xneb7NmzQq0bt3aLD+9nHrqqYH+/fsHVq9ene/wGkGR6zzYxtNPP928fyKX8TfffGOWjQ6Roe8dfew111xj3neRyzLyvbxt2zYzXzp/Op/6fmjZsmVg5syZlpYJYJc0/SdxZRkAAIB30McJAADAIgonAAAAiyicAAAALKJwAgAAsIjCCQAAwCIKJwAAAIsYAPP/n0dp06ZNZsC2RJzSAgAAOIOOwqSnQtJBhCPPb2kFhZOIKZoiz9QOAAC867fffpMTTzwx5sdROImYpCm4EHXo/8g0Ss+jpKd6KEpl6la02z/t9mObFe2m3V7nxzZbafeuXbtMWBLc9seKwinkjN5aNEUrnPTEknq73954tNsf7fZjmxXtpt1e58c2x9LuonbN8c+SBAAAiBOFEwAAgBsKp4ULF0qnTp1Mz3aNzN56662w+/W2aJcnn3wyd5ratWvnuX/06NEpaA0AAPC6lBZOe/fulaZNm8qECROi3p+dnR12mTx5simMunbtGjbdiBEjwqa74447ktQCAADgJyntHN6xY0dzyU+1atXCrr/99ttywQUXSN26dcNu157xkdMCAADYzTVH1f3xxx/y3//+V15++eU89+muuUcffVRq1aol3bp1k3vuuUeKF8+/aQcPHjSX0EMTgz3x9RJKr+tgWZG3ex3t9k+7/dhmRbtpt9f5sc1W2h3v8nBN4aQFkyZLXbp0Cbv9zjvvlDPOOEMqVKggixYtkiFDhpjddePGjcv3uTIzM2X48OF5btdxH/QQxsgFvHPnTrMS/HY4J+32R7v92GZFu2m31/mxzVbaraOG+6Jw0v5NN9xwg5QsWTLs9gEDBuT+v0mTJlKiRAnp06ePKY4yMjKiPpcWV6GPCw6GpYNlRRvHSftV+XEAMdrtj3b7sc2KdtNur/Njm620O7KO8GTh9Nlnn8nq1atlxowZhU7bsmVLOXLkiKxbt05OOeWUqNNoQRWtqNIFHG0h6wrI7z4vo93+abcf26xoN+32Oj+2ubB2x7ssXLEkJ02aJC1atDBH4BVmxYoVZqFUqVIlKfMGAAD8I6WJ0549e+SXX37Jvb527VpT+Gh/Je3oHdyN9sYbb8jYsWPzPH7x4sWyZMkSc6Sd9n/S69ox/MYbb5Ty5csntS0AAMD7Ulo4LVu2zBQ9QcF+R927d5epU6ea/7/++uumg9f111+f5/G6u03vf+SRR8xRcnXq1DGFU2j/JQAAAE8UTm3btjVFUUFuvfVWc4lGj6b78ssvEzR3AAAALuzjBAAA4AQUTgAAABZROAEAAFhE4QQAAOClATDd7PLLL5e5c+eK2+hYWM2bN5dvvvnG8nl9dMAxt9N2N2vWzAyLkV+7vdDOWNvsRbTbW+0u7EAjr7S7sHbG+z3uFGXKlDHr6oQTThCnoXBKsOrVq8uhQ4fk8ccfl9KlS4ub6LD0kefus+PD7OZ2e6mdoY499ljZv3+/+A3t9pbCftTE8p3mZLH8eHNjm//5z3/Kjh07zJiOTkThlGBDhw4159nTyr9///7iFvrrZMuWLWYEdj8N1e/HdvuxzYp2026vc2Obs7Ky5K677jKDXmuB70TuWJIudtJJJ8nNN98sTzzxhOzduzfVswMAgGONHDnSnJw3v/EbnYDCKUmp019//SXPP/98qmcFAADHpk2vvPKK3H///Y5NmxSFUxKQOgEA4P60SVE4JQmpEwAA7k6bFIVTkpA6AQDg7rRJUTglEakTAADuTZsUhVMSkToBAODetElROCUZqRMAAO5MmxSFU5KROgEA4M60SVE4pQCpEwDA77JcmDYpCqcUIHUCAPjdSBemTYrCKUVInQAAfpXl0rRJUTilCKkTAMCvRro0bVIUTilE6gQA8JssF6dNisIphUidAAB+M9LFaZOicEoxUicAgF9kuTxtUhROKUbqBADwi5EuT5sUhZMDkDoBALwuywNpk6JwcgBSJwCA1430QNqkKJwcgtQJAOBVWR5JmxSFk0OQOgEAvGqkR9ImReHkIKROAACvyfJQ2qQonByE1AkA4DUjPZQ2KQonhyF1AgB4RZbH0iZF4eQwpE4AAK8Y6bG0SVE4ORCpEwDA7bI8mDYpCicHInUCALjdSA+mTYrCyaFInQAAbpXl0bRJUTg5FKkTAMCtRno0bVIUTg5G6gQAcJssD6dNisLJwUidAABuM9LDaZOicHI4UicAgFtkeTxtUhRODkfqBABwi5EeT5sUhZMLkDoBAJwuywdpk6JwcgFSJwCA0430QdqkKJxcgtQJAOBUWT5JmxSFk09Sp+yd+2VR1jbzFwAAO7cTI32SNikKJx+kTjOWbpBzR8+Xbi8tMX/1OgAAdmwnsnyUNikKJ4+nTvrLYcjs7yUn8L/r+nfo7JUkTwAAW7YTI32UNikKJ4+nTmu37c39MAQdDQRk3bZ9iZlBAICrxLOdyPJZ2qQonDyeOtWpVFrS08JvK5aWJrUrlUrcTAIAXCOe7cRIn6VNisLJ46lT9bLHSmaXxuZDoPTvqC6NzO0AABR1O5Hlw7RJFU/1DCC+1Om2226T0qVLFzj9tWfVkjYNKpvYVX9BUDQBAOLdToz0YdqkSJx80tdJPwSt6lWkaAIAxL2dyPJp2pTywmnhwoXSqVMnqVGjhqSlpclbb70Vdn+PHj3M7aGXSy65JGyaP//8U2644QYpU6aMlCtXTm655RbZs2ePeB2jiQMAUmWkT9OmlBdOusFv2rSpTJgwId9ptFDKzs7Ovbz22mth92vR9MMPP8hHH30k7733ninG/LIiGU0cAJBsWT5Om1Lex6ljx47mUpCMjAypVq1a1Pt+/PFHmTNnjixdulTOPPNMc9v48ePl0ksvlTFjxpgkK5qDBw+aS9CuXbvM35ycHHMJpdcDgUCe252gZs2aJmHTtvbp06fQvk6xcHK7E8mP7fZjmxXtpt1el6g2jxo1SqpWrSq9evVy5PIsrN3xzrPjO4d/8sknUqVKFSlfvrxceOGF8thjj0nFihXNfYsXLza754JFk2rfvr2kp6fLkiVLpHPnzlGfMzMzU4YPH57n9q1bt8qBAwfyLOCdO3ealaDP6zT9+vWTFStWyLRp0/Jtb1E4vd2J4sd2+7HNinbTbq9LRJuzs7PNXp5hw4bJ7t27zcVt7Y53nh1dOOluui5dukidOnVMNKi7pjSh0oKpWLFisnnzZlNUhSpevLhUqFDB3JefIUOGyIABA8ISJ01vdH+t9pWKXAHat0rvc+KHTdvfrFkzUwjeeOONtqVOTm93ovix3X5ss6LdtNvrEtHmBx54QH777TfTTcapu+kKa3fJkiW9Wzhdd911uf9v3LixNGnSROrVq2dSqHbt2hX5eXX3n14i6QKOtpB1BeR3nxNoIThp0iSZOHGi3HfffbY9r9PbnSh+bLcf26xoN+32OjvbrAHGyy+/LGPHjrW1a0iy2x3vsnDVu6du3bpSqVIl+eWXX8x17fu0ZcuWsGmOHDlijrTLr1+UF3GEHQAg0fx8JJ1rC6eNGzfK9u3bpXr16uZ6q1atZMeOHbJ8+fLcaebPn29iupYtW4qfcIQdACBR/H4knWMKJx1vSTs260WtXbvW/H/Dhg3mvoEDB8qXX34p69atk3nz5skVV1wh9evXlw4dOpjpTzvtNNMPqnfv3vLVV1/JF198IbfffrvZxZffEXVeReoEAEgU0iaHFE7Lli2T5s2bm4vSDtv6/4cffth0/v7uu+/k8ssvlwYNGpjD7lu0aCGfffZZWP+k6dOny6mnnmr6POkwBK1bt5YXX3xR/MirqVP2zv2yKGub+QsATubF7yvSJgd1Dm/btq05XDA/c+fOLfQ59Ai6V1991eY588c57NxgxtINMmT295ITEHP2bj0RpZ5TCQCcxqvfV6RNLu7jBH+lTvqLLfglpPTv0NkrPfVLDoA3ePX7irQpLwonj/FSX6e12/bmfgkFHQ0EzNm7AcBJvPp9RdqUF4WTB3kldapTqbSJu0MVS0uT2pVKpWqWAMA331ekTdFROHmQV1Kn6mWPNX0E9MtH6d9RXRqZ2wHASbz4fUXa5MKRwxFf6jR58mSTOtk5mniyacfKNg0qm7hbf7m5+UsIgLd56fsqmDbpKOGkTeFInDzKK6mT0i+fVvUquvpLCIA/eOX7irQpfxROHuaVvk4AgOShb1PBKJw8zEupEwAgOUibCkbh5HGkTgAAq0ibCkfh5HGkTgAAq0ibCkfh5AOkTonjxfNSAU7H5y4xSJusYTgCH/DiOeycwKvnpQKcjM9d4pA2WUPi5BOkTvby6nmpACfjc5c4v/zyC2mTRRROPkFfJ3t59bxUgJPxuUsc0ibrKJx8hNTJPl48LxXgdHzuEpc2/fvf/yZtsojCyUdInezjxfNSAU7H5y4xSJtiQ+dwn/HKOeycwEvnpQLcgs9dYtImzklnHYmTz5A62csr56UC3ITPnX1Im2JH4eRD9HXyJsa2QSLx/vIe+jYVDbvqfIhxnbyHsW2QSLy/vIm0qWhInHyK1Mk7GNsGicT7y5tIm4qOwsmn6OvkHYxtg0Ti/eVNpE1FR+HkY6RO3sDYNkgk3l/eQ9oUHwonHyN18gYnjG1Dx2HvLmcnvL9gL9Km+NA53OcY18kbUjm2DR2Hvb+cGTvJOxi3KX4kTj5H6uQdqRjbJtUdh1OVdCX7dVO9nBVjJ3kDaVP8KJxAXye4suOwJjDnjp4v3V5aYv7q9WRIxevSQRt2oG+TPSicQOoE13UcTlUCk6rXpYM27EDaZA8KJxikTnBTx+FUJTCpel06aCNepE32oXM4oo4mzgcLTu44HExgQouYZCQwqXpdRQdtxIO0yT4kTshF6gS3dBxOVQKT6uSHDtooiqysLNImG5E4IWrq1KdPn1TPDuDIBIbkB26TmZlJ2mQjEidETZ0mTpyY6lkBHJvAkPzALbKzs2XatGmkTTaicELU1GnMmDFy4MCBVM8OACAOM2fOJG2yGYUT8k2dPvjgg1TPCgAgjr5NCxYskEGDBpE22YjCCVFTp549e8qsWbMY1wkAXNy3qUyZMtKrV69Uz4qnUDghKt0fvmfPHvo6AYBLx23Svk1XXXUVaZPNKJwQVa1ateSiiy4yfZ1InQDAneM2dejQIdWz4jkUTsjX1VdfzbhOAODSUcK1b1NGRkaqZ8dzKJyQrypVqpi+TpzDDgDclzbRtykxKJxQaF8nUicAcAfOSZd4FE4otK9TcDRxUicAcDbOSZd4FE4oFOewAwDnI21KDgonxHQOO1InAHAm0qbkoHCCJaROAOBcpE3JQ+EES0idAMC5SJuSh8IJlpE6AYDzkDYlF4UTLCN1AgDnIW1KLgonxITUCQCcg7Qp+SicEBNSJwBwDtImnxVOCxculE6dOkmNGjUkLS1N3nrrrdz7Dh8+LIMHD5bGjRtL6dKlzTQ33XSTbNq0Kew5ateubR4behk9enQKWuMfpE4AkHqkTT4snDSxaNq0qUyYMCHPffv27ZOvv/5aHnroIfN39uzZsnr1arn88svzTDtixAjJzs7Ovdxxxx1JaoE/kToBQOqRNqVGcUmhjh07mks0ZcuWlY8++ijstn/+859y9tlny4YNG8ypQIKOP/54qVatWsLnF+Gp0+TJk03qdN9996V6dgDAl2nT2LFjSZv8VDjFaufOnWZXXLly5cJu111zjz76qCmmunXrJvfcc48UL55/0w4ePGguQbt27TJ/c3JyzCWUXg8EAnlu97rC2l2zZk255ZZbZMyYMdKnTx+zO9UL/Li+/dhmRbtpt5uNGjVKqlatKr169cq3TV5rs1WFtTve5eGawunAgQOmz9P1118vZcqUyb39zjvvlDPOOEMqVKggixYtkiFDhpjddePGjcv3uTIzM2X48OF5bt+6dat5ncgFrAWbroT0dP/0pbfS7n79+smKFStk2rRp0rlzZ/ECP65vP7ZZ0W7a7Va6jVu1apUMGzZMdu/ebS5eb3MsCmt3fsvLqrSAPrMDaJL05ptvypVXXpnnPu0o3rVrV9m4caN88sknYYVTJN19pAnInj17JCMjw3LipAmKdniOfG5dAVpQ6X5kv73xrLRbiyft1L9mzRpPpE5+XN9+bLOi3bTbrTRlmjt3rvz8888F7qbzUptjUVi7dZtfvnx5U1wVVE+4NnHSoumaa66R9evXy/z58wttZMuWLeXIkSOybt06OeWUU6JOowVVtKJKF3C0haxFXX73eZmVdmvCN2nSJJk4caJn+jr5cX37sc2KdtNuN/ZteuWVV0zfJis/Vr3Q5qIoqN3xLot0NxRNmmZ8/PHHUrFixUIfo7uOdKFUqVIlKfPodxxhBwDJw5F0qZfSwkl3p2mhoxe1du1a8389ak6LpquuukqWLVsm06dPl6NHj8rmzZvN5dChQ2b6xYsXy9NPPy3ffvut/Prrr2Y67Rh+4403mhgOycG4TgCQeIzb5AwpLZy0KGrevLm5qAEDBpj/P/zww/L777/LO++8Y/o1NWvWTKpXr5570U7gSne3vf7663L++edLw4YNTSWuhdOLL76Yymb5DqkTACQeaZMzpLSPU9u2bU2v9/wU1m9dj6b78ssvEzBniBXjOgFA4jBuk3M4uo8T3IPUCQASh7TJOSicYBv6OgGA/ejb5CwUTrANqRMA2I+0yVkonGArUicAsA9pk/NQOMFWpE4AYB/SJuehcILtSJ0AIH6kTc5E4QTbkToBQPxIm5yJwgkJQeoEAEVH2uRcFE5ICFInACg60ibnonBCwpA6AUDsSJucjcIJCUPqBACxI21yNgonJBSpEwBYR9rkfBROSChSJwCwjrTJ+SickHCkTgBQONImd6BwQsKROgFA4Uib3IHCCUlB6gQA+SNtcg8KJyQFqRMA5I+0yT0onJA0pE4AkBdpk7tQOCFpSJ0AIC/SJnehcEJKUqfnnnsu1bMCAClH2uQ+FE5ISer05JNPkjoB8D3SJvehcELS0dcJAEib3IrCCUlHXycAIG1yKwonpASpEwA/I21yLwonpASpEwA/I21yLwonpAypEwA/Im1yNwonpAypEwA/Im1yNwonpBSpEwA/IW1yPwonpBSpEwA/IW1yPwonpBypEwA/IG3yBgonpBypEwA/IG3yBgonOAKpEwAvI23yDgonOAKpEwAvI23yDgonOAapEwAvIm3yFgonOAapEwAvIm3yFgonOAqpEwAvIW3yHgonOAqpEwAvIW3yHgonOA6pEwAvIG3yJgonOA6pEwAvIG3yJgonOBKpEwA3I23yLgonOBKpEwA3I23yLgonOBapEwA3Im3yNgonOBapEwA3Im3yNgonOBqpEwA3IW3yPgonOBqpEwA3IW3yPgonOB6pEwA3IG3yBwonOB6pEwA3IG3yBwonuAKpEwAnI23yDwoneDp1yt65XxZlbTN/ASBR3xukTf5B4QTPpk4zlm6Qc0fPl24vLTF/9ToA2P29QdrkLxRO8GTqpL8Uh8z+XnIC/7uuf4fOXknyBMD27w3SJn9JaeG0cOFC6dSpk9SoUUPS0tLkrbfeCrs/EAjIww8/LNWrVzdVfPv27WXNmjVh0/z5559yww03SJkyZaRcuXJyyy23yJ49e5LcEjgtdVq7bW/ul1/Q0UBA1m3bl9gZBOBaRfneIG3yn5QWTpoaNG3aVCZMmBD1fk0Wnn32WXnhhRdkyZIlUrp0aenQoYMcOHAgdxotmn744Qf56KOP5L333jPFGFW/d1lNnepUKi3paeG3FUtLk9qVSiV+JgG4UlG+N0ib/CelhVPHjh3lsccek86dO+e5T9Omp59+Wh588EG54oorpEmTJvLKK6/Ipk2bcpOpH3/8UebMmSP/+te/pGXLltK6dWsZP368vP7662Y6+Dd1ql72WMns0th86Sn9O6pLI3M7ANjxvUHa5E/FxaHWrl0rmzdvNrvngsqWLWsKpMWLF8t1111n/uruuTPPPDN3Gp0+PT3dJFTRCjJ18OBBcwnatWuX+ZuTk2MuofS6FnGRt3udk9tds2ZNs0t2zJgx0qdPH5NERnN1ixOldf2Ksn77PjmpYinz5VdYe+xqt/aJ0Hhff6k6vVhz8rpOJNrt/Hbb+Tmy2u5YvjdGjRolVatWlV69ejlyebppXSez3fEuD8cWTlo0KX1ThtLrwfv0b5UqVcLuL168uFSoUCF3mmgyMzNl+PDheW7funVr2G7A4ALeuXOnWQlakPmF09vdr18/WbFihUybNi3fAlkVE5G6x2m1vFu2bNmdlHa/s3KbjJ633vSV0Nj//nYnyeWNKolTOX1dJwrtdna77f4cxdJuK98b2dnZsmrVKhk2bJjs3r3bXJzGLes62e2Od105tnBKpCFDhsiAAQPCEidNMXQ/tXYyj1wB2nFd7/PbG8/J7daCuVmzZqYAvvHGG/NNnZLdbv2FPHre8rCjch6ft14ua1HHscmT09d1otBu57Y7EZ8ju9utXQZ+++0308/Wqbvp3LCuU9HukiVLerNwqlatmvn7xx9/mKPqgvS6bjCD02zZsiXscUeOHDFH2gUfH01GRoa5RNIFHG0h6wrI7z4vc3q7tQCeNGmSTJw4Ue677z5HtHv9n/ujHJUjsuHPA3JCeXuKOz+u60Sh3c5sd6I+R3a1W/s2aZ/bsWPH2vajza/rOhXtjndZOHZJ1qlTxxQ/8+bNC0uGtO9Sq1atzHX9u2PHDlm+fHnuNPPnzzfVpvaFgrc58Rx2yT6aj5HRkQqJft85/ahYjqTzt5QWTjrekvZT0UuwQ7j+f8OGDaZavPvuu81Rd++88458//33ctNNN5kxn6688koz/WmnnSaXXHKJ9O7dW7766iv54osv5Pbbbzcdx3U6eJ/TzmGXzKP5GBkdqZCM952Tj4rlSDoUaVedHpGmyc/69etl3759pvJu3ry5SYlisWzZMrngggtyrwf7HXXv3l2mTp0qgwYNMkmCVvWaLOlwAzr8QOj+yenTp5tiqV27diZ+69q1qxn7Cf5LnW677TZHxObXnlVL2jSonNCj6vIb4Vhf1wkbF3hTMt93yfgcFQVpE2IqnDTReeaZZ+Tdd9+Vw4cPm+EBtOLWPkVaTNWtW9e8mfr27SvHH398oc/Xtm1b0+s9P5o6jRgxwlzyo0fQvfrqq7E0Ax5MnSZPnmxSJzv7OsVDv+QT+UVf0AjHdr6ubij1tXTXiVM2XEjdekvW+y5Zn6Oipk3at4m0yb8s76q7/PLL5dprr5XatWvLhx9+aA7n2759u2zcuNGkTnoqFB2sUvskNWjQwIzkDfi1r1OiJaMPCLsC3SmR683pfY8SjbQJMRVOl112memDpBun8847L0+1rWmT7mLTXWlaPPmtBz9Sy2l9nRIt0X1AknGSZL93bE9E+xO93pzc9yjR6NuEmHfV6QjNVp1++unmAvi5r1OiJbIPSKJ3yWgKEtzAa4KhG2Ntj1N3Udn9vIlqfzJ2pTm171GikTYhKN2OI+N0mIDQC5AKfkudlG60WtWraPvGK5G7ZBKViiRqF5Xdz5vIVChZu9IS9b5zKtImxF046S473XWnv+q1g3j58uXNRc8bp3+BVPBjX6dESeQumYJSEacVI4l43kS0P8jPu9ISibQJcQ9HoKe40KPh9EgmPXecHv0GOIETj7Bzq0TtkgmmIqHFQ7ypSKJ2USXieRPR/lB+3ZWWKBxJB1sKp2+//daM1n3KKacU5eFAwvixr1MiJeJw8GAqosmNFiF2pCKJKkYS8byJaH+016BgsgdpE2wpnM466yxzckMKJzgRqZPz2Z2KJKoYSdTzkgq5A2kTbCuc/vWvf5lBLn///Xdp1KiRHHPMMWH3N2nSpChPC9iC1Mkd7E5FElWMJOp5SYWcj7QJthVOW7dulaysLOnZs2fubdrPSfs96d+jR48W5WkB25A6+VOiihGKHP8hbYKthZP+mtdz07322mt0DocjkToBiAdpE2wtnPTkvu+8847Ur1+/KA8HkoLUCUBRkDbB9nGcLrzwQnNkHeBkjOsEoChIm2B74tSpUye555575Pvvv5fGjRvn6RyuJwQGnIDUCUAsSJuQkMJJj6hTI0aMyHMfncPhJPR1AhAL0iYkZFddTk5OvheKJjiNH89hByB2nJMOSTnJL+B09HUCYAVpE2wtnF5//XWrk5pRxb/44gvL0wOJRuoEoCCkTbC9cNINzmmnnWZ+tf/444957t+5c6e8//770q1bNznjjDNk+/btlmcCSDRSJwAFIW2C7YXTp59+Ko8//rh89NFH5jQrZcqUkZNPPtkcVXfiiSdKxYoVzYapVq1asnLlSo6sg+OQOgGIhrQJCTuqToshvWzbtk0+//xzMxDm/v37pVKlSmYkcb2kp9NtCs7EEXYAoiFtQsKHI9BC6corryzKQ4GUYlwnAKEYtwmxIh6Cr9DXCUAo0ibEisIJvkNfJwCKvk0oCgon+A6pEwBF2oSioHCCL5E6Af5G2oSionCCL5E6Af5G2oSkHlWn56ObOnWqzJs3T7Zs2WLOURdq/vz5RZ4hIFk4wg7wJ46kQ9ILp7vuussUTpdddpkZDDMtLS2umQBSgXGdAH8ibULSCyc9b93MmTPl0ksvjevFgVQjdQL8JSsri7QJye/jVKJECalfv358rww4AH2dAH/JzMwkbULyC6d7771XnnnmGQkEAvG9OuAAHGEH+EN2drZMmzaNI+mQnF11Xbp0ydMB/IMPPpCGDRvKMcccE3bf7Nmz45srIEWpU58+fVI9OwASRLuYkDYhaYVT2bJlw6537tw57hcHnNbXaeLEiXLjjTemenYAJKBv04IFC2TQoEGkTUhO4TRlypT4XglwQeo0ZswYueqqq1I9OwAS0LdJA4BevXqlelbgxz5OF154oezYsSPP7bt27TL3AW7u66S7oAF4a9wm7dukP4pIm5CSwumTTz6RQ4cO5bn9wIED8tlnn8U9U0CqUqeePXvKrFmzOMIO8Ni4TVWqVJGLL7441bMCv43j9N133+X+f9WqVbJ58+aw0cTnzJkjJ5xwgr1zCCSRHm1z3XXXmb5OjOsEeGeU8HHjxklGRkaqZwd+K5yaNWtmRgnXS7RdchqBjh8/3s75A5KqVq1actFFF5m+TowmDngnbbrllltk9+7dqZ4d+G1X3dq1a82RCTp+01dffWWuBy+///676eOkHWwBN7v66qsZ1wnwUNrEuE1IWeKkfUAOHz4s3bt3l4oVK5rrgNfor1Pt68Q57ABvpE29e/dO9azAz53DdbDLN998MzFzAziE/kIldQLci7QJjjqq7oorrpC33nrL/rkBHNTXiXPYAe5F2gRH7KoLOvnkk2XEiBHyxRdfSIsWLfLsyrjzzjvtmj8g5aOJa+rEEXaAO4+kI22CIwqnSZMmSbly5WT58uXmEkqPuKNwgtfOYUdfJ8A9SJvguMJJj6ID/IDUCXAX0iY4so9TKB2aQC+A11Mn+joBzkfaBMcWTq+88oo0btzYVPR6adKkianyAa+ew44j7ABn40g6OLZw0ghU+3xceumlMnPmTHO55JJLpG/fvvLUU0/ZP5dACpE6Ae5A2gTHFk56WhX99f3444/L5Zdfbi66UXnuuefk2WeftX8ugRQjdQKcjbQJji6csrOz5Zxzzslzu96m9wFeQ+oEOBtpExxdONWvX9/snos0Y8YMM8aTnWrXrp17YuHQS//+/c39bdu2zXOf7jIE7EbqBDgTaRMcPxzB8OHD5dprr5WFCxfKueeea27TwTDnzZsXtaCKx9KlS+Xo0aO511euXGnOXq8nYg3SXxg6IGdQqVKlbJ0HoKjjOmXv3C9rt+2VOpVKS/WyfKEDVsT6uSFtguMLp65du8qSJUtMR/DgqVdOO+00+eqrr6R58+a2zmDlypXDro8ePVrq1asn559/flihVK1aNVtfF4h3XKcZSzfIkNnfS05AJD1NJLNLY7n2rFpJm1fAjWL93DBuE1xROCk91cq0adMkmQ4dOmRec8CAAWaXXND06dPN7Vo8derUSR566KECU6eDBw+aS9CuXbvM35ycHHMJpdd1nKrI272Odkdvd82aNeWWW26RMWPGSJ8+ffJNnfQXc/DL3zxvQGTo7O+ldf2KtiRP+vzrtu2T2pVKxf18rGva7YT3YVE/N6NGjTLf/fq5LKhNflzffmyzlXbHuzyKXDilgqZbO3bskB49euTe1q1bN7MLpUaNGvLdd9/J4MGDZfXq1TJ79ux8nyczM9Psboy0detWOXDgQJ4FvHPnTrMS0tPjHi/UNWh3/u3u16+frFixwhTrnTt3jjrNit925375Bx0NiKz4ZZMUq3l8XPP4zsptMnre+txf5Pe3O0kub1SpyM/HuqbdTngfFuVzowcjrVq1SoYNGya7d+82l/z4cX37sc1W2l3Q+8SKtEAMw37rDIQmPVGfMC1Njhw5IonQoUMHKVGihLz77rv5TjN//nxp166diW91l57VxEmTBO34W6ZMmTwrQAsq3WXotzce7c6/3Vo8aSG/Zs2aqKmT/nI+74lPwjYCxdJEFg5qG9cv80Q8r7b5h19/l11SUupWPs43fbH8+h7//a998m3WJmlar4acUL5o/UGd8v7u1auXfPjhh+bHcmG76fy4vv3YZivt1m1++fLlTXEVuc23PXF68803871v8eLFZgynREWC69evl48//rjAJEm1bNnS/C2ocMrIyDCXSLqAoy1kLQbzu8/LaHf+7R4yZIg52fXEiROj9nU6oXxp0zdj6OyVcjQQkGJpaTKqSyNzezzW/7k/6i/yDX8eKPJzz1j2mzzw5kpb+mK5rTO8W97jdi3X8P5Da4q8rhPxPoz1c6Pf8XoGC+3bZPUE3G5Z33byY5sLa3e8yyKmwumKK67Ic5tW+noIqKZAN9xwQ9jRbXaaMmWKOWrisssuK3A63YWiqlevnpD5AKweYacbpDYNKtvaB0Q3nFrchP8iTzPPX9QNcrBo+r8+JSvNfMc6v3Z2hrejUPDKc9i1XKP3Hyraurb7fViUzw1H0iFVilx2bdq0ybxh9Xx1umtOC5aXX37ZbFDspimWFk7du3eX4sX/r9bLysqSRx99VJYvXy7r1q2Td955R2666SZp06aNOXcekOpxnfRLv1U9ezqEB59PN5y6kVLBX+RFfX7doOdNDgJmo2XHRllvL0qhcO7o+dLtpSXmr17363PYuVztWteJeB/G+rlh3CakUsydw3WfoB7FoKddadasmRm76bzzzpNE0l10GzZsML/wQ2l/J73v6aefNqM5az8lHSrhwQcfTOj8AEUd18kOdiZZdiUHBW2UY5k/O1IRLz2HXcs1ESlRIhJVq0ib4JrESTcQdevWlffee09ee+01WbRoUcKLJnXxxReb3vENGjQIu10LpU8//VS2b99ujobTjro6j0Xp7AW4aTRxu5IsffzIzo3MBjWe5CC4UQ5ldwHmx+ewa7mGp0TB55G4UyK7E1UrSJvgqsQp+EbVU67objm9RFNYB27AK1KVOtnp2jNrSsPyabIn7VipU8Sj6oIb5chOvalIRbz0HHYt19CUSMdE0sP7m9XXo+rc934lbYKrCiftP1TYcASA38QymrhTVTm+hDSqUjGuo03s2HVjR6HgpedIxC4xfbyOiVTFBUc9RmKUcDhBTOM4eZWO6VC2bNmoYzpox/QtW7aYXzh+OpyTdsfWbh1FXIfrWLt2retSJyeuaztGpC7sOay0OxnzkWxOXN9W9ezZU+bOnWsODIq1cHJzu4vKj2220u6CtvlW+GdJAh7s6+RVdvSd8dJzgL5NcA4KJ8Dmvk56hCcAe9G3CU5B4QTYhNQJSAzSJjgJhRNgE1InIDFIm+AkFE6AjUidAHuRNsFpKJwAG5E6AfYibYLTUDgBNiN1AuxB2gQnonACbEbqBNiDtAlOROEEJACpExAf0iY4FYUTkACkTkB8SJvgVBROQIKQOgFFQ9oEJ6NwAhKE1AkoGtImOBmFE5BApE5AbEib4HQUTkACkToBsSFtgtNROAFJSJ127Nghzz33XKpnBXBF2jR48GDSJjgWhROQhNSpZ8+epE6AxbTp1ltvTfWsAPmicAKSgNQJKBh9m+AWFE5AEtDXCSgYfZvgFhROQJKQOgHRkTbBTSicgCQhdQKiI22Cm1A4AUlE6gSEI22C21A4AUlE6gSEI22C21A4AUlG6gT8D2kT3IjCCUgyUifgf0ib4EYUTkAKkDrB70ib4FYUTkAKkDrB70ib4FYUTkCKkDrBr0ib4GYUTkCKkDrBr0ib4GYUToBLUqfsnftlUdY28xdwGqvvT9ImuB2FE+CC1GnG0g1y7uj50u2lJeavXi+KeIuvVD3e649L5WPteHws70/SJrhd8VTPAOB3mjpNnjzZpE4DBw7Mc79uzIbM/l5yAv+7rn+Hzl4pbRpUluplrf9i141Z8HnS00QyuzSWa8+q5fjHe/1xqXysHY+P5f0ZTJvGjRtH2gTXInECHJ46rd22N3ejFHQ0EJB12/bFvXGzmjCk6vFef1wqH2vH42N9f5I2wQsonACH93WqU6m0SQJCFUtLk9qVSll+/niLr1Q93uuPS+Vj7Xh8LO9P+jbBKyicAIenTrq7Q3ef6MZI6d9RXRrFtJsu3uIrVY/3+uNS+Vg7Hh/L+5O0CV5B4QS4IHXSPief33+BvNb7b+ZvLH1Q7Ci+UvV4rz8ulY+14/FW35+kTfCStEAgEBHU+s+uXbukbNmysnPnTilTpkzYfTk5ObJlyxbzSyk93T91Ju1OTbv79Okjs2fPlnXr1knp0qVtf37tu6K7YTRRCG4cY2lztMfH+/qpelxB7U72fCbzsdHaHe96LUzPnj1l7ty5kpWVlbLCKdWf7VTwY5uttLugbb4VHFUHuOgIu3jpRjGeDWOqHu/1x6XysXY8viAcSQev8U8JCrgAo4nDa+jbBK+hcAIchnPYwSvo2wQvonACHIbUCV5B2gQvonACHIjUCW5H2gSvonACHIjUCW5H2gSvonACHIrUCW5F2gQvo3ACHIrUCW5F2gQvo3ACHIzUCW5D2gSvo3ACHIzUCW5D2gSvo3ACXJA66akBJkyYkOpZASylTYMHDyZtgmc5unB65JFHJC0tLexy6qmn5t5/4MAB6d+/v1SsWFGOO+446dq1q/zxxx8pnWcgUanTk08+SeoEx6dNlStXlltvvTXVswL4s3BSDRs2lOzs7NzL559/nnvfPffcI++++6688cYb8umnn8qmTZukS5cuKZ1fIBGGDBliUif6OsGp6NsEv3B84VS8eHGpVq1a7qVSpUrmdt2ITJo0yZw48sILL5QWLVrIlClTZNGiRfLll1+merYBW9HXCU5H2gS/KC4Ot2bNGqlRo4aULFlSWrVqJZmZmVKrVi1Zvny5HD58WNq3b587re7G0/sWL14sf/vb3/J9zoMHD5pL0K5du8zfnJwccwml1wOBQJ7bvY52O6/d+kt+6tSpJnW69957fdHmRKLd9rU7KytLpk+fbnYnZ2RkOHKZ+nF9+7HNVtod7/JwdOHUsmVLs6E45ZRTzG664cOHy3nnnScrV66UzZs3S4kSJaRcuXJhj6lataq5ryBafOlzRdq6davpNxW5gDXd0pWQnu74gM42tNt57dYfD4MGDZK5c+fK1Vdfba57vc2JRLvta/fkyZOlbdu2cuWVV8qWLVvEify4vv3YZivt3r17t3i2cOrYsWPu/5s0aWIKKd1lMXPmzLj2oWt/kQEDBoQlTjVr1jQxc5kyZfKsAO2Urvf57Y1Hu53X7uDuOu3XZ1fq5PQ2JwrttqfdmjaNHTvWpE36PepUflzffmyzlXbH+6PT0YVTJE2XGjRoYDohXnTRRXLo0CEzOGBo6qRH1WlfqIJolKyXSLqAoy1kXQH53edltNt57a5du7b06NHDFE/9+vWT0qVLe77NiUS742/3qFGjzJHN2rfJ6cvRj+vbj20urN3xLgtXLck9e/aYXzfVq1c3ncGPOeYYmTdvXu79q1evlg0bNpi+UIBXcYQdnIIj6eBHji6c7rvvPjPMwLp168zRcp07d5ZixYrJ9ddfL2XLlpVbbrnF7HJbsGCB6Szes2dPUzQV1DEccDuOsItN9s79sihrm/mbiOn9jCPp4EeO3lW3ceNGUyRt377dfDhbt25thhrQ/6unnnrKRG468KUeJdehQwd+hcM3qZN2yNX3+8CBA/OdTjf+a7ftlTqVSkv1stYTgWQ+LtbHxDL9jKUbZMjs7yUnIJKeJpLZpbFce1Yt26Yvyvw7/TFWHxdMm7R/E2kT/CQtoN3OfU47h2uCpbs/onUO16NE9NxLftpHTLud3+6+ffvKrFmzTCIbra+T1SIgss1FKR5ieb14HhPL9LrxP3f0fDNtULG0NPn8/gtMMRDZ7sKmT1Wb7X5MYe9xq6+lCf+cOXPk119/dUXh5KbPtl382GYr7S5om2+Ff5Yk4KO+TloEBDd+Sv8Onb2y0N1PyXxcrI+JdXpNTEKLIHU0EJB12/bZMn0y2pzMx8TyOPo2wc8onAAP9nWKtQhIxeMSXdjobiZNTEJpglS7Uilbpk9Gm5P5mFgeR98m+BmFE+DB1CnWIiAVj0t0YaO713Q3k04TnHZUl0b57naLdfpktDmZj7H6ONIm+B2FE+DB1CnWIiAVj0t0YaO0b472UXqt99/M38L6BcUyfTLanMzHWH0caRP8js7hdA6Pina7p93r16+Xk08+2WzQIo+w074puptFE4P8NprR2mzlcdEU5XGxPqao85aodZ2MNtv5GCvtzu+1NG3Sc4LqkXR33XWXuIkbP9vx8mObk9E53NHDEQCILXWKHE1cN3pFKS6S+bhYH1PUeUuUZLQ5mY8p6HGkTQC76gBPYDRxJBp9m4D/oXACPIDRxJFopE3A/1A4AR5B6oREIW0C/g+FE+ARpE5IFNIm4P9QOAEeQuoEu5E2AeEonACPpk579uxJ9ezAA0ibgHAUToBHU6fnn38+1bMClyNtAvKicAI8hr5OsAtpE5AXhRPgQfR1QrxIm4DoKJwADyJ1QrxIm4DoKJwAjyJ1QlGRNgH5o3ACPMrrqZOeiHZR1jbz165pE/GcbkTaBOSPk/wCHk+dJk+ebFKngQMHpmQetLBYu22v1KlUutATzlqddsbSDTJk9veSExBJTxPJ7NJYrj2rVlzTJuI5E7kMEp02jR07lrQJiILECfB56qQb6uW/7bacnMSStGiBce7o+dLtpSXmr16Pd1p93WDRovTv0Nkro86P1WkT8ZyJXAbxJF+FrW/SJqBgFE6Aj/s66Yb5vCc+kf6zfjZ/C9tQx7JhT1QxomlMcLqgo4GArNu2r8jTJuI5E12QFaXQKmx907cJKByFE+DT1CnWDXWs0yeqGNFdWLp7LFSxtDSpXalUkadNxHPG2q5Ypk3U+iNtAgpH4QT4NHWKdUMd6/SJKka034/2KdL7g9ON6tIoan8gq9Mm4jkTuQwSsf5ImwBr6BwO+Cx16tevn5QuXTp3Qx26MS1oQx3r9MECQ1MN3UBbKUasTKu0I3abBpXNRl9fv6BO1FanTcRzJnIZ2L3+SJsAa9ICgUDEbxD/2bVrl5QtW9b8Ii9TpkzYfTk5ObJlyxapUqWKpKf7J6Cj3d5r9/r16+Xkk082G8jgEXbax2Xo7O/laEA3oiKjCjk67H/Th2/YC5pe6a4gK8VIrNO6aV0nahnEuj7yW9+aNp166qnmSLq77rpLvMjLn+38+LHNVtpd0DbfCgonCqeoaLc32923b1+ZNWuWrFu3zqRO6ve/9sqKXzZJs/o15ITy/7vNKcVNInllXce6PqKt7549e8qcOXPk119/9exuOq+s71j4sc3JKJz8syQBRO3rpBvbFjWPt1wE6XSt6lV0ddHkJbGuj8j1Td8mIDYUToCPeH00ccSOvk1AbCicAJ/hHHYIIm0CYkfhBPg4ddqzZ0+qZwcpRNoExI7CCfBx6vT888+nelaQIllZWaRNQBFQOAE+RF8nZGZmkjYBRUDhBPg8dXrhhRdSPStIsuzsbJk2bRppE1AEFE6Az1OnMWPGyIEDB8SJ4xMtytpW4ElurU7n1OdKlZkzZ5I2AUXEKVcAn6dOU6dOlffff98MjpkMWkjoedP0FCD5jT2kI1wHT0irpwnRU5FEGxHbynROfa5YlofdfZsWLFgggwYNIm0CioDECfB56qSjRs+ePTvuvk5WEhYtKM4dPV+6vbTE/NXr0Z4nWHQo/aunFYl8XivTOfW5YlkedqdY2rdJR0vu1atXkZ8D8DMKJ8DnBg8ebIqmaH2drG6o7SyINH0JPRGt0nOx6WlFYp3Oqc8Va4FlV5Gl4zZp36arrrqKtAkoIgonwOdq1aolF110kenrFJo6Wd1Q210Q6S4r3b0VSk9gq+dii3U6pz5XLMvDziIrOG5Thw4doj4OQOEonACYBCJ0NPFYNtR2F0Taz0f7BOl9wWlGdWmUp/+Plemc+lyxLA+7iqzF3/5oxm3Svk0ZGRl5HgfAGjqHAzBnEde+TjquU79+/WTttv35bqjzKwBCpy+oINKNuD5XfgWF0o7UbRpUNq+nz5Nfp2kr0zn1uWJZHlaXcUFF1uMTppi0Sfs27d69O+p8AygchROA3L5OkyZNMqnTjbfebnlDnYiCKPi8Vo4yszKdU5/L6vKIt8jS6x/MfFmeGD7U9G2icAKKjsIJQG5fp+Bo4po6Wd1QJ6og8guryyOeIqv+jqWy/9h0xm0CbEDhBCBsXKfJkyeb1GngwIGWiyFFQeTMIkv2bJHzWlwuY8eONWlTTk5OUuYV8Co6hwOIeg67PXv2mI10q3oVKYhcKLjuXnz6CUYJB2xE4QQg6jnsnn/++VTPCuKk4zbpkXSckw6wD4UTgHxTp3hHE0dqBcdtIm0C7EPhBCDf1Ck4rpPT2XFyXjtP8OsEpE1AYtA5HECBqZMeYVe6dOmEvI6VE9wWNk1RT857dYsT436OaCfutaNNdiBtAhKDxAlAQlKnwtIZK6d0KWwaO07Oa+cJfu1ok9XlVxDSJiBxKJwAxNTXycoGPRkFT7wn512//X/T6LR2nOA32QVYQeuDtAlIHAonAJZTJysb9EQXPKHTxHNy3pMq/m8andaOE/za1aZYzhMYbX2QNgE+LpwyMzPlrLPOkuOPP96cS+vKK6+U1atXh03Ttm1bSUtLC7v07ds3ZfMMeDV1ysrebmmDnuiCJ3QaO07Oa9cJfu1qk9UT+uZXYD2UOY60CfBr5/BPP/1U+vfvb4qnI0eOyNChQ+Xiiy+WVatWhXVW7d27t4wYMSL3eqlSec+nBSC+0cSfnfK65ARqF3riXysnpLVy7jWr52cr6sl5Q0fQtuMEv3a1yeoJffMrsN6Zv0hGkTYB/iyc5syZE3Z96tSpJnlavny5tGnTJqxQqlatWgrmEPBP6jR1/JNSsceEPCePzTi8UzZuDE+dBl1wojyxYGPuEWgDLzhBju7eLhtDzi17bvV0eaP7qbJxxyE5sVwJqXJcumzcuDHseaxME1QzQ+To7v1hr1HQNIFAwOyGPHz4sEmqi/Ickexqk5XlV/LwoTwFlgRypEz6IdImwK+FUyT9klMVKlQIu3369Okybdo0Uzx16tRJHnrooQJTp4MHD5pL0K5du8xf/QUaeR4nva5fsH47vxPt9k+7rbRZ+8voZ2zbB+Ol/MX9JC29mARyjsq2D5+Ts574KOpjih1XUYqXry5H/sqW/k9sl/7iLOnp6XLGGWfI119/7cj1bWX5lW58Udj6+OvD5+Sxu/pKRkZGvm3y43vcr+32Y5uttDve5ZEW0Gd3AW3o5ZdfLjt27JDPP/889/YXX3zR/CKuUaOGfPfddzJ48GA5++yzZfbs2fk+1yOPPCLDhw/Pc/vPP/9s+lNFvq4WbGXLljVftH5Bu/3Tbqtt1h8Ya9askb8OimzdL1L5WJHyGeL6trt9PYeuj+plS8rpp5+em6BF48f3uF/b7cc2W2n37t27pUGDBmaaMmXKiGcLp9tuu00++OADUzSdeOL/DVwXaf78+dKuXTtzZEm9evUsJ041a9aUv/76K89C1BWwdetW09nSb2882u2PdvuxzYp2026v82ObrbRbt/nly5cvcuHkil11t99+u7z33nuycOHCAosm1bJlS/O3oMJJY2y9RNIFHG0h66+3/O7zMtrtn3b7sc2KdtNur/Njmwtrd7zLwtGFk4Zhd9xxh7z55pvyySefSJ06dQp9zIoVK8zf6tWrJ2EOAQCAnzi6cNKhCF599VV5++23Td+jzZs3m9t1v6UeapuVlWXuv/TSS6VixYqmj9M999xjjrhr0qRJqmcfAAB4jKMLp+effz53kMtQU6ZMkR49ekiJEiXk448/lqefftqcEkL7KXXt2lUefPDBFM0xAADwMkcXToX1W9dCSQfJBAAASAZ/9RYDAACIA4UTAACARRROAAAAFlE4AQAAWEThBAAAYBGFEwAAgEUUTgAAABZROAEAAFhE4QQAAGARhRMAAIBFFE4AAAAWUTgBAABYROEEAABgEYUTAACARRROAAAAFlE4AQAAWEThBAAAYBGFEwAAgEUUTgAAABZROAEAAFhE4QQAAGARhRMAAIBFFE4AAAAWUTgBAABYROEEAABgEYUTAACARRROAAAAFlE4AQAAWEThBAAAYBGFEwAAgEUUTgAAABZROAEAAFhE4QQAAGARhRMAAIBFFE4AAAAWUTgBAABYROEEAABgEYUTAACARRROAAAAFlE4AQAAWEThBAAAYBGFEwAAgEUUTgAAABZROAEAAFhE4QQAAGARhRMAAIBFFE4AAAAWUTgBAABYROEEAABgEYUTAACARRROAAAAfiucJkyYILVr15aSJUtKy5Yt5auvvkr1LAFwsI8//ljatGlj/gKArwqnGTNmyIABA2TYsGHy9ddfS9OmTaVDhw6yZcuWVM8aAAcKBALywAMPyJo1a8xfvQ4Avimcxo0bJ71795aePXvK6aefLi+88IKUKlVKJk+enOpZA+BAH374oSxbtsz8X//qdQCwori43KFDh2T58uUyZMiQ3NvS09Olffv2snjx4qiPOXjwoLkE7dq1y/zNyckxl1B6XX+NRt7udbTbP+32W5u1rQ8++KAUK1ZMjh49av7qdf3OSEtLE6/z2/r2c7v92GYr7Y53ebi+cNq2bZv58qtatWrY7Xr9p59+ivqYzMxMGT58eJ7bt27dKgcOHMizgHfu3GlWghZkfkG7/dNuv7V5wYIFuWmT0u8PvT5z5ky54IILxOv8tr793G4/ttlKu3fv3i2+LpyKQtMp7RMVmjjVrFlTKleuLGXKlMmzAvRXqN7ntzce7fZHu/3UZv0i1V37wbQpSK/r7ddcc43nUyc/rW+/t9uPbbbSbj2IzNeFU6VKlcyX3h9//BF2u16vVq1a1MdkZGSYSyRdwNEWsq6A/O7zMtrtn3b7pc1z584NS5siUyc9wk4PLPE6v6zvSH5stx/bXFi7410Wrl+SJUqUkBYtWsi8efPCqk293qpVq5TOGwBnpU0PPfRQvl+aervezxF2ADydOCnd7da9e3c588wz5eyzz5ann35a9u7da46yA4DggSQbNmwosMPob7/9ZqaLlkgDgGcKp2uvvdZ07H744Ydl8+bN0qxZM5kzZ06eDuMA/EuLoaVLl5rvimCh9Oeff0qFChVyU6gqVapQNAHwfuGkbr/9dnMBgPzoQSB6CRZOOkiuFkt+6/8BoOj4tgAAALCIwgkAAMAiCicAAACLKJwAAAAsonACAACwiMIJAADAIgonAAAAiyicAAAALKJwAgAAsIjCCQAAwCIKJwAAAIsonAAAACyicAIAALCouNUJvSwQCJi/u3btynOfnkF99+7dUrJkSV+dQZ12+6fdfmyzot202+v82GYr7Q5u64Pb/lhROImYBaxq1qyZ6lkBAABJ2vaXLVs25selBYpacnmsOt20aZMcf/zxkpaWlqcy1YLqt99+kzJlyohf0G7/tNuPbVa0m3Z7nR/bbKXdWvZo0VSjRo0iJXEkTtrRKz1dTjzxxAKn0YXvpzdeEO32Dz+2WdFuf/Fju/3Y5sLaXZSkKcg/Oz0BAADiROEEAABgEYVTITIyMmTYsGHmr5/Qbv+0249tVrSbdnudH9ucjHbTORwAAMAiEicAAACLKJwAAAAsonACAACwiMIJAADAIgqnECNHjpRzzjlHSpUqJeXKlYs6zYYNG+Syyy4z01SpUkUGDhwoR44cCZvmk08+kTPOOMP06K9fv75MnTpV3ELnXUdPj3ZZunSpmWbdunVR7//yyy/FzWrXrp2nTaNHjw6b5rvvvpPzzjvPnANJR6Z94oknxK10Pd5yyy1Sp04dOfbYY6VevXrmSJRDhw6FTePFda0mTJhg1rmuy5YtW8pXX30lXpGZmSlnnXWWORuCfk9deeWVsnr16rBp2rZtm2e99u3bV9zskUceydOmU089Nff+AwcOSP/+/aVixYpy3HHHSdeuXeWPP/4Qt4v23aUXbatX1vXChQulU6dOZrRvnf+33nor7H49zu3hhx+W6tWrm++z9u3by5o1a8Km+fPPP+WGG24wg2LqNl6///bs2RPzvFA4hdANxtVXXy233XZb1PuPHj1qiiadbtGiRfLyyy+bokhXVtDatWvNNBdccIGsWLFC7r77bunVq5fMnTtX3EALx+zs7LCLzr9uXM8888ywaT/++OOw6Vq0aCFuN2LEiLA23XHHHWHD+F988cVy0kknyfLly+XJJ580X9QvvviiuNFPP/1kTjc0ceJE+eGHH+Spp56SF154QYYOHZpnWq+t6xkzZsiAAQNMofj1119L06ZNpUOHDrJlyxbxgk8//dRsNLXA/eijj+Tw4cPmvbt3796w6Xr37h22Xt38QyCoYcOGYW36/PPPc++755575N1335U33njDLCM91VaXLl3E7fRHbWibdZ0r3Z55ZV3v3bvXfE71B0802p5nn33WfIctWbJESpcubT7TWiwHadGk33W6fN577z1TjN16662xz4wOR4BwU6ZMCZQtWzbP7e+//34gPT09sHnz5tzbnn/++UCZMmUCBw8eNNcHDRoUaNiwYdjjrr322kCHDh0CbnTo0KFA5cqVAyNGjMi9be3atTqEReCbb74JeMlJJ50UeOqpp/K9/7nnnguUL18+d12rwYMHB0455ZSAVzzxxBOBOnXqeH5dn3322YH+/fvnXj969GigRo0agczMzIAXbdmyxazHTz/9NPe2888/P3DXXXcFvGTYsGGBpk2bRr1vx44dgWOOOSbwxhtv5N72448/muWyePHigJfoeq1Xr14gJyfHk+taRAJvvvlm7nVtZ7Vq1QJPPvlk2PrOyMgIvPbaa+b6qlWrzOOWLl2aO80HH3wQSEtLC/z+++8xvT6JUwwWL14sjRs3lqpVq+bephWtJhFaxQan0YgwlE6jt7vRO++8I9u3b5eePXvmue/yyy83uwFat25tpvMC3TWnMX7z5s1NohS6G1bXYZs2baREiRJh61Z3gfz111/iBTt37pQKFSp4el1rYqyJYejnVM9Xqdfd+jm1sl5V5LqdPn26VKpUSRo1aiRDhgyRffv2idvp7hndnVO3bl2TMGj3CqXrXJO30PWuu/Fq1arlqfWu7+9p06bJzTffHHbSei+u69A9PZs3bw5bt3ouOt0FH1y3+ld3z4XuOdHp9bOvCVUsOMlvDHTFhBZNKnhd7ytoGi2u9u/fb/a9usmkSZNMcRB6EmTtGzB27Fg599xzzZtu1qxZpg+F7nPWDaxb3XnnnaZvmm5cdFesfrlopD1u3Ljcdau7LPNb/+XLlxc3++WXX2T8+PEyZswYT6/rbdu2md3u0T6nuvvSa3R3rHYZ0HWoG82gbt26md3OWmRo373BgwebHwGzZ88Wt9INpXafOOWUU8xnd/jw4aZP4sqVK81nVH/0RPZf1fUe/P72Av1s7tixQ3r06OHpdR0quP6ifaZDt8364y9U8eLFzfd9rOvf84XT/fffL48//niB0/z4449hHQi9qCjLYePGjaZv1syZM8Om018t2j8kSDuhal8BTWictjGNpd2hbWrSpIn5ku3Tp4/paOumUxYUZV3//vvvcskll5g+EdoXwo3rGtFpXyctHEL7+qjQvh2apGun2nbt2klWVpY5UMCNOnbsGPYZ1kJKCwb9DnPbj9Z4fuzqctAiycvrOpU8Xzjde++9YZV3NBrpWlGtWrU8R94Ej8jQ+4J/I4/S0Ovaiz+VH9yiLIcpU6aY3VZWNpD6BRXskOiV9a9t0l11emSZ/oLNb92Grn83tlkLIT2YQQ8MsNLR3anr2iotBosVKxZ1XTppPdrh9ttvz+0EG5oa57deg8mjVzammi41aNDAtOmiiy4yu7E0jQlNnby03tevX28O5CgsSfLauq72/9efrkstCoP0erNmzXKniTz4Q7/f9Ui7WNe/5wunypUrm4sdWrVqZYYs0IUfjPx0A6JF0emnn547zfvvvx/2OJ1Gb3fTctD+d1o43XTTTXLMMccUOr0eQRj6hvXC+tc26e6p4LrWdfjAAw+YfhLBZaLrVosqJ+2mi6XNmjRp0aRHyen61va6dV1bpUmitnfevHlmt2Nwd5Ze10LDC/Tzq0eEvvnmm2aIkchdzPmtV+XmdRtJDzXXVOUf//iHWef6udX1rMMQKN1dpX2gUv39bBf9DOv3lR7Z7ad1XadOHVP86LoNFkraPUb7LgWPktd1rEWz9nULHhU8f/5889kPFpKW2dLF3SPWr19vjh4aPnx44LjjjjP/18vu3bvN/UeOHAk0atQocPHFFwdWrFgRmDNnjjnibMiQIbnP8euvvwZKlSoVGDhwoDliY8KECYFixYqZad3k448/NkcgaBsiTZ06NfDqq6+a+/QycuRIc7Th5MmTA261aNEic0SdrtesrKzAtGnTzLq96aabwo7SqFq1auAf//hHYOXKlYHXX3/drOuJEyemdN6LauPGjYH69esH2rVrZ/6fnZ2de/Hyula67vSIG22fHm1z6623BsqVKxd2xKyb3XbbbebI4E8++SRsve7bt8/c/8svv5gjZZctW2aOnHz77bcDdevWDbRp0ybgZvfee69ps7bpiy++CLRv3z5QqVIlc1Sh6tu3b6BWrVqB+fPnm7a3atXKXLxAjwzVtumRvqG8sq53796du03WbdO4cePM/3W7rUaPHm0+w9q+7777LnDFFVeYI4T379+f+xyXXHJJoHnz5oElS5YEPv/888DJJ58cuP7662OeFwqnEN27dzcrJPKyYMGC3GnWrVsX6NixY+DYY481H0j9oB4+fDjseXT6Zs2aBUqUKGHeoDq8gdvom+mcc86Jep9ubE477TRTNOhQDHpod+ghvm60fPnyQMuWLc3GpmTJkqZ9o0aNChw4cCBsum+//TbQunVrs9E94YQTzIfVrfR9Ge39Hvp7yovrOmj8+PFmQ6OfU23Xl19+GfCK/NZr8Ltow4YNZsNZoUIF817WAlp/7O3cuTPgZjr0S/Xq1c061c+nXtfCIUg3ov369TPDiuh7unPnzmE/FNxs7ty5Zh2vXr067HavrOsFCxZEfU/rdjs4JMFDDz1kftxqO/UHYeSy2L59u9m2aTCi32c9e/bMDUZikab/2B+cAQAAeA/jOAEAAFhE4QQAAGARhRMAAIBFFE4AAAAWUTgBAABYROEEAABgEYUTAACARRROAAAAFlE4AUA+9Bxno0aNius55syZY86fpefEAuB+FE4AHKNHjx6SlpaW53LJJZfY8vx6wlt9Pj3ZZ2G+/fZbc8LuO++8M67X1HnXk8tOnz49rucB4AwUTgAcRQuN7OzssMtrr72W9PkYP368XH311XLcccfZUhA+++yztswXgNSicALgKBkZGVKtWrWwS/ny5XPvHzdunDRu3FhKly4tNWvWlH79+smePXty71+/fr106tTJPEanadiwoUmO1q1bJxdccIGZRu/T5EkLmmiOHj0q//nPf8zzhKpdu7Y89thjctNNN5mC6qSTTpJ33nlHtm7dKldccYW5rUmTJrJs2bKwx+nz6G1ZWVk2Ly0AyUbhBMBV0tPTTXrzww8/yMsvvyzz58+XQYMG5d7fv39/OXjwoCxcuFC+//57efzxx01Bo0XWrFmzzDSrV682SdYzzzwT9TW+++472blzp5x55pl57nvqqafk3HPPlW+++UYuu+wy0w9KC6kbb7xRvv76a6lXr565Hnr+9Fq1aknVqlXls88+S8gyAZA8xZP4WgBQqPfeey/P7rGhQ4eai7r77rvzJEB9+/aV5557zty2YcMG6dq1q0mlVN26dXOnr1ChgvlbpUoVKVeuXL7zoKlVsWLFzHSRLr30UunTp4/5/8MPPyzPP/+8nHXWWWa3nho8eLC0atVK/vjjD5OWBdWoUcM8LwB3o3AC4Ci6O02LkVDBgkd9/PHHkpmZKT/99JPs2rVLjhw5IgcOHJB9+/ZJqVKlTGfu2267TT788ENp3769KaJ091ks9u/fb3YZ6u68SKHPpSmSChZpobdt2bIlrHA69thjzTwCcDd21QFwFO2XVL9+/bBLsHDSfkp///vfTfGiu92WL18uEyZMMPcdOnTI/O3Vq5f8+uuvZhea7qrT3W3a0TsWlSpVMkVO8DlD6RFyQcHCKtptkcMP/Pnnn1K5cuWY5gOA81A4AXANLZS0IBk7dqz87W9/kwYNGsimTZvyTKf9mXT33ezZs+Xee++Vl156ydxeokSJ3M7fBdFxl9SqVatsmW9NxLRjePPmzW15PgCpQ+EEwFG0Y/fmzZvDLtu2bTP3afp0+PBhkyBpqvTvf/9bXnjhhbDHax+ouXPnytq1a01n7QULFshpp51m7tOj4DQR0n5UeiRc6NF4oTQZOuOMM+Tzzz+3pU1ffvml2fWnfZ8AuBuFEwBH0ZG2q1evHnZp3bq1ua9p06ZmOAI9Uq5Ro0ZmUEnt7xRK0yQ9sk6LJR0TSlOpYMfxE044QYYPHy7333+/6Yt0++235zsfusvPrkErdRyqG264wfTBAuBuaYHQY2YBALkdxE855RSZMWNGXEmRpmX6PDqOU506dWydRwDJR+IEAFHoUXCvvPJK7m7CotIO7Zp4UTQB3kDiBAAAYBGJEwAAgEUUTgAAABZROAEAAFhE4QQAAGARhRMAAIBFFE4AAAAWUTgBAABYROEEAABgEYUTAACAWPP/ACqnmafE8ctBAAAAAElFTkSuQmCC",
+      "text/plain": [
+       "<Figure size 800x600 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "import geopandas as gpd\n",
+    "\n",
+    "pixel_camera = tower.instruments[0].model_copy(update={\"cross_track_pixels\": 12, \"along_track_pixels\": 8})\n",
+    "pixels = pixel_camera.compute_footprint_pixel_array(tower.get_track(), elevation=tower.elevation)[0]\n",
+    "pixels_local = gpd.GeoSeries([pixels], crs=\"EPSG:4326\").to_crs(local_crs(tower)).iloc[0]\n",
+    "\n",
+    "# pixel centers by cross-track (right to left) and along-track (fore to aft) index\n",
+    "centers = np.array([(p.x, p.y) for p in pixels_local.geoms]).reshape(12, 8, 2)\n",
+    "# distances (north) of the rows, averaged over the two central columns\n",
+    "rows = np.sort(centers[5:7, :, 1].mean(axis=0))\n",
+    "print(\"row distances (m):\", np.round(rows, 1))\n",
+    "print(\"row spacing (m):\", np.round(np.diff(rows), 1))\n",
+    "\n",
+    "fig, ax = plt.subplots(figsize=(8, 6))\n",
+    "tower_results[tower_results.instrument == \"North camera\"].to_crs(local_crs(tower)).plot(\n",
+    "    facecolor=\"none\", edgecolor=\"k\", ax=ax\n",
+    ")\n",
+    "ax.plot([p.x for p in pixels_local.geoms], [p.y for p in pixels_local.geoms], \".\", color=\"tab:blue\")\n",
+    "ax.plot(0, 0, \"k^\")\n",
+    "ax.set(xlabel=\"East (m)\", ylabel=\"North (m)\", title=\"North Camera Pixel Centers\", aspect=\"equal\")\n",
+    "ax.grid(True, alpha=0.3)\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "fd851e48",
+   "metadata": {},
+   "source": [
+    "## Observation Conditions\n",
+    "\n",
+    "Although footprints are static, an instrument's observation conditions can still vary with time, just as for a satellite. `SurfacePlatform.get_track` accepts times, and instrument methods such as `is_valid_observation` evaluate its requirements at each one. For example, the north camera may require the sun at least 10 degrees above the horizon at the center of its footprint (`min_target_solar_elevation`). Evaluated every 10 minutes on 16 October 2026, it observes from about 7:30 to 16:50 local time (Arizona does not observe daylight saving time, so local time is UTC-7)."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "id": "6306b882",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2026-10-16T23:46:32.177403Z",
+     "iopub.status.busy": "2026-10-16T23:46:32.177403Z",
+     "iopub.status.idle": "2026-10-16T23:46:32.369781Z",
+     "shell.execute_reply": "2026-10-16T23:46:32.369781Z"
+    }
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "first valid: 2026-10-16 07:30:00-07:00\n",
+      "last valid: 2026-10-16 16:50:00-07:00\n",
+      "valid fraction of the day: 39.6%\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 1000x250 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "from datetime import datetime, timedelta, timezone\n",
+    "\n",
+    "import pandas as pd\n",
+    "\n",
+    "times = [datetime(2026, 10, 16, 7, tzinfo=timezone.utc) + timedelta(minutes=10 * i) for i in range(144)]\n",
+    "camera = tower.instruments[0].model_copy(update={\"min_target_solar_elevation\": 10})\n",
+    "track = tower.get_track(times)\n",
+    "center = camera.compute_footprint_center(track, elevation=tower.elevation)\n",
+    "valid = pd.Series(\n",
+    "    camera.is_valid_observation(track, center),\n",
+    "    index=pd.DatetimeIndex(times).tz_convert(\"America/Phoenix\"),\n",
+    ")\n",
+    "print(\"first valid:\", valid[valid].index[0])\n",
+    "print(\"last valid:\", valid[valid].index[-1])\n",
+    "print(f\"valid fraction of the day: {valid.mean():.1%}\")\n",
+    "\n",
+    "fig, ax = plt.subplots(figsize=(10, 2.5))\n",
+    "ax.step(valid.index.tz_localize(None), valid.astype(int), where=\"post\")\n",
+    "ax.set(yticks=[0, 1], yticklabels=[\"invalid\", \"valid\"], xlabel=\"Local time (MST)\", title=\"North Camera Valid Observations\")\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "2945a292",
+   "metadata": {},
+   "source": [
+    "## Network Coverage\n",
+    "\n",
+    "The `compute_platform_track` method dissolves the footprints of several platforms into a single composite geometry (for example, a network coverage map), optionally clipped to a mask. Here, a network of five tethered balloons flies 1,000 m above cities across the Phoenix metropolitan area. Each carries a downward-looking instrument with a 170 degree field of regard, which reaches to 5 degrees below the horizon, a radius of about 1,000 tan(85°) ≈ 11.4 km. Ground elevations are approximate. The mask clips the composite to the area south of 33.55°N."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "id": "60700af8",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2026-10-16T23:46:32.369781Z",
+     "iopub.status.busy": "2026-10-16T23:46:32.369781Z",
+     "iopub.status.idle": "2026-10-16T23:46:32.492358Z",
+     "shell.execute_reply": "2026-10-16T23:46:32.492358Z"
+    }
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "composite area: 1575 km2\n",
+      "masked composite area: 1323 km2\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 800x700 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "from shapely.geometry import box\n",
+    "\n",
+    "from tatc.analysis import compute_platform_track\n",
+    "\n",
+    "sites = {\n",
+    "    \"Phoenix\": (33.4484, -112.0740, 300),\n",
+    "    \"Glendale\": (33.5387, -112.1860, 320),\n",
+    "    \"Scottsdale\": (33.4942, -111.9261, 350),\n",
+    "    \"Mesa\": (33.4152, -111.8315, 350),\n",
+    "    \"Chandler\": (33.3062, -111.8413, 340),\n",
+    "}\n",
+    "network = [\n",
+    "    SurfacePlatform(\n",
+    "        name=name,\n",
+    "        latitude=latitude,\n",
+    "        longitude=longitude,\n",
+    "        elevation=elevation,\n",
+    "        height=1000,\n",
+    "        instruments=[Instrument(name=\"Imager\", field_of_regard=170)],\n",
+    "    )\n",
+    "    for name, (latitude, longitude, elevation) in sites.items()\n",
+    "]\n",
+    "mask = box(-112.5, 33.0, -111.5, 33.55)\n",
+    "\n",
+    "composite = compute_platform_track(network)\n",
+    "composite_masked = compute_platform_track(network, mask=mask)\n",
+    "print(f\"composite area: {composite.to_crs(local_crs(network[0])).area.iloc[0] / 1e6:.0f} km2\")\n",
+    "print(f\"masked composite area: {composite_masked.to_crs(local_crs(network[0])).area.iloc[0] / 1e6:.0f} km2\")\n",
+    "\n",
+    "fig, ax = plt.subplots(figsize=(8, 7), subplot_kw={\"projection\": ccrs.PlateCarree()})\n",
+    "composite.plot(facecolor=\"none\", edgecolor=\"tab:red\", ls=\"--\", ax=ax, transform=ccrs.PlateCarree())\n",
+    "composite_masked.plot(facecolor=\"tab:red\", edgecolor=\"none\", alpha=0.4, ax=ax, transform=ccrs.PlateCarree())\n",
+    "ax.plot(*mask.exterior.xy, color=\"k\", lw=1, transform=ccrs.PlateCarree())\n",
+    "for platform in network:\n",
+    "    ax.plot(platform.longitude, platform.latitude, \"k^\", transform=ccrs.PlateCarree())\n",
+    "    ax.text(platform.longitude + 0.01, platform.latitude + 0.01, platform.name, transform=ccrs.PlateCarree())\n",
+    "ax.add_feature(cfeature.STATES, edgecolor=\"gray\")\n",
+    "ax.set_extent([-112.45, -111.6, 33.1, 33.7], crs=ccrs.PlateCarree())\n",
+    "ax.set_title(\"Composite Balloon Network Coverage (shaded: masked)\")\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "a14bb773",
+   "metadata": {},
+   "source": [
+    "## Looking Up\n",
+    "\n",
+    "Instruments can also look up at a target elevation above the platform, for example from a tower to the base of a cloud layer. A roll angle of 180 degrees turns a `PointedInstrument`'s view from nadir to zenith (straight up). Here the tower in Tempe hosts two sky cameras viewing a cloud base 2,000 m above the ground (2,320 m above the ellipsoid):\n",
+    "\n",
+    " * `Sky camera`: an all-sky imager with a 160 degree circular field of view about zenith, which reaches down to 10 degrees above the horizon.\n",
+    " * `West sky camera`: a rectangular frame camera with a 40 degree field of view, rolled 90 degrees to the left (west) so that it looks horizontally, from 20 degrees below to 20 degrees above the horizon."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "id": "bdc35cda",
+   "metadata": {},
+   "outputs": [
+    {
+     "output_type": "display_data",
+     "data": {
+      "text/plain": [
+       "  platform       instrument  elevation  near (km)  far (km)  area (km2)\n",
+       "0    Tower       Sky camera     2320.0     11.057    11.114     385.383\n",
+       "1    Tower  West sky camera     2320.0      5.404   179.355   11215.478"
+      ],
+      "text/html": [
+       "<div>\n",
+       "<style scoped>\n",
+       "    .dataframe tbody tr th:only-of-type {\n",
+       "        vertical-align: middle;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe tbody tr th {\n",
+       "        vertical-align: top;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe thead th {\n",
+       "        text-align: right;\n",
+       "    }\n",
+       "</style>\n",
+       "<table border=\"1\" class=\"dataframe\">\n",
+       "  <thead>\n",
+       "    <tr style=\"text-align: right;\">\n",
+       "      <th></th>\n",
+       "      <th>platform</th>\n",
+       "      <th>instrument</th>\n",
+       "      <th>elevation</th>\n",
+       "      <th>near (km)</th>\n",
+       "      <th>far (km)</th>\n",
+       "      <th>area (km2)</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>0</th>\n",
+       "      <td>Tower</td>\n",
+       "      <td>Sky camera</td>\n",
+       "      <td>2320.0</td>\n",
+       "      <td>11.057</td>\n",
+       "      <td>11.114</td>\n",
+       "      <td>385.383</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>1</th>\n",
+       "      <td>Tower</td>\n",
+       "      <td>West sky camera</td>\n",
+       "      <td>2320.0</td>\n",
+       "      <td>5.404</td>\n",
+       "      <td>179.355</td>\n",
+       "      <td>11215.478</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ]
+     },
+     "metadata": {}
+    }
+   ],
+   "source": [
+    "sky_tower = tower.model_copy(\n",
+    "    update={\n",
+    "        \"instruments\": [\n",
+    "            PointedInstrument(\n",
+    "                name=\"Sky camera\",\n",
+    "                cross_track_field_of_view=160,\n",
+    "                along_track_field_of_view=160,\n",
+    "                roll_angle=180,\n",
+    "            ),\n",
+    "            PointedInstrument(\n",
+    "                name=\"West sky camera\",\n",
+    "                cross_track_field_of_view=40,\n",
+    "                along_track_field_of_view=40,\n",
+    "                roll_angle=90,\n",
+    "                is_rectangular=True,\n",
+    "            ),\n",
+    "        ]\n",
+    "    }\n",
+    ")\n",
+    "cloud_base = tower.elevation + 2000\n",
+    "sky_results = collect_platform_track(sky_tower, instrument_index=None, elevation=cloud_base)\n",
+    "\n",
+    "\n",
+    "def distance_range(track, platform):\n",
+    "    \"\"\"Minimum and maximum distances (m) from a platform to the boundary of each footprint.\"\"\"\n",
+    "    local = track.to_crs(local_crs(platform))\n",
+    "    distances = local.geometry.apply(lambda g: np.hypot(*np.array(g.exterior.coords)[:, :2].T))\n",
+    "    return distances.apply(np.min), distances.apply(np.max)\n",
+    "\n",
+    "\n",
+    "sky_summary = sky_results[[\"platform\", \"instrument\", \"elevation\"]].copy()\n",
+    "sky_summary[\"near (km)\"], sky_summary[\"far (km)\"] = (d / 1e3 for d in distance_range(sky_results, sky_tower))\n",
+    "sky_summary[\"area (km2)\"] = sky_results.to_crs(local_crs(sky_tower)).area / 1e6\n",
+    "display(sky_summary.round(3))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "c688dc63",
+   "metadata": {},
+   "source": [
+    "The all-sky imager's footprint is a disk of radius about 1,970 tan(80°) ≈ 11.2 km, or 11.1 km because the cloud base curves away below its lines of sight. The west sky camera's upper edge, 20 degrees above the horizon, reaches the cloud base 1,970 / tan(20°) ≈ 5.4 km away. Its lower half looks below the horizon, where the ground blocks its view, so its footprint is clipped to the horizon: the lines of sight tangent to the ground, which graze the ground about √(2R × 30 m) ≈ 20 km away and reach the cloud base about √(2R × 2,000 m) ≈ 160 km beyond. The footprint's far edge, an arc about 179 km away spanning the camera's 40 degree width, bounds the part of the cloud base visible over the horizon. (A view entirely below the horizon, such as a downward-looking camera, has an empty footprint.)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "id": "af8b47a2",
+   "metadata": {},
+   "outputs": [
+    {
+     "output_type": "display_data",
+     "data": {
+      "text/plain": [
+       "<Figure size 1300x600 with 2 Axes>"
+      ],
+      "image/png": "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"
+     },
+     "metadata": {}
+    }
+   ],
+   "source": [
+    "fig = plt.figure(figsize=(13, 6))\n",
+    "ax = fig.add_subplot(1, 2, 1, projection=ccrs.PlateCarree())\n",
+    "sky_results[sky_results.instrument == \"West sky camera\"].plot(\n",
+    "    facecolor=\"tab:purple\", edgecolor=\"k\", alpha=0.4, ax=ax, transform=ccrs.PlateCarree()\n",
+    ")\n",
+    "ax.plot(sky_tower.longitude, sky_tower.latitude, \"k^\", transform=ccrs.PlateCarree())\n",
+    "ax.stock_img()\n",
+    "ax.add_feature(cfeature.STATES, edgecolor=\"gray\")\n",
+    "ax.set_extent([-114.4, -111.4, 32.2, 34.6], crs=ccrs.PlateCarree())\n",
+    "ax.set_title(\"West Sky Camera Footprint at 2,000 m\")\n",
+    "\n",
+    "ax = fig.add_subplot(1, 2, 2)\n",
+    "sky_results[sky_results.instrument == \"Sky camera\"].to_crs(local_crs(sky_tower)).plot(\n",
+    "    facecolor=\"tab:cyan\", edgecolor=\"k\", alpha=0.5, ax=ax\n",
+    ")\n",
+    "ax.plot(0, 0, \"k^\")\n",
+    "ax.set(xlabel=\"East (m)\", ylabel=\"North (m)\", title=\"Sky Camera Footprint at 2,000 m\", aspect=\"equal\")\n",
+    "ax.grid(True, alpha=0.3)\n",
+    "plt.tight_layout()\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "7abea383",
+   "metadata": {},
+   "source": [
+    "`collect_platform_track` treats the ground at a platform's elevation as blocking views toward a target above its instruments. When calling instrument methods directly, such as `compute_footprint`, `compute_footprint_center`, or `compute_footprint_pixel_array`, pass `ground_elevation=platform.elevation` for the same behavior (by default, the ground is the WGS 84 ellipsoid). Here the all-sky imager has 9 by 9 pixels. Along its central column, pixels look 0, 17.8, 35.6, 53.3, and 71.1 degrees from zenith, so their centers on the cloud base spread out toward the horizon, about 1,970 tan(71.1°) ≈ 5.8 km away at the edge."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "id": "1bf9fdae",
+   "metadata": {},
+   "outputs": [
+    {
+     "output_type": "stream",
+     "name": "stdout",
+     "text": [
+      "central column offsets (km): [-5.75 -2.64 -1.41 -0.63  0.    0.63  1.41  2.64  5.75]\n",
+      "pixel elevations (m): [2320]\n"
+     ]
+    }
+   ],
+   "source": [
+    "pixel_sky_camera = sky_tower.instruments[0].model_copy(update={\"cross_track_pixels\": 9, \"along_track_pixels\": 9})\n",
+    "sky_pixels = pixel_sky_camera.compute_footprint_pixel_array(\n",
+    "    sky_tower.get_track(), elevation=cloud_base, ground_elevation=sky_tower.elevation\n",
+    ")[0]\n",
+    "sky_pixels_local = gpd.GeoSeries([sky_pixels], crs=\"EPSG:4326\").to_crs(local_crs(sky_tower)).iloc[0]\n",
+    "\n",
+    "# pixel centers by cross-track and along-track index\n",
+    "sky_centers = np.array([(p.x, p.y) for p in sky_pixels_local.geoms]).reshape(9, 9, 2)\n",
+    "# offsets (north) of the pixels in the central column\n",
+    "print(\"central column offsets (km):\", np.round(np.sort(sky_centers[4, :, 1]) / 1e3, 2))\n",
+    "print(\"pixel elevations (m):\", sorted({round(p.z) for p in sky_pixels.geoms}))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "04187a85",
+   "metadata": {},
+   "source": [
+    "### Terrain Mask\n",
+    "\n",
+    "The ground at a platform's elevation is an idealized horizon: real terrain can block low lines of sight in some directions. A `TerrainMask`, as for a `RadarStation` (see the [Collect Radar Coverage](CollectRadarTrack.ipynb) example), gives the minimum usable elevation angle at each azimuth, and a platform's `terrain_mask` clips footprints toward a target above its instruments to the region visible over it (`SurfacePlatform.compute_visible_region`). It does not apply to targets below the instruments.\n",
+    "\n",
+    "The `tatc.preprocess` module (installed via `pip install tatc[preprocess]`) derives a terrain mask from a digital elevation model (DEM). `compute_terrain_mask_for_platform` places the instruments a platform's `height` above the DEM's ground at its location (in the DEM's vertical datum, mean sea level for the [Copernicus DEM GLO-30](https://registry.opendata.aws/copernicus-dem/)) and, by default, uses straight lines of sight (`effective_earth_radius_factor=1`) without the radio refraction assumed for radars, matching the geometry of the platform's footprints. Here the mask samples every 1 degree of azimuth out to 100 km. Fetching the DEM over the network takes about a minute, so the mask is saved to a file for reuse."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "id": "8a88c58b",
+   "metadata": {},
+   "outputs": [
+    {
+     "output_type": "stream",
+     "name": "stdout",
+     "text": [
+      "terrain mask: -0.29 to 2.00 degrees\n",
+      "visible cloud base (km2): {'ground horizon': 100818.0, 'terrain mask': 50977.0}\n"
+     ]
+    },
+    {
+     "output_type": "display_data",
+     "data": {
+      "text/plain": [
+       "        instrument  area without mask (km2)  area with mask (km2)\n",
+       "0       Sky camera                    385.4                 385.4\n",
+       "1  West sky camera                  11215.5                8424.1"
+      ],
+      "text/html": [
+       "<div>\n",
+       "<style scoped>\n",
+       "    .dataframe tbody tr th:only-of-type {\n",
+       "        vertical-align: middle;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe tbody tr th {\n",
+       "        vertical-align: top;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe thead th {\n",
+       "        text-align: right;\n",
+       "    }\n",
+       "</style>\n",
+       "<table border=\"1\" class=\"dataframe\">\n",
+       "  <thead>\n",
+       "    <tr style=\"text-align: right;\">\n",
+       "      <th></th>\n",
+       "      <th>instrument</th>\n",
+       "      <th>area without mask (km2)</th>\n",
+       "      <th>area with mask (km2)</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>0</th>\n",
+       "      <td>Sky camera</td>\n",
+       "      <td>385.4</td>\n",
+       "      <td>385.4</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>1</th>\n",
+       "      <td>West sky camera</td>\n",
+       "      <td>11215.5</td>\n",
+       "      <td>8424.1</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ]
+     },
+     "metadata": {}
+    }
+   ],
+   "source": [
+    "import json\n",
+    "\n",
+    "from tatc.schemas import TerrainMask\n",
+    "\n",
+    "TERRAIN_MASK_PATH = \"tempe_tower_terrain_mask.json\"\n",
+    "REGENERATE_TERRAIN_MASK = False  # set True to re-derive from the DEM over the network\n",
+    "\n",
+    "if REGENERATE_TERRAIN_MASK:\n",
+    "    from tatc.preprocess import compute_terrain_mask_for_platform, get_copernicus_dem_tile_urls\n",
+    "\n",
+    "    dem_urls = get_copernicus_dem_tile_urls(sky_tower.longitude, sky_tower.latitude, radius=100000)\n",
+    "    sky_tower.terrain_mask = compute_terrain_mask_for_platform(dem_urls, sky_tower, search_radius=100000)\n",
+    "    with open(TERRAIN_MASK_PATH, \"w\", encoding=\"utf-8\") as f:\n",
+    "        json.dump({sky_tower.name: sky_tower.terrain_mask.model_dump()}, f, indent=2)\n",
+    "else:\n",
+    "    with open(TERRAIN_MASK_PATH, encoding=\"utf-8\") as f:\n",
+    "        sky_tower.terrain_mask = TerrainMask(**json.load(f)[sky_tower.name])\n",
+    "\n",
+    "open_sky = sky_tower.model_copy(update={\"terrain_mask\": None})\n",
+    "visible = gpd.GeoSeries(\n",
+    "    [open_sky.compute_visible_region(cloud_base), sky_tower.compute_visible_region(cloud_base)],\n",
+    "    index=[\"ground horizon\", \"terrain mask\"],\n",
+    "    crs=\"EPSG:4326\",\n",
+    ")\n",
+    "masked_results = collect_platform_track(sky_tower, instrument_index=None, elevation=cloud_base)\n",
+    "\n",
+    "angles = sky_tower.terrain_mask.min_elevation_angle\n",
+    "print(f\"terrain mask: {min(angles):.2f} to {max(angles):.2f} degrees\")\n",
+    "print(\"visible cloud base (km2):\", (visible.to_crs(local_crs(sky_tower)).area / 1e6).round(0).to_dict())\n",
+    "masked_summary = masked_results[[\"instrument\"]].copy()\n",
+    "masked_summary[\"area without mask (km2)\"] = sky_results.to_crs(local_crs(sky_tower)).area / 1e6\n",
+    "masked_summary[\"area with mask (km2)\"] = masked_results.to_crs(local_crs(sky_tower)).area / 1e6\n",
+    "display(masked_summary.round(1))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "c98eb66f",
+   "metadata": {},
+   "source": [
+    "Mountains around the Phoenix valley rise up to about 2 degrees above the horizon, so the terrain mask halves the area of the cloud base visible from the tower, bounding it 50 to 180 km away rather than at the horizon of the ground, about 179 km away in every direction. The all-sky imager, which reaches down to 10 degrees above the horizon, is unaffected, while the far edge of the west sky camera's footprint now follows the terrain to the west."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "id": "aa3ba8f2",
+   "metadata": {},
+   "outputs": [
+    {
+     "output_type": "display_data",
+     "data": {
+      "text/plain": [
+       "<Figure size 800x800 with 1 Axes>"
+      ],
+      "image/png": "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"
+     },
+     "metadata": {}
+    }
+   ],
+   "source": [
+    "fig, ax = plt.subplots(figsize=(8, 8), subplot_kw={\"projection\": ccrs.PlateCarree()})\n",
+    "visible[[\"ground horizon\"]].plot(facecolor=\"none\", edgecolor=\"k\", ls=\"--\", ax=ax, transform=ccrs.PlateCarree())\n",
+    "visible[[\"terrain mask\"]].plot(facecolor=\"tab:green\", edgecolor=\"k\", alpha=0.2, ax=ax, transform=ccrs.PlateCarree())\n",
+    "masked_results[masked_results.instrument == \"West sky camera\"].plot(\n",
+    "    facecolor=\"tab:purple\", edgecolor=\"k\", alpha=0.5, ax=ax, transform=ccrs.PlateCarree()\n",
+    ")\n",
+    "ax.plot(sky_tower.longitude, sky_tower.latitude, \"k^\", transform=ccrs.PlateCarree())\n",
+    "ax.add_feature(cfeature.STATES, edgecolor=\"gray\")\n",
+    "ax.set_extent([-114.1, -109.8, 31.8, 35.1], crs=ccrs.PlateCarree())\n",
+    "ax.set_title(\"Cloud Base at 2,000 m Visible over the Horizon (dashed) and Terrain (green)\")\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "b20e9642",
+   "metadata": {},
+   "source": [
+    "## Limitations\n",
+    "\n",
+    "Footprints are projected onto a single target elevation, either below the instruments (the same geometry as a satellite looking down at the Earth) or above them; `collect_platform_track` raises a `ValueError` for a target elevation equal to a platform's instruments. Toward a target below the instruments, footprints do not account for terrain or obstructions; toward a target above them, the ground at the platform's elevation and an optional terrain mask (one blocking angle per azimuth) block views. Footprints do not account for atmospheric refraction, and `ConicalInstrument` views, which depend on a satellite's motion, are not supported on platforms."
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "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.10.16"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/docs/examples/index.rst b/docs/examples/index.rst
index 86702c6d..23c830ba 100644
--- a/docs/examples/index.rst
+++ b/docs/examples/index.rst
@@ -11,6 +11,7 @@ The following provide examples of TAT-C use in a Jupyter notebook environment.
   GenerateRandomPoints.ipynb
   CollectOrbitGroundTrack.ipynb
   CollectRadarTrack.ipynb
+  CollectPlatformTrack.ipynb
   ComputeCoverage.ipynb
   ComputeLatency.ipynb
   ComputeDOP.ipynb
diff --git a/docs/examples/tempe_tower_terrain_mask.json b/docs/examples/tempe_tower_terrain_mask.json
new file mode 100644
index 00000000..23af5f06
--- /dev/null
+++ b/docs/examples/tempe_tower_terrain_mask.json
@@ -0,0 +1,728 @@
+{
+  "Tower": {
+    "azimuth": [
+      0.0,
+      1.0,
+      2.0,
+      3.0,
+      4.0,
+      5.0,
+      6.0,
+      7.0,
+      8.0,
+      9.0,
+      10.0,
+      11.0,
+      12.0,
+      13.0,
+      14.0,
+      15.0,
+      16.0,
+      17.0,
+      18.0,
+      19.0,
+      20.0,
+      21.0,
+      22.0,
+      23.0,
+      24.0,
+      25.0,
+      26.0,
+      27.0,
+      28.0,
+      29.0,
+      30.0,
+      31.0,
+      32.0,
+      33.0,
+      34.0,
+      35.0,
+      36.0,
+      37.0,
+      38.0,
+      39.0,
+      40.0,
+      41.0,
+      42.0,
+      43.0,
+      44.0,
+      45.0,
+      46.0,
+      47.0,
+      48.0,
+      49.0,
+      50.0,
+      51.0,
+      52.0,
+      53.0,
+      54.0,
+      55.0,
+      56.0,
+      57.0,
+      58.0,
+      59.0,
+      60.0,
+      61.0,
+      62.0,
+      63.0,
+      64.0,
+      65.0,
+      66.0,
+      67.0,
+      68.0,
+      69.0,
+      70.0,
+      71.0,
+      72.0,
+      73.0,
+      74.0,
+      75.0,
+      76.0,
+      77.0,
+      78.0,
+      79.0,
+      80.0,
+      81.0,
+      82.0,
+      83.0,
+      84.0,
+      85.0,
+      86.0,
+      87.0,
+      88.0,
+      89.0,
+      90.0,
+      91.0,
+      92.0,
+      93.0,
+      94.0,
+      95.0,
+      96.0,
+      97.0,
+      98.0,
+      99.0,
+      100.0,
+      101.0,
+      102.0,
+      103.0,
+      104.0,
+      105.0,
+      106.0,
+      107.0,
+      108.0,
+      109.0,
+      110.0,
+      111.0,
+      112.0,
+      113.0,
+      114.0,
+      115.0,
+      116.0,
+      117.0,
+      118.0,
+      119.0,
+      120.0,
+      121.0,
+      122.0,
+      123.0,
+      124.0,
+      125.0,
+      126.0,
+      127.0,
+      128.0,
+      129.0,
+      130.0,
+      131.0,
+      132.0,
+      133.0,
+      134.0,
+      135.0,
+      136.0,
+      137.0,
+      138.0,
+      139.0,
+      140.0,
+      141.0,
+      142.0,
+      143.0,
+      144.0,
+      145.0,
+      146.0,
+      147.0,
+      148.0,
+      149.0,
+      150.0,
+      151.0,
+      152.0,
+      153.0,
+      154.0,
+      155.0,
+      156.0,
+      157.0,
+      158.0,
+      159.0,
+      160.0,
+      161.0,
+      162.0,
+      163.0,
+      164.0,
+      165.0,
+      166.0,
+      167.0,
+      168.0,
+      169.0,
+      170.0,
+      171.0,
+      172.0,
+      173.0,
+      174.0,
+      175.0,
+      176.0,
+      177.0,
+      178.0,
+      179.0,
+      180.0,
+      181.0,
+      182.0,
+      183.0,
+      184.0,
+      185.0,
+      186.0,
+      187.0,
+      188.0,
+      189.0,
+      190.0,
+      191.0,
+      192.0,
+      193.0,
+      194.0,
+      195.0,
+      196.0,
+      197.0,
+      198.0,
+      199.0,
+      200.0,
+      201.0,
+      202.0,
+      203.0,
+      204.0,
+      205.0,
+      206.0,
+      207.0,
+      208.0,
+      209.0,
+      210.0,
+      211.0,
+      212.0,
+      213.0,
+      214.0,
+      215.0,
+      216.0,
+      217.0,
+      218.0,
+      219.0,
+      220.0,
+      221.0,
+      222.0,
+      223.0,
+      224.0,
+      225.0,
+      226.0,
+      227.0,
+      228.0,
+      229.0,
+      230.0,
+      231.0,
+      232.0,
+      233.0,
+      234.0,
+      235.0,
+      236.0,
+      237.0,
+      238.0,
+      239.0,
+      240.0,
+      241.0,
+      242.0,
+      243.0,
+      244.0,
+      245.0,
+      246.0,
+      247.0,
+      248.0,
+      249.0,
+      250.0,
+      251.0,
+      252.0,
+      253.0,
+      254.0,
+      255.0,
+      256.0,
+      257.0,
+      258.0,
+      259.0,
+      260.0,
+      261.0,
+      262.0,
+      263.0,
+      264.0,
+      265.0,
+      266.0,
+      267.0,
+      268.0,
+      269.0,
+      270.0,
+      271.0,
+      272.0,
+      273.0,
+      274.0,
+      275.0,
+      276.0,
+      277.0,
+      278.0,
+      279.0,
+      280.0,
+      281.0,
+      282.0,
+      283.0,
+      284.0,
+      285.0,
+      286.0,
+      287.0,
+      288.0,
+      289.0,
+      290.0,
+      291.0,
+      292.0,
+      293.0,
+      294.0,
+      295.0,
+      296.0,
+      297.0,
+      298.0,
+      299.0,
+      300.0,
+      301.0,
+      302.0,
+      303.0,
+      304.0,
+      305.0,
+      306.0,
+      307.0,
+      308.0,
+      309.0,
+      310.0,
+      311.0,
+      312.0,
+      313.0,
+      314.0,
+      315.0,
+      316.0,
+      317.0,
+      318.0,
+      319.0,
+      320.0,
+      321.0,
+      322.0,
+      323.0,
+      324.0,
+      325.0,
+      326.0,
+      327.0,
+      328.0,
+      329.0,
+      330.0,
+      331.0,
+      332.0,
+      333.0,
+      334.0,
+      335.0,
+      336.0,
+      337.0,
+      338.0,
+      339.0,
+      340.0,
+      341.0,
+      342.0,
+      343.0,
+      344.0,
+      345.0,
+      346.0,
+      347.0,
+      348.0,
+      349.0,
+      350.0,
+      351.0,
+      352.0,
+      353.0,
+      354.0,
+      355.0,
+      356.0,
+      357.0,
+      358.0,
+      359.0
+    ],
+    "min_elevation_angle": [
+      0.5808495694526488,
+      0.6987616780797504,
+      0.7454241935428605,
+      0.693569024618172,
+      0.8259929001323892,
+      0.8645738832999631,
+      0.8328195590003827,
+      0.8761655797687448,
+      0.8104077244716812,
+      0.8526140445505345,
+      0.711380806152737,
+      0.7998525857201121,
+      0.7096406560299996,
+      0.8001881663875029,
+      0.9580413671320112,
+      0.674088848357196,
+      0.7365687573365993,
+      1.2117562683060612,
+      1.1211343175297543,
+      1.2787731839094374,
+      1.2830407490371412,
+      1.408844108614675,
+      1.311025164694302,
+      1.2559276206703083,
+      1.4675594465961008,
+      1.3193596624552126,
+      1.1542761940518584,
+      1.427153344286395,
+      1.201350664779939,
+      1.4703424401720033,
+      1.0773739450653654,
+      1.0136236057283332,
+      1.017014032685221,
+      1.058212226963924,
+      0.9995912744285903,
+      0.6975596517420676,
+      0.8128420182720433,
+      0.7121342518539099,
+      0.692194979824462,
+      0.7435043021739698,
+      0.8051256081124498,
+      0.8297595485309345,
+      0.9791765989167757,
+      0.8133527863199895,
+      0.6395301845256511,
+      0.5703011010739009,
+      0.7621521307541445,
+      0.7423220044119093,
+      1.0671677054312938,
+      1.0035562509740013,
+      0.9093218502877828,
+      0.9286423477581837,
+      0.9031589127676145,
+      1.071358347609461,
+      1.090348985632822,
+      0.9826951288594108,
+      0.9882414622333076,
+      0.892274770884327,
+      0.9261168697822383,
+      0.9354512907133655,
+      0.9067733900977241,
+      1.0677560135137922,
+      1.1988990461625657,
+      1.2749646706369389,
+      1.146480538289971,
+      0.9750288937615095,
+      1.0518474606619759,
+      1.0404913256342117,
+      0.9973388060280027,
+      0.7673967206933304,
+      0.5574409529839793,
+      0.6758206620244848,
+      0.8323467120425311,
+      0.72040233128961,
+      0.6691012584688839,
+      0.7949196464558356,
+      0.7560635550005685,
+      0.9552264819337564,
+      0.9008091104848948,
+      0.736669515791713,
+      0.7537237109713674,
+      0.78272001695533,
+      0.7478960092660222,
+      0.7560718335583324,
+      0.7274773300334496,
+      0.7510880978617369,
+      0.8004891098626631,
+      0.8930072646404265,
+      1.0845109610876293,
+      0.9702313064878206,
+      1.0433977967016954,
+      0.89761680751263,
+      0.8630036905486901,
+      0.4444837643217207,
+      0.5794223773995852,
+      0.5525684228975474,
+      0.4560603021619725,
+      0.4645217430133702,
+      0.39531375142968384,
+      0.28359237747891225,
+      0.2796629055438191,
+      0.374856818761456,
+      0.29821683279134487,
+      0.31811168646214466,
+      0.3088768661402914,
+      0.1687566741178695,
+      0.21312462821302705,
+      0.2448057545755768,
+      0.23900468060166394,
+      0.2684512848076018,
+      0.24380994408481044,
+      0.1623731236826484,
+      0.09731058332449082,
+      0.1254352218839888,
+      -0.04165394814606878,
+      -0.04010337761322787,
+      -0.046797595941648236,
+      -0.011161531600222504,
+      -0.06694652674598389,
+      -0.06580922641329151,
+      -0.06835867343668456,
+      -0.06862366561864312,
+      -0.0707248063933505,
+      -0.0738861647080312,
+      -0.07180871770209908,
+      -0.07181533887436586,
+      -0.0718715492860707,
+      -0.07072283974505744,
+      -0.03755397639806455,
+      -0.05855643041371198,
+      -0.07553290586950646,
+      0.011423360680484787,
+      -0.05080383295912481,
+      0.10260333584698594,
+      0.1533226964222319,
+      0.24260100460083134,
+      0.24585646703082298,
+      0.19187219854654433,
+      0.12916263828282107,
+      0.2588352528370561,
+      0.10099797454320225,
+      0.15525183491565336,
+      0.2783984824480897,
+      0.5433790979802633,
+      0.5909323095305596,
+      0.3870508041055903,
+      0.1129999021012903,
+      0.20366076321767176,
+      0.0760552167122544,
+      0.10332989334624036,
+      -0.054204202817869904,
+      -0.0833034568501728,
+      -0.08833574380742269,
+      0.2028855515177245,
+      0.16994120420759318,
+      0.1820498411240786,
+      0.09508357060689167,
+      -0.05474199429673762,
+      -0.08813268170454605,
+      -0.08088889517516759,
+      -0.09873203015363499,
+      -0.10321027997282438,
+      -0.10820668195184108,
+      -0.05460460684227711,
+      -0.08053377032594768,
+      0.021905127941500603,
+      -0.011071829800326892,
+      -0.028190633218833975,
+      0.03336342785304836,
+      -0.01583853502697017,
+      -0.06089750950070964,
+      0.03443996301107349,
+      -0.10215734711254497,
+      -0.1221181755096784,
+      -0.1351189824574325,
+      -0.13780498482578432,
+      -0.13279898364289416,
+      -0.1668310673935951,
+      -0.16822683638853803,
+      -0.15120401752462237,
+      -0.16279204266413533,
+      -0.12309993785328545,
+      -0.12581026940250978,
+      -0.1515232828983169,
+      -0.16509788019817384,
+      -0.13998770161549626,
+      -0.16847785752305414,
+      -0.16130397418529477,
+      -0.1511036349073226,
+      -0.16033620261728734,
+      -0.14596134831051183,
+      -0.11895182011816793,
+      -0.07360012098067299,
+      0.09753005969667206,
+      0.35303146216776865,
+      0.16455796982523624,
+      0.07361709414198182,
+      0.05474200641340377,
+      -0.06056864129746092,
+      -0.05757485070177837,
+      -0.058863717520189485,
+      -0.03587321942625823,
+      -0.03934411251820324,
+      -0.015619751530134758,
+      -0.026547893044774985,
+      0.0017454094239463547,
+      -0.003057807158293766,
+      0.014493680215037373,
+      0.028059918372167737,
+      0.09547381599363611,
+      0.05801862128294868,
+      0.07108742190295528,
+      0.09297357894948864,
+      0.10823807610477361,
+      0.2679537011812287,
+      0.5496138291074267,
+      0.6529288452942517,
+      0.8119020573835812,
+      0.8299342820089317,
+      0.6561577374226311,
+      0.78197756038778,
+      0.670244983630927,
+      0.8971384794838684,
+      1.2158001866548762,
+      1.3598786960690823,
+      1.4101681337244192,
+      1.4074447494921196,
+      1.412895929666331,
+      1.5497698792991326,
+      1.3876890806892783,
+      1.3352491702716307,
+      1.3980038653354405,
+      1.3248708711395645,
+      1.2072849277271112,
+      1.1279175111299369,
+      1.022610806409342,
+      0.914629850656156,
+      1.0487738951807464,
+      0.9973876571763217,
+      0.8757020154922853,
+      0.9581169572785011,
+      0.9287407410804698,
+      0.9037603768552716,
+      1.2605331765966985,
+      0.916269944889972,
+      0.7216302848667578,
+      0.6449349154411154,
+      0.36339187759970226,
+      0.6162413212654775,
+      0.7822918815138451,
+      0.6496414796752922,
+      0.660185034786205,
+      0.44854998822696046,
+      0.26703833023347273,
+      0.39717419395422016,
+      0.3952535470896682,
+      0.1330139851069959,
+      0.022321559130935704,
+      -0.023423703398959186,
+      -0.09206955867484155,
+      -0.17572934822745379,
+      -0.2395525273629285,
+      -0.21652563530105234,
+      -0.21149490128189888,
+      -0.28830098206477844,
+      -0.2890136329257429,
+      -0.2859779981527472,
+      -0.2838989823557214,
+      -0.2442666813392586,
+      -0.23281882687238764,
+      -0.2569031859800859,
+      -0.2702819451133491,
+      -0.2496786844577389,
+      -0.2515248055158292,
+      -0.23338365427910404,
+      -0.033875134320703305,
+      -0.07962157841493805,
+      -0.05176941377245849,
+      0.0414567378842977,
+      0.18240549159459063,
+      0.18015232216574548,
+      0.14151663181699764,
+      0.14257107844401903,
+      0.3333378460015794,
+      0.2812868591559624,
+      0.41826661887525973,
+      0.42106660446741834,
+      0.35523923848603045,
+      0.2339770838556161,
+      0.15928321821434455,
+      0.12203689937906448,
+      0.1392317194346838,
+      0.1942428782293742,
+      0.06905672760873588,
+      -0.10192492934440724,
+      -0.03870830316265812,
+      0.22603567441167047,
+      0.22876461740101936,
+      0.7840495179511967,
+      0.9351599578344718,
+      0.9351599578344718,
+      0.44597126732273834,
+      0.44597126732273834,
+      -0.12310280157188859,
+      0.012054968078255663,
+      -0.1526043033566399,
+      -0.1499876502658657,
+      -0.1452938030701258,
+      -0.1407115040592017,
+      -0.14105218030001757,
+      -0.12876188977656888,
+      -0.12312160726157005,
+      -0.0726621878060381,
+      -0.08219637980197977,
+      -0.022510633588173137,
+      0.059125289435878636,
+      0.07598160682665588,
+      0.09908866567967163,
+      0.13509364297995355,
+      0.19214911930630332,
+      0.19637681502741833,
+      0.26519855052217217,
+      0.5363035215696192,
+      0.40848435670549255,
+      0.366289660246755,
+      0.4955203939033104,
+      0.668592940972069,
+      0.9122525075387494,
+      1.1663085887402123,
+      1.0544753893770848,
+      0.7753739194232621,
+      0.873439515276633,
+      0.9998125373515541,
+      0.8777041041807306,
+      0.9628608453140386,
+      1.1413800755929893,
+      1.106610105077923,
+      1.0200856309399635,
+      1.0461332177370035,
+      1.0233891407091713,
+      1.050894651149201,
+      1.4354055231587919,
+      1.9736525692055225,
+      1.9993292530483364,
+      1.86558342591186,
+      1.5997313222863263,
+      1.5510540070642,
+      1.266407565356854,
+      0.9748696576595384,
+      1.0039758096936784,
+      0.7822729390383352,
+      0.5669065171279714,
+      0.5389937999516065,
+      0.7692867985172219,
+      0.8557042480291103,
+      0.754617725830089,
+      0.7368331648786152,
+      0.6467097909711893,
+      0.595748449312485,
+      0.5417355265679851
+    ]
+  }
+}
diff --git a/src/tatc/analysis/__init__.py b/src/tatc/analysis/__init__.py
index 33d8ebe4..d1026ece 100644
--- a/src/tatc/analysis/__init__.py
+++ b/src/tatc/analysis/__init__.py
@@ -28,6 +28,10 @@
     OrbitOutput,
     collect_orbit_track,
 )
+from .platform_track import (
+    collect_platform_track,
+    compute_platform_track,
+)
 from .point_sampling import (
     collect_multi_observations,
     collect_observations,
@@ -63,6 +67,7 @@
     "collect_multi_region_observations",
     "collect_observations",
     "collect_orbit_track",
+    "collect_platform_track",
     "collect_radar_track",
     "collect_region_observations",
     "collect_ro_observations",
@@ -71,6 +76,7 @@
     "compute_dop",
     "compute_ground_track",
     "compute_latencies",
+    "compute_platform_track",
     "compute_radar_track",
     "compute_region_access_periods",
     "grid_latencies",
diff --git a/src/tatc/analysis/check.py b/src/tatc/analysis/check.py
index 5d4ce0c8..4eac1e8e 100644
--- a/src/tatc/analysis/check.py
+++ b/src/tatc/analysis/check.py
@@ -13,7 +13,7 @@
 import geopandas as gpd
 import pandas as pd
 
-from ..schemas import Satellite
+from ..schemas import Satellite, SurfacePlatform
 from .. import constants
 from ..schemas.space.base_constellation import BaseConstellation
 
@@ -145,14 +145,19 @@ def _check_time_window(start: datetime, end: datetime) -> None:
         )
 
 
-def _check_instrument_index(satellite: Satellite, instrument_index: int) -> int:
+def _check_instrument_index(
+    satellite: Satellite | SurfacePlatform,
+    instrument_index: int,
+    kind: str = "satellite",
+) -> int:
     """
-    Checks that `instrument_index` indexes one of a satellite's instruments,
-    raising an `IndexError` that names the satellite otherwise.
+    Checks that `instrument_index` indexes one of a satellite's (or other
+    platform's) instruments, raising an `IndexError` that names it otherwise.
 
     Args:
-        satellite (Satellite): the satellite.
+        satellite (Satellite | SurfacePlatform): the satellite or platform.
         instrument_index (int): the instrument index.
+        kind (str): the kind of platform, as named in the error.
 
     Returns:
         int: the checked instrument index.
@@ -160,7 +165,7 @@ def _check_instrument_index(satellite: Satellite, instrument_index: int) -> int:
     count = len(satellite.instruments)
     if not -count <= instrument_index < count:
         raise IndexError(
-            f"instrument_index {instrument_index} is out of range for satellite "
+            f"instrument_index {instrument_index} is out of range for {kind} "
             f"{satellite.name!r}, which has {count} "
             f"instrument{'' if count == 1 else 's'}"
         )
@@ -189,23 +194,27 @@ def _is_single(*values: object, instrument_index: int | None = 0) -> bool:
 
 
 def _get_instrument_indices(
-    satellite: Satellite, instrument_index: int | None
+    satellite: Satellite | SurfacePlatform,
+    instrument_index: int | None,
+    kind: str = "satellite",
 ) -> range | list[int]:
     """
-    Gets the indices of a satellite's observing instruments: the given
-    index (see `_check_instrument_index`), or every instrument's if None.
+    Gets the indices of a satellite's (or other platform's) observing
+    instruments: the given index (see `_check_instrument_index`), or every
+    instrument's if None.
 
     Args:
-        satellite (Satellite): The satellite.
+        satellite (Satellite | SurfacePlatform): The satellite or platform.
         instrument_index (int | None): The instrument index (None for every
             instrument).
+        kind (str): the kind of platform, as named in an error.
 
     Returns:
         range | list[int]: the instrument indices
     """
     if instrument_index is None:
         return range(len(satellite.instruments))
-    return [_check_instrument_index(satellite, instrument_index)]
+    return [_check_instrument_index(satellite, instrument_index, kind)]
 
 
 def _combine_results(
diff --git a/src/tatc/analysis/platform_track.py b/src/tatc/analysis/platform_track.py
new file mode 100644
index 00000000..75daa800
--- /dev/null
+++ b/src/tatc/analysis/platform_track.py
@@ -0,0 +1,198 @@
+"""
+Methods to collect the static tracks of instruments on fixed surface platforms.
+
+@author: Paul T. Grogan <paul.grogan@asu.edu>
+"""
+
+from __future__ import annotations
+
+import geopandas as gpd
+import pandas as pd
+import shapely
+from shapely.geometry import MultiPolygon, Polygon
+
+from ..schemas import SurfacePlatform
+from .check import _get_instrument_indices
+from .ground_track import _get_mask_geometry
+
+
+def _get_empty_platform_track() -> gpd.GeoDataFrame:
+    """
+    Gets an empty data frame for platform track results.
+
+    Returns:
+        geopandas.GeoDataFrame: Empty data frame.
+    """
+    columns = {
+        "platform": pd.Series([], dtype="str"),
+        "instrument": pd.Series([], dtype="str"),
+        "elevation": pd.Series([], dtype="float"),
+        "geometry": pd.Series([], dtype="object"),
+    }
+    return gpd.GeoDataFrame(columns, crs="EPSG:4326")
+
+
+def _get_target_elevation(platform: SurfacePlatform, elevation: float | None) -> float:
+    """
+    Gets the elevation at which to project a platform's footprints: the
+    given elevation, or the platform's ground elevation if None, which must
+    differ from the elevation of its instruments (below them, looking down,
+    or above them, looking up).
+
+    Args:
+        platform (SurfacePlatform): The platform.
+        elevation (float | None): The target elevation (meters) above the
+            WGS 84 ellipsoid, or None for the platform's ground elevation.
+
+    Returns:
+        float: the target elevation (meters).
+    """
+    target = platform.elevation if elevation is None else elevation
+    if target == platform.get_altitude():
+        raise ValueError(
+            f"target elevation ({target} m) must differ from the elevation of "
+            f"the instruments of platform {platform.name!r} "
+            f"({platform.get_altitude()} m)"
+        )
+    return target
+
+
+def _clip_to_region(
+    footprint: Polygon | MultiPolygon, region: Polygon | MultiPolygon, elevation: float
+) -> Polygon | MultiPolygon:
+    """
+    Clips a footprint to a region (such as the region visible over a terrain
+    mask), keeping only its polygonal parts.
+
+    Args:
+        footprint (shapely.geometry.Polygon | shapely.geometry.MultiPolygon): The footprint.
+        region (shapely.geometry.Polygon | shapely.geometry.MultiPolygon): The region.
+        elevation (float): The elevation (meters) of the footprint.
+
+    Returns:
+        shapely.geometry.Polygon | shapely.geometry.MultiPolygon: The clipped footprint.
+    """
+    clipped = shapely.intersection(shapely.force_2d(footprint), region)
+    parts = [
+        part
+        for part in shapely.get_parts(shapely.get_parts(clipped))
+        if isinstance(part, Polygon) and not part.is_empty
+    ]
+    if len(parts) == 0:
+        return Polygon()
+    return shapely.force_3d(
+        parts[0] if len(parts) == 1 else MultiPolygon(parts), elevation
+    )
+
+
+def collect_platform_track(
+    platforms: SurfacePlatform | list[SurfacePlatform],
+    instrument_index: int | None = 0,
+    elevation: float | None = None,
+    mask: Polygon | MultiPolygon | gpd.GeoDataFrame | gpd.GeoSeries | None = None,
+) -> gpd.GeoDataFrame:
+    """
+    Collect the static footprint of each instrument on fixed surface
+    platforms (e.g. towers or tethered balloons), projected to a target
+    elevation by computing the exact ray/WGS 84 ellipsoid intersection, as
+    for a satellite's ground track (see `collect_ground_track`). Rays that
+    miss a target below the instruments (looking above the horizon) are
+    projected to the horizon. A target above the instruments (as for clouds
+    observed by an instrument looking up, e.g. with a roll angle of 180
+    degrees) is observed only above the horizon: views are clipped to the
+    lines of sight tangent to the ground, which blocks the rest (a view
+    entirely below the horizon has an empty footprint), and to the
+    platform's terrain mask, if any (see
+    `SurfacePlatform.compute_visible_region`). Unlike
+    `collect_ground_track`, there is no time dimension: a platform does not
+    move in the Earth-fixed frame, so this returns one row per platform and
+    instrument rather than one row per time step.
+
+    Args:
+        platforms (SurfacePlatform | list[SurfacePlatform]): The platform(s).
+        instrument_index (int | None): The index of the observing instrument
+                on each platform, or `None` for every instrument of each
+                platform.
+        elevation (float | None): The elevation (meters) above the WGS 84
+                ellipsoid of the observed target for which to compute
+                footprints, below (looking down) or above (looking up) each
+                platform's instruments. Defaults to each platform's ground
+                elevation.
+        mask (shapely.geometry.Polygon | shapely.geometry.MultiPolygon | geopandas.GeoDataFrame | geopandas.GeoSeries | None):
+                An optional mask, always interpreted in WGS84 (lon/lat)
+                coordinates, to constrain results.
+
+    Returns:
+        geopandas.GeoDataFrame: The data frame of collected platform track
+            results, in the order of the platforms and their instruments.
+    """
+    platforms = [platforms] if isinstance(platforms, SurfacePlatform) else platforms
+    records = []
+    for platform in platforms:
+        target = _get_target_elevation(platform, elevation)
+        track = platform.get_track()
+        # the region visible over the terrain mask, toward a target above
+        region = (
+            platform.compute_visible_region(target)
+            if platform.terrain_mask is not None and target > platform.get_altitude()
+            else None
+        )
+        for index in _get_instrument_indices(platform, instrument_index, "platform"):
+            instrument = platform.instruments[index]
+            footprint = instrument.compute_footprint(
+                track, elevation=target, ground_elevation=platform.elevation
+            )[0]
+            if region is not None:
+                footprint = _clip_to_region(footprint, region, target)
+            records.append(
+                {
+                    "platform": platform.name,
+                    "instrument": instrument.name,
+                    "elevation": target,
+                    "geometry": footprint,
+                }
+            )
+    if len(records) == 0:
+        return _get_empty_platform_track()
+    track = gpd.GeoDataFrame(records, crs="EPSG:4326")
+    if mask is not None:
+        # clipping does not preserve the order of rows
+        track = gpd.clip(track, _get_mask_geometry(mask)).sort_index()
+        track = track.reset_index(drop=True)
+    return track
+
+
+def compute_platform_track(
+    platforms: SurfacePlatform | list[SurfacePlatform],
+    instrument_index: int | None = 0,
+    elevation: float | None = None,
+    mask: Polygon | MultiPolygon | gpd.GeoDataFrame | gpd.GeoSeries | None = None,
+) -> gpd.GeoDataFrame:
+    """
+    Compute the aggregated (dissolved) coverage of instruments on fixed
+    surface platforms into a single composite geometry (e.g. a network
+    coverage map): unlike `collect_platform_track` (one footprint polygon per
+    platform and instrument), this dissolves every footprint into one
+    geometry.
+
+    Args:
+        platforms (SurfacePlatform | list[SurfacePlatform]): The platform(s).
+        instrument_index (int | None): The index of the observing instrument
+                on each platform, or `None` for every instrument of each
+                platform.
+        elevation (float | None): The elevation (meters) above the WGS 84
+                ellipsoid of the observed target for which to compute
+                footprints, below (looking down) or above (looking up) each
+                platform's instruments. Defaults to each platform's ground
+                elevation.
+        mask (shapely.geometry.Polygon | shapely.geometry.MultiPolygon | geopandas.GeoDataFrame | geopandas.GeoSeries | None):
+                An optional mask, always interpreted in WGS84 (lon/lat)
+                coordinates, to constrain results.
+
+    Returns:
+        geopandas.GeoDataFrame: The data frame of aggregated platform track results.
+    """
+    track = collect_platform_track(platforms, instrument_index, elevation, mask)
+    if track.empty:
+        return track
+    return track[["geometry"]].dissolve()
diff --git a/src/tatc/preprocess/__init__.py b/src/tatc/preprocess/__init__.py
index fbc2d662..9db26ab4 100644
--- a/src/tatc/preprocess/__init__.py
+++ b/src/tatc/preprocess/__init__.py
@@ -8,6 +8,7 @@
 from .raster import read_raster_weights
 from .terrain import (
     compute_terrain_mask,
+    compute_terrain_mask_for_platform,
     compute_terrain_mask_for_station,
     get_copernicus_dem_tile_urls,
     sample_dem_elevation,
@@ -15,6 +16,7 @@
 
 __all__ = [
     "compute_terrain_mask",
+    "compute_terrain_mask_for_platform",
     "compute_terrain_mask_for_station",
     "get_copernicus_dem_tile_urls",
     "read_raster_weights",
diff --git a/src/tatc/preprocess/terrain.py b/src/tatc/preprocess/terrain.py
index fbc5bd4c..e6daf008 100644
--- a/src/tatc/preprocess/terrain.py
+++ b/src/tatc/preprocess/terrain.py
@@ -1,7 +1,7 @@
 """
 Terrain-based preprocessing utilities: derive a `TerrainMask` for a
-ground-based radar station by sampling a digital elevation model (DEM) for
-terrain obstructions.
+ground-based radar station or a fixed surface platform by sampling a
+digital elevation model (DEM) for terrain obstructions.
 
 A convenient, public, global, 30-meter-resolution DEM requiring no
 authentication is the Copernicus DEM GLO-30 dataset, hosted on AWS Open
@@ -32,7 +32,7 @@
     ) from error
 
 from .. import constants
-from ..schemas.surface.radar import RadarStation, TerrainMask
+from ..schemas.surface import RadarStation, SurfacePlatform, TerrainMask
 from ..utils.geometry import geodesic_destination
 from ..utils.radar import compute_terrain_elevation_angle
 
@@ -242,10 +242,12 @@ def compute_terrain_mask(
     number_azimuths: int = 360,
     number_range_samples: int = 400,
     range_spacing: str = "geometric",
+    effective_earth_radius_factor: float = constants.EFFECTIVE_EARTH_RADIUS_FACTOR,
 ) -> TerrainMask:
     """
-    Computes a `TerrainMask` for a ground-based radar station by ray-
-    tracing a digital elevation model (DEM): at each sampled azimuth,
+    Computes a `TerrainMask` for a ground-based radar station (or other
+    fixed antenna or instrument) by ray-tracing a digital elevation model
+    (DEM): at each sampled azimuth,
     terrain elevation is sampled at a series of ranges out to
     `search_radius`, converted to a curvature-corrected elevation angle as
     seen from the station (`tatc.utils.compute_terrain_elevation_angle`),
@@ -300,6 +302,11 @@ def compute_terrain_mask(
             densely near the station and sparsely far away, so a missed
             ridge crest causes a similar angle error at every range;
             `"linear"` spaces samples evenly.
+        effective_earth_radius_factor (float): The ratio of the effective
+            Earth radius to the mean Earth radius, accounting for refraction
+            (see `tatc.utils.compute_terrain_elevation_angle`): 4/3 for radio
+            waves in a standard atmosphere (the default), or 1 for straight
+            lines of sight (as for the footprints of a `SurfacePlatform`).
 
     Returns:
         TerrainMask: The resulting azimuthal terrain blockage mask. An
@@ -354,7 +361,7 @@ def compute_terrain_mask(
     )
     terrain_elevations = _lookup_elevations(tiles, sample_longitudes, sample_latitudes)
     angles = compute_terrain_elevation_angle(
-        range_grid, terrain_elevations, station_elevation
+        range_grid, terrain_elevations, station_elevation, effective_earth_radius_factor
     )
     # the highest obstruction along each azimuth (-90 if no valid DEM data)
     min_elevation_angles = np.max(np.where(np.isnan(angles), -90.0, angles), axis=1)
@@ -401,3 +408,52 @@ def compute_terrain_mask_for_station(
         number_range_samples=number_range_samples,
         range_spacing=range_spacing,
     )
+
+
+def compute_terrain_mask_for_platform(
+    dem_paths: str | list[str],
+    platform: SurfacePlatform,
+    search_radius: float = 100000,
+    min_range: float = 1000,
+    number_azimuths: int = 360,
+    number_range_samples: int = 400,
+    range_spacing: str = "geometric",
+    effective_earth_radius_factor: float = 1,
+) -> TerrainMask:
+    """
+    Convenience wrapper around `compute_terrain_mask` for the instruments of
+    a `SurfacePlatform`, a `height` above the ground at its location. The
+    ground elevation is sampled from the DEM (see `sample_dem_elevation`),
+    in the DEM's own vertical datum, rather than taken from the platform's
+    `elevation` (above the WGS 84 ellipsoid), so the instruments' height
+    above the surrounding terrain does not depend on the geoid undulation.
+
+    Args:
+        dem_paths (str | list[str]): See `compute_terrain_mask`.
+        platform (SurfacePlatform): The platform (its `longitude`,
+            `latitude`, and `height` are used).
+        search_radius (float): See `compute_terrain_mask`.
+        min_range (float): See `compute_terrain_mask`.
+        number_azimuths (int): See `compute_terrain_mask`.
+        number_range_samples (int): See `compute_terrain_mask`.
+        range_spacing (str): See `compute_terrain_mask`.
+        effective_earth_radius_factor (float): See `compute_terrain_mask`.
+            Defaults to 1 (straight lines of sight, without refraction), as
+            for the platform's footprints.
+
+    Returns:
+        TerrainMask: The resulting azimuthal terrain blockage mask.
+    """
+    ground = sample_dem_elevation(dem_paths, platform.longitude, platform.latitude)
+    return compute_terrain_mask(
+        dem_paths,
+        platform.longitude,
+        platform.latitude,
+        ground + platform.height,
+        search_radius=search_radius,
+        min_range=min_range,
+        number_azimuths=number_azimuths,
+        number_range_samples=number_range_samples,
+        range_spacing=range_spacing,
+        effective_earth_radius_factor=effective_earth_radius_factor,
+    )
diff --git a/src/tatc/schemas/__init__.py b/src/tatc/schemas/__init__.py
index d4b665c1..255b4b5c 100644
--- a/src/tatc/schemas/__init__.py
+++ b/src/tatc/schemas/__init__.py
@@ -30,6 +30,7 @@
     Point,
     RadarBand,
     RadarStation,
+    SurfacePlatform,
     TerrainMask,
 )
 
@@ -55,6 +56,7 @@
     "SOCConstellation",
     "Satellite",
     "SunSynchronousOrbit",
+    "SurfacePlatform",
     "TerrainMask",
     "TrainConstellation",
     "TundraOrbit",
diff --git a/src/tatc/schemas/instrument/conical.py b/src/tatc/schemas/instrument/conical.py
index 0f198581..cb2fc350 100644
--- a/src/tatc/schemas/instrument/conical.py
+++ b/src/tatc/schemas/instrument/conical.py
@@ -218,6 +218,7 @@ def compute_footprint(
         orbit_track: Geocentric,
         number_points: int | None = None,
         elevation: float = 0,
+        ground_elevation: float = 0,
     ) -> list[Polygon | MultiPolygon]:
         """
         Compute the instanteous instrument footprint: the region swept by the
@@ -230,6 +231,8 @@ def compute_footprint(
                 rotation of each edge of the arc. Defaults to the runtime
                 configuration.
             elevation (float): The elevation (meters) at which project the footprint.
+            ground_elevation (float): The elevation (meters) of the ground,
+                which blocks rays toward an elevation above the instrument.
 
         Returns:
             list[shapely.geometry.Polygon | shapely.geometry.MultiPolygon]: The instrument footprint(s).
@@ -259,6 +262,7 @@ def project(rays):
                     elevation,
                     self.velocity_frame,
                     self.nadir_reference,
+                    ground_elevation=ground_elevation,
                 )[:2]
             return np.stack([geos[0], geos[1]], axis=-1)
 
@@ -299,6 +303,7 @@ def compute_footprint_center(
         self,
         orbit_track: Geocentric,
         elevation: float = 0,
+        ground_elevation: float = 0,
     ) -> GeographicPosition:
         """
         Compute the center of an instaneous instrument footprint: the point
@@ -307,6 +312,8 @@ def compute_footprint_center(
         Args:
             orbit_track (skyfield.positionlib.Geocentric): The satellite position/velocity.
             elevation (float): The elevation (meters) at which project the footprint.
+            ground_elevation (float): The elevation (meters) of the ground,
+                which blocks rays toward an elevation above the instrument.
 
         Returns:
             skyfield.toposlib.GeographicPosition: The instrument footprint center.
@@ -321,6 +328,7 @@ def compute_footprint_center(
             elevation=elevation,
             velocity_frame=self.velocity_frame,
             nadir_reference=self.nadir_reference,
+            ground_elevation=ground_elevation,
         )
 
     def is_in_field_of_view(
diff --git a/src/tatc/schemas/instrument/pointed.py b/src/tatc/schemas/instrument/pointed.py
index f2e0d2e5..0e360b0a 100644
--- a/src/tatc/schemas/instrument/pointed.py
+++ b/src/tatc/schemas/instrument/pointed.py
@@ -149,6 +149,7 @@ def compute_footprint(
         orbit_track: Geocentric,
         number_points: int | None = None,
         elevation: float = 0,
+        ground_elevation: float = 0,
     ) -> list[Polygon | MultiPolygon]:
         """
         Compute the instanteous instrument footprint.
@@ -157,6 +158,8 @@ def compute_footprint(
             orbit_track (skyfield.positionlib.Geocentric): The satellite position/velocity.
             number_points (int | None): The required number of polygon points to generate.
             elevation (float): The elevation (meters) at which project the footprint.
+            ground_elevation (float): The elevation (meters) of the ground,
+                which blocks rays toward an elevation above the instrument.
 
         Returns:
             list[shapely.geometry.Polygon | shapely.geometry.MultiPolygon]: The instrument footprint(s).
@@ -173,6 +176,7 @@ def compute_footprint(
             velocity_frame=self.velocity_frame,
             nadir_reference=self.nadir_reference,
             view_geometry=self.view_geometry,
+            ground_elevation=ground_elevation,
         )
 
     @field_validator("roll_angle_profile", "pitch_angle_profile")
@@ -313,6 +317,7 @@ def compute_footprint_center(
         self,
         orbit_track: Geocentric,
         elevation: float = 0,
+        ground_elevation: float = 0,
     ) -> GeographicPosition:
         """
         Compute the center of an instaneous instrument footprint.
@@ -320,6 +325,8 @@ def compute_footprint_center(
         Args:
             orbit_track (skyfield.positionlib.Geocentric): The satellite position/velocity.
             elevation (float): The elevation (meters) at which project the footprint.
+            ground_elevation (float): The elevation (meters) of the ground,
+                which blocks rays toward an elevation above the instrument.
 
         Returns:
             skyfield.toposlib.GeographicPosition: The instrument footprint center.
@@ -335,6 +342,7 @@ def compute_footprint_center(
             elevation=elevation,
             velocity_frame=self.velocity_frame,
             nadir_reference=self.nadir_reference,
+            ground_elevation=ground_elevation,
         )
 
     def compute_projected_pixel_position(
@@ -343,6 +351,7 @@ def compute_projected_pixel_position(
         cross_track_index: int,
         along_track_index: int,
         elevation: float = 0,
+        ground_elevation: float = 0,
     ) -> GeographicPosition:
         """
         Get the location of a projected pixel.
@@ -353,6 +362,8 @@ def compute_projected_pixel_position(
                 index 0 is on the right of the direction of motion).
             along_track_index (int): along-track pixel index (fore-to-aft).
             elevation (float): The elevation (meters) at which project the pixel.
+            ground_elevation (float): The elevation (meters) of the ground,
+                which blocks rays toward an elevation above the instrument.
 
         Returns:
             (skyfield.toposlib.GeographicPosition): the geographic position of the projected pixel
@@ -371,6 +382,7 @@ def compute_projected_pixel_position(
                 velocity_frame=self.velocity_frame,
                 nadir_reference=self.nadir_reference,
                 tilt_angle=self.get_pitch_angle(orbit_track),
+                ground_elevation=ground_elevation,
             )
         cone, clock = self.get_pixel_cone_and_clock_angle(
             cross_track_index, along_track_index
@@ -392,6 +404,7 @@ def compute_projected_pixel_position(
             elevation=elevation,
             velocity_frame=self.velocity_frame,
             nadir_reference=self.nadir_reference,
+            ground_elevation=ground_elevation,
         )
 
     def _get_pixel_offsets(
@@ -454,6 +467,7 @@ def compute_footprint_pixel_array(
         self,
         orbit_track: Geocentric,
         elevation: float = 0,
+        ground_elevation: float = 0,
     ) -> list[MultiPoint]:
         """
         Compute the instanteous footprint pixel array.
@@ -461,6 +475,8 @@ def compute_footprint_pixel_array(
         Args:
             orbit_track (skyfield.positionlib.Geocentric): The satellite position/velocity.
             elevation (float): The elevation (meters) at which project the footprint.
+            ground_elevation (float): The elevation (meters) of the ground,
+                which blocks rays toward an elevation above the instrument.
 
         Returns:
             list[shapely.geometry.MultiPoint]: The instrument pixel array(s).
@@ -471,19 +487,25 @@ def compute_footprint_pixel_array(
                 cross_track_index=i,
                 along_track_index=j,
                 elevation=elevation,
+                ground_elevation=ground_elevation,
             )
             for i in range(self.cross_track_pixels)
             for j in range(self.along_track_pixels)
         ]
+        # coordinates of each pixel, with shape (N,) for one or more times
+        coordinates = [
+            (
+                np.atleast_1d(point.longitude.degrees),
+                np.atleast_1d(point.latitude.degrees),
+                np.atleast_1d(point.elevation.m),
+            )
+            for point in points
+        ]
         return [
             MultiPoint(
                 [
-                    Point(
-                        point.longitude.degrees[i],
-                        point.latitude.degrees[i],
-                        point.elevation.m[i],
-                    )
-                    for point in points
+                    Point(longitude[i], latitude[i], elevation[i])
+                    for longitude, latitude, elevation in coordinates
                 ]
             )
             for i in range(np.size(orbit_track.t.tt))  # type: ignore
diff --git a/src/tatc/schemas/instrument/simple.py b/src/tatc/schemas/instrument/simple.py
index 063d57ba..4e476cfa 100644
--- a/src/tatc/schemas/instrument/simple.py
+++ b/src/tatc/schemas/instrument/simple.py
@@ -132,6 +132,7 @@ def compute_footprint(
         orbit_track: Geocentric,
         number_points: int | None = None,
         elevation: float = 0,
+        ground_elevation: float = 0,
     ) -> list[Polygon | MultiPolygon]:
         """
         Compute the instanteous instrument footprint.
@@ -140,6 +141,8 @@ def compute_footprint(
             orbit_track (skyfield.positionlib.Geocentric): The satellite position/velocity.
             number_points (int | None): The required number of polygon points to generate.
             elevation (float): The elevation (meters) at which project the footprint.
+            ground_elevation (float): The elevation (meters) of the ground,
+                which blocks rays toward an elevation above the instrument.
 
         Returns:
             list[shapely.geometry.Polygon | shapely.geometry.MultiPolygon]: The instrument footprint(s).
@@ -154,12 +157,14 @@ def compute_footprint(
             number_points=number_points,
             elevation=elevation,
             nadir_reference=self.nadir_reference,
+            ground_elevation=ground_elevation,
         )
 
     def compute_footprint_center(
         self,
         orbit_track: Geocentric,
         elevation: float = 0,
+        ground_elevation: float = 0,
     ) -> GeographicPosition:
         """
         Compute the center of an instaneous instrument footprint.
@@ -167,6 +172,8 @@ def compute_footprint_center(
         Args:
             orbit_track (skyfield.positionlib.Geocentric): The satellite position/velocity.
             elevation (float): The elevation (meters) at which project the footprint.
+            ground_elevation (float): The elevation (meters) of the ground,
+                which blocks rays toward an elevation above the instrument.
 
         Returns:
             skyfield.toposlib.GeographicPosition: The instrument footprint center.
@@ -181,6 +188,7 @@ def compute_footprint_center(
             angle=0,
             elevation=elevation,
             nadir_reference=self.nadir_reference,
+            ground_elevation=ground_elevation,
         )
 
     def is_valid_observation(
diff --git a/src/tatc/schemas/surface/__init__.py b/src/tatc/schemas/surface/__init__.py
index 0d407965..8b928d22 100644
--- a/src/tatc/schemas/surface/__init__.py
+++ b/src/tatc/schemas/surface/__init__.py
@@ -4,11 +4,13 @@
 @author: Paul T. Grogan <paul.grogan@asu.edu>
 """
 
+from .platform import SurfacePlatform
 from .point import Point
-from .radar import RadarBand, RadarStation, TerrainMask
+from .radar import RadarBand, RadarStation
 from .station import GroundStation
+from .terrain import TerrainMask
 
-AllSurfaceObjects = Point | GroundStation | RadarStation
+AllSurfaceObjects = Point | GroundStation | RadarStation | SurfacePlatform
 
 __all__ = [
     "AllSurfaceObjects",
@@ -16,5 +18,6 @@
     "Point",
     "RadarBand",
     "RadarStation",
+    "SurfacePlatform",
     "TerrainMask",
 ]
diff --git a/src/tatc/schemas/surface/platform.py b/src/tatc/schemas/surface/platform.py
new file mode 100644
index 00000000..2f43887c
--- /dev/null
+++ b/src/tatc/schemas/surface/platform.py
@@ -0,0 +1,197 @@
+"""
+Object schemas for fixed surface platforms.
+
+@author: Paul T. Grogan <paul.grogan@asu.edu>
+"""
+
+from __future__ import annotations
+
+from datetime import datetime
+
+import numpy as np
+from pydantic import Field, model_validator
+from shapely.geometry import MultiPolygon, Polygon
+from skyfield.positionlib import Geocentric
+
+from ...utils.projection import (
+    VelocityFrame,
+    _compute_horizon_region,
+    compute_static_track,
+)
+from ...utils.time import _to_time
+from ..instrument import (
+    AllInstruments,
+    ConicalInstrument,
+    Instrument,
+    PointedInstrument,
+)
+from .point import Point
+from .terrain import TerrainMask
+
+
+class SurfacePlatform(Point):
+    """
+    Platform fixed above the Earth's surface (e.g. a tower or a tethered
+    balloon) in the WGS 84 coordinate system, hosting one or more
+    instruments. Unlike a satellite, the platform does not move in the
+    Earth-fixed frame, so the views of its instruments, and the footprints
+    they project, are static.
+
+    Instruments are oriented as on a satellite whose direction of motion is
+    the platform's `heading`: a view at zero roll and pitch looks straight
+    down (nadir), a positive roll angle looks to the left of the heading,
+    a positive pitch angle looks toward the heading, and a roll angle of 180
+    degrees looks straight up (zenith). A generic `Instrument` observes a
+    cone about nadir; a `PointedInstrument` observes a view rotated from
+    nadir by fixed roll and pitch angles, for example looking up at a
+    target above the instruments (such as clouds).
+    """
+
+    name: str = Field(..., description="Platform name.", examples=["tower 1"])
+    elevation: float = Field(
+        default=0,
+        description="Elevation (meters) of the ground below the platform above "
+        + "the WGS 84 ellipsoid (which differs from a height above mean sea "
+        + "level by the local geoid undulation).",
+    )
+    height: float = Field(
+        ...,
+        description="Height (meters) of the instruments above the ground, for "
+        + "example the height of a tower or the altitude of a tethered balloon "
+        + "above its tether point.",
+        gt=0,
+        examples=[30],
+    )
+    heading: float = Field(
+        default=0,
+        description="Azimuth (decimal degrees, clockwise from north) of the "
+        + "platform's forward (along-track) direction, which orients the views "
+        + "of its instruments.",
+        ge=0,
+        lt=360,
+    )
+    instruments: list[AllInstruments] = Field(
+        default=[Instrument()],
+        min_length=1,
+        description="List of hosted instruments (`Instrument` or "
+        + "`PointedInstrument`).",
+    )
+    terrain_mask: TerrainMask | None = Field(
+        default=None,
+        description="Optional azimuthal terrain blockage mask as seen from the "
+        + "instruments (e.g. from "
+        + "`tatc.preprocess.compute_terrain_mask_for_platform`), which, with "
+        + "the horizon of the ground, blocks views toward a target above the "
+        + "instruments (see `compute_visible_region`). It does not apply to "
+        + "targets below the instruments.",
+    )
+
+    @model_validator(mode="after")
+    def check_instruments(self) -> SurfacePlatform:
+        """
+        Checks that each instrument's view is defined for a fixed platform:
+        not a `ConicalInstrument` (whose footprint is swept by motion along
+        track), and without roll or pitch angle profiles (which vary with an
+        orbit's argument of latitude) or an inertial velocity frame (aligned
+        with an orbit plane).
+        """
+        for instrument in self.instruments:
+            if isinstance(instrument, ConicalInstrument):
+                raise ValueError(
+                    f"instrument {instrument.name!r}: a ConicalInstrument is not "
+                    "supported on a surface platform"
+                )
+            if isinstance(instrument, PointedInstrument):
+                if (
+                    instrument.roll_angle_profile is not None
+                    or instrument.pitch_angle_profile is not None
+                ):
+                    raise ValueError(
+                        f"instrument {instrument.name!r}: roll and pitch angle "
+                        "profiles are not supported on a surface platform"
+                    )
+                if instrument.velocity_frame != VelocityFrame.EARTH_FIXED:
+                    raise ValueError(
+                        f"instrument {instrument.name!r}: a surface platform's "
+                        "heading defines the along-track direction, which "
+                        "requires velocity_frame='earth_fixed'"
+                    )
+        return self
+
+    def get_altitude(self) -> float:
+        """
+        Gets the elevation of the instruments: the ground elevation plus the
+        platform height.
+
+        Returns:
+            float: the elevation (meters) above the WGS 84 ellipsoid
+        """
+        return self.elevation + self.height
+
+    def compute_visible_region(
+        self, elevation: float, number_azimuths: int = 360
+    ) -> Polygon | MultiPolygon:
+        """
+        Computes the region at a target elevation above the instruments that
+        is visible over the horizon: bounded at each azimuth by the lowest
+        line of sight that clears both the terrain mask (if any) and the
+        horizon of the ground, projected to the target elevation. Footprints
+        toward a target above the instruments are clipped to this region
+        (see `tatc.analysis.collect_platform_track`).
+
+        Args:
+            elevation (float): The target elevation (meters) above the WGS 84
+                ellipsoid, above the instruments.
+            number_azimuths (int): The number of evenly spaced azimuths at
+                which to sample the region (in addition to those of the
+                terrain mask).
+
+        Returns:
+            shapely.geometry.Polygon | shapely.geometry.MultiPolygon: The
+                visible region.
+        """
+        if elevation <= self.get_altitude():
+            raise ValueError(
+                f"target elevation ({elevation} m) must be above the "
+                f"instruments of platform {self.name!r} ({self.get_altitude()} m)"
+            )
+        azimuths = np.linspace(0, 360, number_azimuths, endpoint=False)
+        if self.terrain_mask is None:
+            # below the horizon of the ground at every azimuth
+            angles = np.full(len(azimuths), -89.0)
+        else:
+            azimuths = np.union1d(azimuths, self.terrain_mask.azimuth)
+            angles = self.terrain_mask.get_min_elevation_angles(azimuths)
+        return _compute_horizon_region(
+            self.longitude,
+            self.latitude,
+            self.get_altitude(),
+            elevation,
+            self.elevation,
+            azimuths,
+            angles,
+        )
+
+    def get_track(self, times: datetime | list[datetime] | None = None) -> Geocentric:
+        """
+        Gets the static track of the platform's instruments (see
+        `tatc.utils.compute_static_track`), from which they project their
+        views as from a satellite's orbit track.
+
+        Args:
+            times (datetime.datetime | list[datetime.datetime] | None): The
+                time(s). The views and footprints do not depend on time; times
+                are needed only to evaluate time-varying conditions (such as
+                the sunlit conditions of `Instrument.is_valid_observation`).
+                Defaults to 2020-01-01 00:00:00 UTC.
+
+        Returns:
+            skyfield.positionlib.Geocentric: The position/velocity.
+        """
+        return compute_static_track(
+            self.longitude,
+            self.latitude,
+            self.get_altitude(),
+            self.heading,
+            None if times is None else _to_time(times),
+        )
diff --git a/src/tatc/schemas/surface/radar.py b/src/tatc/schemas/surface/radar.py
index 4b171f27..cd1cfbbe 100644
--- a/src/tatc/schemas/surface/radar.py
+++ b/src/tatc/schemas/surface/radar.py
@@ -9,104 +9,14 @@
 from enum import Enum
 
 import numpy as np
-import numpy.typing as npt
-from pydantic import BaseModel, Field, model_validator
+from pydantic import Field, model_validator
 from shapely.geometry import MultiPolygon, Polygon
 
 from ... import config
 from ...utils.radar import compute_radar_footprint, compute_radar_footprint_profile
 from ...utils.radar import compute_radar_ground_range_bounds
 from .point import Point
-
-
-class TerrainMask(BaseModel):
-    """
-    Azimuthal terrain blockage mask for a ground-based radar station: the
-    minimum usable elevation angle at each azimuth, due to terrain
-    blocking the station's line of sight at low grazing angles. Typically
-    derived by ray-tracing a digital elevation model (DEM) outward from
-    the station to find the highest terrain obstruction angle along each
-    azimuthal direction.
-
-    This represents one blocking angle per azimuth (the common case for a
-    DEM-derived terrain horizon, where the nearest/highest ridge along a
-    ray dominates): any elevation angle at or above the masked value is
-    assumed clear, and any below it is blocked. It does not model
-    multiple, separately-blocked elevation bands along the same azimuth
-    (e.g. a nearby building blocking only a narrow low-elevation slice
-    while a distant mountain blocks a separate, higher slice).
-    """
-
-    azimuth: list[float] = Field(
-        ...,
-        description="Azimuth samples (decimal degrees, clockwise from "
-        + "north, in [0, 360)), strictly increasing, at which the minimum "
-        + "elevation angle is specified. Values are linearly interpolated "
-        + "between samples, wrapping around 0/360 degrees.",
-        min_length=2,
-    )
-    min_elevation_angle: list[float] = Field(
-        ...,
-        description="Minimum usable elevation angle (decimal degrees), "
-        + "due to terrain blockage, at each corresponding azimuth.",
-        min_length=2,
-    )
-
-    @model_validator(mode="after")
-    def validate_profile(self) -> TerrainMask:
-        """
-        Validates that `azimuth` and `min_elevation_angle` are the same
-        length, and that `azimuth` values fall in [0, 360) and are
-        strictly increasing.
-        """
-        if len(self.azimuth) != len(self.min_elevation_angle):
-            raise ValueError(
-                "azimuth and min_elevation_angle must have the same length"
-            )
-        if any(a < 0 or a >= 360 for a in self.azimuth):
-            raise ValueError("azimuth values must be in [0, 360)")
-        if any(b <= a for a, b in zip(self.azimuth, self.azimuth[1:])):
-            raise ValueError("azimuth values must be strictly increasing")
-        return self
-
-    def get_min_elevation_angle(self, azimuth: float) -> float:
-        """
-        Interpolates (periodically, wrapping at 0/360 degrees) the minimum
-        usable elevation angle at a specified azimuth.
-
-        Args:
-            azimuth (float): Azimuth (decimal degrees, clockwise from north).
-
-        Returns:
-            float: The interpolated minimum usable elevation angle (degrees).
-        """
-        return float(self.get_min_elevation_angles(azimuth))
-
-    def get_min_elevation_angles(self, azimuths: npt.ArrayLike) -> npt.NDArray:
-        """
-        Interpolates (periodically, wrapping at 0/360 degrees) the minimum
-        usable elevation angles at specified azimuths, vectorized across
-        azimuths (see `get_min_elevation_angle`).
-
-        Args:
-            azimuths (numpy.typing.ArrayLike): Azimuths (decimal degrees,
-                clockwise from north).
-
-        Returns:
-            numpy.typing.NDArray: The interpolated minimum usable elevation
-            angles (degrees).
-        """
-        samples = np.concatenate(
-            ([self.azimuth[-1] - 360], self.azimuth, [self.azimuth[0] + 360])
-        )
-        angles = np.concatenate(
-            (
-                [self.min_elevation_angle[-1]],
-                self.min_elevation_angle,
-                [self.min_elevation_angle[0]],
-            )
-        )
-        return np.interp(np.asarray(azimuths) % 360, samples, angles)
+from .terrain import TerrainMask
 
 
 class RadarBand(str, Enum):
diff --git a/src/tatc/schemas/surface/terrain.py b/src/tatc/schemas/surface/terrain.py
new file mode 100644
index 00000000..b36d9705
--- /dev/null
+++ b/src/tatc/schemas/surface/terrain.py
@@ -0,0 +1,102 @@
+"""
+Object schemas for terrain masks of fixed surface objects.
+
+@author: Paul T. Grogan <paul.grogan@asu.edu>
+"""
+
+from __future__ import annotations
+
+import numpy as np
+import numpy.typing as npt
+from pydantic import BaseModel, Field, model_validator
+
+
+class TerrainMask(BaseModel):
+    """
+    Azimuthal terrain blockage mask for a fixed surface object (a
+    `RadarStation` or a `SurfacePlatform`): the minimum usable elevation
+    angle at each azimuth, due to terrain blocking the line of sight at low
+    grazing angles. Typically derived by ray-tracing a digital elevation
+    model (DEM) outward from the antenna or instruments to find the highest
+    terrain obstruction angle along each azimuthal direction (see
+    `tatc.preprocess.compute_terrain_mask`).
+
+    This represents one blocking angle per azimuth (the common case for a
+    DEM-derived terrain horizon, where the nearest/highest ridge along a
+    ray dominates): any elevation angle at or above the masked value is
+    assumed clear, and any below it is blocked. It does not model
+    multiple, separately-blocked elevation bands along the same azimuth
+    (e.g. a nearby building blocking only a narrow low-elevation slice
+    while a distant mountain blocks a separate, higher slice).
+    """
+
+    azimuth: list[float] = Field(
+        ...,
+        description="Azimuth samples (decimal degrees, clockwise from "
+        + "north, in [0, 360)), strictly increasing, at which the minimum "
+        + "elevation angle is specified. Values are linearly interpolated "
+        + "between samples, wrapping around 0/360 degrees.",
+        min_length=2,
+    )
+    min_elevation_angle: list[float] = Field(
+        ...,
+        description="Minimum usable elevation angle (decimal degrees), "
+        + "due to terrain blockage, at each corresponding azimuth.",
+        min_length=2,
+    )
+
+    @model_validator(mode="after")
+    def validate_profile(self) -> TerrainMask:
+        """
+        Validates that `azimuth` and `min_elevation_angle` are the same
+        length, and that `azimuth` values fall in [0, 360) and are
+        strictly increasing.
+        """
+        if len(self.azimuth) != len(self.min_elevation_angle):
+            raise ValueError(
+                "azimuth and min_elevation_angle must have the same length"
+            )
+        if any(a < 0 or a >= 360 for a in self.azimuth):
+            raise ValueError("azimuth values must be in [0, 360)")
+        if any(b <= a for a, b in zip(self.azimuth, self.azimuth[1:])):
+            raise ValueError("azimuth values must be strictly increasing")
+        return self
+
+    def get_min_elevation_angle(self, azimuth: float) -> float:
+        """
+        Interpolates (periodically, wrapping at 0/360 degrees) the minimum
+        usable elevation angle at a specified azimuth.
+
+        Args:
+            azimuth (float): Azimuth (decimal degrees, clockwise from north).
+
+        Returns:
+            float: The interpolated minimum usable elevation angle (degrees).
+        """
+        return float(self.get_min_elevation_angles(azimuth))
+
+    def get_min_elevation_angles(self, azimuths: npt.ArrayLike) -> npt.NDArray:
+        """
+        Interpolates (periodically, wrapping at 0/360 degrees) the minimum
+        usable elevation angles at specified azimuths, vectorized across
+        azimuths (see `get_min_elevation_angle`).
+
+        Args:
+            azimuths (numpy.typing.ArrayLike): Azimuths (decimal degrees,
+                clockwise from north).
+
+        Returns:
+            numpy.typing.NDArray: The interpolated minimum usable elevation
+            angles (degrees).
+        """
+        samples = np.concatenate(
+            ([self.azimuth[-1] - 360], self.azimuth, [self.azimuth[0] + 360])
+        )
+        angles = np.concatenate(
+            (
+                [self.min_elevation_angle[-1]],
+                self.min_elevation_angle,
+                [self.min_elevation_angle[0]],
+            )
+        )
+        return np.interp(np.asarray(azimuths) % 360, samples, angles)
diff --git a/src/tatc/utils/__init__.py b/src/tatc/utils/__init__.py
index da6620b2..1533bb7c 100644
--- a/src/tatc/utils/__init__.py
+++ b/src/tatc/utils/__init__.py
@@ -59,6 +59,7 @@
     compute_footprint,
     compute_limb,
     compute_projected_ray_position,
+    compute_static_track,
     compute_view_angles,
     compute_view_tangents,
 )
@@ -106,6 +107,7 @@
     "compute_radar_ground_range",
     "compute_radar_ground_range_bounds",
     "compute_radar_slant_range",
+    "compute_static_track",
     "compute_terrain_elevation_angle",
     "compute_view_angles",
     "compute_view_tangents",
diff --git a/src/tatc/utils/projection.py b/src/tatc/utils/projection.py
index 07f5e56e..7ff5bca4 100644
--- a/src/tatc/utils/projection.py
+++ b/src/tatc/utils/projection.py
@@ -18,15 +18,20 @@
 from shapely.geometry import MultiPolygon, Point, Polygon
 from shapely.ops import transform
 from skyfield.api import wgs84
+from skyfield.constants import AU_M, DAY_S
 from skyfield.framelib import itrs
+from skyfield.functions import _T, mxv
 from skyfield.positionlib import Geocentric
+from skyfield.timelib import Time
 from skyfield.toposlib import GeographicPosition
 from spiceypy.spiceypy import edlimb, recgeo
 
 from .. import config, constants
 from .ellipsoid import (
+    _get_axes,
     _intersect_limb,
     compute_ellipsoid_intersection,
+    geodetic_to_rectangular,
     rectangular_to_geodetic,
 )
 from .geometry import (
@@ -416,13 +421,17 @@ def compute_projected_ray_position(  # pylint: disable=too-many-branches,too-man
     velocity_frame: VelocityFrame = VelocityFrame.EARTH_FIXED,
     nadir_reference: NadirReference = NadirReference.GEODETIC,
     tilt_angle: float = 0,
+    ground_elevation: float = 0,
 ) -> GeographicPosition:
     """
     Get the location of a projected ray from an instrument. The ray is cast
     from the satellite position toward the WGS 84 geoid at the specified
     elevation; if it misses the geoid entirely (e.g. an off-nadir angle
     pointing past the horizon), the projected position instead falls back
-    to the nearest point on the visible Earth limb. Zero roll, pitch, and
+    to the nearest point on the visible Earth limb. Toward an elevation
+    above the instrument (for example, from a surface platform), a ray
+    blocked by the ground below the horizon instead falls back to the line
+    of sight tangent to the ground in the same azimuth. Zero roll, pitch, and
     field of view center on nadir: by default, the geodetic nadir (the WGS 84
     ellipsoid surface normal through the satellite), matching Skyfield's
     `wgs84.subpoint_of`/`wgs84.geographic_position_of`.
@@ -460,6 +469,8 @@ def compute_projected_ray_position(  # pylint: disable=too-many-branches,too-man
             positive forward, applied before the roll angle (tilting the
             plane in which the roll angle is measured, as for the scan plane
             of a `ViewGeometry.SCAN` view).
+        ground_elevation (float): The elevation (meters) of the ground, which
+            blocks rays toward an elevation above the instrument.
 
     Returns:
         (skyfield.toposlib.GeographicPosition): the geographic position of the projected ray
@@ -476,6 +487,7 @@ def compute_projected_ray_position(  # pylint: disable=too-many-branches,too-man
         velocity_frame,
         nadir_reference,
         tilt_angle,
+        ground_elevation,
     )[:, 0]
     # return resulting geographic position
     return wgs84.latlon(geos[1], geos[0], geos[2])
@@ -531,7 +543,56 @@ def _get_rectangular_ray_coefficients(
     return -tan_c_2 * np.tan(2 * np.pi - angle), tan_c_2
 
 
-def _compute_projected_rays(
+def _is_looking_up(
+    position: npt.NDArray, elevation: float, ground_elevation: float
+) -> npt.NDArray[np.bool_]:
+    """
+    Determines whether positions lie between the ground and a target
+    elevation above them (inside the WGS 84 ellipsoid with semi-axes
+    extended by the target elevation, and outside the one extended by the
+    ground elevation), so that views of the target look up.
+
+    Args:
+        position (numpy.typing.NDArray): The positions (meters, Earth-fixed, shape (3, N)).
+        elevation (float): The target elevation (meters) above the WGS 84 ellipsoid.
+        ground_elevation (float): The ground elevation (meters) above the WGS 84 ellipsoid.
+
+    Returns:
+        numpy.typing.NDArray[numpy.bool_]: whether each position looks up
+    """
+    inside = np.sum((position / _get_axes(elevation)) ** 2, axis=0) < 1
+    above = np.sum((position / _get_axes(ground_elevation)) ** 2, axis=0) > 1
+    return inside & above
+
+
+def _is_blocked_by_ground(
+    position: npt.NDArray,
+    direction: npt.NDArray,
+    elevation: float,
+    ground_elevation: float,
+) -> npt.NDArray[np.bool_]:
+    """
+    Determines whether rays toward a target elevation above their origins
+    (see `_is_looking_up`) intersect the ground below their origins before
+    reaching it.
+
+    Args:
+        position (numpy.typing.NDArray): The rays' origins (meters, Earth-fixed, shape (3, N)).
+        direction (numpy.typing.NDArray): The rays' directions (Earth-fixed, shape (3, N)).
+        elevation (float): The target elevation (meters) above the WGS 84 ellipsoid.
+        ground_elevation (float): The ground elevation (meters) above the WGS 84 ellipsoid.
+
+    Returns:
+        numpy.typing.NDArray[numpy.bool_]: whether each ray is blocked
+    """
+    looking_up = _is_looking_up(position, elevation, ground_elevation)
+    if not np.any(looking_up):
+        return looking_up
+    _, hits = compute_ellipsoid_intersection(position, direction, ground_elevation)
+    return looking_up & hits
+
+
+def _compute_rays(
     orbit_track: Geocentric,
     cross_track_field_of_view: float,
     along_track_field_of_view: float,
@@ -539,43 +600,19 @@ def _compute_projected_rays(
     pitch_angle: npt.ArrayLike = 0,
     is_rectangular: bool = False,
     angles: npt.ArrayLike = (0,),
-    elevation: float = 0,
     velocity_frame: VelocityFrame = VelocityFrame.EARTH_FIXED,
     nadir_reference: NadirReference = NadirReference.GEODETIC,
     tilt_angle: float = 0,
-) -> npt.NDArray:
+) -> tuple[npt.NDArray, npt.NDArray, npt.NDArray, npt.NDArray, npt.NDArray, bool]:
     """
-    Get the locations of several projected rays from an instrument (see
-    `compute_projected_ray_position`), vectorized across rays and times:
-    the view frame is computed once, and all rays are projected together.
-
-    Args:
-        orbit_track (skyfield.positionlib.Geocentric): the satellite orbit track.
-        cross_track_field_of_view (float): the instrument cross-track field
-            of view (degrees).
-        along_track_field_of_view (float): the instrument along-track field
-            of view (degrees).
-        roll_angle (numpy.typing.ArrayLike): the roll angle (degrees): a
-            scalar, an array of one per time (shape (N,)), or an array of one
-            per ray (shape (K, 1)) or per ray and time (shape (K, N)).
-        pitch_angle (numpy.typing.ArrayLike): the pitch angle (degrees),
-            shaped as `roll_angle`.
-        is_rectangular (bool): `True` if the instrument view has a rectangular
-            shape (otherwise elliptical).
-        angles (numpy.typing.ArrayLike): the ray angles (degrees, shape (K,))
-            about the view center.
-        elevation (float): The elevation (meters) at which project the rays.
-        velocity_frame (VelocityFrame): The reference frame of the velocity
-            vector that defines the along-track direction.
-        nadir_reference (NadirReference): The definition of the nadir
-            direction from which the view is rotated.
-        tilt_angle (float): a rotation (degrees) about the cross-track axis,
-            positive forward, applied before the roll angle.
+    Get several rays from an instrument (see `_compute_projected_rays` for
+    the arguments), vectorized across rays and times.
 
     Returns:
-        numpy.typing.NDArray: the geodetic longitudes (degrees), latitudes
-            (degrees), and altitudes (meters) of the projected rays, with
-            shape (3, K, N), or (3, K) for a single time.
+        tuple: the rays' origins (meters, Earth-fixed) and directions, the
+            normals of the planes of each ray about the view center, and the
+            unrotated nadir and along-track unit vectors, each with shape
+            (3, K, N); and whether `orbit_track` has a vector of times
     """
     # convert to radians for internal use (with shape (K, 1) to broadcast
     # against times)
@@ -586,8 +623,8 @@ def _compute_projected_rays(
     is_vectorized = len(np.shape(p_m)) > 1
     p_m, n, a, c = (np.reshape(x, (3, 1, -1)) for x in (p_m, n, a, c))
     # ray pointed at the field of view center (before adding the field of
-    # view extent) and the along-track (v) and cross-track (c) axes of the view
-    base_ray, v, c = _rotate_view_axes(n, a, c, roll_angle, pitch_angle, tilt_angle)
+    # view extent) and the along-track (v) and cross-track (u) axes of the view
+    base_ray, v, u = _rotate_view_axes(n, a, c, roll_angle, pitch_angle, tilt_angle)
     # construct projected rays
     if is_rectangular:
         # along track half width
@@ -601,31 +638,58 @@ def _compute_projected_rays(
             ],
             (-1, 2, 1),
         ).transpose(1, 0, 2)
-        ray = base_ray + v * v_coef + c * c_coef
+        ray = base_ray + v * v_coef + u * c_coef
     else:
         ray = (
             base_ray
             + v * np.sin(angle) * np.tan(np.radians(along_track_field_of_view / 2))
-            + c * np.cos(angle) * np.tan(np.radians(cross_track_field_of_view / 2))
+            + u * np.cos(angle) * np.tan(np.radians(cross_track_field_of_view / 2))
         )
-    # find the intersections of the rays and the WGS 84 geoid (at the
-    # elevation), vectorized across rays and times
     shape = np.broadcast_shapes(ray.shape, (3, len(angle), 1))
-    position = np.reshape(np.broadcast_to(p_m, shape), (3, -1))
-    direction = np.reshape(np.broadcast_to(ray, shape), (3, -1))
+    # the planes of each ray, normal to the ray's angle about the view center
+    normal = v * np.sin(np.pi / 2 + angle) + u * np.cos(np.pi / 2 + angle)
+    return (
+        *(np.broadcast_to(x, shape) for x in (p_m, ray, normal, n, a)),
+        is_vectorized,
+    )
+
+
+def _project_rays(
+    position: npt.NDArray,
+    direction: npt.NDArray,
+    normal: npt.NDArray,
+    nadir: npt.NDArray,
+    elevation: float = 0,
+    ground_elevation: float = 0,
+) -> tuple[npt.NDArray, npt.NDArray[np.bool_]]:
+    """
+    Project rays from an instrument to an elevation (see
+    `compute_projected_ray_position`), vectorized across rays.
+
+    Args:
+        position (numpy.typing.NDArray): The rays' origins (meters, Earth-fixed, shape (3, M)).
+        direction (numpy.typing.NDArray): The rays' directions (Earth-fixed, shape (3, M)).
+        normal (numpy.typing.NDArray): The normals of the planes of each ray
+            about the view center (Earth-fixed, shape (3, M)).
+        nadir (numpy.typing.NDArray): The nadir unit vectors (Earth-fixed, shape (3, M)).
+        elevation (float): The elevation (meters) at which project the rays.
+        ground_elevation (float): The elevation (meters) of the ground, which
+            blocks rays toward an elevation above the instrument.
+
+    Returns:
+        tuple[numpy.typing.NDArray, numpy.typing.NDArray[numpy.bool_]]: the
+            geodetic longitudes (degrees), latitudes (degrees), and altitudes
+            (meters) of the projected rays (shape (3, M)), and whether each
+            ray is blocked by the ground
+    """
+    # find the intersections of the rays and the WGS 84 geoid (at the
+    # elevation), vectorized across rays
     points, found = compute_ellipsoid_intersection(position, direction, elevation)
     geos = np.array(rectangular_to_geodetic(points))
     miss = ~found
     if np.any(miss):
         # projected points do not fall on the WGS 84 geoid surface: use the
-        # points of its limb on the plane of each ray, normal to the ray's
-        # angle about the view center
-        normal = np.reshape(
-            np.broadcast_to(
-                v * np.sin(np.pi / 2 + angle) + c * np.cos(np.pi / 2 + angle), shape
-            ),
-            (3, -1),
-        )
+        # points of its limb on the plane of each ray
         geos[:, miss] = np.array(
             rectangular_to_geodetic(
                 _intersect_limb(
@@ -633,7 +697,256 @@ def _compute_projected_rays(
                 )
             )
         )
-    geos = np.reshape(geos, shape)
+    blocked = _is_blocked_by_ground(position, direction, elevation, ground_elevation)
+    if np.any(blocked):
+        # rays toward a target above the instrument are blocked by the ground
+        # below the horizon: use the lines of sight tangent to the ground at
+        # the points of its limb in the same azimuth (on the vertical plane
+        # through each ray and nadir, or the plane of the ray about the view
+        # center for a ray toward nadir), extended to the target elevation
+        origin, toward = position[:, blocked], direction[:, blocked]
+        vertical = np.cross(nadir[:, blocked], toward, axis=0)
+        toward_nadir = np.linalg.norm(vertical, axis=0) <= 1e-9 * np.linalg.norm(
+            toward, axis=0
+        )
+        vertical[:, toward_nadir] = normal[:, blocked][:, toward_nadir]
+        limb = _intersect_limb(origin, toward, vertical, ground_elevation)
+        horizon, _ = compute_ellipsoid_intersection(origin, limb - origin, elevation)
+        geos[:, blocked] = np.array(rectangular_to_geodetic(horizon))
+    return geos, blocked
+
+
+def _compute_horizon_region(
+    longitude: float,
+    latitude: float,
+    altitude: float,
+    elevation: float,
+    ground_elevation: float,
+    azimuths: npt.ArrayLike,
+    min_elevation_angles: npt.ArrayLike,
+) -> Polygon | MultiPolygon:
+    """
+    Compute the region at an elevation above an instrument that is visible
+    over the horizon: the lines of sight at azimuths and minimum elevation
+    angles (for example, from a terrain mask) projected to the elevation,
+    where those below the horizon of the ground are projected along the
+    lines of sight tangent to the ground in the same azimuth.
+
+    Args:
+        longitude (float): The instrument longitude (degrees).
+        latitude (float): The instrument latitude (degrees).
+        altitude (float): The instrument elevation (meters) above the WGS 84 ellipsoid.
+        elevation (float): The elevation (meters) at which project the region,
+            above the instrument.
+        ground_elevation (float): The elevation (meters) of the ground.
+        azimuths (numpy.typing.ArrayLike): The azimuths (degrees, clockwise
+            from north) of the lines of sight.
+        min_elevation_angles (numpy.typing.ArrayLike): The elevation angles
+            (degrees, above local horizontal) of the lines of sight, limited
+            to [-89, 89].
+
+    Returns:
+        shapely.geometry.Polygon | shapely.geometry.MultiPolygon: The region.
+    """
+    lon, lat = np.radians(longitude), np.radians(latitude)
+    up = np.array([np.cos(lat) * np.cos(lon), np.cos(lat) * np.sin(lon), np.sin(lat)])
+    east = np.array([-np.sin(lon), np.cos(lon), 0])
+    north = np.cross(up, east)
+    azimuth = np.radians(np.asarray(azimuths, dtype=float))
+    angle = np.radians(np.clip(np.asarray(min_elevation_angles, dtype=float), -89, 89))
+    direction = (
+        np.outer(east, np.cos(angle) * np.sin(azimuth))
+        + np.outer(north, np.cos(angle) * np.cos(azimuth))
+        + np.outer(up, np.sin(angle))
+    )
+    position = geodetic_to_rectangular(longitude, latitude, altitude)
+    position = np.repeat(position[:, np.newaxis], len(azimuth), axis=1)
+    nadir = np.repeat(-up[:, np.newaxis], len(azimuth), axis=1)
+    geos, _ = _project_rays(
+        position,
+        direction,
+        np.cross(nadir, direction, axis=0),
+        nadir,
+        elevation,
+        ground_elevation,
+    )
+    return _build_split_polygons(geos[0][np.newaxis], geos[1][np.newaxis])[0]
+
+
+def _clip_to_horizon(
+    position: npt.NDArray,
+    direction: npt.NDArray,
+    nadir: npt.NDArray,
+    along: npt.NDArray,
+    elevation: float,
+    ground_elevation: float,
+) -> Polygon | MultiPolygon | None:
+    """
+    Compute the footprint of a view toward an elevation above the instrument
+    that is partly blocked by the ground: the part of the view above the
+    horizon. The view is clipped to the horizon (the lines of sight tangent
+    to the ground) in an azimuthal equidistant projection of directions about
+    zenith, which preserves the azimuth of each direction.
+
+    Args:
+        position (numpy.typing.NDArray): The instrument position (meters, Earth-fixed, shape (3,)).
+        direction (numpy.typing.NDArray): The directions of the rays on the
+            boundary of the view (Earth-fixed, shape (3, K)).
+        nadir (numpy.typing.NDArray): The nadir unit vector (Earth-fixed, shape (3,)).
+        along (numpy.typing.NDArray): The along-track unit vector (Earth-fixed, shape (3,)).
+        elevation (float): The elevation (meters) at which project the footprint.
+        ground_elevation (float): The elevation (meters) of the ground.
+
+    Returns:
+        shapely.geometry.Polygon | shapely.geometry.MultiPolygon | None: The
+            footprint (empty if the view is entirely below the horizon), or
+            None if the view cannot be projected about zenith (if it contains
+            nadir).
+    """
+    cross = np.cross(nadir, along)
+
+    def to_plane(rays: npt.NDArray) -> npt.NDArray:
+        # zenith angles (degrees) and azimuths of the directions
+        rays = rays / np.linalg.norm(rays, axis=0)
+        zenith = np.degrees(np.arccos(np.clip(-nadir @ rays, -1, 1)))
+        azimuth = np.arctan2(cross @ rays, along @ rays)
+        return np.stack([zenith * np.cos(azimuth), zenith * np.sin(azimuth)], axis=1)
+
+    def from_plane(xy: npt.NDArray) -> npt.NDArray:
+        zenith = np.radians(np.hypot(xy[:, 0], xy[:, 1]))
+        azimuth = np.arctan2(xy[:, 1], xy[:, 0])
+        level = np.outer(along, np.cos(azimuth)) + np.outer(cross, np.sin(azimuth))
+        return np.sin(zenith) * level - np.cos(zenith) * nadir[:, np.newaxis]
+
+    def project(xy: npt.NDArray) -> npt.NDArray:
+        # longitudes and latitudes (degrees) of directions projected to the elevation
+        rays = from_plane(xy)
+        geos, _ = _project_rays(
+            np.repeat(position[:, np.newaxis], rays.shape[1], axis=1),
+            rays,
+            np.cross(nadir[:, np.newaxis], rays, axis=0),
+            np.repeat(nadir[:, np.newaxis], rays.shape[1], axis=1),
+            elevation,
+            ground_elevation,
+        )
+        return geos[:2]
+
+    # interpolate the boundary of the view along great circles at most one
+    # degree apart, whose straight segments in the projection would
+    # otherwise cut across wide views
+    unit = direction / np.linalg.norm(direction, axis=0)
+    following = np.roll(unit, -1, axis=1)
+    count = np.maximum(
+        1,
+        np.ceil(
+            np.degrees(np.arccos(np.clip(np.sum(unit * following, axis=0), -1, 1)))
+        ).astype(int),
+    )
+    index = np.repeat(np.arange(unit.shape[1]), count)
+    fraction = (np.arange(len(index)) - np.repeat(np.cumsum(count) - count, count)) / (
+        count[index]
+    )
+    direction = unit[:, index] * (1 - fraction) + following[:, index] * fraction
+    view = Polygon(to_plane(direction))
+    if not view.is_valid:
+        return None
+    # the horizon: lines of sight tangent to the ground, sampled in azimuth
+    azimuth = np.linspace(0, 2 * np.pi, 360, endpoint=False)
+    level = np.outer(along, np.cos(azimuth)) + np.outer(cross, np.sin(azimuth))
+    origin = np.repeat(position[:, np.newaxis], len(azimuth), axis=1)
+    limb = _intersect_limb(
+        origin, level, np.cross(nadir[:, np.newaxis], level, axis=0), ground_elevation
+    )
+    horizon = Polygon(to_plane(limb - origin))
+    # a view whose center (the mean direction of its boundary) projects
+    # outside its boundary contains nadir, and lies outside its boundary
+    center = np.sum(direction / np.linalg.norm(direction, axis=0), axis=1)
+    if view.contains(Point(to_plane(center[:, np.newaxis])[0])):
+        visible = shapely.intersection(view, horizon)
+    else:
+        visible = shapely.difference(horizon, view)
+    parts = []
+    for part in shapely.get_parts(visible):
+        if not isinstance(part, Polygon) or part.is_empty:
+            continue
+        shell = project(np.array(part.exterior.coords)[:-1])
+        if len(part.interiors) > 0:
+            # a view about nadir that reaches above the horizon: an annulus
+            holes = [project(np.array(ring.coords)[:-1]).T for ring in part.interiors]
+            parts.append(Polygon(shell.T, holes))
+        else:
+            footprint = _build_split_polygons(shell[:1], shell[1:])[0]
+            parts.extend(shapely.get_parts(footprint))
+    if len(parts) == 0:
+        return Polygon()
+    return parts[0] if len(parts) == 1 else MultiPolygon(parts)
+
+
+def _compute_projected_rays(
+    orbit_track: Geocentric,
+    cross_track_field_of_view: float,
+    along_track_field_of_view: float,
+    roll_angle: npt.ArrayLike = 0,
+    pitch_angle: npt.ArrayLike = 0,
+    is_rectangular: bool = False,
+    angles: npt.ArrayLike = (0,),
+    elevation: float = 0,
+    velocity_frame: VelocityFrame = VelocityFrame.EARTH_FIXED,
+    nadir_reference: NadirReference = NadirReference.GEODETIC,
+    tilt_angle: float = 0,
+    ground_elevation: float = 0,
+) -> npt.NDArray:
+    """
+    Get the locations of several projected rays from an instrument (see
+    `compute_projected_ray_position`), vectorized across rays and times:
+    the view frame is computed once, and all rays are projected together.
+
+    Args:
+        orbit_track (skyfield.positionlib.Geocentric): the satellite orbit track.
+        cross_track_field_of_view (float): the instrument cross-track field
+            of view (degrees).
+        along_track_field_of_view (float): the instrument along-track field
+            of view (degrees).
+        roll_angle (numpy.typing.ArrayLike): the roll angle (degrees): a
+            scalar, an array of one per time (shape (N,)), or an array of one
+            per ray (shape (K, 1)) or per ray and time (shape (K, N)).
+        pitch_angle (numpy.typing.ArrayLike): the pitch angle (degrees),
+            shaped as `roll_angle`.
+        is_rectangular (bool): `True` if the instrument view has a rectangular
+            shape (otherwise elliptical).
+        angles (numpy.typing.ArrayLike): the ray angles (degrees, shape (K,))
+            about the view center.
+        elevation (float): The elevation (meters) at which project the rays.
+        velocity_frame (VelocityFrame): The reference frame of the velocity
+            vector that defines the along-track direction.
+        nadir_reference (NadirReference): The definition of the nadir
+            direction from which the view is rotated.
+        tilt_angle (float): a rotation (degrees) about the cross-track axis,
+            positive forward, applied before the roll angle.
+        ground_elevation (float): The elevation (meters) of the ground, which
+            blocks rays toward an elevation above the instrument.
+
+    Returns:
+        numpy.typing.NDArray: the geodetic longitudes (degrees), latitudes
+            (degrees), and altitudes (meters) of the projected rays, with
+            shape (3, K, N), or (3, K) for a single time.
+    """
+    *rays, is_vectorized = _compute_rays(
+        orbit_track,
+        cross_track_field_of_view,
+        along_track_field_of_view,
+        roll_angle,
+        pitch_angle,
+        is_rectangular,
+        angles,
+        velocity_frame,
+        nadir_reference,
+        tilt_angle,
+    )
+    geos, _ = _project_rays(
+        *(np.reshape(x, (3, -1)) for x in rays[:4]), elevation, ground_elevation
+    )
+    geos = np.reshape(geos, rays[0].shape)
     return geos if is_vectorized else geos[:, :, 0]
 
 
@@ -649,12 +962,17 @@ def compute_footprint(
     velocity_frame: VelocityFrame = VelocityFrame.EARTH_FIXED,
     nadir_reference: NadirReference = NadirReference.GEODETIC,
     view_geometry: ViewGeometry = ViewGeometry.FRAME,
+    ground_elevation: float = 0,
 ) -> list[Polygon | MultiPolygon]:
     """
     Compute the instantaneous instrument footprint. Supports both a scalar
     (single-time) and vectorized (multi-time) `orbit_track`; the result is
     always a list, with one footprint per time (length 1 for a scalar
-    `orbit_track`).
+    `orbit_track`). Toward an elevation above the instrument (for example,
+    from a surface platform), the footprint is the part of the view above
+    the horizon, clipped to the lines of sight tangent to the ground: empty
+    for a view entirely below the horizon, or an annulus for a view about
+    nadir that reaches above it.
 
     Args:
         orbit_track (skyfield.positionlib.Geocentric): The satellite position/velocity.
@@ -678,6 +996,8 @@ def compute_footprint(
             direction from which the view is rotated.
         view_geometry (ViewGeometry): The geometry in which the fields of view
             are defined.
+        ground_elevation (float): The elevation (meters) of the ground, which
+            blocks rays toward an elevation above the instrument.
 
     Returns:
         list[shapely.geometry.Polygon | shapely.geometry.MultiPolygon]: The instrument footprint(s).
@@ -731,7 +1051,7 @@ def compute_footprint(
             offsets = np.stack([half_c * np.cos(theta), half_a * np.sin(theta)], axis=1)
         # rays at the angular offsets from the roll angle and the scan plane,
         # which the pitch angle tilts about the cross-track axis
-        geos = _compute_projected_rays(
+        *rays, _ = _compute_rays(
             orbit_track,
             0,
             0,
@@ -739,13 +1059,12 @@ def compute_footprint(
             offsets[:, 1:],
             False,
             np.zeros(len(offsets)),
-            elevation,
             velocity_frame,
             nadir_reference,
             pitch_angle,
         )
     else:
-        geos = _compute_projected_rays(
+        *rays, _ = _compute_rays(
             orbit_track,
             cross_track_field_of_view,
             along_track_field_of_view,
@@ -753,16 +1072,32 @@ def compute_footprint(
             pitch_angle,
             is_rectangular,
             angles,
-            elevation,
             velocity_frame,
             nadir_reference,
         )
+    position, direction, _, nadir, along = rays
+    geos, _ = _project_rays(
+        *(np.reshape(x, (3, -1)) for x in rays[:4]), elevation, ground_elevation
+    )
+    geos = np.reshape(geos, position.shape)
     # footprint polygons (one per time), built at once from their points
     # (split along the anti-meridian and poles, and repaired if invalid)
-    footprints = _build_split_polygons(
-        np.reshape(geos[0], (len(geos[0]), -1)).T,
-        np.reshape(geos[1], (len(geos[1]), -1)).T,
-    )
+    footprints = _build_split_polygons(geos[0].T, geos[1].T)
+    for i in np.flatnonzero(
+        _is_looking_up(position[:, 0], elevation, ground_elevation)
+    ):
+        # clip views toward a target above the instrument to the horizon
+        # (including views about nadir, whose boundaries may be visible)
+        clipped = _clip_to_horizon(
+            position[:, 0, i],
+            direction[:, :, i],
+            nadir[:, 0, i],
+            along[:, 0, i],
+            elevation,
+            ground_elevation,
+        )
+        if clipped is not None:
+            footprints[i] = clipped
     # project the footprints to the elevation
     return list(shapely.force_3d(footprints, elevation))
 
@@ -847,6 +1182,67 @@ def compute_limb(
     return [_compute_limb_for_position(p_m, number_points, elevation)]
 
 
+def compute_static_track(
+    longitude: float,
+    latitude: float,
+    elevation: float = 0,
+    heading: float = 0,
+    t: Time | None = None,
+) -> Geocentric:
+    """
+    Compute the track of an instrument fixed in the Earth-fixed (ITRS) frame,
+    as for a tower or a tethered balloon: a position and velocity, in the
+    form of a satellite's orbit track, from which instruments project their
+    views (see `compute_footprint`). Its Earth-fixed velocity is a unit
+    vector (1 m/s) in the local horizontal plane toward the heading, which
+    only orients the view: the along-track axis points toward the heading,
+    so that a positive roll angle looks to its left and a positive pitch
+    angle looks toward it. The track is static: its Earth-fixed position and
+    view do not change with time, while its inertial (GCRS) position and
+    velocity rotate with the Earth (for example, to evaluate sunlit
+    conditions).
+
+    Args:
+        longitude (float): The geodetic longitude (degrees).
+        latitude (float): The geodetic latitude (degrees).
+        elevation (float): The elevation (meters) above the WGS 84 ellipsoid.
+        heading (float): The azimuth (degrees, clockwise from north) of the
+            along-track (forward) direction.
+        t (skyfield.timelib.Time | None): The time(s), a scalar or a vector.
+            Defaults to 2020-01-01 00:00:00 UTC.
+
+    Returns:
+        skyfield.positionlib.Geocentric: The position/velocity (with shape
+            (3,) for a scalar time or (3, N) for N times).
+    """
+    if t is None:
+        t = constants.timescale.utc(2020, 1, 1)
+    lat, lon, azimuth = np.radians([latitude, longitude, heading])
+    position = np.array(wgs84.latlon(latitude, longitude, elevation).itrs_xyz.m)
+    # unit vector toward the heading in the local (geodetic) horizontal plane
+    east = np.array([-np.sin(lon), np.cos(lon), 0])
+    north = np.array(
+        [-np.sin(lat) * np.cos(lon), -np.sin(lat) * np.sin(lon), np.cos(lat)]
+    )
+    velocity = np.sin(azimuth) * east + np.cos(azimuth) * north
+    if np.ndim(t.tt) > 0:
+        position = np.repeat(position[:, np.newaxis], np.size(t.tt), axis=1)
+        velocity = np.repeat(velocity[:, np.newaxis], np.size(t.tt), axis=1)
+    r_au = position / AU_M
+    v_au_per_d = velocity / AU_M * DAY_S
+    # invert Skyfield's conversion to the Earth-fixed frame (see
+    # `ICRF.frame_xyz_and_velocity`), which adds the velocity of the rotating
+    # frame, so that the track converts back to this position and velocity
+    rotation = itrs.rotation_at(t)
+    rate = itrs._dRdt_times_RT_at(t)  # pylint: disable=protected-access
+    return Geocentric(
+        mxv(_T(rotation), r_au),
+        mxv(_T(rotation), v_au_per_d - mxv(rate, r_au)),
+        t,
+        center=399,
+    )
+
+
 def buffer_footprint(
     geometry: Geometry,
     to_crs: Transformer,
diff --git a/src/tatc/utils/radar.py b/src/tatc/utils/radar.py
index 2d3e849e..1a422166 100644
--- a/src/tatc/utils/radar.py
+++ b/src/tatc/utils/radar.py
@@ -256,7 +256,10 @@ def compute_radar_ground_range_bounds(
 
 @njit(cache=True)
 def compute_terrain_elevation_angle(
-    ground_distance: float, terrain_elevation: float, station_elevation: float = 0
+    ground_distance: float,
+    terrain_elevation: float,
+    station_elevation: float = 0,
+    effective_earth_radius_factor: float = constants.EFFECTIVE_EARTH_RADIUS_FACTOR,
 ) -> float:
     """
     Fast computation of the curvature-corrected elevation angle, as seen
@@ -278,6 +281,10 @@ def compute_terrain_elevation_angle(
             in the same vertical reference as `station_elevation`.
         station_elevation (float): Elevation (meters) of the station
             (antenna).
+        effective_earth_radius_factor (float): The ratio of the effective
+            Earth radius to the mean Earth radius, accounting for refraction:
+            4/3 for radio waves in a standard atmosphere (the default), or 1
+            for straight lines of sight (without refraction).
 
     Returns:
         float: The elevation angle (degrees) to the terrain point, as seen
@@ -289,9 +296,7 @@ def compute_terrain_elevation_angle(
         terrain_elevation * 1.0,
         station_elevation * 1.0,
     )
-    effective_radius = (
-        constants.EFFECTIVE_EARTH_RADIUS_FACTOR * constants.EARTH_MEAN_RADIUS
-    )
+    effective_radius = effective_earth_radius_factor * constants.EARTH_MEAN_RADIUS
     curvature_drop = ground_distance**2 / (2 * effective_radius)
     return np.degrees(
         np.arctan2(
diff --git a/tests/analysis/test_platform_track.py b/tests/analysis/test_platform_track.py
new file mode 100644
index 00000000..31cedea3
--- /dev/null
+++ b/tests/analysis/test_platform_track.py
@@ -0,0 +1,435 @@
+"""
+Unit tests for surface platform analysis functions.
+
+@author Paul T. Grogan <paul.grogan@asu.edu>
+"""
+
+import unittest
+from datetime import datetime, timezone
+
+import numpy as np
+from pyproj import Geod
+from shapely.geometry import Polygon, box
+from skyfield.api import wgs84
+from skyfield.framelib import itrs
+
+from tatc.analysis import (
+    collect_ground_track,
+    collect_platform_track,
+    compute_platform_track,
+)
+from tatc.schemas import (
+    Instrument,
+    PointedInstrument,
+    Satellite,
+    SurfacePlatform,
+    TerrainMask,
+)
+from tatc.utils import ViewGeometry
+
+from .common import IssConstellationTestCase
+
+GEOD = Geod(ellps="WGS84")
+
+
+def _distances(platform, geometry):
+    """
+    Distances (meters) from a platform to the exterior points of a footprint.
+    """
+    lon, lat, *_ = zip(*geometry.exterior.coords)
+    return GEOD.inv(
+        np.full(len(lon), platform.longitude),
+        np.full(len(lat), platform.latitude),
+        lon,
+        lat,
+    )[2]
+
+
+class TestPlatformAnalysis(IssConstellationTestCase):
+    """
+    Unit tests for surface platform analysis functions.
+    """
+
+    def setUp(self):
+        super().setUp()
+        self.camera = Instrument(name="Camera", field_of_regard=60)
+        self.oblique = PointedInstrument(
+            name="Oblique",
+            cross_track_field_of_view=40,
+            along_track_field_of_view=30,
+            pitch_angle=60,
+            is_rectangular=True,
+        )
+        self.platform = SurfacePlatform(
+            name="Balloon",
+            latitude=33.45,
+            longitude=-112.07,
+            elevation=300,
+            height=500,
+            heading=45,
+            instruments=[self.camera, self.oblique],
+        )
+        self.platforms = [
+            self.platform,
+            SurfacePlatform(
+                name="Tower",
+                latitude=33.46,
+                longitude=-112.06,
+                elevation=310,
+                height=30,
+                instruments=[self.camera],
+            ),
+        ]
+
+    def test_collect_platform_track_empty(self):
+        """
+        Test that an empty platform list produces an empty data frame.
+        """
+        track = collect_platform_track([])
+        self.assertTrue(track.empty)
+        self.assertListEqual(
+            list(track.columns), ["platform", "instrument", "elevation", "geometry"]
+        )
+
+    def test_collect_platform_track_singular_matches_list(self):
+        """
+        Test that passing a single platform produces the same result as
+        passing a list containing that one platform.
+        """
+        singular = collect_platform_track(self.platform)
+        as_list = collect_platform_track([self.platform])
+        self.assertEqual(len(singular), 1)
+        self.assertTrue(singular.geometry.iloc[0].equals(as_list.geometry.iloc[0]))
+
+    def test_collect_platform_track_instruments(self):
+        """
+        Test that collecting every instrument of several platforms produces
+        one row per platform and instrument, in order.
+        """
+        track = collect_platform_track(self.platforms, instrument_index=None)
+        self.assertListEqual(list(track.platform), ["Balloon", "Balloon", "Tower"])
+        self.assertListEqual(list(track.instrument), ["Camera", "Oblique", "Camera"])
+        self.assertListEqual(list(track.elevation), [300, 300, 310])
+        track = collect_platform_track(self.platform, instrument_index=1)
+        self.assertListEqual(list(track.instrument), ["Oblique"])
+
+    def test_collect_platform_track_instrument_index_out_of_range(self):
+        """
+        Test that an instrument index out of range names the platform.
+        """
+        with self.assertRaisesRegex(IndexError, "platform 'Tower'"):
+            collect_platform_track(self.platforms, instrument_index=1)
+
+    def test_collect_platform_track_nadir_footprint(self):
+        """
+        Test that a nadir cone projects to a circle of radius height times the
+        tangent of the half angle at the ground or a target elevation.
+        """
+        for elevation, height in [(None, 500), (600, 200)]:
+            track = collect_platform_track(self.platform, elevation=elevation)
+            distances = _distances(self.platform, track.geometry.iloc[0])
+            np.testing.assert_allclose(
+                distances, height * np.tan(np.radians(30)), atol=0.1
+            )
+            elevations = [z for *_, z in track.geometry.iloc[0].exterior.coords]
+            np.testing.assert_allclose(elevations, track.elevation.iloc[0])
+
+    def test_collect_platform_track_horizon(self):
+        """
+        Test that a hemispheric view projects to the horizon.
+        """
+        platform = self.platform.model_copy(
+            update={"instruments": [Instrument(field_of_regard=180)]}
+        )
+        track = collect_platform_track(platform)
+        distances = _distances(platform, track.geometry.iloc[0])
+        np.testing.assert_allclose(distances, np.sqrt(2 * 6371e3 * 500), rtol=0.005)
+
+    def test_collect_platform_track_oblique_footprint(self):
+        """
+        Test that a forward-pitched view projects ahead of the platform,
+        toward its heading, between the near and far edges of the view.
+        """
+        footprint = collect_platform_track(
+            self.platform, instrument_index=1
+        ).geometry.iloc[0]
+        azimuth, _, distance = GEOD.inv(
+            self.platform.longitude,
+            self.platform.latitude,
+            footprint.centroid.x,
+            footprint.centroid.y,
+        )
+        self.assertAlmostEqual(azimuth, 45, delta=0.1)
+        self.assertGreater(distance, 500 * np.tan(np.radians(45)))
+        self.assertLess(distance, 500 * np.tan(np.radians(75)))
+        self.assertAlmostEqual(min(_distances(self.platform, footprint)), 500, delta=1)
+
+    def test_collect_platform_track_scan_geometry(self):
+        """
+        Test that a scanning view rolled to the left of the heading projects
+        to the left.
+        """
+        platform = self.platform.model_copy(
+            update={
+                "instruments": [
+                    PointedInstrument(
+                        cross_track_field_of_view=20,
+                        along_track_field_of_view=2,
+                        roll_angle=45,
+                        view_geometry=ViewGeometry.SCAN,
+                        is_rectangular=True,
+                    )
+                ]
+            }
+        )
+        footprint = collect_platform_track(platform).geometry.iloc[0]
+        azimuth, _, _ = GEOD.inv(
+            platform.longitude,
+            platform.latitude,
+            footprint.centroid.x,
+            footprint.centroid.y,
+        )
+        self.assertAlmostEqual(azimuth % 360, 315, delta=0.1)
+
+    def test_collect_platform_track_zenith_footprint(self):
+        """
+        Test that a zenith cone projects to a circle of radius the height of
+        a target above the instruments times the tangent of the half angle.
+        """
+        platform = self.platforms[1].model_copy(
+            update={
+                "instruments": [
+                    PointedInstrument(
+                        cross_track_field_of_view=60,
+                        along_track_field_of_view=60,
+                        roll_angle=180,
+                    )
+                ]
+            }
+        )
+        track = collect_platform_track(platform, elevation=1340)
+        distances = _distances(platform, track.geometry.iloc[0])
+        # geodesic distances on the ellipsoid, below the target elevation, to
+        # the points on the circle and between them (on great circles)
+        radius = 1000 * np.tan(np.radians(30))
+        self.assertAlmostEqual(max(distances), radius, delta=1e-3 * radius)
+        self.assertGreater(min(distances), 0.99 * radius)
+        elevations = [z for *_, z in track.geometry.iloc[0].exterior.coords]
+        np.testing.assert_allclose(elevations, 1340)
+
+    def test_collect_platform_track_ground_horizon(self):
+        """
+        Test that a view toward a target above the instruments that is partly
+        blocked by the ground is clipped to the horizon, spanning the view's
+        azimuths along the lines of sight tangent to the ground.
+        """
+        platform = self.platforms[1].model_copy(
+            update={
+                "instruments": [
+                    PointedInstrument(
+                        cross_track_field_of_view=40,
+                        along_track_field_of_view=40,
+                        roll_angle=90,
+                        is_rectangular=True,
+                    )
+                ]
+            }
+        )
+        footprint = collect_platform_track(platform, elevation=1310).geometry.iloc[0]
+        self.assertEqual(footprint.geom_type, "Polygon")
+        self.assertTrue(footprint.is_valid)
+        distances = _distances(platform, footprint)
+        # the upper edge of the view, 20 degrees above horizontal
+        self.assertAlmostEqual(
+            min(distances), 970 / np.tan(np.radians(20)), delta=0.01 * 970
+        )
+        # the line of sight tangent to the ground, extended to 1 km above it
+        horizon = np.sqrt(2 * 6371e3 * 30) + np.sqrt(2 * 6371e3 * 1000)
+        np.testing.assert_allclose(max(distances), horizon, rtol=0.005)
+        # the horizon spans the view's azimuths, to the left of the heading
+        lon, lat, *_ = zip(*footprint.exterior.coords)
+        azimuths = GEOD.inv(
+            np.full(len(lon), platform.longitude),
+            np.full(len(lat), platform.latitude),
+            lon,
+            lat,
+        )[0][distances > 0.995 * horizon]
+        self.assertAlmostEqual(min(azimuths), -110, delta=0.5)
+        self.assertAlmostEqual(max(azimuths), -70, delta=0.5)
+
+    def test_collect_platform_track_ground_horizon_tilted(self):
+        """
+        Test that tilted views toward a target above the instruments that are
+        partly blocked by the ground project to valid polygons.
+        """
+        for roll_angle, pitch_angle in [(95, -60), (100, 30), (90, 45), (120, -15)]:
+            platform = self.platforms[1].model_copy(
+                update={
+                    "instruments": [
+                        PointedInstrument(
+                            cross_track_field_of_view=30,
+                            along_track_field_of_view=20,
+                            roll_angle=roll_angle,
+                            pitch_angle=pitch_angle,
+                            is_rectangular=True,
+                        )
+                    ]
+                }
+            )
+            footprint = collect_platform_track(platform, elevation=1310).geometry
+            self.assertEqual(footprint.iloc[0].geom_type, "Polygon")
+            self.assertTrue(footprint.iloc[0].is_valid)
+
+    def test_collect_platform_track_ground_blocked(self):
+        """
+        Test that a view about nadir toward a target above the instruments
+        is blocked by the ground: entirely, with an empty footprint, or
+        except for an annulus between the horizontal and the horizon.
+        """
+        platform = self.platforms[1].model_copy(
+            update={
+                "instruments": [
+                    Instrument(field_of_regard=60),
+                    Instrument(field_of_regard=180),
+                ]
+            }
+        )
+        footprints = collect_platform_track(
+            platform, instrument_index=None, elevation=1310
+        ).geometry
+        self.assertTrue(footprints.iloc[0].is_empty)
+        annulus = footprints.iloc[1]
+        self.assertTrue(annulus.is_valid)
+        self.assertEqual(len(annulus.interiors), 1)
+        # horizontal lines of sight reach 970 m above the instruments
+        hole = Polygon(annulus.interiors[0])
+        np.testing.assert_allclose(
+            _distances(platform, hole), np.sqrt(2 * 6371e3 * 970), rtol=0.005
+        )
+        np.testing.assert_allclose(
+            _distances(platform, annulus),
+            np.sqrt(2 * 6371e3 * 30) + np.sqrt(2 * 6371e3 * 1000),
+            rtol=0.005,
+        )
+
+    def test_collect_platform_track_terrain_mask(self):
+        """
+        Test that a terrain mask clips footprints toward a target above the
+        instruments to the region visible over it, but not footprints toward
+        a target below the instruments.
+        """
+        mask = TerrainMask(
+            azimuth=[0, 240, 250, 290, 300], min_elevation_angle=[-1, -1, 2, 2, -1]
+        )
+        platform = self.platforms[1].model_copy(
+            update={
+                "terrain_mask": mask,
+                "instruments": [
+                    PointedInstrument(
+                        cross_track_field_of_view=40,
+                        along_track_field_of_view=40,
+                        roll_angle=90,
+                        is_rectangular=True,
+                    )
+                ],
+            }
+        )
+        unmasked = platform.model_copy(update={"terrain_mask": None})
+        footprint = collect_platform_track(platform, elevation=1310).geometry.iloc[0]
+        self.assertTrue(footprint.is_valid)
+        self.assertTrue(footprint.has_z)
+        self.assertTrue(
+            footprint.equals(
+                collect_platform_track(unmasked, elevation=1310)
+                .geometry.iloc[0]
+                .intersection(platform.compute_visible_region(1310))
+            )
+        )
+        # the ridge (2 degrees above horizontal) limits the view to the west
+        self.assertLess(max(_distances(platform, footprint)), 30000)
+        # but not toward a target below the instruments
+        self.assertTrue(
+            collect_platform_track(platform)
+            .geometry.iloc[0]
+            .equals(collect_platform_track(unmasked).geometry.iloc[0])
+        )
+
+    def test_collect_platform_track_elevation_at_instruments(self):
+        """
+        Test that a target elevation at a platform's instruments raises a
+        ValueError.
+        """
+        with self.assertRaisesRegex(ValueError, "Tower"):
+            collect_platform_track(self.platforms, elevation=340)
+        with self.assertRaises(ValueError):
+            collect_platform_track(self.platform, elevation=800)
+
+    def test_collect_platform_track_mask(self):
+        """
+        Test that a mask clips results to the intersecting platform(s) only,
+        in order.
+        """
+        far = self.platform.model_copy(update={"name": "Far", "longitude": -100})
+        mask = box(-113, 33, -112, 34)
+        track = collect_platform_track([far, *self.platforms], None, mask=mask)
+        self.assertListEqual(list(track.platform), ["Balloon", "Balloon", "Tower"])
+        self.assertListEqual(list(track.index), [0, 1, 2])
+
+    def test_matches_satellite_ground_track(self):
+        """
+        Test that a platform at a satellite's position, heading along its
+        ground track, projects the same footprint as the satellite.
+        """
+        time = datetime(2022, 6, 20, tzinfo=timezone.utc)
+        instrument = PointedInstrument(
+            cross_track_field_of_view=20,
+            along_track_field_of_view=10,
+            roll_angle=15,
+            pitch_angle=-5,
+            is_rectangular=True,
+        )
+        satellite = Satellite(name="ISS", orbit=self.orbit, instruments=[instrument])
+        expected = collect_ground_track(satellite, [time]).geometry.iloc[0]
+        orbit_track = self.orbit.to_gp_orbit().get_orbit_track([time])
+        _, velocity = orbit_track.frame_xyz_and_velocity(itrs)
+        subpoint = wgs84.geographic_position_of(orbit_track)
+        lat = np.radians(subpoint.latitude.degrees[0])
+        lon = np.radians(subpoint.longitude.degrees[0])
+        east = [-np.sin(lon), np.cos(lon), 0]
+        north = [-np.sin(lat) * np.cos(lon), -np.sin(lat) * np.sin(lon), np.cos(lat)]
+        v = np.array(velocity.m_per_s)[:, 0]
+        platform = SurfacePlatform(
+            name="ISS",
+            latitude=subpoint.latitude.degrees[0],
+            longitude=subpoint.longitude.degrees[0],
+            height=subpoint.elevation.m[0],
+            heading=np.degrees(np.arctan2(np.dot(v, east), np.dot(v, north))) % 360,
+            instruments=[instrument],
+        )
+        footprint = collect_platform_track(platform).geometry.iloc[0]
+        np.testing.assert_allclose(
+            np.array(footprint.exterior.coords),
+            np.array(expected.exterior.coords),
+            atol=1e-6,
+        )
+
+    def test_compute_platform_track_dissolves(self):
+        """
+        Test that compute_platform_track dissolves footprints into a single
+        geometry.
+        """
+        merged = compute_platform_track(self.platforms, instrument_index=None)
+        self.assertEqual(len(merged), 1)
+        self.assertListEqual(list(merged.columns), ["geometry"])
+        individual = collect_platform_track(self.platforms, instrument_index=None)
+        self.assertTrue(merged.geometry.iloc[0].covers(individual.union_all()))
+
+    def test_compute_platform_track_empty(self):
+        """
+        Test that an empty platform list produces an empty data frame.
+        """
+        self.assertTrue(compute_platform_track([]).empty)
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/tests/preprocess/test_terrain.py b/tests/preprocess/test_terrain.py
index 385c6c49..822cb50e 100644
--- a/tests/preprocess/test_terrain.py
+++ b/tests/preprocess/test_terrain.py
@@ -18,11 +18,12 @@
 
 from tatc.preprocess import (
     compute_terrain_mask,
+    compute_terrain_mask_for_platform,
     compute_terrain_mask_for_station,
     get_copernicus_dem_tile_urls,
     sample_dem_elevation,
 )
-from tatc.schemas import RadarStation
+from tatc.schemas import RadarStation, SurfacePlatform
 
 
 def _write_ridge_dem(path: str) -> None:
@@ -321,6 +322,36 @@ def test_compute_terrain_mask_for_station_matches_direct_call(self):
         self.assertEqual(direct.azimuth, wrapped.azimuth)
         self.assertEqual(direct.min_elevation_angle, wrapped.min_elevation_angle)
 
+    def test_compute_terrain_mask_for_platform_matches_direct_call(self):
+        """
+        Test that the SurfacePlatform convenience wrapper places the
+        instruments a platform height above the DEM ground, without
+        refraction by default.
+        """
+        platform = SurfacePlatform(
+            name="test", latitude=0.0, longitude=0.0, elevation=-30, height=30
+        )
+        kwargs = {"search_radius": 50000, "number_azimuths": 36}
+        kwargs["number_range_samples"] = 50
+        direct = compute_terrain_mask(
+            self.dem_path, 0.0, 0.0, 30, effective_earth_radius_factor=1, **kwargs
+        )
+        wrapped = compute_terrain_mask_for_platform(self.dem_path, platform, **kwargs)
+        self.assertEqual(direct.azimuth, wrapped.azimuth)
+        self.assertEqual(direct.min_elevation_angle, wrapped.min_elevation_angle)
+        # refraction (4/3) raises the apparent terrain
+        refracted = compute_terrain_mask_for_platform(
+            self.dem_path, platform, effective_earth_radius_factor=4 / 3, **kwargs
+        )
+        self.assertTrue(
+            all(
+                a > b
+                for a, b in zip(
+                    refracted.min_elevation_angle, wrapped.min_elevation_angle
+                )
+            )
+        )
+
     def test_terrain_mask_usable_by_radar_station(self):
         """
         Test that the resulting TerrainMask can be attached to a
diff --git a/tests/schemas/instrument/test_pointed.py b/tests/schemas/instrument/test_pointed.py
index 2961b1ff..dfcd791d 100644
--- a/tests/schemas/instrument/test_pointed.py
+++ b/tests/schemas/instrument/test_pointed.py
@@ -494,6 +494,24 @@ def test_compute_footprint_pixel_array_shape(self):
         for pixel_array in pixel_arrays:
             self.assertEqual(len(pixel_array.geoms), 6)
 
+    def test_compute_footprint_pixel_array_scalar_time(self):
+        """
+        Test that the pixel array of a single-time (scalar) orbit track
+        matches that of the same time in a vector of times.
+        """
+        o = PointedInstrument(
+            name="t",
+            cross_track_field_of_view=20.0,
+            along_track_field_of_view=10.0,
+            cross_track_pixels=3,
+            along_track_pixels=2,
+        )
+        times = timescale.utc(2020, 3, 20, 12, 0, [0, 1])  # type: ignore
+        pixel_arrays = o.compute_footprint_pixel_array(self.test_sat.at(times[0]))
+        self.assertEqual(len(pixel_arrays), 1)
+        expected = o.compute_footprint_pixel_array(self.test_sat.at(times))[0]
+        self.assertTrue(pixel_arrays[0].equals_exact(expected, 1e-9))
+
     def test_compute_footprint_cross_track_extent_matches_swath_width(self):
         """
         Test that the cross-track and along-track extents of a computed
diff --git a/tests/schemas/surface/test_platform.py b/tests/schemas/surface/test_platform.py
new file mode 100644
index 00000000..2b9f289a
--- /dev/null
+++ b/tests/schemas/surface/test_platform.py
@@ -0,0 +1,189 @@
+"""
+Unit tests for the SurfacePlatform schema.
+
+@author Paul T. Grogan <paul.grogan@asu.edu>
+"""
+
+import unittest
+from datetime import datetime, timezone
+
+import numpy as np
+from pydantic import ValidationError
+from pyproj import Geod
+from skyfield.api import wgs84
+from skyfield.framelib import itrs
+
+from tatc.schemas import (
+    ConicalInstrument,
+    Instrument,
+    PointedInstrument,
+    SurfacePlatform,
+    TerrainMask,
+)
+from tatc.utils import VelocityFrame
+
+
+class TestSurfacePlatform(unittest.TestCase):
+    """
+    Unit tests for the SurfacePlatform schema.
+    """
+
+    def test_good_data(self):
+        """
+        Test that the SurfacePlatform schema correctly initializes with valid data.
+        """
+        good_data = {
+            "name": "Tower",
+            "latitude": 33.45,
+            "longitude": -112.07,
+            "elevation": 300,
+            "height": 30,
+            "heading": 90,
+            "instruments": [
+                {"name": "Camera", "field_of_regard": 60},
+                {
+                    "name": "Pointed",
+                    "cross_track_field_of_view": 40,
+                    "along_track_field_of_view": 30,
+                    "pitch_angle": 60,
+                },
+            ],
+        }
+        o = SurfacePlatform(**good_data)
+        self.assertEqual(o.name, "Tower")
+        self.assertEqual(o.height, 30)
+        self.assertEqual(o.heading, 90)
+        self.assertIsInstance(o.instruments[0], Instrument)
+        self.assertIsInstance(o.instruments[1], PointedInstrument)
+        self.assertEqual(o.get_altitude(), 330)
+
+    def test_default_instrument(self):
+        """
+        Test that a platform hosts a default instrument.
+        """
+        o = SurfacePlatform(name="Tower", latitude=0, longitude=0, height=30)
+        self.assertEqual(len(o.instruments), 1)
+        self.assertEqual(o.heading, 0)
+        self.assertEqual(o.elevation, 0)
+
+    def test_bad_data(self):
+        """
+        Test that invalid heights and headings raise validation errors.
+        """
+        for bad in [
+            {"height": 0},
+            {"height": -10},
+            {"height": 30, "heading": 360},
+            {"height": 30, "heading": -1},
+            {"height": 30, "instruments": []},
+        ]:
+            with self.assertRaises(ValidationError):
+                SurfacePlatform(name="Tower", latitude=0, longitude=0, **bad)
+        with self.assertRaises(ValidationError):
+            SurfacePlatform(name="Tower", latitude=0, longitude=0)
+
+    def test_unsupported_instruments(self):
+        """
+        Test that instruments whose views depend on orbital motion raise
+        validation errors.
+        """
+        for instrument in [
+            ConicalInstrument(cone_angle=45, along_track_field_of_view=1),
+            PointedInstrument(
+                cross_track_field_of_view=10,
+                along_track_field_of_view=10,
+                roll_angle_profile=[(0, 10)],
+            ),
+            PointedInstrument(
+                cross_track_field_of_view=10,
+                along_track_field_of_view=10,
+                pitch_angle_profile=[(0, 10)],
+            ),
+            PointedInstrument(
+                cross_track_field_of_view=10,
+                along_track_field_of_view=10,
+                velocity_frame=VelocityFrame.INERTIAL,
+            ),
+        ]:
+            with self.assertRaises(ValidationError):
+                SurfacePlatform(
+                    name="Tower",
+                    latitude=0,
+                    longitude=0,
+                    height=30,
+                    instruments=[instrument],
+                )
+
+    def test_get_track(self):
+        """
+        Test that the track is at the instruments' Earth-fixed position, at
+        one or more times.
+        """
+        o = SurfacePlatform(
+            name="Balloon", latitude=33.45, longitude=-112.07, elevation=300, height=500
+        )
+        expected = wgs84.latlon(33.45, -112.07, 800).itrs_xyz.m
+        position, _ = o.get_track().frame_xyz_and_velocity(itrs)
+        np.testing.assert_allclose(position.m, expected, atol=1e-3)
+        times = [datetime(2020, 6, 1, hour, tzinfo=timezone.utc) for hour in (0, 12)]
+        track = o.get_track(times)
+        position, _ = track.frame_xyz_and_velocity(itrs)
+        np.testing.assert_allclose(
+            position.m, np.stack([expected] * 2, axis=1), atol=1e-3
+        )
+        track = o.get_track(times[0])
+        self.assertEqual(track.t.utc_datetime(), times[0])
+
+    def test_valid_observation(self):
+        """
+        Test that an instrument's sunlit requirement varies with time.
+        """
+        o = SurfacePlatform(
+            name="Tower",
+            latitude=0,
+            longitude=0,
+            height=30,
+            instruments=[Instrument(req_target_sunlit=True)],
+        )
+        times = [datetime(2020, 3, 20, hour, tzinfo=timezone.utc) for hour in (0, 12)]
+        valid = o.instruments[0].is_valid_observation(
+            o.get_track(times), wgs84.latlon(0, 0)
+        )
+        self.assertListEqual(list(valid), [False, True])
+
+    def test_compute_visible_region(self):
+        """
+        Test that the region visible from a platform at a target elevation
+        above it reaches the horizon of the ground without a terrain mask,
+        and only as far as the lines of sight clearing a terrain mask.
+        """
+        o = SurfacePlatform(
+            name="Tower", latitude=33.45, longitude=-112.07, elevation=300, height=30
+        )
+        geod = Geod(ellps="WGS84")
+
+        def distances(region):
+            lon, lat = np.array(region.exterior.coords).T
+            return geod.inv(
+                np.full(len(lon), o.longitude), np.full(len(lat), o.latitude), lon, lat
+            )
+
+        # lines of sight tangent to the ground, extended to 1 km above it
+        _, _, d = distances(o.compute_visible_region(1300))
+        horizon = np.sqrt(2 * 6371e3 * 30) + np.sqrt(2 * 6371e3 * 1000)
+        np.testing.assert_allclose(d, horizon, rtol=0.005)
+        # a 2 degree ridge to the west
+        o.terrain_mask = TerrainMask(
+            azimuth=[0, 240, 250, 290, 300], min_elevation_angle=[-1, -1, 2, 2, -1]
+        )
+        azimuth, _, d = distances(o.compute_visible_region(1300))
+        west = (azimuth % 360 >= 250) & (azimuth % 360 <= 290)
+        # lines of sight 2 degrees above horizontal rise 970 m (with the
+        # curvature drop) at the distance d: d tan(2) + d^2 / 2R = 970
+        slope, curvature = np.tan(np.radians(2)), 1 / (2 * 6371e3)
+        reach = (np.sqrt(slope**2 + 4 * curvature * 970) - slope) / (2 * curvature)
+        np.testing.assert_allclose(d[west], reach, rtol=0.005)
+        east = (azimuth > 0) & (azimuth < 180)
+        np.testing.assert_allclose(d[east], horizon, rtol=0.005)
+        with self.assertRaises(ValueError):
+            o.compute_visible_region(330)
diff --git a/tests/schemas/surface/test_radar.py b/tests/schemas/surface/test_radar.py
index ddbbb3b4..1b65ebdf 100644
--- a/tests/schemas/surface/test_radar.py
+++ b/tests/schemas/surface/test_radar.py
@@ -257,102 +257,6 @@ def test_compute_footprint_annulus_area_matches_ground_ranges(self):
         self.assertAlmostEqual(projected.area / expected_area, 1.0, delta=0.05)
 
 
-class TestTerrainMask(unittest.TestCase):
-    """
-    Unit tests for the TerrainMask schema.
-    """
-
-    def test_good_data(self):
-        """
-        Test that the TerrainMask schema correctly initializes with valid data.
-        """
-        mask = TerrainMask(
-            azimuth=[0, 90, 180, 270], min_elevation_angle=[0.5, 5, 0.5, 2]
-        )
-        self.assertEqual(mask.azimuth, [0, 90, 180, 270])
-        self.assertEqual(mask.min_elevation_angle, [0.5, 5, 0.5, 2])
-
-    def test_bad_mismatched_lengths(self):
-        """
-        Test that mismatched azimuth/min_elevation_angle lengths are rejected.
-        """
-        with self.assertRaises(ValidationError):
-            TerrainMask(azimuth=[0, 90, 180], min_elevation_angle=[0.5, 5])
-
-    def test_bad_azimuth_out_of_range(self):
-        """
-        Test that azimuth values outside [0, 360) are rejected.
-        """
-        with self.assertRaises(ValidationError):
-            TerrainMask(azimuth=[-1, 90], min_elevation_angle=[0.5, 5])
-        with self.assertRaises(ValidationError):
-            TerrainMask(azimuth=[0, 360], min_elevation_angle=[0.5, 5])
-
-    def test_bad_azimuth_not_increasing(self):
-        """
-        Test that non-strictly-increasing azimuth values are rejected.
-        """
-        with self.assertRaises(ValidationError):
-            TerrainMask(azimuth=[90, 0], min_elevation_angle=[0.5, 5])
-        with self.assertRaises(ValidationError):
-            TerrainMask(azimuth=[0, 0], min_elevation_angle=[0.5, 5])
-
-    def test_bad_too_few_samples(self):
-        """
-        Test that a single-sample mask is rejected (at least two required).
-        """
-        with self.assertRaises(ValidationError):
-            TerrainMask(azimuth=[0], min_elevation_angle=[0.5])
-
-    def test_get_min_elevation_angle_at_samples(self):
-        """
-        Test that the interpolated value exactly at a sample azimuth
-        matches that sample.
-        """
-        mask = TerrainMask(
-            azimuth=[0, 90, 180, 270], min_elevation_angle=[0.5, 5, 0.5, 2]
-        )
-        for azimuth, expected in zip([0, 90, 180, 270], [0.5, 5, 0.5, 2]):
-            self.assertAlmostEqual(
-                mask.get_min_elevation_angle(azimuth), expected, delta=1e-9
-            )
-
-    def test_get_min_elevation_angle_interpolates_between_samples(self):
-        """
-        Test that the interpolated value midway between two samples is the
-        linear average.
-        """
-        mask = TerrainMask(azimuth=[0, 90], min_elevation_angle=[0, 10])
-        self.assertAlmostEqual(mask.get_min_elevation_angle(45), 5, delta=1e-9)
-
-    def test_get_min_elevation_angle_wraps_around_zero(self):
-        """
-        Test that interpolation wraps around the 0/360 degree boundary
-        (e.g. between the last sample and the first).
-        """
-        mask = TerrainMask(azimuth=[0, 270], min_elevation_angle=[0, 10])
-        # halfway from 270 to 360 (0), wrapping, should be ~5
-        self.assertAlmostEqual(mask.get_min_elevation_angle(315), 5, delta=1e-9)
-
-    def test_get_min_elevation_angle_accepts_azimuth_outside_0_360(self):
-        """
-        Test that an azimuth outside [0, 360) is wrapped before lookup.
-        """
-        mask = TerrainMask(
-            azimuth=[0, 90, 180, 270], min_elevation_angle=[0.5, 5, 0.5, 2]
-        )
-        self.assertAlmostEqual(
-            mask.get_min_elevation_angle(90),
-            mask.get_min_elevation_angle(450),
-            delta=1e-9,
-        )
-        self.assertAlmostEqual(
-            mask.get_min_elevation_angle(0),
-            mask.get_min_elevation_angle(-360),
-            delta=1e-9,
-        )
-
-
 class TestRadarStationTerrainMask(unittest.TestCase):
     """
     Unit tests for RadarStation's terrain_mask-aware behavior.
diff --git a/tests/schemas/surface/test_terrain.py b/tests/schemas/surface/test_terrain.py
new file mode 100644
index 00000000..afebc172
--- /dev/null
+++ b/tests/schemas/surface/test_terrain.py
@@ -0,0 +1,111 @@
+"""
+Unit tests for the TerrainMask schema.
+
+@author Paul T. Grogan <paul.grogan@asu.edu>
+"""
+
+import unittest
+
+from pydantic import ValidationError
+
+from tatc.schemas import TerrainMask
+
+
+class TestTerrainMask(unittest.TestCase):
+    """
+    Unit tests for the TerrainMask schema.
+    """
+
+    def test_good_data(self):
+        """
+        Test that the TerrainMask schema correctly initializes with valid data.
+        """
+        mask = TerrainMask(
+            azimuth=[0, 90, 180, 270], min_elevation_angle=[0.5, 5, 0.5, 2]
+        )
+        self.assertEqual(mask.azimuth, [0, 90, 180, 270])
+        self.assertEqual(mask.min_elevation_angle, [0.5, 5, 0.5, 2])
+
+    def test_bad_mismatched_lengths(self):
+        """
+        Test that mismatched azimuth/min_elevation_angle lengths are rejected.
+        """
+        with self.assertRaises(ValidationError):
+            TerrainMask(azimuth=[0, 90, 180], min_elevation_angle=[0.5, 5])
+
+    def test_bad_azimuth_out_of_range(self):
+        """
+        Test that azimuth values outside [0, 360) are rejected.
+        """
+        with self.assertRaises(ValidationError):
+            TerrainMask(azimuth=[-1, 90], min_elevation_angle=[0.5, 5])
+        with self.assertRaises(ValidationError):
+            TerrainMask(azimuth=[0, 360], min_elevation_angle=[0.5, 5])
+
+    def test_bad_azimuth_not_increasing(self):
+        """
+        Test that non-strictly-increasing azimuth values are rejected.
+        """
+        with self.assertRaises(ValidationError):
+            TerrainMask(azimuth=[90, 0], min_elevation_angle=[0.5, 5])
+        with self.assertRaises(ValidationError):
+            TerrainMask(azimuth=[0, 0], min_elevation_angle=[0.5, 5])
+
+    def test_bad_too_few_samples(self):
+        """
+        Test that a single-sample mask is rejected (at least two required).
+        """
+        with self.assertRaises(ValidationError):
+            TerrainMask(azimuth=[0], min_elevation_angle=[0.5])
+
+    def test_get_min_elevation_angle_at_samples(self):
+        """
+        Test that the interpolated value exactly at a sample azimuth
+        matches that sample.
+        """
+        mask = TerrainMask(
+            azimuth=[0, 90, 180, 270], min_elevation_angle=[0.5, 5, 0.5, 2]
+        )
+        for azimuth, expected in zip([0, 90, 180, 270], [0.5, 5, 0.5, 2]):
+            self.assertAlmostEqual(
+                mask.get_min_elevation_angle(azimuth), expected, delta=1e-9
+            )
+
+    def test_get_min_elevation_angle_interpolates_between_samples(self):
+        """
+        Test that the interpolated value midway between two samples is the
+        linear average.
+        """
+        mask = TerrainMask(azimuth=[0, 90], min_elevation_angle=[0, 10])
+        self.assertAlmostEqual(mask.get_min_elevation_angle(45), 5, delta=1e-9)
+
+    def test_get_min_elevation_angle_wraps_around_zero(self):
+        """
+        Test that interpolation wraps around the 0/360 degree boundary
+        (e.g. between the last sample and the first).
+        """
+        mask = TerrainMask(azimuth=[0, 270], min_elevation_angle=[0, 10])
+        # halfway from 270 to 360 (0), wrapping, should be ~5
+        self.assertAlmostEqual(mask.get_min_elevation_angle(315), 5, delta=1e-9)
+
+    def test_get_min_elevation_angle_accepts_azimuth_outside_0_360(self):
+        """
+        Test that an azimuth outside [0, 360) is wrapped before lookup.
+        """
+        mask = TerrainMask(
+            azimuth=[0, 90, 180, 270], min_elevation_angle=[0.5, 5, 0.5, 2]
+        )
+        self.assertAlmostEqual(
+            mask.get_min_elevation_angle(90),
+            mask.get_min_elevation_angle(450),
+            delta=1e-9,
+        )
+        self.assertAlmostEqual(
+            mask.get_min_elevation_angle(0),
+            mask.get_min_elevation_angle(-360),
+            delta=1e-9,
+        )
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/tests/utils/test_projection.py b/tests/utils/test_projection.py
index ce702d94..1bdf37f3 100644
--- a/tests/utils/test_projection.py
+++ b/tests/utils/test_projection.py
@@ -9,7 +9,7 @@
 from datetime import datetime, timezone
 
 import numpy as np
-from pyproj import Transformer
+from pyproj import Geod, Transformer
 from shapely.geometry import Point
 from skyfield.api import EarthSatellite, wgs84
 from skyfield.framelib import itrs
@@ -32,6 +32,7 @@
     compute_cone_and_azimuth,
     compute_limb,
     compute_projected_ray_position,
+    compute_static_track,
     compute_view_angles,
     compute_view_tangents,
 )
@@ -1063,3 +1064,96 @@ def test_inverts_tilted_rotation(self):
                     ),
                     1,
                 )
+
+
+class TestComputeStaticTrack(unittest.TestCase):
+    """
+    Unit tests for compute_static_track.
+    """
+
+    def test_earth_fixed_position_and_heading(self):
+        """
+        Test that the track converts back to the Earth-fixed position and a
+        unit velocity toward the heading in the local horizontal plane.
+        """
+        track = compute_static_track(-112.07, 33.45, 800, heading=45)
+        position, velocity = track.frame_xyz_and_velocity(itrs)
+        expected = wgs84.latlon(33.45, -112.07, 800).itrs_xyz.m
+        np.testing.assert_allclose(position.m, expected, atol=1e-3)
+        lat, lon = np.radians(33.45), np.radians(-112.07)
+        east = [-np.sin(lon), np.cos(lon), 0]
+        north = [-np.sin(lat) * np.cos(lon), -np.sin(lat) * np.sin(lon), np.cos(lat)]
+        up = np.cross(east, north)
+        v = np.array(velocity.m_per_s)
+        self.assertAlmostEqual(np.linalg.norm(v), 1, delta=1e-9)
+        self.assertAlmostEqual(np.dot(v, up), 0, delta=1e-9)
+        self.assertAlmostEqual(
+            np.degrees(np.arctan2(np.dot(v, east), np.dot(v, north))), 45, delta=1e-6
+        )
+
+    def test_static_over_time(self):
+        """
+        Test that a vector of times gives the same Earth-fixed position at
+        each time, while the inertial position rotates with the Earth.
+        """
+        t = timescale.from_datetimes(
+            [datetime(2020, 1, 1, hour, tzinfo=timezone.utc) for hour in (0, 6, 12)]
+        )
+        track = compute_static_track(10, 45, 100, heading=90, t=t)
+        position, _ = track.frame_xyz_and_velocity(itrs)
+        self.assertEqual(np.shape(position.m), (3, 3))
+        np.testing.assert_allclose(
+            position.m, np.repeat(position.m[:, :1], 3, axis=1), atol=1e-3
+        )
+        self.assertGreater(
+            np.linalg.norm(track.position.m[:, 0] - track.position.m[:, 1]), 1e6
+        )
+
+    def test_default_time(self):
+        """
+        Test that the default time is 2020-01-01 00:00:00 UTC.
+        """
+        track = compute_static_track(0, 0, 100)
+        self.assertEqual(
+            track.t.utc_datetime(), datetime(2020, 1, 1, tzinfo=timezone.utc)
+        )
+
+    def test_view_orientation(self):
+        """
+        Test that a positive roll angle looks to the left of the heading and a
+        positive pitch angle looks toward the heading.
+        """
+        track = compute_static_track(-112.07, 33.45, 1000, heading=30)
+        geod = Geod(ellps="WGS84")
+        for roll, pitch, azimuth in [
+            (45, 0, 300),
+            (-45, 0, 120),
+            (0, 45, 30),
+            (0, -45, 210),
+        ]:
+            center = compute_projected_ray_position(track, 0, 0, roll, pitch)
+            forward, _, distance = geod.inv(
+                -112.07, 33.45, center.longitude.degrees, center.latitude.degrees
+            )
+            self.assertAlmostEqual(forward % 360, azimuth, delta=1e-4)
+            self.assertAlmostEqual(distance, 1000, delta=0.1)
+
+    def test_footprint_radius(self):
+        """
+        Test that a nadir cone projects to a circle of radius height times the
+        tangent of the half angle, and a hemisphere to the horizon.
+        """
+        geod = Geod(ellps="WGS84")
+        track = compute_static_track(-112.07, 33.45, 800)
+        for field_of_view, expected, delta in [
+            (60, 500 * np.tan(np.radians(30)), 0.1),
+            (180, np.sqrt(2 * constants.EARTH_MEAN_RADIUS * 500), 200),
+        ]:
+            footprint = compute_footprint(
+                track, field_of_view, field_of_view, elevation=300
+            )[0]
+            lon, lat, *_ = zip(*footprint.exterior.coords)
+            distances = geod.inv(
+                np.full(len(lon), -112.07), np.full(len(lat), 33.45), lon, lat
+            )[2]
+            np.testing.assert_allclose(distances, expected, atol=delta)
diff --git a/tests/utils/test_radar.py b/tests/utils/test_radar.py
index e2e46c55..4184bff1 100644
--- a/tests/utils/test_radar.py
+++ b/tests/utils/test_radar.py
@@ -248,6 +248,20 @@ def test_compute_terrain_elevation_angle_zero_distance(self):
             compute_terrain_elevation_angle(0, 100, 0), 90.0, delta=1e-6
         )
 
+    def test_compute_terrain_elevation_angle_refraction(self):
+        """
+        Test that, without refraction (an effective Earth radius factor of
+        1), the curvature drop is the geometric one, larger than with the
+        default (4/3) refraction.
+        """
+        straight = compute_terrain_elevation_angle(50000, 0, 0, 1)
+        self.assertAlmostEqual(
+            straight,
+            math.degrees(math.atan2(-(50000**2) / (2 * 6371008.8), 50000)),
+            delta=1e-3,
+        )
+        self.assertLess(straight, compute_terrain_elevation_angle(50000, 0, 0))
+
     def test_compute_terrain_elevation_angle_increases_with_height(self):
         """
         Test that, for a fixed ground distance, the elevation angle