terraingenpy 0.1.1.dev6__tar.gz → 0.1.1.dev17__tar.gz

terraingenpy-0.1.1.dev17/CHANGELOG.md

@@ -0,0 +1,53 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [Unreleased]
+
+### Added
+
+- Piecewise uniform size-frequency distributions: counts per diameter band, given absolutely or as shares of a total.
+- Radial wall marks on craters, ridges and grooves down the wall that are strongest where it is steepest.
+- Thomas cluster process for boulder clusters, with Poisson-scattered centres whose clusters add where they overlap.
+- Craters on slopes: floors offset downslope and rims and ejecta lowered upslope (Plescia et al. 2019), and faster wear toward a critical gradient (Roering et al. 1999).
+- Boulders limited to a maximum slope, optionally rolling down steeper ground to gather at its foot.
+- Density maps from GeoTIFFs or constants: a scale, a count in a diameter range, or an areal fraction such as rock abundance, which set crater and boulder densities point by point.
+- 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.
+
+### 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.
+- 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.
+
+## [0.1.0] - 2026-10-18
+
+Initial release.
+
+### Added
+
+- C++20 library with Python bindings (`terraingenpy` on PyPI) for generating terrain from scratch or adding detail to existing DEMs.
+- Craters and boulders from published size-frequency distributions, with crater ages, profiles, degradation, irregularity, secondaries and ejecta.
+- Procedural 3D boulder models, and small boulders baked into the heightmap.
+- Synthetic albedo with crater ejecta and rays that fade with age.
+- Geologic features: dunes and ripples, layered strata, fractured bedrock, ventifacts and sand pooled in lows or behind boulders.
+- Planes, spheres and ellipsoids, whole-body meshes, tiles and point queries.
+- Deterministic output for a seed on any grid, tile or thread count.
+- GPU acceleration on Vulkan, CUDA and Metal, detected at run time.
+- `terraingen` command-line interface driven by JSON configurations.
+- Examples in C++, Python and JSON.
+- Release archives for Linux, macOS and Windows, Debian packages, and a Docker image.
+
+[Unreleased]: https://github.com/alexmaietta/terraingen/compare/v0.1.0...HEAD
+[0.1.0]: https://github.com/alexmaietta/terraingen/releases/tag/v0.1.0

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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: terraingenpy
-Version: 0.1.1.dev6
+Version: 0.1.1.dev17
 Summary: Scientific terrain generation for planetary surfaces
 Keywords: terrain,moon,mars,craters,planetary science,simulation
 Author: Alex Maietta
@@ -60,7 +60,6 @@ Description-Content-Type: text/markdown
 [![coverage](https://img.shields.io/endpoint?url=https://alexmaietta.github.io/terraingen/coverage/badge.json)](https://alexmaietta.github.io/terraingen/coverage/)
 [![release](https://img.shields.io/github/v/release/alexmaietta/terraingen)](https://github.com/alexmaietta/terraingen/releases)
 [![pypi](https://img.shields.io/pypi/v/terraingenpy)](https://pypi.org/project/terraingenpy/)
-[![docs](https://img.shields.io/website?url=https%3A%2F%2Falexmaietta.github.io%2Fterraingen%2F&label=docs&up_message=latest&down_message=offline)](https://alexmaietta.github.io/terraingen/)
 [![license](https://img.shields.io/badge/license-BSD_3--Clause-blue)](LICENSE)
 
 # TerrainGen
@@ -78,7 +77,7 @@ TerrainGen can:
 - Produce synthetic albedo maps with crater ejecta and rays that fade with crater age.
 - Model complex geologic features such as complex and secondary craters, boulder ejecta fields, dunes and wind ripples, layered strata terraced into benches and cliffs, fractured bedrock pavement, wind-carved ventifacts, and sand pooled in lows or trailing behind boulders.
 - Be extended through base classes in C++ or Python with custom size-frequency distributions, crater ages, profiles and degradation, albedo, sources, and layers.
-- GPU-accelerated operations for generating noise, craters, boulders, albedo, and more.
+- Perform GPU-accelerated operations for generating noise, craters, boulders, albedo, and more.
 - Generate deterministic results for the same seed on any grid, tile or thread count.
 - Integrate into simulations and other external workflows.
 

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

@@ -4,7 +4,6 @@
 [![coverage](https://img.shields.io/endpoint?url=https://alexmaietta.github.io/terraingen/coverage/badge.json)](https://alexmaietta.github.io/terraingen/coverage/)
 [![release](https://img.shields.io/github/v/release/alexmaietta/terraingen)](https://github.com/alexmaietta/terraingen/releases)
 [![pypi](https://img.shields.io/pypi/v/terraingenpy)](https://pypi.org/project/terraingenpy/)
-[![docs](https://img.shields.io/website?url=https%3A%2F%2Falexmaietta.github.io%2Fterraingen%2F&label=docs&up_message=latest&down_message=offline)](https://alexmaietta.github.io/terraingen/)
 [![license](https://img.shields.io/badge/license-BSD_3--Clause-blue)](LICENSE)
 
 # TerrainGen
@@ -22,7 +21,7 @@ TerrainGen can:
 - Produce synthetic albedo maps with crater ejecta and rays that fade with crater age.
 - Model complex geologic features such as complex and secondary craters, boulder ejecta fields, dunes and wind ripples, layered strata terraced into benches and cliffs, fractured bedrock pavement, wind-carved ventifacts, and sand pooled in lows or trailing behind boulders.
 - Be extended through base classes in C++ or Python with custom size-frequency distributions, crater ages, profiles and degradation, albedo, sources, and layers.
-- GPU-accelerated operations for generating noise, craters, boulders, albedo, and more.
+- Perform GPU-accelerated operations for generating noise, craters, boulders, albedo, and more.
 - Generate deterministic results for the same seed on any grid, tile or thread count.
 - Integrate into simulations and other external workflows.
 

{terraingenpy-0.1.1.dev6 → terraingenpy-0.1.1.dev17}/docs/README.md

@@ -7,6 +7,9 @@ sudo apt install doxygen
 ```
 
 For the Python API, TerrainGen must be built with Python bindings, `-DTERRAINGEN_BUILD_PYTHON=ON`.
+The configuration reference is generated from the same build: `scripts/generate_schema.py` reads
+the library's configuration schema at build time and writes the pages under `reference/`, so
+nothing there is kept in the source tree.
 
 Install `mkdocs` and related dependencies.
 

terraingenpy-0.1.1.dev17/docs/scripts/generate_schema.py

@@ -0,0 +1,419 @@
+"""
+MkDocs hook that writes the configuration reference from the library's own schema.
+"""
+
+from __future__ import annotations
+
+import json
+import sys
+from collections import defaultdict
+from pathlib import Path
+
+from mkdocs.structure.files import File
+
+ROOT = Path(__file__).resolve().parents[2]
+REPO_BLOB = "https://github.com/alexmaietta/terraingen/blob/main/"
+
+# Titles and slugs of the choices, keyed by where they are first reached from the root.
+CHOICES = {
+    "body": ("Bodies", "body"),
+    "base": ("Base sources", "base"),
+    "layers": ("Layers", "layers"),
+    "layers[craters].density": ("Crater densities", "models/densities"),
+    "layers[craters].ages": ("Crater ages", "models/ages"),
+    "layers[craters].profile": ("Crater profiles", "models/profiles"),
+    "layers[craters].degradation": ("Crater degradation", "models/degradation"),
+    "layers[boulders].sizes": ("Boulder sizes", "models/boulder-sizes"),
+    "layers[region].shape": ("Region shapes", "models/region-shapes"),
+    "outputs": ("Outputs", "outputs"),
+    "albedo.source": ("Albedo sources", "albedo-sources"),
+    "albedo.layers": ("Albedo layers", "albedo-layers"),
+}
+
+# The order of the reference's sections in the navigation.
+SECTIONS = [
+    ("Bodies", ["body"]),
+    ("Base sources", ["base"]),
+    ("Layers", ["layers"]),
+    (
+        "Crater and boulder models",
+        [
+            "layers[craters].density",
+            "layers[craters].ages",
+            "layers[craters].profile",
+            "layers[craters].degradation",
+            "layers[boulders].sizes",
+            "layers[region].shape",
+        ],
+    ),
+    ("Albedo", ["albedo.source", "albedo.layers"]),
+    ("Outputs", ["outputs"]),
+]
+
+
+def load_schema():
+    """The schema and catalog from the built module."""
+    sys.path.insert(0, str(ROOT / "build" / "python"))
+    try:
+        import terraingen
+    except ImportError as error:
+        raise RuntimeError(
+            "The configuration reference needs TerrainGen built with Python in build/ "
+            "(cmake -S . -B build && cmake --build build)"
+        ) from error
+    return terraingen.config_schema(), terraingen.config_catalog()
+
+
+def unwrap(schema):
+    """The schema an optional or a list holds, and whether it was either."""
+    wrapped = []
+    while schema.get("kind") in ("optional", "array"):
+        wrapped.append(schema["kind"])
+        schema = schema["of"]
+    return schema, wrapped
+
+
+def compact(value, limit=40):
+    """A value as short JSON for a table cell."""
+    if isinstance(value, dict):
+        return f'`{{"type": "{value["type"]}", ...}}`' if "type" in value else "`{...}`"
+    if isinstance(value, list) and value:
+        return "`[...]`"
+    if isinstance(value, float) and value == int(value) and abs(value) < 1e15:
+        text = f"{value:.1f}"
+    else:
+        text = json.dumps(value)
+    if len(text) > limit:
+        text = text[: limit - 3] + "..."
+    return f"`{text}`"
+
+
+def cell(text):
+    """Text safe in a Markdown table cell."""
+    return text.replace("|", "\\|").replace("\n", " ")
+
+
+def number(value):
+    return f"{value:g}"
+
+
+def range_text(field):
+    """A field's range in interval notation, or empty."""
+    low = field.get("minimum")
+    high = field.get("maximum")
+    if low is None and high is None:
+        return ""
+    left = "(" if low is None or field.get("exclusive_minimum") else "["
+    right = ")" if high is None or field.get("exclusive_maximum") else "]"
+    return f"{left}{'-inf' if low is None else number(low)}, {'inf' if high is None else number(high)}{right}"
+
+
+class Reference:
+    """The pages of the configuration reference, built from one schema."""
+
+    def __init__(self, schema, catalog, examples):
+        self.schema = schema
+        self.catalog = catalog
+        self.definitions = schema["definitions"]
+        self.paths = {}  # choice id -> path first reached from the root
+        self.names = defaultdict(set)  # choice id -> the field names that refer to it
+        self.enums = {}  # tuple of choices -> (anchor, name, descriptions)
+        self.examples = examples
+        self.walk(schema["root"], "")
+
+    # Discovery ---------------------------------------------------------------------------------
+
+    def walk(self, obj, path):
+        for field in obj.get("fields", []):
+            self.visit(field["schema"], f"{path}.{field['name']}" if path else field["name"], field)
+
+    def visit(self, schema, path, field):
+        inner, _ = unwrap(schema)
+        kind = inner.get("kind")
+        if kind == "enum":
+            key = tuple(inner["choices"])
+            if key not in self.enums:
+                name = field["name"]
+                anchor = name.replace("_", "-")
+                taken = {a for a, _, _ in self.enums.values()}
+                suffix = 2
+                while anchor in taken:
+                    anchor = f"{name.replace('_', '-')}-{suffix}"
+                    suffix += 1
+                self.enums[key] = (anchor, name, inner.get("descriptions", []))
+            return
+        if kind != "ref":
+            return
+        ref = inner["ref"]
+        target = self.definitions[ref]
+        if target["kind"] == "choice":
+            self.names[ref].add(field["name"])
+            if ref in self.paths:
+                return
+            self.paths[ref] = path
+            for alternative in target["alternatives"]:
+                self.walk(alternative, f"{path}[{alternative['type']}]")
+        else:
+            self.walk(target, path)
+
+    def page_of(self, ref):
+        """The slug and title of a choice's page."""
+        path = self.paths[ref]
+        if path in CHOICES:
+            title, slug = CHOICES[path]
+            return slug, title
+        if path.endswith("].simple"):
+            return CHOICES["layers[craters].profile"][1], CHOICES["layers[craters].profile"][0]
+        name = path.rsplit(".", 1)[-1]
+        return f"models/{name.replace('_', '-')}", name.replace("_", " ").capitalize()
+
+    def ref_of(self, path):
+        return next(ref for ref, p in self.paths.items() if p == path)
+
+    # Rendering ---------------------------------------------------------------------------------
+
+    def link(self, here, slug, anchor=""):
+        """A relative link from page `here` to page `slug`."""
+        depth = here.count("/")
+        target = "../" * depth + slug + ".md"
+        return target + (f"#{anchor}" if anchor else "")
+
+    def type_text(self, schema, here):
+        inner, wrapped = unwrap(schema)
+        kind = inner.get("kind")
+        if kind == "ref":
+            target = self.definitions[inner["ref"]]
+            if target["kind"] == "choice":
+                slug, title = self.page_of(inner["ref"])
+                page = "layers/index" if slug == "layers" else slug
+                text = f"[{title.lower()}]({self.link(here, page)})"
+            else:
+                text = "object, below"
+        elif kind == "enum":
+            anchor, _, _ = self.enums[tuple(inner["choices"])]
+            values = ", ".join(f"`{c}`" for c in inner["choices"])
+            text = f"[one of]({self.link(here, 'enums', anchor)}) {values}"
+        elif kind == "integer" and inner.get("fixed"):
+            text = "integer, fixed"
+        else:
+            text = kind
+        for wrapper in reversed(wrapped):
+            text = f"list of {text}" if wrapper == "array" else f"{text}, optional"
+        return text
+
+    def nested(self, schema):
+        """The object definition a field holds, if any."""
+        inner, wrapped = unwrap(schema)
+        if inner.get("kind") == "ref":
+            target = self.definitions[inner["ref"]]
+            if target["kind"] == "object":
+                return target, "array" in wrapped
+        return None, False
+
+    def fields(self, fields, here, indent=""):
+        """The fields of an object: the plain ones in a table, then each group collapsed."""
+        lines = []
+        plain = [f for f in fields if self.nested(f["schema"])[0] is None]
+        groups = [f for f in fields if self.nested(f["schema"])[0] is not None]
+        if plain:
+            lines += [
+                f"{indent}| Key | Type | Default | Range | Unit | Description |",
+                f"{indent}| --- | --- | --- | --- | --- | --- |",
+            ]
+            for f in plain:
+                lines.append(
+                    f"{indent}| `{f['name']}` | {self.type_text(f['schema'], here)} | "
+                    f"{compact(f['default'])} | {range_text(f)} | {f['unit']} | "
+                    f"{cell(f['description'])} |"
+                )
+            lines.append("")
+        for f in groups:
+            target, listed = self.nested(f["schema"])
+            title = f"{f['name']}[]" if listed else f["name"]
+            lines.append(f'{indent}??? note "`{title}`: {f["description"].replace(chr(34), chr(39))}"')
+            lines.append("")
+            lines += self.fields(target["fields"], here, indent + "    ")
+        return lines
+
+    def used_in(self, names, type_name):
+        files = sorted({path for name in names for path in self.examples.get((name, type_name), [])})
+        if not files:
+            return []
+        links = ", ".join(f"[{Path(p).stem}]({REPO_BLOB}{p})" for p in files[:8])
+        more = f" and {len(files) - 8} more" if len(files) > 8 else ""
+        return [f"**Used in:** {links}{more}", ""]
+
+    def alternative(self, alternative, names, here, level="##"):
+        lines = [f"{level} `{alternative['type']}` {{#{alternative['type']}}}", ""]
+        lines += [alternative["description"], ""]
+        lines += self.fields(alternative["fields"], here)
+        lines += [
+            '??? example "Every key with its default"',
+            "",
+            "    ```json",
+            *("    " + line for line in json.dumps(alternative["default"], indent=4).splitlines()),
+            "    ```",
+            "",
+        ]
+        lines += self.used_in(names, alternative["type"])
+        return lines
+
+    def choice_page(self, ref):
+        slug, title = self.page_of(ref)
+        choice = self.definitions[ref]
+        names = self.names[ref]
+        keys = ", ".join(f"`{n}`" for n in sorted(names))
+        lines = [f"# {title}", "", f'Chosen by `"type"` in {keys}.', ""]
+        lines += ["| Type | What it is |", "| --- | --- |"]
+        for alternative in choice["alternatives"]:
+            first = alternative["description"].split(". ")[0].rstrip(".")
+            lines.append(f"| [`{alternative['type']}`](#{alternative['type']}) | {cell(first)}. |")
+        lines.append("")
+        for alternative in choice["alternatives"]:
+            lines += self.alternative(alternative, names, slug)
+        return slug, title, "\n".join(lines)
+
+    def layer_pages(self):
+        ref = self.ref_of("layers")
+        choice = self.definitions[ref]
+        names = self.names[ref]
+        index = ["# Layers", "", "Relief and features added to the base, applied in order.", ""]
+        index += ["| Type | What it is |", "| --- | --- |"]
+        pages = []
+        for alternative in choice["alternatives"]:
+            slug = f"layers/{alternative['type']}"
+            first = alternative["description"].split(". ")[0].rstrip(".")
+            index.append(f"| [`{alternative['type']}`]({alternative['type']}.md) | {cell(first)}. |")
+            body = self.alternative(alternative, names, slug, level="#")
+            pages.append((slug, alternative["type"], "\n".join(body)))
+        return ("layers/index", "Layers", "\n".join(index + [""])), pages
+
+    def overview(self):
+        lines = [
+            "# Configuration",
+            "",
+            "A configuration is a JSON file the `terraingen` command, `GenerateTerrain` and",
+            "`terraingen.load_config` read. This reference is generated from the same field lists",
+            "the parser reads, so it always matches the library; the [raw schema](schema.md) is",
+            "the same information as JSON, for editors and tools.",
+            "",
+            "Ranges are the values each field accepts on its own; validation also checks the rules",
+            "that tie fields together.",
+            "",
+            "## Top level",
+            "",
+        ]
+        lines += self.fields(self.schema["root"]["fields"], "index")
+        lines += ["## Sections", ""]
+        for _, paths in SECTIONS:
+            for path in paths:
+                title, slug = CHOICES[path]
+                target = "layers/index.md" if slug == "layers" else f"{slug}.md"
+                lines.append(f"- [{title}]({target})")
+        lines += ["- [Enumerations](enums.md)", "- [Raw schema](schema.md)", ""]
+        return "\n".join(lines)
+
+    def enum_page(self):
+        lines = ["# Enumerations", "", "The named values fields choose between.", ""]
+        for choices, (anchor, name, descriptions) in sorted(self.enums.items(), key=lambda item: item[1][0]):
+            lines += [f"## `{name}` {{#{anchor}}}", "", "| Value | Meaning |", "| --- | --- |"]
+            for value, description in zip(choices, descriptions or [""] * len(choices), strict=True):
+                lines.append(f"| `{value}` | {cell(description)} |")
+            lines.append("")
+        return "\n".join(lines)
+
+    def schema_page(self):
+        text = json.dumps(self.schema, indent=2)
+        return "\n".join(
+            [
+                "# Raw schema",
+                "",
+                "The structure of a configuration as JSON, from the same field lists the parser",
+                "reads: each object's fields with their descriptions, units, defaults and ranges,",
+                "and each choice's alternatives. `terraingen.config_schema()` returns it too.",
+                "",
+                "- [schema.json](schema.json): this document.",
+                "- [catalog.json](catalog.json): every type with its defaults, as",
+                "  `terraingen.config_catalog()` and `terraingen schema` give it.",
+                "",
+                '??? abstract "schema.json"',
+                "",
+                "    ```json",
+                *("    " + line for line in text.splitlines()),
+                "    ```",
+                "",
+            ]
+        )
+
+    def pages(self):
+        """Every page as (slug, title, markdown), in navigation order, and the navigation."""
+        pages = [("index", "Overview", self.overview())]
+        nav = [{"Overview": "reference/index.md"}]
+        for section, paths in SECTIONS:
+            entries = []
+            for path in paths:
+                if path == "layers":
+                    index, layers = self.layer_pages()
+                    pages.append(index)
+                    pages += layers
+                    entries.append("reference/layers/index.md")
+                    entries += [{title: f"reference/{slug}.md"} for slug, title, _ in layers]
+                    continue
+                slug, title, text = self.choice_page(self.ref_of(path))
+                pages.append((slug, title, text))
+                entries.append({title: f"reference/{slug}.md"})
+            nav.append({section: entries})
+        pages.append(("enums", "Enumerations", self.enum_page()))
+        pages.append(("schema", "Raw schema", self.schema_page()))
+        nav += [{"Enumerations": "reference/enums.md"}, {"Raw schema": "reference/schema.md"}]
+        return pages, nav
+
+
+def scan_examples():
+    """(key, type) -> the example configurations using that type under that key."""
+    found = defaultdict(set)
+
+    def walk(value, key, path):
+        if isinstance(value, dict):
+            if "type" in value and key:
+                found[(key, value["type"])].add(path)
+            for child_key, child in value.items():
+                walk(child, child_key, path)
+        elif isinstance(value, list):
+            for child in value:
+                walk(child, key, path)
+
+    for file in sorted((ROOT / "examples" / "config").rglob("*.json")):
+        walk(json.loads(file.read_text()), "", str(file.relative_to(ROOT)))
+    return found
+
+
+_STATE = {}
+
+
+def on_config(config):
+    schema, catalog = load_schema()
+    reference = Reference(schema, catalog, scan_examples())
+    pages, nav = reference.pages()
+    _STATE["pages"] = pages
+    _STATE["schema"] = schema
+    _STATE["catalog"] = catalog
+    entry = {"Configuration": nav}
+    position = next(
+        (i for i, item in enumerate(config.nav) if isinstance(item, dict) and "API" in item),
+        len(config.nav),
+    )
+    config.nav.insert(position, entry)
+    return config
+
+
+def on_files(files, config):
+    for slug, _, text in _STATE["pages"]:
+        files.append(File.generated(config, f"reference/{slug}.md", content=text + "\n"))
+    files.append(
+        File.generated(config, "reference/schema.json", content=json.dumps(_STATE["schema"], indent=2))
+    )
+    files.append(
+        File.generated(config, "reference/catalog.json", content=json.dumps(_STATE["catalog"], indent=2))
+    )
+    return files

terraingenpy-0.1.1.dev17/examples/config/boulders/example_boulders_max_slope.json

@@ -0,0 +1,44 @@
+{
+    "schema_version": 1,
+    "layers": [
+        {
+            "type": "noise",
+            "stack": [
+                {
+                    "seed": 1,
+                    "wavelength": 30,
+                    "amplitude": 6,
+                    "octaves": 4
+                }
+            ]
+        },
+        {
+            "type": "boulders",
+            "seed": 1,
+            "coverage": 0.06,
+            "min_diameter": 0.2,
+            "max_diameter": 3,
+            "max_slope": 0.35
+        }
+    ],
+    "outputs": [
+        {
+            "type": "heightmap",
+            "path": "example_boulders_max_slope.tif",
+            "region": {
+                "width": 401,
+                "height": 401,
+                "pixel_size": 0.1
+            }
+        },
+        {
+            "type": "boulder_list",
+            "path": "example_boulders_max_slope_boulders.csv",
+            "region": {
+                "width": 401,
+                "height": 401,
+                "pixel_size": 0.1
+            }
+        }
+    ]
+}

terraingenpy-0.1.1.dev17/examples/config/boulders/example_boulders_rock_abundance.json

@@ -0,0 +1,65 @@
+{
+    "schema_version": 1,
+    "layers": [
+        {
+            "type": "noise",
+            "stack": [
+                {
+                    "seed": 1,
+                    "wavelength": 40,
+                    "amplitude": 0.5,
+                    "octaves": 6
+                }
+            ]
+        },
+        {
+            "type": "boulders",
+            "seed": 1,
+            "coverage": 0.05,
+            "min_diameter": 0.2,
+            "max_diameter": 3,
+            "density_map": {
+                "field": {
+                    "value": 0.01
+                },
+                "measure": "areal_fraction",
+                "min_diameter": 1
+            },
+            "manual": [
+                {
+                    "x": 5,
+                    "y": -3,
+                    "diameter": 4.5
+                },
+                {
+                    "x": -8,
+                    "y": 10,
+                    "diameter": 3.2
+                }
+            ],
+            "completeness": {
+                "value": 3
+            }
+        }
+    ],
+    "outputs": [
+        {
+            "type": "heightmap",
+            "path": "example_boulders_rock_abundance.tif",
+            "region": {
+                "width": 401,
+                "height": 401,
+                "pixel_size": 0.1
+            }
+        },
+        {
+            "type": "boulder_list",
+            "path": "example_boulders_rock_abundance_boulders.csv",
+            "region": {
+                "width": 401,
+                "height": 401,
+                "pixel_size": 0.1
+            }
+        }
+    ]
+}