# Measuring a Canyon from FPV Video

> A foam plane, an action camera and a flight log: structure from motion and multi-view stereo turn FPV footage of the Kojori canyon into a metric terrain model, GPS gives it scale, and a live 3D lab floods it between two dams to read the volume.

- Published: 2026-11-18
- URL: https://latentstate.dev/posts/canyon-volume-from-fpv-video/
- Topics: Computer Vision, Robotics
- Code: https://github.com/format37/fpv-photogrammetry
- Data: https://huggingface.co/datasets/format37/kojori-canyon-fpv
- Video: https://youtu.be/s8RxP2BK_d0

---

How much water would the canyon below Kojori hold if you dammed it? It is an idle question, but a
good excuse to walk the whole photogrammetry chain end to end: video → camera poses → dense surface →
metres → a number. Move the two dams and the water level:

> Interactive demo (needs a browser): https://latentstate.dev/posts/canyon-volume-from-fpv-video/

![3D model of the Kojori canyon flooded between two dams](https://latentstate.dev/_astro/fig-lab.Dzu62Tz3.jpg "fig 1 — the canyon model flooded between two dams; the live version needs JavaScript and WebGL")

The terrain is a 2 m height grid, the volume is a flood fill over that same grid, and both come from
5.7 minutes of ordinary FPV footage. The rest of this post is how; the code, the capture notes and a
standalone copy of this demo are in the [repository](https://github.com/format37/fpv-photogrammetry).

## The flight

- **Airframe**: ZOHD Altus, a 980 mm twin-motor V-tail foam wing.
- **Autopilot**: Matek H743 running ArduPlane 4.6. Automatic takeoff, then FBWA (stabilised manual) for
  the whole flight. Two u-blox M10 GPS receivers at 5 Hz, a barometer, and an EKF fusing them at 25 Hz.
- **Camera**: DJI O4 Pro, 4K, in the nose on a tilt mount, so it can be pointed down in flight. I used
  the tilt rarely on this flight, so it looks forward and slightly down almost all the time. Electronic
  stabilisation on, rolling shutter, no stabilising gimbal. It is an FPV camera, not a survey camera.
- **Place**: the canyon south-east of Kojori, Georgia; launch at 1123 m above sea level.
- **Numbers**: 27.4 minutes armed, 31 km flown, up to 663 m above the launch point, median ground
  speed 19.6 m/s.

Nothing about the flight was planned for mapping: no route of parallel lines, no camera looking
straight down (the way maps are shot), no ground control points with known coordinates.

The five passes the model is built from, uncut apart from the joins:

[▶ Kojori canyon: the five FPV passes used for the 3D reconstruction](https://youtu.be/s8RxP2BK_d0)

## Telemetry

ArduPilot writes a binary DataFlash log to the SD card. `pymavlink` reads it message by message; the
useful ones are `GPS` and `GPA` (fix and accuracy), `POS` (EKF position), `ATT` (attitude) and `ARM`.

Details worth noting before the parsing:

- **GPS.** The two receivers disagree by 1.1 m (median). The second one had more satellites
  (26–31), a reported horizontal accuracy of 0.14 m, and was the one the autopilot used.
- **Clock.** The flight controller's clock ran 0.104 % fast: 1.7 s over the flight. A straight
  line fitted from log time to GPS fix epochs removes that, with an 18 ms residual.
- **Sync with the video.** The camera starts recording at the ARM command, so video time and log time
  share a zero, up to a start-up lag. I left the lag as an unknown and solved for it later.

## From video to camera poses

**Keyframes.** A video has far too many near-identical frames. I keep a frame when the image has
shifted by 2.5 % of its width since the last kept one (measured with sparse optical flow), which gives
about one frame per second: 241 frames from five passes over the canyon, downscaled to 1920 px.

**[Structure from motion](https://en.wikipedia.org/wiki/Structure_from_motion)** (SfM; the [COLMAP](https://colmap.github.io/) software, incremental mode):

1. [SIFT](https://www.youtube.com/watch?v=4AvTMVD9ig0) features in every frame, matched between every pair of frames.
2. Each pair is verified geometrically: [RANSAC](https://www.youtube.com/watch?v=9D5rrtCC_E0) fits the [essential matrix](https://www.youtube.com/watch?v=auhpPoAqprk) and throws out matches that
   violate the epipolar constraint $x_2^\top E\, x_1 = 0$.
3. Start from one good pair, triangulate its points, then add frames one at a time. A new frame's pose
   comes from the 3D points it already sees ([PnP](https://en.wikipedia.org/wiki/Perspective-n-Point) inside RANSAC); new points are triangulated; repeat.
4. After every few frames, **[bundle adjustment](https://www.youtube.com/watch?v=lmj2Jk5tl60)** refines everything at once.

![Three steps of incremental SfM: the first pair of frames, the pose of a new frame, new points](https://latentstate.dev/_astro/fig-sfm.en-light.D8Je-QJf.png "fig 3 — item 3 of the list in parts, seen from above: the model grows one frame at a time")

<details>
<summary>How to match the same point in two different frames</summary>

Items 1 and 2 of the list above answer one question: which point of frame A and which point of frame B are the same place on the ground. Nobody looks for identical pixels: a pixel is one brightness number, and a frame has thousands like it. Instead, a few thousand distinctive points are found, and small neighbourhoods around them are compared. The algorithm is SIFT (scale-invariant feature transform). It has three steps, and a fourth, geometric one follows it.

All the demos below run on two real frames of this flight. They are 5 minutes and 134 metres apart: two different passes over the same ridge, with the camera rotated by 55° between them and the ground about 850 m away. For the demos the frames are reduced to 960 px and the lens distortion is removed.

<details>
<summary>Step 1. Detector: which points to pick</summary>

**What problem it solves.** A point from frame A will later have to be found in frame B, taken from another distance and at another angle. The detector looks at each frame on its own and knows nothing about the second one. So it has to pick places that it would pick again in any other picture of the same ground. That gives three requirements:

- the position of the point is unambiguous. Blobs and corners work (a house, a bush, a bend in a path). A flat surface does not (the neighbourhood looks the same everywhere), and neither does a straight edge: a window can slide along it and its content does not change;
- a size is found together with the position. The same house takes a different number of pixels from 300 m and from 900 m, and the point found in both frames has to be the same one;
- sensor and compression noise creates no points.

The detector only answers "where, and how large". What makes a point recognisable is step 2.

**A stack of blurs.** Take the frame and blur it with a Gaussian filter several times, each time more strongly. The blur strength $\sigma$ is measured in pixels: details smaller than $\sigma$ disappear, larger ones stay. Each level is $2^{1/3} \approx 1.26$ times stronger than the one before, so $\sigma$ doubles every three levels. The result is a stack of copies of one frame: the bottom one shows single houses, the top one only slopes.

**The difference of neighbouring levels.** From each level subtract the next one, pixel by pixel: $D_k = G_k - G_{k+1}$ (difference of Gaussians, DoG). What is left after the subtraction:

- details smaller than $\sigma_k$ are already erased in both levels. That removes fine noise;
- smooth changes of brightness (a cloud shadow, haze) are the same in both levels and cancel;
- what stays is what the first blur still kept and the second one already erased: blobs of about size $\sigma_k$.

A light blob on a dark background gives a positive difference, a dark one on a light background a negative one, and a flat area gives zero. There is one difference fewer than there are blurs, and they form a stack too: each layer answers for its own blob size.

> Interactive demo (needs a browser): https://latentstate.dev/posts/canyon-volume-from-fpv-video/

![Four blur levels of one crop of a frame on top, the differences of neighbouring levels below](https://latentstate.dev/_astro/fig-sift-stack.FI6djrRa.jpg "fig 4 — step 1: four of the thirteen blur levels (top) and the differences of neighbouring levels (bottom); the live version needs JavaScript")

Things to try:

- drag the slider through the whole stack. The first differences show single houses and tree crowns, the last ones only whole slopes;
- hover a light blob in the difference: the first number is larger than the second. On an even slope the two numbers are almost equal, and the difference is close to zero;
- look at the row plot. The thin line of the original brightness jitters with noise, the blurred ones run smoothly, and the difference moves away from zero only where there is a blob of the right size.

**One of 26.** Now look for extrema in the stack of differences. Every pixel of a layer is compared with 26 neighbours: eight around it in its own layer, nine in the layer below and nine in the layer above. That is a 3×3×3 cube without its centre. A pixel becomes a candidate if its value is larger than all 26 or smaller than all 26.

An extremum in $x$ and $y$ means the centre of a blob. An extremum across layers means that the blob's size matched the $\sigma$ of this layer best: in the neighbouring layers the response is weaker. So a point gets three numbers: $x$, $y$ and a size $\sigma$.

**Two filters.** There are more candidates than needed, and some of them do harm.

The first filter is a contrast threshold. An even sky or a uniform slope has extrema too, only they are made by noise. In another frame the noise is different, and such a point will not appear there. So a candidate is rejected if the absolute value of the difference at it is below a threshold. In COLMAP the threshold is 0.0067 for brightness from 0 to 1.

The second filter is an edge test. On the side of a road or the ridge of a roof the difference is large, and the contrast threshold lets such a point through. But it is pinned only across the line. Along the line every place looks the same, and in another frame the detector will put the point somewhere else on the same line: a match will be found, but its coordinate will be wrong. To tell a blob from an edge, the curvature of the difference layer is measured at the point in two directions. A blob has a large curvature in both: it is a hill. An edge has a large one across and almost none along: it is a ridge. A point is rejected if the ratio of curvatures $r$ is above 10. The curvatures themselves are not computed; the second differences of neighbouring pixels $D_{xx}$, $D_{yy}$, $D_{xy}$ are enough. A point is kept if

$$
\frac{(D_{xx} + D_{yy})^2}{D_{xx} D_{yy} - D_{xy}^2} < \frac{(r + 1)^2}{r} = 12.1 \quad \text{for } r = 10.
$$

The first filter removes points that will not repeat in another frame. The second removes points that will repeat in the wrong place.

> Interactive demo (needs a browser): https://latentstate.dev/posts/canyon-volume-from-fpv-video/

![A difference layer with its extrema marked: yellow kept, red on an edge, white below the threshold](https://latentstate.dev/_astro/fig-sift-extrema.9MtClhDJ.jpg "fig 5 — step 1: the extrema of one difference layer among their 26 neighbours. Yellow ones are kept, red ones lie on an edge, white ones are below the contrast threshold; the live version needs JavaScript")

Things to try:

- press "keypoint". The three grids hold 27 numbers; the central one is outlined in yellow and is larger (or smaller) than all the others. There are no red outlines;
- press "not an extremum". This is a pixel next to a keypoint: its value is almost the same, but the neighbour's is further from zero, and the neighbour is outlined in red;
- press "weak". There is an extremum, but its absolute value is below the threshold. Such points lie on even ground;
- press "on an edge". The magnified view shows a stripe, not a blob. In layers with no such points the button is inactive.

**What comes out.** The demo below puts everything together: the stack, the difference, the extrema and both filters on one crop of a frame.

> Interactive demo (needs a browser): https://latentstate.dev/posts/canyon-volume-from-fpv-video/

![A crop of a frame with keypoints: the circle radius is the size of the blob](https://latentstate.dev/_astro/fig-sift-detect._lptsWSU.jpg "fig 6 — step 1: keypoints on a crop of a frame, the circle radius is the size of the blob; the live version needs JavaScript")

Things to try:

- move $\sigma$: with a weak blur there are hundreds of points, single houses and trees. With a strong blur only a few remain, blobs tens of pixels across: a group of houses, a clearing;
- turn on "show points rejected as edges": the extrema that lie on a straight edge are marked in red. Natural terrain has few of them, about 5 % here;
- raise the contrast threshold: only the most prominent blobs remain.

The detector in all three demos is simplified: the frame is not downscaled, and a point's position is not refined to a fraction of a pixel. Real SIFT halves the frame after every doubling of $\sigma$ (this is called an octave), so that a large image is never blurred with a wide filter.

</details>

<details>
<summary>Step 2. Descriptor: writing a point's neighbourhood as numbers</summary>

A square window is taken around the point. Its side is proportional to the size found ($12\sigma$), and it is rotated to the dominant direction of the brightness gradient near the point. The window is split into 4×4 cells, and in each cell a histogram of gradient directions with 8 bins is computed. That gives 4·4·8 = 128 numbers. The vector is normalised.

Each decision buys robustness to one thing:

- window size from $\sigma$: distance to the object;
- window rotation: camera roll;
- gradients instead of brightness: lighting;
- normalisation: contrast;
- histograms over cells: a small shift and perspective distortion.

> Interactive demo (needs a browser): https://latentstate.dev/posts/canyon-volume-from-fpv-video/

![The same point in two frames: the windows before and after rotation and the 128 numbers of the two descriptors](https://latentstate.dev/_astro/fig-sift-describe.DPuJKMHa.jpg "fig 7 — step 2: one point in frames A and B. The windows sit at different angles; after rotation they are almost the same, and so are the 128 numbers; the live version needs JavaScript")

In frames A and B the window sits at a different angle and has a different size. After rotation both windows show almost the same picture, and the arrows in the cells (the histograms) and the bars below almost coincide.

</details>

<details>
<summary>Step 3. Matching</summary>

For every descriptor of frame A the nearest one in frame B is found. Nearness is the ordinary Euclidean distance between the vectors of 128 numbers. Two filters follow:

- **Ratio test** (Lowe's test). The distance to the best candidate must be clearly smaller than to the second best: $d_1 / d_2 < 0.8$. If two candidates are almost equally good, this is a repeating texture, and there is no way to choose between them.
- **Mutual check.** The point in B must choose the same point in A too.

> Interactive demo (needs a browser): https://latentstate.dev/posts/canyon-volume-from-fpv-video/

![Two frames one above the other, matched points joined by lines](https://latentstate.dev/_astro/fig-sift-match.bEOV4Hlw.jpg "fig 8 — step 3: matches after the ratio test and the mutual check; the live version needs JavaScript")

Move the threshold towards 1.0: there are several times more lines, and the new ones run in all directions. At 0.6 few matches remain, but almost all of them follow the common flow.

</details>

<details>
<summary>Step 4. Geometric verification</summary>

A descriptor knows nothing about where the point is in the frame, so after step 3 some matches are still wrong. The arrangement of points in the two frames is not the same: near points shift more than far ones (parallax), and the frame itself may be rotated. Something else is the same: all correct matches are explained by one camera motion. This is the epipolar constraint $x_2^\top F\, x_1 = 0$: for a point $x_1$ of the first frame the matrix $F$ gives a line in the second frame, and the match of that point must lie on it.

RANSAC finds the matrix:

1. Take a random sample of matches of the smallest sufficient size and compute the matrix from it.
2. Count how many of the other matches agree with it, that is, lie within a tolerance of their line.
3. Repeat many times and keep the matrix with the most agreeing matches. Reject the matches that disagree.

> Interactive demo (needs a browser): https://latentstate.dev/posts/canyon-volume-from-fpv-video/

![Two frames one above the other: agreeing matches in green, rejected ones in red](https://latentstate.dev/_astro/fig-sift-verify.ClmuITQk.jpg "fig 9 — step 4: matches that agree with one camera motion (green) and rejected ones (red); the live version needs JavaScript")

How many trials are needed? Let the share of correct matches be $w$ and the sample size $s$. A sample is entirely correct with probability $w^s$. For at least one sample to be so with probability $p$, it takes

$$
N = \frac{\log(1 - p)}{\log(1 - w^s)}
$$

trials. With $w = 0.78$, $s = 8$ and $p = 0.99$ that is 32 trials, and with $w = 0.5$ already 1177. Two conclusions follow: the ratio test comes before RANSAC because it raises $w$, and the sample should be as small as possible.

In the demo $F$ is the fundamental matrix, and a sample is 8 matches. It works directly in pixels and needs no camera calibration. The essential matrix $E$ from the list above is the same constraint for a camera with known calibration $K$: $E = K^\top F K$. It needs 5 matches (at $w = 0.5$ that is 146 trials instead of 1177), and it yields the camera rotation and the direction of its translation. For every pair of frames COLMAP estimates three models, $E$, $F$ and a homography $H$ (for a flat scene or a pure rotation), and keeps the one that explains the matches best.

</details>

<details>
<summary>In numbers for this flight</summary>

From the COLMAP database:

- 241 frames, a median of 8246 keypoints per frame, 1.8 million in total;
- every frame is compared with every other: 28 920 pairs of frames. This is how links between different passes over the same place are found;
- descriptor matches were found in 21 623 pairs of frames, 15 880 passed the geometric verification (55 %), with a median of 248 matches per pair;
- feature extraction took 8 seconds, matching all pairs under two minutes on an RTX 4090;
- the pair of frames from the demos has 1919 verified matches in the real run. The demos have about a hundred: the frames are half the size, with 1500 points per frame instead of ten thousand.

</details>

<details>
<summary>What comes from libraries and what is written by hand</summary>

In the pipeline steps 1–4 are two COLMAP commands:

```bash
colmap feature_extractor --database_path database.db --image_path images \
  --ImageReader.camera_model OPENCV --ImageReader.single_camera_per_folder 1 \
  --ImageReader.camera_params "$FOCAL,$FOCAL,960,540,0,0,0,0" \
  --SiftExtraction.use_gpu 1 --SiftExtraction.max_num_features 8192

colmap exhaustive_matcher --database_path database.db \
  --SiftMatching.use_gpu 1 --SiftMatching.guided_matching 1
```

What happens inside:

- **Detector and descriptor**: SiftGPU, on the graphics card. Descriptors are stored as RootSIFT: the vector is normalised by its sum and the square root of every number is taken. This makes matches more reliable.
- **Matching**: brute force over all pairs of descriptors on the graphics card. The ratio test threshold is 0.8, the mutual check is on.
- **Geometric verification**: LO-RANSAC, tolerance 4 px, at least 15 agreeing matches.
- **`guided_matching`**: once the geometry of a pair of frames is known, the search for matches is repeated, but only along the epipolar lines. This brings back matches that failed the ratio test. That is why there are more verified matches in total (9.0 million) than matches found by descriptors (6.6 million).

The same four steps in OpenCV take about fifteen lines. This is how the points and descriptors for the demos were computed:

```python
import cv2, numpy as np

sift = cv2.SIFT_create(nfeatures=1500, contrastThreshold=0.02)
kp_a, des_a = sift.detectAndCompute(gray_a, None)        # steps 1 and 2
kp_b, des_b = sift.detectAndCompute(gray_b, None)

bf = cv2.BFMatcher(cv2.NORM_L2)                          # step 3
two_best = bf.knnMatch(des_a, des_b, k=2)
back = bf.knnMatch(des_b, des_a, k=1)
good = [m for m, n in two_best
        if m.distance < 0.8 * n.distance                 # ratio test
        and back[m.trainIdx][0].trainIdx == m.queryIdx]  # mutual check

pa = np.float32([kp_a[m.queryIdx].pt for m in good])
pb = np.float32([kp_b[m.trainIdx].pt for m in good])
F, inliers = cv2.findFundamentalMat(pa, pb, cv2.FM_RANSAC, 1.5, 0.999)  # step 4
```

What is written by hand is everything around it:

- keyframe selection by optical flow: `select_keyframes.py`, with `goodFeaturesToTrack` and `calcOpticalFlowPyrLK` from OpenCV;
- `localize_pnp.py`: steps 3 and 4 for a new frame against a finished model. Nearest-neighbour search, the ratio test, then PnP inside RANSAC;
- the checks and everything after SfM: the mirrored-pass test, the GPS alignment, the height grid, the volume;
- the demos on this page: the detector, the nearest-neighbour search, the 8-point algorithm and RANSAC, in TypeScript with no libraries.

</details>

<details>
<summary>Where SIFT breaks</summary>

- the tilt of the surface relative to the camera changes by more than 30–40°: the window is distorted and the histograms stop matching. Rotation of the frame around the lens axis does no harm: the window rotates with it;
- repeating texture (windows, garden beds): the ratio test rejects such points;
- a surface with no texture (water, snow, sky) and glare: the detector has nothing to hold on to;
- motion blur.

On this flight the weak spots are tree crowns and deep shadow. The modern replacement is learned detectors and matchers: SuperPoint with LightGlue, LoFTR. The geometric verification after them is the same.

</details>

</details>

Bundle adjustment is the core of the method. It moves all camera poses $(R_i, t_i)$, the shared
intrinsics $K$ and distortion, and all 3D points $X_j$ to minimise the reprojection error:

$$
\min_{R_i,\,t_i,\,K,\,X_j}\ \sum_{i,j} \rho\!\left(\norm{\pi\!\left(K,\ R_i X_j + t_i\right) - x_{ij}}^2\right)
$$

Here $x_{ij}$ is where point $j$ was observed in frame $i$, $\pi$ projects through the lens model, and
$\rho$ is a robust loss (soft L1 in COLMAP's local adjustments), so a wrong match pulls with limited force instead of quadratic.
The solver is Levenberg–Marquardt in Ceres. It is fast only because of structure: each residual touches
one camera and one point, so the points can be eliminated first (the Schur complement), leaving a much
smaller system over cameras alone.

Result: all 241 frames in one model, 137 000 points, median reprojection error 0.75 px. The camera was
never calibrated on a chessboard; the focal length (800.6 px) and radial distortion ($k_1 = -0.114$)
came out of the bundle adjustment, and match what an earlier flight with the same camera gave.

## From poses to a surface

**Multi-view stereo.** For each frame, COLMAP's PatchMatch estimates a depth and a surface normal per
pixel by comparing a small patch against ten neighbouring frames (normalised cross-correlation).
Good guesses spread to neighbouring pixels and are randomly perturbed, which is far cheaper than
testing every depth. A second pass keeps only depths that neighbouring frames agree on.

**Fusion** merges the 241 depth maps into one cloud, keeping a point only when several views confirm
it: 8.0 million points. That took 89 minutes on an RTX 4090, most of the pipeline's time.

## Metres: tying the model to GPS

A camera-only reconstruction has no scale, no north and no up: it is correct up to a similarity
transform, seven unknowns. GPS removes them. Each keyframe has a time, so it has a GPS position;
SfM gives the same camera a position in model units. The closed-form Umeyama solution finds the scale
$s$, rotation $R$ and shift $t$ that best map one set onto the other:

$$
\min_{s,\,R,\,t}\ \sum_i \norm{s R\, c_i + t - g_i(\tau)}^2
$$

where $c_i$ are SfM camera centres, $g_i$ the GPS positions, and $\tau$ the video-to-log lag. I scan
$\tau$ and keep the best fit:

- lag **1.15 s** (the camera needs about a second to start recording after arm);
- scale **162.5 m** per model unit;
- residual **3.0 m rms** over 223 cameras. Fitted separately, each pass agrees to 0.7–1.5 m and all
  four give the same scale within 0.1 %.

The gap between 1 m and 3 m is drift between passes inside the SfM model. The proper fix is to put the
GPS positions into the bundle adjustment as extra residuals, not to align afterwards.

The plane flies at 20 m/s, so a 0.1 s timing error is a 2 m position error. That is why the clock
correction and the lag search were worth doing.

## The pass that was reconstructed as a mirror image

The GPS fit exposed a bug that reprojection error could not. One high pass (18 frames) sat a kilometre
above the real track after alignment. Its reprojection error was a normal 1.3 px.

A distant, almost flat scene has two valid solutions for the camera motion, mirror images of each
other. If a pass shares few points with the rest of the model, the mapper can pick the wrong one, and
its points, seen only by that pass, reproject perfectly. A simple test finds it: for a camera tilted
down, the bottom of the image must be closer than the top. In that pass the order was inverted in
18 frames of 18. I dropped it.

Low reprojection error says the model is consistent with itself. It does not say the model is right.
Independent data does: here GPS, and a coarse check against [SRTM](https://en.wikipedia.org/wiki/Shuttle_Radar_Topography_Mission) elevation along the track (the model
sits 9 m above it in the median, within SRTM's own error on this terrain).

## From a point cloud to a volume

1. **Height grid.** Rotate and scale the cloud into east/north/up metres, then take the median height
   of the points in each 2 m cell. 78 % of the modelled area has measurements; the gaps (deep shadow,
   featureless slopes) are interpolated and flagged.
2. **Axis.** The canyon floor line is the cheapest path across the grid when height above the local
   floor is the cost. Smoothed, it gives each dam its position and its direction: always square to the
   canyon.
3. **Volume.** Water is every cell below the level that is connected to the floor between the two
   dams: a flood fill, so a side valley on the far side of a ridge stays dry. Then
   $V = \sum_{\text{wet}} (h_\text{water} - z)\cdot 2^2\ \text{m}^3$.

If the water reaches the edge of the model, the lab says so instead of printing a number.

## How far to trust the number

- **Scale** is good to about 0.2 %, so about 0.6 % in volume.
- **Shape** is the larger error: 3 m of drift between passes, and a 2 m grid from footage with roughly
  0.5 m per pixel on the ground.
- **Trees.** This is a surface model. Where the floor is forested the "ground" is the canopy, and the
  true volume is slightly larger.
- **Holes.** The lab shows what share of the water sits over interpolated terrain. Keep it small.

For a real survey you would fly a grid with a downward camera, add ground control points or [RTK](https://en.wikipedia.org/wiki/Real-time_kinematic_positioning), and
put GPS into the bundle adjustment. For a foam plane on a weekend, a 1.5 million m³ reservoir measured
to a few per cent is a fair result.

## Where else this applies

A canyon reservoir is a toy question, but the same chain (poses, dense surface, metres, a difference of
surfaces) is everyday survey work:

- **Stockpiles.** How much sand, gravel or soil sits in a pile, measured every week.
- **Quarries and mines.** How much rock was extracted this month: two surveys, one subtraction.
- **Construction.** The as-built surface against the design model shows where to cut and where to fill.
- **Landslides and floods.** Before-and-after models give the volume of debris to clear.
- **Forestry.** Surface minus bare ground is a canopy height model: tree heights and timber volume.
- **Coasts and riverbanks.** How much ground was lost between two dates.
- **Places a drone cannot reach.** The same geometry from satellite images covers wide areas, closed
  zones and disaster sites.
- **Site walkthroughs.** 360° camera images placed into the drone model.

In each of them the 3D reconstruction is only half the job. The other half is the errors: finding their
sources and showing how much each one contributes to the final number. That is a separate and hard problem.
