terraingenpy 0.1.0.dev279__tar.gz → 0.1.0.dev283__tar.gz

{terraingenpy-0.1.0.dev279 → terraingenpy-0.1.0.dev283}/.github/workflows/ci.yml

@@ -451,6 +451,34 @@ jobs:
           path: dist
       - uses: pypa/gh-action-pypi-publish@dc37677b2e1c63e2034f94d8a5b11f265b73ba33 # v1.14.2
 
+  # The "latest" pre-release: main's packages and their checksums, replaced on every push to main.
+  # Marked as a pre-release and never as the latest release, so versioned releases stay the default.
+  latest:
+    needs: [lint, test, packages, package-test]
+    if: github.event_name == 'push' && github.ref == 'refs/heads/main'
+    runs-on: ubuntu-24.04
+    timeout-minutes: 10
+    permissions:
+      contents: write
+    steps:
+      - uses: actions/download-artifact@9000827ccba6bdab643e8b6fd33ac0654aef8333 # v8.0.2
+        with:
+          pattern: "packages-*"
+          merge-multiple: true
+          path: assets
+      - name: Flatten
+        run: find assets -mindepth 2 -type f -exec mv -t assets {} + && find assets -mindepth 1 -type d -empty -delete
+      - name: Checksums
+        run: cd assets && sha256sum -- * > SHA256SUMS
+      - name: Release
+        env:
+          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        run: |
+          gh release delete latest --repo "$GITHUB_REPOSITORY" --cleanup-tag --yes || true
+          gh release create latest assets/* --repo "$GITHUB_REPOSITORY" --target "$GITHUB_SHA" \
+            --prerelease --latest=false --title "Latest (main)" \
+            --notes "Built from main at $GITHUB_SHA. For versioned binaries, use a tagged release."
+
   # A GitHub release for each v* tag, with every wheel, the sdist, the packages and their checksums.
   release:
     needs: [lint, test, wheel, sdist, package-test, docker]

{terraingenpy-0.1.0.dev279 → terraingenpy-0.1.0.dev283}/CMakeLists.txt

@@ -8,7 +8,7 @@ endif()
 
 # The release being worked towards, such as 0.1.0, or for a development build a PEP 440 pre-release of
 # it, such as 0.1.0.dev42, which only the Python package carries.
-set(TERRAINGEN_FULL_VERSION "0.1.0.dev279")
+set(TERRAINGEN_FULL_VERSION "0.1.0.dev283")
 string(REGEX MATCH "^[0-9]+\\.[0-9]+\\.[0-9]+" TERRAINGEN_VERSION "${TERRAINGEN_FULL_VERSION}")
 
 project(

{terraingenpy-0.1.0.dev279 → terraingenpy-0.1.0.dev283}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: terraingenpy
-Version: 0.1.0.dev279
+Version: 0.1.0.dev283
 Summary: Scientific terrain generation for planetary surfaces
 Keywords: terrain,moon,mars,craters,planetary science,simulation
 Author: Alex Maietta
@@ -94,7 +94,7 @@ We also provide:
 
 For more information on the concepts behind TerrainGen and the API, see our latest [documentation](https://alexmaietta.github.io/terraingen/).
 
-## Getting Started
+## Quick Start
 
 We recommended getting started by installing `terraingenpy` from PyPi and running the GUI.
 
@@ -103,21 +103,117 @@ pip install terraingenpy
 terraingen --gui
 ```
 
+## Requirements
+
+- Linux (Ubuntu 22.04 or newer), macOS 14 or newer, or Windows 10 or newer, on x86_64 or arm64.
+- Python 3.10 or newer for the Python package.
+- Optional: a Vulkan, CUDA or Metal driver for GPU acceleration. Run `terraingen backends` to see what is available.
+
+## Installation
+
+### Releases
+
+Every [release](https://github.com/alexmaietta/terraingen/releases) has the CLI, library, headers and CMake package for each platform, and `.deb` packages for Ubuntu and Debian. The [latest](https://github.com/alexmaietta/terraingen/releases/tag/latest) pre-release is built from `main` on every push.
+
+### Building from Source
+
+You need CMake 3.22 or newer and a C++20 compiler (GCC 11, Clang 14, Apple Clang 15 or MSVC 2022). CMake fetches everything else.
+
+```sh
+cmake -S . -B build -DCMAKE_BUILD_TYPE=Release
+cmake --build build -j 8
+cmake --install build --prefix /usr/local
+```
+
+To build the Python package from source, run `pip install .` instead.
+
+### Docker
+
+```sh
+docker run --rm ghcr.io/alexmaietta/terraingen:latest terraingen --help
+```
+
+The `dev` tag follows `main`.
+
+## Getting Started
+
 ### Python
 
+```python
+import terraingen
+
+# A flat 513 x 513 grid with 2 m pixels
+ground = terraingen.FlatSource(513, 513, 2.0)
+
+# Fractal noise 40 m high with an 800 m wavelength
+fractal = terraingen.FractalParams(seed=1, wavelength=800.0, amplitude=40.0)
+noise = terraingen.NoiseLayer(fractal)
+relief = terraingen.NoiseRelief([noise])
+
+terrain = terraingen.Terrain(ground, [relief])
+heights = terraingen.evaluate(terrain)
+terraingen.write_geotiff("terrain.tif", heights)
+```
+
 ### C++
 
+```cmake
+find_package(terraingen REQUIRED)
+target_link_libraries(app PRIVATE terraingen::terraingen)
+```
+
+```cpp
+#include <terraingen/terraingen.h>
+
+int main() {
+    // Fractal noise 40 m high with an 800 m wavelength
+    terraingen::NoiseLayer noise;
+    noise.fractal.seed = 1;
+    noise.fractal.wavelength = 800.0f;
+    noise.fractal.amplitude = 40.0f;
+
+    terraingen::SyntheticTerrainParams relief;
+    relief.layers = {noise};
+
+    // A flat 513 x 513 grid with 2 m pixels, plus the noise
+    terraingen::Terrain terrain;
+    terrain.source = std::make_shared<terraingen::FlatSource>(513, 513, 2.0);
+    terrain.layers.push_back(std::make_shared<terraingen::NoiseRelief>(relief));
+
+    terraingen::Raster<float> heights = terraingen::Evaluate(terrain);
+    terraingen::WriteGeoTiff("terrain.tif", heights);
+}
+```
+
 ### Examples
 
-## Installation
+[examples/](examples/) has the same terrains as JSON configurations, C++ programs and Python scripts, covering basic terrains, craters, boulders, albedo, planets, DEM detail and tiles:
+
+```sh
+terraingen examples/config/craters/example_craters_simple.json
+```
+
+### Demos
 
+[demos/](demos/) has larger showcases, such as terrain over a whole asteroid built from the Itokawa shape model.
 
 ## Contributing
 
+Contributions are welcome. See [CONTRIBUTING.md](CONTRIBUTING.md) for how to build, test and submit changes.
+
 ### Documentation
 
+The [documentation](https://alexmaietta.github.io/terraingen/) is built with MkDocs and Doxygen from [docs/](docs/). Run `make -C docs build` to build it locally.
+
 ### Code Coverage
 
+The [coverage report](https://alexmaietta.github.io/terraingen/coverage/) is updated on every push to `main`. To generate it locally:
+
+```sh
+cmake -S . -B build-coverage -DTERRAINGEN_COVERAGE=ON -DCMAKE_BUILD_TYPE=Debug
+cmake --build build-coverage -j 8 --target coverage
+```
+
 ## Citation
 
 If you use TerrainGen for published research, please cite:
@@ -147,5 +243,5 @@ TerrainGen draws inspiration from existing lunar terrain generation tools:
 | --- | --- | --- | --- | --- |
 | [synthterrain](https://github.com/NeoGeographyToolkit/synthterrain) | NASA Ames | Open source (Apache-2.0) | Crater and boulder populations from size-frequency distributions, crater profiles and DEMs on flat terrain | Doesn't generate surface detail or upscale existing DEMs, not actively contributed to. |
 | [lunasynth](https://github.com/nasa-jpl/lunasynth) | NASA JPL | Open source (Apache-2.0) | Adds craters and boulders to a lunar base DEM, down to 1 cm pixels, and renders images under varying camera and sun positions | Project is not actively-maintained |
-| [DLES Terrain Crafting](https://doi.org/10.1109/AERO63441.2025.11068736) | NASA JSC | Not publicly released (paper) | Enhances LOLA and NAC-derived DEMs of the lunar south pole to 20 cm with synthetic craters and boulders, including hand-placed craters from imagery | Not publicly released, |
-| [PANGU](https://pangu.software/) | University of Dundee / STAR-Dundee | Commercial | Multi-resolution planet and asteroid surfaces from real or fractal DEMs with statistical craters and boulders; GPU camera, LiDAR and thermal sensor simulation | Commercial software |
+| [DLES Terrain Crafting](https://doi.org/10.1109/AERO63441.2025.11068736) | NASA JSC | Not publicly released (paper) | Enhances LOLA and NAC-derived DEMs of the lunar south pole to 20 cm with synthetic craters and boulders, including hand-placed craters from imagery | Not publicly released, relies on manual crater counting, stamps craters from four template shapes, leaves blending rings around craters and smooth interpolated ground between them, and doesn't produce albedo maps. |
+| [PANGU](https://pangu.software/) | University of Dundee / STAR-Dundee | Commercial (free for ESA projects) | Multi-resolution planet and asteroid surfaces from real or fractal DEMs with statistical craters and boulders; GPU camera, LiDAR and thermal sensor simulation | Requires a paid license outside ESA projects, and ships as standalone command-line tools and GUIs rather than a library to integrate into a project. |

{terraingenpy-0.1.0.dev279 → terraingenpy-0.1.0.dev283}/README.md

@@ -38,7 +38,7 @@ We also provide:
 
 For more information on the concepts behind TerrainGen and the API, see our latest [documentation](https://alexmaietta.github.io/terraingen/).
 
-## Getting Started
+## Quick Start
 
 We recommended getting started by installing `terraingenpy` from PyPi and running the GUI.
 
@@ -47,21 +47,117 @@ pip install terraingenpy
 terraingen --gui
 ```
 
+## Requirements
+
+- Linux (Ubuntu 22.04 or newer), macOS 14 or newer, or Windows 10 or newer, on x86_64 or arm64.
+- Python 3.10 or newer for the Python package.
+- Optional: a Vulkan, CUDA or Metal driver for GPU acceleration. Run `terraingen backends` to see what is available.
+
+## Installation
+
+### Releases
+
+Every [release](https://github.com/alexmaietta/terraingen/releases) has the CLI, library, headers and CMake package for each platform, and `.deb` packages for Ubuntu and Debian. The [latest](https://github.com/alexmaietta/terraingen/releases/tag/latest) pre-release is built from `main` on every push.
+
+### Building from Source
+
+You need CMake 3.22 or newer and a C++20 compiler (GCC 11, Clang 14, Apple Clang 15 or MSVC 2022). CMake fetches everything else.
+
+```sh
+cmake -S . -B build -DCMAKE_BUILD_TYPE=Release
+cmake --build build -j 8
+cmake --install build --prefix /usr/local
+```
+
+To build the Python package from source, run `pip install .` instead.
+
+### Docker
+
+```sh
+docker run --rm ghcr.io/alexmaietta/terraingen:latest terraingen --help
+```
+
+The `dev` tag follows `main`.
+
+## Getting Started
+
 ### Python
 
+```python
+import terraingen
+
+# A flat 513 x 513 grid with 2 m pixels
+ground = terraingen.FlatSource(513, 513, 2.0)
+
+# Fractal noise 40 m high with an 800 m wavelength
+fractal = terraingen.FractalParams(seed=1, wavelength=800.0, amplitude=40.0)
+noise = terraingen.NoiseLayer(fractal)
+relief = terraingen.NoiseRelief([noise])
+
+terrain = terraingen.Terrain(ground, [relief])
+heights = terraingen.evaluate(terrain)
+terraingen.write_geotiff("terrain.tif", heights)
+```
+
 ### C++
 
+```cmake
+find_package(terraingen REQUIRED)
+target_link_libraries(app PRIVATE terraingen::terraingen)
+```
+
+```cpp
+#include <terraingen/terraingen.h>
+
+int main() {
+    // Fractal noise 40 m high with an 800 m wavelength
+    terraingen::NoiseLayer noise;
+    noise.fractal.seed = 1;
+    noise.fractal.wavelength = 800.0f;
+    noise.fractal.amplitude = 40.0f;
+
+    terraingen::SyntheticTerrainParams relief;
+    relief.layers = {noise};
+
+    // A flat 513 x 513 grid with 2 m pixels, plus the noise
+    terraingen::Terrain terrain;
+    terrain.source = std::make_shared<terraingen::FlatSource>(513, 513, 2.0);
+    terrain.layers.push_back(std::make_shared<terraingen::NoiseRelief>(relief));
+
+    terraingen::Raster<float> heights = terraingen::Evaluate(terrain);
+    terraingen::WriteGeoTiff("terrain.tif", heights);
+}
+```
+
 ### Examples
 
-## Installation
+[examples/](examples/) has the same terrains as JSON configurations, C++ programs and Python scripts, covering basic terrains, craters, boulders, albedo, planets, DEM detail and tiles:
+
+```sh
+terraingen examples/config/craters/example_craters_simple.json
+```
+
+### Demos
 
+[demos/](demos/) has larger showcases, such as terrain over a whole asteroid built from the Itokawa shape model.
 
 ## Contributing
 
+Contributions are welcome. See [CONTRIBUTING.md](CONTRIBUTING.md) for how to build, test and submit changes.
+
 ### Documentation
 
+The [documentation](https://alexmaietta.github.io/terraingen/) is built with MkDocs and Doxygen from [docs/](docs/). Run `make -C docs build` to build it locally.
+
 ### Code Coverage
 
+The [coverage report](https://alexmaietta.github.io/terraingen/coverage/) is updated on every push to `main`. To generate it locally:
+
+```sh
+cmake -S . -B build-coverage -DTERRAINGEN_COVERAGE=ON -DCMAKE_BUILD_TYPE=Debug
+cmake --build build-coverage -j 8 --target coverage
+```
+
 ## Citation
 
 If you use TerrainGen for published research, please cite:
@@ -91,5 +187,5 @@ TerrainGen draws inspiration from existing lunar terrain generation tools:
 | --- | --- | --- | --- | --- |
 | [synthterrain](https://github.com/NeoGeographyToolkit/synthterrain) | NASA Ames | Open source (Apache-2.0) | Crater and boulder populations from size-frequency distributions, crater profiles and DEMs on flat terrain | Doesn't generate surface detail or upscale existing DEMs, not actively contributed to. |
 | [lunasynth](https://github.com/nasa-jpl/lunasynth) | NASA JPL | Open source (Apache-2.0) | Adds craters and boulders to a lunar base DEM, down to 1 cm pixels, and renders images under varying camera and sun positions | Project is not actively-maintained |
-| [DLES Terrain Crafting](https://doi.org/10.1109/AERO63441.2025.11068736) | NASA JSC | Not publicly released (paper) | Enhances LOLA and NAC-derived DEMs of the lunar south pole to 20 cm with synthetic craters and boulders, including hand-placed craters from imagery | Not publicly released, |
-| [PANGU](https://pangu.software/) | University of Dundee / STAR-Dundee | Commercial | Multi-resolution planet and asteroid surfaces from real or fractal DEMs with statistical craters and boulders; GPU camera, LiDAR and thermal sensor simulation | Commercial software |
+| [DLES Terrain Crafting](https://doi.org/10.1109/AERO63441.2025.11068736) | NASA JSC | Not publicly released (paper) | Enhances LOLA and NAC-derived DEMs of the lunar south pole to 20 cm with synthetic craters and boulders, including hand-placed craters from imagery | Not publicly released, relies on manual crater counting, stamps craters from four template shapes, leaves blending rings around craters and smooth interpolated ground between them, and doesn't produce albedo maps. |
+| [PANGU](https://pangu.software/) | University of Dundee / STAR-Dundee | Commercial (free for ESA projects) | Multi-resolution planet and asteroid surfaces from real or fractal DEMs with statistical craters and boulders; GPU camera, LiDAR and thermal sensor simulation | Requires a paid license outside ESA projects, and ships as standalone command-line tools and GUIs rather than a library to integrate into a project. |

{terraingenpy-0.1.0.dev279 → terraingenpy-0.1.0.dev283}/terraingen/layers/craters/generation/population.cpp

@@ -163,11 +163,12 @@ class Generation {
         CraterList craters;
         craters.Reserve(static_cast<std::size_t>(expected));
         for (const BandPlan& entry : plan) {
+            const BandRegion region = BandRegionOf(entry.band);
             for (const CellIndex& cell : entry.cells) {
                 const std::shared_ptr<const CraterList> drawn = DrawCell(entry.band, cell);
                 for (std::size_t n = 0; n < drawn->Size(); ++n) {
                     const Crater crater = drawn->At(n);
-                    if (InRegion(crater, CandidateMargin(crater.diameter))) {
+                    if (InBandRegion(region, crater)) {
                         craters.Append(crater);
                     }
                 }
@@ -176,6 +177,33 @@ class Generation {
         return craters;
     }
 
+    /// The region expanded by the candidate margins of a band's smallest and largest craters,
+    /// which bound every margin in between since `Expand` and `CandidateMargin` only grow.
+    struct BandRegion {
+        CraterBand band;
+        Bounds2d inner;
+        Bounds2d outer;
+    };
+
+    BandRegion BandRegionOf(const CraterBand& band) const {
+        return {band, surface_.Expand(region_, CandidateMargin(band.low)),
+                surface_.Expand(region_, CandidateMargin(band.high))};
+    }
+
+    /// `InRegion` with the crater's candidate margin, expanding the region only for craters of the
+    /// band between its inner and outer regions.
+    bool InBandRegion(const BandRegion& region, const Crater& crater) const {
+        if (!(crater.diameter >= region.band.low && crater.diameter <= region.band.high)) {
+            return InRegion(crater, CandidateMargin(crater.diameter));
+        }
+        const Vec2d centre{crater.x, crater.y};
+        if (!surface_.Contains(region.outer, centre)) {
+            return false;
+        }
+        return surface_.Contains(region.inner, centre) ||
+               InRegion(crater, CandidateMargin(crater.diameter));
+    }
+
     std::shared_ptr<const CraterList> DrawCell(const CraterBand& band,
                                                const CellIndex& cell) const {
         if (options_.cellCraters) {

{terraingenpy-0.1.0.dev279 → terraingenpy-0.1.0.dev283}/terraingen/util/cube_sphere_cells.cpp

@@ -164,7 +164,43 @@ std::vector<CellIndex> CubeSphereCells::CellsCovering(const Bounds2d& region,
         cells.insert(cells.end(), around.begin(), around.end());
     }
     SortUnique(cells);
-    return cells;
+    // A ring cell reaches the region only if its centre lies within its farthest corner's angle of
+    // it, since cell edges are great circles; one expansion by the largest such angle tests them.
+    const std::int32_t n = CellsPerEdge(cellSize);
+    std::vector<CellIndex> ring;
+    std::vector<Vec2d> centres;
+    double widest = 0.0;
+    for (const CellIndex& cell : cells) {
+        if (std::binary_search(seeds.begin(), seeds.end(), cell)) {
+            continue;
+        }
+        const auto [a1, a2, b1, b2] = Bounds(cell, cellSize);
+        const detail::CubeFace& face = detail::kCubeFaces[static_cast<std::size_t>(cell.i / n)];
+        const Vec3d centre =
+            Normalized(detail::CubeFacePoint(face, 0.5 * (a1 + a2), 0.5 * (b1 + b2)));
+        double nearest = 1.0;
+        for (const double a : {a1, a2}) {
+            for (const double b : {b1, b2}) {
+                nearest =
+                    std::min(nearest, Dot(centre, Normalized(detail::CubeFacePoint(face, a, b))));
+            }
+        }
+        widest = std::max(widest, std::acos(std::clamp(nearest, -1.0, 1.0)));
+        ring.push_back(cell);
+        centres.push_back(sphere.PointOf(centre));
+    }
+    if (ring.empty()) {
+        return cells;
+    }
+    const Bounds2d reach = sphere.Expand(box, radius_ * (widest * (1.0 + 1e-9) + 1e-12));
+    std::vector<CellIndex> kept = seeds;
+    for (std::size_t k = 0; k < ring.size(); ++k) {
+        if (sphere.Contains(reach, centres[k])) {
+            kept.push_back(ring[k]);
+        }
+    }
+    SortUnique(kept);
+    return kept;
 }
 
 double CubeSphereCells::CellArea(const CellIndex& cell, double cellSize) const {

{terraingenpy-0.1.0.dev279 → terraingenpy-0.1.0.dev283}/tests/unit/layers/craters/generation/population_test.cpp

@@ -445,6 +445,26 @@ TEST(GenerateCraters, CellCraterSourcesGiveTheSameCraters) {
     }
 }
 
+TEST(GenerateCraters, CellCraterSourcesOutsideTheirBandKeepCratersWithinTheirOwnMargin) {
+    const terraingen::PowerLawSfd density(0.05, 2.0);
+    const terraingen::UniformAges ages(1.0);
+    const terraingen::Bounds2d region{-50.0, -50.0, 50.0, 50.0};
+    terraingen::CraterGenerationOptions options{.dMin = 3.0, .dMax = 60.0, .marginRadii = 1.5};
+    int calls = 0;
+    options.cellCraters = [&](const terraingen::CraterBand&, const terraingen::CellIndex&) {
+        ++calls;
+        terraingen::CraterList craters;
+        craters.Append({region.maxX + 140.0, 0.0, 200.0, 0.5, 1u});
+        craters.Append({region.maxX + 160.0, 0.0, 200.0, 0.5, 2u});
+        return std::make_shared<const terraingen::CraterList>(craters);
+    };
+    const auto craters =
+        terraingen::GenerateCraters(terraingen::PlanarCells(), region, density, ages, 5u, options);
+    EXPECT_GT(calls, 0);
+    EXPECT_EQ(std::count(craters.Ids().begin(), craters.Ids().end(), 1u), calls);
+    EXPECT_EQ(std::count(craters.Ids().begin(), craters.Ids().end(), 2u), 0);
+}
+
 TEST(GenerateCraters, SkippingUnresolvedBandsKeepsEveryResolvedCrater) {
     const terraingen::PowerLawSfd density(0.05, 2.0);
     const terraingen::UniformAges ages(1.0);

{terraingenpy-0.1.0.dev279 → terraingenpy-0.1.0.dev283}/tests/unit/util/surface_test.cpp

@@ -225,6 +225,42 @@ TEST(CubeSphereCells, CoveringFindsEveryCellReachingTheRegion) {
     EXPECT_THROW(cells.CellsCovering({0.0, 0.0, NAN, 1.0}, size), std::invalid_argument);
 }
 
+TEST(CubeSphereCells, CoveringKeepsCellsAtTheRegionEdgesAndDropsFarRingCells) {
+    const CubeSphereCells cells(kMoon);
+    const double size = 40000.0;
+    const double corner = std::atan(1.0 / std::sqrt(2.0)) * 180.0 / std::numbers::pi;
+    for (const Bounds2d& region :
+         {Bounds2d{44.6, 34.9, 45.4, 35.3}, Bounds2d{44.9, -0.3, 45.1, 0.3},
+          Bounds2d{44.8, corner - 0.2, 45.2, corner + 0.2}, Bounds2d{-0.4, 89.5, 0.4, 90.0},
+          Bounds2d{179.8, 10.0, 180.4, 10.5}, Bounds2d{-30.0, -20.0, -29.0, -19.0}}) {
+        const std::vector<CellIndex> covering = cells.CellsCovering(region, size);
+        RandomStream random(11, 12);
+        for (int k = 0; k < 4000; ++k) {
+            const double t = random.NextDouble();
+            const double lon = region.minX + (region.maxX - region.minX) * t;
+            const double lat = region.minY + (region.maxY - region.minY) * t;
+            for (const auto& [x, y] : {std::pair{lon, region.minY}, std::pair{lon, region.maxY},
+                                       std::pair{region.minX, lat}, std::pair{region.maxX, lat}}) {
+                const CellIndex c = cells.CellOf(x, y, size);
+                EXPECT_TRUE(std::binary_search(covering.begin(), covering.end(), c))
+                    << x << " " << y;
+            }
+        }
+    }
+
+    const CellIndex centre = cells.CellOf(10.0, 10.0, size);
+    const std::int32_t n = cells.CellsPerEdge(size);
+    const double step = std::numbers::pi / 2.0 / n;
+    const Vec3d direction = CubeSphereCells::Direction(
+        centre.i / n, -std::numbers::pi / 4.0 + (centre.i % n + 0.5) * step,
+        -std::numbers::pi / 4.0 + (centre.j + 0.5) * step);
+    const Vec2d point = Surface::Sphere(kMoon).PointOf(direction);
+    const std::vector<CellIndex> one =
+        cells.CellsCovering(terraingen::PointBounds(point.x, point.y), size);
+    ASSERT_EQ(one.size(), 1u);
+    EXPECT_EQ(one[0], centre);
+}
+
 TEST(CubeSphereCells, TwoRingsOfNeighboursHoldEveryPointWithinACellAcrossFacesAndCorners) {
     const CubeSphereCells cells(kMoon);
     const Surface moon = Surface::Sphere(kMoon);