terraingenpy 0.1.1.dev17__tar.gz → 0.1.1.dev23__tar.gz

{terraingenpy-0.1.1.dev17 → terraingenpy-0.1.1.dev23}/CHANGELOG.md

@@ -18,18 +18,24 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - Size slope maps that bend boulder sizes into a local power law, from an exponent or a mean diameter map.
 - Crater and boulder catalogs with a completeness limit, above which they stand in for generated features.
 - Configuration reference in the documentation, generated from the schema at build time, and machine-readable value ranges in the schema.
+- Rock albedo: boulders brighter than the regolith (Holt 1981; Marshal et al. 2023), and a speckle of the share of each sample covered by boulders too small to resolve, with the scatter of randomly placed rocks.
+- Slope albedo: steep ground kept immature by mass wasting, its optical maturity rising with slope beyond 20 degrees (Ikeda et al. 2022; Lucey et al. 2014).
 
 ### Changed
 
 - Density maps that count every feature take out the secondaries thrown from a layer's craters and the blocks thrown out around craters, and boulder patches and bedrock keep a map's mean, so nothing is counted twice.
 - Boulder models settle onto a stable face by default instead of balancing on an edge or corner.
 - Boulder generation logs under boulders rather than craters.
+- Crater and boulder generation summaries log at debug level; `terraingen` ends with one line counting the files written instead of listing each, and feature outputs log how long they took.
+- Generation logs each grid as it is evaluated, with the time of every layer, the albedo and the materials, and ends with each step's total and share.
+- Faster boulders: the ground beneath them is read in one batch, outputs over one region share the boulders placed for the first, models are placed in parallel, ejecta craters are found through a spatial index and shapes skip the roughness of fracture planes that cannot reach a vertex. The hero demo runs in about 10 s instead of 276 s.
 - Martin, Parkes and Dunstan is the default crater profile.
 
 ### Fixed
 
 - Freshness degradation never makes a crater deeper than fresh: basins shallower than the cutoff keep their fresh shape.
 - Small craters inside larger ones on sloping ground no longer stand as raised mounds: datums are fitted to the slope-shaped relief that is applied.
+- Crater layers over other layers read the ground beneath their slopes and datums in batches rather than point by point, and point batches are evaluated in spatial order: the hero demo went from 433 s to 11 s with the same output.
 
 ## [0.1.0] - 2026-10-18
 

{terraingenpy-0.1.1.dev17 → terraingenpy-0.1.1.dev23}/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.1.dev17")
+set(TERRAINGEN_FULL_VERSION "0.1.1.dev23")
 string(REGEX MATCH "^[0-9]+\\.[0-9]+\\.[0-9]+" TERRAINGEN_VERSION "${TERRAINGEN_FULL_VERSION}")
 
 project(

{terraingenpy-0.1.1.dev17 → terraingenpy-0.1.1.dev23}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: terraingenpy
-Version: 0.1.1.dev17
+Version: 0.1.1.dev23
 Summary: Scientific terrain generation for planetary surfaces
 Keywords: terrain,moon,mars,craters,planetary science,simulation
 Author: Alex Maietta
@@ -64,7 +64,9 @@ Description-Content-Type: text/markdown
 
 # TerrainGen
 
-![]()
+![Blue Moon MK1 SN101 lander at Connecting Ridge, with Mons Malapert in the background](docs/images/hero_mk1_sn101_connecting_ridge.jpg)
+
+*Blue Moon MK1 SN101 lander at Connecting Ridge near the lunar south pole, with Mons Malapert in the background. Terrain upscaled by TerrainGen from LOLA elevation models.*
 
 A high-performance scientific terrain generation tool for interplanetary bodies.
 

{terraingenpy-0.1.1.dev17 → terraingenpy-0.1.1.dev23}/README.md

@@ -8,7 +8,9 @@
 
 # TerrainGen
 
-![]()
+![Blue Moon MK1 SN101 lander at Connecting Ridge, with Mons Malapert in the background](docs/images/hero_mk1_sn101_connecting_ridge.jpg)
+
+*Blue Moon MK1 SN101 lander at Connecting Ridge near the lunar south pole, with Mons Malapert in the background. Terrain upscaled by TerrainGen from LOLA elevation models.*
 
 A high-performance scientific terrain generation tool for interplanetary bodies.
 

terraingenpy-0.1.1.dev23/assets/textures/README.md

@@ -0,0 +1,14 @@
+# Textures
+
+Tileable detail textures for terrain and rock materials, stored in Git LFS.
+
+| Files | Source | License |
+| --- | --- | --- |
+| `moon_01_diff_4k.jpg`, `moon_01_nor_gl_4k.exr`, `moon_01_rough_4k.exr`, `moon_01_disp_4k.png` | Poly Haven, "Moon 01" by Greg Zaal, Rico Cilliers and Jenelle van Heerden (photography) and Dario Barresi (processing), <https://polyhaven.com/a/moon_01> | CC0 1.0 |
+| `seaside_rock_diff_2k.png`, `seaside_rock_nor_gl_2k.exr`, `seaside_rock_nor_dx_2k.exr`, `seaside_rock_rough_2k.exr`, `seaside_rock_ao_2k.png`, `seaside_rock_arm_2k.png`, `seaside_rock_disp_2k.png` | Poly Haven, "Seaside Rock", <https://polyhaven.com/a/seaside_rock> | CC0 1.0 |
+The moon_01 scan covers about 3.1 m of lunar regolith per tile: diffuse colour (sRGB), OpenGL
+normal map, roughness and displacement, at 4096 x 4096.
+
+The seaside rock maps are 2048 x 2048 (diffuse sRGB; OpenGL and DirectX normal maps; roughness,
+ambient occlusion, packed AO/roughness/metal and displacement). The lunar_regolith maps are
+8192 x 8192 (diffuse sRGB, OpenGL normal map, roughness, 16-bit ambient occlusion).

terraingenpy-0.1.1.dev23/assets/textures/seaside_rock_ao_2k.png

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:f907a0905707a4eeeeedd2c22e98ac616df42a3cd9851057abd72182fe443e31
+size 7393858

terraingenpy-0.1.1.dev23/assets/textures/seaside_rock_arm_2k.png

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:995985a315fade7b3a6e201419ba98d18316732246acfed2536327e52618ef71
+size 16682666

terraingenpy-0.1.1.dev23/assets/textures/seaside_rock_diff_2k.png

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:2263535252e356c57f47861e16c45c0875eb83c6d5ba95180f551b681a561f0d
+size 22995458

terraingenpy-0.1.1.dev23/assets/textures/seaside_rock_disp_2k.png

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:c80a1449d2e32d29bab0730f5369fc355825f20873e37ffe16e3357ad606e648
+size 6170255

terraingenpy-0.1.1.dev23/assets/textures/seaside_rock_nor_dx_2k.exr

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:b7beaf1c752a80dbd5861843f5ae3d6e3c816e9b2225ab4881b5a4da008b6ff8
+size 9124350

terraingenpy-0.1.1.dev23/assets/textures/seaside_rock_nor_gl_2k.exr

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:112b3b036cbca6098083754f626485e1fa0f2843782a4a6d8328b62b1b83ea13
+size 9109880

terraingenpy-0.1.1.dev23/assets/textures/seaside_rock_rough_2k.exr

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:543c1863afe8702c8c51f05f453309e3ae0c8f827269e0b8f05bb0f2a1a06ff1
+size 1585214

terraingenpy-0.1.1.dev23/examples/config/albedo/example_albedo_rocks_and_slopes.json

@@ -0,0 +1,76 @@
+{
+    "schema_version": 1,
+    "layers": [
+        {
+            "type": "noise",
+            "stack": [
+                {
+                    "seed": 1,
+                    "wavelength": 200,
+                    "amplitude": 2.0,
+                    "octaves": 6
+                }
+            ]
+        },
+        {
+            "type": "craters",
+            "seed": 3,
+            "density": {
+                "type": "trask"
+            },
+            "ages": {
+                "type": "fresh"
+            },
+            "min_diameter": 2,
+            "max_diameter": 40
+        },
+        {
+            "type": "boulders",
+            "seed": 5,
+            "coverage": 0.01,
+            "min_diameter": 0.05,
+            "max_diameter": 1.5,
+            "ejecta": {
+                "min_crater_diameter": 10,
+                "coverage": 0.05,
+                "reach": 3
+            }
+        }
+    ],
+    "outputs": [
+        {
+            "type": "heightmap",
+            "path": "example_albedo_rocks_and_slopes_heights.tif",
+            "region": {
+                "width": 401,
+                "height": 401,
+                "pixel_size": 0.25
+            }
+        },
+        {
+            "type": "albedo",
+            "path": "example_albedo_rocks_and_slopes_albedo.tif",
+            "region": {
+                "width": 401,
+                "height": 401,
+                "pixel_size": 0.25
+            }
+        }
+    ],
+    "albedo": {
+        "source": {
+            "type": "synthetic",
+            "value": 0.12
+        },
+        "layers": [
+            {
+                "type": "slopes",
+                "baseline": 2
+            },
+            {
+                "type": "rocks",
+                "seed": 7
+            }
+        ]
+    }
+}

{terraingenpy-0.1.1.dev17 → terraingenpy-0.1.1.dev23}/terraingen/albedo/CMakeLists.txt

@@ -6,6 +6,8 @@ terraingen_add_library(
     crater_albedo.cpp
     maturity.cpp
     raster_albedo.cpp
+    rock_albedo.cpp
+    slope_albedo.cpp
     splotches.cpp
     synthetic.cpp
     PUBLIC

{terraingenpy-0.1.1.dev17 → terraingenpy-0.1.1.dev23}/terraingen/albedo/albedo.cpp

@@ -1,6 +1,7 @@
 #include "terraingen/albedo/albedo.h"
 
 #include "terraingen/util/checks.h"
+#include "terraingen/util/log.h"
 #include "terraingen/util/parallel.h"
 
 #include <algorithm>
@@ -110,8 +111,11 @@ std::vector<Raster<float>> EvaluateAlbedo(const Albedo& albedo, const RasterGrid
         bands.push_back(std::move(raster));
     }
     albedo.source->Fill(bands, context);
-    for (const auto& layer : albedo.layers) {
-        layer->Apply(bands, context);
+    for (std::size_t n = 0; n < albedo.layers.size(); ++n) {
+        const Stopwatch stopwatch;
+        albedo.layers[n]->Apply(bands, context);
+        LogDebug("albedo", "Applied albedo layer ", n + 1, " in ",
+                 FormatDuration(stopwatch.Milliseconds()));
     }
     return bands;
 }

terraingenpy-0.1.1.dev23/terraingen/albedo/rock_albedo.cpp

@@ -0,0 +1,134 @@
+#include "terraingen/albedo/rock_albedo.h"
+
+#include "terraingen/random/philox.h"
+#include "terraingen/random/value_distribution.h"
+#include "terraingen/util/parallel.h"
+
+#include <algorithm>
+#include <bit>
+#include <cmath>
+#include <stdexcept>
+#include <utility>
+
+namespace terraingen {
+
+namespace {
+
+constexpr std::uint32_t kRockStream = 0x524F434Bu;
+
+/// Multiplies every band of `value` by 1 + `share` (`ratio` - 1); NaN stays NaN.
+void Brighten(AlbedoSample& value, std::size_t bands, double share, double ratio) {
+    if (share == 0.0) {
+        return;
+    }
+    const double factor = 1.0 + share * (ratio - 1.0);
+    for (std::size_t band = 0; band < bands; ++band) {
+        if (!std::isnan(value[band])) {
+            value[band] = static_cast<float>(factor * static_cast<double>(value[band]));
+        }
+    }
+}
+
+}  // namespace
+
+void ValidateRockAlbedo(const RockAlbedoOptions& options) {
+    if (!(options.reflectanceRatio > 0.0 && std::isfinite(options.reflectanceRatio))) {
+        throw std::invalid_argument("Rock reflectance ratio must be positive and finite");
+    }
+}
+
+double RockShare(double resolved, const UnresolvedCover& unresolved, double normal) {
+    double drawn = 0.0;
+    if (unresolved.mean > 0.0) {
+        const double s2 = std::log1p(unresolved.variance / (unresolved.mean * unresolved.mean));
+        drawn =
+            std::fmin(1.0, std::exp(std::log(unresolved.mean) - 0.5 * s2 + std::sqrt(s2) * normal));
+    }
+    const double kept = std::clamp(resolved, 0.0, 1.0);
+    return kept + (1.0 - kept) * drawn;
+}
+
+RockAlbedo::RockAlbedo(RockAlbedoOptions options, std::vector<RockSource> sources)
+    : options_(options), sources_(std::move(sources)) {
+    ValidateRockAlbedo(options_);
+    for (const RockSource& source : sources_) {
+        if (!source.layer || !source.ground) {
+            throw std::invalid_argument(
+                "A rock albedo source needs a boulder layer and its ground");
+        }
+    }
+}
+
+double RockAlbedo::Draw(double x, double y, std::size_t source) const {
+    const auto xs = std::bit_cast<std::uint64_t>(x);
+    const auto ys = std::bit_cast<std::uint64_t>(y);
+    const U32x4 bits =
+        Philox4x32({static_cast<std::uint32_t>(xs), static_cast<std::uint32_t>(xs >> 32),
+                    static_cast<std::uint32_t>(ys), static_cast<std::uint32_t>(ys >> 32)},
+                   {options_.seed ^ kRockStream, static_cast<std::uint32_t>(source)});
+    return StandardNormal(std::ldexp(static_cast<double>(bits.x), -32),
+                          std::ldexp(static_cast<double>(bits.y), -32));
+}
+
+double RockAlbedo::ShareAt(double x, double y, const AlbedoContext& context) const {
+    ValidateAlbedoContext(context);
+    double bare = 1.0;
+    for (std::size_t n = 0; n < sources_.size(); ++n) {
+        const RockSource& source = sources_[n];
+        const double resolved =
+            source.layer->MaterialCoverAt(x, y, context.spacing, source.ground.get());
+        const UnresolvedCover unresolved =
+            options_.unresolved
+                ? source.layer->UnresolvedCoverAt(x, y, context.spacing, source.ground.get())
+                : UnresolvedCover{};
+        bare *= 1.0 - RockShare(resolved, unresolved, options_.unresolved ? Draw(x, y, n) : 0.0);
+    }
+    return 1.0 - bare;
+}
+
+void RockAlbedo::ApplyAt(AlbedoSample& value, std::size_t bands, double x, double y,
+                         const AlbedoContext& context) const {
+    Brighten(value, bands, ShareAt(x, y, context), options_.reflectanceRatio);
+}
+
+void RockAlbedo::Apply(std::vector<Raster<float>>& bands, const AlbedoContext& context) const {
+    ValidateAlbedoContext(context);
+    if (bands.empty() || sources_.empty()) {
+        return;
+    }
+    const RasterGrid grid = RasterGrid::FromRaster(bands[0]);
+    std::vector<double> bare(grid.width * grid.height, 1.0);
+    for (std::size_t n = 0; n < sources_.size(); ++n) {
+        const RockSource& source = sources_[n];
+        const Raster<double> resolved = source.layer->MaterialCoverOver(
+            grid, context.spacing, source.ground.get(), context.threads);
+        const std::vector<UnresolvedCover> unresolved =
+            options_.unresolved ? source.layer->UnresolvedCoverOver(
+                                      grid, context.spacing, source.ground.get(), context.threads)
+                                : std::vector<UnresolvedCover>(bare.size());
+        ParallelFor(grid.height, context.threads, [&](std::size_t row) {
+            for (std::size_t col = 0; col < grid.width; ++col) {
+                const std::size_t cell = row * grid.width + col;
+                const Vec2d centre = bands[0].CellCenter(col, row);
+                bare[cell] *=
+                    1.0 - RockShare(resolved(col, row), unresolved[cell],
+                                    options_.unresolved ? Draw(centre.x, centre.y, n) : 0.0);
+            }
+        });
+    }
+    ParallelFor(grid.height, context.threads, [&](std::size_t row) {
+        for (std::size_t col = 0; col < grid.width; ++col) {
+            AlbedoSample value{};
+            for (std::size_t band = 0; band < bands.size(); ++band) {
+                value[band] = bands[band](col, row);
+            }
+            Brighten(value, bands.size(), 1.0 - bare[row * grid.width + col],
+                     options_.reflectanceRatio);
+            for (std::size_t band = 0; band < bands.size(); ++band) {
+                bands[band](col, row) = value[band];
+            }
+        }
+    });
+}
+
+}  // namespace terraingen

terraingenpy-0.1.1.dev23/terraingen/albedo/rock_albedo.h

@@ -0,0 +1,72 @@
+/// @file
+/// @brief Rock albedo: boulders and the rocks too small to resolve, brighter than the regolith.
+#pragma once
+
+#include "terraingen/albedo/albedo.h"
+#include "terraingen/layers/boulders/boulder_layer.h"
+
+#include <cstdint>
+#include <memory>
+#include <vector>
+
+namespace terraingen {
+
+/// How rocks brighten the albedo. Rock reflects more than mature regolith: Holt (1981) measured
+/// normal albedos of 18 to 51% for rocks at the Apollo 16 site against 14 to 15% for its most
+/// mature soils; Marshal et al. (2023) model rock about 2.5 times as reflective as regolith,
+/// within the near 3 times of Apollo 16 fragmental breccias (Clark et al. 2002), and earlier
+/// models took about 1.5 times. Boulders an albedo resolves brighten where their rock stands;
+/// smaller ones brighten each sample by the share of it they cover, drawn per sample about its
+/// expected share with the variance of Poisson-scattered rocks, which unresolved cobbles show as
+/// bright pixels (Marshal et al. 2023).
+struct RockAlbedoOptions {
+    std::uint32_t seed = 0;         ///< Seed of the per-sample draws of unresolved rock.
+    double reflectanceRatio = 2.5;  ///< Rock over regolith reflectance; positive.
+    bool unresolved = true;         ///< Whether rocks too small to resolve brighten samples.
+
+    bool operator==(const RockAlbedoOptions&) const = default;
+};
+
+/// Checks rock albedo options.
+/// @throws std::invalid_argument for a reflectance ratio that is not positive and finite.
+void ValidateRockAlbedo(const RockAlbedoOptions& options);
+
+/// A boulder layer whose rock brightens the albedo, and the ground beneath it.
+struct RockSource {
+    std::shared_ptr<const BoulderLayer> layer;
+    /// The ground the layer was applied to, read under its boulders; must not be null.
+    std::shared_ptr<const Ground> ground;
+};
+
+/// The share of a sample rock covers, from the share its resolved boulders cover and a draw
+/// `normal` (standard normal) of the share unresolved rock covers of the rest: log-normal with
+/// the mean and variance of `unresolved`, at most 1.
+double RockShare(double resolved, const UnresolvedCover& unresolved, double normal);
+
+/// The albedo brightened by the rock of boulder layers: each band times 1 + `share`
+/// (`reflectanceRatio` - 1), for the share of each sample rock covers over every layer.
+class RockAlbedo final : public AlbedoLayer {
+  public:
+    /// @throws std::invalid_argument for options invalid as `ValidateRockAlbedo`, or a source
+    /// without a layer or ground.
+    RockAlbedo(RockAlbedoOptions options, std::vector<RockSource> sources);
+
+    /// Brightens `value` by the rock at (`x`, `y`); NaN stays NaN.
+    void ApplyAt(AlbedoSample& value, std::size_t bands, double x, double y,
+                 const AlbedoContext& context) const override;
+
+    /// `ApplyAt` at every cell centre, the boulders found once per layer.
+    void Apply(std::vector<Raster<float>>& bands, const AlbedoContext& context) const override;
+
+    /// The share of the sample at (`x`, `y`) rock covers, over every layer.
+    double ShareAt(double x, double y, const AlbedoContext& context) const;
+
+  private:
+    /// The standard normal drawn for unresolved rock of source `source` at (`x`, `y`).
+    double Draw(double x, double y, std::size_t source) const;
+
+    RockAlbedoOptions options_;
+    std::vector<RockSource> sources_;
+};
+
+}  // namespace terraingen

terraingenpy-0.1.1.dev23/terraingen/albedo/slope_albedo.cpp

@@ -0,0 +1,167 @@
+#include "terraingen/albedo/slope_albedo.h"
+
+#include "terraingen/util/parallel.h"
+
+#include <cmath>
+#include <limits>
+#include <numbers>
+#include <stdexcept>
+#include <utility>
+
+namespace terraingen {
+
+struct SlopeAlbedo::Lattice {
+    double i0 = 0.0;  ///< Column of the first node, in steps from the origin.
+    double j0 = 0.0;  ///< Row of the first node.
+    std::size_t columns = 0;
+    std::size_t rows = 0;
+    std::vector<double> slopes;  ///< Degrees, row-major; 0 on the outer ring.
+
+    double At(std::size_t i, std::size_t j) const {
+        return slopes[j * columns + i];
+    }
+};
+
+void ValidateSlopeMaturity(const SlopeMaturityOptions& options) {
+    const SlopeMaturityOptions& o = options;
+    if (!(o.onsetDegrees >= 0.0 && o.onsetDegrees < 90.0)) {
+        throw std::invalid_argument("Slope maturity onset must be in [0, 90) degrees");
+    }
+    if (!(o.maturityPerDegree >= 0.0 && std::isfinite(o.maturityPerDegree))) {
+        throw std::invalid_argument("Slope maturity per degree must be finite and not negative");
+    }
+    if (!(o.backgroundMaturity > 0.0 && std::isfinite(o.maxMaturity) &&
+          o.maxMaturity >= o.backgroundMaturity)) {
+        throw std::invalid_argument(
+            "Slope background maturity must be positive and the cap finite and not below it");
+    }
+    if (!(o.baseline > 0.0 && std::isfinite(o.baseline))) {
+        throw std::invalid_argument("Slope baseline must be positive and finite");
+    }
+    if (!std::isfinite(o.originReflectance)) {
+        throw std::invalid_argument("Slope origin reflectance must be finite");
+    }
+}
+
+SlopeAlbedo::SlopeAlbedo(SlopeMaturityOptions options, Surface surface)
+    : options_(options), surface_(surface) {
+    ValidateSlopeMaturity(options_);
+    step_ = surface_.IsBody() ? options_.baseline / (surface_.Radius() * std::numbers::pi / 180.0)
+                              : options_.baseline;
+}
+
+double SlopeAlbedo::MaturityAt(double slopeDegrees) const {
+    const double excess =
+        options_.maturityPerDegree * std::fmax(0.0, slopeDegrees - options_.onsetDegrees);
+    return std::fmin(options_.backgroundMaturity + excess, options_.maxMaturity);
+}
+
+SlopeAlbedo::Lattice SlopeAlbedo::ReadLattice(const Bounds2d& region, const Ground& ground) const {
+    Lattice lattice;
+    lattice.i0 = std::floor(region.minX / step_) - 1.0;
+    lattice.j0 = std::floor(region.minY / step_) - 1.0;
+    lattice.columns =
+        static_cast<std::size_t>(std::floor(region.maxX / step_) + 2.0 - lattice.i0) + 1;
+    lattice.rows = static_cast<std::size_t>(std::floor(region.maxY / step_) + 2.0 - lattice.j0) + 1;
+    const auto node = [&](std::size_t i, std::size_t j) {
+        return Vec2d{(lattice.i0 + static_cast<double>(i)) * step_,
+                     (lattice.j0 + static_cast<double>(j)) * step_};
+    };
+    std::vector<Vec2d> points;
+    points.reserve(lattice.columns * lattice.rows);
+    for (std::size_t j = 0; j < lattice.rows; ++j) {
+        for (std::size_t i = 0; i < lattice.columns; ++i) {
+            points.push_back(node(i, j));
+        }
+    }
+    std::vector<float> heights(points.size());
+    ground.HeightsAt(points, heights, options_.baseline);
+    lattice.slopes.assign(points.size(), 0.0);
+    for (std::size_t j = 1; j + 1 < lattice.rows; ++j) {
+        for (std::size_t i = 1; i + 1 < lattice.columns; ++i) {
+            const auto z = [&](std::size_t a, std::size_t b) {
+                return static_cast<double>(heights[b * lattice.columns + a]);
+            };
+            const double dx =
+                (z(i + 1, j) - z(i - 1, j)) / surface_.Distance(node(i - 1, j), node(i + 1, j));
+            const double dy =
+                (z(i, j + 1) - z(i, j - 1)) / surface_.Distance(node(i, j - 1), node(i, j + 1));
+            const double slope = std::atan(std::hypot(dx, dy)) * 180.0 / std::numbers::pi;
+            lattice.slopes[j * lattice.columns + i] = std::isnan(slope) ? 0.0 : slope;
+        }
+    }
+    return lattice;
+}
+
+double SlopeAlbedo::Interpolate(const Lattice& lattice, double x, double y) const {
+    const double u = x / step_;
+    const double v = y / step_;
+    const double fu = std::floor(u);
+    const double fv = std::floor(v);
+    const auto i = static_cast<std::size_t>(fu - lattice.i0);
+    const auto j = static_cast<std::size_t>(fv - lattice.j0);
+    const double tu = u - fu;
+    const double tv = v - fv;
+    return (1.0 - tv) * ((1.0 - tu) * lattice.At(i, j) + tu * lattice.At(i + 1, j)) +
+           tv * ((1.0 - tu) * lattice.At(i, j + 1) + tu * lattice.At(i + 1, j + 1));
+}
+
+double SlopeAlbedo::SlopeAt(double x, double y, const Ground& ground) const {
+    return Interpolate(ReadLattice({x, y, x, y}, ground), x, y);
+}
+
+void SlopeAlbedo::Mature(AlbedoSample& value, std::size_t bands, double slopeDegrees) const {
+    const double maturity = MaturityAt(slopeDegrees);
+    if (maturity == options_.backgroundMaturity) {
+        return;
+    }
+    for (std::size_t band = 0; band < bands; ++band) {
+        if (!std::isnan(value[band])) {
+            value[band] = static_cast<float>(ReflectanceAtMaturity(
+                value[band], options_.backgroundMaturity, maturity, options_.originReflectance));
+        }
+    }
+}
+
+void SlopeAlbedo::ApplyAt(AlbedoSample& value, std::size_t bands, double x, double y,
+                          const AlbedoContext& context) const {
+    ValidateAlbedoContext(context);
+    if (context.ground != nullptr) {
+        Mature(value, bands, SlopeAt(x, y, *context.ground));
+    }
+}
+
+void SlopeAlbedo::Apply(std::vector<Raster<float>>& bands, const AlbedoContext& context) const {
+    ValidateAlbedoContext(context);
+    if (context.ground == nullptr || bands.empty()) {
+        return;
+    }
+    const RasterGrid grid = RasterGrid::FromRaster(bands[0]);
+    Bounds2d centres{
+        std::numeric_limits<double>::infinity(), std::numeric_limits<double>::infinity(),
+        -std::numeric_limits<double>::infinity(), -std::numeric_limits<double>::infinity()};
+    for (const auto& [col, row] : {std::pair<std::size_t, std::size_t>{0, 0},
+                                   {grid.width - 1, 0},
+                                   {0, grid.height - 1},
+                                   {grid.width - 1, grid.height - 1}}) {
+        const Vec2d c = bands[0].CellCenter(col, row);
+        centres = {std::fmin(centres.minX, c.x), std::fmin(centres.minY, c.y),
+                   std::fmax(centres.maxX, c.x), std::fmax(centres.maxY, c.y)};
+    }
+    const Lattice lattice = ReadLattice(centres, *context.ground);
+    ParallelFor(grid.height, context.threads, [&](std::size_t row) {
+        for (std::size_t col = 0; col < grid.width; ++col) {
+            const Vec2d centre = bands[0].CellCenter(col, row);
+            AlbedoSample value{};
+            for (std::size_t band = 0; band < bands.size(); ++band) {
+                value[band] = bands[band](col, row);
+            }
+            Mature(value, bands.size(), Interpolate(lattice, centre.x, centre.y));
+            for (std::size_t band = 0; band < bands.size(); ++band) {
+                bands[band](col, row) = value[band];
+            }
+        }
+    });
+}
+
+}  // namespace terraingen