refined-quads 0.1.0__tar.gz

refined_quads-0.1.0/.gitattributes

@@ -0,0 +1,4 @@
+* text=auto eol=lf
+*.npz binary
+*.nc binary
+*.gpkg binary

refined_quads-0.1.0/.gitignore

@@ -0,0 +1,18 @@
+# Python
+__pycache__/
+*.py[cod]
+*.egg-info/
+.venv/
+build/
+dist/
+
+# Tool caches
+.pytest_cache/
+.ruff_cache/
+.mypy_cache/
+.benchmarks/
+.coverage
+htmlcov/
+
+# Local issue tracker and scratch work (see docs/agents/issue-tracker.md)
+.scratch/

refined_quads-0.1.0/.hypothesis/.gitignore

@@ -0,0 +1,9 @@
+# This .gitignore file was automatically created by Hypothesis. Hypothesis gitignores
+# .hypothesis by default, because we generally recommend that .hypothesis not be checked
+# into version control.
+#
+# If you *would* like to check .hypothesis into version control, you should delete this
+# file. Hypothesis will not re-create this .gitignore unless .hypothesis is deleted (and
+# if it does, that's a bug - please report it!)
+
+*

refined_quads-0.1.0/.hypothesis/constants/00ac74e5f24a8f23

@@ -0,0 +1,4 @@
+# file: /home/runner/work/refined-quads/refined-quads/src/refined_quads/_generate/quadtree.py
+# hypothesis_version: 6.170.15
+
+['ij']

refined_quads-0.1.0/.hypothesis/constants/00b099b28ab69719

@@ -0,0 +1,4 @@
+# file: /home/runner/work/refined-quads/refined-quads/src/refined_quads/_generate/select.py
+# hypothesis_version: 6.170.15
+
+[1e-06]

refined_quads-0.1.0/.hypothesis/constants/03071a56d568c4ff

@@ -0,0 +1,4 @@
+# file: /home/runner/work/refined-quads/refined-quads/src/refined_quads/_common/grid.py
+# hypothesis_version: 6.170.15
+
+[]

refined_quads-0.1.0/.hypothesis/constants/0ca6499cddf7bb4e

@@ -0,0 +1,4 @@
+# file: /home/runner/work/refined-quads/refined-quads/src/refined_quads/_generate/conformity.py
+# hypothesis_version: 6.170.15
+
+[0.35, 0.65, 1.0, 'stable']

refined_quads-0.1.0/.hypothesis/constants/0d3d930a8cf43bfe

@@ -0,0 +1,4 @@
+# file: /home/runner/work/refined-quads/refined-quads/src/refined_quads/_generate/balance.py
+# hypothesis_version: 6.170.15
+
+[200, 2000, 'E', 'N', 'S', 'W']

refined_quads-0.1.0/.hypothesis/constants/17ee048a05047466

@@ -0,0 +1,4 @@
+# file: /home/runner/work/refined-quads/refined-quads/src/refined_quads/_check/check.py
+# hypothesis_version: 6.170.15
+
+[2.0, ', ']

refined_quads-0.1.0/.hypothesis/constants/1f66879254faba2d

@@ -0,0 +1,4 @@
+# file: /home/runner/work/refined-quads/refined-quads/src/refined_quads/_common/topology.py
+# hypothesis_version: 6.170.15
+
+[]

refined_quads-0.1.0/.hypothesis/constants/25497450f93ddf0a

@@ -0,0 +1,4 @@
+# file: /home/runner/work/refined-quads/refined-quads/src/refined_quads/_generate/generate.py
+# hypothesis_version: 6.170.15
+
+[100.0, 100, ', ', 'MultiPolygon', 'Polygon', 'Starting', 'centre', 'domain', 'inside', 'refinement areas', 'touches', 'water areas']

refined_quads-0.1.0/.hypothesis/constants/28260f4e3ba16f80

@@ -0,0 +1,4 @@
+# file: /home/runner/work/refined-quads/refined-quads/src/refined_quads/_refine/refine.py
+# hypothesis_version: 6.170.15
+
+[1e-06, 2.0, ', ', 'centre', 'domain', 'intersects']

refined_quads-0.1.0/.hypothesis/constants/39328d456621aedd

@@ -0,0 +1,4 @@
+# file: /home/runner/work/refined-quads/refined-quads/src/refined_quads/_common/recognise.py
+# hypothesis_version: 6.170.15
+
+[1e-06]

refined_quads-0.1.0/.hypothesis/constants/3e605759b9d714fe

@@ -0,0 +1,4 @@
+# file: /home/runner/work/refined-quads/refined-quads/src/refined_quads/_io/gis.py
+# hypothesis_version: 6.170.15
+
+[-1.0, 'EPSG_code', 'GPKG', 'MultiPolygon', 'Point', 'Polygon', 'Unknown projected', 'WKT1_GDAL', 'columns', 'crs', 'domain', 'epsg', 'fields', 'geometries', 'geometry', 'grid_mapping_name', 'ignore', 'index', 'inverse_flattening', 'levels', 'name', 'orth_e', 'proj4_params', 'projection_name', 'refinement area', 'semi_major_axis', 'semi_minor_axis', 'unknown', 'value', 'water area', 'wkt']

refined_quads-0.1.0/.hypothesis/constants/3f2b180b637013e0

@@ -0,0 +1,4 @@
+# file: /home/runner/work/refined-quads/refined-quads/src/refined_quads/_generate/faces.py
+# hypothesis_version: 6.170.15
+
+['E', 'N', 'NSEW', 'S', 'SNEW', 'W']

refined_quads-0.1.0/.hypothesis/constants/46f7bb725c91ddeb

@@ -0,0 +1,4 @@
+# file: /home/runner/work/refined-quads/refined-quads/src/refined_quads/_generate/areas.py
+# hypothesis_version: 6.170.15
+
+[8.0, 2000, 'structure']

refined_quads-0.1.0/.hypothesis/constants/60081ff99c20a9d1

@@ -0,0 +1,4 @@
+# file: /home/runner/work/refined-quads/refined-quads/src/refined_quads/spec.py
+# hypothesis_version: 6.170.15
+
+[', ', '.', 'WaterRemovalRule', 'cell_size', 'cell_size: missing', 'centre', 'crs', 'domain', 'domain: missing', 'layer', 'level', 'origin', 'output', 'path', 'refinement', 'refinement_areas', 'transition_rows', 'utf-8', 'water_areas', 'water_removal']

refined_quads-0.1.0/.hypothesis/constants/6de9487054c298a0

@@ -0,0 +1,4 @@
+# file: /home/runner/work/refined-quads/refined-quads/src/refined_quads/mesh.py
+# hypothesis_version: 6.170.15
+
+[1e-06, 'None', 'cell_size', 'crs', 'faces', 'levels', 'nodes', 'origin']

refined_quads-0.1.0/.hypothesis/constants/8814f21e6484e0fc

@@ -0,0 +1,4 @@
+# file: /home/runner/work/refined-quads/refined-quads/src/refined_quads/_check/__init__.py
+# hypothesis_version: 6.170.15
+
+[]

refined_quads-0.1.0/.hypothesis/constants/88daa58db1ff125a

@@ -0,0 +1,4 @@
+# file: /home/runner/work/refined-quads/refined-quads/src/refined_quads/__init__.py
+# hypothesis_version: 6.170.15
+
+['0.0.0', 'Areas', 'Cancelled', 'InputError', 'Lattice', 'LayerSource', 'Mesh', 'MeshRecognitionError', 'MeshReport', 'MeshSpec', 'RefineResult', 'RefineSpec', 'RefinementSource', 'ReplacementMap', '__version__', 'check', 'generate', 'read_domain', 'read_ugrid', 'read_water_areas', 'refine', 'refined-quads', 'write_ugrid']

refined_quads-0.1.0/.hypothesis/constants/9182c701def2d4d5

@@ -0,0 +1,4 @@
+# file: /home/runner/work/refined-quads/refined-quads/src/refined_quads/_generate/orthogonality.py
+# hypothesis_version: 6.170.15
+
+[-1e-12, 1e-12, 0.3, 0.5, 1.0, 2.0, 3.0, 50.0, ', ', '2 (fan)', '5 (corner fan)', 'ENSW', 'ignore']

refined_quads-0.1.0/.hypothesis/constants/989da628c6044bfc

@@ -0,0 +1,4 @@
+# file: /home/runner/work/refined-quads/refined-quads/src/refined_quads/cli.py
+# hypothesis_version: 6.170.15
+
+[254, '+', '--cell-size', '--crs', '--origin', '--output', '--transition-rows', '--verbose', '--version', '--water-removal', '-o', '-v', ';', 'COMMAND', 'N', 'X', 'Y', 'cell_size', 'command', 'crs', 'generate', 'info', 'mesh', 'none', 'origin', 'output', 'problem', 'recognition_problems', 'refine', 'refined-quads', 'spec', 'store_true', 'transition_rows', 'version', 'water removal rule', 'water_removal']

refined_quads-0.1.0/.hypothesis/constants/a5631cf79c8a54c4

@@ -0,0 +1,4 @@
+# file: /home/runner/work/refined-quads/refined-quads/src/refined_quads/_common/__init__.py
+# hypothesis_version: 6.170.15
+
+[]

refined_quads-0.1.0/.hypothesis/constants/b197677f5f08a04f

@@ -0,0 +1,4 @@
+# file: /home/runner/work/refined-quads/refined-quads/src/refined_quads/errors.py
+# hypothesis_version: 6.170.15
+
+[]

refined_quads-0.1.0/.hypothesis/constants/b747fbea3787abd2

@@ -0,0 +1,4 @@
+# file: /home/runner/work/refined-quads/refined-quads/.venv/bin/pytest
+# hypothesis_version: 6.170.15
+
+['-script.pyw', '.exe', '__main__']

refined_quads-0.1.0/.hypothesis/constants/b7542176cfbb5401

@@ -0,0 +1,4 @@
+# file: /home/runner/work/refined-quads/refined-quads/src/refined_quads/_generate/engine.py
+# hypothesis_version: 6.170.15
+
+[100, 'centre', 'inside', 'the domain', 'touches']

refined_quads-0.1.0/.hypothesis/constants/bdb6ab1d246d2c55

@@ -0,0 +1,4 @@
+# file: /home/runner/work/refined-quads/refined-quads/src/refined_quads/_refine/__init__.py
+# hypothesis_version: 6.170.15
+
+[]

refined_quads-0.1.0/.hypothesis/constants/c70157c5272366f2

@@ -0,0 +1,4 @@
+# file: /home/runner/work/refined-quads/refined-quads/src/refined_quads/_common/progress.py
+# hypothesis_version: 6.170.15
+
+['[QuadRef] %s%s%s']

refined_quads-0.1.0/.hypothesis/constants/cbaeb266738a869f

@@ -0,0 +1,4 @@
+# file: /home/runner/work/refined-quads/refined-quads/src/refined_quads/_io/__init__.py
+# hypothesis_version: 6.170.15
+
+[]

refined_quads-0.1.0/.hypothesis/constants/dd7ed633ab48ff73

@@ -0,0 +1,4 @@
+# file: /home/runner/work/refined-quads/refined-quads/src/refined_quads/_io/ugrid.py
+# hypothesis_version: 6.170.15
+
+[-999.0, 0.5, 299.1528128, 6356078.962818189, 6377397.155, -999, 28992, '%Y-%m-%dT%H:%M:%S', ', ', '0', 'Amersfoort / RD New', 'Conventions', 'EPSG:0', 'EPSG:28992', 'EPSG_code', 'HKV / Svasek', 'Mesh2d', 'Mesh2d_edge_nodes', 'Mesh2d_edge_x', 'Mesh2d_edge_y', 'Mesh2d_face_nodes', 'Mesh2d_face_x', 'Mesh2d_face_x_bnd', 'Mesh2d_face_y', 'Mesh2d_face_y_bnd', 'Mesh2d_face_z', 'Mesh2d_nEdges', 'Mesh2d_nFaces', 'Mesh2d_nNodes', 'Mesh2d_node_x', 'Mesh2d_node_y', 'Mesh2d_node_z', 'NETCDF4', 'Two', 'Unknown projected', 'altitude', 'bounds', 'cf_role', 'crs_wkt', 'edge_coordinates', 'edge_dimension', 'epsg', 'f8', 'face_coordinates', 'face_dimension', 'grid_mapping_name', 'history', 'i4', 'institution', 'inverse_flattening', 'long_name', 'm', 'mesh_topology', 'name', 'node_coordinates', 'node_dimension', 'proj4_params', 'projection_name', 'r', 'references', 'semi_major_axis', 'semi_minor_axis', 'source', 'standard_name', 'start_index', 'topology_dimension', 'units', 'unknown', 'value', 'w', 'wkt', 'x', 'x-coordinate', 'y', 'y-coordinate']

refined_quads-0.1.0/.hypothesis/constants/e5330bdc0ad9bcb0

@@ -0,0 +1,4 @@
+# file: /home/runner/work/refined-quads/refined-quads/src/refined_quads/_generate/clip.py
+# hypothesis_version: 6.170.15
+
+[-999.0, -998.0, 'centre', 'inside', 'touches']

refined_quads-0.1.0/.hypothesis/constants/fc51d84a26877bba

@@ -0,0 +1,4 @@
+# file: /home/runner/work/refined-quads/refined-quads/src/refined_quads/_generate/__init__.py
+# hypothesis_version: 6.170.15
+
+[]

refined_quads-0.1.0/.pre-commit-config.yaml

@@ -0,0 +1,40 @@
+---
+# Install once with `uv run pre-commit install`; run on everything with
+# `uv run pre-commit run --all-files`. CI runs the same hooks.
+repos:
+  - repo: https://github.com/pre-commit/pre-commit-hooks
+    rev: v6.0.0
+    hooks:
+      - id: check-added-large-files
+      - id: check-ast
+      - id: check-case-conflict
+      - id: check-merge-conflict
+      - id: check-toml
+      - id: debug-statements
+      - id: end-of-file-fixer
+      - id: trailing-whitespace
+        args: [--markdown-linebreak-ext=md]
+
+  - repo: https://github.com/adrienverge/yamllint
+    rev: v1.38.0
+    hooks:
+      - id: yamllint
+        args: [--config-file=.yamllint.yaml]
+
+  # No pydoclint (in the HKV template): it compares the types in docstrings with the
+  # annotations, and the docstrings here describe types in words ("list of (float, float)").
+  # ruff checks the docstrings (numpy convention), mypy the annotations.
+
+  # ruff from the project environment, so the hooks and `uv run ruff` use one version.
+  - repo: local
+    hooks:
+      - id: ruff-check
+        name: ruff check
+        entry: uv run --frozen ruff check --fix --exit-non-zero-on-fix
+        language: system
+        types_or: [python, pyi]
+      - id: ruff-format
+        name: ruff format
+        entry: uv run --frozen ruff format
+        language: system
+        types_or: [python, pyi]

refined_quads-0.1.0/.python-version

@@ -0,0 +1 @@
+3.12

refined_quads-0.1.0/.yamllint.yaml

@@ -0,0 +1,9 @@
+---
+extends: default
+rules:
+  new-lines: disable
+  line-length:
+    max: 100
+  # GitHub Actions uses the key `on`, which yamllint reads as a boolean.
+  truthy:
+    check-keys: false

refined_quads-0.1.0/CHANGELOG.md

@@ -0,0 +1,147 @@
+# Changelog
+
+All notable changes to this project are documented here. The format follows
+[Keep a Changelog](https://keepachangelog.com/en/1.1.0/) and the project uses
+[Semantic Versioning](https://semver.org/). Any intended change to the cells a given
+input produces is at least a minor version (see `docs/adr/0002-output-contract-same-cells.qmd`).
+
+## [Unreleased]
+
+## [0.1.0] - 2026-11-12
+
+### Added
+
+- Project skeleton: uv project, ruff, mypy, pytest, CI workflow and documentation site.
+- `Mesh` and `Lattice`: an immutable mesh (nodes, faces padded with -1) on its lattice.
+- `check(mesh) -> MeshReport`: hanging nodes, 2:1 balance, FM orthogonality per internal
+  edge (the D-Flow FM measure), orientation, cells per refinement level and nodes off the
+  lattice.
+- `InputError` for invalid input.
+- Golden masters of the generator at qgis_dhydamo `9a324bc` for fourteen synthetic
+  scenarios, with the recording script and a runtime baseline (`tests/golden`); with
+  water or holes they are the old generator without water plus the MeshKernel clip of
+  the model workflow.
+- `generate(domain, *, cell_size, refinement_areas, transition_rows) -> Mesh`, with the
+  engine of the generator at qgis_dhydamo `9a324bc`; it gives the same cells for the
+  same input (golden masters).
+- `OrthogonalityRepairError` when the orthogonality repair does not close.
+- Water areas in `generate` (`water_areas`, `water_removal`) with three water removal
+  rules: `"centre"` (default), `"inside"` and `"touches"`. The finished mesh is clipped
+  cell by cell with MeshKernel, exactly as the model workflow (hydrolib's
+  `mesh2d_clip`) does, so the remaining small cells follow the water's edge; MeshKernel
+  is a new dependency.
+- `MeshReport.cell_levels`: the refinement level of the lattice square of every cell.
+- `write_ugrid(mesh, path)` and `read_ugrid(path)`: UGRID-1.0 netCDF with the structure
+  of the old writer; for EPSG:28992 exactly the CRS attributes of the D-Flow FM plugin.
+  `read_ugrid` reads only the 2D mesh of a net file (a 1D network is ignored) and
+  derives the lattice from the square cells.
+- `Mesh.crs`: the projected CRS of a mesh, or `None` when unknown; a geographic CRS
+  raises `InputError`.
+- `read_domain`, `read_refinement_areas` (level from a column or one fixed level) and
+  `read_water_areas`: read a GeoPackage or shapefile layer with pyogrio, or take a
+  GeoDataFrame (geopandas is not a dependency), into `Areas` (polygons with a CRS).
+- `generate` takes `Areas` and GeoDataFrames and has a `crs` parameter for input
+  without CRS. The mesh gets the CRS of the domain; other input is transformed to it.
+- `write_ugrid` derives the CRS attributes of CRSs other than EPSG:28992 with pyproj.
+- `MeshSpec`: the input of a run, one-to-one with a TOML file (`MeshSpec.from_toml`,
+  `replace`, `generate`); an invalid TOML file gives an `InputError` naming the key and
+  the reason.
+- Command line: `refined-quads generate run.toml -o mesh_net.nc` (options override the
+  TOML values) and `refined-quads info mesh_net.nc` (lattice, cells per level and the
+  checks). Exit codes: 0 success, 1 the run failed, 2 invalid input or arguments.
+- `generate(..., origin=(x, y))` (also `origin` in the TOML and `--origin X Y`): a
+  point of the lattice, so a mesh lines up with an existing mesh or raster; by
+  default the lower-left corner of the domain rounded down to a multiple of the cell
+  size, as before.
+- `generate(..., progress=callback)`: `callback(fraction, message)` with a fraction
+  rising from 0 to 1 and English messages; returning `True` cancels the run with
+  `Cancelled` (the old generator raised a `RuntimeError`). `refined-quads generate -v`
+  prints the progress.
+- `OrthogonalityRepairError.mesh`: the raw mesh before the repair, next to
+  `bad_points`. When the repair does not close, `refined-quads generate` writes
+  `<output>_raw.nc` and `<output>_problems.gpkg` (layer `orthogonality_problems`,
+  field `orth_e`, -1 for a degenerate edge) in the CRS of the mesh and exits with 1; a
+  failure to write them is reported without hiding the repair error.
+- `refine(mesh, refinement_areas, ...) -> RefineResult`: refine an existing mesh
+  without its original input (ADR-0001). The lattice squares are recognised from the
+  cells, the new areas applied, the 2:1 balance restored where needed; squares that do
+  not change keep their cells and nodes exactly, the mesh never grows beyond its
+  footprint, and a domain or water areas only remove new cells. `RefineResult` has the
+  new mesh and a `ReplacementMap` (per new cell the old cell it lies in, which cells are
+  unchanged, which old cells went). `generate` is the same route from the base grid.
+- `MeshRecognitionError` (an `InputError` with locations) when a mesh cannot be
+  refined: nodes off its lattice, cells that fill no lattice square, or a broken 2:1
+  balance. Duplicate nodes are accepted, and so are lattice squares that their cells
+  fill only partly (clipped along water); new cells in such a square stay only where
+  they lie completely within its old cells.
+- Refine works on meshes from other programs: any lattice origin and base cell (derived
+  from the cells), and any transition cells (a pentagon, another triangulation) as long
+  as they fill a lattice square; squares that do not change keep their cells. Refine
+  judges the orthogonality only of edges next to new cells, so problems the mesh
+  already had do not stop it. Meshes of rectangles or rotated cells raise `InputError`.
+- `refined-quads refine mesh_net.nc extra.toml -o mesh_v2_net.nc` and `RefineSpec` (the
+  TOML of a refine: new refinement areas, optional domain and water areas): same
+  options and exit codes as `generate`; a mesh that cannot be recognised exits with 2
+  and writes `<output>_recognition.gpkg` with the problem locations.
+- `MeshReport.duplicate_nodes` (information only: cells that touch in a point lose
+  nothing) and `MeshReport.split_edges` (an edge on top of another edge with other
+  nodes: an internal wall; makes the mesh invalid).
+- Benchmarks (`pytest -m benchmark`, pytest-benchmark) on three golden-master
+  scenarios, and `tests/golden/benchmarks.py` to compare results with a baseline and
+  report changes above 5%. CI runs slow tests and benchmarks on main and compares with
+  the previous run on main; results are kept as artifact.
+- Documentation: a tutorial (a first mesh), how-to guides (GIS layers, TOML and the
+  command line, water areas, refining an existing mesh, D-HYDRO), explanations (refined
+  quad meshes, FM orthogonality, why refine starts from the mesh) and the API reference.
+  The site is built with Quarto, as in the HKV package template; the code on the pages
+  runs during the build and draws the mesh figures, and quartodoc writes the API
+  reference. CI publishes it to GitHub Pages from main once the repository is public.
+- Licence: GNU GPL v3 or later (`LICENSE`), with `CITATION.cff`.
+- pre-commit hooks (file hygiene, yamllint, pydoclint, ruff), also run in CI.
+- Publishing to PyPI when a GitHub release is published (trusted publishing).
+
+### Changed compared with the generator at qgis_dhydamo `9a324bc`
+
+- Intended output change: water areas are clipped cell by cell with MeshKernel after
+  generation, instead of removing whole lattice squares before the cells are formed
+  (the old `clip_water` option). Holes in the domain are clipped the same way; the old
+  generator kept every lattice square that overlaps the domain, so cells reached into
+  a hole. MeshKernel derives cells from edges again: a single deleted cell whose edges
+  all stay comes back, which is accepted.
+- Intended output change: no minimum cell size. A 24 m base cell asked for level 5 now
+  gives 0.75 m cells; the old generator capped the levels so that the smallest cell
+  was at least 1 m (4 levels, 1.5 m).
+- Every face is counterclockwise; the old generator wrote about 5% of its transition
+  triangles clockwise. The cells are the same.
+- Transition rows are given per step from coarse to fine and must be at least 1; 0
+  raises `InputError` (the old generator took them from fine to coarse and counted 0
+  as 1). Callers get the same mesh by reversing their list and replacing 0 by 1.
+- The highest refinement level follows from the refinement areas; there is no
+  `max_refinement`. A level that is not an integer of at least 1 raises `InputError`
+  instead of being clamped.
+- Explicit refine zones without transition rows and support for shapely < 2 are gone.
+- The orthogonality repair works on integer lattice indices: flips, convexity and the
+  redecomposition of lattice squares are exact, and the centre nodes it adds lie exactly
+  on the lattice (the old generator computed them as float midpoints). Only the FM
+  measure uses coordinates, as D-Flow FM does.
+- Water areas that are given are always applied; there is no `clip_water` switch that
+  silently ignored them. An unknown water removal rule raises `InputError` instead of
+  falling back to the centre rule.
+- `write_ugrid` writes the CRS of the mesh instead of always EPSG:28992: a mesh without
+  CRS gets no CRS variable. The `source` attribute names refined-quads and its version.
+- No CRS is ever assumed: input without CRS (a layer, a GeoDataFrame or shapely
+  geometries) raises `InputError` unless `crs=` is given, and a geographic domain CRS
+  raises `InputError` (the old generator read a layer without CRS as RD New and
+  transformed everything else to RD New). A layer whose CRS contradicts `crs=` raises
+  `InputError`, as do a missing or invalid level (naming the feature), a feature
+  without geometry or that is not a polygon, and a file with several layers when no
+  layer is named.
+- Intended output change for invalid polygons only: a domain, refinement area or water
+  area that is not valid is made valid with shapely's `make_valid` (structure method,
+  only polygonal parts) instead of `buffer(0)`, and a warning is logged. A
+  self-intersecting polygon such as a bowtie keeps all its loops, where `buffer(0)` kept
+  one. Valid input gives the same cells.
+- The quadtree is built one generation at a time with the geometry tests in bulk
+  (shapely's vectorised predicates on prepared geometries, one STRtree query for all
+  start cells), and the selection of lattice squares in the domain clips in bulk. The
+  cells, and their order, are unchanged; on the benchmarks generate is 3-14% faster.

refined_quads-0.1.0/CITATION.cff

@@ -0,0 +1,22 @@
+---
+cff-version: 1.2.0
+message: "If you use this software, please cite it using these metadata."
+title: refined-quads
+version: 0.1.0
+date-released: 2026-11-12
+abstract: >-
+  Generate and refine refined quad meshes for D-Flow FM: axis-aligned squares on a
+  fixed lattice, locally refined by repeated halving, with transition cells only where
+  refinement levels meet.
+authors:
+  - name: "HKV lijn in water"
+  - name: "Svasek Hydraulics"
+repository-code: "https://github.com/HKV-products-services/refined-quads"
+url: "https://hkv-products-services.github.io/refined-quads"
+license: GPL-3.0-or-later
+keywords:
+  - mesh
+  - quadtree
+  - UGRID
+  - D-Flow FM
+  - hydrodynamics

refined_quads-0.1.0/CLAUDE.md

@@ -0,0 +1,53 @@
+# CLAUDE.md — refined-quads
+
+Python package that generates and refines refined quad meshes for D-Flow FM. It is the
+single source of the generator formerly vendored as `meshgen` in qgis_dhydamo
+(`tools/runtime/mesh/meshgen`) and DHYDRO_Varianten (`tools/standalone/measures_cli/rooster/meshgen`).
+Plan: `.scratch/issues/refined-quads/PRD.md` and the issues next to it.
+
+## Rules
+
+- Everything in English: code, docstrings (numpy style), error and log messages, docs.
+  Conversation with the user may be in Dutch.
+- Output contract (ADR-0002): the same input gives the same cells as the generator at
+  qgis_dhydamo `9a324bc`, compared on integer lattice indices; cell and node order are
+  free. Golden masters guard this; an intended output change is at least a minor
+  version with a CHANGELOG entry.
+- Replacing own code by shapely/numpy or vectorising: only if the golden masters still
+  give the same cells and the benchmark is not more than 5% slower.
+- Invalid input raises an error; never silently adjust (levels, transition rows, CRS).
+  Exception: invalid polygons (domain, refinement areas, water areas) are made valid
+  with `make_valid` and a logged warning, not an error.
+- Public API only via the top-level package. Internal code lives in subpackages whose
+  name starts with an underscore, grouped by task: `_generate/`, `_refine/`, `_check/`,
+  `_io/`, `_common/` (the modules inside have plain names). The test folders mirror them
+  (`tests/generate/`, ...); tests of the public layer (`cli`, `mesh`) stay in `tests/`.
+- Use the terms from `CONTEXT.md`.
+
+## Commands
+
+| Task | Command |
+| --- | --- |
+| Install | `uv sync` |
+| Fast tests | `uv run pytest` (slow/benchmark/realdata via `-m <marker>`) |
+| Benchmarks | `uv run pytest -m benchmark --benchmark-json=after.json`, then `uv run python tests/golden/benchmarks.py after.json --baseline before.json` (5% rule: measure before and after back to back on one machine) |
+| Lint / format | `uv run pre-commit run --all-files` (ruff check and format, yamllint, file hygiene) |
+| Types | `uv run mypy` |
+| Docs | in `docs/`: `uv run quartodoc build`, then `uv run quarto render` (or `quarto preview`). Quarto is a separate install (`C:\Program Files\Quarto\bin`); CI fails on any `WARN` in the render output |
+
+uv manages Python itself (`.python-version` = 3.12); the chocolatey Python shims on the
+development PC are broken, so do not rely on a system Python.
+
+## Agent skills
+
+### Issue tracker
+
+Local markdown in `.scratch/issues/<feature>/` (outside Git). See `docs/agents/issue-tracker.md`.
+
+### Triage labels
+
+Default labels (`needs-triage`, `needs-info`, `ready-for-agent`, `ready-for-human`, `wontfix`) as a `Status:` line in the issue file. See `docs/agents/triage-labels.md`.
+
+### Domain docs
+
+Single-context: `CONTEXT.md` at the root, ADRs in `docs/adr/`. See `docs/agents/domain.md`.

refined_quads-0.1.0/CONTEXT.md

@@ -0,0 +1,80 @@
+# refined-quads
+
+Generates 2D computational meshes of axis-aligned square cells that are locally
+refined by halving, for use as the 2D grid of a D-Flow FM model.
+
+## Language
+
+**Refined quad mesh**:
+A 2D mesh of axis-aligned squares on a fixed lattice, locally refined by
+repeated halving, with triangles or irregular quads only where cell sizes change.
+_Avoid_: quadtree grid, meshgen grid, Quad Grid
+
+**Base cell**:
+The coarsest square of a refined quad mesh; its size is the cell size the user
+chooses, any positive length (not necessarily a power of 2).
+_Avoid_: basiscel, coarse cell
+
+**Refinement level**:
+The number of halvings of the base cell; level 0 is the base cell, level N has
+side length cell size / 2^N.
+_Avoid_: halving level, refinement (as a number)
+
+**Lattice**:
+The fixed grid of points, given by an origin and the base cell size, on which
+every square of a refined quad mesh has its corners.
+_Avoid_: raster, grid origin
+
+**Lattice square**:
+A square of the quadtree: a base cell or one of the squares its halving gives,
+aligned to the lattice at its refinement level. It becomes one square cell, or is
+filled exactly by transition cells; after clipping along water it can be filled only
+partly.
+_Avoid_: parent square, quadtree cell, leaf
+
+**Transition rows**:
+For the step from refinement level k+1 down to level k, the number of rows of
+level-(k+1) cells kept around the finer area before the mesh coarsens; at least 1.
+Given per step from coarse to fine.
+_Avoid_: buffer rows, bufferrijen, buffer
+
+**Transition cell**:
+A triangle or irregular quad that, together with the other transition cells in
+the same lattice square, fills that square exactly where refinement levels meet.
+_Avoid_: sliver, overgangsdriehoek, transition triangle
+
+**Footprint**:
+The area covered by the cells of an existing mesh; holes are not part of it.
+Refining never adds cells outside it.
+_Avoid_: extent, mesh outline
+
+**Replacement map**:
+The record of a refine: which existing cells were removed and, for every new
+cell, the existing cell it lies in. Lets callers carry cell data over.
+_Avoid_: diff, mapping, splice
+
+## Input
+
+**Domain**:
+The (multi)polygon that encloses the mesh and forms its edges (the enclosure in
+D-HYDRO terms); usually a polygon layer of a GeoPackage, whose features are merged. A
+lattice square that overlaps it is kept whole, so the outer edge of the mesh follows
+the lattice along the domain rather than the polygon exactly. Holes in the domain are
+clipped like water areas, cell by cell.
+_Avoid_: boundary, extent, model area
+
+**Refinement area**:
+A polygon paired with the refinement level its cells must reach; transition
+rows are added around it automatically.
+_Avoid_: refinement polygon, refine zone, refinement (as a shape)
+
+**Water area**:
+An area where no 2D cells are kept, because the 1D network carries the flow there.
+_Avoid_: water polygon, exclusion area, clip area
+
+**Water removal rule**:
+The test that decides whether a cell touching a water area (or a hole in the domain)
+is removed from the finished mesh: by its circumcentre, only when fully inside, or as
+soon as it touches; applied cell by cell with MeshKernel, as in the model workflow, so
+the remaining small cells follow the water's edge.
+_Avoid_: delete option, clip method