diff --git a/.github/workflows/python-app.yml b/.github/workflows/python-app.yml index b074aa1..163f3f1 100644 --- a/.github/workflows/python-app.yml +++ b/.github/workflows/python-app.yml @@ -2,19 +2,31 @@ name: pytest on: push: - branches: ["feat_tests", "main", "master"] + branches: ["main", "master"] pull_request: schedule: - cron: "0 0 * * 0" jobs: + lint: + runs-on: ubuntu-latest + steps: + - uses: actions/checkout@v4 + - uses: actions/setup-python@v5 + with: + python-version: "3.12" + - name: Install ruff + run: pip install ruff + - name: Ruff check + run: ruff check src tests + test: runs-on: ${{ matrix.os }} strategy: fail-fast: false matrix: os: [ubuntu-latest, windows-latest, macos-latest] - python-version: ["3.11", "3.12"] + python-version: ["3.10", "3.11", "3.12"] steps: - uses: actions/checkout@v4 @@ -25,6 +37,39 @@ jobs: create-args: >- python=${{ matrix.python-version }} cache-environment: true - - name: Run pytest + - name: Run pytest with coverage shell: bash -l {0} - run: pytest + run: pytest --cov=vorflow --cov-report=term-missing + + minimum-dependencies: + runs-on: ubuntu-latest + steps: + - uses: actions/checkout@v7 + - uses: actions/setup-python@v6 + with: + python-version: "3.10" + cache: pip + - name: Install Gmsh system library + run: sudo apt-get update && sudo apt-get install --yes libglu1-mesa + - name: Install minimum runtime dependencies + run: >- + python -m pip install + numpy==1.24.0 + pandas==1.5.0 + geopandas==0.13.0 + shapely==2.0.0 + scipy==1.10.0 + gmsh==4.11.1 + - name: Install vorflow development tools + run: python -m pip install --no-deps -e . && python -m pip install pytest pytest-cov tomli + - name: Verify installed dependency versions + run: >- + python -c "import geopandas, gmsh, numpy, pandas, scipy, shapely; + assert numpy.__version__ == '1.24.0'; + assert pandas.__version__ == '1.5.0'; + assert geopandas.__version__ == '0.13.0'; + assert shapely.__version__ == '2.0.0'; + assert scipy.__version__ == '1.10.0'; + assert gmsh.__version__ == '4.11.1'" + - name: Run tests at dependency floors + run: pytest --cov=vorflow --cov-report=term-missing diff --git a/.github/workflows/testpypi.yml b/.github/workflows/testpypi.yml new file mode 100644 index 0000000..e926f6f --- /dev/null +++ b/.github/workflows/testpypi.yml @@ -0,0 +1,66 @@ +name: Publish release candidate to TestPyPI + +on: + push: + tags: + - "v*rc*" + +permissions: + contents: read + +jobs: + build: + runs-on: ubuntu-latest + steps: + - uses: actions/checkout@v7 + - uses: actions/setup-python@v6 + with: + python-version: "3.12" + cache: pip + - name: Install Gmsh system library + run: sudo apt-get update && sudo apt-get install --yes libglu1-mesa + - name: Install build and test tools + run: python -m pip install -e ".[dev]" + - name: Run Ruff + run: ruff check src tests scripts + - name: Run pytest + run: pytest --cov=vorflow --cov-report=term-missing + - name: Build wheel and source distribution + run: python -m build + - name: Check package metadata rendering + run: python -m twine check dist/* + - name: Validate tag, metadata, and archive contents + env: + RELEASE_TAG: ${{ github.ref_name }} + run: python scripts/check_dist.py dist --expected-tag "$RELEASE_TAG" + - name: Smoke-test the built wheel + run: | + python -m venv "$RUNNER_TEMP/vorflow-smoke" + "$RUNNER_TEMP/vorflow-smoke/bin/python" -m pip install dist/*.whl + "$RUNNER_TEMP/vorflow-smoke/bin/python" -m pip check + "$RUNNER_TEMP/vorflow-smoke/bin/python" -c "import vorflow; assert vorflow.__version__ == '0.1.0rc1'" + cd "$RUNNER_TEMP" + "$RUNNER_TEMP/vorflow-smoke/bin/python" "$GITHUB_WORKSPACE/examples/basic_usage.py" + - uses: actions/upload-artifact@v7 + with: + name: python-package-distributions + path: dist/ + if-no-files-found: error + + publish-testpypi: + needs: build + runs-on: ubuntu-latest + environment: + name: testpypi + url: https://test.pypi.org/p/vorflow + permissions: + id-token: write + steps: + - uses: actions/download-artifact@v8 + with: + name: python-package-distributions + path: dist/ + - name: Publish package distributions to TestPyPI + uses: pypa/gh-action-pypi-publish@release/v1 + with: + repository-url: https://test.pypi.org/legacy/ diff --git a/.gitignore b/.gitignore index 883286e..db570ad 100644 --- a/.gitignore +++ b/.gitignore @@ -210,8 +210,18 @@ __marimo__/ .DS_Store # vscode -.code-workspace +*.code-workspace # .pyc __pycache__ + +# Internal benchmarks / scratch experiments (not tracked) +benchmarks/ + +# Local conda environment in repo root +.conda/ + +# Superpowers visual brainstorming state +.superpowers/ + diff --git a/CHANGELOG.md b/CHANGELOG.md new file mode 100644 index 0000000..2592bd6 --- /dev/null +++ b/CHANGELOG.md @@ -0,0 +1,26 @@ +# Changelog + +All notable changes to `vorflow` are documented in this file. + +The format follows [Keep a Changelog](https://keepachangelog.com/en/1.1.0/), +and the project uses [Semantic Versioning](https://semver.org/spec/v2.0.0.html). + +## [Unreleased] + +## [0.1.0rc1] + +### Added + +- Voronoi and triangular/mixed-element grid generation for MODFLOW 6 workflows. +- Mesh-quality and connectivity diagnostics. +- Optional boundary inset/mirror points and structured quad buffers. +- Explicit mesh-size growth fields and runnable examples. +- Cross-platform tests and TestPyPI release automation. + +### Changed + +- Prepared project metadata, installation documentation, and dependency floors + for the first public release candidate. + +[Unreleased]: https://github.com/oscarfasanchez/vorflow_os/compare/v0.1.0rc1...HEAD +[0.1.0rc1]: https://github.com/oscarfasanchez/vorflow_os/tree/v0.1.0rc1 diff --git a/MANIFEST.in b/MANIFEST.in new file mode 100644 index 0000000..34c79e1 --- /dev/null +++ b/MANIFEST.in @@ -0,0 +1,6 @@ +prune .conda +prune benchmarks +prune docs +global-exclude *.code-workspace +global-exclude __pycache__ +global-exclude *.py[cod] diff --git a/README.md b/README.md index 14af340..700124b 100644 --- a/README.md +++ b/README.md @@ -1,8 +1,8 @@ # vorflow -Voronoi mesh generation for MODFLOW 6 using Gmsh and Geopandas. +Voronoi mesh generation for MODFLOW 6 using Gmsh and GeoPandas. -`vorflow` is a Python package for creating 2D unstructured Voronoi cell meshes for groundwater modeling, particularly for MODFLOW 6. It leverages the power of `Gmsh` for robust triangular meshing and `Shapely`/`Geopandas` for geometric operations. +`vorflow` is a Python package for creating 2D unstructured Voronoi cell meshes for groundwater modeling, particularly for MODFLOW 6. It leverages the power of `Gmsh` for robust triangular meshing and `Shapely`/`GeoPandas` for geometric operations. The process is designed to translate a conceptual model—defined by geometric features like polygons, lines, and points—into a high-quality Voronoi grid suitable for numerical simulation. @@ -28,49 +28,116 @@ The typical workflow follows these steps: ## Installation -The package dependencies are listed in `pyproject.toml`. You can install them using pip: +Install the latest published release: ```bash -pip install numpy pandas geopandas shapely scipy gmsh matplotlib +pip install vorflow ``` -To install `vorflow` itself, you can install it in editable mode from the root of the repository: +`vorflow` requires Python 3.10 or newer. + +### Development installation + +Clone the repository and install it in editable mode: + +```bash +pip install -e .[dev] +``` + +For plotting examples and notebooks without all development tools: ```bash -pip install -e . +pip install -e .[examples] ``` +Alternatively, create the Conda development environment from +[`etc/environment.yml`](https://github.com/oscarfasanchez/vorflow_os/blob/main/etc/environment.yml). + ## Basic Usage -Here is a simple example of how to generate a grid: +Here is a simple example of how to generate a non-empty Voronoi grid: + +The complete runnable version is +[examples/basic_usage.py](https://github.com/oscarfasanchez/vorflow_os/blob/main/examples/basic_usage.py). ```python +from shapely.geometry import LineString, Point, box + from vorflow import ConceptualMesh, MeshGenerator, VoronoiTessellator -from shapely.geometry import box, Point, LineString -# 1. Define conceptual model features domain = box(0, 0, 200, 200) well_point = Point(25, 25) fault_line = LineString([(100, 0), (100, 150)]) -# 2. Create a blueprint blueprint = ConceptualMesh(crs="EPSG:3857") blueprint.add_polygon(domain, zone_id=1) -blueprint.add_point(well_point, point_id="Well-A", resolution=2, dist_max=300) -blueprint.add_line(fault_line, line_id="Fault-1", resolution=1, is_barrier=True) +blueprint.add_point( + well_point, + point_id="Well-A", + resolution=2, + growth_factor=1.2, +) +blueprint.add_line( + fault_line, + line_id="Fault-1", + resolution=1, + is_barrier=True, +) clean_polys, clean_lines, clean_pts = blueprint.generate() -# 3. Generate the triangular mesh mesher = MeshGenerator(background_lc=100) mesher.generate(clean_polys, clean_lines, clean_pts) -# 4. Convert to Voronoi grid tessellator = VoronoiTessellator(mesher, blueprint, clip_to_boundary=True) grid_gdf = tessellator.generate() +if grid_gdf.empty: + raise RuntimeError("Basic Usage generated an empty Voronoi grid") +``` + +### Optional file export + +GeoPandas writes formats such as Shapefile and GeoPackage through an I/O engine +such as Pyogrio or Fiona. Install one of those engines before calling: -# 5. Save the output -grid_gdf.to_file("mf6_grid.shp") +```python +grid_gdf.to_file("mf6_grid.gpkg", driver="GPKG") +``` + +### Mesh gradation -print("Grid generation complete.") +Feature resolutions use `GeometricGrowthField` by default. Its +`growth_factor` is an upper target for neighboring characteristic edge-length +growth, not cell area growth and not an exact guarantee for every generated +neighbor pair. The default `growth_factor=1.2` uses the transparent spatial law + +```text +h(d) = feature_lc + (growth_factor - 1) * d. ``` + +For the continuous-metric convention, pass an explicit +`GeometricGrowthField(growth_model="continuous_metric")`; this uses the gentler +gradient `log(growth_factor)`. In normal `MeshGenerator` use, the global +background field caps either result at `background_lc`. + +> **Coordinate systems:** always work in a *projected* CRS (e.g. UTM or a +> national grid) so mesh sizes are in real length units (meters/feet). +> Geographic coordinates (lat/lon degrees, e.g. EPSG:4326) produce +> physically meaningless MODFLOW grids — reproject your data first with +> `GeoDataFrame.to_crs()`. + +## Examples + +The [examples/](https://github.com/oscarfasanchez/vorflow_os/tree/main/examples) +folder contains runnable scripts and notebooks +covering field-based refinement, mesh quality diagnostics, structured quad +buffers, active-domain workflows, and triangular element-grid export. + +## Roadmap + +See [ROADMAP.md](https://github.com/oscarfasanchez/vorflow_os/blob/main/ROADMAP.md) +for planned and completed milestones. + +## License + +MIT — see [LICENSE](https://github.com/oscarfasanchez/vorflow_os/blob/main/LICENSE). diff --git a/ROADMAP.md b/ROADMAP.md new file mode 100644 index 0000000..e182102 --- /dev/null +++ b/ROADMAP.md @@ -0,0 +1,99 @@ +# vorflow Roadmap - Porting robust capabilities from `gmshflow` + +This roadmap captures the agreed plan for bringing the strongest features of the +pre-refactor `gmshflow` library into `vorflow`, while keeping `vorflow`'s current +defaults backward-compatible and adding robust paths as opt-in options. + +Each milestone has a self-contained document under [`docs/roadmap/`](docs/roadmap/) +with goals, files to touch, source references, reuse notes, and verification +steps. + +## Context + +`gmshflow` (`../gmshflow/src/gmshflow.py`, a single module on the gmsh geo +kernel) was the version that existed before the refactor into `vorflow`. +`vorflow` (`src/vorflow/`) is modular and more robust: it runs on the gmsh OCC +kernel with `fragment` / `removeAllDuplicates` / `healShapes`, has a better field +system, and tracks generator points through the pipeline so Voronoi quality can +be computed correctly. + +However, a handful of `gmshflow` capabilities are either missing from `vorflow` +or useful enough to port. + +## Decisions + +- Keep both the lightweight straddle path and the robust structured-quad buffer + path. Structured buffers are opt-in and do not replace straddle. +- Keep the current Voronoi clipping behavior as the default. +- Do not add a core sliver-filtering or active-domain API for now. Larger + mesh-envelope / smaller active-domain workflows should select or tag active + cells externally with GeoPandas after grid generation. +- Add triangular/2D element quality, Voronoi/MODFLOW-facing connectivity reports, + CVFD skewness, and centroid-based quality diagnostics. +- Avoid new hard dependencies. Skip `topojson`; document external preprocessing + recipes instead. +- Leave `calculate_orthogonality` backward-compatible. New connectivity reports + can expose both Voronoi-dual generator connectivity and MODFLOW-facing centroid + connectivity. + +## Out of Scope + +- Outer-domain construction (`prepare_mesh_domain`): users can construct convex + hulls, square extents, or buffered envelopes with Shapely/GeoPandas. +- Topology-preserving simplification with `topojson`: avoid the dependency. +- A general `merge_many_multilinestring_into_one_linestring` helper: add only a + localized repair if structured buffers actually encounter offset-curve splits. + +## Current Objective + +| # | Milestone | Status | Risk | Behavior change | Doc | +|---|-----------|--------|------|-----------------|-----| +| 6 | First PyPI release | In progress | Low | None (packaging only) | [06-pypi-publishing.md](docs/roadmap/06-pypi-publishing.md) | + +The current release scope is a `0.1.0rc1` TestPyPI rehearsal. A successful +rehearsal changes this status to **TestPyPI verified**. The milestone becomes +**Done** only after `vorflow` is published to real PyPI. + +## Completed Milestones + +| # | Milestone | Status | Doc | +|---|-----------|--------|-----| +| 1 | Quality metrics | Done | [01-quality-metrics.md](docs/roadmap/01-quality-metrics.md) | +| 2 | Active-domain filtering workflow | Done (example) | [02-robust-clipping.md](docs/roadmap/02-robust-clipping.md) | +| 3 | Boundary inset/mirror points | Done | [03-boundary-mirror-points.md](docs/roadmap/03-boundary-mirror-points.md) | +| 4 | Structured-quad transfinite buffer | Done | [04-structured-quad-buffer.md](docs/roadmap/04-structured-quad-buffer.md) | +| 5 | Triangular/mixed element-grid output | Done | [05-triangular-grid-output.md](docs/roadmap/05-triangular-grid-output.md) | + +All five milestones are implemented: quality metrics and connectivity reports +(`get_triangular_quality`, `utils.build_connectivity`), the active-domain +workflow example (`examples/active_domain_quality_example.py`), opt-in boundary +inset/mirror points (`VoronoiTessellator(boundary_centering="inset_mirror")`), +opt-in structured quad buffers (`add_polygon`/`add_line` with +`quad_buffer=True`), and the element-grid exporter +(`MeshGenerator.get_element_grid()`, see +`examples/triangular_grid_example.py` and +`examples/structured_buffer_example.py`). + +## Summary per Milestone + +1. **Quality metrics**: add cached gmsh 2D element quality, generator/centroid + connectivity reports, skewness, tests, and example diagnostics. +2. **Active-domain filtering workflow**: no core API. Add an example showing how + to mesh a larger envelope, select active cells externally, and compare quality + against direct clipping. +3. **Boundary inset/mirror points**: add an opt-in Voronoi construction mode that + improves boundary-cell center placement and boundary connectivity quality. +4. **Structured-quad transfinite buffer**: add opt-in robust feature alignment for + line and polygon features in the OCC pipeline, keeping straddle as the default. +5. **Triangular/mixed element-grid output**: add a separate `MeshGenerator` + exporter for gmsh element polygons, supporting triangles now and mixed tri/quad + meshes for structured buffers. + +## Verification + +- Per milestone: add focused tests under `tests/`. +- End-to-end: keep `examples/field_capabilities_example.py` for field and quality + diagnostics, and add `examples/active_domain_quality_example.py` for the larger + mesh-envelope workflow. +- Backward compatibility: with new options disabled, current Voronoi output and + public APIs remain unchanged. diff --git a/docs/roadmap/01-quality-metrics.md b/docs/roadmap/01-quality-metrics.md new file mode 100644 index 0000000..07420c3 --- /dev/null +++ b/docs/roadmap/01-quality-metrics.md @@ -0,0 +1,104 @@ +# Milestone 1 — Quality metrics + +**Status:** planned · **Risk:** low · **Behavior change:** additive only +**Back to** [ROADMAP.md](../../ROADMAP.md) + +## Goal + +Give `vorflow` three quality capabilities that `gmshflow` had (some more complete +than others): + +1. **Triangular-element quality** on the gmsh mesh (gmsh's built-in metrics). +2. A **completed CVFD skewness** metric for the Voronoi grid (gmshflow's version + is buggy). +3. A **cell-pair connectivity report** (per shared face: angle + skewness) for + diagnostics/QA export. + +All additions reuse `vorflow`'s **generator-point** based pair logic, which is +the correct CVFD center — not `gmshflow`'s centroid-Delaunay reconstruction. + +## Why + +- `vorflow`'s `utils.py` already has `calculate_orthogonality`, + `calculate_mesh_quality` (compactness/convexity/drift), and + `summarize_quality`, but **no triangular-element quality** and **no skewness**. +- `gmshflow.calculate_cvfd_quality` (`../gmshflow/src/gmshflow.py:20-92`) computes + angle + skewness but: + - rebuilds a Delaunay from polygon **centroids** (an approximation — the + correct connector uses the generator points), and + - has a bug at `gmshflow.py:50-51` where `voronoi_index_1` and + `voronoi_index_2` are computed identically, so every "pair" is a cell with + itself. +- `gmshflow.GmshModel.get_triangular_quality` (`gmshflow.py:211-250`) is a clean, + useful wrapper worth porting as-is. + +## Files to touch + +- `src/vorflow/engine.py` — add `MeshGenerator.get_triangular_quality()`. +- `src/vorflow/utils.py` — add new connectivity/skewness functions; **leave + `calculate_orthogonality` untouched**. +- `examples/field_capabilities_example.py` — demonstrate the new reports. +- `tests/test_quality_metrics.py` (new) — unit tests. + +## Detail + +### 1. `MeshGenerator.get_triangular_quality()` + +Port of `gmshflow.py:211-250`. Wrap `gmsh.model.mesh.getElementQualities` over +the 2D elements and return a `pandas.DataFrame` with one row per element and +columns: `minSICN`, `minDetJac`, `maxDetJac`, `minSJ`, `minSIGE`, `gamma`, +`innerRadius`, `outerRadius`, `minIsotropy`, `angleShape`, `minEdge`, `maxEdge`. + +Constraints: +- Must run **while the gmsh model is still live** — i.e. after + `MeshGenerator.generate()` and before gmsh is finalized. Document this in the + docstring (mirrors how nodes are extracted today). +- Get element tags via `gmsh.model.mesh.getElements(dim=2)` and pass the + triangle tag array to `getElementQualities(tags, measure)` per measure name. + +### 2. New Voronoi connectivity + skewness functions (in `utils.py`) + +**Do not change `calculate_orthogonality`.** It keeps the same signature and +returns the same result (backward-compatible). Add new, separate functions: + +- `build_connectivity(gdf)` → GeoDataFrame of neighbor pairs with columns + `cell_id_1`, `cell_id_2`, `shared_edge` (geometry), `angle`, `skewness`. + - Find touching pairs and their shared edge using the same robust approach as + `calculate_orthogonality` (spatial self-join on touching cells, then + `intersection` to get the shared edge). Implement it within the new function + so the existing function's behavior is guaranteed untouched. + - **Connector = line between the two generator points** (`x`, `y` columns that + `VoronoiTessellator` already stores), not centroids. + - `angle` = orthogonality error in degrees between the connector and the shared + edge (the connector should be perpendicular to the face). + - `skewness` = fractional position along the connector where it crosses the + shared face, ideal `0.5`. Compute the connector∩face intersection; if empty, + project the face midpoint onto the connector (as gmshflow did at + `gmshflow.py:75-89`) — but using generator points and correct pair indices. +- A public **connectivity report** wrapper that returns the per-pair GeoDataFrame + for export (supersedes `gmshflow.calculate_cvfd_quality`). +- `calculate_mesh_quality` / `summarize_quality` gain an **optional** `skewness` + column (max `|skewness − 0.5|` per cell) + summary line, behind a flag so the + default output is unchanged. + +### Note on "angle between centroids" + +What the team referred to as "angle between centroids" is exactly orthogonality: +the cell-center connector should be perpendicular to the shared face. `vorflow` +already measures this from **generator points** (the proper CVFD cell center), so +no change is needed there — `build_connectivity` simply exposes the same quantity +per pair, plus skewness. + +## Verification + +- `tests/test_quality_metrics.py`: + - Build a small known mesh; assert `get_triangular_quality()` returns one row + per triangle with all expected columns and values in valid ranges + (`0 ≤ gamma ≤ 1`, `minSICN ∈ [-1, 1]`, etc.). + - On a regular grid of generators, assert orthogonality angle ≈ 90° and + skewness ≈ 0.5; assert `build_connectivity` produces **distinct** cell ids per + pair (regression against the gmshflow index bug). + - Assert `calculate_orthogonality` output is byte-for-byte unchanged vs the + current implementation (golden test). +- Extend `examples/field_capabilities_example.py` to print a triangular-quality + summary and a skewness summary. diff --git a/docs/roadmap/02-robust-clipping.md b/docs/roadmap/02-robust-clipping.md new file mode 100644 index 0000000..6018165 --- /dev/null +++ b/docs/roadmap/02-robust-clipping.md @@ -0,0 +1,65 @@ +# Milestone 2 - Active-Domain Filtering Workflow + +**Status:** replaced by example workflow | **Risk:** low | **Behavior change:** none +**Back to** [ROADMAP.md](../../ROADMAP.md) + +## Decision + +Do **not** add `min_cell_overlap`, `boundary_buffer`, or `active_domain` options +to `VoronoiTessellator` for now. + +The better default is to keep core tessellation simple: + +1. Build a mesh on the geometry the user wants as the mesh envelope. +2. Generate the Voronoi grid with the existing clipping behavior. +3. If the model's active domain is smaller than the mesh envelope, select or tag + active cells externally with GeoPandas. + +This keeps cell removal visible to the user instead of hiding it inside a +tessellator parameter. + +## Why + +Boundary sliver filtering is easy to do externally and can be risky if it happens +silently inside the core API. A low-overlap cell might be a real modeling choice, +not just a bad artifact. Removing it automatically can change the model topology +without enough user inspection. + +The larger-envelope workflow is also a different use case from clipping cleanup. +Users may deliberately mesh a convex hull, square extent, or buffered envelope so +the cells around the real active model boundary stay healthy. In that case the +right operation is not clipping cells to the active boundary; it is selecting or +tagging active cells after grid generation. + +## Example Workflow + +Add `examples/active_domain_quality_example.py` showing: + +- a baseline mesh whose mesh boundary equals the active model boundary; +- an improved mesh generated on a larger envelope; +- active-cell selection from the larger-envelope grid by centroid and overlap; +- centroid-based connectivity/quality comparisons for the two outputs. + +The example should use ordinary GeoPandas operations such as: + +```python +active_overlap = grid.geometry.intersection(active_domain).area / grid.geometry.area +grid["active_overlap_ratio"] = active_overlap +grid["is_active_by_overlap"] = active_overlap >= 0.5 +grid["is_active_by_centroid"] = grid.geometry.centroid.within(active_domain) +active_grid = grid[grid["is_active_by_centroid"]].copy() +``` + +## Verification + +- Run the new example with `MPLBACKEND=Agg` to confirm it executes headlessly. +- Keep full `pytest` green. +- No new unit tests are required for a core API because this milestone adds no + core API. + +## Future Revisit Criteria + +Promote active-domain filtering into core code only if the external workflow +becomes repetitive, error-prone, or needs library-managed metadata for downstream +export. Until then, prefer transparent GeoPandas selection in user code and +examples. diff --git a/docs/roadmap/03-boundary-mirror-points.md b/docs/roadmap/03-boundary-mirror-points.md new file mode 100644 index 0000000..0e47656 --- /dev/null +++ b/docs/roadmap/03-boundary-mirror-points.md @@ -0,0 +1,82 @@ +# Milestone 3 — Boundary mirror points (opt-in) + +**Status:** planned · **Risk:** medium · **Behavior change:** none by default +**Back to** [ROADMAP.md](../../ROADMAP.md) + +## Goal + +Give boundary Voronoi cells properly-centered generators and perpendicular +boundary faces, **adapting to variable cell sizes** along the domain edge. This +is the principled replacement for `gmshflow`'s empirical global `cs_dom/3` +pre-buffer. + +The current `gpd.clip`-to-domain stays the **default**; mirror points are +strictly **opt-in**. + +## Why + +When a boundary generator node sits exactly on the domain edge, `gpd.clip` chops +its cell into a half-cell with the generator on a face — poor for CVFD +(cell center on the face). A single global outward buffer (`cs_dom/3`) softens +this but is wrong when cell size varies along the boundary (too much where cells +are small, too little where large). + +**Mirror/reflection points** fix this in a size-adaptive way: for each boundary +generator node, add a ghost node mirrored just outside the local boundary. The +Voronoi edge between the node and its mirror then lands exactly on the boundary, +producing a centered boundary cell with a clean perpendicular face. Because each +node is mirrored by its **own local offset**, variable sizes are handled +automatically. + +`vorflow` already densifies and embeds the domain boundary, so the boundary nodes +are known and mirroring is tractable. + +## Files to touch + +- `src/vorflow/tessellator.py` — mirror-point generation + integration with the + raw Voronoi build (`_build_raw_voronoi` adds the 4 far ghost nodes today; mirror + points are an additional, opt-in ghost set). +- `src/vorflow/engine.py` — expose boundary generator nodes / boundary polyline if + not already available to the tessellator. +- `tests/test_voronoi_tessellator.py` — extend. + +## Detail + +Add an opt-in flag (e.g. `boundary_mirror: bool = False`, plus tuning params). +When enabled: + +1. Identify boundary generator nodes and the local boundary segment/normal at + each (from the embedded, densified domain boundary). +2. For each boundary node, place a reflected ghost node across the local boundary + at an offset clamped to the **local node spacing** (so the Voronoi face lands + on the boundary). +3. Build the Voronoi with these extra ghosts; the mirror ghosts' cells are + discarded (like the existing far ghost nodes). + +### Corner-aware handling (important) + +The team's concern is **weird angles among adjacent boundary cells**, not interior +cells. Mirror reflection misbehaves at sharp convex/concave corners and where +boundary spacing is irregular (mirrors can overlap or skew). So: + +- Detect sharp corners (turn angle threshold) and **limit or skip** mirrors there. +- **Clamp** the mirror offset to local node spacing. +- Optionally fall back to plain clipping in flagged corner neighborhoods. + +### Diagnostics + +Reuse Milestone 1's `build_connectivity` helper, restricted to boundary cells, to +report the boundary-cell **angle distribution before vs after** enabling mirror +points — so the effect is measurable and corner regressions are visible. + +## Verification + +- `tests/test_voronoi_tessellator.py`: + - Default (mirror off) reproduces current output exactly. + - On a straight-edged domain with uniform spacing, boundary-cell orthogonality + improves toward 90° with mirror on. + - On a graded-size boundary, assert mirror offsets scale with local spacing. + - On a domain with a sharp corner, assert no degenerate/overlapping boundary + cells are produced (corner handling regression test). +- Visual check via an example: overlay boundary cells with mirror on/off and + inspect the angle-distribution diagnostic. diff --git a/docs/roadmap/04-structured-quad-buffer.md b/docs/roadmap/04-structured-quad-buffer.md new file mode 100644 index 0000000..fb81e48 --- /dev/null +++ b/docs/roadmap/04-structured-quad-buffer.md @@ -0,0 +1,108 @@ +# Milestone 4 — Structured-quad transfinite buffer (OCC) + +**Status:** planned · **Risk:** high · **Behavior change:** opt-in +**Back to** [ROADMAP.md](../../ROADMAP.md) + +## Goal + +Port `gmshflow`'s transfinite **structured-quad buffer-surface** system for +**line and polygon** features into `vorflow`'s OCC pipeline, as an opt-in robust +alternative to the current straddle approach. It produces sharp, regular boundary +alignment of Voronoi cells along a feature. + +The existing lightweight **straddle** path stays as-is; this buffer is the +heavier, higher-fidelity option. **Keep both.** + +## Why + +- `gmshflow` builds a thin transfinite quad strip hugging each feature: + - Lines: `create_surfacegrid_from_buffer_line` (`../gmshflow/src/gmshflow.py:992-1123`). + - Polygons: `create_surfacegrid_from_buffer_poly` (`gmshflow.py:776-868`). + - `offset_curve(±cs_thick*cs/2)` on each side, build curve loops, a plane + surface, set transfinite curves/surface, `setRecombine`, mesh algorithm 8 + (frontal-Delaunay for quads). + - `cs_thick = 1` ⇒ a sharp boundary (two node rows `cs/2` apart ⇒ Voronoi edge + lands exactly on the feature); `cs_thick = 2` ⇒ a quasi-rectangular zone. + - Asserts `cs_thick ∈ {1, 2}` because thicker strips give bad quads. +- `vorflow`'s straddle (in `src/vorflow/engine.py`) is the simpler dual-row of + offset points. It is conceptually the same idea but without structured control + of along-feature spacing. + +## Scope (agreed) + +- **Lines and polygons**, `cs_thick ∈ {1, 2}` only. +- **Per-feature `cs` preserved** (each feature row carries its own cell size; + transfinite divisions computed from it). Graded widening **away** from the + feature is left to the field system (`fields.py`) — do **not** extend + `cs_thick > 2`. +- Straddle remains the lightweight default path; the buffer is opt-in. + +## Files to touch + +- `src/vorflow/buffer.py` (new) **or** methods on `MeshGenerator` in + `src/vorflow/engine.py`. +- `src/vorflow/engine.py` — reuse the existing post-`removeAllDuplicates` / + `healShapes` **coordinate/bbox tag-remap** machinery; factor out the straddle's + corridor-protection logic (below). +- `tests/test_buffer.py` (new). + +## Detail + +### OCC integration (the hard part) + +`vorflow` runs `occ.fragment` + `removeAllDuplicates`, which **re-tags and can +split surfaces** — this would destroy a 4-corner transfinite structure if applied +naively. Approach: + +1. Create the buffer surfaces (offset curves → loops → plane surfaces). +2. Run the normal `occ.fragment` + `removeAllDuplicates` (+ optional + `healShapes`). +3. **Relocate the buffer surfaces by coordinate/bbox match** after fragmentation, + reusing the same remap logic `engine.py` already uses to track killed/remapped + tags. +4. **Apply transfinite + recombine to the relocated surfaces** (post-fragment), + so re-tagging cannot break the structured constraint. + +`setTransfiniteCurve/Surface` and `setRecombine` are mesh-level ops and work on +OCC surfaces — the issue is purely ordering vs fragmentation. + +### Shared feature-corridor protection (improvement over gmshflow) + +The straddle path already **differences-out other features within a corridor** +around the barrier so nothing else injects nodes into that zone. The transfinite +strip needs the **same** protection to mesh cleanly. So: + +- Factor that corridor-protection step out of the straddle code into a **shared + helper** used by **both** straddle and the structured buffer. +- This is a genuine improvement over `gmshflow`, which had no such protection (it + only warned that feature lines must not intersect — `gmshflow.py:1022`). + +### offset_curve artifacts + +`offset_curve` can occasionally emit a `MultiLineString` (GEOS). `gmshflow` worked +around this with `merge_many_multilinestring_into_one_linestring` +(`gmshflow.py:94-125`). Shapely 2.x is more robust but can still split on +self-intersections. **Only** add a localized merge if the port actually +encounters it — do not vendor it preemptively. + +## Interaction with other milestones + +- **Milestone 5 (triangular-grid output) must be designed together with this + one:** quad recombination here produces a **mixed** tri/quad mesh, which a + "triangular-only" mode must either disable or explicitly support. Define the + behavior jointly. + +## Verification + +- `tests/test_buffer.py`: + - A single straight line with `cs_thick=1` yields a Voronoi boundary that + follows the line within tolerance (sharp alignment). + - `cs_thick=2` yields a quasi-rectangular band of cells along the feature. + - A polygon feature yields a clean buffered band around its boundary. + - With two **crossing** features, the shared corridor-protection step prevents + node injection / meshing failure (regression vs the gmshflow non-intersecting + assumption). + - Transfinite/recombine survive `occ.fragment` (surfaces correctly relocated + and structured after fragmentation). +- Example: add a structured buffer on a line and a polygon to an example script + and visually confirm alignment + quad structure. diff --git a/docs/roadmap/05-triangular-grid-output.md b/docs/roadmap/05-triangular-grid-output.md new file mode 100644 index 0000000..a0571d3 --- /dev/null +++ b/docs/roadmap/05-triangular-grid-output.md @@ -0,0 +1,66 @@ +# Milestone 5 — Triangular-grid output option + +**Status:** planned · **Risk:** low–medium · **Behavior change:** opt-in +**Back to** [ROADMAP.md](../../ROADMAP.md) + +## Goal + +Allow the final product to be a plain **triangular grid** (the gmsh 2D triangle +mesh) instead of the Voronoi dual — useful when a triangular FE/FV grid is wanted +directly. Captured now (rather than later) because it **interacts with the quad +recombination** of Milestone 4 and we want to avoid an architectural clash. + +## Why + +The current pipeline always produces Voronoi cells via `VoronoiTessellator`. Some +workflows want the triangular mesh itself as the deliverable. The MeshGenerator +already extracts node coordinates; this path additionally needs the **triangle +element connectivity**. + +## Approach to explore (decide during execution) + +Two viable shapes — pick during implementation: + +- **(a) A flag on the existing pipeline** — e.g. `tessellate=False` or + `output="triangular"` — that short-circuits before the Voronoi step and returns + a triangle-cell GeoDataFrame. +- **(b) A separate lightweight exporter** that reads `gmsh.model.mesh` triangle + elements + node coordinates and builds the triangle-cell GeoDataFrame, bypassing + `VoronoiTessellator` entirely. + +Both need: `gmsh.model.mesh.getElements(dim=2)` for triangle connectivity + +`getNodes` for coordinates, assembled into shapely triangles → GeoDataFrame +(carrying zone ids the same way the Voronoi path does). + +## Files to touch + +- `src/vorflow/engine.py` and/or `src/vorflow/tessellator.py` — depending on + approach (a) vs (b). +- `tests/` — new tests for the triangular path. + +## Architectural watch-outs (the reason this is captured now) + +- **Clash with Milestone 4:** quad recombination / transfinite buffers produce a + **mixed** tri/quad mesh. A "triangular-only" mode must either: + - disable recombination (no structured buffers in this mode), **or** + - explicitly support a mixed-element grid (triangles + quads) in the output. + Define and document the chosen behavior; design jointly with Milestone 4. +- **Skip Voronoi-only steps:** mirror points (Milestone 3) are Voronoi-specific + and must be **skipped** on the triangular path. Active-domain filtering from + Milestone 2 remains an external GeoPandas workflow and can be applied to any + polygonal grid after export. +- **Quality reporting differs:** the triangular grid uses Milestone 1's + `get_triangular_quality()` (element metrics), **not** the Voronoi + connectivity/orthogonality/skewness report. + +## Keep it additive + +This must be opt-in and additive so the default Voronoi pipeline is unchanged. + +## Verification + +- New test: with the triangular option enabled, the output GeoDataFrame contains + triangle polygons matching the gmsh element count, with zone ids assigned. +- With Milestone 4 buffers present, assert the documented mixed-vs-disabled + behavior holds (no silent loss of quad regions, or a clear error/te disable). +- Default Voronoi output unchanged when the option is off. diff --git a/docs/roadmap/06-pypi-publishing.md b/docs/roadmap/06-pypi-publishing.md new file mode 100644 index 0000000..86af556 --- /dev/null +++ b/docs/roadmap/06-pypi-publishing.md @@ -0,0 +1,88 @@ +# Milestone 6 — First PyPI release + +**Status:** in progress · **Current target:** TestPyPI `0.1.0rc1` · **Risk:** low · **Behavior change:** none (packaging/metadata only) +**Back to** [ROADMAP.md](../../ROADMAP.md) + +## Goal + +Publish `vorflow` to PyPI so users can `pip install vorflow`. The name is +**available on PyPI** (verified 2026-07-18: the registry returns 404 for +`vorflow`). + +This milestone is being rehearsed on TestPyPI first. The rehearsal stops after +verifying `0.1.0rc1`; real PyPI publication remains a separate approval gate. + +## Current state (release candidate prepared locally) + +- Explicit PEP 621/639 metadata for `0.1.0rc1`, with Oscar Sanchez as primary + author and maintainer and rhugman retained as an original author. +- MIT SPDX metadata, dependency floors, keywords, repository links, changelog, + and absolute README links suitable for package-index rendering. +- One canonical Basic Usage script that runs against an installed wheel. +- Cross-platform CI plus a Python 3.10 job for the six exact dependency floors. +- Automated wheel/sdist content and built-metadata validation. +- A `v*rc*` GitHub Actions workflow that builds once and publishes only to + TestPyPI through the protected `testpypi` environment and short-lived OIDC + credentials. +- `__version__` resolved from installed metadata, with a neutral source-tree + fallback instead of a duplicated release number. + +The local rehearsal passes Ruff, the full test suite, isolated archive builds, +Twine checks, archive validation, fresh-wheel installation, `pip check`, and +the Basic Usage example outside the source tree. + +## Completed release preparation + +- [x] Integrate `gmshflow_missing` into local `main` after full verification. +- [x] Prepare and validate the `0.1.0rc1` wheel and source distribution. +- [x] Smoke-test the wheel in a fresh environment outside the repository. +- [x] Add PyPI-facing installation documentation and absolute links. +- [x] Add and test runtime dependency floors without upper caps. +- [x] Confirm public authorship and maintainer metadata without publishing + rhugman's email. +- [x] Add the changelog, modern licence metadata, and package keywords. +- [x] Add an RC-only, TestPyPI-only Trusted Publishing workflow. + +## Remaining TestPyPI rehearsal + +- [ ] Address release code-review findings and integrate the focused release + branch into `main`. +- [ ] Create and push the annotated `v0.1.0rc1` tag. +- [ ] Review the GitHub build and manually approve the protected `testpypi` + deployment. +- [ ] Inspect the TestPyPI project page and install `0.1.0rc1` independently. +- [ ] Record the result as **TestPyPI verified**. Real PyPI publication remains + a separate approval gate. + +## Phase 3 — Nice-to-have (can follow in later 0.x releases) + +- [ ] **Python 3.13/3.14 in the CI matrix and classifiers.** The local dev + env is already on 3.14, so it is implicitly supported but untested in CI. +- [ ] **Docs site** (mkdocs-material + API reference on GitHub Pages or + ReadTheDocs) and a `Documentation` URL in `[project.urls]`. The README is + sufficient for an alpha. +- [ ] **Citation/DOI** (`CITATION.cff` + Zenodo) — worthwhile for a + research-audience package. +- [ ] **conda-forge feedstock.** The MODFLOW/flopy user base is heavily + conda-based. Do this after the PyPI release stabilizes, since conda-forge + builds from the published sdist. + +## Release sequence + +1. Integrate the reviewed release branch into `main`. +2. Tag `v0.1.0rc1`; only the `v*rc*` TestPyPI workflow can match. +3. Let GitHub rebuild, retest, and validate one wheel and one sdist. +4. Review the build results, then manually approve the protected `testpypi` + deployment. +5. Verify the rendered TestPyPI page and an independent installation, then stop + before real PyPI. + +## Verification + +- `twine check dist/*` passes; sdist/wheel contain only the package and + standard metadata. +- README Basic Usage example runs against the installed wheel in a clean venv. +- TestPyPI project page renders with no broken links before the real upload. +- After the rehearsal: install `vorflow==0.1.0rc1` from TestPyPI in a fresh + environment and confirm `vorflow.__version__` matches the tag. +- Real PyPI publication remains pending a separate review and approval. diff --git a/docs/superpowers/plans/2026-07-21-testpypi-release.md b/docs/superpowers/plans/2026-07-21-testpypi-release.md new file mode 100644 index 0000000..086eb3c --- /dev/null +++ b/docs/superpowers/plans/2026-07-21-testpypi-release.md @@ -0,0 +1,1200 @@ +# TestPyPI Release Rehearsal Implementation Plan + +> **For agentic workers:** REQUIRED SUB-SKILL: Use superpowers:subagent-driven-development (recommended) or superpowers:executing-plans to implement this plan task-by-task. Steps use checkbox (`- [ ]`) syntax for tracking. + +**Goal:** Build, validate, and publish `vorflow==0.1.0rc1` to TestPyPI through a manually approved GitHub Trusted Publishing workflow, then stop before real PyPI. + +**Architecture:** Keep the release version and metadata in `pyproject.toml`, validate the generated wheel and source distribution with a repository script, and build the archives once in a tag-triggered GitHub job. A separate least-privilege publish job downloads those exact archives, pauses at the protected `testpypi` environment, and uploads only to TestPyPI. + +**Tech Stack:** Python 3.10-3.12, setuptools 77+, pytest, Ruff, `build`, Twine, GitHub Actions, PyPI Trusted Publishing (OIDC), TestPyPI. + +## Global Constraints + +- Start release implementation only after `gmshflow_missing` is integrated into a clean `main`; preserve all unrelated user changes. +- Candidate version is exactly `0.1.0rc1`; reserve `0.1.0` for a future production release. +- Do not change mesh-generation behaviour or public runtime APIs. +- Do not create a real-PyPI job, environment, credential, tag, or upload. +- Oscar is the primary author and current maintainer; retain rhugman as an original author without an email in package metadata. +- Keep the existing MIT copyright notice unchanged. +- Runtime floors are `numpy>=1.24`, `pandas>=1.5`, `geopandas>=0.13`, `shapely>=2.0`, `scipy>=1.10`, and `gmsh>=4.11`; add no upper caps. +- Test the exact available floor releases `numpy==1.24.0`, `pandas==1.5.0`, `geopandas==0.13.0`, `shapely==2.0.0`, `scipy==1.10.0`, and `gmsh==4.11.1` on Python 3.10. +- TestPyPI account registration, email verification, recovery settings, and publishing approval are user-owned manual steps. Never request or store passwords, recovery codes, two-factor codes, or API tokens. +- TestPyPI is temporary rehearsal infrastructure, not a permanent release archive. + +## Pre-execution Gate + +Before Task 1, use `superpowers:finishing-a-development-branch` to review and integrate `gmshflow_missing`. Do not automatically stage the current unrelated files under `docs/assets/`, `docs/auto-exponential-field-math-review.md`, or `benchmarks/`. + +Verify the baseline: + +```powershell +git branch --show-current +git status --short +git log -1 --oneline +``` + +Expected after integration: branch `main`, an empty status, and `main` containing design commits `ec0964d` and `612eab8`. Create a focused release-preparation branch or worktree before Task 1. + +## File Structure + +**Create:** + +- `CHANGELOG.md` — release-candidate history. +- `MANIFEST.in` — explicit source-distribution exclusions. +- `examples/basic_usage.py` — canonical runnable smoke example. +- `scripts/check_dist.py` — archive and built-metadata validator. +- `tests/test_check_dist.py` — focused validator tests. +- `tests/test_release_metadata.py` — static release-metadata tests. +- `.github/workflows/testpypi.yml` — tag-triggered TestPyPI build and publish workflow. + +**Modify:** + +- `.gitignore` — ignore `.superpowers/` visual state. +- `ROADMAP.md` — one active milestone plus completed history. +- `docs/roadmap/06-pypi-publishing.md` — candidate scope and status. +- `pyproject.toml` — version, authorship, dependencies, licence, keywords, build and release tools. +- `src/vorflow/__init__.py` — non-duplicated source fallback. +- `README.md` — PyPI install path, absolute links, canonical example, optional export note. +- `.github/workflows/python-app.yml` — minimum-dependency CI job. + +--- + +### Task 1: Establish the Current Roadmap and Ignore Local Visual State + +**Files:** + +- Modify: `.gitignore` +- Modify: `ROADMAP.md` +- Modify: `docs/roadmap/06-pypi-publishing.md` + +**Interfaces:** + +- Consumes: approved release design in `docs/superpowers/specs/2026-07-20-testpypi-release-design.md`. +- Produces: one active roadmap objective, preserved completed history, and no tracked `.superpowers/` state. + +- [ ] **Step 1: Inspect the user's existing roadmap edits before changing them** + +```powershell +git diff -- ROADMAP.md docs/roadmap/06-pypi-publishing.md .gitignore +``` + +Expected: reviewable output; do not overwrite text that is not superseded by the approved design. + +- [ ] **Step 2: Ignore the visual companion directory** + +Add this exact entry beside other local development exclusions in `.gitignore`: + +```gitignore +# Superpowers visual brainstorming state +.superpowers/ +``` + +- [ ] **Step 3: Replace the stale roadmap sequencing with current/completed sections** + +Preserve the existing context and decisions, but make the milestone area read: + +```markdown +## Current Objective + +| # | Milestone | Status | Risk | Behavior change | Doc | +|---|-----------|--------|------|-----------------|-----| +| 6 | First PyPI release | In progress | Low | None (packaging only) | [06-pypi-publishing.md](docs/roadmap/06-pypi-publishing.md) | + +The current release scope is a `0.1.0rc1` TestPyPI rehearsal. A successful +rehearsal changes this status to **TestPyPI verified**. The milestone becomes +**Done** only after `vorflow` is published to real PyPI. + +## Completed Milestones + +| # | Milestone | Status | Doc | +|---|-----------|--------|-----| +| 1 | Quality metrics | Done | [01-quality-metrics.md](docs/roadmap/01-quality-metrics.md) | +| 2 | Active-domain filtering workflow | Done (example) | [02-robust-clipping.md](docs/roadmap/02-robust-clipping.md) | +| 3 | Boundary inset/mirror points | Done | [03-boundary-mirror-points.md](docs/roadmap/03-boundary-mirror-points.md) | +| 4 | Structured-quad transfinite buffer | Done | [04-structured-quad-buffer.md](docs/roadmap/04-structured-quad-buffer.md) | +| 5 | Triangular/mixed element-grid output | Done | [05-triangular-grid-output.md](docs/roadmap/05-triangular-grid-output.md) | +``` + +Remove `Suggested Sequencing`, because it describes already completed work. Keep the completed-capability summary and verification history. + +- [ ] **Step 4: Mark the detailed publishing milestone as in progress** + +Change its header metadata to: + +```markdown +**Status:** in progress · **Current target:** TestPyPI `0.1.0rc1` · **Risk:** low · **Behavior change:** none (packaging/metadata only) +``` + +Add a scope note immediately after the goal: + +```markdown +This milestone is being rehearsed on TestPyPI first. The rehearsal stops after +verifying `0.1.0rc1`; real PyPI publication remains a separate approval gate. +``` + +- [ ] **Step 5: Verify the roadmap no longer contains obsolete sequencing** + +```powershell +rg -n "Current Objective|Completed Milestones|TestPyPI|Suggested Sequencing|Implement the remaining" ROADMAP.md docs/roadmap/06-pypi-publishing.md +git diff --check +``` + +Expected: current/completed headings and TestPyPI scope are found; obsolete sequencing phrases are absent; `git diff --check` is silent. + +- [ ] **Step 6: Commit the roadmap cleanup** + +```powershell +git add .gitignore ROADMAP.md docs/roadmap/06-pypi-publishing.md +git commit -m "docs: focus roadmap on TestPyPI release" +``` + +### Task 2: Make Release Metadata Explicit and Testable + +**Files:** + +- Create: `tests/test_release_metadata.py` +- Modify: `pyproject.toml` +- Modify: `src/vorflow/__init__.py` + +**Interfaces:** + +- Consumes: PEP 621/639 metadata through setuptools. +- Produces: authoritative version `0.1.0rc1` and runtime `vorflow.__version__` from installed metadata. + +- [ ] **Step 1: Write failing static metadata tests** + +Create `tests/test_release_metadata.py`: + +```python +from pathlib import Path + +try: + import tomllib +except ModuleNotFoundError: # Python 3.10 + import tomli as tomllib + + +ROOT = Path(__file__).resolve().parents[1] + + +def test_release_metadata_is_complete(): + with (ROOT / "pyproject.toml").open("rb") as stream: + data = tomllib.load(stream) + + project = data["project"] + assert data["build-system"]["requires"] == ["setuptools>=77.0.3"] + assert project["version"] == "0.1.0rc1" + assert project["license"] == "MIT" + assert project["license-files"] == ["LICENSE"] + assert project["authors"] == [ + {"name": "Oscar Sanchez", "email": "oscarfasanchez@gmail.com"}, + {"name": "rhugman"}, + ] + assert project["maintainers"] == [ + {"name": "Oscar Sanchez", "email": "oscarfasanchez@gmail.com"} + ] + assert project["dependencies"] == [ + "numpy>=1.24", + "pandas>=1.5", + "geopandas>=0.13", + "shapely>=2.0", + "scipy>=1.10", + "gmsh>=4.11", + ] + assert "License :: OSI Approved :: MIT License" not in project["classifiers"] + + +def test_source_fallback_is_not_a_duplicate_release_version(): + source = (ROOT / "src" / "vorflow" / "__init__.py").read_text(encoding="utf-8") + assert '__version__ = "0+unknown"' in source + assert '__version__ = "0.0.2"' not in source +``` + +- [ ] **Step 2: Run the tests and confirm they fail for the current metadata** + +```powershell +python -m pip install "tomli>=2; python_version < '3.11'" +pytest tests/test_release_metadata.py -v +``` + +Expected: failures showing `setuptools>=61.0`, version `0.0.2`, legacy licence metadata, unbounded dependencies, and the duplicated fallback. + +- [ ] **Step 3: Update `pyproject.toml` metadata** + +Apply these exact values: + +```toml +[build-system] +requires = ["setuptools>=77.0.3"] +build-backend = "setuptools.build_meta" + +[project] +name = "vorflow" +version = "0.1.0rc1" +description = "Voronoi mesh generation for MODFLOW 6 using Gmsh and GeoPandas" +readme = "README.md" +license = "MIT" +license-files = ["LICENSE"] +authors = [ + {name = "Oscar Sanchez", email = "oscarfasanchez@gmail.com"}, + {name = "rhugman"}, +] +maintainers = [ + {name = "Oscar Sanchez", email = "oscarfasanchez@gmail.com"}, +] +requires-python = ">=3.10" +keywords = ["modflow", "groundwater", "voronoi", "mesh", "gmsh"] +classifiers = [ + "Development Status :: 3 - Alpha", + "Intended Audience :: Science/Research", + "Programming Language :: Python :: 3", + "Programming Language :: Python :: 3.10", + "Programming Language :: Python :: 3.11", + "Programming Language :: Python :: 3.12", + "Topic :: Scientific/Engineering :: Hydrology", +] +dependencies = [ + "numpy>=1.24", + "pandas>=1.5", + "geopandas>=0.13", + "shapely>=2.0", + "scipy>=1.10", + "gmsh>=4.11", +] +``` + +Add the changelog URL and release tools: + +```toml +[project.urls] +Repository = "https://github.com/oscarfasanchez/vorflow_os" +Issues = "https://github.com/oscarfasanchez/vorflow_os/issues" +Changelog = "https://github.com/oscarfasanchez/vorflow_os/blob/main/CHANGELOG.md" + +[project.optional-dependencies] +dev = [ + "pytest", + "pytest-cov", + "black", + "ruff", + "jupyter", + "matplotlib", + "build>=1.2", + "twine>=6", + "tomli>=2; python_version < '3.11'", +] +``` + +Keep the existing `examples` extra unchanged. + +- [ ] **Step 4: Replace the duplicate fallback in `src/vorflow/__init__.py`** + +```python +from importlib.metadata import PackageNotFoundError, version + +try: + __version__ = version("vorflow") +except PackageNotFoundError: + __version__ = "0+unknown" +``` + +Leave the imports, public classes, logging setup, and `__all__` unchanged. + +- [ ] **Step 5: Run the focused tests** + +```powershell +pytest tests/test_release_metadata.py -v +``` + +Expected: `2 passed`. + +- [ ] **Step 6: Commit the metadata change** + +```powershell +git add pyproject.toml src/vorflow/__init__.py tests/test_release_metadata.py +git commit -m "build: prepare 0.1.0rc1 metadata" +``` + +### Task 3: Create a Canonical Basic Usage Example and PyPI-Facing Documentation + +**Files:** + +- Create: `examples/basic_usage.py` +- Create: `CHANGELOG.md` +- Modify: `README.md` + +**Interfaces:** + +- Consumes: public `ConceptualMesh`, `MeshGenerator`, and `VoronoiTessellator` APIs. +- Produces: `main()` returning a non-empty GeoDataFrame and a README that renders outside GitHub. + +- [ ] **Step 1: Add a failing test for the canonical example** + +Append to `tests/test_release_metadata.py`: + +```python +import os +import subprocess +import sys + + +def test_basic_usage_script_runs_from_a_clean_directory(tmp_path): + env = os.environ.copy() + env["PYTHONPATH"] = str(ROOT / "src") + result = subprocess.run( + [sys.executable, str(ROOT / "examples" / "basic_usage.py")], + cwd=tmp_path, + env=env, + capture_output=True, + text=True, + timeout=180, + check=False, + ) + assert result.returncode == 0, result.stderr + assert "Generated " in result.stdout + assert " Voronoi cells" in result.stdout +``` + +- [ ] **Step 2: Run the test and verify the missing script causes failure** + +```powershell +pytest tests/test_release_metadata.py::test_basic_usage_script_runs_from_a_clean_directory -v +``` + +Expected: FAIL because `examples/basic_usage.py` does not exist. + +- [ ] **Step 3: Create `examples/basic_usage.py`** + +```python +"""Minimal end-to-end vorflow example used by release smoke tests.""" + +from shapely.geometry import LineString, Point, box + +from vorflow import ConceptualMesh, MeshGenerator, VoronoiTessellator + + +def main(): + domain = box(0, 0, 200, 200) + well_point = Point(25, 25) + fault_line = LineString([(100, 0), (100, 150)]) + + blueprint = ConceptualMesh(crs="EPSG:3857") + blueprint.add_polygon(domain, zone_id=1) + blueprint.add_point( + well_point, + point_id="Well-A", + resolution=2, + growth_factor=1.2, + ) + blueprint.add_line( + fault_line, + line_id="Fault-1", + resolution=1, + is_barrier=True, + ) + + clean_polys, clean_lines, clean_pts = blueprint.generate() + mesher = MeshGenerator(background_lc=100) + mesher.generate(clean_polys, clean_lines, clean_pts) + + tessellator = VoronoiTessellator(mesher, blueprint, clip_to_boundary=True) + grid_gdf = tessellator.generate() + if grid_gdf.empty: + raise RuntimeError("Basic Usage generated an empty Voronoi grid") + return grid_gdf + + +if __name__ == "__main__": + grid = main() + print(f"Generated {len(grid)} Voronoi cells") +``` + +- [ ] **Step 4: Run the canonical example test** + +```powershell +pytest tests/test_release_metadata.py::test_basic_usage_script_runs_from_a_clean_directory -v +``` + +Expected: PASS and subprocess output containing `Generated ... Voronoi cells`. + +- [ ] **Step 5: Rewrite the README installation section** + +Use this exact structure: + +````markdown +## Installation + +Install the latest published release: + +```bash +pip install vorflow +``` + +`vorflow` requires Python 3.10 or newer. + +### Development installation + +Clone the repository and install it in editable mode: + +```bash +pip install -e .[dev] +``` + +For plotting examples and notebooks without all development tools: + +```bash +pip install -e .[examples] +``` + +Alternatively, create the Conda development environment from +[`etc/environment.yml`](https://github.com/oscarfasanchez/vorflow_os/blob/main/etc/environment.yml). +```` + +Keep the Basic Usage code aligned with `examples/basic_usage.py`, stop after the non-empty GeoDataFrame is created, and add: + +````markdown +### Optional file export + +GeoPandas writes formats such as Shapefile and GeoPackage through an I/O engine +such as Pyogrio or Fiona. Install one of those engines before calling: + +```python +grid_gdf.to_file("mf6_grid.gpkg", driver="GPKG") +``` +```` + +Replace repository-relative links with: + +```markdown +[examples/](https://github.com/oscarfasanchez/vorflow_os/tree/main/examples) +[ROADMAP.md](https://github.com/oscarfasanchez/vorflow_os/blob/main/ROADMAP.md) +[LICENSE](https://github.com/oscarfasanchez/vorflow_os/blob/main/LICENSE) +``` + +- [ ] **Step 6: Create `CHANGELOG.md`** + +```markdown +# Changelog + +All notable changes to `vorflow` are documented in this file. + +The format follows [Keep a Changelog](https://keepachangelog.com/en/1.1.0/), +and the project uses [Semantic Versioning](https://semver.org/spec/v2.0.0.html). + +## [Unreleased] + +## [0.1.0rc1] - 2026-07-21 + +### Added + +- Voronoi and triangular/mixed-element grid generation for MODFLOW 6 workflows. +- Mesh-quality and connectivity diagnostics. +- Optional boundary inset/mirror points and structured quad buffers. +- Explicit mesh-size growth fields and runnable examples. +- Cross-platform tests and TestPyPI release automation. + +### Changed + +- Prepared project metadata, installation documentation, and dependency floors + for the first public release candidate. + +[Unreleased]: https://github.com/oscarfasanchez/vorflow_os/compare/v0.1.0rc1...HEAD +[0.1.0rc1]: https://github.com/oscarfasanchez/vorflow_os/tree/v0.1.0rc1 +``` + +- [ ] **Step 7: Check links and documentation whitespace** + +```powershell +rg -n "\]\((examples/|ROADMAP.md|LICENSE|etc/environment.yml)\)" README.md +git diff --check +``` + +Expected: the relative-link search returns no matches; whitespace check is silent. + +- [ ] **Step 8: Commit the example and documentation** + +```powershell +git add README.md CHANGELOG.md examples/basic_usage.py tests/test_release_metadata.py +git commit -m "docs: add release candidate usage and changelog" +``` + +### Task 4: Enforce Distribution Contents and Built Metadata + +**Files:** + +- Create: `MANIFEST.in` +- Create: `scripts/check_dist.py` +- Create: `tests/test_check_dist.py` +- Modify: `pyproject.toml` + +**Interfaces:** + +- Consumes: a directory containing one wheel and one `.tar.gz` source distribution. +- Produces: exit code 0 for valid `vorflow` archives; a descriptive exception and nonzero exit for forbidden contents or incorrect metadata. + +- [ ] **Step 1: Write failing validator unit tests** + +Create `tests/test_check_dist.py`: + +```python +import importlib.util +from pathlib import Path + + +ROOT = Path(__file__).resolve().parents[1] +SCRIPT = ROOT / "scripts" / "check_dist.py" +SPEC = importlib.util.spec_from_file_location("check_dist", SCRIPT) +check_dist = importlib.util.module_from_spec(SPEC) +assert SPEC.loader is not None +SPEC.loader.exec_module(check_dist) + + +def test_version_from_tag(): + assert check_dist.version_from_tag("v0.1.0rc1") == "0.1.0rc1" + + +def test_version_from_tag_rejects_production_tag(): + try: + check_dist.version_from_tag("v0.1.0") + except ValueError as error: + assert "release-candidate" in str(error) + else: + raise AssertionError("production tag was accepted") + + +def test_forbidden_members_are_reported(): + members = [ + "vorflow-0.1.0rc1/src/vorflow/__init__.py", + "vorflow-0.1.0rc1/docs/private-plan.md", + "vorflow-0.1.0rc1/src/vorflow/vorflow.code-workspace", + ] + assert check_dist.forbidden_members(members) == [members[1], members[2]] +``` + +- [ ] **Step 2: Run the tests and confirm import failure** + +```powershell +pytest tests/test_check_dist.py -v +``` + +Expected: collection fails because `scripts/check_dist.py` does not exist. + +- [ ] **Step 3: Create `scripts/check_dist.py`** + +```python +"""Validate vorflow wheel/sdist contents and release metadata.""" + +from __future__ import annotations + +import argparse +from email.parser import BytesParser +from email.policy import default +from pathlib import Path, PurePosixPath +import tarfile +import zipfile + + +FORBIDDEN_DIRECTORIES = {".conda", "benchmarks", "docs", "__pycache__"} +EXPECTED_REQUIREMENTS = { + "numpy>=1.24", + "pandas>=1.5", + "geopandas>=0.13", + "shapely>=2.0", + "scipy>=1.10", + "gmsh>=4.11", +} + + +def version_from_tag(tag: str) -> str: + if not tag.startswith("v") or "rc" not in tag: + raise ValueError(f"expected a release-candidate tag, received {tag!r}") + return tag[1:] + + +def forbidden_members(names: list[str]) -> list[str]: + result = [] + for name in names: + parts = PurePosixPath(name).parts + if ( + any(part in FORBIDDEN_DIRECTORIES for part in parts) + or name.endswith(".code-workspace") + or name.endswith((".pyc", ".pyo")) + ): + result.append(name) + return result + + +def _one(directory: Path, pattern: str) -> Path: + matches = sorted(directory.glob(pattern)) + if len(matches) != 1: + raise ValueError(f"expected one {pattern} in {directory}, found {matches}") + return matches[0] + + +def _require_suffix(names: list[str], suffix: str) -> None: + if not any(name.endswith(suffix) for name in names): + raise ValueError(f"archive is missing required path ending in {suffix!r}") + + +def _normalized_requirement(value: str) -> str: + return value.replace(" ", "") + + +def validate_wheel(wheel: Path, expected_version: str) -> None: + with zipfile.ZipFile(wheel) as archive: + names = archive.namelist() + bad = forbidden_members(names) + if bad: + raise ValueError(f"wheel contains forbidden members: {bad}") + _require_suffix(names, "vorflow/__init__.py") + _require_suffix(names, ".dist-info/licenses/LICENSE") + metadata_name = next( + (name for name in names if name.endswith(".dist-info/METADATA")), + None, + ) + if metadata_name is None: + raise ValueError("wheel has no .dist-info/METADATA") + metadata = BytesParser(policy=default).parsebytes(archive.read(metadata_name)) + + if metadata["Name"].lower().replace("_", "-") != "vorflow": + raise ValueError(f"unexpected project name: {metadata['Name']}") + if metadata["Version"] != expected_version: + raise ValueError( + f"wheel version {metadata['Version']} does not match {expected_version}" + ) + if metadata["Requires-Python"] != ">=3.10": + raise ValueError(f"unexpected Requires-Python: {metadata['Requires-Python']}") + requirements = { + _normalized_requirement(value) + for value in metadata.get_all("Requires-Dist", []) + if "extra==" not in _normalized_requirement(value) + } + if requirements != EXPECTED_REQUIREMENTS: + raise ValueError(f"unexpected runtime requirements: {requirements}") + if metadata["License-Expression"] != "MIT": + raise ValueError("wheel does not declare the MIT SPDX expression") + if "LICENSE" not in metadata.get_all("License-File", []): + raise ValueError("wheel metadata does not declare LICENSE") + if "Oscar Sanchez" not in (metadata["Author-email"] or ""): + raise ValueError("primary author is missing from wheel metadata") + if "rhugman" not in (metadata["Author"] or ""): + raise ValueError("original author is missing from wheel metadata") + if "Oscar Sanchez" not in (metadata["Maintainer-email"] or ""): + raise ValueError("maintainer is missing from wheel metadata") + project_urls = set(metadata.get_all("Project-URL", [])) + expected_urls = { + "Repository, https://github.com/oscarfasanchez/vorflow_os", + "Issues, https://github.com/oscarfasanchez/vorflow_os/issues", + "Changelog, https://github.com/oscarfasanchez/vorflow_os/blob/main/CHANGELOG.md", + } + if not expected_urls.issubset(project_urls): + raise ValueError(f"wheel is missing project URLs: {expected_urls - project_urls}") + + +def validate_sdist(sdist: Path, expected_version: str) -> None: + with tarfile.open(sdist, "r:gz") as archive: + names = archive.getnames() + bad = forbidden_members(names) + if bad: + raise ValueError(f"sdist contains forbidden members: {bad}") + root = f"vorflow-{expected_version}/" + for required in ( + "pyproject.toml", + "README.md", + "LICENSE", + "src/vorflow/__init__.py", + ): + if root + required not in names: + raise ValueError(f"sdist is missing {root + required}") + + +def validate_dist(directory: Path, expected_version: str) -> None: + wheel = _one(directory, "*.whl") + sdist = _one(directory, "*.tar.gz") + validate_wheel(wheel, expected_version) + validate_sdist(sdist, expected_version) + print(f"Validated {wheel.name} and {sdist.name}") + + +def main() -> None: + parser = argparse.ArgumentParser() + parser.add_argument("directory", type=Path) + version_group = parser.add_mutually_exclusive_group(required=True) + version_group.add_argument("--expected-version") + version_group.add_argument("--expected-tag") + args = parser.parse_args() + expected = ( + version_from_tag(args.expected_tag) + if args.expected_tag + else args.expected_version + ) + validate_dist(args.directory, expected) + + +if __name__ == "__main__": + main() +``` + +- [ ] **Step 4: Run validator unit tests** + +```powershell +pytest tests/test_check_dist.py -v +``` + +Expected: `3 passed`. + +- [ ] **Step 5: Make setuptools discovery and source exclusions explicit** + +Add to `pyproject.toml`: + +```toml +[tool.setuptools] +package-dir = {"" = "src"} +include-package-data = false + +[tool.setuptools.packages.find] +where = ["src"] +``` + +Create `MANIFEST.in`: + +```text +prune .conda +prune benchmarks +prune docs +global-exclude *.code-workspace +global-exclude __pycache__ +global-exclude *.py[cod] +``` + +- [ ] **Step 6: Run focused tests and commit** + +```powershell +pytest tests/test_check_dist.py tests/test_release_metadata.py -v +git add MANIFEST.in pyproject.toml scripts/check_dist.py tests/test_check_dist.py +git commit -m "build: validate release archives" +``` + +Expected: focused tests pass and the commit contains only packaging-boundary files. + +### Task 5: Prove the Advertised Minimum Dependencies in CI + +**Files:** + +- Modify: `.github/workflows/python-app.yml` + +**Interfaces:** + +- Consumes: exact floor releases on Python 3.10. +- Produces: a CI result proving or disproving the dependency floors. + +- [ ] **Step 1: Add the minimum-dependencies job** + +Append under `jobs:` at the same indentation as `lint` and `test`: + +```yaml + minimum-dependencies: + runs-on: ubuntu-latest + steps: + - uses: actions/checkout@v7 + - uses: actions/setup-python@v6 + with: + python-version: "3.10" + cache: pip + - name: Install Gmsh system library + run: sudo apt-get update && sudo apt-get install --yes libglu1-mesa + - name: Install minimum runtime dependencies + run: >- + python -m pip install + numpy==1.24.0 + pandas==1.5.0 + geopandas==0.13.0 + shapely==2.0.0 + scipy==1.10.0 + gmsh==4.11.1 + - name: Install vorflow development tools + run: python -m pip install --no-deps -e . && python -m pip install pytest pytest-cov tomli + - name: Verify installed dependency versions + run: >- + python -c "import geopandas, gmsh, numpy, pandas, scipy, shapely; + assert numpy.__version__ == '1.24.0'; + assert pandas.__version__ == '1.5.0'; + assert geopandas.__version__ == '0.13.0'; + assert shapely.__version__ == '2.0.0'; + assert scipy.__version__ == '1.10.0'; + assert gmsh.__version__ == '4.11.1'" + - name: Run tests at dependency floors + run: pytest --cov=vorflow --cov-report=term-missing +``` + +- [ ] **Step 2: Verify the existing nine-job matrix is unchanged** + +```powershell +rg -n "ubuntu-latest|windows-latest|macos-latest|3.10|3.11|3.12|minimum-dependencies" .github/workflows/python-app.yml +git diff --check +``` + +Expected: all three operating systems and Python versions remain, plus the new minimum job. + +- [ ] **Step 3: Run the local suite before relying on CI** + +```powershell +ruff check src tests scripts +pytest -v +``` + +Expected: Ruff and pytest pass. If the remote minimum job later fails because an advertised floor is incompatible, stop and raise that floor to the lowest demonstrated passing release before continuing. + +- [ ] **Step 4: Commit the CI check** + +```powershell +git add .github/workflows/python-app.yml +git commit -m "ci: test minimum supported dependencies" +``` + +### Task 6: Add the TestPyPI-Only Trusted Publishing Workflow + +**Files:** + +- Create: `.github/workflows/testpypi.yml` + +**Interfaces:** + +- Consumes: tag `v0.1.0rc1`, verified source, protected environment `testpypi`. +- Produces: one internal artifact named `python-package-distributions` and a TestPyPI upload using short-lived OIDC credentials. + +- [ ] **Step 1: Create `.github/workflows/testpypi.yml`** + +```yaml +name: Publish release candidate to TestPyPI + +on: + push: + tags: + - "v*rc*" + +permissions: + contents: read + +jobs: + build: + runs-on: ubuntu-latest + steps: + - uses: actions/checkout@v7 + - uses: actions/setup-python@v6 + with: + python-version: "3.12" + cache: pip + - name: Install Gmsh system library + run: sudo apt-get update && sudo apt-get install --yes libglu1-mesa + - name: Install build and test tools + run: python -m pip install -e ".[dev]" + - name: Run Ruff + run: ruff check src tests scripts + - name: Run pytest + run: pytest --cov=vorflow --cov-report=term-missing + - name: Build wheel and source distribution + run: python -m build + - name: Check package metadata rendering + run: python -m twine check dist/* + - name: Validate tag, metadata, and archive contents + env: + RELEASE_TAG: ${{ github.ref_name }} + run: python scripts/check_dist.py dist --expected-tag "$RELEASE_TAG" + - name: Smoke-test the built wheel + run: | + python -m venv "$RUNNER_TEMP/vorflow-smoke" + "$RUNNER_TEMP/vorflow-smoke/bin/python" -m pip install dist/*.whl + "$RUNNER_TEMP/vorflow-smoke/bin/python" -m pip check + "$RUNNER_TEMP/vorflow-smoke/bin/python" -c "import vorflow; assert vorflow.__version__ == '0.1.0rc1'" + cd "$RUNNER_TEMP" + "$RUNNER_TEMP/vorflow-smoke/bin/python" "$GITHUB_WORKSPACE/examples/basic_usage.py" + - uses: actions/upload-artifact@v7 + with: + name: python-package-distributions + path: dist/ + if-no-files-found: error + + publish-testpypi: + needs: build + runs-on: ubuntu-latest + environment: + name: testpypi + url: https://test.pypi.org/p/vorflow + permissions: + id-token: write + steps: + - uses: actions/download-artifact@v8 + with: + name: python-package-distributions + path: dist/ + - name: Publish package distributions to TestPyPI + uses: pypa/gh-action-pypi-publish@release/v1 + with: + repository-url: https://test.pypi.org/legacy/ +``` + +- [ ] **Step 2: Verify there is no production publishing path** + +```powershell +rg -n "test.pypi.org|pypi.org|id-token|environment|api-token|password" .github/workflows/testpypi.yml +``` + +Expected: TestPyPI URLs and `id-token: write` are present; `https://upload.pypi.org`, API tokens, and passwords are absent. + +- [ ] **Step 3: Run local equivalents of the build job** + +```powershell +python -m pip install -e ".[dev]" +ruff check src tests scripts +pytest -v +python -m build +python -m twine check dist/* +python scripts/check_dist.py dist --expected-version 0.1.0rc1 +``` + +Expected: every command succeeds; the validator prints both archive filenames. + +- [ ] **Step 4: Commit the workflow** + +```powershell +git add .github/workflows/testpypi.yml +git commit -m "ci: add trusted TestPyPI publishing" +``` + +### Task 7: Perform the Complete Local Release Rehearsal + +**Files:** + +- Verify only; do not modify source files unless a check reveals a defect. + +**Interfaces:** + +- Consumes: committed release-preparation branch. +- Produces: clean local evidence that the exact wheel installs and runs outside the source tree. + +- [ ] **Step 1: Run source verification** + +```powershell +ruff check src tests scripts +pytest --cov=vorflow --cov-report=term-missing +git diff --check +git status --short +``` + +Expected: checks pass; status contains no uncommitted release files. + +- [ ] **Step 2: Build into a new explicit temporary directory** + +```powershell +$releaseDist = Join-Path $env:TEMP 'vorflow-0.1.0rc1-dist' +if (Test-Path -LiteralPath $releaseDist) { throw "$releaseDist already exists; inspect it before choosing a new empty directory" } +New-Item -ItemType Directory -Path $releaseDist | Out-Null +python -m build --outdir $releaseDist +python -m twine check "$releaseDist\*" +python scripts/check_dist.py $releaseDist --expected-version 0.1.0rc1 +``` + +Expected: exactly one wheel and one source distribution validate successfully. + +- [ ] **Step 3: Create a fresh wheel-only environment** + +```powershell +$smokeEnv = Join-Path $env:TEMP 'vorflow-0.1.0rc1-smoke' +if (Test-Path -LiteralPath $smokeEnv) { throw "$smokeEnv already exists; inspect it before choosing a new empty directory" } +python -m venv $smokeEnv +$smokePython = Join-Path $smokeEnv 'Scripts\python.exe' +$releaseWheel = Get-ChildItem -LiteralPath $releaseDist -Filter '*.whl' | Select-Object -ExpandProperty FullName +& $smokePython -m pip install $releaseWheel +& $smokePython -m pip check +& $smokePython -c "import vorflow; assert vorflow.__version__ == '0.1.0rc1'; print(vorflow.__version__)" +``` + +Expected: dependency installation succeeds, `pip check` reports no broken requirements, and version output is `0.1.0rc1`. + +- [ ] **Step 4: Run Basic Usage outside the source tree** + +```powershell +$examplePath = (Resolve-Path 'examples/basic_usage.py').Path +Push-Location $env:TEMP +try { & $smokePython $examplePath } finally { Pop-Location } +``` + +Expected: `Generated Voronoi cells`. + +- [ ] **Step 5: Review the branch before external configuration** + +```powershell +git log --oneline main..HEAD +git diff --stat main...HEAD +git status --short +``` + +Expected: focused release commits and an empty status. + +### Task 8: User Configures TestPyPI and the GitHub Approval Environment + +**Files:** + +- External configuration only; no passwords, tokens, or recovery values enter the repository. + +**Interfaces:** + +- Consumes: committed `.github/workflows/testpypi.yml` and Oscar's accounts. +- Produces: matching GitHub environment and pending TestPyPI Trusted Publisher. + +- [ ] **Step 1: User creates and verifies the TestPyPI account** + +Open `https://test.pypi.org/account/register/`. Oscar chooses the credentials, verifies the email, and stores recovery information privately. Codex waits and provides navigation guidance only. + +- [ ] **Step 2: User creates the protected GitHub environment** + +In repository settings, create environment `testpypi`, add Oscar as required reviewer, and allow Oscar to approve a run he triggered. Do not add API-token secrets. + +- [ ] **Step 3: User registers the pending Trusted Publisher** + +At `https://test.pypi.org/manage/account/publishing/`, enter exactly: + +```text +PyPI project name: vorflow +Owner: oscarfasanchez +Repository: vorflow_os +Workflow name: testpypi.yml +Environment name: testpypi +``` + +- [ ] **Step 4: Confirm the configuration without exposing secrets** + +Expected: TestPyPI lists the pending publisher with all five exact values; GitHub lists environment `testpypi` with a required reviewer; neither service contains a TestPyPI API token for this workflow. + +### Task 9: Integrate, Tag, and Trigger the Candidate Build + +**Files:** + +- Git branch and tag state; no new source edit. + +**Interfaces:** + +- Consumes: passing release-preparation branch and completed Task 8. +- Produces: immutable annotated tag `v0.1.0rc1` on clean `main` and a paused TestPyPI deployment. + +- [ ] **Step 1: Request code review and integrate the release branch** + +Use `superpowers:requesting-code-review`, address findings, rerun Task 7, then use `superpowers:finishing-a-development-branch`. Choose the user's preferred PR or local merge route; do not tag a feature branch. + +- [ ] **Step 2: Verify the exact tag target** + +```powershell +git switch main +git status --short +git log -1 --oneline +git tag --list v0.1.0rc1 +``` + +Expected: branch `main`, empty status, reviewed release commit at HEAD, and no existing `v0.1.0rc1` tag. + +- [ ] **Step 3: Obtain explicit user approval for the external tag push** + +Explain that pushing the tag starts GitHub Actions but cannot upload until the protected `testpypi` environment is manually approved. + +- [ ] **Step 4: Create and push the annotated candidate tag** + +```powershell +git tag -a v0.1.0rc1 -m "Release vorflow 0.1.0rc1" +git push origin v0.1.0rc1 +``` + +Expected: GitHub starts `Publish release candidate to TestPyPI`; the build job runs first. + +- [ ] **Step 5: Review the build before approval** + +Confirm Ruff, pytest, build, Twine, archive validation, and fresh-wheel smoke steps all passed. Downloading or rebuilding a different artifact is not permitted. + +- [ ] **Step 6: User approves the `testpypi` environment** + +Oscar reviews the pending deployment and clicks approval. Expected: the publish job receives a short-lived OIDC credential and uploads the previously built wheel and source distribution to TestPyPI. + +### Task 10: Verify TestPyPI and Record the Rehearsal + +**Files:** + +- Modify: `ROADMAP.md` +- Modify: `docs/roadmap/06-pypi-publishing.md` + +**Interfaces:** + +- Consumes: TestPyPI project `vorflow` release `0.1.0rc1`. +- Produces: an independent installation result and roadmap status `TestPyPI verified`. + +- [ ] **Step 1: Inspect the TestPyPI project page** + +Open `https://test.pypi.org/project/vorflow/0.1.0rc1/` and verify the README, absolute links, authors, maintainer, MIT licence, Python requirement, dependencies, wheel, source distribution, and Trusted Publishing provenance. + +- [ ] **Step 2: Install dependencies from real PyPI in a second clean environment** + +```powershell +$testPypiEnv = Join-Path $env:TEMP 'vorflow-0.1.0rc1-testpypi' +if (Test-Path -LiteralPath $testPypiEnv) { throw "$testPypiEnv already exists; inspect it before choosing a new empty directory" } +python -m venv $testPypiEnv +$testPypiPython = Join-Path $testPypiEnv 'Scripts\python.exe' +& $testPypiPython -m pip install "numpy>=1.24" "pandas>=1.5" "geopandas>=0.13" "shapely>=2.0" "scipy>=1.10" "gmsh>=4.11" +``` + +Expected: dependencies come from normal PyPI successfully. + +- [ ] **Step 3: Install only vorflow from TestPyPI** + +```powershell +& $testPypiPython -m pip install --index-url https://test.pypi.org/simple/ --no-deps vorflow==0.1.0rc1 +& $testPypiPython -m pip check +& $testPypiPython -c "import vorflow; assert vorflow.__version__ == '0.1.0rc1'; print(vorflow.__version__)" +``` + +Expected: `vorflow` comes from TestPyPI, `pip check` passes, and version output is `0.1.0rc1`. + +- [ ] **Step 4: Run Basic Usage against the TestPyPI installation** + +```powershell +$examplePath = (Resolve-Path 'examples/basic_usage.py').Path +Push-Location $env:TEMP +try { & $testPypiPython $examplePath } finally { Pop-Location } +``` + +Expected: `Generated Voronoi cells`. + +- [ ] **Step 5: Record the verified status without claiming production publication** + +Change Milestone 6 in `ROADMAP.md` from `In progress` to `TestPyPI verified`. Add this section to `docs/roadmap/06-pypi-publishing.md`: + +```markdown +## TestPyPI rehearsal result + +- Candidate: `vorflow==0.1.0rc1` +- Tag: `v0.1.0rc1` +- Test index: +- Wheel and source distribution passed Twine and archive-content validation. +- A clean environment installed the TestPyPI candidate, passed `pip check`, + reported the expected version, and ran the Basic Usage example. +- Real PyPI publication remains pending and requires separate approval. +``` + +- [ ] **Step 6: Run the final documentation and repository checks** + +```powershell +rg -n "TestPyPI verified|0.1.0rc1|Real PyPI publication remains pending" ROADMAP.md docs/roadmap/06-pypi-publishing.md +git diff --check +git status --short +``` + +Expected: the rehearsal is recorded accurately, production remains pending, and only the two roadmap files are modified. + +- [ ] **Step 7: Commit the rehearsal record** + +```powershell +git add ROADMAP.md docs/roadmap/06-pypi-publishing.md +git commit -m "docs: record TestPyPI release rehearsal" +``` + +- [ ] **Step 8: Stop before production** + +Do not create `v0.1.0`, a production environment, a real-PyPI Trusted Publisher, or a production upload workflow. Report the TestPyPI result and the remaining production decision to the user. diff --git a/docs/superpowers/specs/2026-07-20-testpypi-release-design.md b/docs/superpowers/specs/2026-07-20-testpypi-release-design.md new file mode 100644 index 0000000..fef0fef --- /dev/null +++ b/docs/superpowers/specs/2026-07-20-testpypi-release-design.md @@ -0,0 +1,393 @@ +# TestPyPI Release Rehearsal Design + +**Date:** 2026-07-20 + +**Status:** Approved design + +**Target candidate:** `vorflow` version `0.1.0rc1` + +**Production release reserved:** `0.1.0` + +## Purpose + +Prepare `vorflow` as an installable Python package and rehearse the complete +release process on TestPyPI. The rehearsal must prove that a clean user +environment can install the built wheel, import the package, run the Basic +Usage mesh-generation example, and report the expected version. + +The work stops after TestPyPI verification. It does not create or execute a +real-PyPI publishing path. + +## Current Repository Context + +- Release-target feature work is committed on branch `gmshflow_missing` but is + not yet integrated into `main`. +- The working tree contains uncommitted roadmap and documentation material. +- `pyproject.toml` already uses PEP 621 metadata, setuptools, and a `src/` + layout. +- The package version is currently duplicated as `0.0.2` in + `pyproject.toml` and the source-checkout fallback in + `src/vorflow/__init__.py`. +- GitHub Actions currently runs Ruff and pytest across Linux, Windows, and + macOS with Python 3.10 through 3.12. +- No package distribution has yet been built and verified in this repository. + +Release preparation begins only after the intended feature work is integrated +into a clean `main`. Packaging work must remain separate from feature work so +that the release-specific changes are easy to review. + +## Scope Boundary + +### In scope + +- Package metadata and dependency lower bounds. +- Version reporting and release-candidate versioning. +- PyPI-compatible README content and a runnable Basic Usage example. +- A changelog entry for the candidate. +- Wheel and source-distribution build verification. +- Minimum-dependency, clean-wheel, and post-upload smoke tests. +- A dedicated TestPyPI Trusted Publishing workflow. +- TestPyPI account, GitHub environment, and pending-publisher setup guidance. +- TestPyPI page and installation verification. +- Roadmap updates recording the rehearsal result. + +### Out of scope + +- Changes to mesh generation or other runtime behaviour. +- A real-PyPI publishing job or production repository URL. +- A `v0.1.0` production tag or real PyPI upload. +- `setuptools-scm` or another tag-derived versioning dependency. +- Documentation-site, DOI, citation, or conda-forge work. +- Removing or relocating the user's ignored local VS Code workspace file. + +## Agreed Release Sequence + +1. Review and integrate `gmshflow_missing` into `main` without folding + packaging work into that integration. +2. Begin packaging changes from a clean `main`. +3. Prepare package version `0.1.0rc1`. +4. Run source tests, minimum-dependency tests, archive validation, and a fresh + wheel-install smoke test locally. The tag-triggered GitHub workflow repeats + the release-critical version, test, build, archive, and smoke checks. +5. Create the TestPyPI account and configure the matching Trusted Publisher + and GitHub environment. +6. Merge the reviewed release-preparation changes into `main`. +7. Create tag `v0.1.0rc1` on the exact verified commit. +8. Let GitHub Actions build the archives, then approve the protected + `testpypi` publishing environment. +9. Verify the TestPyPI page and install `vorflow==0.1.0rc1` in another clean + environment. +10. Record the result and stop without publishing to real PyPI. + +## Roadmap Cleanup + +`ROADMAP.md` is retained as both the current work map and the historical record +of completed work. It is reorganized rather than erased: + +- Milestone 6 becomes the single current objective. +- Milestones 1 through 5 remain in a compact completed-milestones section. +- Their detailed files under `docs/roadmap/` remain available as decision and + verification history. +- The stale `Suggested Sequencing` text for already completed milestones is + removed. +- After a successful TestPyPI rehearsal, Milestone 6 is recorded as + `TestPyPI verified`, not `Done`. +- Milestone 6 becomes `Done` only after the separate future production release + makes `pip install vorflow` available from real PyPI. + +## Version Design + +`pyproject.toml` is the only authoritative source containing the candidate +version: + +```toml +version = "0.1.0rc1" +``` + +At runtime, `vorflow.__version__` continues to use +`importlib.metadata.version("vorflow")`. If distribution metadata is +unavailable because the source directory is being imported without an +installation, the fallback is `0+unknown`, not a duplicated release number. + +The release workflow must compare the pushed tag, with its leading `v` +removed, against the built distribution version. A mismatch stops the build +before an upload is possible. + +If the first candidate needs a correction after upload, the corrected package +uses `0.1.0rc2` and tag `v0.1.0rc2`. An uploaded candidate is never overwritten +or represented by a moved tag. The eventual production release remains +`0.1.0`. + +## Authors, Maintainer, and Licence + +Project metadata lists Oscar Sanchez as the primary current author and +maintainer. It retains rhugman as an original author without publishing +rhugman's email: + +```toml +authors = [ + {name = "Oscar Sanchez", email = "oscarfasanchez@gmail.com"}, + {name = "rhugman"}, +] +maintainers = [ + {name = "Oscar Sanchez", email = "oscarfasanchez@gmail.com"}, +] +``` + +The existing MIT copyright notice remains intact. Packaging metadata adopts +the PEP 639 form supported by setuptools 77.0.3 and newer: + +```toml +[build-system] +requires = ["setuptools>=77.0.3"] + +[project] +license = "MIT" +license-files = ["LICENSE"] +``` + +The deprecated `License :: OSI Approved :: MIT License` classifier is removed +because the SPDX expression now declares the licence. This does not remove or +change the MIT licence itself. + +References: + +- [PyPA project authors and maintainers metadata](https://packaging.python.org/en/latest/specifications/declaring-project-metadata/#authors-maintainers) +- [PyPA licence and licence-file guidance](https://packaging.python.org/en/latest/guides/writing-pyproject-toml/#license-and-license-files) + +## Dependencies + +Runtime dependencies use lower bounds and no upper caps: + +```toml +dependencies = [ + "numpy>=1.24", + "pandas>=1.5", + "geopandas>=0.13", + "shapely>=2.0", + "scipy>=1.10", + "gmsh>=4.11", +] +``` + +A dedicated Python 3.10 minimum-dependency check installs those exact lower +versions and runs the test suite. If an exact lower-bound combination fails +because `vorflow` uses an unavailable or incompatible API, the dependency +floor is raised to the lowest version demonstrated to pass. Tests are not +weakened to preserve an incorrect advertised floor. + +## README and Example Design + +The README installation section leads with the future production command: + +```bash +pip install vorflow +``` + +Editable installation and development extras appear in a separate development +subsection. Repository links use complete `https://github.com/...` addresses +so they resolve on GitHub, TestPyPI, and PyPI. This includes links to +`examples/`, `ROADMAP.md`, `LICENSE`, and `etc/environment.yml`. + +The core Basic Usage example becomes a runnable +`examples/basic_usage.py` script and succeeds after producing a non-empty +Voronoi `GeoDataFrame`. The README keeps an understandable version of that +flow and links to the complete script. + +Shapefile export is documented separately from core mesh generation. The +current `GeoDataFrame.to_file(...)` call relies on a GeoPandas-supported I/O +engine such as Pyogrio or Fiona; `vorflow` itself does not import either +engine. The core smoke test therefore proves mesh construction without making +an optional geospatial file writer a hard `vorflow` dependency. + +Reference: [GeoPandas `GeoDataFrame.to_file` documentation](https://geopandas.org/en/stable/docs/reference/api/geopandas.GeoDataFrame.to_file.html). + +## Distribution Design + +The release build produces both standard distribution formats: + +- `vorflow-0.1.0rc1-py3-none-any.whl`, the ready-to-install pure-Python wheel. +- `vorflow-0.1.0rc1.tar.gz`, the source distribution containing the source and + build instructions needed to create a wheel. + +The wheel contains the `vorflow` Python package and its `.dist-info` metadata. +The source distribution contains the source package, `pyproject.toml`, README, +licence, and required build metadata. Tests may be present in the source +distribution, but `.conda/`, `benchmarks/`, general planning documentation, +and `*.code-workspace` files must not be present in either archive. + +The user's ignored `src/vorflow/vorflow.code-workspace` file is not modified. +Packaging configuration prevents it from entering an archive. + +## Verification Design + +### Source checks + +- Run Ruff against `src` and `tests`. +- Run the complete pytest suite. +- Preserve the existing Linux, Windows, and macOS coverage across Python 3.10 + through 3.12. +- Run the exact minimum-dependency combination on Python 3.10. + +### Archive checks + +1. Build both archives with `python -m build`. +2. Run `twine check dist/*`. +3. Inspect every archive member against required and forbidden paths. +4. Read built metadata and confirm the name, version, dependencies, Python + requirement, licence, authors, maintainer, and project URLs. +5. Confirm that the wheel and source distribution describe the same version. + +### Fresh-wheel smoke test + +Create a new virtual environment with no inherited project packages, install +the built wheel, and then: + +1. run `pip check`; +2. import `vorflow`; +3. assert `vorflow.__version__ == "0.1.0rc1"`; +4. run `examples/basic_usage.py` from outside the source tree; +5. confirm it produces a non-empty `GeoDataFrame`. + +Running outside the source tree ensures the test imports the installed wheel +rather than accidentally importing `src/vorflow`. + +### Post-upload TestPyPI smoke test + +TestPyPI does not serve as a complete mirror of all runtime dependencies. In a +new environment, install the declared dependencies from the normal Python +package index first. Then install only `vorflow==0.1.0rc1` from TestPyPI with +dependency resolution disabled for that second command. Run `pip check`, the +version assertion, and the Basic Usage script again. + +Also inspect the rendered TestPyPI project page, absolute links, author and +maintainer presentation, licence, dependencies, release files, and Trusted +Publishing provenance. + +## Trusted Publishing Architecture + +The dedicated workflow is `.github/workflows/testpypi.yml` and is triggered +only by release-candidate tags matching the intended `v*rc*` family. The build +job also performs an exact PEP 440 version comparison, so the broad GitHub tag +glob cannot authorize a mismatched version. + +### Build job + +- Checks out the tagged source. +- Has read-only repository permissions and no OIDC identity permission. +- Confirms the tag and package version match. +- Runs the required checks and builds both archives. +- Uploads the verified `dist/` directory as an internal GitHub artifact. + +### Publish job + +- Depends on successful completion of the build job. +- Downloads the build job's artifact and does not rebuild it. +- Uses the protected GitHub environment named `testpypi`. +- Receives `id-token: write` only at the job level. +- Publishes with `pypa/gh-action-pypi-publish@release/v1`. +- Sets `repository-url: https://test.pypi.org/legacy/` explicitly. + +There is no production publish job, production environment, production +repository URL, or API token secret. + +Reference: [PyPI Trusted Publishing with GitHub Actions](https://docs.pypi.org/trusted-publishers/using-a-publisher/). + +## One-Time Account Configuration + +Oscar creates and verifies a TestPyPI account. Before pushing the candidate +tag, TestPyPI receives a pending Trusted Publisher registration with exactly: + +```text +Owner: oscarfasanchez +Repository: vorflow_os +Workflow: testpypi.yml +Environment: testpypi +Project: vorflow +``` + +GitHub receives an environment named `testpypi` with Oscar configured as its +required reviewer. The environment permits Oscar to approve a run that he +triggered. The spelling and capitalization must match the TestPyPI +registration and workflow exactly. + +Trusted Publishing uses short-lived OIDC credentials rather than a stored +TestPyPI API token. The publish job cannot authenticate if its repository, +workflow filename, or environment differs from the registered identity. + +Account creation is an explicit user-owned manual step because it uses Oscar's +email, password, email-verification link, recovery information, and account +security settings. The implementation work prepares the workflow and exact +publisher values, then pauses while Oscar completes those personal steps. +Passwords, recovery information, and two-factor authentication values are not +requested, stored, or handled by the implementation process. + +TestPyPI is a rehearsal service rather than permanent storage. Its database may +periodically remove projects, releases, and accounts. The durable record is the +Git repository, release tag, changelog, workflow, and verification notes; the +TestPyPI project page is not treated as a backup or permanent release archive. + +## Failure Handling + +- A source-test, lint, minimum-dependency, tag/version, build, metadata, + archive-content, or Twine failure stops before the publish job. +- Without environment approval, the publish job remains paused and uploads + nothing. +- A Trusted Publisher identity mismatch is rejected by TestPyPI; it does not + fall back to a stored credential. +- A problem discovered after upload produces the next immutable candidate, + such as `0.1.0rc2`; the existing archive and tag are not replaced. +- If `vorflow` is unavailable in TestPyPI's separate project namespace, work + stops for an explicit naming decision. The workflow does not silently change + the distribution name. +- Successful TestPyPI verification records the result and stops. Production + publishing requires a separate future design and explicit approval. + +## File Responsibilities + +| File | Responsibility | +|---|---| +| `pyproject.toml` | Authoritative version, package identity, dependencies, licence, build configuration, and search metadata | +| `src/vorflow/__init__.py` | Installed-version lookup and non-release source fallback | +| `README.md` | PyPI-facing installation, usage, links, and optional-export guidance | +| `CHANGELOG.md` | Candidate release notes | +| `examples/basic_usage.py` | Canonical executable core example used by smoke tests | +| `scripts/check_dist.py` | Deterministic archive-member and built-metadata validation | +| `MANIFEST.in` | Explicit source-distribution exclusions for repository-only material | +| `.github/workflows/testpypi.yml` | Build, approval, OIDC, and TestPyPI-only upload path | +| `.gitignore` | Exclusion of local `.superpowers/` visual-session state | +| `docs/roadmap/06-pypi-publishing.md` | Detailed milestone decisions and rehearsal record | +| `ROADMAP.md` | High-level milestone status without claiming a production release | + +`pyproject.toml` explicitly limits setuptools package discovery to `src/` and +disables undeclared package data. `MANIFEST.in` prunes `.conda/`, `benchmarks/`, +general planning documentation, and `*.code-workspace` from the source +distribution. `scripts/check_dist.py` independently inspects both archives and +fails when required files or metadata are missing or forbidden members are +present. The release cannot proceed while any forbidden archive member +remains. + +## Acceptance Criteria + +- The intended feature work is integrated and the release commit on `main` is + clean. +- Source tests and Ruff pass. +- The exact minimum-dependency test passes or the declared floors are raised + to the demonstrated passing minimums. +- `python -m build` creates one wheel and one source distribution for + `0.1.0rc1`. +- `twine check` passes for both archives. +- Required metadata is correct and forbidden repository-only material is + absent from both archives. +- A clean environment installs the local wheel, passes `pip check`, reports + `0.1.0rc1`, and runs the Basic Usage example. +- The tag is exactly `v0.1.0rc1` and points at the verified release commit. +- GitHub publishes the checked artifact to TestPyPI through the protected + `testpypi` environment and Trusted Publishing. +- A second clean environment installs the candidate from TestPyPI and repeats + the smoke checks. +- The TestPyPI page renders correctly with working links and expected metadata. +- `ROADMAP.md` identifies Milestone 6 as the only current objective, preserves + Milestones 1 through 5 as completed history, and contains no obsolete + implementation sequencing. +- No real-PyPI workflow, tag, credential, or upload is created. diff --git a/etc/environment.yml b/etc/environment.yml index 5a4dea8..0570078 100644 --- a/etc/environment.yml +++ b/etc/environment.yml @@ -3,15 +3,15 @@ channels: - nodefaults - conda-forge dependencies: - - python>3.9 + - python>=3.10 - pip - gmsh - geopandas - shapely - numpy - pandas + - scipy - pyproj - - meshio - pytest - jupyter - matplotlib diff --git a/examples/active_domain_quality_example.py b/examples/active_domain_quality_example.py new file mode 100644 index 0000000..f13cb17 --- /dev/null +++ b/examples/active_domain_quality_example.py @@ -0,0 +1,209 @@ +#%% +"""Active-domain quality example (pseudo-notebook). + +This example shows a workflow for getting healthier cells around a model's active +area without adding active-domain logic to `VoronoiTessellator`. + +Two grids are compared: +- Baseline: the mesh boundary is the active model boundary, so boundary cells are + clipped directly at the active edge. +- Larger envelope: the mesh is generated on a larger square envelope, then active + cells are selected externally with GeoPandas. + +The larger-envelope approach keeps active cells uncut near the active boundary, +which often improves MODFLOW-facing centroid connectivity metrics. +""" + +from __future__ import annotations + +import matplotlib.pyplot as plt +import pandas as pd + +from shapely.geometry import box + +from vorflow import ConceptualMesh, MeshGenerator, VoronoiTessellator +from vorflow.utils import build_connectivity, calculate_mesh_quality + +#%% +# 1) Geometry + +active_domain = box(0, 0, 300, 180) +mesh_envelope = box(-60, -60, 360, 240) +cell_size = 18.0 + + +def generate_voronoi(boundary, *, zone_id): + conceptual = ConceptualMesh(crs="EPSG:3857") + conceptual.add_polygon(boundary, zone_id=zone_id, resolution=cell_size, densify=True) + clean_polys, clean_lines, clean_points = conceptual.generate() + + mesher = MeshGenerator( + background_lc=cell_size, + verbosity=0, + smoothing_steps=5, + optimization_cycles=1, + ) + mesher.generate(clean_polys, clean_lines, clean_points, launch_gmsh_gui=False) + + tessellator = VoronoiTessellator(mesher, conceptual, clip_to_boundary=True) + return tessellator.generate() + + +def tag_active_cells(grid, active_geom): + tagged = grid.copy() + overlap_area = tagged.geometry.intersection(active_geom).area + tagged["active_overlap_ratio"] = overlap_area / tagged.geometry.area + tagged["is_active_by_overlap"] = tagged["active_overlap_ratio"] >= 0.5 + tagged["is_active_by_centroid"] = tagged.geometry.centroid.within(active_geom) + return tagged + + +def quality_with_centroid_connectivity(grid): + connectivity = build_connectivity(grid.reset_index(drop=True), center="centroid") + quality = calculate_mesh_quality( + grid.reset_index(drop=True), + calc_ortho=True, + calc_skewness=True, + connectivity=connectivity, + ) + return quality, connectivity + + +def summarize_metrics(label, quality): + metrics = ["area", "compactness", "drift_ratio", "ortho_error", "skewness"] + summary = quality[metrics].describe(percentiles=[0.05, 0.5, 0.95]).T + summary = summary[["min", "5%", "50%", "95%", "max"]] + print(f"\n{label}") + print(summary) + return summary + + +#%% +# 2) Generate comparable grids + +baseline_grid = generate_voronoi(active_domain, zone_id="active-domain") +envelope_grid = generate_voronoi(mesh_envelope, zone_id="mesh-envelope") + +baseline_quality, baseline_connectivity = quality_with_centroid_connectivity(baseline_grid) + +envelope_tagged = tag_active_cells(envelope_grid, active_domain) +active_grid = envelope_tagged[envelope_tagged["is_active_by_centroid"]].copy() +active_quality, active_connectivity = quality_with_centroid_connectivity(active_grid) +active_quality["active_overlap_ratio"] = active_grid["active_overlap_ratio"].to_numpy() + +print("\nActive-cell selection from larger envelope") +print(f" Full envelope cells: {len(envelope_tagged)}") +print(f" Active by centroid: {int(envelope_tagged['is_active_by_centroid'].sum())}") +print(f" Active by >=50% overlap: {int(envelope_tagged['is_active_by_overlap'].sum())}") + +baseline_summary = summarize_metrics("Baseline: clipped at active boundary", baseline_quality) +active_summary = summarize_metrics("Larger envelope: active cells selected externally", active_quality) + +comparison = pd.concat( + { + "baseline_clipped": baseline_summary[["50%", "95%", "max"]], + "envelope_active": active_summary[["50%", "95%", "max"]], + }, + axis=1, +) +print("\nQuality comparison") +print(comparison) + +#%% +# 3) Plot grid geometry and active selection + +fig, axes = plt.subplots(1, 2, figsize=(14, 6)) + +axes[0].set_aspect("equal") +baseline_quality.plot( + column="ortho_error", + ax=axes[0], + cmap="Reds", + legend=True, + vmin=0, + vmax=max(1.0, baseline_quality["ortho_error"].quantile(0.95)), + edgecolor="0.75", + linewidth=0.2, +) +axes[0].plot(*active_domain.exterior.xy, color="black", lw=1.2) +axes[0].set_title("Baseline: cells clipped to active boundary") +axes[0].set_axis_off() + +axes[1].set_aspect("equal") +envelope_tagged.plot(ax=axes[1], color="0.9", edgecolor="white", linewidth=0.15) +active_grid.plot(ax=axes[1], color="tab:blue", alpha=0.55, edgecolor="0.3", linewidth=0.2) +axes[1].plot(*mesh_envelope.exterior.xy, color="0.35", lw=1.0, ls="--") +axes[1].plot(*active_domain.exterior.xy, color="black", lw=1.2) +axes[1].set_title("Larger envelope: active cells selected after meshing") +axes[1].set_axis_off() + +fig.tight_layout() +plt.show() + +#%% +# 4) Plot MODFLOW-facing connectivity diagnostics + +fig, axes = plt.subplots(1, 2, figsize=(14, 6)) + +for ax, grid, connectivity, title in [ + ( + axes[0], + baseline_quality, + baseline_connectivity, + "Baseline centroid connectivity", + ), + ( + axes[1], + active_quality, + active_connectivity, + "Envelope-selected active-cell connectivity", + ), +]: + ax.set_aspect("equal") + grid.plot(ax=ax, color="white", edgecolor="0.85", linewidth=0.2) + connectivity.set_geometry("connector").plot( + ax=ax, + color="0.35", + linewidth=0.25, + alpha=0.25, + ) + connectivity.plot( + column="ortho_error", + ax=ax, + cmap="Reds", + legend=True, + linewidth=1.0, + vmin=0, + vmax=max(1.0, baseline_quality["ortho_error"].quantile(0.95)), + ) + ax.plot(*active_domain.exterior.xy, color="black", lw=1.0) + ax.set_title(title) + ax.set_axis_off() + +fig.tight_layout() +plt.show() + +#%% +# 5) Compare quality distributions + +fig, axes = plt.subplots(2, 2, figsize=(12, 8)) +plot_metrics = [ + ("compactness", "Compactness"), + ("drift_ratio", "Generator drift ratio"), + ("ortho_error", "Centroid orthogonality error"), + ("skewness", "Centroid skewness error"), +] + +for ax, (metric, title) in zip(axes.ravel(), plot_metrics): + ax.boxplot( + [baseline_quality[metric].dropna(), active_quality[metric].dropna()], + tick_labels=["clipped", "envelope active"], + showfliers=False, + ) + ax.set_title(title) + ax.grid(axis="y", alpha=0.25) + +fig.tight_layout() +plt.show() + +#%% diff --git a/examples/basic_example.ipynb b/examples/basic_example.ipynb index 2385cd7..2726e6c 100644 --- a/examples/basic_example.ipynb +++ b/examples/basic_example.ipynb @@ -2,7 +2,7 @@ "cells": [ { "cell_type": "code", - "execution_count": null, + "execution_count": 1, "id": "f2412c60", "metadata": {}, "outputs": [], @@ -21,7 +21,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 2, "id": "96e8fbed", "metadata": {}, "outputs": [], @@ -38,11 +38,14 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 3, "id": "c970674e", "metadata": {}, "outputs": [], - "source": [] + "source": [ + "river_coords = [(x, 165 + 20 * 1) for x in range(50, 150, 10)]\n", + "river_coords = LineString(river_coords)" + ] }, { "cell_type": "code", @@ -57,7 +60,63 @@ "execution_count": null, "id": "71f205cc", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Applying optional geometry simplification...\n", + "Resolving polygon overlaps...\n", + "Enforcing strict topology...\n", + "Snapping 2 lines to polygon boundaries (tol=0.001)...\n", + "Snapping 1 points to geometry (tol=0.001)...\n", + "Densifying geometry...\n", + "Transferring Geometry to Gmsh...\n", + "Constructed Barrier Zone from 1 barriers.\n", + "Adding 2 polygons to Gmsh...\n", + "Fragmenting 2 surfaces with 393 tools...\n", + "Reconstructing Map (Input Tags: 395, Out Map Len: 395)...\n", + "Setting up Resolution Fields...\n", + "--- Setup Fields Debug ---\n", + "Polygons GDF: 2 rows\n", + "Gmsh Surface Map: 2 entries\n", + "First Poly Index: 1 (Type: )\n", + "First Map Key: 1 (Type: )\n", + "Match? True\n", + "Gmsh Map Keys: points=[0], lines=[1], surfaces=[1, 0]\n", + " line key=1 -> raw tags=[(1, 1), (1, 2), (1, 3), (1, 4), (1, 5), (1, 6), (1, 7), (1, 8), (1, 9), (1, 10), (1, 11), (1, 12), (1, 13), (1, 14), (1, 15), (1, 16), (1, 17), (1, 18), (1, 19), (1, 20), (1, 21), (1, 22), (1, 23), (1, 24), (1, 25), (1, 26), (1, 27), (1, 28), (1, 29), (1, 30), (1, 31), (1, 32), (1, 33), (1, 34), (1, 35), (1, 36), (1, 37), (1, 38), (1, 39), (1, 40), (1, 41), (1, 42), (1, 43), (1, 44), (1, 45), (1, 46), (1, 47), (1, 48), (1, 49), (1, 50), (1, 51), (1, 52), (1, 53), (1, 54), (1, 55), (1, 56), (1, 57), (1, 58), (1, 59), (1, 60), (1, 61), (1, 62), (1, 63), (1, 64), (1, 65), (1, 66), (1, 67), (1, 68), (1, 69), (1, 70), (1, 71), (1, 72), (1, 73), (1, 74), (1, 75), (1, 76), (1, 77), (1, 78), (1, 79), (1, 80), (1, 81), (1, 82), (1, 83), (1, 84), (1, 85), (1, 86), (1, 87), (1, 88), (1, 89), (1, 90)]\n", + "FieldGraph: line 1 sizing uses curves=90 points=91 lc=1.0 dist_min=80.0 dist_max=15.0\n", + "FieldGraph: 5 groups -> 6 fields (plus Min).\n", + "Generating Triangular Mesh...\n", + "TriStats Line 0: 8312 tris inside buffer (mean area=0.5836319070268174 , min=0.09999591689348933) ; outside mean=0.7999829662651772\n", + "TriStats Line 1: 45 tris inside buffer (mean area=79.21515223136574 , min=14.484696083358267) ; outside mean=0.6979411184887853\n", + "Running 2 Optimization Cycles (Relocate2D & Laplace2D)...\n", + " -> Cycle 1/2\n", + " -> Cycle 2/2\n", + "Extracting 26760 Nodes from Gmsh...\n", + "Computing Mathematical Voronoi...\n", + " -> Raw Polygons: 26760\n", + " -> After Ghost Filter: 26760\n", + "Clipping to Domain Boundary...\n", + " -> After Domain Clip: 26760\n", + "Enforcing Hydrogeological Zones (Optimization: Point Sampling)...\n", + " -> Zones Assigned: 26760\n", + "Enforcing Barrier Cuts on 1 lines (Straddle lines skipped)...\n", + " -> After Barrier Cuts: 26898\n", + "Final Voronoi Grid Generated: 26898 cells.\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "# 1. Setup Blueprint\n", "background_lc=100\n", @@ -66,8 +125,8 @@ "blueprint.add_polygon(domain, zone_id=1)#,border_density=100,dist_max_in=background_lc)\n", "blueprint.add_polygon(poly1, zone_id=2, \n", " resolution=1, z_order=2,\n", - " dist_max_out=3* background_lc,\n", - " #dist_max_in=10\n", + " dist_max=3* background_lc,\n", + " \n", " ) \n", "blueprint.add_point(well_point, point_id=\"Well-A\", \n", " resolution=2,\n", @@ -80,12 +139,13 @@ "blueprint.add_line(river_coords, line_id=\"riv-1\", \n", " resolution=1, \n", " is_barrier=False,\n", - " dist_max=3* 5,)\n", + " dist_max=3* 5,\n", + " dist_min=1)\n", "\n", "clean_polys, clean_lines, clean_pts = blueprint.generate()\n", "\n", "# 2. Mesh Generation\n", - "mesher = MeshGenerator(background_lc=background_lc, verbosity=10)\n", + "mesher = MeshGenerator(background_lc=background_lc, verbosity=20)\n", "mesher.generate(clean_polys, clean_lines, clean_pts)\n", "\n", "# 3. Voronoi Conversion\n", @@ -136,7 +196,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 5, "id": "0ba0153a", "metadata": {}, "outputs": [], @@ -146,10 +206,31 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 6, "id": "cfd21be8", "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "gdf = calculate_mesh_quality(grid_gdf,calc_ortho=True)\n", "gdf.plot(column='drift_ratio', cmap='viridis', legend=True, figsize=(10,8),vmax=.25)" @@ -190,7 +271,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.14.0" + "version": "3.14.2" } }, "nbformat": 4, diff --git a/examples/basic_usage.py b/examples/basic_usage.py new file mode 100644 index 0000000..7b6741d --- /dev/null +++ b/examples/basic_usage.py @@ -0,0 +1,41 @@ +"""Minimal end-to-end vorflow example used by release smoke tests.""" + +from shapely.geometry import LineString, Point, box + +from vorflow import ConceptualMesh, MeshGenerator, VoronoiTessellator + + +def main(): + domain = box(0, 0, 200, 200) + well_point = Point(25, 25) + fault_line = LineString([(100, 0), (100, 150)]) + + blueprint = ConceptualMesh(crs="EPSG:3857") + blueprint.add_polygon(domain, zone_id=1) + blueprint.add_point( + well_point, + point_id="Well-A", + resolution=2, + growth_factor=1.2, + ) + blueprint.add_line( + fault_line, + line_id="Fault-1", + resolution=1, + is_barrier=True, + ) + + clean_polys, clean_lines, clean_pts = blueprint.generate() + mesher = MeshGenerator(background_lc=100) + mesher.generate(clean_polys, clean_lines, clean_pts) + + tessellator = VoronoiTessellator(mesher, blueprint, clip_to_boundary=True) + grid_gdf = tessellator.generate() + if grid_gdf.empty: + raise RuntimeError("Basic Usage generated an empty Voronoi grid") + return grid_gdf + + +if __name__ == "__main__": + grid = main() + print(f"Generated {len(grid)} Voronoi cells") diff --git a/examples/cleaning_limitations_demo.ipynb b/examples/cleaning_limitations_demo.ipynb new file mode 100644 index 0000000..48fd3b2 --- /dev/null +++ b/examples/cleaning_limitations_demo.ipynb @@ -0,0 +1,1635 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "28ffa4b8", + "metadata": {}, + "source": [ + "# Vorflow: Common Geometry Problems and How to Handle Them\n", + "\n", + "This notebook is a practical guide for users building conceptual meshes with vorflow. Each section introduces a problem you are likely to encounter when loading real geometry — what it looks like, what goes wrong if you ignore it, and exactly which parameter or utility function solves it.\n", + "\n", + "Work through the sections top to bottom. By the end you will know what to watch for before your first real mesh run." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "eb28fa9c", + "metadata": {}, + "outputs": [], + "source": [ + "%load_ext autoreload\n", + "%autoreload 2\n", + "\n", + "import time\n", + "from copy import deepcopy\n", + "\n", + "import numpy as np\n", + "import pandas as pd\n", + "import matplotlib.pyplot as plt\n", + "import matplotlib as mpl\n", + "import geopandas as gpd\n", + "\n", + "from shapely.geometry import Point, Polygon, LineString, box\n", + "from shapely.ops import unary_union\n", + "\n", + "from vorflow import ConceptualMesh, MeshGenerator, VoronoiTessellator, ThresholdField\n", + "from vorflow.utils import (\n", + " calculate_mesh_quality,\n", + " summarize_quality,\n", + " check_geometry_resolution,\n", + " resample_geometry,\n", + ")\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "2dfe37b6", + "metadata": {}, + "outputs": [], + "source": [ + "CRS = \"EPSG:3857\"\n", + "\n", + "\n", + "# ---------------------------------------------------------------------------\n", + "# Geometry helpers\n", + "# ---------------------------------------------------------------------------\n", + "def to_gdf(geometries, crs=CRS):\n", + " return gpd.GeoDataFrame({\"geometry\": geometries}, crs=crs)\n", + "\n", + "\n", + "def vertex_count(geom):\n", + " if geom.geom_type == \"Polygon\":\n", + " total = len(geom.exterior.coords)\n", + " for interior in geom.interiors:\n", + " total += len(interior.coords)\n", + " return total\n", + " if geom.geom_type == \"LineString\":\n", + " return len(geom.coords)\n", + " if geom.geom_type == \"MultiPolygon\":\n", + " return sum(vertex_count(part) for part in geom.geoms)\n", + " return 0\n", + "\n", + "\n", + "def gdf_vertex_count(gdf):\n", + " if gdf is None or gdf.empty:\n", + " return 0\n", + " return int(gdf.geometry.apply(vertex_count).sum())\n", + "\n", + "\n", + "# ---------------------------------------------------------------------------\n", + "# Pipeline runner\n", + "# ---------------------------------------------------------------------------\n", + "def run_case(\n", + " name,\n", + " domain_spec,\n", + " line_specs=None,\n", + " point_specs=None,\n", + " polygon_specs=None,\n", + " background_lc=1.0,\n", + " cm_kwargs=None,\n", + " mg_kwargs=None,\n", + " gen_kwargs=None,\n", + " resample_spacing=None,\n", + "):\n", + " \"\"\"Run a complete vorflow pipeline and return all artifacts for comparison.\"\"\"\n", + " cm_kwargs = cm_kwargs or {}\n", + " mg_kwargs = mg_kwargs or {}\n", + " gen_kwargs = gen_kwargs or {}\n", + " line_specs = line_specs or []\n", + " point_specs = point_specs or []\n", + " polygon_specs = polygon_specs or []\n", + "\n", + " # Optional upstream resampling of non-domain polygons\n", + " if resample_spacing:\n", + " polygon_specs = [\n", + " {**ps, \"geometry\": resample_geometry(ps[\"geometry\"], resample_spacing)}\n", + " for ps in polygon_specs\n", + " ]\n", + "\n", + " # Raw GDFs (for later plotting — assembled AFTER any resampling)\n", + " raw_poly_geoms = [domain_spec[\"geometry\"]] + [ps[\"geometry\"] for ps in polygon_specs]\n", + " raw_line_geoms = [ls[\"geometry\"] for ls in line_specs]\n", + " raw_point_geoms = [ps[\"geometry\"] for ps in point_specs]\n", + "\n", + " raw_polygons = gpd.GeoDataFrame({\"geometry\": raw_poly_geoms}, crs=CRS)\n", + " raw_lines = gpd.GeoDataFrame({\"geometry\": raw_line_geoms}, crs=CRS) if raw_line_geoms else None\n", + " raw_points = gpd.GeoDataFrame({\"geometry\": raw_point_geoms}, crs=CRS) if raw_point_geoms else None\n", + "\n", + " # ConceptualMesh\n", + " cm = ConceptualMesh(crs=CRS, **cm_kwargs)\n", + " cm.add_polygon(\n", + " domain_spec[\"geometry\"],\n", + " zone_id=domain_spec[\"zone_id\"],\n", + " resolution=domain_spec.get(\"resolution\"),\n", + " dist_min=domain_spec.get(\"dist_min\"),\n", + " dist_max=domain_spec.get(\"dist_max\"),\n", + " densify=domain_spec.get(\"densify\"),\n", + " z_order=domain_spec.get(\"z_order\", 0),\n", + " simplify_tolerance=domain_spec.get(\"simplify_tolerance\"),\n", + " fields=domain_spec.get(\"fields\"),\n", + " embed=domain_spec.get(\"embed\", True),\n", + " )\n", + " for ps in polygon_specs:\n", + " cm.add_polygon(\n", + " ps[\"geometry\"],\n", + " zone_id=ps[\"zone_id\"],\n", + " resolution=ps.get(\"resolution\"),\n", + " z_order=ps.get(\"z_order\", 0),\n", + " dist_min=ps.get(\"dist_min\"),\n", + " dist_max=ps.get(\"dist_max\"),\n", + " densify=ps.get(\"densify\"),\n", + " simplify_tolerance=ps.get(\"simplify_tolerance\"),\n", + " fields=ps.get(\"fields\"),\n", + " embed=ps.get(\"embed\", True),\n", + " )\n", + " for ls in line_specs:\n", + " cm.add_line(\n", + " ls[\"geometry\"],\n", + " line_id=ls[\"line_id\"],\n", + " resolution=ls[\"resolution\"],\n", + " is_barrier=ls.get(\"is_barrier\", False),\n", + " dist_min=ls.get(\"dist_min\"),\n", + " dist_max=ls.get(\"dist_max\"),\n", + " fields=ls.get(\"fields\"),\n", + " embed=ls.get(\"embed\", True),\n", + " densify=ls.get(\"densify\", True),\n", + " simplify_tolerance=ls.get(\"simplify_tolerance\"),\n", + " )\n", + " for ps in point_specs:\n", + " cm.add_point(\n", + " ps[\"geometry\"],\n", + " point_id=ps[\"point_id\"],\n", + " resolution=ps[\"resolution\"],\n", + " dist_min=ps.get(\"dist_min\"),\n", + " dist_max=ps.get(\"dist_max\"),\n", + " simplify_tolerance=ps.get(\"simplify_tolerance\"),\n", + " )\n", + "\n", + " clean_polys, clean_lines, clean_points = cm.generate()\n", + "\n", + " # Meshing\n", + " t0 = time.time()\n", + " mesh_success = False\n", + " mg = grid = quality = None\n", + " error = \"\"\n", + " try:\n", + " mg = MeshGenerator(background_lc=background_lc, **mg_kwargs)\n", + " mg.generate(clean_polys, clean_lines, clean_points, **gen_kwargs)\n", + " mesh_success = True\n", + " vt = VoronoiTessellator(mg, cm, clip_to_boundary=True)\n", + " grid = vt.generate()\n", + " quality = calculate_mesh_quality(grid)\n", + " except Exception as exc:\n", + " error = str(exc)\n", + " mesh_s = round(time.time() - t0, 2)\n", + "\n", + " return dict(\n", + " name=name,\n", + " raw_polygons=raw_polygons,\n", + " raw_lines=raw_lines,\n", + " raw_points=raw_points,\n", + " clean_polys=clean_polys,\n", + " clean_lines=clean_lines,\n", + " clean_points=clean_points,\n", + " mg=mg,\n", + " grid=grid,\n", + " quality=quality,\n", + " mesh_success=mesh_success,\n", + " mesh_s=mesh_s,\n", + " error=error,\n", + " )\n", + "\n", + "\n", + "# ---------------------------------------------------------------------------\n", + "# Summary table helper\n", + "# ---------------------------------------------------------------------------\n", + "def result_row(case):\n", + " \"\"\"Return a dict suitable for building a summary DataFrame.\"\"\"\n", + " return {\n", + " \"case\": case[\"name\"],\n", + " \"raw_poly_vertices\": gdf_vertex_count(case[\"raw_polygons\"]),\n", + " \"clean_poly_vertices\": gdf_vertex_count(case[\"clean_polys\"]),\n", + " \"mesh_success\": case[\"mesh_success\"],\n", + " \"grid_cells\": len(case[\"grid\"]) if case[\"grid\"] is not None else 0,\n", + " \"mesh_s\": case[\"mesh_s\"],\n", + " \"error\": case[\"error\"],\n", + " }\n", + "\n", + "\n", + "# ---------------------------------------------------------------------------\n", + "# Plot helpers\n", + "# ---------------------------------------------------------------------------\n", + "def _plot_case_row(axes, case, label, tint, nodes=None):\n", + " \"\"\"Fill a 3-axes row (raw | clean | grid) for one case.\"\"\"\n", + " ax_raw, ax_clean, ax_grid = axes\n", + "\n", + " # Raw\n", + " if case[\"raw_polygons\"] is not None and not case[\"raw_polygons\"].empty:\n", + " case[\"raw_polygons\"].boundary.plot(ax=ax_raw, color=\"black\", linewidth=0.8)\n", + " if case[\"raw_lines\"] is not None and not case[\"raw_lines\"].empty:\n", + " case[\"raw_lines\"].plot(ax=ax_raw, color=\"steelblue\", linewidth=1.5, zorder=3)\n", + " if case[\"raw_points\"] is not None and not case[\"raw_points\"].empty:\n", + " case[\"raw_points\"].plot(ax=ax_raw, color=\"crimson\", markersize=8, zorder=4)\n", + " ax_raw.set_title(f\"{label}\\nInput geometry\", fontsize=9, fontweight=\"bold\")\n", + " ax_raw.set_facecolor(tint)\n", + "\n", + " # Clean\n", + " if case[\"clean_polys\"] is not None and not case[\"clean_polys\"].empty:\n", + " case[\"clean_polys\"].boundary.plot(ax=ax_clean, color=\"black\", linewidth=0.8)\n", + " if case[\"clean_lines\"] is not None and not case[\"clean_lines\"].empty:\n", + " case[\"clean_lines\"].plot(ax=ax_clean, color=\"steelblue\", linewidth=1.5, zorder=3)\n", + " if case[\"clean_points\"] is not None and not case[\"clean_points\"].empty:\n", + " case[\"clean_points\"].plot(ax=ax_clean, color=\"green\", markersize=8, zorder=4)\n", + " ax_clean.set_title(\"After preprocessing\", fontsize=9)\n", + " ax_clean.set_facecolor(tint)\n", + "\n", + " # Grid\n", + " if case[\"grid\"] is not None and not case[\"grid\"].empty:\n", + " case[\"grid\"].plot(ax=ax_grid, alpha=0.45, edgecolor=\"black\", linewidth=0.25)\n", + " if nodes is not None:\n", + " ax_grid.scatter(\n", + " nodes[:, 0], nodes[:, 1],\n", + " s=5, color=\"dimgray\", alpha=0.35, zorder=3, linewidths=0,\n", + " )\n", + " ax_grid.set_title(\"Voronoi grid\", fontsize=9)\n", + "\n", + " for ax in axes:\n", + " ax.set_aspect(\"equal\")\n", + " ax.grid(alpha=0.2)\n", + "\n", + "\n", + "def plot_comparison(case_a, case_b, label_a=\"Case A\", label_b=\"Case B\",\n", + " nodes_a=None, nodes_b=None):\n", + " \"\"\"2 × 3 comparison plot: raw / clean / grid for two cases.\"\"\"\n", + " fig, axes = plt.subplots(2, 3, figsize=(18, 10))\n", + " _plot_case_row(axes[0], case_a, label_a, \"#fff0f0\", nodes=nodes_a)\n", + " _plot_case_row(axes[1], case_b, label_b, \"#f0fff0\", nodes=nodes_b)\n", + " plt.suptitle(\n", + " \"Rows compare two cases; columns show input, preprocessing, and final Voronoi grid\",\n", + " fontweight=\"bold\",\n", + " fontsize=11,\n", + " )\n", + " plt.tight_layout(rect=(0, 0, 1, 0.96))\n", + " plt.show()\n", + "\n", + "\n", + "def plot_case(case, label=\"\", nodes=None):\n", + " \"\"\"1 × 3 single-case plot: raw / clean / grid.\"\"\"\n", + " fig, axes = plt.subplots(1, 3, figsize=(18, 5))\n", + " _plot_case_row(axes, case, label, \"#f5f5ff\", nodes=nodes)\n", + " plt.suptitle(label, fontweight=\"bold\", fontsize=12)\n", + " plt.tight_layout(rect=(0, 0, 1, 0.95))\n", + " plt.show()\n" + ] + }, + { + "cell_type": "markdown", + "id": "936b6300", + "metadata": {}, + "source": [ + "---\n", + "## Problem 1 — Duplicate and Near-Duplicate Vertices\n", + "\n", + "**What you'll see:** You export river or boundary geometry from a GIS tool and two consecutive vertices in the same linestring share the exact same coordinate — or differ by a sub-nanometre floating-point rounding error.\n", + "\n", + "**What goes wrong:** Gmsh treats a zero-length or near-zero line segment as a degenerate element and can reject the geometry during OCC line creation.\n", + "\n", + "**How vorflow handles it:** The meshing path now has a guard at geometry transfer: `MeshGenerator` filters invalid and near-duplicate coordinates before creating OCC entities. That means mesh generation can succeed even when the displayed `clean_lines` were later densified and have more vertices than the raw input.\n", + "\n", + "The diagnostic below therefore checks **short consecutive segments**, not just vertex counts. Vertex counts are still useful context, but after densification they are not proof that duplicates were removed.\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "c92290f7", + "metadata": {}, + "outputs": [], + "source": [ + "domain = {\n", + " \"geometry\": box(0, 0, 10, 10),\n", + " \"zone_id\": 1,\n", + " \"resolution\": 4.0,\n", + " \"dist_max\": 20.0,\n", + "}\n", + "\n", + "line_with_duplicate = LineString([(1, 1), (5, 5), (5, 5), (9, 9)])\n", + "line_with_near_duplicate = LineString([(1, 8), (5, 8), (5 + 1e-9, 8), (9, 8)])\n", + "\n", + "\n", + "def short_segment_count(line, tol=1e-8):\n", + " coords = list(line.coords)\n", + " return sum(\n", + " Point(coords[i]).distance(Point(coords[i + 1])) <= tol\n", + " for i in range(len(coords) - 1)\n", + " )\n", + "\n", + "\n", + "duplicate_case = run_case(\n", + " name=\"duplicate-and-near-duplicate-line-vertices\",\n", + " domain_spec=domain,\n", + " line_specs=[\n", + " {\n", + " \"geometry\": line_with_duplicate,\n", + " \"line_id\": \"duplicate_vertices\",\n", + " \"resolution\": 1.0,\n", + " },\n", + " {\n", + " \"geometry\": line_with_near_duplicate,\n", + " \"line_id\": \"near_duplicate_vertices\",\n", + " \"resolution\": 1.0,\n", + " },\n", + " ],\n", + " background_lc=4.0,\n", + ")\n", + "\n", + "# Show duplicate/near-duplicate diagnostics. Clean vertex counts are reported\n", + "# only as context because line densification can add vertices after cleaning.\n", + "for label, raw_line, clean_line in [\n", + " (\"Line 1 ? exact duplicate at (5, 5)\", line_with_duplicate, duplicate_case[\"clean_lines\"].geometry.iloc[0]),\n", + " (\"Line 2 ? near-duplicate pair at ~(5, 8)\", line_with_near_duplicate, duplicate_case[\"clean_lines\"].geometry.iloc[1]),\n", + "]:\n", + " print(label + \":\")\n", + " print(f\" Input vertices : {len(list(raw_line.coords))}\")\n", + " print(f\" Clean vertices : {len(list(clean_line.coords))} (after optional densification)\")\n", + " print(f\" Raw short segments : {short_segment_count(raw_line)}\")\n", + " print(f\" Clean short segments : {short_segment_count(clean_line)}\")\n", + " print()\n", + "\n", + "print(f\"Mesh generation succeeded: {duplicate_case[\"mesh_success\"]}\")\n", + "print(\"Note: any remaining near-zero segment is filtered before Gmsh OCC creation.\")\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "2c2d764b", + "metadata": {}, + "outputs": [], + "source": [ + "\n", + "fig, axes = plt.subplots(1, 3, figsize=(18, 5))\n", + "ax_raw, ax_clean, ax_grid = axes\n", + "\n", + "# --- raw geometry: highlight the problem coordinates ---\n", + "duplicate_case[\"raw_polygons\"].boundary.plot(ax=ax_raw, color=\"black\", linewidth=1)\n", + "duplicate_case[\"raw_lines\"].plot(ax=ax_raw, color=\"steelblue\", linewidth=1.5)\n", + "\n", + "for x, y, lbl in [(5, 5, \"exact duplicate\"), (5, 8, \"near-duplicate\\n(1e-9 m gap)\")]:\n", + " ax_raw.plot(x, y, \"o\", color=\"red\", markersize=18, alpha=0.75, zorder=5)\n", + " ax_raw.annotate(\n", + " lbl, xy=(x, y), xytext=(x + 1.0, y + 0.8),\n", + " fontsize=8, color=\"darkred\",\n", + " arrowprops=dict(arrowstyle=\"->\", color=\"darkred\", lw=1.2),\n", + " )\n", + "\n", + "ax_raw.set_title(\"Input geometry ✗\\n(duplicate vertices highlighted in red)\", fontsize=10, color=\"darkred\")\n", + "ax_raw.set_facecolor(\"#fff0f0\")\n", + "\n", + "# --- cleaned geometry ---\n", + "duplicate_case[\"clean_polys\"].boundary.plot(ax=ax_clean, color=\"black\", linewidth=1)\n", + "duplicate_case[\"clean_lines\"].plot(ax=ax_clean, color=\"steelblue\", linewidth=1.5)\n", + "ax_clean.set_title(\"After ConceptualMesh preprocessing ✓\\n(duplicates removed)\", fontsize=10, color=\"darkgreen\")\n", + "ax_clean.set_facecolor(\"#f0fff0\")\n", + "\n", + "# --- resulting Voronoi grid with subtle Gmsh triangle-mesh nodes ---\n", + "grid = duplicate_case.get(\"grid\")\n", + "if grid is not None and not grid.empty:\n", + " grid.plot(ax=ax_grid, alpha=0.5, edgecolor=\"black\", linewidth=0.25)\n", + "mg = duplicate_case.get(\"mg\")\n", + "if mg is not None and mg.nodes is not None:\n", + " ax_grid.scatter(\n", + " mg.nodes[:, 0], mg.nodes[:, 1],\n", + " s=5, color=\"dimgray\", alpha=0.35, zorder=3, linewidths=0,\n", + " label=\"mesh nodes\",\n", + " )\n", + "ax_grid.set_title(\"Voronoi grid + mesh nodes (grey dots)\\n(mesh succeeds cleanly)\", fontsize=10)\n", + "\n", + "for ax in axes:\n", + " ax.set_aspect(\"equal\")\n", + " ax.grid(alpha=0.2)\n", + "\n", + "plt.suptitle(\"Problem 1: Duplicate Vertices — detected and removed automatically\", fontweight=\"bold\", fontsize=12)\n", + "plt.tight_layout()\n", + "plt.show()\n" + ] + }, + { + "cell_type": "markdown", + "id": "7018a8d3", + "metadata": {}, + "source": [ + "## Problem 2 — Features That Don't Quite Reach the Domain Boundary\n", + "\n", + "**What you'll see:** After digitising in a GIS, a monitoring well is snapped to the wrong layer and ends up 5 cm outside the domain boundary.\n", + "\n", + "**Current behavior:** If the point cannot be snapped into the resolved domain, `ConceptualMesh.generate()` removes it from `clean_points`. That is safer than sending an outside point to Gmsh and later clipping away its Voronoi cell, but the practical effect is the same: the well has **zero influence on the grid**.\n", + "\n", + "**What goes wrong:** `connectivity_tolerance` defaults to 1 mm. A gap of 5 cm is well outside that range, so the point is not snapped. During domain clipping it is removed before meshing.\n", + "\n", + "**Fix — `connectivity_tolerance`:** Raise the tolerance to cover the gap. Any endpoint within that distance of the nearest feature vertex (domain boundary, line vertex) is snapped onto it before meshing.\n", + "\n", + "```python\n", + "cm = ConceptualMesh(crs=\"EPSG:3857\", connectivity_tolerance=0.1) # snap within 10 cm\n", + "```\n", + "\n", + "**Important caveats for real data:**\n", + "\n", + "* `connectivity_tolerance` uses Shapely's `snap()` internally, so the well can only move to an **existing vertex** of the reference geometry. It does **not** snap to an arbitrary point along an edge.\n", + "* In this demo the river already has a vertex at `(0, 1.0)`, so the well has an exact snap target.\n", + "* `ConceptualMesh.generate()` runs in this order: **simplify → snap/connectivity → clip to domain → densify**.\n", + "* That means `simplify_tolerance` can remove the very vertex you needed as a snap target.\n", + "* It also means `densify=` does **not** help snapping, because densified vertices are added only after snapping has finished.\n", + "* If your target location lies on a long edge with no nearby vertex, `resample_geometry()` applied **before** `add_polygon()` or `add_line()` is usually the better tool.\n", + "* In those cases, **resampling without simplification** can be the safer option, because simplification may clean away the candidate vertices you needed for the snap.\n", + "\n", + "The comparison below uses a river crossing the domain and a well 5 cm outside the domain near the river's entry point. The river is intentionally kept as coarse as the background mesh while the well requests much finer cells, so the snapped case creates a visibly tighter local node cluster. The plot includes a zoomed panel because the full-domain grid can make the boundary-local difference look subtler than it is.\n", + "\n", + "* **Bad** (`tol=0.01`, 1 cm): well stays outside → removed from `clean_points` → no local refinement \n", + "* **Good** (`tol=0.1`, 10 cm): well snaps to the river's entry vertex at `(0, 1.0)` → proper boundary node → fine local refinement becomes visible\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "f83a1d8c", + "metadata": {}, + "outputs": [], + "source": [ + "# Geometry: domain box, river line from boundary to boundary, well 5 cm outside domain\n", + "snap_domain = {\"geometry\": box(0, 0, 2, 2), \"zone_id\": 1, \"resolution\": 1.0}\n", + "snap_lines = [{\n", + " \"geometry\": LineString([(0, 1.0), (2, 1.0)]),\n", + " \"line_id\": \"river\",\n", + " \"resolution\": 1.0,\n", + " \"dist_max\": 0.10,\n", + " \"densify\": False,\n", + "}]\n", + "snap_points = [{\n", + " \"geometry\": Point(-0.05, 1.0),\n", + " \"point_id\": \"well\",\n", + " \"resolution\": 0.025,\n", + " \"dist_max\": 0.55,\n", + "}]\n", + "# Note: well is 5 cm outside the domain at x = 0. The river starts exactly at (0, 1.0)\n", + "# on the domain boundary, providing the snap target when tolerance is large enough.\n", + "# The river uses background-scale sizing; the well is much finer so snapping is visually obvious.\n", + "\n", + "snap_low = run_case(\n", + " name=\"connectivity_tolerance=0.01 (gap not snapped)\",\n", + " domain_spec=snap_domain,\n", + " line_specs=snap_lines,\n", + " point_specs=snap_points,\n", + " background_lc=1.0,\n", + " cm_kwargs={\"connectivity_tolerance\": 0.01}, # 5 cm gap > 1 cm tol → no snap\n", + ")\n", + "\n", + "snap_good = run_case(\n", + " name=\"connectivity_tolerance=0.1 (gap snapped)\",\n", + " domain_spec=snap_domain,\n", + " line_specs=snap_lines,\n", + " point_specs=snap_points,\n", + " background_lc=1.0,\n", + " cm_kwargs={\"connectivity_tolerance\": 0.1}, # 5 cm gap < 10 cm tol → snaps to (0, 1.0)\n", + ")\n", + "\n", + "from shapely.geometry import box as _sbox\n", + "_domain_geom = _sbox(0, 0, 2, 2)\n", + "\n", + "def _pt_info(case):\n", + " pts = case[\"clean_points\"]\n", + " if pts is None or pts.empty:\n", + " return \"no points\"\n", + " geom = pts.geometry.iloc[0]\n", + " d = _domain_geom.exterior.distance(geom)\n", + " status = \"ON boundary\" if d < 1e-9 else f\"{d*100:.1f} cm OUTSIDE\"\n", + " return f\"{geom} → {status}\"\n", + "\n", + "print(f\"Low tolerance — well after preprocessing: {_pt_info(snap_low)}\")\n", + "print(f\"Good tolerance — well after preprocessing: {_pt_info(snap_good)}\")\n", + "print()\n", + "cells_low = len(snap_low[\"grid\"]) if snap_low[\"grid\"] is not None else 0\n", + "cells_good = len(snap_good[\"grid\"]) if snap_good[\"grid\"] is not None else 0\n", + "print(f\"Low tolerance — {cells_low} Voronoi cells (well clipped away, no local point refinement)\")\n", + "print(f\"Good tolerance — {cells_good} Voronoi cells (well snaps to a boundary vertex and activates fine refinement)\")\n", + "print()\n", + "print(\"Caveat: the river already contributes a vertex at (0, 1.0).\")\n", + "print(\"The visible difference comes from the snapped well requesting much finer cells than the river/background mesh.\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "2a663e79", + "metadata": {}, + "outputs": [], + "source": [ + "nodes_low = snap_low[\"mg\"].nodes if snap_low[\"mg\"] is not None else None\n", + "nodes_good = snap_good[\"mg\"].nodes if snap_good[\"mg\"] is not None else None\n", + "\n", + "\n", + "def _zoom_node_count(nodes, xlim=(-0.08, 0.55), ylim=(0.45, 1.55)):\n", + " if nodes is None:\n", + " return 0\n", + " in_x = (nodes[:, 0] >= xlim[0]) & (nodes[:, 0] <= xlim[1])\n", + " in_y = (nodes[:, 1] >= ylim[0]) & (nodes[:, 1] <= ylim[1])\n", + " return int((in_x & in_y).sum())\n", + "\n", + "print(f\"Low tolerance zoom nodes : {_zoom_node_count(nodes_low)}\")\n", + "print(f\"Good tolerance zoom nodes: {_zoom_node_count(nodes_good)}\")\n", + "\n", + "fig, axes = plt.subplots(2, 4, figsize=(22, 10))\n", + "\n", + "_plot_case_row(\n", + " axes[0, :3],\n", + " snap_low,\n", + " \"tol=0.01 -- well remains outside\",\n", + " \"#fff0f0\",\n", + " nodes=nodes_low,\n", + ")\n", + "_plot_case_row(\n", + " axes[1, :3],\n", + " snap_good,\n", + " \"tol=0.10 -- well snaps to river vertex\",\n", + " \"#f0fff0\",\n", + " nodes=nodes_good,\n", + ")\n", + "\n", + "def _plot_snap_zoom(ax, case, nodes, title, tint):\n", + " if case[\"grid\"] is not None and not case[\"grid\"].empty:\n", + " case[\"grid\"].plot(ax=ax, alpha=0.50, edgecolor=\"black\", linewidth=0.30)\n", + " if case[\"clean_lines\"] is not None and not case[\"clean_lines\"].empty:\n", + " case[\"clean_lines\"].plot(ax=ax, color=\"steelblue\", linewidth=1.8, zorder=4)\n", + " if case[\"clean_points\"] is not None and not case[\"clean_points\"].empty:\n", + " case[\"clean_points\"].plot(ax=ax, color=\"crimson\", markersize=45, zorder=6)\n", + " if nodes is not None:\n", + " ax.scatter(nodes[:, 0], nodes[:, 1], s=10, color=\"dimgray\", alpha=0.55, zorder=5, linewidths=0)\n", + " ax.set_xlim(-0.08, 0.55)\n", + " ax.set_ylim(0.45, 1.55)\n", + " ax.set_aspect(\"equal\")\n", + " ax.grid(alpha=0.25)\n", + " ax.set_facecolor(tint)\n", + " ax.set_title(title, fontsize=9, fontweight=\"bold\")\n", + "\n", + "_plot_snap_zoom(\n", + " axes[0, 3],\n", + " snap_low,\n", + " nodes_low,\n", + " \"Zoom: well is outside\\nno fine boundary node cluster\",\n", + " \"#fff0f0\",\n", + ")\n", + "_plot_snap_zoom(\n", + " axes[1, 3],\n", + " snap_good,\n", + " nodes_good,\n", + " \"Zoom: snapped well on boundary\\nfine node cluster is active\",\n", + " \"#f0fff0\",\n", + ")\n", + "\n", + "for ax in axes[:, 3]:\n", + " ax.axvline(0, color=\"black\", linewidth=0.8, alpha=0.6)\n", + " ax.axhline(1.0, color=\"steelblue\", linewidth=0.8, linestyle=\"--\", alpha=0.7)\n", + "\n", + "plt.suptitle(\n", + " \"Problem 2: connectivity_tolerance controls whether the outside well participates in the mesh\",\n", + " fontweight=\"bold\",\n", + " fontsize=12,\n", + ")\n", + "plt.tight_layout(rect=(0, 0, 1, 0.96))\n", + "plt.show()\n" + ] + }, + { + "cell_type": "markdown", + "id": "46cf45b7", + "metadata": {}, + "source": [ + "---\n", + "## Problem 3 — Irregular Vertex Spacing: Useful Tool or Extra Constraint?\n", + "\n", + "**What you'll see:** Source geometry can have clustered vertices in one part of a boundary and long, simple segments elsewhere. That does not mean Gmsh will leave the long segment unmeshed: Gmsh still discretizes curves from the active mesh-size field.\n", + "\n", + "**The real question:** Does changing the source geometry improve the final mesh, or does it just add constraints that Gmsh did not need?\n", + "\n", + "**Tools to compare:**\n", + "\n", + "| Tool | How to use | What it does | Tradeoff |\n", + "|------|-----------|-------------|----------|\n", + "| No preprocessing | pass geometry as-is | Lets Gmsh choose mesh nodes from the size field | Acceptable when quality diagnostics are already good |\n", + "| `add_polygon(..., simplify_tolerance=1.0)` / `add_line(..., simplify_tolerance=1.0)` | blueprint parameter | Removes redundant/noisy source vertices without inserting new CAD points | Can erase intentional small features if the tolerance is too high |\n", + "| `resample_geometry(geom, spacing)` | before `add_polygon` / `add_line` | Redistributes vertices to near-uniform spacing | May move/remove original vertices and sharp source spacing patterns |\n", + "| `simplify_tolerance` + `densify` | blueprint parameters | Removes noisy clusters first, then caps long segments | Best when the source has both noise and long gaps |\n", + "\n", + "The cells below use deliberately coarse meshes so local differences are visible, and diagnostics rather than assumptions. Both experiments use the same numeric source-cleanup parameters (`simplify_tolerance=1.0`, `resample_spacing=10.0`, and `densify=10.0` only after simplification). 3B keeps a bigger cell-size setting, but its polygon context receives the same cleanup operation as the matching 3A column.\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "63927fe3", + "metadata": {}, + "outputs": [], + "source": [ + "# ---------------------------------------------------------------------------\n", + "# Problem 3A: embedded polygon boundary with noisy clusters and long gaps\n", + "# ---------------------------------------------------------------------------\n", + "noisy_uneven_coords = [\n", + " (10, 10), (11, 10.2), (11.5, 9.8), (12, 10.2), (15, 10),\n", + " (50, 10), (85, 10), (88, 14), (90, 20), (90, 85),\n", + " (85, 90), (50, 95), (15, 90), (10, 85), (10, 50), (10, 20),\n", + "]\n", + "noisy_uneven_poly = Polygon(noisy_uneven_coords)\n", + "\n", + "spacing_domain = {\n", + " \"geometry\": box(0, 0, 100, 100),\n", + " \"zone_id\": 1,\n", + " \"resolution\": 20.0,\n", + "}\n", + "\n", + "\n", + "def run_spacing_polygon_case(\n", + " name,\n", + " geometry,\n", + " *,\n", + " densify=False,\n", + " simplify_tolerance=None,\n", + " resample_spacing=None,\n", + " cm_kwargs=None,\n", + " mg_kwargs=None,\n", + "):\n", + " geom = resample_geometry(geometry, resample_spacing) if resample_spacing else geometry\n", + " return run_case(\n", + " name=name,\n", + " domain_spec=spacing_domain,\n", + " polygon_specs=[\n", + " {\n", + " \"geometry\": geom,\n", + " \"zone_id\": 2,\n", + " \"resolution\": 10,\n", + " \"z_order\": 1,\n", + " \"dist_max\": 30.0,\n", + " \"densify\": densify,\n", + " \"simplify_tolerance\": simplify_tolerance,\n", + " }\n", + " ],\n", + " background_lc=20.0,\n", + " cm_kwargs=cm_kwargs,\n", + " mg_kwargs=mg_kwargs,\n", + " )\n", + "\n", + "\n", + "polygon_spacing_cases = [\n", + " run_spacing_polygon_case(\"polygon-baseline\", noisy_uneven_poly, densify=False),\n", + " run_spacing_polygon_case(\"polygon-simplify-1\", noisy_uneven_poly, densify=False, simplify_tolerance=1.0),\n", + " run_spacing_polygon_case(\"polygon-resample-10\", noisy_uneven_poly, densify=False, resample_spacing=10.0),\n", + " run_spacing_polygon_case(\n", + " \"polygon-simplify-1-densify-10\",\n", + " noisy_uneven_poly,\n", + " densify=10.0,\n", + " simplify_tolerance=1.0,\n", + " ),\n", + "]\n", + "\n", + "\n", + "# ---------------------------------------------------------------------------\n", + "# Problem 3B: embedded diagonal line crossing the polygon context\n", + "# ---------------------------------------------------------------------------\n", + "spacing_line = LineString([(5, 5), (20, 20), (35, 35), (50, 50), (65, 65), (80, 80), (95, 95)])\n", + "spacing_line_domain = {\n", + " \"geometry\": box(0, 0, 100, 100),\n", + " \"zone_id\": 1,\n", + " \"resolution\": 20.0,\n", + "}\n", + "\n", + "\n", + "def run_spacing_line_case(\n", + " name,\n", + " *,\n", + " densify=False,\n", + " simplify_tolerance=None,\n", + " resample_spacing=None,\n", + " polygon_densify=False,\n", + " polygon_simplify_tolerance=None,\n", + " polygon_resample_spacing=None,\n", + " cm_kwargs=None,\n", + " mg_kwargs=None,\n", + " gen_kwargs=None,\n", + "):\n", + " geom = resample_geometry(spacing_line, resample_spacing) if resample_spacing else spacing_line\n", + " polygon_geom = resample_geometry(noisy_uneven_poly, polygon_resample_spacing) if polygon_resample_spacing else noisy_uneven_poly\n", + " field = ThresholdField(\n", + " size_min=5.0,\n", + " dist_min=2.0,\n", + " dist_max=18.0,\n", + " size_max=20.0,\n", + " sampling=5,\n", + " )\n", + " return run_case(\n", + " name=name,\n", + " domain_spec=spacing_line_domain,\n", + " polygon_specs=[\n", + " {\n", + " \"geometry\": polygon_geom,\n", + " \"zone_id\": 2,\n", + " \"resolution\": 10.0,\n", + " \"z_order\": 1,\n", + " \"dist_max\": 30,\n", + " \"densify\": polygon_densify,\n", + " \"simplify_tolerance\": polygon_simplify_tolerance,\n", + " }\n", + " ],\n", + " line_specs=[\n", + " {\n", + " \"geometry\": geom,\n", + " \"line_id\": \"embedded_diagonal_refinement_line\",\n", + " \"resolution\": 5.0,\n", + " \"fields\": [field],\n", + " \"embed\": True,\n", + " \"densify\": densify,\n", + " \"simplify_tolerance\": simplify_tolerance,\n", + " }\n", + " ],\n", + " background_lc=20.0,\n", + " cm_kwargs=cm_kwargs,\n", + " mg_kwargs=mg_kwargs,\n", + " gen_kwargs=gen_kwargs,\n", + " )\n", + "\n", + "\n", + "spacing_line_cases = [\n", + " run_spacing_line_case(\"line-polygon-baseline\", densify=False, polygon_densify=False),\n", + " run_spacing_line_case(\"line-polygon-simplify-1\", simplify_tolerance=1.0, polygon_simplify_tolerance=1.0),\n", + " run_spacing_line_case(\"line-polygon-resample-10\", resample_spacing=10.0, polygon_resample_spacing=10.0),\n", + " run_spacing_line_case(\n", + " \"line-polygon-simplify-1-densify-10\",\n", + " simplify_tolerance=1.0,\n", + " densify=10.0,\n", + " polygon_simplify_tolerance=1.0,\n", + " polygon_densify=10.0,\n", + " ),\n", + "]\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "ee14b728", + "metadata": {}, + "outputs": [], + "source": [ + "def _zone_geom(case, zone_id=2):\n", + " zone_mask = case[\"clean_polys\"][\"zone_id\"] == zone_id\n", + " return case[\"clean_polys\"].loc[zone_mask, \"geometry\"].iloc[0]\n", + "\n", + "\n", + "def _segment_stats(geom):\n", + " stats = check_geometry_resolution(to_gdf([geom]))\n", + " if isinstance(stats, str):\n", + " return {\"min\": np.nan, \"max\": np.nan, \"median\": np.nan, \"count\": 0, \"max_median_ratio\": np.nan}\n", + " median = stats[\"median\"]\n", + " return {\n", + " \"min\": stats[\"min\"],\n", + " \"max\": stats[\"max\"],\n", + " \"median\": median,\n", + " \"count\": stats[\"count\"],\n", + " \"max_median_ratio\": stats[\"max\"] / median if median else np.nan,\n", + " }\n", + "\n", + "\n", + "def _local_quality(case, reference_geom, band_distance):\n", + " quality = case[\"quality\"]\n", + " if quality is None or quality.empty:\n", + " return {\"local_cells\": 0, \"compact_p05\": np.nan, \"compact_median\": np.nan, \"drift_p95\": np.nan, \"drift_max\": np.nan, \"area_cv\": np.nan}\n", + "\n", + " generators = gpd.GeoSeries(gpd.points_from_xy(quality.x, quality.y), crs=CRS)\n", + " target = reference_geom.boundary if reference_geom.geom_type in (\"Polygon\", \"MultiPolygon\") else reference_geom\n", + " local = quality.loc[generators.distance(target) <= band_distance]\n", + " if local.empty:\n", + " return {\"local_cells\": 0, \"compact_p05\": np.nan, \"compact_median\": np.nan, \"drift_p95\": np.nan, \"drift_max\": np.nan, \"area_cv\": np.nan}\n", + "\n", + " return {\n", + " \"local_cells\": int(len(local)),\n", + " \"compact_p05\": local[\"compactness\"].quantile(0.05),\n", + " \"compact_median\": local[\"compactness\"].median(),\n", + " \"drift_p95\": local[\"drift_ratio\"].quantile(0.95),\n", + " \"drift_max\": local[\"drift_ratio\"].max(),\n", + " \"area_cv\": local[\"area\"].std() / local[\"area\"].mean(),\n", + " }\n", + "\n", + "\n", + "def _vertex_context_row(label, geom, note):\n", + " spacing = _segment_stats(geom)\n", + " coords = list(geom.exterior.coords) if geom.geom_type == \"Polygon\" else list(geom.coords)\n", + " return {\n", + " \"case\": label,\n", + " \"vertices\": len(coords),\n", + " \"min_seg\": spacing[\"min\"],\n", + " \"max_seg\": spacing[\"max\"],\n", + " \"median_seg\": spacing[\"median\"],\n", + " \"max_median_ratio\": spacing[\"max_median_ratio\"],\n", + " \"note\": note,\n", + " }\n", + "\n", + "\n", + "def _polygon_diagnostic_row(case):\n", + " clean_geom = _zone_geom(case)\n", + " spacing = _segment_stats(clean_geom)\n", + " local = _local_quality(case, clean_geom, band_distance=15.0)\n", + " return {\n", + " \"case\": case[\"name\"],\n", + " \"clean_vertices\": len(clean_geom.exterior.coords),\n", + " \"clean_max_seg\": spacing[\"max\"],\n", + " \"max_median_ratio\": spacing[\"max_median_ratio\"],\n", + " \"cells\": len(case[\"grid\"]) if case[\"grid\"] is not None else 0,\n", + " **local,\n", + " }\n", + "\n", + "\n", + "def _line_diagnostic_row(case):\n", + " line_geom = case[\"clean_lines\"].geometry.iloc[0]\n", + " spacing = _segment_stats(line_geom)\n", + " local = _local_quality(case, line_geom, band_distance=6.0)\n", + " return {\n", + " \"case\": case[\"name\"],\n", + " \"clean_vertices\": len(line_geom.coords),\n", + " \"clean_max_seg\": spacing[\"max\"],\n", + " \"cells\": len(case[\"grid\"]) if case[\"grid\"] is not None else 0,\n", + " **local,\n", + " }\n", + "\n", + "\n", + "polygon_vertex_variants = [\n", + " (\"Baseline input\", noisy_uneven_poly, \"clustered vertices plus long gaps\"),\n", + " (\"simplify=1.0\", _zone_geom(polygon_spacing_cases[1]), \"removes small wiggles without adding vertices\"),\n", + " (\"resample_geometry(..., 10.0)\", _zone_geom(polygon_spacing_cases[2]), \"redistributes the ring to near-uniform spacing\"),\n", + " (\"simplify=1.0 + densify=10.0\", _zone_geom(polygon_spacing_cases[3]), \"removes small wiggles, then caps long segments\"),\n", + "]\n", + "\n", + "vertex_context_df = pd.DataFrame([_vertex_context_row(label, geom, note) for label, geom, note in polygon_vertex_variants])\n", + "print(\"Source/clean vertex spacing context:\")\n", + "display(vertex_context_df.round({\"min_seg\": 2, \"max_seg\": 2, \"median_seg\": 2, \"max_median_ratio\": 2}))\n", + "\n", + "fig, axes = plt.subplots(2, 2, figsize=(14, 11))\n", + "for ax, (label, geom, note) in zip(axes.ravel(), polygon_vertex_variants):\n", + " coords = list(geom.exterior.coords)\n", + " xs, ys = zip(*coords)\n", + " ax.plot(xs, ys, color=\"black\", linewidth=1.2)\n", + " ax.plot(xs, ys, \"o\", color=\"red\", markersize=2, zorder=5)\n", + " ax.set_title(f\"{label}\\n{len(coords)} vertices - {note}\", fontsize=10)\n", + " ax.set_aspect(\"equal\")\n", + " ax.grid(alpha=0.2)\n", + " ax.set_xlim(5, 95)\n", + " ax.set_ylim(5, 100)\n", + "plt.suptitle(\"Problem 3A: source vertices before judging mesh quality\", fontweight=\"bold\", fontsize=12)\n", + "plt.tight_layout(rect=(0, 0, 1, 0.96))\n", + "plt.show()\n", + "\n", + "polygon_diagnostics = pd.DataFrame([_polygon_diagnostic_row(case) for case in polygon_spacing_cases])\n", + "line_diagnostics = pd.DataFrame([_line_diagnostic_row(case) for case in spacing_line_cases])\n", + "\n", + "print(\"Metric guide: compact_p05/compact_median higher is better; drift_p95/drift_max and area_cv lower are better; clean_max_seg is source spacing, not a quality score.\")\n", + "print(\"Experiment 3A - embedded polygon boundary\")\n", + "display(polygon_diagnostics.round({\"clean_max_seg\": 2, \"max_median_ratio\": 2, \"compact_p05\": 4, \"compact_median\": 4, \"drift_p95\": 4, \"drift_max\": 4, \"area_cv\": 4}))\n", + "\n", + "print(\"Experiment 3B - embedded diagonal line crossing the polygon\")\n", + "display(line_diagnostics.round({\"clean_max_seg\": 2, \"compact_p05\": 4, \"compact_median\": 4, \"drift_p95\": 4, \"drift_max\": 4, \"area_cv\": 4}))\n", + "\n", + "print(\"Interpretation:\")\n", + "print(\" * Gmsh meshes long curves from the active size field; source densification is not mandatory.\")\n", + "print(\" * Simplify-only removes redundant/noisy source detail without adding new CAD points.\")\n", + "print(\" * Resampling redistributes source vertices; simplify + densify removes noise first, then caps long remaining segments.\")\n", + "print(\" * In 3B, the same cleanup is applied to the polygon context and the embedded line, while keeping the coarser cell-size settings.\")\n", + "print(\" * Use the least intrusive tool that improves the local diagnostics you care about; baseline is acceptable when metrics are already good.\")\n", + "\n", + "fig, axes = plt.subplots(2, 4, figsize=(22, 11), constrained_layout=True)\n", + "quality_metric = \"compactness\"\n", + "quality_vmin = 0.55\n", + "quality_vmax = 0.95\n", + "quality_cmap = \"RdYlGn\"\n", + "\n", + "\n", + "def _plot_quality_mesh(ax, case, title, overlay_geoms, xlim, ylim):\n", + " quality = case[\"quality\"]\n", + " if quality is not None and not quality.empty:\n", + " quality.plot(\n", + " ax=ax,\n", + " column=quality_metric,\n", + " cmap=quality_cmap,\n", + " vmin=quality_vmin,\n", + " vmax=quality_vmax,\n", + " edgecolor=\"black\",\n", + " linewidth=0.25,\n", + " legend=False,\n", + " )\n", + " if not isinstance(overlay_geoms, (list, tuple)):\n", + " overlay_geoms = [overlay_geoms]\n", + " for geom, color, linewidth, linestyle in overlay_geoms:\n", + " gpd.GeoSeries([geom], crs=CRS).plot(\n", + " ax=ax,\n", + " color=color,\n", + " linewidth=linewidth,\n", + " linestyle=linestyle,\n", + " zorder=4,\n", + " )\n", + " ax.set_xlim(*xlim)\n", + " ax.set_ylim(*ylim)\n", + " ax.set_title(title, fontsize=10, fontweight=\"bold\")\n", + " ax.set_aspect(\"equal\")\n", + " ax.grid(alpha=0.18)\n", + "\n", + "\n", + "polygon_plot_cases = [\n", + " (polygon_spacing_cases[0], \"Polygon: baseline\"),\n", + " (polygon_spacing_cases[1], \"Polygon: simplify=1\"),\n", + " (polygon_spacing_cases[2], \"Polygon: resample=10\"),\n", + " (polygon_spacing_cases[3], \"Polygon: simplify=1 + densify=10\"),\n", + "]\n", + "for ax, (case, title) in zip(axes[0], polygon_plot_cases):\n", + " _plot_quality_mesh(ax, case, title, [(_zone_geom(case).boundary, \"black\", 1.3, \"-\")], xlim=(0, 100), ylim=(0, 100))\n", + "\n", + "line_plot_cases = [\n", + " (spacing_line_cases[0], \"Line + polygon: baseline\"),\n", + " (spacing_line_cases[1], \"Line + polygon: simplify=1\"),\n", + " (spacing_line_cases[2], \"Line + polygon: resample=10\"),\n", + " (spacing_line_cases[3], \"Line + polygon: simplify=1 + densify=10\"),\n", + "]\n", + "for ax, (case, title) in zip(axes[1], line_plot_cases):\n", + " line_overlays = [\n", + " (_zone_geom(case).boundary, \"black\", 1.1, \"-\"),\n", + " (case[\"clean_lines\"].geometry.iloc[0], \"tab:blue\", 1.8, \"--\"),\n", + " ]\n", + " _plot_quality_mesh(ax, case, title, line_overlays, xlim=(0, 100), ylim=(0, 100))\n", + "\n", + "norm = mpl.colors.Normalize(vmin=quality_vmin, vmax=quality_vmax)\n", + "sm = mpl.cm.ScalarMappable(norm=norm, cmap=quality_cmap)\n", + "sm.set_array([])\n", + "fig.colorbar(\n", + " sm,\n", + " ax=axes.ravel().tolist(),\n", + " orientation=\"horizontal\",\n", + " shrink=0.72,\n", + " pad=0.08,\n", + " aspect=40,\n", + " label=\"Cell compactness (same scale for all panels; higher is better)\",\n", + ")\n", + "fig.suptitle(\"Problem 3: Voronoi cell quality comparison with a shared color scale\", fontweight=\"bold\", fontsize=12)\n", + "plt.show()\n" + ] + }, + { + "cell_type": "markdown", + "id": "5137334d", + "metadata": {}, + "source": [ + "---\n", + "## Problem 4 - Snapping, Healing, and Sliver Side Effects\n", + "\n", + "**What you'll see:** A clean set of embedded lines is hard but meshable without healing: a horizontal line, a 5 degree line pinned at its midpoint, and a nearby vertical line. Then we add a tiny unintended polygon sliver near that same intersection cluster. The sliver creates extra local topology that `connectivity_tolerance` does not remove.\n", + "\n", + "**Why this matters:** `connectivity_tolerance` is a preprocessing snap. In the current workflow it snaps line endpoints to polygon boundaries and points to nearby geometry; it does not solve interior line-line intersections or remove tiny embedded polygon slivers. Those are left for Gmsh/OCC fragmentation and, optionally, OCC healing.\n", + "\n", + "**Knobs compared:**\n", + "\n", + "```python\n", + "ConceptualMesh(connectivity_tolerance=...)\n", + "MeshGenerator(heal_shapes=True, heal_tolerance=...)\n", + "```\n", + "\n", + "> **Rule of thumb:** First check whether the clean geometry meshes without healing. Use healing for real tiny artifacts such as slivers, and judge it by cost, mesh quality, and constraint preservation. A lower cell count is only useful if the embedded features are still represented and the quality metrics remain acceptable.\n" + ], + "outputs": [], + "execution_count": null + }, + { + "cell_type": "code", + "execution_count": null, + "id": "07f5c711", + "metadata": {}, + "outputs": [], + "source": [ + "pinned_domain = {\n", + " \"geometry\": box(0, 0, 2, 2),\n", + " \"zone_id\": 1,\n", + " \"resolution\": 0.45,\n", + "}\n", + "\n", + "pinned_angle_deg = 5.0\n", + "vertical_offset = 1e-4\n", + "pinned_line_resolution = 0.04\n", + "pinned_background_lc = 0.45\n", + "pinned_center = (1.0, 1.0)\n", + "pinned_half_length = 0.75\n", + "\n", + "sliver_width = 1e-3\n", + "sliver_length = 0.05\n", + "sliver_origin = (1.00018, 1.00002)\n", + "\n", + "theta = np.deg2rad(pinned_angle_deg)\n", + "dx = np.cos(theta) * pinned_half_length\n", + "dy = np.sin(theta) * pinned_half_length\n", + "cx, cy = pinned_center\n", + "\n", + "pinned_line_geoms = [\n", + " (\"horizontal\", LineString([(0.25, cy), (1.75, cy)])),\n", + " (f\"angled_{pinned_angle_deg:g}deg\", LineString([(cx - dx, cy - dy), (cx + dx, cy + dy)])),\n", + " (\"near_vertical\", LineString([(cx + vertical_offset, 0.35), (cx + vertical_offset, 1.65)])),\n", + "]\n", + "\n", + "pinned_line_specs = [\n", + " {\n", + " \"geometry\": geom,\n", + " \"line_id\": name,\n", + " \"resolution\": pinned_line_resolution,\n", + " \"is_barrier\": False,\n", + " \"dist_max\": 0.12,\n", + " \"embed\": True,\n", + " \"densify\": True,\n", + " }\n", + " for name, geom in pinned_line_geoms\n", + "]\n", + "\n", + "sliver_x, sliver_y = sliver_origin\n", + "sliver_polygon = Polygon(\n", + " [\n", + " (sliver_x, sliver_y - sliver_width / 2),\n", + " (sliver_x + sliver_length, sliver_y - sliver_width / 2),\n", + " (sliver_x + sliver_length, sliver_y + sliver_width / 2),\n", + " (sliver_x, sliver_y + sliver_width / 2),\n", + " ]\n", + ")\n", + "sliver_specs = [\n", + " {\n", + " \"geometry\": sliver_polygon,\n", + " \"zone_id\": 2,\n", + " \"resolution\": pinned_line_resolution,\n", + " \"z_order\": 2,\n", + " \"embed\": True,\n", + " \"densify\": False,\n", + " }\n", + "]\n", + "\n", + "# At the vertical line, the horizontal and angled-line intersections are this far apart.\n", + "local_intersection_gap = abs(np.tan(theta) * vertical_offset)\n", + "constraint_node_tolerance = max(local_intersection_gap / 4, 1e-7)\n", + "minimum_nodes_per_line = 10\n", + "\n", + "robustness_settings = [\n", + " {\n", + " \"name\": \"clean-lines\",\n", + " \"label\": \"Clean lines, no healing\",\n", + " \"has_sliver\": False,\n", + " \"polygon_specs\": [],\n", + " \"mg_kwargs\": {\"tolerance_initial_delaunay\": 1e-8, \"heal_shapes\": False, \"optimization_cycles\": 0, \"smoothing_steps\": 0},\n", + " },\n", + " {\n", + " \"name\": \"sliver-no-healing\",\n", + " \"label\": \"Sliver, no healing\",\n", + " \"has_sliver\": True,\n", + " \"polygon_specs\": sliver_specs,\n", + " \"mg_kwargs\": {\"tolerance_initial_delaunay\": 1e-8, \"heal_shapes\": False, \"optimization_cycles\": 0, \"smoothing_steps\": 0},\n", + " },\n", + " {\n", + " \"name\": \"sliver-mild-healing\",\n", + " \"label\": \"Sliver, healing tol=5e-5\",\n", + " \"has_sliver\": True,\n", + " \"polygon_specs\": sliver_specs,\n", + " \"mg_kwargs\": {\"tolerance_initial_delaunay\": 1e-8, \"heal_shapes\": True, \"heal_tolerance\": 5e-5, \"optimization_cycles\": 0, \"smoothing_steps\": 0},\n", + " },\n", + " {\n", + " \"name\": \"sliver-over-healing\",\n", + " \"label\": \"Sliver, healing tol=1e-3\",\n", + " \"has_sliver\": True,\n", + " \"polygon_specs\": sliver_specs,\n", + " \"mg_kwargs\": {\"tolerance_initial_delaunay\": 1e-8, \"heal_shapes\": True, \"heal_tolerance\": 1e-3, \"optimization_cycles\": 0, \"smoothing_steps\": 0},\n", + " },\n", + "]\n", + "\n", + "\n", + "def _constraint_node_counts(case, source_lines, distance_tolerance):\n", + " if not case[\"mesh_success\"] or case[\"mg\"] is None or case[\"mg\"].nodes is None:\n", + " return [0 for _ in source_lines]\n", + " nodes = case[\"mg\"].nodes\n", + " counts = []\n", + " for _, line in source_lines:\n", + " counts.append(int(sum(line.distance(Point(x, y)) <= distance_tolerance for x, y in nodes)))\n", + " return counts\n", + "\n", + "\n", + "print(\n", + " \"Pinned embedded-line geometry: \"\n", + " f\"angle={pinned_angle_deg:g} deg, vertical offset={vertical_offset:g}, \"\n", + " f\"local intersection gap={local_intersection_gap:.2e}\"\n", + ")\n", + "print(\n", + " \"Sliver artifact: \"\n", + " f\"width={sliver_width:g}, length={sliver_length:g}, origin=({sliver_x:g}, {sliver_y:g})\"\n", + ")\n", + "print(\n", + " \"Constraint preservation check: \"\n", + " f\"at least {minimum_nodes_per_line} nodes per line within {constraint_node_tolerance:.2e} units\"\n", + ")\n", + "print(\"Topology note: connectivity_tolerance is held at 1e-12; it does not remove this interior sliver or line-line cluster.\")\n", + "\n", + "robustness_cases = []\n", + "for setting in robustness_settings:\n", + " print(f\"Running {setting['label']}...\")\n", + " case = run_case(\n", + " name=setting[\"name\"],\n", + " domain_spec=pinned_domain,\n", + " polygon_specs=setting[\"polygon_specs\"],\n", + " line_specs=pinned_line_specs,\n", + " background_lc=pinned_background_lc,\n", + " cm_kwargs={\"connectivity_tolerance\": 1e-12},\n", + " mg_kwargs=setting[\"mg_kwargs\"],\n", + " )\n", + " node_counts = _constraint_node_counts(case, pinned_line_geoms, constraint_node_tolerance)\n", + " case[\"label\"] = setting[\"label\"]\n", + " case[\"has_sliver\"] = setting[\"has_sliver\"]\n", + " case[\"settings\"] = setting[\"mg_kwargs\"]\n", + " case[\"constraint_node_counts\"] = node_counts\n", + " case[\"constraint_preserved\"] = case[\"mesh_success\"] and min(node_counts) >= minimum_nodes_per_line\n", + " robustness_cases.append(case)\n", + " cells = len(case[\"grid\"]) if case[\"grid\"] is not None else 0\n", + " print(\n", + " f\" mesh_success={case['mesh_success']} constraints_preserved={case['constraint_preserved']} \"\n", + " f\"cells={cells} node_counts={node_counts}\"\n", + " )\n", + "\n", + "\n", + "def _robustness_row(case):\n", + " quality = case[\"quality\"]\n", + " node_counts = case[\"constraint_node_counts\"]\n", + " lost_lines = sum(count < minimum_nodes_per_line for count in node_counts)\n", + " settings = case[\"settings\"]\n", + " base = {\n", + " \"case\": case[\"name\"],\n", + " \"has_sliver\": case[\"has_sliver\"],\n", + " \"heal_tolerance\": settings.get(\"heal_tolerance\", np.nan),\n", + " \"mesh_success\": case[\"mesh_success\"],\n", + " \"constraints_preserved\": case[\"constraint_preserved\"],\n", + " \"lost_lines\": lost_lines,\n", + " \"node_counts\": str(node_counts),\n", + " \"min_nodes_per_line\": min(node_counts),\n", + " \"cells\": len(case[\"grid\"]) if case[\"grid\"] is not None else 0,\n", + " \"mesh_s\": case[\"mesh_s\"],\n", + " \"error\": case[\"error\"][:80],\n", + " }\n", + " if quality is None or quality.empty:\n", + " return {**base, \"compact_median\": np.nan, \"area_cv\": np.nan}\n", + " return {\n", + " **base,\n", + " \"compact_median\": quality[\"compactness\"].median(),\n", + " \"area_cv\": quality[\"area\"].std() / quality[\"area\"].mean(),\n", + " }\n", + "\n", + "\n", + "robustness_diagnostics = pd.DataFrame([_robustness_row(case) for case in robustness_cases])\n", + "print(\n", + " \"Metric guide: mesh_success should be True and constraints_preserved should also be True. \"\n", + " \"Fewer cells is only better when constraints are preserved. compact_median higher is better; area_cv lower is better.\"\n", + ")\n", + "display(robustness_diagnostics.round({\"heal_tolerance\": 8, \"mesh_s\": 2, \"compact_median\": 4, \"area_cv\": 4}))\n", + "\n", + "sliver_no_healing_cells = int(robustness_diagnostics.loc[robustness_diagnostics[\"case\"] == \"sliver-no-healing\", \"cells\"].iloc[0])\n", + "sliver_mild_healing_cells = int(robustness_diagnostics.loc[robustness_diagnostics[\"case\"] == \"sliver-mild-healing\", \"cells\"].iloc[0])\n", + "sliver_mild_ok = bool(robustness_diagnostics.loc[robustness_diagnostics[\"case\"] == \"sliver-mild-healing\", \"constraints_preserved\"].iloc[0])\n", + "print(\n", + " \"Mild healing comparison: \"\n", + " f\"sliver case changes from {sliver_no_healing_cells} to {sliver_mild_healing_cells} cells \"\n", + " f\"while constraints_preserved={sliver_mild_ok}. Inspect compactness/area_cv before accepting that tradeoff.\"\n", + ")\n", + "\n", + "if robustness_diagnostics[\"constraints_preserved\"].all():\n", + " print(\"Result: every setting preserved the embedded lines; compare cell cost and quality.\")\n", + "elif robustness_diagnostics[\"mesh_success\"].all():\n", + " print(\"Result: every setting meshed, but over-healing lost at least one embedded-line constraint.\")\n", + "else:\n", + " print(\"Result: at least one setting failed before producing a mesh.\")\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "407e870e", + "metadata": {}, + "outputs": [], + "source": [ + "fig, axes = plt.subplots(\n", + " 2,\n", + " 4,\n", + " figsize=(20, 9),\n", + " gridspec_kw={\"height_ratios\": [3.0, 2.1]},\n", + " constrained_layout=True,\n", + ")\n", + "map_axes = axes[0]\n", + "zoom_axes = axes[1]\n", + "quality_metric = \"compactness\"\n", + "quality_vmin = 0.55\n", + "quality_vmax = 0.95\n", + "quality_cmap = \"RdYlGn\"\n", + "line_colors = {\n", + " \"horizontal\": \"#d73027\",\n", + " f\"angled_{pinned_angle_deg:g}deg\": \"#4575b4\",\n", + " \"near_vertical\": \"#111111\",\n", + "}\n", + "sliver_face = \"#fdae61\"\n", + "sliver_edge = \"#7f2704\"\n", + "\n", + "\n", + "def _plot_problem4_lines(ax, linewidth=1.8):\n", + " for name, geom in pinned_line_geoms:\n", + " gpd.GeoSeries([geom], crs=CRS).plot(\n", + " ax=ax,\n", + " color=line_colors[name],\n", + " linewidth=linewidth,\n", + " zorder=6,\n", + " )\n", + " ax.scatter([cx], [cy], s=20, color=\"white\", edgecolor=\"black\", linewidth=0.7, zorder=7)\n", + "\n", + "\n", + "def _plot_problem4_sliver(ax, case):\n", + " if not case[\"has_sliver\"]:\n", + " return\n", + " gpd.GeoSeries([sliver_polygon], crs=CRS).plot(\n", + " ax=ax,\n", + " facecolor=sliver_face,\n", + " edgecolor=sliver_edge,\n", + " alpha=0.45,\n", + " linewidth=1.0,\n", + " zorder=5,\n", + " )\n", + "\n", + "\n", + "def _plot_case_quality(ax, case, linewidth):\n", + " quality = case[\"quality\"]\n", + " if quality is not None and not quality.empty:\n", + " quality.plot(\n", + " ax=ax,\n", + " column=quality_metric,\n", + " cmap=quality_cmap,\n", + " vmin=quality_vmin,\n", + " vmax=quality_vmax,\n", + " edgecolor=\"black\",\n", + " linewidth=linewidth,\n", + " legend=False,\n", + " )\n", + " else:\n", + " gpd.GeoSeries([pinned_domain[\"geometry\"]], crs=CRS).boundary.plot(\n", + " ax=ax,\n", + " color=\"black\",\n", + " linewidth=1.0,\n", + " )\n", + " ax.text(\n", + " 0.04,\n", + " 0.94,\n", + " \"mesh failed\",\n", + " transform=ax.transAxes,\n", + " ha=\"left\",\n", + " va=\"top\",\n", + " fontsize=10,\n", + " fontweight=\"bold\",\n", + " color=\"#b2182b\",\n", + " bbox={\"facecolor\": \"white\", \"edgecolor\": \"#b2182b\", \"alpha\": 0.85, \"pad\": 2},\n", + " )\n", + "\n", + "\n", + "for ax_map, ax_zoom, case in zip(map_axes, zoom_axes, robustness_cases):\n", + " _plot_case_quality(ax_map, case, linewidth=0.22)\n", + " _plot_problem4_sliver(ax_map, case)\n", + " _plot_problem4_lines(ax_map, linewidth=1.5)\n", + " status = \"OK\" if case[\"mesh_success\"] and case[\"constraint_preserved\"] else \"FAIL\"\n", + " cells = len(case[\"grid\"]) if case[\"grid\"] is not None else 0\n", + " min_nodes = min(case[\"constraint_node_counts\"])\n", + " heal_label = \"no healing\" if not case[\"settings\"].get(\"heal_shapes\") else f\"heal={case['settings']['heal_tolerance']:.0e}\"\n", + " ax_map.set_title(\n", + " f\"{case['name']}\\n{status}, {cells} cells, min nodes/line={min_nodes}\\n{heal_label}\",\n", + " fontsize=8.5,\n", + " fontweight=\"bold\",\n", + " )\n", + " ax_map.set_xlim(0, 2)\n", + " ax_map.set_ylim(0, 2)\n", + " ax_map.set_aspect(\"equal\")\n", + " ax_map.grid(alpha=0.18)\n", + " ax_map.set_xlabel(\"\")\n", + " ax_map.set_ylabel(\"\")\n", + "\n", + " _plot_case_quality(ax_zoom, case, linewidth=0.45)\n", + " _plot_problem4_sliver(ax_zoom, case)\n", + " _plot_problem4_lines(ax_zoom, linewidth=2.1)\n", + " if case[\"mesh_success\"] and case[\"mg\"] is not None and case[\"mg\"].nodes is not None:\n", + " nodes = case[\"mg\"].nodes\n", + " window = (\n", + " (nodes[:, 0] >= 0.94)\n", + " & (nodes[:, 0] <= 1.08)\n", + " & (nodes[:, 1] >= 0.965)\n", + " & (nodes[:, 1] <= 1.035)\n", + " )\n", + " ax_zoom.scatter(nodes[window, 0], nodes[window, 1], s=8, color=\"black\", alpha=0.65, zorder=8)\n", + " ax_zoom.set_xlim(0.94, 1.08)\n", + " ax_zoom.set_ylim(0.965, 1.035)\n", + " ax_zoom.set_aspect(\"equal\")\n", + " ax_zoom.grid(alpha=0.25)\n", + " ax_zoom.set_xlabel(\"intersection/sliver zoom\")\n", + " ax_zoom.set_ylabel(\"\")\n", + "\n", + "norm = mpl.colors.Normalize(vmin=quality_vmin, vmax=quality_vmax)\n", + "sm = mpl.cm.ScalarMappable(norm=norm, cmap=quality_cmap)\n", + "sm.set_array([])\n", + "fig.colorbar(\n", + " sm,\n", + " ax=map_axes.ravel().tolist(),\n", + " orientation=\"horizontal\",\n", + " shrink=0.78,\n", + " pad=0.03,\n", + " aspect=36,\n", + " label=\"Cell compactness (same range for all map panels; higher is better)\",\n", + ")\n", + "fig.suptitle(\n", + " \"Problem 4: topology snapping is not sliver healing, and over-healing can lose constraints\",\n", + " fontweight=\"bold\",\n", + " fontsize=12,\n", + ")\n", + "plt.show()\n" + ] + }, + { + "cell_type": "markdown", + "id": "088b9722", + "metadata": {}, + "source": [ + "---\n", + "## Known Limitations\n", + "\n", + "The following cases show where the vorflow preprocessing pipeline **cannot** fully infer user intent — either because the problem is fundamentally topological, or because any automatic fix could destroy intended geometry.\n", + "\n", + "---\n", + "### Limitation 1 — Polygon Holes Mean \"Not This Zone,\" Not Automatically \"Empty Void\"\n", + "\n", + "**What you'll see:** You create a polygon with a hole (donut shape) in zone 2 and place it inside zone 1.\n", + "\n", + "**What vorflow can know:** The hole is definitely not zone 2. Vorflow cannot infer whether you intended that hole to be empty space, lower-priority zone 1, or a separate material.\n", + "\n", + "**Current effect:** If a lower-priority polygon exists underneath, cells inside the hole are assigned to that lower-priority zone. In this demo the hole belongs to zone 1. That is valid behavior, and some examples/tests rely on it.\n", + "\n", + "**Choose the geometry that matches your intent:**\n", + "\n", + "```python\n", + "# 1) Hole should belong to the lower-priority/background zone:\n", + "# use the donut polygon as-is. This is the current demo behavior.\n", + "cm.add_polygon(domain, zone_id=1, z_order=0)\n", + "cm.add_polygon(zone2_with_hole, zone_id=2, z_order=1)\n", + "\n", + "# 2) Hole should be empty / outside the mesh:\n", + "# remove the hole from the underlying domain too.\n", + "domain_with_void = domain.difference(hole_polygon)\n", + "cm.add_polygon(domain_with_void, zone_id=1, z_order=0)\n", + "cm.add_polygon(zone2_with_hole, zone_id=2, z_order=1)\n", + "\n", + "# 3) Hole should be a third material/zone:\n", + "# add it explicitly as a higher-priority polygon.\n", + "cm.add_polygon(domain, zone_id=1, z_order=0)\n", + "cm.add_polygon(zone2_with_hole, zone_id=2, z_order=1)\n", + "cm.add_polygon(hole_polygon, zone_id=3, z_order=2)\n", + "```\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "0de9589e", + "metadata": {}, + "outputs": [], + "source": [ + "donut_case = run_case(\n", + " name=\"donut-with-overlapping-hole\",\n", + " domain_spec={\n", + " \"geometry\": Polygon([(0, 0), (20, 0), (20, 20), (0, 20)]),\n", + " \"zone_id\": 1,\n", + " \"resolution\": 5.0,\n", + " \"z_order\": 0,\n", + " \"dist_max\": 25.0,\n", + " },\n", + " polygon_specs=[\n", + " {\n", + " \"geometry\": Polygon(\n", + " [(5, 5), (15, 5), (15, 15), (5, 15)],\n", + " [[(8, 8), (12, 8), (12, 12), (8, 12)]],\n", + " ),\n", + " \"zone_id\": 2,\n", + " \"resolution\": 2.0,\n", + " \"z_order\": 1,\n", + " \"dist_max\": 10.0,\n", + " }\n", + " ],\n", + " background_lc=5.0,\n", + ")\n", + "\n", + "if donut_case[\"grid\"] is not None and not donut_case[\"grid\"].empty:\n", + " print(\"Zone assignment in grid:\")\n", + " print(donut_case[\"grid\"][\"zone_id\"].value_counts().to_string())\n", + " print()\n", + " print(\"? Cells inside the hole (the 4?4 m interior square) are assigned to zone 1.\")\n", + " print(\" A hole means 'not zone 2'; it is not automatically an empty mesh void.\")\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "53ce2ac8", + "metadata": {}, + "outputs": [], + "source": [ + "fig, ax = plt.subplots(figsize=(6, 6))\n", + "\n", + "if donut_case[\"grid\"] is not None and not donut_case[\"grid\"].empty:\n", + " donut_case[\"grid\"].plot(\n", + " ax=ax, column=\"zone_id\", cmap=\"Set1\", alpha=0.6,\n", + " edgecolor=\"black\", linewidth=0.3,\n", + " categorical=True, legend=True,\n", + " )\n", + "\n", + "# Draw the intended hole boundary for reference\n", + "hole_ring = Polygon([(8, 8), (12, 8), (12, 12), (8, 12)])\n", + "gpd.GeoSeries([hole_ring], crs=CRS).boundary.plot(\n", + " ax=ax, color=\"red\", linewidth=2, linestyle=\"--\", label=\"Intended hole boundary\"\n", + ")\n", + "\n", + "ax.set_title(\n", + " \"Limitation 1: hole inside zone 2 polygon\\n\"\n", + " \"Red dashed line = intended hole — interior cells belong to zone 1 (not removed)\",\n", + " fontsize=10,\n", + ")\n", + "ax.set_aspect(\"equal\")\n", + "ax.grid(alpha=0.2)\n", + "ax.legend(fontsize=9)\n", + "plt.tight_layout()\n", + "plt.show()\n" + ] + }, + { + "cell_type": "markdown", + "id": "d249edcf", + "metadata": {}, + "source": [ + "---\n", + "### Limitation 2 — Connectivity Tolerance Is a Blanket Setting\n", + "\n", + "**What you need to know:** `connectivity_tolerance` is applied globally to every feature — it is not selective. When you raise it to 1.0 m to heal a 0.0005 m gap at one boundary, that same 1.0 m radius is applied to every endpoint everywhere. Any feature endpoint within 1.0 m of the domain boundary (or another nearby feature) will also be snapped, whether you intended it to move or not.\n", + "\n", + "**How to stay safe:** After calling `cm.generate()`, always inspect `clean_points` and `clean_lines` to confirm features are where you expect:\n", + "\n", + "```python\n", + "clean_polys, clean_lines, clean_points = cm.generate()\n", + "print(clean_points[[\"point_id\", \"geometry\"]]) # verify positions\n", + "```\n", + "\n", + "The cell below shows a 100 m × 2 m domain (very thin) with a centreline and two monitoring points 0.1 m above and below the line. With `connectivity_tolerance=1.0`, the snapping routine processes both points (they are within 1.0 m of the line), but since they are interior to the domain they stay put. In a real workflow with features near the domain boundary, the same tolerance can pull them to unexpected positions — always verify." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "6d4d5163", + "metadata": {}, + "outputs": [], + "source": [ + "\n", + "aggressive_connectivity = run_case(\n", + " name=\"aggressive-connectivity-collapse\",\n", + " domain_spec={\"geometry\": box(0, -1, 100, 1), \"zone_id\": 1, \"resolution\": 2.0},\n", + " line_specs=[\n", + " {\"geometry\": LineString([(0, 0), (100, 0)]), \"line_id\": \"centerline\", \"resolution\": 0.5, \"densify\": False}\n", + " ],\n", + " point_specs=[\n", + " {\"geometry\": Point(50, 0.1), \"point_id\": \"above\", \"resolution\": 0.2},\n", + " {\"geometry\": Point(50, -0.1), \"point_id\": \"below\", \"resolution\": 0.2},\n", + " ],\n", + " background_lc=2.0,\n", + " cm_kwargs={\"connectivity_tolerance\": 1.0},\n", + ")\n", + "\n", + "clean_pts = aggressive_connectivity[\"clean_points\"]\n", + "print(f\"Input: 2 distinct points (50, +0.1) and (50, -0.1)\")\n", + "if clean_pts is not None and not clean_pts.empty:\n", + " for _, row in clean_pts.iterrows():\n", + " print(f\" Clean point coords: ({row.geometry.x:.4f}, {row.geometry.y:.4f})\")\n", + "print()\n", + "print(\"→ Both points STAYED at their original positions — the centreline has no vertex at x=50\")\n", + "print(\" so there is nothing to snap to at that location.\")\n", + "print()\n", + "print(\" In a real workflow, features near the domain boundary or near another feature's\")\n", + "print(\" vertex CAN be pulled unexpectedly. Always inspect clean_points/clean_lines\")\n", + "print(\" after cm.generate() to confirm feature positions.\")\n", + "\n", + "print(\"\\nVerification pattern — inspect clean geometry:\")\n", + "if clean_pts is not None:\n", + " print(clean_pts[[\"point_id\", \"geometry\"]].to_string(index=True))\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "2a899baa", + "metadata": {}, + "outputs": [], + "source": [ + "clean_pts = aggressive_connectivity[\"clean_points\"]\n", + "\n", + "fig, axes = plt.subplots(1, 2, figsize=(14, 5))\n", + "ax_raw, ax_clean = axes\n", + "\n", + "# Zoom tight around the points so the y=±0.1 offset is visible\n", + "xlim, ylim = (44, 58), (-0.5, 0.5)\n", + "\n", + "for ax, pts_gdf, pt_color, title in [\n", + " (ax_raw, aggressive_connectivity[\"raw_points\"], \"red\", \"Input: 2 monitoring points\\n(0.1 m above and 0.1 m below the centreline)\"),\n", + " (ax_clean, clean_pts, \"green\", \"After preprocessing (connectivity_tolerance=1.0)\\nBoth points stayed at original positions ✓\"),\n", + "]:\n", + " aggressive_connectivity[\"raw_polygons\"].boundary.plot(ax=ax, color=\"black\", linewidth=0.6)\n", + " aggressive_connectivity[\"raw_lines\"].plot(ax=ax, color=\"steelblue\", linewidth=2, zorder=3)\n", + "\n", + " if pts_gdf is not None and not pts_gdf.empty:\n", + " pts_gdf.plot(ax=ax, color=pt_color, markersize=60, zorder=5)\n", + " # stagger annotations: first point up, second down\n", + " offsets = [(2, 0.15), (2, -0.20)]\n", + " for i, (_, row) in enumerate(pts_gdf.iterrows()):\n", + " dx, dy = offsets[i]\n", + " ax.annotate(\n", + " f\"{row.geometry.y:+.1f} m\",\n", + " xy=(row.geometry.x, row.geometry.y),\n", + " xytext=(row.geometry.x + dx, row.geometry.y + dy),\n", + " fontsize=9, color=pt_color,\n", + " arrowprops=dict(arrowstyle=\"->\", color=pt_color, lw=1.2),\n", + " )\n", + "\n", + " ax.set_title(title, fontsize=10)\n", + " ax.set_xlim(*xlim)\n", + " ax.set_ylim(*ylim)\n", + " ax.set_aspect(\"equal\")\n", + " ax.grid(alpha=0.2)\n", + " ax.axhline(0, color=\"steelblue\", linewidth=0.5, linestyle=\"--\", alpha=0.5)\n", + "\n", + "ax_raw.set_facecolor(\"#fff8f8\")\n", + "ax_clean.set_facecolor(\"#f8fff8\")\n", + "\n", + "plt.suptitle(\n", + " \"Limitation 2: connectivity_tolerance is global\\n\"\n", + " \"Always inspect clean_points / clean_lines after cm.generate() to verify positions\",\n", + " fontweight=\"bold\", fontsize=11,\n", + ")\n", + "plt.tight_layout()\n", + "plt.show()\n", + "\n", + "# Practical verification pattern\n", + "print(\"Verification pattern — inspect clean geometry:\")\n", + "if clean_pts is not None and not clean_pts.empty:\n", + " print(clean_pts[[\"point_id\", \"geometry\"]].to_string())" + ] + }, + { + "cell_type": "markdown", + "id": "e820d914", + "metadata": {}, + "source": [ + "---\n", + "## Quick Reference\n", + "\n", + "| Problem | Symptom | Fix | API |\n", + "|---------|---------|-----|-----|\n", + "| Duplicate / near-duplicate vertices | Gmsh would reject degenerate zero-length segments | Handled during robust geometry transfer before OCC creation; inspect short-segment diagnostics, not post-densification vertex counts | `MeshGenerator` geometry transfer |\n", + "| Feature doesn't reach domain boundary | Feature is removed from `clean_points` or clipped from `clean_lines`, so it has no local influence | Snap within `N` units, but only to an existing vertex | `ConceptualMesh(connectivity_tolerance=N)` |\n", + "| No snap vertex exists where you need one | Large tolerance still does not connect the feature | Resample the reference geometry before adding it | `resample_geometry(geom, spacing)` |\n", + "| Irregular source spacing | Local quality diagnostics improve after adding/redistributing vertices | Use the least intrusive spacing tool that improves metrics | `densify=spacing`, `resample_geometry()`, or `simplify_tolerance` + `densify` |\n", + "| Field-only refinement line under-refines | Refinement coverage is sparse even though the line is present | Increase DistanceField sampling when the field is under-sampled; fix topology first if the feature is misplaced or clipped | `ThresholdField(..., sampling=N)` |\n", + "| Over-digitised / noisy boundaries | Too many redundant vertices drive unnecessary detail | Remove redundant vertices while preserving overall shape | `add_polygon(..., simplify_tolerance=X)` or `add_line(..., simplify_tolerance=X)` |\n", + "| Narrow zone + barrier / sliver topology causes Gmsh issues | `generate()` returns `False`, raises, or constraints disappear after healing | Inspect clean geometry and embedding diagnostics first; use healing/tolerance changes only as measured tradeoffs | `MeshGenerator(diagnose=True, heal_shapes=True, tolerance_initial_delaunay=...)` |\n", + "| Polygon hole overlapping another zone | Hole is assigned to the lower-priority zone, but user intent may differ | Keep as-is for lower-zone holes; subtract the hole from the domain for an empty void; add a new polygon for a separate zone | `domain.difference(hole)` or `add_polygon(hole, z_order=...)` |\n", + "| `connectivity_tolerance` too large | Closely-spaced features can move unexpectedly | Lower tolerance to match the gap size only | Inspect `clean_points` / `clean_lines` after `cm.generate()` |\n" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "vorflow", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.14.2" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} \ No newline at end of file diff --git a/examples/comprehensive_demo.ipynb b/examples/comprehensive_demo.ipynb index 8df3770..5a18b4c 100644 --- a/examples/comprehensive_demo.ipynb +++ b/examples/comprehensive_demo.ipynb @@ -99,8 +99,8 @@ "cm.add_polygon(domain, zone_id=1, resolution=20.0)\n", "\n", "# 2. Add Refined Zone\n", - "# dist_max_out controls how fast the mesh grows outside this zone\n", - "cm.add_polygon(zone_poly,z_order=2, zone_id=2, resolution=3.0, dist_max_out=20.0)\n", + "# dist_max controls how fast the mesh grows outside this zone\n", + "cm.add_polygon(zone_poly,z_order=2, zone_id=2, resolution=3.0, dist_max=20.0)\n", "\n", "\n", "# 3. Add River (Standard Line)\n", @@ -258,7 +258,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.14.0" + "version": "3.14.2" } }, "nbformat": 4, diff --git a/examples/field_capabilities_example.py b/examples/field_capabilities_example.py new file mode 100644 index 0000000..fe92a2d --- /dev/null +++ b/examples/field_capabilities_example.py @@ -0,0 +1,420 @@ +#%% +"""Field capabilities example (pseudo-notebook). + +Run this file in VS Code with the Python extension. The `#%%` markers create +cell-like execution, similar to a notebook. + +This example duplicates polygon and line geometries to exercise multiple mesh +field types: +- Implicit threshold via `dist_min`/`dist_max` +- Explicit `ThresholdField` +- `GeometricGrowthField` with edge-ratio and continuous-metric conventions +- Field-only polygon via `embed=False` +- Barrier/straddle line to validate point-pair representation +""" + +from __future__ import annotations + +import matplotlib.pyplot as plt +import numpy as np + +from shapely.affinity import translate +from shapely.geometry import LineString, Point, box + +from vorflow import ConceptualMesh, MeshGenerator, VoronoiTessellator +from vorflow.fields import ( + GeometricGrowthField, + ThresholdField, +) +from vorflow.utils import build_connectivity, calculate_mesh_quality, summarize_quality + +#%% +# Geometry +domain = box(0, 0, 400, 200) +# Base refinement polygon (simplified set) +poly_base = box(40, 40, 70, 70) + +# Create a 2x3 layout (upper/lower × left/center/right) +ul = translate(poly_base, xoff=0, yoff=80) +uc = translate(poly_base, xoff=120, yoff=80) +ur = translate(poly_base, xoff=240, yoff=80) +ll = translate(poly_base, xoff=0, yoff=0) +lc = translate(poly_base, xoff=120, yoff=0) +lr = translate(poly_base, xoff=240, yoff=0) + +polys = { + "upper-left": ul, + "upper-center": uc, + "upper-right": ur, + "lower-left": ll, + "lower-center": lc, + "lower-right": lr, +} + +# A gentle sine-wave river +xs = np.linspace(-10, 430, 45) +river_y = 140 + 18 * np.sin(0.06 * xs) +river_base = LineString(list(zip(xs, river_y))) +rivers = { + "river-center-up": translate(river_base, xoff=0, yoff=0), + "river-center-down": translate(river_base, xoff=0, yoff=-60), +} + +# Points (simplified) +points = { + "pt-lower-left": Point(25, 25), + "pt-lower-center": Point(185, 25), + "pt-lower-right": Point(325, 25), +} +#%% +# Fields used below + +edge_growth = GeometricGrowthField(growth_factor=1.1) +metric_growth = GeometricGrowthField( + growth_factor=1.1, growth_model="continuous_metric" +) +threshold = ThresholdField(size_min=5.0, dist_min=5.0, dist_max=50.0, size_max=20.0) + + + + + +#%% +# 1) Setup Blueprint + 2) Mesh Generation + 3) Voronoi Conversion + +background_lc = 100 +feature_lc = 10 # representative base feature length for features + +blueprint = ConceptualMesh(crs="EPSG:3857") +blueprint.add_polygon(domain, zone_id="domain") # color: black (domain boundary) + +# Polygons (IDs are location-based) +blueprint.add_polygon( + polys["upper-left"], + zone_id="upper-left", + resolution=feature_lc/5, + z_order=10, + dist_min=feature_lc/2,#using the implicit threshold approach here (instead of an explicit ThresholdField) to validate both code paths + dist_max=background_lc * 5.0, +) + +blueprint.add_polygon( + polys["upper-center"], + zone_id="upper-center", + resolution=feature_lc/5, + z_order=10, + fields=[edge_growth], + embed=False, # field-only polygon +) + +blueprint.add_polygon( + polys["upper-right"], + zone_id="upper-right", + resolution=feature_lc/5, + z_order=10, + fields=[metric_growth], +) + + +blueprint.add_line( + polys["lower-left"].boundary, + line_id='lower-left',# zone_id="lower-left", + resolution=feature_lc/5, + # z_order=5, + dist_min=feature_lc/2, + dist_max=background_lc * 1.5, + fields=[metric_growth], + embed=False, # field-only boundary line +) + +blueprint.add_polygon( + polys["lower-center"], + zone_id="lower-center", + resolution=feature_lc/5, + z_order=5, + fields=[edge_growth], +) + +blueprint.add_polygon( + polys["lower-right"], + zone_id="lower-right", + resolution=feature_lc/5, + z_order=5, + fields=[threshold], + embed=False, # field-only polygon +) + +blueprint.add_line( + rivers["river-center-up"], + line_id="river-center-up", + resolution=feature_lc/2, + is_barrier=False, + fields=[threshold], +) + +blueprint.add_line( + rivers["river-center-down"], + line_id="river-center-down", + resolution=feature_lc/4, + is_barrier=False, + fields=[edge_growth], + embed=False, # field-only line +) + +# Points (IDs are location-based) +# Colors: pt-lower-left -> 'tab:red', pt-lower-center -> 'tab:purple' +blueprint.add_point( + points["pt-lower-left"], + point_id="pt-lower-left", + resolution=feature_lc/5, + dist_min=feature_lc/5, + dist_max=background_lc * 1.5, +) +blueprint.add_point( + points["pt-lower-center"], + point_id="pt-lower-center", + resolution=feature_lc/5, + fields=[edge_growth], + embed=False, # field-only point +) + +blueprint.add_point( + points["pt-lower-right"], + point_id="pt-lower-right", + resolution=feature_lc/5, + fields=[metric_growth], + embed=False, # field-only point +) + +clean_polys, clean_lines, clean_pts = blueprint.generate() + +mesher = MeshGenerator(background_lc=background_lc, verbosity=0) +mesher.generate(clean_polys, clean_lines, clean_pts, launch_gmsh_gui=False) + +#%% 3) Triangular quality + Voronoi conversion + quality reports + +tri_quality = mesher.get_triangular_quality() +print("\nTriangular element quality summary:") +print(tri_quality["element_name"].value_counts().to_string()) + +tri_quality_metrics = [ + "minSICN", + "minDetJac", + "maxDetJac", + "minSJ", + "minSIGE", + "gamma", + "innerRadius", + "outerRadius", + "minIsotropy", + "angleShape", + "minEdge", + "maxEdge", +] +print( + tri_quality[tri_quality_metrics] + .describe(percentiles=[0.05, 0.5, 0.95]) + .T[["min", "5%", "50%", "95%", "max"]] +) + +tessellator = VoronoiTessellator(mesher, blueprint, clip_to_boundary=True) +grid_gdf = tessellator.generate() + +modflow_connectivity_report = build_connectivity(grid_gdf, center="centroid") +voronoi_dual_connectivity_report = build_connectivity(grid_gdf, center="generator") + +print("\nMODFLOW-facing centroid connectivity summary:") +print( + modflow_connectivity_report[["angle", "ortho_error", "skewness"]] + .describe(percentiles=[0.05, 0.5, 0.95]) + .T[["min", "5%", "50%", "95%", "max"]] +) + +print("\nVoronoi-dual generator connectivity summary:") +print( + voronoi_dual_connectivity_report[["angle", "ortho_error", "skewness"]] + .describe(percentiles=[0.05, 0.5, 0.95]) + .T[["min", "5%", "50%", "95%", "max"]] +) + +worst_columns = [ + col + for col in ["node_id_1", "node_id_2", "angle", "ortho_error", "skewness"] + if col in modflow_connectivity_report.columns +] +print("\nWorst MODFLOW-facing centroid connectivity pairs by orthogonality error:") +print( + modflow_connectivity_report + .sort_values("ortho_error", ascending=False) + .head(10)[worst_columns] + .to_string(index=False) +) + +quality_gdf = calculate_mesh_quality( + grid_gdf, + calc_ortho=True, + calc_skewness=True, + connectivity=modflow_connectivity_report, +) +summarize_quality(quality_gdf) + + +#%% +# 4) Visual sanity-check + +fig, ax = plt.subplots(1, 1, figsize=(14, 7)) +ax.set_aspect("equal") + +# Domain +ax.plot(*domain.exterior.xy, color="black", lw=1) + +# Polygons +plot_polys = polys +poly_colors = { + "upper-left": "tab:orange", + "upper-center": "tab:green", + "upper-right": "tab:blue", + "lower-left": "tab:purple", + "lower-center": "tab:brown", + "lower-right": "tab:pink", +} +field_only = { + "upper-center": "polygon", + "lower-left": "boundary line", + "lower-right": "polygon", +} +for name, poly in plot_polys.items(): + field_only_kind = field_only.get(name) + label = f"{name} (field-only {field_only_kind})" if field_only_kind else name + ax.plot( + *poly.exterior.xy, + lw=1, + ls=":" if field_only_kind else "--", + color=poly_colors.get(name), + label=label, + ) + +line_colors = { + "river-center-up": "tab:cyan", + "river-center-down": "tab:cyan", +} + +ax.plot( + *rivers["river-center-up"].xy, + lw=1, + color=line_colors["river-center-up"], + label="river-center-up", +) +ax.plot( + *rivers["river-center-down"].xy, + lw=1, + color=line_colors["river-center-down"], + label="river-center-down (field-only)", +) + +# Points +point_colors = { + "pt-lower-left": "tab:red", + "pt-lower-center": "tab:purple", + "pt-lower-right": "tab:blue", +} +for name, pt in points.items(): + ax.scatter(pt.x, pt.y, s=25, marker="x", color=point_colors.get(name), label=name) + +grid_gdf.plot(ax=ax, alpha=0.35, edgecolor="k", linewidth=0.15) +ax.legend(loc="upper right", fontsize=7, ncol=2) +fig.tight_layout() +plt.show() + + +#%% +# Quick check: smaller cells => smaller polygon areas (proxy for refinement) + +fig, ax = plt.subplots(1, 1, figsize=(14, 6)) +ax.set_aspect("equal") +ax.plot(*domain.exterior.xy, color="black", lw=1) +quality_gdf.plot(ax=ax, column="area", cmap="viridis", legend=True, linewidth=0.0) +ax.set_title("Voronoi cell area (proxy for refinement)") +fig.tight_layout() +plt.show() + +#%% 5) Quality diagnostics plots + +fig, ax = plt.subplots(figsize=(10, 5)) +for element_name, group in tri_quality.groupby("element_name"): + group["gamma"].plot.hist( + ax=ax, + bins=40, + alpha=0.55, + label=element_name, + ) +ax.set_title("Gmsh 2D element quality: gamma") +ax.set_xlabel("gamma (higher is better)") +ax.legend() +fig.tight_layout() +plt.show() + +fig, ax = plt.subplots(figsize=(10, 8)) +ax.set_aspect("equal") +grid_gdf.plot(ax=ax, color="white", edgecolor="0.85", linewidth=0.2) +modflow_connectivity_report.set_geometry("connector").plot( + ax=ax, + color="0.35", + linewidth=0.35, + alpha=0.35, +) +# ortho_error is in degrees (0 is ideal); let the color scale auto-range +# instead of saturating at 1 degree. +modflow_connectivity_report.plot( + column="ortho_error", + ax=ax, + legend=True, + cmap="Reds", + linewidth=1.2, + vmin=0, +) +ax.plot(*domain.exterior.xy, color="black", lw=1) +ax.set_title("MODFLOW-facing centroid connectivity: shared-face orthogonality error") +fig.tight_layout() +plt.show() + +fig, ax = plt.subplots(figsize=(10, 8)) +ax.set_aspect("equal") +quality_gdf.plot(column="ortho_error", ax=ax, legend=True, cmap="Reds", vmin=0) +ax.plot(*domain.exterior.xy, color="black", lw=1) +ax.set_title("Per-cell orthogonality error (degrees, worst face per cell)") +fig.tight_layout() +plt.show() + +fig, ax = plt.subplots(figsize=(10, 8)) +ax.set_aspect("equal") +quality_gdf.plot(column="skewness", ax=ax, legend=True, cmap="Purples", vmin=0, vmax=0.5) +ax.plot(*domain.exterior.xy, color="black", lw=1) +ax.set_title("Per-cell skewness error |s - 0.5|") +fig.tight_layout() +plt.show() + +fig, axes = plt.subplots(2, 2, figsize=(14, 10)) +dashboard_metrics = [ + ("area", "Cell area", "viridis", None, None), + ("drift_ratio", "Generator drift ratio", "magma", None, None), + ("ortho_error", "Orthogonality error (degrees)", "Reds", 0, None), + ("skewness", "Skewness error |s - 0.5|", "Purples", 0, 0.5), +] +for ax, (column, title, cmap, vmin, vmax) in zip(axes.ravel(), dashboard_metrics): + ax.set_aspect("equal") + quality_gdf.plot( + column=column, + ax=ax, + legend=True, + cmap=cmap, + vmin=vmin, + vmax=vmax, + linewidth=0.0, + ) + ax.plot(*domain.exterior.xy, color="black", lw=0.8) + ax.set_title(title) + ax.set_axis_off() +fig.tight_layout() +plt.show() +# %% diff --git a/examples/structured_buffer_example.py b/examples/structured_buffer_example.py new file mode 100644 index 0000000..58fc97b --- /dev/null +++ b/examples/structured_buffer_example.py @@ -0,0 +1,218 @@ +#%% +"""Structured quad-buffer example. + +Demonstrates the four canonical quad-buffer behaviors (gmshflow parity). The +band/strip width is ``quad_buffer_thickness`` cells, and the feature outline +itself never becomes mesh edges: + +- line, thickness=1 -> one quad row straddling the line, no mesh nodes on it: + the Voronoi FACES align with the line (sharp barrier). +- line, thickness=2 -> two quad rows, a node row lands ON the line: a row of + ~square Voronoi cells centered on it. +- polygon, thickness=1 -> a quad band straddling the outline: the Voronoi + faces trace the shapefile shape. +- polygon, thickness=2 -> a ring of ~square cells centered on the outline. + +Crossing buffers are a vorflow extension (gmshflow never supported them). When +two quad buffers cross, the higher-priority one stays continuous and only the +other is trimmed at the crossing -- priority is z_order, then finer resolution, +then wider strip, then line over polygon, then insertion order. A local size +field keeps the small trimmed gap meshed at the feature size instead of jumping +to the background size, so the cell size and quality stay smooth across the +crossing. Here the inner zone (z_order=1) wins over the fault, which is trimmed. + +Two more features round out the comparison: a ``tee`` line that ends ON the +fault (a T-junction, trimmed because the fault was added first) and a classic +straddle ``barrier`` line (no quad buffer), which aligns Voronoi faces via +mirrored point pairs rather than a structured strip -- the lightweight treatment +to compare against the quad buffers. +""" + +import matplotlib.pyplot as plt +from shapely.geometry import LineString, Polygon, box +from shapely.affinity import translate + +from vorflow import ConceptualMesh, MeshGenerator, VoronoiTessellator +from vorflow.utils import build_connectivity, calculate_mesh_quality +from vorflow.fields import GeometricGrowthField + +#%% +field = GeometricGrowthField(growth_factor=1.5) +domain = box(0, 0, 12, 22) +fault = LineString([(0, 5), (12, 5)]) # crosses inner_zone's band +drain = LineString([(0, 10), (12, 10)]) # passes between the two zones +tee = LineString([(10, 5), (10, 9)]) # T-junction: ends on the fault +barrier = LineString([(0, 20), (12, 20)]) # classic straddle, clear of all bands +inner_zone = Polygon([(4, 3), (8, 3), (8, 7), (4, 7)]) +sup_inner_zone = translate(inner_zone, xoff=0, yoff=10) + +mesh = ConceptualMesh(crs=None) +mesh.add_polygon(domain, zone_id="domain", resolution=1, densify=False) + +# thickness=1: Voronoi faces trace the outline. +mesh.add_polygon( + inner_zone, + zone_id="inner-zone", + resolution=1.0, + z_order=1, + densify=True, + fields=[field], + quad_buffer=True, + quad_buffer_thickness=1, +) + +# thickness=2: a ring of ~square cells centered on the outline. +mesh.add_polygon( + sup_inner_zone, + zone_id="sup-inner-zone", + resolution=1.0, + z_order=1, + densify=True, + fields=[field], + quad_buffer=True, + quad_buffer_thickness=2, +) + +# thickness=1: sharp Voronoi faces on the line (barrier-like). +mesh.add_line( + fault, + line_id="fault-buffer", + resolution=1.0, + quad_buffer=True, + quad_buffer_thickness=1, + fields=[field], +) + +# thickness=2: square cells centered on the line. +mesh.add_line( + drain, + line_id="drain-buffer", + resolution=1.0, + quad_buffer=True, + quad_buffer_thickness=2, + fields=[field], +) + +# T-junction: this quad buffer ends on the fault. With equal priority the fault +# (added first) wins, so the tee is trimmed where the two meet. +mesh.add_line( + tee, + line_id="tee-buffer", + resolution=1.0, + quad_buffer=True, + quad_buffer_thickness=1, + fields=[field], +) + +# Classic straddle barrier (no quad_buffer) for contrast: it forces Voronoi +# faces onto the line with mirrored point pairs rather than a structured strip. +mesh.add_line( + barrier, + line_id="barrier", + resolution=1.0, + is_barrier=True, + fields=[field], +) + +clean_polys, clean_lines, clean_points = mesh.generate() + +mesher = MeshGenerator( + background_lc=1.5, + verbosity=0, + smoothing_steps=0, + optimization_cycles=0, +) +mesher.generate(clean_polys, clean_lines, clean_points) + +element_grid = mesher.get_element_grid() +quads = mesher.get_element_grid("quads") +triangles = mesher.get_element_grid("triangles") + +print(f"2D elements: {len(element_grid)}") +print(f" triangles: {len(triangles)}") +print(f" quads: {len(quads)}") + + +#%% +tessellator = VoronoiTessellator(mesher, mesh, clip_to_boundary=True) +voronoi_grid = tessellator.generate() + +# Behavior diagnostics: count cells centered on each feature (thickness=2 +# should have a full row, thickness=1 none) and, for the thickness=1 zone, +# cells straddling the outline (faces should trace it). The inner zone wins +# the crossing with the fault (z_order=1), so it stays continuous and its +# straddle count is ~0 -- the fault is the one trimmed there instead. +centroids = voronoi_grid.geometry.centroid +def centered_cells(geom, tol=0.05): + return voronoi_grid[centroids.distance(geom) < tol] + +fault_centered = centered_cells(fault) +drain_centered = centered_cells(drain) +inner_centered = centered_cells(inner_zone.exterior) +sup_centered = centered_cells(sup_inner_zone.exterior) +inner_frac = voronoi_grid.geometry.intersection(inner_zone).area / voronoi_grid.geometry.area +inner_crossing = ((inner_frac > 0.03) & (inner_frac < 0.97)).sum() + +print("\nBehavior checks (cells centered on each feature):") +print(f" fault t=1: {len(fault_centered)} (expect 0 - faces align with the line)") +print(f" drain t=2: {len(drain_centered)} ~square cells, " + f"area mean={drain_centered.geometry.area.mean():.2f}") +print(f" inner t=1: {len(inner_centered)} on outline, " + f"{inner_crossing} cells straddle it (~0 - the zone wins, faces trace it)") +print(f" sup t=2: {len(sup_centered)} ~square cells on outline, " + f"area mean={sup_centered.geometry.area.mean():.2f}") + +connectivity = build_connectivity(voronoi_grid, center="centroid") +quality = calculate_mesh_quality( + voronoi_grid, + calc_ortho=True, + calc_skewness=True, + connectivity=connectivity, +) + +# Note: calculate_mesh_quality aggregates per cell with the MAX over the +# cell's faces, so these per-cell numbers read higher than the face-level +# distribution. In this small, gradient-heavy domain boundary cells also +# dominate the stats; the faces along the buffered features are the best ones. +print("\nPer-cell quality (worst face per cell):") +print(quality[["compactness", "drift_ratio", "ortho_error", "skewness"]].describe().T) +print(f"\nFace-level ortho_error mean: {connectivity['ortho_error'].mean():.2f} deg " + f"(per-cell worst-face mean: {quality['ortho_error'].mean():.2f} deg)") + + +#%% +fig, axes = plt.subplots(1, 3, figsize=(16, 6.5), constrained_layout=True) + +triangles.plot(ax=axes[0], facecolor="#d7e3f4", edgecolor="#8aa0bd", linewidth=0.35) +quads.plot(ax=axes[0], facecolor="#f3c97a", edgecolor="#9b6b1f", linewidth=0.55) +axes[0].set_title("Element grid: quad strips/bands") + +voronoi_grid.plot( + column="zone_id", ax=axes[1], categorical=True, legend=True, + cmap="Pastel2", edgecolor="#666666", linewidth=0.4, +) +axes[1].set_title("Voronoi cells: faces trace the t=1 outlines,\nsquares sit on the t=2 features") + +quality.plot( + column="ortho_error", + ax=axes[2], + cmap="magma_r", + edgecolor="#555555", + linewidth=0.25, + legend=True, +) +axes[2].set_title("Centroid orthogonality error (deg)") + +for ax in axes: + ax.plot(*fault.xy, color="black", linewidth=1.2) + ax.plot(*drain.xy, color="black", linewidth=1.2, linestyle="--") + ax.plot(*tee.xy, color="black", linewidth=1.2) + ax.plot(*barrier.xy, color="crimson", linewidth=1.2, linestyle=":") + ax.plot(*inner_zone.exterior.xy, color="black", linewidth=1.0) + ax.plot(*sup_inner_zone.exterior.xy, color="black", linewidth=1.0, linestyle="--") + ax.set_aspect("equal") + ax.axis("off") + +plt.show() + +# %% diff --git a/examples/triangular_grid_example.py b/examples/triangular_grid_example.py new file mode 100644 index 0000000..6c82aa1 --- /dev/null +++ b/examples/triangular_grid_example.py @@ -0,0 +1,115 @@ +#%% +"""Triangular grid output example. + +Run this file in VS Code with the Python extension. The `#%%` markers create +cell-like execution, similar to a notebook. + +Some workflows want the gmsh triangular mesh itself as the deliverable (e.g. a +triangular FE/FV grid) instead of the Voronoi dual. `MeshGenerator` caches the +2D element polygons during `generate()`, so after meshing you can export: + +- ``get_element_grid("triangles")`` — the plain triangular grid as a + GeoDataFrame with zone ids assigned by element centroid, +- ``get_element_grid("all")`` / ``("quads")`` — the mixed tri/quad grid when a + structured quad buffer is present, +- ``get_triangular_quality()`` — per-element gmsh quality metrics, joinable on + ``element_tag``. + +The Voronoi tessellation step is simply never invoked here. +""" + +import matplotlib.pyplot as plt +from shapely.geometry import LineString, Polygon, box + +from vorflow import ConceptualMesh, MeshGenerator +from vorflow.fields import GeometricGrowthField +from vorflow.utils import build_connectivity + +#%% +# Conceptual model: a domain with a refined inner zone and a structured quad +# buffer along a fault, so the exported grid is a mixed tri/quad mesh. +field = GeometricGrowthField(growth_factor=1.2) +domain = box(0, 0, 20, 12) +inner_zone = Polygon([(6, 3), (14, 3), (14, 9), (6, 9)]) +fault = LineString([(2, 6), (18, 6)]) + +mesh = ConceptualMesh(crs=None) +mesh.add_polygon(domain, zone_id="domain", resolution=2.0, densify=True) +mesh.add_polygon( + inner_zone, + zone_id="inner-zone", + resolution=1.0, + z_order=1, + densify=True, + fields=[field], +) +mesh.add_line( + fault, + line_id="fault", + resolution=1.0, + is_barrier=True, + quad_buffer=True, + quad_buffer_thickness=1, + fields=[field], +) + +clean_polys, clean_lines, clean_points = mesh.generate() + +mesher = MeshGenerator(background_lc=2.0, verbosity=0) +mesher.generate(clean_polys, clean_lines, clean_points) + +#%% +# The element grid is the deliverable: triangles (plus quads from the buffer), +# each with a zone id assigned by element centroid. +element_grid = mesher.get_element_grid() # mixed tri/quad +triangles = mesher.get_element_grid("triangles") # triangular-only view +quads = mesher.get_element_grid("quads") + +print(f"2D elements: {len(element_grid)}") +print(f" triangles: {len(triangles)}") +print(f" quads: {len(quads)}") +print("\nElements per zone:") +print(element_grid["zone_id"].value_counts().to_string()) + +#%% +# Per-element quality joins on element_tag. gamma is the inscribed/circumscribed +# radius ratio (1.0 = equilateral); it applies to the triangles. +quality = mesher.get_triangular_quality() +graded = element_grid.merge(quality[["element_tag", "gamma"]], on="element_tag", how="left") +print("\nTriangle gamma quality:") +print(graded.loc[graded["is_triangle"], "gamma"].describe()[["min", "mean", "50%"]]) + +# Element-centroid connectivity works on the element grid too (no generator +# columns needed), e.g. for FV-style face checks on the triangular grid. +connectivity = build_connectivity(element_grid, center="centroid") +print(f"\nElement-face connectivity pairs: {len(connectivity)}") + +#%% +fig, axes = plt.subplots(1, 3, figsize=(18, 5), constrained_layout=True) + +element_grid.plot( + column="zone_id", ax=axes[0], categorical=True, legend=True, + cmap="Pastel2", edgecolor="#666666", linewidth=0.3, +) +axes[0].plot(*fault.xy, color="black", linewidth=1.2, linestyle='--') +axes[0].set_title("Element grid colored by zone_id") + +graded.plot( + column="gamma", ax=axes[1], cmap="viridis", legend=True, + edgecolor="#444444", linewidth=0.2, vmin=0.5, vmax=1.0, + missing_kwds={"color": "#f3c97a", "label": "quads"}, +) +axes[1].set_title("Triangle quality (gamma, 1.0 = equilateral)") + +triangles.plot(ax=axes[2], facecolor="#d7e3f4", edgecolor="#8aa0bd", linewidth=0.3) +quads.plot(ax=axes[2], facecolor="#f3c97a", edgecolor="#9b6b1f", linewidth=0.5) +axes[2].plot(*fault.xy, color="black", linewidth=1.2, linestyle='--') +axes[2].set_title("Triangular grid with structured quad buffer") + +for ax in axes: + ax.set_aspect("equal") + ax.axis("off") + +plt.show() + +# %% diff --git a/pyproject.toml b/pyproject.toml index 5b5f14b..ba64847 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -1,31 +1,77 @@ [build-system] -requires = ["setuptools>=61.0"] +requires = ["setuptools>=77.0.3"] build-backend = "setuptools.build_meta" [project] name = "vorflow" -version = "0.0.1" -description = "Voronoi mesh generation for MODFLOW 6 using Gmsh and Geopandas" -authors = [{name = "Your Name", email = "you@example.com"}] -requires-python = ">=3.9" +version = "0.1.0rc1" +description = "Voronoi mesh generation for MODFLOW 6 using Gmsh and GeoPandas" +readme = "README.md" +license = "MIT" +license-files = ["LICENSE"] +authors = [ + {name = "Oscar Sanchez", email = "oscarfasanchez@gmail.com"}, + {name = "rhugman"}, +] +maintainers = [ + {name = "Oscar Sanchez", email = "oscarfasanchez@gmail.com"}, +] +requires-python = ">=3.10" +keywords = ["modflow", "groundwater", "voronoi", "mesh", "gmsh"] +classifiers = [ + "Development Status :: 3 - Alpha", + "Intended Audience :: Science/Research", + "Programming Language :: Python :: 3", + "Programming Language :: Python :: 3.10", + "Programming Language :: Python :: 3.11", + "Programming Language :: Python :: 3.12", + "Topic :: Scientific/Engineering :: Hydrology", +] dependencies = [ - "numpy", - "pandas", - "geopandas", - "shapely", - "scipy", - "gmsh", # The official python SDK - "matplotlib" # For visualization + "numpy>=1.24", + "pandas>=1.5", + "geopandas>=0.13", + "shapely>=2.0", + "scipy>=1.10", + "gmsh>=4.11", ] +[project.urls] +Repository = "https://github.com/oscarfasanchez/vorflow_os" +Issues = "https://github.com/oscarfasanchez/vorflow_os/issues" +Changelog = "https://github.com/oscarfasanchez/vorflow_os/blob/main/CHANGELOG.md" + [project.optional-dependencies] +examples = [ + "matplotlib", # Plotting in examples/ and notebooks; the library itself never imports it +] dev = [ "pytest", "pytest-cov", "black", - "jupyter" + "ruff", + "jupyter", + "matplotlib", + "build>=1.2", + "twine>=6", + "tomli>=2; python_version < '3.11'", ] +[tool.setuptools] +package-dir = {"" = "src"} +include-package-data = false + +[tool.setuptools.packages.find] +where = ["src"] + +[tool.ruff.lint.per-file-ignores] +# set_verbosity(1) must run before the submodules are imported so their +# loggers inherit the default console behavior. +"src/vorflow/__init__.py" = ["E402"] + [tool.pytest.ini_options] testpaths = ["tests"] -pythonpath = ["src"] \ No newline at end of file +pythonpath = ["src"] +markers = [ + "slow: gmsh-heavy end-to-end tests (deselect with -m 'not slow')", +] diff --git a/scripts/check_dist.py b/scripts/check_dist.py new file mode 100644 index 0000000..68bb545 --- /dev/null +++ b/scripts/check_dist.py @@ -0,0 +1,198 @@ +"""Validate vorflow wheel/sdist contents and release metadata.""" + +from __future__ import annotations + +import argparse +from email.parser import BytesParser +from email.policy import default +from pathlib import Path, PurePosixPath +import tarfile +import zipfile + +from packaging.version import InvalidVersion, Version + + +FORBIDDEN_DIRECTORIES = {".conda", "benchmarks", "docs", "__pycache__"} +EXPECTED_REQUIREMENTS = { + "numpy>=1.24", + "pandas>=1.5", + "geopandas>=0.13", + "shapely>=2.0", + "scipy>=1.10", + "gmsh>=4.11", +} +EXPECTED_URLS = { + "Repository, https://github.com/oscarfasanchez/vorflow_os", + "Issues, https://github.com/oscarfasanchez/vorflow_os/issues", + "Changelog, https://github.com/oscarfasanchez/vorflow_os/blob/main/CHANGELOG.md", +} + + +def version_from_tag(tag: str) -> str: + if not tag.startswith("v"): + raise ValueError(f"expected a release-candidate tag, received {tag!r}") + value = tag[1:] + try: + version = Version(value) + except InvalidVersion as error: + raise ValueError( + f"expected a release-candidate tag, received {tag!r}" + ) from error + if version.pre is None or version.pre[0] != "rc" or tag != f"v{version}": + raise ValueError(f"expected a release-candidate tag, received {tag!r}") + return str(version) + + +def forbidden_members(names: list[str]) -> list[str]: + result = [] + for name in names: + parts = PurePosixPath(name).parts + if ( + any(part in FORBIDDEN_DIRECTORIES for part in parts) + or name.endswith(".code-workspace") + or name.endswith((".pyc", ".pyo")) + ): + result.append(name) + return result + + +def _one(directory: Path, pattern: str) -> Path: + matches = sorted(directory.glob(pattern)) + if len(matches) != 1: + raise ValueError(f"expected one {pattern} in {directory}, found {matches}") + return matches[0] + + +def _require_suffix(names: list[str], suffix: str) -> None: + if not any(name.endswith(suffix) for name in names): + raise ValueError(f"archive is missing required path ending in {suffix!r}") + + +def _normalized_requirement(value: str) -> str: + return value.replace(" ", "") + + +def _validate_metadata(metadata, expected_version: str, archive_kind: str) -> None: + project_name = metadata["Name"] + if project_name is None or project_name.lower().replace("_", "-") != "vorflow": + raise ValueError(f"unexpected {archive_kind} project name: {project_name}") + if metadata["Version"] != expected_version: + raise ValueError( + f"{archive_kind} version {metadata['Version']} does not match " + f"{expected_version}" + ) + if metadata["Requires-Python"] != ">=3.10": + raise ValueError( + f"unexpected {archive_kind} Requires-Python: " + f"{metadata['Requires-Python']}" + ) + requirements = { + _normalized_requirement(value) + for value in metadata.get_all("Requires-Dist", []) + if "extra==" not in _normalized_requirement(value) + } + if requirements != EXPECTED_REQUIREMENTS: + raise ValueError( + f"unexpected {archive_kind} runtime requirements: {requirements}" + ) + if metadata["License-Expression"] != "MIT": + raise ValueError( + f"{archive_kind} does not declare the MIT SPDX expression" + ) + if "LICENSE" not in metadata.get_all("License-File", []): + raise ValueError(f"{archive_kind} metadata does not declare LICENSE") + if "Oscar Sanchez" not in (metadata["Author-email"] or ""): + raise ValueError(f"primary author is missing from {archive_kind} metadata") + if "rhugman" not in (metadata["Author"] or ""): + raise ValueError(f"original author is missing from {archive_kind} metadata") + if "Oscar Sanchez" not in (metadata["Maintainer-email"] or ""): + raise ValueError(f"maintainer is missing from {archive_kind} metadata") + project_urls = set(metadata.get_all("Project-URL", [])) + if not EXPECTED_URLS.issubset(project_urls): + raise ValueError( + f"{archive_kind} is missing project URLs: " + f"{EXPECTED_URLS - project_urls}" + ) + + +def validate_wheel(wheel: Path, expected_version: str) -> None: + with zipfile.ZipFile(wheel) as archive: + names = archive.namelist() + bad = forbidden_members(names) + if bad: + raise ValueError(f"wheel contains forbidden members: {bad}") + _require_suffix(names, "vorflow/__init__.py") + _require_suffix(names, ".dist-info/licenses/LICENSE") + metadata_name = next( + (name for name in names if name.endswith(".dist-info/METADATA")), + None, + ) + if metadata_name is None: + raise ValueError("wheel has no .dist-info/METADATA") + metadata = BytesParser(policy=default).parsebytes(archive.read(metadata_name)) + + _validate_metadata(metadata, expected_version, "wheel") + + +def validate_sdist(sdist: Path, expected_version: str) -> None: + expected_filename = f"vorflow-{expected_version}.tar.gz" + if sdist.name != expected_filename: + raise ValueError( + f"sdist filename {sdist.name!r} does not match {expected_filename!r}" + ) + root = f"vorflow-{expected_version}" + with tarfile.open(sdist, "r:gz") as archive: + names = archive.getnames() + bad = forbidden_members(names) + if bad: + raise ValueError(f"sdist contains forbidden members: {bad}") + roots = { + PurePosixPath(name).parts[0] + for name in names + if PurePosixPath(name).parts + } + if roots != {root}: + raise ValueError(f"sdist has unexpected top-level paths: {sorted(roots)}") + for required in ( + "PKG-INFO", + "pyproject.toml", + "README.md", + "LICENSE", + "src/vorflow/__init__.py", + ): + member_name = f"{root}/{required}" + if member_name not in names: + raise ValueError(f"sdist is missing {member_name}") + metadata_file = archive.extractfile(f"{root}/PKG-INFO") + if metadata_file is None: + raise ValueError(f"sdist cannot read {root}/PKG-INFO") + metadata = BytesParser(policy=default).parsebytes(metadata_file.read()) + + _validate_metadata(metadata, expected_version, "sdist") + + +def validate_dist(directory: Path, expected_version: str) -> None: + wheel = _one(directory, "*.whl") + sdist = _one(directory, "*.tar.gz") + validate_wheel(wheel, expected_version) + validate_sdist(sdist, expected_version) + print(f"Validated {wheel.name} and {sdist.name}") + + +def main() -> None: + parser = argparse.ArgumentParser() + parser.add_argument("directory", type=Path) + version_group = parser.add_mutually_exclusive_group(required=True) + version_group.add_argument("--expected-version") + version_group.add_argument("--expected-tag") + args = parser.parse_args() + expected = ( + version_from_tag(args.expected_tag) + if args.expected_tag + else args.expected_version + ) + validate_dist(args.directory, expected) + + +if __name__ == "__main__": + main() diff --git a/src/.DS_Store b/src/.DS_Store deleted file mode 100644 index e3bf75f..0000000 Binary files a/src/.DS_Store and /dev/null differ diff --git a/src/vorflow/__init__.py b/src/vorflow/__init__.py index 2ad235b..93fe698 100644 --- a/src/vorflow/__init__.py +++ b/src/vorflow/__init__.py @@ -1,5 +1,29 @@ +from importlib.metadata import PackageNotFoundError, version + +try: + __version__ = version("vorflow") +except PackageNotFoundError: + __version__ = "0+unknown" + +from ._log import set_verbosity + +# Default: show progress messages, like the historical print() output. +# Call vorflow.set_verbosity(0) to silence everything except warnings/errors. +set_verbosity(1) + from .blueprint import ConceptualMesh from .engine import MeshGenerator from .tessellator import VoronoiTessellator +from .fields import ( + AutoExponentialField, + AutoLinearField, + ExponentialField, + GeometricGrowthField, + MeshField, + ThresholdField, +) -__all__ = ["ConceptualMesh", "MeshGenerator", "VoronoiTessellator"] \ No newline at end of file +__all__ = ["ConceptualMesh", "MeshGenerator", "VoronoiTessellator", + "MeshField", "ThresholdField", "ExponentialField", + "GeometricGrowthField", "AutoLinearField", "AutoExponentialField", + "set_verbosity"] diff --git a/src/vorflow/_log.py b/src/vorflow/_log.py new file mode 100644 index 0000000..197f1ff --- /dev/null +++ b/src/vorflow/_log.py @@ -0,0 +1,40 @@ +"""Package-wide logging setup. + +vorflow reports progress through the standard :mod:`logging` module under the +``"vorflow"`` logger. Messages keep the plain look of the old ``print()`` +output, but can now be silenced, made more verbose, or redirected to a file +without touching library code. + +Verbosity mapping (same scale MeshGenerator has always documented): + +- ``0`` — silent: only warnings and errors are shown. +- ``1`` — basic progress messages (the package default). +- ``2`` — debug diagnostics (the ``[DIAG]`` output). +""" +from __future__ import annotations + +import logging + +_LEVELS = {0: logging.WARNING, 1: logging.INFO} + +_handler = None + + +def set_verbosity(verbosity): + """Set how talkative vorflow is on the console. + + Args: + verbosity (int): 0 = warnings/errors only, 1 = progress messages + (default), 2 or more = debug diagnostics. + """ + global _handler + logger = logging.getLogger("vorflow") + if _handler is None: + _handler = logging.StreamHandler() + _handler.setFormatter(logging.Formatter("%(message)s")) + logger.addHandler(_handler) + # Keep messages out of the root logger so applications that configure + # their own logging don't see vorflow output twice. Attach handlers to + # the "vorflow" logger to customize destination/format. + logger.propagate = False + logger.setLevel(_LEVELS.get(int(verbosity), logging.DEBUG)) diff --git a/src/vorflow/blueprint.py b/src/vorflow/blueprint.py index bb869a9..0fad868 100644 --- a/src/vorflow/blueprint.py +++ b/src/vorflow/blueprint.py @@ -1,12 +1,80 @@ +from __future__ import annotations + +import logging +import math +import warnings import geopandas as gpd import pandas as pd import numpy as np -from shapely.geometry import Polygon, LineString, Point, box, MultiPolygon -from shapely.ops import unary_union, snap, linemerge +from shapely.geometry import Polygon, LineString, MultiPolygon +from shapely.ops import unary_union, snap +from shapely.prepared import prep from shapely.validation import make_valid +from shapely.strtree import STRtree + +logger = logging.getLogger(__name__) + +# Constants for geometry simplification and reporting +SIGNIFICANT_REDUCTION_PCT = 1.0 +DEFAULT_CONNECTIVITY_TOLERANCE = 1e-3 + + +def _validate_growth_factor(value): + if value is None: + return None + if isinstance(value, bool) or not isinstance(value, (int, float)): + raise ValueError( + f"growth_factor must be a number greater than 1.0 (or None). Got {value!r}." + ) + if not math.isfinite(value): + raise ValueError(f"growth_factor must be finite. Got {value}.") + if value <= 1.0: + raise ValueError(f"growth_factor must be greater than 1.0. Got {value}.") + return float(value) + +def _coerce_connectivity_tolerance(value, parameter_name="connectivity_tolerance"): + if isinstance(value, bool): + raise ValueError( + f"{parameter_name} must be a non-negative number. Boolean values are not supported." + ) + if not isinstance(value, (int, float)): + raise TypeError( + f"{parameter_name} must be a non-negative number. Got {type(value).__name__}." + ) + if value < 0: + raise ValueError(f"{parameter_name} must be non-negative. Got {value}.") + return float(value) + + +def _warn_if_geographic_crs(crs): + """Warn when the project CRS is geographic (lat/lon degrees). + + Mesh sizes (resolution, background_lc, buffer thicknesses) are expressed + in CRS units, and MODFLOW needs real length units for cell areas and + conductances -- meshing in degrees is almost certainly a mistake. + """ + if crs is None: + return + try: + from pyproj import CRS + is_geographic = CRS.from_user_input(crs).is_geographic + except Exception: + # Unparseable CRS spec: GeoDataFrame construction will surface it. + return + if is_geographic: + warnings.warn( + f"The project CRS ({crs}) is geographic (latitude/longitude " + "degrees). Mesh sizes will be in degrees and the resulting " + "MODFLOW grid will be physically meaningless (1 deg of longitude " + "and latitude differ in length, and cell areas/conductances need " + "length units). Reproject your data to a projected CRS (e.g. a " + "UTM zone) with GeoDataFrame.to_crs() before building the mesh.", + stacklevel=3, + ) + class ConceptualMesh: - def __init__(self, crs="EPSG:4326"): + def __init__(self, crs=None, connectivity_tolerance=DEFAULT_CONNECTIVITY_TOLERANCE): """ Initializes the conceptual model, which holds raw geometric inputs. @@ -15,9 +83,20 @@ def __init__(self, crs="EPSG:4326"): inputs for the mesh generator. Args: - crs: The coordinate reference system for the project (e.g., "EPSG:4326"). + crs: The coordinate reference system for the project. Use a + *projected* CRS (e.g. a UTM zone like "EPSG:32618") so mesh + sizes are in real length units. Geographic CRSs (lat/lon + degrees, e.g. "EPSG:4326") produce physically meaningless + grids and trigger a warning -- reproject your data first with + GeoDataFrame.to_crs(). None (default) means local/unspecified + coordinates; output GeoDataFrames then carry no CRS. + connectivity_tolerance (float, optional): Default snapping tolerance used + during topology cleanup in generate(). Larger values make lines and + points connect more aggressively to nearby geometry. """ self.crs = crs + _warn_if_geographic_crs(crs) + self.connectivity_tolerance = _coerce_connectivity_tolerance(connectivity_tolerance) # Store raw geometric inputs before processing. self.raw_polygons = [] self.raw_lines = [] @@ -29,7 +108,22 @@ def __init__(self, crs="EPSG:4326"): self.clean_lines = gpd.GeoDataFrame() self.clean_points = gpd.GeoDataFrame() - def add_polygon(self, geometry, zone_id, resolution=None, z_order=0, mesh_refinement=True, dist_min=None, dist_max=None, dist_max_in=None, dist_max_out=None, border_density=None): + def add_polygon( + self, + geometry, + zone_id, + resolution=None, + z_order=0, + dist_min=None, + dist_max=None, + densify=None, + fields=None, + embed=True, + simplify_tolerance=None, + quad_buffer=False, + quad_buffer_thickness=1, + growth_factor=None, + ): """ Adds a polygon feature, such as a model boundary or a refinement zone. @@ -39,39 +133,104 @@ def add_polygon(self, geometry, zone_id, resolution=None, z_order=0, mesh_refine resolution (float, optional): Target mesh size within this polygon. If None, the background mesh size will be used. z_order (int): Stacking order for resolving overlaps. Higher values are - processed first and will "cut" into lower-order polygons. - mesh_refinement (bool): If True, this polygon will be used to control mesh - refinement. If False, it is used only for tagging the final cells. - dist_min (float, optional): Distance from the polygon boundary where the mesh - size is held constant at the boundary's resolution. - dist_max (float, optional): Legacy alias for `dist_max_out`. - dist_max_in (float, optional): Distance inside the polygon over which the mesh - transitions from the boundary resolution to the internal resolution. - dist_max_out (float, optional): Distance outside the polygon over which the - mesh transitions to the background resolution. - border_density (float, optional): If set, densifies the polygon's boundary - by adding vertices, ensuring no segment is longer than this value. + processed first and will "cut" into lower-order polygons. Also acts + as the crossing priority when this polygon's quad buffer crosses + another quad-buffered feature (higher stays continuous). To control + the two independently, add the zone without ``quad_buffer`` and add + its boundary as a separate quad-buffered line with its own z_order. + dist_min (float, optional): DEPRECATED. Distance from the polygon boundary where + the mesh size is held constant at the boundary's resolution. Supplying + dist_min/dist_max selects the legacy linear ThresholdField transition and + emits a DeprecationWarning; omit them to use the default GeometricGrowthField. + dist_max (float, optional): DEPRECATED. Distance from the polygon boundary over + which the mesh transitions to the background resolution. See dist_min. + growth_factor (float, optional): Cell-to-cell growth ratio (>1.0) for the default + GeometricGrowthField size transition away from the feature. Defaults to 1.2. + Ignored when an explicit ``fields`` list or the legacy dist_min/dist_max is given. + densify (float|bool|None, optional): Controls polygon boundary densification: + - If False, disables densification. + - If True, densifies using `resolution` (lc). Requires `resolution` to be set. + - If a float, densifies so no boundary segment is longer than this value. + Raises ValueError if non-positive when specified as a float. + simplify_tolerance (float|int|None, optional): If a number > 0, applies Douglas-Peucker + simplification with this tolerance. If None or 0, no simplification is applied. + Raises ValueError if negative. Boolean values are not supported. + fields (list, optional): List of MeshField objects. + embed (bool): If True, the polygon is embedded in the mesh. If False, it is used only for fields. + quad_buffer (bool): If True, replaces the meshed polygon outline + with a quad band straddling it (the annulus between the + ``+/- thickness * resolution / 2`` offsets, meshed as + recombined quads; annuli cannot be 4-corner transfinite). The + outline itself never becomes mesh edges: with + ``quad_buffer_thickness=1`` no nodes fall on it, so the Voronoi + cell faces trace the shapefile shape; with ``2`` a node row + lands on it, giving a row of ~square cells centered on the + shape. (For the triangular element-grid deliverable the reading + is opposite: ``2`` puts element edges along the outline.) + When the band crosses another quad buffer, the higher-priority + feature (``z_order``, then finer resolution, wider strip, lines + over polygons) stays continuous and only the other is trimmed + with a warning; polygons narrower than the band fall back to a + plain outline with a warning. + quad_buffer_thickness (int): Band width in local cell widths + (multiples of ``resolution``, like gmshflow's ``cs_thick``). + Supported values are 1 and 2. """ if not geometry.is_valid: geometry = make_valid(geometry) - - # For backward compatibility, allow 'dist_max' to function as 'dist_max_out'. - if dist_max is not None and dist_max_out is None: - dist_max_out = dist_max - self.raw_polygons.append({ - 'geometry': geometry, - 'zone_id': zone_id, - 'lc': resolution, - 'z_order': z_order, - 'refine': mesh_refinement, - 'dist_min': dist_min, - 'dist_max_in': dist_max_in, - 'dist_max_out': dist_max_out, - 'border_density': border_density - }) + if isinstance(simplify_tolerance, bool): + raise ValueError( + "simplify_tolerance must be a non-negative number (or None/0 to disable). " + "Boolean values are not supported." + ) + if isinstance(simplify_tolerance, (int, float)) and simplify_tolerance < 0: + raise ValueError(f"simplify_tolerance must be non-negative. Got {simplify_tolerance}.") + + if isinstance(densify, (int, float)) and not isinstance(densify, bool) and densify <= 0: + raise ValueError(f"densify must be positive when specified as a float. Got {densify}.") + if densify is True and (resolution is None or resolution <= 0): + raise ValueError("densify=True for polygons requires a positive `resolution` (lc).") + + if resolution is not None and resolution <= 0: + raise ValueError(f"resolution must be positive (or None). Got {resolution}.") + + if dist_max is not None and dist_max < 0: + raise ValueError(f"dist_max must be non-negative (or None). Got {dist_max}.") + + if dist_min is not None and dist_min < 0: + raise ValueError(f"dist_min must be non-negative (or None). Got {dist_min}.") + + if quad_buffer_thickness not in (1, 2): + raise ValueError("quad_buffer_thickness must be either 1 or 2.") + + growth_factor = _validate_growth_factor(growth_factor) + + if fields is None: + fields = [] - def add_line(self, geometry, line_id, resolution, snap_to_polygons=True, is_barrier=False, dist_min=None, dist_max=None, straddle_width=None): + self.raw_polygons.append( + { + "geometry": geometry, + "zone_id": zone_id, + "lc": resolution, + "z_order": z_order, + "dist_min": dist_min, + "dist_max": dist_max, + "densify": densify, + "simplify_tolerance": simplify_tolerance, + 'fields': fields, + 'embed': embed, + 'quad_buffer': bool(quad_buffer), + 'quad_buffer_thickness': int(quad_buffer_thickness), + 'growth_factor': growth_factor, + } + ) + + def add_line(self, geometry, line_id, resolution, snap_to_polygons=True, is_barrier=False, + dist_min=None, dist_max=None, straddle_width=None, fields=None, embed=True, densify=True, + simplify_tolerance=None, quad_buffer=False, quad_buffer_thickness=1, z_order=0, + growth_factor=None): """ Adds a line feature, such as a river, fault, or other linear boundary. @@ -83,16 +242,71 @@ def add_line(self, geometry, line_id, resolution, snap_to_polygons=True, is_barr nearby polygon boundaries to ensure connectivity. is_barrier (bool): If True, the line is treated as a flow barrier. The mesh will be constructed to prevent cell faces from crossing it. - dist_min (float, optional): Distance from the line where the mesh size is - held constant at the line's resolution. - dist_max (float, optional): Distance from the line over which the mesh - transitions to the background resolution. + dist_min (float, optional): DEPRECATED. Distance from the line where the mesh size + is held constant at the line's resolution. Supplying dist_min/dist_max selects + the legacy linear ThresholdField transition and emits a DeprecationWarning; + omit them to use the default GeometricGrowthField. + dist_max (float, optional): DEPRECATED. Distance from the line over which the mesh + transitions to the background resolution. See dist_min. straddle_width (float, optional): If set, forces Voronoi cell edges to align perfectly with the line by creating a "virtual straddle" of mesh nodes. + fields (list, optional): List of MeshField objects. + embed (bool): If True, the line is embedded in the mesh. If False, it is used only for fields. + densify (float or bool, optional): Controls line densification: + - If False, disables densification. + - If True, densifies the line using the `resolution` value. + - If a float, densifies the line so that no segment is longer than this value. + Raises ValueError if negative or zero. + simplify_tolerance (float|int|None, optional): If a number > 0, simplifies the line with + this tolerance using Douglas-Peucker algorithm. If None or 0, no simplification is applied. + Raises ValueError if negative. Boolean values are not supported. + quad_buffer (bool): If True, creates an opt-in structured quad buffer + strip around the line instead of the lightweight straddle points. + The strip is meshed as a 4-corner transfinite surface (structured + quad rows): with ``quad_buffer_thickness=1`` no nodes fall on + the line, so the Voronoi faces align with it (sharp barrier); + with ``2`` a node row lands on it, giving a row of ~square + Voronoi cells centered on the line. (For the triangular + element-grid deliverable the reading is opposite: ``2`` puts + element edges along the line.) When two quad buffers cross, + the higher-priority one stays continuous and only the other is + trimmed at the crossing with a warning (priority: ``z_order``, + then finer resolution, wider strip, lines over polygons, + insertion order). Strips crossing a barrier/straddle corridor + are still trimmed there. Independent of ``is_barrier``. + quad_buffer_thickness (int): Strip width in local cell widths + (multiples of ``resolution``, like gmshflow's ``cs_thick``). + Supported values are 1 and 2. + z_order (int): Crossing priority for quad buffers. When this + feature's quad buffer crosses another one, the feature with the + higher ``z_order`` keeps its strip continuous and the other is + trimmed. Lines do not participate in polygon overlap stacking. + growth_factor (float, optional): Cell-to-cell growth ratio (>1.0) for the default + GeometricGrowthField size transition away from the line. Defaults to 1.2. + Ignored when an explicit ``fields`` list or the legacy dist_min/dist_max is given. """ if not geometry.is_valid: geometry = make_valid(geometry) - + + if isinstance(simplify_tolerance, bool): + raise ValueError( + "simplify_tolerance must be a non-negative number (or None/0 to disable). " + "Boolean values are not supported." + ) + if isinstance(simplify_tolerance, (int, float)) and simplify_tolerance < 0: + raise ValueError(f"simplify_tolerance must be non-negative. Got {simplify_tolerance}.") + + if isinstance(densify, (int, float)) and not isinstance(densify, bool) and densify <= 0: + raise ValueError(f"densify must be positive when specified as a float. Got {densify}.") + + if quad_buffer_thickness not in (1, 2): + raise ValueError("quad_buffer_thickness must be either 1 or 2.") + + growth_factor = _validate_growth_factor(growth_factor) + + if fields is None: + fields = [] + self.raw_lines.append({ 'geometry': geometry, 'line_id': line_id, @@ -100,10 +314,18 @@ def add_line(self, geometry, line_id, resolution, snap_to_polygons=True, is_barr 'is_barrier': is_barrier, 'dist_min': dist_min, 'dist_max': dist_max, - 'straddle_width': straddle_width + 'straddle_width': straddle_width, + 'fields': fields, + 'embed': embed, + 'densify': densify, + 'simplify_tolerance': simplify_tolerance, + 'quad_buffer': bool(quad_buffer), + 'quad_buffer_thickness': int(quad_buffer_thickness), + 'z_order': z_order, + 'growth_factor': growth_factor, }) - def add_point(self, geometry, point_id, resolution, dist_min=None, dist_max=None): + def add_point(self, geometry, point_id, resolution, dist_min=None, dist_max=None, fields=None, embed=True, simplify_tolerance=None, growth_factor=None): """ Adds a point feature, such as a well or an observation point. @@ -111,18 +333,147 @@ def add_point(self, geometry, point_id, resolution, dist_min=None, dist_max=None geometry (shapely.Point): The point geometry. point_id (str): A unique identifier for the point. resolution (float): Target mesh size at the point. - dist_min (float, optional): Distance from the point where the mesh size is - held constant at the point's resolution. - dist_max (float, optional): Distance from the point over which the mesh - transitions to the background resolution. + dist_min (float, optional): DEPRECATED. Distance from the point where the mesh size + is held constant at the point's resolution. Supplying dist_min/dist_max selects + the legacy linear ThresholdField transition and emits a DeprecationWarning; + omit them to use the default GeometricGrowthField. + dist_max (float, optional): DEPRECATED. Distance from the point over which the mesh + transitions to the background resolution. See dist_min. + simplify_tolerance (float|int|None, optional): If a number > 0, merges points that are closer + than this tolerance. If None or 0, no merging is applied. Raises ValueError if negative. + Boolean values are not supported. + growth_factor (float, optional): Cell-to-cell growth ratio (>1.0) for the default + GeometricGrowthField size transition away from the point. Defaults to 1.2. + Ignored when an explicit ``fields`` list or the legacy dist_min/dist_max is given. """ + if isinstance(simplify_tolerance, bool): + raise ValueError( + "simplify_tolerance must be a non-negative number (or None/0 to disable). " + "Boolean values are not supported." + ) + if isinstance(simplify_tolerance, (int, float)) and simplify_tolerance < 0: + raise ValueError(f"simplify_tolerance must be non-negative. Got {simplify_tolerance}.") + + growth_factor = _validate_growth_factor(growth_factor) + + if fields is None: + fields = [] self.raw_points.append({ 'geometry': geometry, 'point_id': point_id, 'lc': resolution, 'dist_min': dist_min, - 'dist_max': dist_max + 'dist_max': dist_max, + 'fields': fields, + 'embed': embed, + 'simplify_tolerance': simplify_tolerance, + 'growth_factor': growth_factor, }) + def _apply_simplification(self): + """ + Applies geometry simplification to raw polygons, lines, and points + based on their specified tolerances to reduce geometric complexity. + + For polygons and lines the Douglas-Peucker algorithm is used. + For points, this method performs deduplication: points that are within + a specified tolerance of each other are merged, and only the point with the + finest (smallest) resolution is kept. + """ + # Simplify Polygons + for i, poly_data in enumerate(self.raw_polygons): + tol = poly_data.get('simplify_tolerance') + if isinstance(tol, bool): + raise ValueError( + "simplify_tolerance must be a non-negative number (or None/0 to disable). " + "Boolean values are not supported." + ) + + if tol is not None and tol > 0: + org_area = poly_data['geometry'].area + simplified_geom = poly_data['geometry'].simplify(tol, preserve_topology=True) + self.raw_polygons[i]['geometry'] = simplified_geom + new_area = simplified_geom.area + if new_area < org_area and org_area > 0: + reduction_pct = 100 * (org_area - new_area) / org_area + if reduction_pct > SIGNIFICANT_REDUCTION_PCT: + logger.info( + f"Simplified polygon (zone_id={poly_data['zone_id']}) " + f"reduced area by {reduction_pct:.2f}% using tolerance {tol}." + ) + + # Simplify Lines + for i, line_data in enumerate(self.raw_lines): + tol = line_data.get('simplify_tolerance') + if isinstance(tol, bool): + raise ValueError( + "simplify_tolerance must be a non-negative number (or None/0 to disable). " + "Boolean values are not supported." + ) + + if tol is not None and tol > 0: + org_length = line_data['geometry'].length + simplified_geom = line_data['geometry'].simplify(tol, preserve_topology=True) + self.raw_lines[i]['geometry'] = simplified_geom + new_length = simplified_geom.length + if new_length < org_length and org_length > 0: + reduction_pct = 100 * (org_length - new_length) / org_length + if reduction_pct > SIGNIFICANT_REDUCTION_PCT: + logger.info( + f"Simplified line (line_id={line_data['line_id']}) " + f"reduced length by {reduction_pct:.2f}% using tolerance {tol}." + ) + + # Merge points that are very close to each other (deduplication) + if self.raw_points: + # Let's sort by resolution first + sorted_points = sorted( + self.raw_points, + key=lambda x: x['lc'] if x['lc'] is not None else float('inf') + ) + final_points = [] + geoms = [p['geometry'] for p in sorted_points] + tree = STRtree(geoms) + kept_indices = set() + + for i, point_data in enumerate(sorted_points): + current_geom = point_data['geometry'] + tol = point_data.get('simplify_tolerance') + + if isinstance(tol, bool): + raise ValueError( + "simplify_tolerance must be a non-negative number (or None/0 to disable). " + "Boolean values are not supported." + ) + + # None or <=0 => no merging for this point (keep as-is) + if tol is None or tol <= 0: + final_points.append(point_data) + kept_indices.add(i) + continue + + is_merged = False + + # Query tree for potential neighbors + # tree.query returns indices of geometries that intersect the buffer + search_area = current_geom.buffer(tol) + candidate_indices = tree.query(search_area) + + for candidate_idx in candidate_indices: + if candidate_idx in kept_indices: + if geoms[candidate_idx].distance(current_geom) < tol: + is_merged = True + break + + if not is_merged: + final_points.append(point_data) + kept_indices.add(i) + + if len(self.raw_points) != len(final_points): + logger.info( + f"Simplification merged {len(self.raw_points) - len(final_points)} " + f"points out of {len(self.raw_points)}" + ) + self.raw_points = final_points def _resolve_overlaps(self): """ @@ -131,10 +482,30 @@ def _resolve_overlaps(self): lower ones. """ # Sort polygons by priority, with the highest z_order processed first. + if not self.raw_polygons: + # If this is empty, just create an empty GeoDataFrame. + self.clean_polygons = gpd.GeoDataFrame( + columns=[ + "geometry", + "zone_id", + "lc", + "z_order", + "dist_min", + "dist_max", + "densify", + "simplify_tolerance", + "fields", + "embed", + "quad_buffer", + "quad_buffer_thickness", + "growth_factor", + ], + crs=self.crs, + ) + return df = pd.DataFrame(self.raw_polygons) df = df.sort_values(by='z_order', ascending=False) - processed_geoms = [] occupied_space = None # Tracks the union of all higher-priority polygons. final_features = [] @@ -150,7 +521,7 @@ def _resolve_overlaps(self): # Subtract the already-occupied space from the current polygon. try: final_geo = current_geo.difference(occupied_space) - except Exception as e: + except Exception: # If the standard difference fails, try again with valid geometries. current_geo = make_valid(current_geo) occupied_space = make_valid(occupied_space) @@ -180,13 +551,18 @@ def _resolve_overlaps(self): self.clean_polygons = gpd.GeoDataFrame(final_features, crs=self.crs) - def _enforce_connectivity(self, tolerance=1e-3): + def _enforce_connectivity(self, connectivity_tolerance=None): """ Snaps features together to ensure they are topologically connected before being passed to the mesher. This is crucial for Gmsh to correctly interpret shared boundaries. """ + if connectivity_tolerance is None: + tolerance = self.connectivity_tolerance + else: + tolerance = _coerce_connectivity_tolerance(connectivity_tolerance) + # 1. Collect all polygon boundaries into a single geometry. # We snap to the linear boundaries, not the polygon areas. if not self.clean_polygons.empty: @@ -197,7 +573,7 @@ def _enforce_connectivity(self, tolerance=1e-3): # 2. Snap lines to polygon boundaries. # This ensures that features like rivers connect precisely to zone edges. if self.raw_lines and poly_boundaries is not None and not poly_boundaries.is_empty: - print(f"Snapping {len(self.raw_lines)} lines to polygon boundaries (tol={tolerance})...") + logger.info(f"Snapping {len(self.raw_lines)} lines to polygon boundaries (tol={tolerance})...") for i, line_data in enumerate(self.raw_lines): original_line = line_data['geometry'] snapped_line = snap(original_line, poly_boundaries, tolerance) @@ -218,38 +594,216 @@ def _enforce_connectivity(self, tolerance=1e-3): if geoms_to_snap_to: reference_geom = unary_union(geoms_to_snap_to) - print(f"Snapping {len(self.raw_points)} points to geometry (tol={tolerance})...") + logger.info(f"Snapping {len(self.raw_points)} points to geometry (tol={tolerance})...") for i, point_data in enumerate(self.raw_points): original_point = point_data['geometry'] snapped_point = snap(original_point, reference_geom, tolerance) self.raw_points[i]['geometry'] = snapped_point - def generate(self): + def _clip_features_to_domain(self): + """Remove or trim line/point features that remain outside the meshing domain.""" + if self.clean_polygons.empty: + return + + domain_union = unary_union(self.clean_polygons.geometry) + if domain_union.is_empty: + return + domain_union = make_valid(domain_union) + # Prepared-geometry fast paths: most features are entirely inside + # (or outside) the domain, where a cheap predicate avoids the full + # boolean intersection. + domain_prep = prep(domain_union) + + clipped_lines = [] + for line_data in self.raw_lines: + geom = line_data.get("geometry") + if geom is None or geom.is_empty: + continue + if not domain_prep.intersects(geom): + continue + if domain_prep.covers(geom): + clipped = geom + else: + try: + clipped = geom.intersection(domain_union) + except Exception: + clipped = make_valid(geom).intersection(domain_union) + + if clipped.is_empty: + continue + + line_parts = [] + if clipped.geom_type in ("LineString", "MultiLineString"): + line_parts = [clipped] if clipped.geom_type == "LineString" else list(clipped.geoms) + elif clipped.geom_type == "GeometryCollection": + line_parts = [ + part for part in clipped.geoms + if part.geom_type in ("LineString", "MultiLineString") and not part.is_empty + ] + + for part in line_parts: + if part.geom_type == "MultiLineString": + for subpart in part.geoms: + if subpart.length > 0: + feat = line_data.copy() + feat["geometry"] = subpart + clipped_lines.append(feat) + elif part.length > 0: + feat = line_data.copy() + feat["geometry"] = part + clipped_lines.append(feat) + + removed_lines = len(self.raw_lines) - len(clipped_lines) + if removed_lines > 0: + logger.info(f"Clipped/removed {removed_lines} line feature(s) outside the domain.") + self.raw_lines = clipped_lines + + kept_points = [] + for point_data in self.raw_points: + geom = point_data.get("geometry") + if geom is None or geom.is_empty: + continue + if domain_union.covers(geom): + kept_points.append(point_data) + + removed_points = len(self.raw_points) - len(kept_points) + if removed_points > 0: + logger.info(f"Removed {removed_points} point feature(s) outside the domain.") + self.raw_points = kept_points + + + def generate(self, connectivity_tolerance=None): """ Runs the full preprocessing workflow: resolves polygon overlaps, ensures topological connectivity, and prepares clean GeoDataFrames for the mesher. + + Args: + connectivity_tolerance (float, optional): Override for the instance's + default topology snapping tolerance during this preprocessing run. """ - print("Resolving polygon overlaps...") + logger.info("Applying optional geometry simplification...") + self._apply_simplification() + + # --- Embed semantics for polygons --- + # Polygons with embed=True define the actual meshing domain and therefore + # participate in the cookie-cutter (overlap resolution) process. + # Polygons with embed=False are refinement-only (field-only) regions and + # must NOT affect domain topology. + embedded_polys = [p for p in self.raw_polygons if bool(p.get("embed", True))] + field_only_polys = [p for p in self.raw_polygons if not bool(p.get("embed", True))] + + # Only embedded polygons are used to build the domain partition. + self.raw_polygons = embedded_polys + + logger.info("Resolving polygon overlaps...") self._resolve_overlaps() - print("Enforcing strict topology...") - self._enforce_connectivity() + logger.info("Enforcing strict topology...") + self._enforce_connectivity(connectivity_tolerance=connectivity_tolerance) + + logger.info("Clipping features to domain...") + self._clip_features_to_domain() # Promote the processed raw geometries to final "clean" GeoDataFrames. if self.raw_lines: self.clean_lines = gpd.GeoDataFrame(self.raw_lines, crs=self.crs) else: - self.clean_lines = gpd.GeoDataFrame(columns=['geometry', 'line_id', 'lc', 'is_barrier', 'dist_min', 'dist_max', 'straddle_width'], crs=self.crs) - + self.clean_lines = gpd.GeoDataFrame( + columns=[ + 'geometry', + 'line_id', + 'lc', + 'is_barrier', + 'dist_min', + 'dist_max', + 'straddle_width', + 'fields', + 'embed', + 'densify', + 'simplify_tolerance', + 'quad_buffer', + 'quad_buffer_thickness', + 'z_order', + 'growth_factor', + ], + crs=self.crs, + ) + # Clean Points if self.raw_points: self.clean_points = gpd.GeoDataFrame(self.raw_points, crs=self.crs) else: - self.clean_points = gpd.GeoDataFrame(columns=['geometry', 'point_id', 'lc', 'dist_min', 'dist_max'], crs=self.crs) + self.clean_points = gpd.GeoDataFrame( + columns=['geometry', 'point_id', 'lc', 'dist_min', 'dist_max', 'fields', 'embed', 'simplify_tolerance', 'growth_factor'], + crs=self.crs, + ) + + # Clip field-only polygons to the final embedded domain. + # Field-only polygons should not extend outside the domain, but they also + # should not cut/modify domain topology. + if field_only_polys and not self.clean_polygons.empty: + domain_union = unary_union(self.clean_polygons.geometry) + domain_union = make_valid(domain_union) + domain_prep = prep(domain_union) - print("Densifying geometry...") + clipped_features = [] + for poly_data in field_only_polys: + geom = poly_data.get("geometry") + if geom is None or geom.is_empty: + continue + geom = make_valid(geom) + if not domain_prep.intersects(geom): + continue + if domain_prep.covers(geom): + clipped = geom + else: + try: + clipped = geom.intersection(domain_union) + except Exception: + clipped = make_valid(geom).intersection(make_valid(domain_union)) + + if clipped.is_empty: + continue + + feat = poly_data.copy() + feat["geometry"] = make_valid(clipped) + clipped_features.append(feat) + + if clipped_features: + field_only_gdf = gpd.GeoDataFrame(clipped_features, crs=self.crs) + # Align schemas before concat to avoid pandas dtype inference warnings + # while preserving the canonical polygon columns. + polygon_columns = [ + 'geometry', + 'zone_id', + 'lc', + 'z_order', + 'dist_min', + 'dist_max', + 'fields', + 'embed', + 'densify', + 'simplify_tolerance', + 'quad_buffer', + 'quad_buffer_thickness', + 'growth_factor', + ] + self.clean_polygons = self.clean_polygons.reindex(columns=polygon_columns) + field_only_gdf = field_only_gdf.reindex(columns=polygon_columns) + # Drop all-null non-geometry columns only during concat; they are + # restored immediately after so the public GeoDataFrame shape is unchanged. + concat_frames = [ + frame.dropna(axis=1, how='all') + for frame in (self.clean_polygons, field_only_gdf) + ] + self.clean_polygons = gpd.GeoDataFrame( + pd.concat(concat_frames, ignore_index=True).reindex(columns=polygon_columns), + crs=self.crs, + ) + + logger.info("Densifying geometry...") self._apply_densification() return self.clean_polygons, self.clean_lines, self.clean_points @@ -310,15 +864,43 @@ def densify_line(line, max_segment_length): def _apply_densification(self): """Applies densification to the clean polygon and line features.""" - # Densify polygon boundaries where a 'border_density' is specified. + # Densify polygon boundaries based on `densify`. if not self.clean_polygons.empty: - self.clean_polygons['geometry'] = self.clean_polygons.apply( - lambda row: self._densify_geometry(row['geometry'], row['border_density']) - if pd.notna(row.get('border_density')) else row['geometry'], axis=1 - ) + + def get_poly_resolution(row): + d = row.get("densify") + if d is False or pd.isna(d): + return None + if d is True: + return row.get("lc") + if isinstance(d, (int, float)) and not isinstance(d, bool) and d > 0: + return d + return None + + def _poly_densify(row): + res = get_poly_resolution(row) + return self._densify_geometry(row["geometry"], res) if res is not None else row["geometry"] + + self.clean_polygons["geometry"] = self.clean_polygons.apply(_poly_densify, axis=1) # Densify lines based on their target resolution ('lc'). if not self.clean_lines.empty: - self.clean_lines['geometry'] = self.clean_lines.apply( - lambda row: self._densify_geometry(row['geometry'], row['lc']), axis=1 - ) \ No newline at end of file + # Helper to determine the target resolution for a line row + def get_line_resolution(row): + d = row.get('densify') + + # 1. Explicitly disabled (densify=False) + if d is False: + return None + + # 2. Explicit custom resolution (e.g., densify=5.0) + if isinstance(d, (int, float)) and not isinstance(d, bool) and d > 0: + return d + + # 3. Default behavior (True or None): use the mesh resolution (lc) + return row.get('lc') + def _line_densify(row): + res = get_line_resolution(row) + return self._densify_geometry(row['geometry'], res) if res is not None else row['geometry'] + + self.clean_lines['geometry'] = self.clean_lines.apply(_line_densify, axis=1) diff --git a/src/vorflow/engine.py b/src/vorflow/engine.py index 942cde2..c121071 100644 --- a/src/vorflow/engine.py +++ b/src/vorflow/engine.py @@ -1,14 +1,108 @@ +from __future__ import annotations + +import logging import gmsh -import sys import math +import warnings import numpy as np import pandas as pd -from shapely.geometry import Point, LineString, Polygon -from shapely.ops import unary_union +import geopandas as gpd +from shapely.geometry import Point, LineString, MultiLineString, MultiPolygon, Polygon +from shapely.ops import linemerge, unary_union from shapely.validation import make_valid +from .fields import ( + DEFAULT_GROWTH_FACTOR, + ConstantField, + GeometricGrowthField, + MeshField, + ThresholdField, +) +from ._log import set_verbosity + + +logger = logging.getLogger(__name__) + + +# Half-cell gap left between a trimmed (lower-priority) quad buffer and the +# continuous (higher-priority) one it crosses. The loser is trimmed to the +# winner's footprint plus this many local cell widths, so its quads butt up +# against the winner's structured node row with one clean unstructured row in +# between. Tunable; larger values widen the gap if slivers appear. +QUAD_BUFFER_CROSSING_GAP = 0.5 + +def _unit_tangent(line, d, probe): + """Unit tangent of ``line`` at distance ``d`` along it. + + The direction is estimated from a short chord of length ``probe``. The + caller chooses ``probe`` proportional to the line length so the estimate + is CRS-unit independent (a fixed absolute step would span whole features + on short lines and blunt corners on curved ones). + """ + length = line.length + if d >= length - probe: + p1 = line.interpolate(max(d - probe, 0.0)) + p2 = line.interpolate(d) + else: + p1 = line.interpolate(d) + p2 = line.interpolate(d + probe) + dx, dy = p2.x - p1.x, p2.y - p1.y + mag = math.hypot(dx, dy) + if mag == 0: + # Degenerate (zero-length) input: any unit vector keeps the straddle + # pair perpendicular and non-coincident. + return 1.0, 0.0 + return dx / mag, dy / mag + + +def _to_key(dim, tag): + """Normalize a gmsh (dim, tag) pair into a hashable dict key.""" + return (int(dim), int(tag)) + + +def _assign_zones_to_elements(grid, zones_gdf): + """Assign a zone to each element by spatially joining element centroids. + + When a centroid intersects several zones (overlaps or shared borders) the + tie is broken deterministically: highest ``z_order`` wins, then the zone + that appears earliest in ``zones_gdf``. + """ + if zones_gdf is None or zones_gdf.empty or "zone_id" not in zones_gdf.columns: + grid["zone_id"] = pd.NA + grid["z_order"] = pd.NA + return grid + + zone_cols = ["geometry", "zone_id"] + if "z_order" in zones_gdf.columns: + zone_cols.append("z_order") + zones = zones_gdf[zone_cols].reset_index(drop=True) + centroids = gpd.GeoDataFrame( + {"element_tag": grid["element_tag"]}, + geometry=gpd.points_from_xy(grid["centroid_x"], grid["centroid_y"]), + crs=grid.crs, + ) + joined = gpd.sjoin(centroids, zones, how="left", predicate="intersects") + sort_cols, ascending = ["element_tag"], [True] + if "z_order" in joined.columns: + sort_cols += ["z_order", "index_right"] + ascending += [False, True] + else: + sort_cols += ["index_right"] + ascending += [True] + joined = joined.sort_values(sort_cols, ascending=ascending, kind="mergesort") + joined = joined.drop_duplicates(subset="element_tag") + merge_cols = ["element_tag", "zone_id"] + if "z_order" in joined.columns: + merge_cols.append("z_order") + return grid.merge(joined[merge_cols], on="element_tag", how="left") + class MeshGenerator: - def __init__(self, background_lc=None,verbosity=0, mesh_algorithm=6, smoothing_steps=10, optimization_cycles=2): + def __init__(self, background_lc=None, verbosity=0, mesh_algorithm=6, + smoothing_steps=10, optimization_cycles=2, + tolerance_initial_delaunay=1e-8, + heal_shapes=False, heal_tolerance=1e-8, + heal_fix_degenerated=True, heal_fix_small_edges=True, + heal_fix_small_faces=True, diagnose=False): """ Initializes the Gmsh-based mesh generator. @@ -25,17 +119,76 @@ def __init__(self, background_lc=None,verbosity=0, mesh_algorithm=6, smoothing_s performed by Gmsh during mesh generation. optimization_cycles (int): Number of explicit optimization passes (e.g., Relocate2D, Laplace2D) to run after the initial mesh is generated. + tolerance_initial_delaunay (float): Tolerance for the initial Delaunay + point insertion. Increase this (e.g. 1e-4, 1e-2) to handle + "Could not insert point" errors caused by near-degenerate geometry + after fragmentation. This is a meshing-phase tolerance — it does NOT + alter the CAD topology, so no surfaces or lines are lost. + Default is 1e-8 (Gmsh default). + heal_shapes (bool): If True, run OCC topology healing after + fragmentation. This can fix degenerate geometry that causes + meshing failures, but may also merge or delete small entities. + Use with caution on complex models — keep heal_tolerance small. + Default is False. + heal_tolerance (float): Size threshold for healShapes. Entities + smaller than this may be removed or merged. Default 1e-8. only works if heal_shapes=True. + heal_fix_degenerated (bool): Fix degenerated edges/faces. Default True. Only works if heal_shapes=True. + heal_fix_small_edges (bool): Remove edges smaller than tolerance. Default True. Only works if heal_shapes=True. + heal_fix_small_faces (bool): Remove faces smaller than tolerance. Default True. Only works if heal_shapes=True. + diagnose (bool): If True, retain structured diagnostic details from + geometry transfer, embedding, and meshing steps. """ self.background_lc = background_lc self.verbosity = verbosity + # The documented verbosity scale (0=silent, 1=basic, 2=debug) also + # drives the package logger so console output honors it. + set_verbosity(verbosity) self.mesh_algorithm = mesh_algorithm self.smoothing_steps = smoothing_steps self.optimization_cycles = optimization_cycles + self.tolerance_initial_delaunay = tolerance_initial_delaunay + self.heal_shapes = heal_shapes + self.heal_tolerance = heal_tolerance + self.heal_fix_degenerated = heal_fix_degenerated + self.heal_fix_small_edges = heal_fix_small_edges + self.heal_fix_small_faces = heal_fix_small_faces + self.diagnose = bool(diagnose) self.initialized = False self.nodes = None self.node_tags = None self.zones_gdf = None + self.triangular_quality = None + self.element_grid = None + self.diagnostics = {} + + def _sanitize_coords(self, coords, *, min_spacing=1e-5, require_closed=False, min_points=2): + """Remove invalid and near-duplicate coordinates before OCC creation.""" + clean_coords = [] + for pt in coords: + if len(pt) < 2: + continue + x = float(pt[0]) + y = float(pt[1]) + if not (math.isfinite(x) and math.isfinite(y)): + continue + if clean_coords: + dist = math.sqrt((x - clean_coords[-1][0])**2 + (y - clean_coords[-1][1])**2) + if dist <= min_spacing: + continue + clean_coords.append((x, y)) + + if require_closed and len(clean_coords) > 1: + dist = math.sqrt( + (clean_coords[0][0] - clean_coords[-1][0])**2 + + (clean_coords[0][1] - clean_coords[-1][1])**2 + ) + if dist <= min_spacing: + clean_coords.pop() + + if len(clean_coords) < min_points: + return [] + return clean_coords def _force_close_polygon(self, poly): """Ensure a polygon's exterior and interior rings are closed.""" @@ -61,20 +214,515 @@ def _force_close_polygon(self, poly): return Polygon(poly.exterior, new_interiors) def _initialize_gmsh(self): - if not gmsh.is_initialized(): - gmsh.initialize() - gmsh.option.setNumber("General.Verbosity", self.verbosity) - gmsh.option.setNumber("Geometry.Tolerance", 1e-6) - gmsh.option.setNumber("Geometry.OCCBooleanPreserveNumbering", 1) - gmsh.model.add("mesh_model") - self.initialized = True + # If Gmsh is already initialized (e.g. leftover from a previous failed + # run in the same Jupyter kernel), tear it down first so we start clean. + if gmsh.is_initialized(): + gmsh.finalize() + gmsh.initialize() + gmsh.option.setNumber("General.Verbosity", self.verbosity) + gmsh.option.setNumber("Geometry.Tolerance", 1e-6) + gmsh.option.setNumber("Geometry.OCCBooleanPreserveNumbering", 1) + gmsh.model.add("mesh_model") + self.initialized = True def _finalize_gmsh(self): if gmsh.is_initialized(): gmsh.finalize() self.initialized = False - def _add_geometry(self, polygons_gdf, lines_gdf, points_gdf): + @staticmethod + def _meshed_surface_tags(gmsh_map, clean_polys): + """Surface tags composing the meshed domain. + + Embedded polygon surfaces plus straddle and structured-buffer strips. + Field-only (embed=False) surfaces are excluded: gmsh meshes them as + standalone entities, but they are not part of the deliverable mesh and + must not pollute element/quality/node collection. + """ + def is_embedded_row(row): + val = row.get('embed', True) + return True if pd.isna(val) else bool(val) + + if clean_polys is not None and not clean_polys.empty: + if 'embed' in clean_polys.columns: + poly_ids = [int(i) for i, r in clean_polys.iterrows() if is_embedded_row(r)] + else: + poly_ids = [int(i) for i in clean_polys.index] + else: + poly_ids = [] + + tags, seen = [], set() + + def add_dimtags(dimtags): + for dimtag in dimtags: + if isinstance(dimtag, (tuple, list)) and len(dimtag) >= 2 and int(dimtag[0]) == 2: + tag = int(dimtag[1]) + if tag not in seen: + seen.add(tag) + tags.append(tag) + + for fid in poly_ids: + add_dimtags(gmsh_map.get('surfaces', {}).get(fid, [])) + for map_key in ('straddle_surfs', 'structured_buffer_surfs'): + for dimtags in gmsh_map.get(map_key, {}).values(): + add_dimtags(dimtags) + return tags + + @staticmethod + def _get_2d_elements(surface_tags=None): + """getElements(dim=2), optionally restricted to specific surfaces.""" + if not surface_tags: + return gmsh.model.mesh.getElements(dim=2) + by_type = {} + for tag in surface_tags: + try: + element_types, element_tags, element_nodes = gmsh.model.mesh.getElements(2, int(tag)) + except Exception: + continue + for etype, etags, enodes in zip(element_types, element_tags, element_nodes): + bucket = by_type.setdefault(int(etype), ([], [])) + bucket[0].append(np.asarray(etags, dtype=np.int64)) + bucket[1].append(np.asarray(enodes, dtype=np.int64)) + types = list(by_type.keys()) + tags = [np.concatenate(by_type[t][0]) for t in types] + nodes = [np.concatenate(by_type[t][1]) for t in types] + return types, tags, nodes + + def _collect_triangular_quality(self, surface_tags=None): + """Collect gmsh 2D element quality metrics while the model is live.""" + quality_columns = [ + "minSICN", + "minDetJac", + "maxDetJac", + "minSJ", + "minSIGE", + "gamma", + "innerRadius", + "outerRadius", + "minIsotropy", + "angleShape", + "minEdge", + "maxEdge", + ] + metadata_columns = ["element_tag", "element_type", "element_name", "is_triangle"] + element_types, element_tags, _ = self._get_2d_elements(surface_tags) + if len(element_tags) == 0: + return pd.DataFrame(columns=metadata_columns + quality_columns) + + frames = [] + for element_type, tags_for_type in zip(element_types, element_tags): + tags = np.asarray(tags_for_type, dtype=np.int64) + if len(tags) == 0: + continue + + element_name, _, _, _, _, _ = gmsh.model.mesh.getElementProperties(int(element_type)) + qualities = { + "element_tag": tags, + "element_type": int(element_type), + "element_name": element_name, + "is_triangle": "triangle" in element_name.lower(), + } + for measure in quality_columns: + qualities[measure] = gmsh.model.mesh.getElementQualities(tags, measure) + + frames.append(pd.DataFrame(qualities)) + + if not frames: + return pd.DataFrame(columns=metadata_columns + quality_columns) + + return pd.concat(frames, ignore_index=True)[metadata_columns + quality_columns] + + def get_triangular_quality(self): + """ + Return cached gmsh 2D element quality metrics for the generated mesh. + + The metrics are collected during ``generate()`` before gmsh is finalized, + so this method can be called after the normal mesh-generation lifecycle. + The report includes all 2D element types and marks triangle elements in + ``is_triangle`` so mixed tri/quad meshes are explicit. + """ + if self.triangular_quality is None: + raise RuntimeError( + "Triangular quality is not available. Call MeshGenerator.generate() first." + ) + return self.triangular_quality.copy() + + def _empty_element_grid(self, crs=None): + return gpd.GeoDataFrame( + columns=[ + "element_tag", + "element_type", + "element_name", + "is_triangle", + "is_quad", + "node_tags", + "centroid_x", + "centroid_y", + "zone_id", + "z_order", + "geometry", + ], + geometry="geometry", + crs=crs, + ) + + def _collect_element_grid(self, zones_gdf=None, surface_tags=None): + """Collect gmsh 2D element polygons while the model is live.""" + crs = getattr(zones_gdf, "crs", None) + element_types, element_tags, element_node_tags = self._get_2d_elements(surface_tags) + if len(element_tags) == 0: + warnings.warn("gmsh returned no 2D elements; element grid is empty.") + return self._empty_element_grid(crs) + + node_tags, node_coords, _ = gmsh.model.mesh.getNodes() + coords_3d = np.asarray(node_coords, dtype=float).reshape(-1, 3) + node_xy = { + int(tag): (float(coord[0]), float(coord[1])) + for tag, coord in zip(node_tags, coords_3d) + } + + records = [] + for element_type, tags_for_type, nodes_for_type in zip( + element_types, + element_tags, + element_node_tags, + ): + element_name, _, _, num_nodes, _, num_primary_nodes = gmsh.model.mesh.getElementProperties( + int(element_type) + ) + num_nodes = int(num_nodes) + num_primary_nodes = int(num_primary_nodes) if int(num_primary_nodes) > 0 else num_nodes + if num_nodes <= 0 or num_primary_nodes < 3: + continue + + tags = np.asarray(tags_for_type, dtype=np.int64) + flat_nodes = np.asarray(nodes_for_type, dtype=np.int64) + if len(tags) == 0 or len(flat_nodes) == 0: + continue + + connectivity = flat_nodes.reshape((len(tags), num_nodes)) + element_name_lower = element_name.lower() + is_triangle = "triangle" in element_name_lower + is_quad = "quadrangle" in element_name_lower or "quadrilateral" in element_name_lower + + for element_tag, element_nodes in zip(tags, connectivity): + primary_nodes = [int(tag) for tag in element_nodes[:num_primary_nodes]] + try: + coords = [node_xy[int(tag)] for tag in primary_nodes] + except KeyError: + continue + + polygon = Polygon(coords) + if polygon.is_empty or polygon.area <= 0: + continue + if not polygon.is_valid: + polygon = make_valid(polygon) + if polygon.geom_type != "Polygon" or polygon.is_empty or polygon.area <= 0: + continue + + centroid = polygon.centroid + records.append( + { + "element_tag": int(element_tag), + "element_type": int(element_type), + "element_name": element_name, + "is_triangle": bool(is_triangle), + "is_quad": bool(is_quad), + "node_tags": tuple(primary_nodes), + "centroid_x": float(centroid.x), + "centroid_y": float(centroid.y), + "geometry": polygon, + } + ) + + if not records: + warnings.warn("gmsh returned no usable 2D elements; element grid is empty.") + return self._empty_element_grid(crs) + + grid = gpd.GeoDataFrame(records, geometry="geometry", crs=crs) + grid = grid.sort_values("element_tag").reset_index(drop=True) + + return _assign_zones_to_elements(grid, zones_gdf) + + def get_element_grid(self, element_filter="all"): + """ + Return cached gmsh 2D element polygons for the generated mesh. + + ``element_filter`` may be ``"all"``, ``"triangles"``, or ``"quads"``. + The exporter is independent of the Voronoi tessellator and can represent + mixed tri/quad meshes produced by future structured-buffer workflows. + + Each element is assigned the zone whose polygon intersects the element + centroid. Ties (overlapping zones or centroids on shared borders) are + broken deterministically: highest ``z_order`` wins, then the zone that + appears earliest in the conceptual-mesh polygon table. + """ + if self.element_grid is None: + raise RuntimeError( + "Element grid is not available. Call MeshGenerator.generate() first." + ) + if element_filter not in {"all", "triangles", "quads"}: + raise ValueError("element_filter must be one of 'all', 'triangles', or 'quads'.") + + grid = self.element_grid + if element_filter == "triangles": + grid = grid[grid["is_triangle"]] + elif element_filter == "quads": + grid = grid[grid["is_quad"]] + return grid.copy() + + def _dedup_and_remap_fragment_map(self, out_map, object_tags, input_tag_info): + """Remove duplicate OCC entities and remap the fragment map. + + removeAllDuplicates() can merge coincident entities (changing + tags) without returning a mapping, so point coordinates are + snapshotted beforehand and out_map tags that disappear are + remapped to the surviving entity at the same location. + Mutates out_map in place. + """ + # Remove geometrically coincident (duplicate) entities left by + # fragmentation. Unlike healShapes this does NOT delete or merge + # entities based on a size tolerance, so it cannot destroy surfaces + # or convert interior lines into boundaries. + # + # Because removeAllDuplicates() can merge entities (changing tags) + # without returning a mapping, we snapshot the coordinates of all + # out_map entries beforehand and remap any that disappear. + _pre_dedup_coords = {} # (dim, tag) -> (x, y, z) for dim-0 entries + for i in range(len(out_map)): + for dt in out_map[i]: + d, t = int(dt[0]), int(dt[1]) + if d == 0 and (d, t) not in _pre_dedup_coords: + try: + bb = gmsh.model.occ.getBoundingBox(0, t) + _pre_dedup_coords[(d, t)] = (bb[0], bb[1], bb[2]) + except Exception: + logger.debug("Pre-dedup snapshot: no bounding box for " + "point %d; it cannot be remapped if " + "removeAllDuplicates renumbers it.", t) + + gmsh.model.occ.removeAllDuplicates() + + # Refresh out_map: replace tags killed by removeAllDuplicates with + # the surviving entity at the same location. + if len(out_map) > 0: + occ_alive = set() + _alive_pts_by_coord = {} # (round_x, round_y, round_z) -> tag + for dim in range(3): + for dt in gmsh.model.occ.getEntities(dim): + d, t = int(dt[0]), int(dt[1]) + occ_alive.add((d, t)) + if d == 0: + try: + bb = gmsh.model.occ.getBoundingBox(0, t) + # Round to ~nm precision to match coordinates + coord_key = (round(bb[0], 6), round(bb[1], 6), round(bb[2], 6)) + _alive_pts_by_coord[coord_key] = t + except Exception: + logger.debug("Post-dedup survey: no bounding box " + "for surviving point %d.", t) + + _dup_pruned = 0 + _dup_remapped = 0 + for i in range(len(out_map)): + new_entries = [] + for dt in out_map[i]: + d, t = int(dt[0]), int(dt[1]) + if (d, t) in occ_alive: + new_entries.append(dt) + elif d == 0 and (d, t) in _pre_dedup_coords: + # Tag was killed by dedup — find the surviving point + x, y, z = _pre_dedup_coords[(d, t)] + coord_key = (round(x, 6), round(y, 6), round(z, 6)) + new_tag = _alive_pts_by_coord.get(coord_key) + if new_tag is not None: + new_entries.append((0, new_tag)) + _dup_remapped += 1 + else: + _dup_pruned += 1 + else: + _dup_pruned += 1 + out_map[i] = new_entries + if _dup_pruned > 0 or _dup_remapped > 0: + logger.info(f"removeAllDuplicates: remapped {_dup_remapped}, pruned {_dup_pruned} tag(s) from fragment map.") + + # DIAG: Per-feature point tracking after dedup + if self.verbosity >= 2: + _pt_feat_status = [] + for i, input_dimtag in enumerate(object_tags): + key = _to_key(input_dimtag[0], input_dimtag[1]) + info = input_tag_info.get(key, {}) + if info.get('type') == 'point': + feat_id = info['id'] + dim0 = [dt for dt in (out_map[i] if i < len(out_map) else []) + if int(dt[0]) == 0] + alive = [(d, t) for d, t in dim0 if (int(d), int(t)) in occ_alive] + _pt_feat_status.append((feat_id, len(dim0), len(alive))) + _n_empty = sum(1 for _, n, a in _pt_feat_status if a == 0) + logger.debug(f"[DIAG] Post-dedup point features: {len(_pt_feat_status)} total, " + f"{_n_empty} with 0 alive tags") + if _n_empty > 0: + for fid, nd, na in _pt_feat_status: + if na == 0: + logger.debug(f" [DIAG] Point feat_id={fid}: {nd} map entries, 0 alive") + + def _heal_and_remap_fragment_map(self, out_map, object_tags, input_tag_info): + """Optionally heal OCC shapes, synchronize, and remap the map. + + healShapes rebuilds OCC topology - renumbering entities and even + reusing a tag number for a DIFFERENT entity - so remapping is + done purely by coordinate matching, never by tag identity. + Mutates out_map in place. Always synchronizes the OCC model, + even when heal_shapes is off. + """ + if self.heal_shapes: + # Snapshot coordinates of ALL out_map entities before heal so we + # can remap tags that healShapes renumbers. + _pre_heal_coords = {} # (dim, tag) -> (x, y, z) for dim-0 entries + for i in range(len(out_map)): + for dt in out_map[i]: + d, t = int(dt[0]), int(dt[1]) + if (d, t) not in _pre_heal_coords and d in (0, 1, 2): + try: + bb = gmsh.model.occ.getBoundingBox(d, t) + if d == 0: + _pre_heal_coords[(d, t)] = (bb[0], bb[1], bb[2]) + else: + _pre_heal_coords[(d, t)] = (bb[0], bb[1], bb[2], bb[3], bb[4], bb[5]) + except Exception: + logger.debug("Pre-heal snapshot: no bounding box " + "for entity (dim %d, tag %d); it " + "cannot be remapped if healShapes " + "renumbers it.", d, t) + + pre_heal = set() + for dim in range(3): + for dt in gmsh.model.occ.getEntities(dim): + pre_heal.add((int(dt[0]), int(dt[1]))) + + if self.heal_tolerance > 1e-2: + logger.info(f"WARNING: heal_tolerance={self.heal_tolerance} is large. " + f"This may destroy fragment boundaries and lose surfaces/lines. " + f"Consider values <= 1e-3.") + logger.info(f"Healing OCC shapes (tolerance={self.heal_tolerance}, " + f"degenerated={self.heal_fix_degenerated}, " + f"small_edges={self.heal_fix_small_edges}, " + f"small_faces={self.heal_fix_small_faces})...") + gmsh.model.occ.healShapes( + [], tolerance=self.heal_tolerance, + fixDegenerated=self.heal_fix_degenerated, + fixSmallEdges=self.heal_fix_small_edges, + fixSmallFaces=self.heal_fix_small_faces, + sewFaces=False, + makeSolids=False, + ) + + gmsh.model.occ.synchronize() + + # After healing, entity tags may have been renumbered (healShapes + # rebuilds OCC topology even when all fix flags are off). + # Remap out_map entries using coordinate matching, similar to dedup. + if self.heal_shapes and len(out_map) > 0: + surviving = set() + # Build coordinate lookup for surviving entities per dimension. + # healShapes introduces ~1e-6 coordinate drift, so we round to + # 4 decimal places (0.1 mm) — enough to distinguish any two + # intentionally distinct points while absorbing the drift. + _HEAL_ROUND = 4 + _heal_alive_by_dim = {0: {}, 1: {}, 2: {}} # dim -> coord_key -> tag + for dim in range(3): + for dt in gmsh.model.getEntities(dim): + d, t = int(dt[0]), int(dt[1]) + surviving.add((d, t)) + try: + bb = gmsh.model.getBoundingBox(d, t) + if d == 0: + coord_key = (round(bb[0], _HEAL_ROUND), round(bb[1], _HEAL_ROUND), round(bb[2], _HEAL_ROUND)) + else: + coord_key = (round(bb[0], _HEAL_ROUND), round(bb[1], _HEAL_ROUND), round(bb[2], _HEAL_ROUND), + round(bb[3], _HEAL_ROUND), round(bb[4], _HEAL_ROUND), round(bb[5], _HEAL_ROUND)) + _heal_alive_by_dim[d][coord_key] = t + except Exception: + logger.debug("Post-heal survey: no bounding box for " + "surviving entity (dim %d, tag %d).", d, t) + + # healShapes can reuse the same tag number for a DIFFERENT entity, + # so we must ALWAYS remap by coordinates — never trust tag identity. + _heal_remapped = 0 + _heal_pruned = 0 + _heal_kept = 0 + for i in range(len(out_map)): + new_entries = [] + for dt in out_map[i]: + d, t = int(dt[0]), int(dt[1]) + if (d, t) not in _pre_heal_coords: + # Entity wasn't snapshotted (shouldn't happen); keep if alive + if (d, t) in surviving: + new_entries.append(dt) + _heal_kept += 1 + else: + _heal_pruned += 1 + continue + + # Look up the old coordinates and find the matching new tag + old_coords = _pre_heal_coords[(d, t)] + if d == 0: + coord_key = (round(old_coords[0], _HEAL_ROUND), + round(old_coords[1], _HEAL_ROUND), + round(old_coords[2], _HEAL_ROUND)) + else: + coord_key = (round(old_coords[0], _HEAL_ROUND), round(old_coords[1], _HEAL_ROUND), + round(old_coords[2], _HEAL_ROUND), round(old_coords[3], _HEAL_ROUND), + round(old_coords[4], _HEAL_ROUND), round(old_coords[5], _HEAL_ROUND)) + new_tag = _heal_alive_by_dim.get(d, {}).get(coord_key) + if new_tag is not None: + if new_tag == t: + new_entries.append(dt) + _heal_kept += 1 + else: + new_entries.append((d, new_tag)) + _heal_remapped += 1 + else: + _heal_pruned += 1 + out_map[i] = new_entries + + if _heal_remapped > 0 or _heal_pruned > 0: + logger.info(f"Heal post-processing: remapped {_heal_remapped}, pruned {_heal_pruned} tag(s) from fragment map.") + + # DIAG: Per-feature point tracking after heal + if self.verbosity >= 2: + _pt_feat_heal = [] + for i, input_dimtag in enumerate(object_tags): + key = _to_key(input_dimtag[0], input_dimtag[1]) + info = input_tag_info.get(key, {}) + if info.get('type') == 'point': + feat_id = info['id'] + dim0 = [dt for dt in (out_map[i] if i < len(out_map) else []) + if int(dt[0]) == 0] + alive = [(d, t) for d, t in dim0 + if (int(d), int(t)) in surviving] + _pt_feat_heal.append((feat_id, len(dim0), len(alive))) + _n_empty_h = sum(1 for _, n, a in _pt_feat_heal if a == 0) + logger.debug(f"[DIAG] Post-heal point features: {len(_pt_feat_heal)} total, " + f"{_n_empty_h} with 0 alive tags (remapped {_heal_remapped}, pruned {_heal_pruned})") + if _n_empty_h > 0: + for fid, nd, na in _pt_feat_heal: + if na == 0: + logger.debug(f" [DIAG] Point feat_id={fid}: {nd} map entries, 0 alive after heal") + # Report what heal removed/added + heal_removed = pre_heal - surviving + heal_added = surviving - pre_heal + dim0_removed = [(d, t) for d, t in heal_removed if d == 0] + dim0_added = [(d, t) for d, t in heal_added if d == 0] + if dim0_removed or dim0_added: + logger.debug(f"[DIAG] Heal dim-0 changes: removed {len(dim0_removed)}, added {len(dim0_added)}") + if dim0_removed: + logger.debug(f" [DIAG] Removed point tags: {sorted(t for _, t in dim0_removed)}") + if dim0_added: + logger.debug(f" [DIAG] Added point tags: {sorted(t for _, t in dim0_added)}") + + + def _add_geometry(self, polygons_gdf, lines_gdf, points_gdf, launch_gmsh_gui=False): """ Transfers Shapely geometries from GeoDataFrames into the Gmsh model. @@ -83,63 +731,594 @@ def _add_geometry(self, polygons_gdf, lines_gdf, points_gdf): pre-processes barrier features before fragmenting all geometries to create a consistent topological model. """ - input_tag_info = {} + input_tag_info = {} + + # Refinement disks recorded where quad buffers cross (see + # record_quad_buffer_crossings); consumed in _setup_fields. + self._quad_buffer_crossings = [] + + # Non-embedded geometry does not participate in fragmentation. + # We still track it so mesh-size fields can be applied later. + nonembedded_point_tags = {} + nonembedded_line_tags = {} + nonembedded_surface_tags = {} + # For non-embedded polygons, we track their boundary curves so size + # fields can be applied without forcing the polygon to cut/fragment the domain. + nonembedded_poly_curve_tags = {} + pending_nonembedded_polys = [] + + # Embedded geometry DOES participate in fragmentation. + embedded_point_tags = [] + embedded_line_tags = [] + embedded_surface_tags = [] - def to_key(dim, tag): - return (int(dim), int(tag)) + to_key = _to_key + + def is_embedded(row) -> bool: + val = row.get('embed', True) + if pd.isna(val): + return True + return bool(val) + + def create_polygon_surface(poly): + """Create a Gmsh plane surface and return its tag plus boundary curves.""" + if poly.is_empty: + return None, [] + + poly = self._force_close_polygon(poly) + + def create_loop(coords): + clean_coords = self._sanitize_coords( + coords, + min_spacing=1e-5, + require_closed=True, + min_points=3, + ) + + if len(clean_coords) < 3: + return None, [] + + p_tags = [gmsh.model.occ.addPoint(x, y, 0) for x, y in clean_coords] + l_tags = [] + for i in range(len(p_tags)): + p1 = p_tags[i] + p2 = p_tags[(i + 1) % len(p_tags)] + try: + l_tags.append(gmsh.model.occ.addLine(p1, p2)) + except Exception as e: + logger.error(f"Error adding line {p1}-{p2}: {e}") + return None, [] + + try: + loop_tag = gmsh.model.occ.addCurveLoop(l_tags) + return loop_tag, l_tags + except Exception as e: + logger.error(f"Error adding curve loop: {e}") + return None, [] + + exterior_loop_tag, exterior_lines = create_loop(list(poly.exterior.coords)) + if exterior_loop_tag is None: + return None, [] + + loops = [exterior_loop_tag] + boundary_curve_tags = list(exterior_lines) + for interior in poly.interiors: + interior_loop_tag, interior_lines = create_loop(list(interior.coords)) + if interior_loop_tag is not None: + loops.append(interior_loop_tag) + boundary_curve_tags.extend(interior_lines) + + try: + s_tag = gmsh.model.occ.addPlaneSurface(loops) + except Exception as e: + logger.error(f"Error creating surface: {e}") + return None, [] + + return s_tag, boundary_curve_tags + + def row_bool(row, column, default=False): + val = row.get(column, default) + if pd.isna(val): + return bool(default) + return (val is True) or (str(val).lower() in ['true', '1', 'yes']) + + def positive_number(value): + if value is None or pd.isna(value): + return None + try: + value = float(value) + except (TypeError, ValueError): + return None + return value if value > 0 else None + + def feature_lc(row): + lc = positive_number(row.get('lc')) + if lc is None: + lc = positive_number(self.background_lc) + return max(lc if lc is not None else 10.0, 0.001) + + def quad_buffer_thickness(row): + value = row.get('quad_buffer_thickness', 1) + if value is None or pd.isna(value): + return 1 + value = int(value) + if value not in (1, 2): + raise ValueError("quad_buffer_thickness must be either 1 or 2.") + return value + + def polygon_parts(geom): + if geom.is_empty: + return [] + if isinstance(geom, Polygon): + return [geom] + if isinstance(geom, MultiPolygon): + return list(geom.geoms) + if hasattr(geom, "geoms"): + parts = [] + for part in geom.geoms: + parts.extend(polygon_parts(part)) + return parts + return [] + + def line_parts(geom): + if geom.is_empty: + return [] + if isinstance(geom, LineString): + return [geom] + if isinstance(geom, MultiLineString): + return [part for part in geom.geoms if part.length > 0] + if hasattr(geom, "geoms"): + parts = [] + for part in geom.geoms: + parts.extend(line_parts(part)) + return parts + return [] + + def coerce_offset_line(geom): + if isinstance(geom, LineString): + return geom + if isinstance(geom, MultiLineString): + merged = linemerge(geom) + if isinstance(merged, LineString): + return merged + lines = [part for part in merged.geoms if part.length > 0] if hasattr(merged, "geoms") else [] + return max(lines, key=lambda line: line.length) if lines else None + return None + + def domain_union_geometry(): + if polygons_gdf is None or polygons_gdf.empty: + return None + embedded = [] + for _, poly_row in polygons_gdf.iterrows(): + if is_embedded(poly_row): + embedded.append(poly_row.geometry) + if not embedded: + return None + return make_valid(unary_union(embedded)) + + domain_geom_for_buffers = domain_union_geometry() + + def add_structured_buffer_surface(buffer_geom, feature_id, input_type, + corners=None, side_lines=None): + """Create OCC surfaces for a buffer geometry; returns [(key, strip_info), ...].""" + created = [] + if domain_geom_for_buffers is not None and not domain_geom_for_buffers.is_empty: + buffer_geom = buffer_geom.intersection(domain_geom_for_buffers) + buffer_geom = make_valid(buffer_geom) + parts = [ + poly for poly in polygon_parts(buffer_geom) + if not poly.is_empty and poly.area > 0 + ] + if corners is not None and len(parts) != 1: + # The recorded whole-strip corners no longer apply; pieces are + # re-cornered individually from the side lines post-fragment. + corners = None + for poly in parts: + s_tag, boundary_curve_tags = create_polygon_surface(poly) + if s_tag is None: + continue + key = to_key(2, s_tag) + input_tag_info[key] = {'type': input_type, 'id': feature_id} + embedded_surface_tags.append(key) + created.append((key, {'corners': corners, 'side_lines': side_lines})) + return created + + # Strip footprints collected for ring-vertex protection (see + # push_ring_vertices_off_strips below). + line_strip_polygons = [] + + def plan_line_strip(row): + # Pure-geometry planning (no OCC, no trimming): build the untrimmed + # strip polygon(s) for a quad-buffered line so footprints exist for + # all features before any are trimmed. Returns a list of + # {'strip', 'corners', 'side_lines'} dicts, one per line part. + line = row.geometry + lc = feature_lc(row) + thickness = quad_buffer_thickness(row) + offset = thickness * lc / 2.0 + plans = [] + for part in line_parts(line): + if part.length <= 0: + continue + # gmshflow recipe: simplify then segmentize before offsetting so + # both offsets are symmetric and split into ~lc-long segments, + # which keeps the transfinite divisions equal on opposite sides + # of the strip. (Adds one OCC curve per ~lc of feature length.) + work = part.simplify(lc * 1.5) + work = work.segmentize(lc) + pos = coerce_offset_line( + work.offset_curve(offset, quad_segs=1, join_style=2, mitre_limit=5.0) + ) + neg = coerce_offset_line( + work.offset_curve(-offset, quad_segs=1, join_style=2, mitre_limit=5.0) + ) + if pos is None or neg is None: + warnings.warn( + f"Skipping structured buffer for line feature {row.name} after offset split." + ) + continue + # Clip the offset lines (not the strip polygon) to the domain so + # their endpoints remain the true strip corners. + if domain_geom_for_buffers is not None and not domain_geom_for_buffers.is_empty: + pos = coerce_offset_line(pos.intersection(domain_geom_for_buffers)) + neg = coerce_offset_line(neg.intersection(domain_geom_for_buffers)) + if pos is None or neg is None: + warnings.warn( + f"Skipping structured buffer for line feature {row.name} after domain clipping." + ) + continue + + pos_coords = self._sanitize_coords(list(pos.coords), min_points=2) + neg_coords = self._sanitize_coords(list(neg.coords), min_points=2) + if len(pos_coords) < 2 or len(neg_coords) < 2: + continue + + strip = Polygon(pos_coords + list(reversed(neg_coords))) + if not strip.is_valid: + strip = make_valid(strip) + # Corner order matches gmshflow's setTransfiniteSurface(..., "Left", ...). + corners = [ + tuple(neg_coords[0]), + tuple(neg_coords[-1]), + tuple(pos_coords[-1]), + tuple(pos_coords[0]), + ] + plans.append({'strip': strip, 'corners': corners, 'side_lines': (pos, neg)}) + return plans + + def plan_polygon_band(row): + # gmshflow parity (create_surfacegrid_from_buffer_poly): the band is + # the annulus between the +/- offsets of the simplified outline, and + # the zone interior is meshed from the inner offset, so the original + # boundary never becomes mesh edges. thickness=1 leaves no nodes on + # the outline (the Voronoi faces trace the shape); thickness=2 puts + # a node row on it (a row of ~square cells centered on the shape). + # Bands are annuli: no 4-corner transfinite structure is possible, + # so they are meshed quasi-structured (recombined quads with ~lc + # curve divisions). Pure geometry; returns the untrimmed band or None. + geom = row.geometry + lc = feature_lc(row) + thickness = quad_buffer_thickness(row) + offset = thickness * lc / 2.0 + # The band leaves little room to mesh, so simplify first. + work = make_valid(geom.simplify(lc * 1.5)) + inner = make_valid(work.buffer(-offset, quad_segs=1, join_style=2, mitre_limit=5.0)) + outer = make_valid(work.buffer(offset, quad_segs=1, join_style=2, mitre_limit=5.0)) + inner_parts = [ + p for p in polygon_parts(inner) if not p.is_empty and p.area > 0 + ] + if not inner_parts or outer.is_empty: + warnings.warn( + f"Polygon feature {row.name} is too narrow for a quad_buffer band of " + f"width {2.0 * offset:g}; meshing it without the structured buffer." + ) + return None + inner = inner_parts[0] if len(inner_parts) == 1 else MultiPolygon(inner_parts) + # Difference (rather than boundary.buffer) so the band's inner ring + # and the interior surface share exact coordinates and OCC merges + # them into a single curve. + return make_valid(outer.difference(inner)) + + def clean_trimmed_pieces(geom, lc, feature_label): + # After one-sided trimming, drop "sleeve" slivers (thin wedges from + # shallow-angle/tangential overlaps) that would force bad elements. + # Morphological opening (mitre joins keep rectangles square) removes + # whiskers; the area + erosion tests drop pieces thinner than ~0.8 + # cells. Dropped gaps are filled by unstructured elements. + kept = [] + dropped = 0 + for part in polygon_parts(make_valid(geom)): + if part.is_empty or part.area <= 0: + continue + opened = make_valid( + part.buffer(-0.25 * lc, join_style=2).buffer(0.25 * lc, join_style=2) + ) + candidates = polygon_parts(opened) if not opened.is_empty else [] + if not candidates: + dropped += 1 + continue + for sub in candidates: + sub = make_valid(sub.simplify(0.1 * lc)) + if sub.is_empty or sub.area < 0.5 * lc * lc: + dropped += 1 + continue + eroded = sub.buffer(-0.4 * lc) + if eroded.is_empty or getattr(eroded, 'area', 0.0) <= 0: + dropped += 1 + continue + kept.append(sub) + if dropped: + warnings.warn( + f"Structured buffer for {feature_label} dropped {dropped} sliver " + "piece(s) at a crossing (too thin to mesh); that gap is filled with " + "unstructured elements. Flip z_order or simplify the geometry to avoid it." + ) + return kept + + def create_line_structured_buffer(row): + key = ('line', int(row.name)) + plan = strip_plans.get(key) + if plan is None: + return [] + lc = plan['lc'] + obstacles = higher_priority_obstacles(key) + record_quad_buffer_crossings(key) + created = [] + feature_label = f"line feature {row.name}" + for part_plan in plan['parts']: + strip = part_plan['strip'] + corners = part_plan['corners'] + side_lines = part_plan['side_lines'] + if obstacles is not None and strip.intersects(obstacles): + warnings.warn( + f"Structured buffer for {feature_label} crosses a higher-priority " + "protected feature; it is trimmed at the crossing (set z_order to " + "choose which feature stays continuous)." + ) + pieces = clean_trimmed_pieces( + make_valid(strip.difference(obstacles)), lc, feature_label + ) + corners = None + if not pieces: + continue + strip = make_valid(unary_union(pieces) if len(pieces) > 1 else pieces[0]) + line_strip_polygons.append(strip) + created.extend( + add_structured_buffer_surface( + strip, key, 'structured_buffer_surf', + corners=corners, side_lines=side_lines, + ) + ) + return created + + def create_polygon_structured_buffer(row): + key = ('poly', int(row.name)) + plan = strip_plans.get(key) + if plan is None: + return [], None + lc = plan['lc'] + band = plan['band'] + obstacles = higher_priority_obstacles(key) + record_quad_buffer_crossings(key) + feature_label = f"polygon feature {row.name}" + if obstacles is not None and band.intersects(obstacles): + warnings.warn( + f"Structured buffer for {feature_label} crosses a higher-priority " + "protected feature; it is trimmed at the crossing (set z_order to " + "choose which feature stays continuous)." + ) + pieces = clean_trimmed_pieces( + make_valid(band.difference(obstacles)), lc, feature_label + ) + if not pieces: + return [], None + band = make_valid(unary_union(pieces) if len(pieces) > 1 else pieces[0]) + created = add_structured_buffer_surface( + band, key, 'structured_buffer_surf' + ) + if not created: + return [], None + return created, band + + structured_buffer_specs = {} # Add all point features to the Gmsh model first. - all_point_tags = [] for idx, row in points_gdf.iterrows(): tag = gmsh.model.occ.addPoint(row.geometry.x, row.geometry.y, 0) key = to_key(0, tag) - input_tag_info[key] = {'type': 'point', 'id': idx} - all_point_tags.append(key) + if is_embedded(row): + input_tag_info[key] = {'type': 'point', 'id': idx} + embedded_point_tags.append(key) + else: + nonembedded_point_tags.setdefault(int(idx), []).append(key) - # Create a buffer zone around barrier lines. This is used to trim back - # other lines, preventing their endpoints from interfering with the - # meshing of the barrier features. - barrier_buffers = [] + # Build a protection corridor around each barrier/straddle/quad-buffer + # feature. Their union (the "barrier zone") trims standard lines away + # from these sensitive regions. Quad-buffer strips that cross each other + # are resolved by priority (see strip_plans / higher_priority_obstacles + # below): the winner stays continuous and only the loser is trimmed. + def feature_protection_epsilon(row): + lc = feature_lc(row) + if row_bool(row, 'quad_buffer', False): + return quad_buffer_thickness(row) * lc / 2.0 + straddle = positive_number(row.get('straddle_width')) + if straddle: + return straddle / 2.0 + return lc * 0.20 + + def corridor_geometry(basis, eps, min_half_width=0.0): + # The corridor is made slightly larger than the feature's half-width + # to ensure a clean separation between standard lines and the + # sensitive node pairs used for straddle barriers. + return basis.buffer(max(eps * 1.20, min_half_width), cap_style=2) + + corridors_by_feature = {} for idx, row in lines_gdf.iterrows(): - val = row.get('is_barrier', False) - is_barrier = (val is True) or (str(val).lower() in ['true', '1', 'yes']) - straddle = row.get('straddle_width') - - if is_barrier: - lc = max(row.get('lc', 10.0), 0.001) - if straddle and straddle > 0: - eps = straddle / 2.0 - else: - eps = lc * 0.20 - - # The trim buffer is made slightly larger than the feature's half-width - # to ensure a clean separation between standard lines and the - # sensitive node pairs used for straddle barriers. - trim_eps = eps * 1.20 - - buf = row.geometry.buffer(trim_eps, cap_style=2) - barrier_buffers.append(buf) - + if ( + row_bool(row, 'is_barrier', False) + or row_bool(row, 'quad_buffer', False) + or positive_number(row.get('straddle_width')) + ): + corridors_by_feature[('line', int(idx))] = ( + row.geometry, feature_protection_epsilon(row) + ) + if not polygons_gdf.empty: + for idx, row in polygons_gdf.iterrows(): + if row_bool(row, 'quad_buffer', False) and is_embedded(row): + corridors_by_feature[('poly', int(idx))] = ( + row.geometry.boundary, feature_protection_epsilon(row) + ) + barrier_zone = None - if barrier_buffers: - barrier_zone = unary_union(barrier_buffers) - barrier_zone = make_valid(barrier_zone) + if corridors_by_feature: + barrier_zone = make_valid(unary_union([ + corridor_geometry(basis, eps) + for basis, eps in corridors_by_feature.values() + ])) if self.verbosity > 0: - print(f"Constructed Barrier Zone from {len(barrier_buffers)} barriers.") + logger.info(f"Constructed Barrier Zone from {len(corridors_by_feature)} protected features.") + + # --- Quad-buffer crossing priority ------------------------------- + # Plan every quad-buffer footprint up front (pure geometry, no OCC) so + # that when two cross, one stays continuous and only the lower-priority + # one is trimmed -- against the winner's actual footprint plus a half- + # cell gap, instead of both yielding to an inflated corridor (which left + # a hole filled by coarse background triangles). Priority key (lower + # wins): user z_order, then finer lc, then wider strip, then line over + # polygon, then insertion order. + def feature_z_order(row): + val = row.get('z_order', 0) + if val is None or pd.isna(val): + return 0.0 + try: + return float(val) + except (TypeError, ValueError): + return 0.0 + + strip_plans = {} + _feat_counter = 0 + for idx, row in lines_gdf.iterrows(): + if not row_bool(row, 'quad_buffer', False): + continue + parts = plan_line_strip(row) + if not parts: + continue + lc = feature_lc(row) + thickness = quad_buffer_thickness(row) + strip_plans[('line', int(idx))] = { + 'kind': 'line', + 'parts': parts, + 'footprint': make_valid(unary_union([p['strip'] for p in parts])), + 'lc': lc, + 'thickness': thickness, + 'width': thickness * lc, + 'priority_key': (-feature_z_order(row), lc, -(thickness * lc), 0, _feat_counter), + } + _feat_counter += 1 + if not polygons_gdf.empty: + for idx, row in polygons_gdf.iterrows(): + if not (is_embedded(row) and row_bool(row, 'quad_buffer', False)): + continue + band = plan_polygon_band(row) + if band is None or band.is_empty: + continue + lc = feature_lc(row) + thickness = quad_buffer_thickness(row) + strip_plans[('poly', int(idx))] = { + 'kind': 'poly', + 'band': band, + 'footprint': make_valid(band), + 'lc': lc, + 'thickness': thickness, + 'width': thickness * lc, + 'priority_key': (-feature_z_order(row), lc, -(thickness * lc), 1, _feat_counter), + } + _feat_counter += 1 + + def higher_priority_obstacles(self_key): + # Union of geometry a quad buffer must keep clear of: the footprints + # of strictly higher-priority quad buffers (buffered by a half-cell + # so the loser's quads butt up against the winner's structured row), + # plus the corridors of non-quad protected features (barrier/straddle + # lines, which still trim mutually). + self_plan = strip_plans.get(self_key) + if self_plan is None: + return None + self_pkey = self_plan['priority_key'] + lc_self = self_plan['lc'] + geoms = [] + for key, plan in strip_plans.items(): + if key == self_key: + continue + if plan['priority_key'] < self_pkey: + geoms.append( + plan['footprint'].buffer( + QUAD_BUFFER_CROSSING_GAP * lc_self, cap_style=2 + ) + ) + for key, (basis, eps) in corridors_by_feature.items(): + if key in strip_plans or key == self_key: + continue + geoms.append(corridor_geometry(basis, eps, min_half_width=0.6 * lc_self)) + if not geoms: + return None + return make_valid(unary_union(geoms)) + + def record_quad_buffer_crossings(self_key): + # From the loser's side, record a refinement disk over each crossing + # region so the gap fill is pinned to min(lc) rather than jumping to + # the background size next to the dense strip rows. + self_plan = strip_plans.get(self_key) + if self_plan is None: + return + self_fp = self_plan['footprint'] + self_pkey = self_plan['priority_key'] + lc_self = self_plan['lc'] + w_self = self_plan['width'] + for key, plan in strip_plans.items(): + if key == self_key or not (plan['priority_key'] < self_pkey): + continue + inter = make_valid(self_fp.intersection(plan['footprint'])) + for part in polygon_parts(inter): + if part.is_empty or part.area <= 0: + continue + minx, miny, maxx, maxy = part.bounds + part_radius = 0.5 * math.hypot(maxx - minx, maxy - miny) + size = min(lc_self, plan['lc']) + radius = part_radius + 0.5 * (w_self + plan['width']) + size + self._quad_buffer_crossings.append({ + 'x': part.centroid.x, + 'y': part.centroid.y, + 'size': size, + 'radius': radius, + }) # Add line features to the model, handling barriers and standard lines differently. - all_line_tags = [] - all_surface_tags = [] - for idx, row in lines_gdf.iterrows(): - val = row.get('is_barrier', False) - is_barrier = (val is True) or (str(val).lower() in ['true', '1', 'yes']) - straddle = row.get('straddle_width') - lc = max(row.get('lc', 10.0), 0.001) + is_barrier = row_bool(row, 'is_barrier', False) + quad_buffer = row_bool(row, 'quad_buffer', False) + straddle = positive_number(row.get('straddle_width')) + lc = feature_lc(row) - use_virtual_straddle = is_barrier or (straddle is not None and straddle > 0) + use_structured_buffer = quad_buffer + use_virtual_straddle = not use_structured_buffer and (is_barrier or straddle is not None) + + embedded = is_embedded(row) - if use_virtual_straddle: + if use_structured_buffer: + created = create_line_structured_buffer(row) + if created: + structured_buffer_specs[('line', int(idx))] = { + 'lc': lc, + 'thickness': quad_buffer_thickness(row), + 'kind': 'line', + 'strips': [info for _, info in created], + 'n_surfaces_created': len(created), + } + elif self.verbosity > 0: + logger.warning(f"Warning: Structured buffer requested for line {idx}, but no buffer surface was created.") + + elif use_virtual_straddle: # For barriers or "straddle" lines, we don't add the line itself. # Instead, we place pairs of points along the line's path. These # points will become nodes in the triangular mesh, forcing the @@ -149,38 +1328,38 @@ def to_key(dim, tag): num_segments = int(max(1, np.ceil(length / lc))) distances = np.linspace(0, length, num_segments + 1) - if straddle and straddle > 0: + if straddle: epsilon = straddle / 2.0 else: epsilon = lc * 0.20 + # Tangent probe proportional to line length so the offsets + # work for any CRS units and for lines shorter than the old + # fixed 0.01 step. + probe = max(length * 1e-4, 1e-12) for d in distances: p = line.interpolate(d) - t_val = d - p_near = line.interpolate(min(t_val + 0.01, length)) - if t_val >= length - 0.001: - p_near = line.interpolate(max(t_val - 0.01, 0)) - dx, dy = p.x - p_near.x, p.y - p_near.y - else: - dx, dy = p_near.x - p.x, p_near.y - p.y - - mag = np.sqrt(dx*dx + dy*dy) - if mag == 0: mag = 1 - dx, dy = dx/mag, dy/mag + dx, dy = _unit_tangent(line, d, probe) nx, ny = -dy, dx # Create two points, offset from the original line by the normal. lx, ly = p.x + nx*epsilon, p.y + ny*epsilon lt = gmsh.model.occ.addPoint(lx, ly, 0) k_l = to_key(0, lt) - input_tag_info[k_l] = {'type': 'point', 'id': idx} - all_point_tags.append(k_l) + if embedded:#TODO probably this always true for barriers + input_tag_info[k_l] = {'type': 'point', 'id': idx} + embedded_point_tags.append(k_l) + else: + nonembedded_point_tags.setdefault(int(idx), []).append(k_l) rx, ry = p.x - nx*epsilon, p.y - ny*epsilon rt = gmsh.model.occ.addPoint(rx, ry, 0) k_r = to_key(0, rt) - input_tag_info[k_r] = {'type': 'point', 'id': idx} - all_point_tags.append(k_r) + if embedded: + input_tag_info[k_r] = {'type': 'point', 'id': idx} + embedded_point_tags.append(k_r) + else: + nonembedded_point_tags.setdefault(int(idx), []).append(k_r) else: # This is a standard line feature that will act as a constraint @@ -195,10 +1374,10 @@ def to_key(dim, tag): geom = geom.difference(barrier_zone) if self.verbosity > 1: - print(f" Line {idx} trimmed by barrier (Len: {original_len:.2f} -> {geom.length:.2f})") + logger.info(f" Line {idx} trimmed by barrier (Len: {original_len:.2f} -> {geom.length:.2f})") except Exception as e: - print(f"Warning: Failed to trim line {idx}: {e}") + logger.warning(f"Warning: Failed to trim line {idx}: {e}") if geom.is_empty: continue @@ -213,124 +1392,272 @@ def to_key(dim, tag): for part in parts: # Filter out tiny fragments that might remain after trimming. - if part.length < 1e-6: continue - - coords = list(part.coords) - if len(coords) < 2: continue - + if part.length < 1e-6: + continue + + coords = self._sanitize_coords(list(part.coords), min_points=2) + if len(coords) < 2: + if self.verbosity > 0: + logger.warning(f"Warning: Skipping degenerate line part for feature {idx} after coordinate cleanup.") + continue + # Add each segment of the line to Gmsh. pt_tags = [gmsh.model.occ.addPoint(x, y, 0) for x, y in coords] + created_segments = 0 for i in range(len(pt_tags) - 1): - l = gmsh.model.occ.addLine(pt_tags[i], pt_tags[i+1]) - - key = to_key(1, l) - all_line_tags.append(key) - input_tag_info[key] = {'type': 'line', 'id': idx} + try: + line_tag = gmsh.model.occ.addLine(pt_tags[i], pt_tags[i+1]) + except Exception as e: + logger.warning( + f"Warning: Skipping invalid line segment {i} for feature {idx} " + f"between {coords[i]} and {coords[i+1]}: {e}" + ) + continue + + key = to_key(1, line_tag) + created_segments += 1 + if embedded: + embedded_line_tags.append(key) + input_tag_info[key] = {'type': 'line', 'id': idx} + else: + nonembedded_line_tags.setdefault(int(idx), []).append(key) + + if created_segments == 0 and self.verbosity > 0: + logger.warning(f"Warning: No valid line segments were created for feature {idx}.") + + def push_ring_vertices_off_strips(poly): + """Move polygon ring vertices out of structured strip interiors. + + A ring vertex strictly inside a strip (e.g. a densified midpoint + landing on the buffered feature line) subdivides the strip's end + caps during fragmentation and injects a node into the protected + corridor, breaking the transfinite structure. Project such + vertices onto the strip boundary instead — a move of at most half + the strip width, collinear when the ring crosses the strip + straight. + """ + if not line_strip_polygons: + return poly + moved = 0 + + def adjust(coords): + nonlocal moved + out = [] + for x, y in coords: + point = Point(x, y) + for strip in line_strip_polygons: + if strip.contains(point): + boundary = strip.boundary + point = boundary.interpolate(boundary.project(point)) + moved += 1 + break + out.append((point.x, point.y)) + return out + + exterior = adjust(list(poly.exterior.coords)) + interiors = [adjust(list(ring.coords)) for ring in poly.interiors] + if not moved: + return poly + adjusted = Polygon(exterior, interiors) + if not adjusted.is_valid: + adjusted = make_valid(adjusted) + if adjusted.geom_type != 'Polygon' or adjusted.is_empty: + return poly + if self.verbosity > 0: + logger.info(f"Moved {moved} zone-ring vertex(es) off structured buffer strips.") + return adjusted # Add polygon features to the model. if not polygons_gdf.empty: - print(f"Adding {len(polygons_gdf)} polygons to Gmsh...") + logger.info(f"Adding {len(polygons_gdf)} polygons to Gmsh...") + # First pass: create the quad-buffer band surfaces and collect their + # footprints. The band hugs the full feature boundary, so it is + # created once per feature rather than once per MultiPolygon part. + polygon_band_geoms = [] + for idx, row in polygons_gdf.iterrows(): + if not (is_embedded(row) and row_bool(row, 'quad_buffer', False)): + continue + created, band_geom = create_polygon_structured_buffer(row) + if created: + structured_buffer_specs[('poly', int(idx))] = { + 'lc': feature_lc(row), + 'thickness': quad_buffer_thickness(row), + 'kind': 'polygon', + 'strips': [], + 'n_surfaces_created': len(created), + } + polygon_band_geoms.append(band_geom) + elif self.verbosity > 0: + logger.warning(f"Warning: Structured buffer requested for polygon {idx}, but no buffer surface was created.") + buffer_footprints = polygon_band_geoms + line_strip_polygons + buffer_footprints_union = ( + make_valid(unary_union(buffer_footprints)) if buffer_footprints else None + ) + for idx, row in polygons_gdf.iterrows(): + embedded = is_embedded(row) geom = row['geometry'] - if geom.geom_type == 'Polygon': - polys = [geom] - elif geom.geom_type == 'MultiPolygon': - polys = geom.geoms - else: + if geom.geom_type not in ('Polygon', 'MultiPolygon'): continue - + # Mesh every embedded polygon minus the band/strip footprints, + # so the buffer surfaces tile the plane with their neighbours + # exactly (shared curves merged by removeAllDuplicates) instead + # of relying on OCC fragment to cut overlapping faces — which + # silently refuses in some trimmed-crossing configurations and + # leaves double-meshed regions. It also keeps a buffered zone's + # outline out of the mesh entirely: overlap resolution makes + # neighbours share that outline (e.g. the domain piece has a + # hole there), so subtracting only from the buffered zone itself + # would still pin mesh nodes onto it. Zone assignment uses the + # original polygons, so zone extents are unchanged. + if ( + embedded + and buffer_footprints_union is not None + and geom.intersects(buffer_footprints_union) + ): + geom = make_valid(geom.difference(buffer_footprints_union)) + polys = polygon_parts(geom) + for poly in polys: if poly.is_empty: continue - - # Ensure the polygon is valid and closed before processing. - poly = self._force_close_polygon(poly) - - def create_loop(coords): - # Remove consecutive duplicates and points that are too close - clean_coords = [] - for pt in coords: - if not clean_coords: - clean_coords.append(pt) - continue - - # Check distance to last point - dist = math.sqrt((pt[0]-clean_coords[-1][0])**2 + (pt[1]-clean_coords[-1][1])**2) - if dist > 1e-5: # Slightly larger than Gmsh tolerance to be safe - clean_coords.append(pt) - - # Check closure with first point - if len(clean_coords) > 1: - dist = math.sqrt((clean_coords[0][0]-clean_coords[-1][0])**2 + (clean_coords[0][1]-clean_coords[-1][1])**2) - if dist < 1e-5: - clean_coords.pop() - - if len(clean_coords) < 3: - # A polygon must have at least 3 points (triangle) - return None - - p_tags = [gmsh.model.occ.addPoint(x, y, 0) for x, y in clean_coords] - l_tags = [] - for i in range(len(p_tags)): - p1 = p_tags[i] - p2 = p_tags[(i + 1) % len(p_tags)] - try: - l_tags.append(gmsh.model.occ.addLine(p1, p2)) - except Exception as e: - print(f"Error adding line {p1}-{p2}: {e}") - return None - - try: - return gmsh.model.occ.addCurveLoop(l_tags) - except Exception as e: - print(f"Error adding curve loop: {e}") - return None - # 1. Exterior Boundary - ext_coords = list(poly.exterior.coords) - exterior_loop_tag = create_loop(ext_coords) - - if exterior_loop_tag is None: - print(f"Warning: Skipping degenerate polygon {idx}") + if not embedded: + # Defer field-only polygon creation until after + # fragmentation/dedup/healing. If these overlapping + # surfaces exist during global OCC cleanup they can cut + # or renumber embedded domain surfaces, which violates + # embed=False semantics. + pending_nonembedded_polys.append((int(idx), poly)) continue - # 2. Interior Boundaries (Holes) - loops = [exterior_loop_tag] - for interior in poly.interiors: - int_coords = list(interior.coords) - interior_loop_tag = create_loop(int_coords) - if interior_loop_tag is not None: - loops.append(interior_loop_tag) - - # Create plane surface with holes - try: - s_tag = gmsh.model.occ.addPlaneSurface(loops) - except Exception as e: - print(f"Error creating surface for polygon {idx}: {e}") + poly = push_ring_vertices_off_strips(poly) + s_tag, boundary_curve_tags = create_polygon_surface(poly) + if s_tag is None: + logger.warning(f"Warning: Skipping degenerate polygon {idx}") continue - + key = to_key(2, s_tag) input_tag_info[key] = {'type': 'surface', 'id': idx} - all_surface_tags.append(key) + embedded_surface_tags.append(key) + #call the gui before fragmentation for debugging + if self.verbosity > 1 and launch_gmsh_gui: + gmsh.model.occ.synchronize() + gmsh.fltk.run() + + # >>> DIAG: Pre-fragment inventory (summary) + if self.verbosity >= 2: + _line_feats = sorted(set( + input_tag_info.get(to_key(dt[0], dt[1]), {}).get('id', '?') + for dt in embedded_line_tags + )) if embedded_line_tags else [] + logger.debug(f"\n[DIAG] Pre-fragment: {len(embedded_surface_tags)} surfs, " + f"{len(embedded_line_tags)} lines, {len(embedded_point_tags)} pts " + f"| line features: {_line_feats}") + # <<< DIAG # "Fragment" combines all the individual geometries into a single, # topologically consistent model. This is where intersections are # calculated and new, smaller entities are created at overlaps. - object_tags = all_surface_tags + all_line_tags + all_point_tags + # Only embedded geometry participates in fragmentation. + object_tags = embedded_surface_tags + embedded_line_tags + embedded_point_tags if not object_tags: - print("Warning: No geometry to mesh.") - return {'points': {}, 'lines': {}, 'surfaces': {}, 'straddle_surfs': {}} + logger.warning("Warning: No geometry to mesh.") + return { + 'points': nonembedded_point_tags, + 'lines': nonembedded_line_tags, + 'surfaces': nonembedded_surface_tags, + 'straddle_surfs': {}, + 'structured_buffer_surfs': {}, + 'poly_curves': nonembedded_poly_curve_tags, + } - print(f"Fragmenting {len(object_tags)} objects...") + logger.info(f"Fragmenting {len(object_tags)} objects...") out_dt, out_map = gmsh.model.occ.fragment(object_tags, []) - gmsh.model.occ.synchronize() + + self._dedup_and_remap_fragment_map(out_map, object_tags, input_tag_info) + + self._heal_and_remap_fragment_map(out_map, object_tags, input_tag_info) + + # >>> DIAG: Post-fragment summary + if self.verbosity >= 2: + all_surfs_post = gmsh.model.getEntities(2) + all_lines_post = gmsh.model.getEntities(1) + all_pts_post = gmsh.model.getEntities(0) + + # Classify line fragments: boundary vs interior vs orphan + _n_boundary, _n_interior, _n_orphan, _n_dim0 = 0, 0, 0, 0 + _boundary_feats = set() # feature names whose lines became boundaries + for i, input_dimtag in enumerate(object_tags): + key = to_key(input_dimtag[0], input_dimtag[1]) + info = input_tag_info.get(key, {}) + if info.get('type') != 'line': + continue + res = out_map[i] if i < len(out_map) else [input_dimtag] + for dt in res: + dim_r, tag_r = int(dt[0]), int(dt[1]) + if dim_r == 0: + _n_dim0 += 1 + continue + try: + gmsh.model.getBoundingBox(dim_r, tag_r) + up, _ = gmsh.model.getAdjacencies(1, tag_r) + if len(up) > 0: + _n_boundary += 1 + _boundary_feats.add(info.get('id', '?')) + else: + _n_interior += 1 + except Exception: + _n_orphan += 1 + + # Count auto-embeddings + _n_auto = 0 + for s in all_surfs_post: + try: + if gmsh.model.mesh.getEmbedded(2, s[1]): + _n_auto += 1 + except Exception: + logger.debug("getEmbedded failed for surface %d during " + "post-fragment diagnostics.", s[1]) + + logger.debug(f"[DIAG] Post-fragment: {len(all_surfs_post)} surfs, " + f"{len(all_lines_post)} lines, {len(all_pts_post)} pts") + logger.debug(f"[DIAG] Line fragments: {_n_interior} interior, " + f"{_n_boundary} BOUNDARY, {_n_orphan} orphan, " + f"{_n_dim0} became-points | auto-embed surfs: {_n_auto}") + if _boundary_feats: + logger.debug(f"[DIAG] *** Lines from these features became BOUNDARIES: " + f"{sorted(_boundary_feats)} ***") + # <<< DIAG + + if pending_nonembedded_polys: + if self.verbosity > 0: + logger.info(f"Adding {len(pending_nonembedded_polys)} field-only polygon surface(s)...") + for idx, poly in pending_nonembedded_polys: + s_tag, boundary_curve_tags = create_polygon_surface(poly) + if s_tag is None: + if self.verbosity > 0: + logger.warning(f"Warning: Skipping degenerate field-only polygon {idx}") + continue + nonembedded_surface_tags.setdefault(int(idx), []).append(to_key(2, s_tag)) + nonembedded_poly_curve_tags.setdefault(int(idx), []).extend( + [(1, int(t)) for t in boundary_curve_tags] + ) + gmsh.model.occ.synchronize() # After fragmentation, we need to rebuild our map of which original # feature corresponds to which new Gmsh tags. - final_map = {'points': {}, 'lines': {}, 'surfaces': {}, 'straddle_surfs': {}} + final_map = { + 'points': dict(nonembedded_point_tags), + 'lines': dict(nonembedded_line_tags), + 'surfaces': dict(nonembedded_surface_tags), + 'straddle_surfs': {}, + 'structured_buffer_surfs': {}, + 'poly_curves': dict(nonembedded_poly_curve_tags), + } - print(f"Reconstructing Map (Input Tags: {len(object_tags)}, Out Map Len: {len(out_map)})...") + logger.info(f"Reconstructing Map (Input Tags: {len(object_tags)}, Out Map Len: {len(out_map)})...") for i, input_dimtag in enumerate(object_tags): if i < len(out_map): @@ -344,7 +1671,9 @@ def create_loop(coords): if key in input_tag_info: info = input_tag_info[key] kind = info['type'] - feat_id = int(info['id']) + # Structured-buffer ids are ('line'|'poly', idx) tuples so line + # and polygon features with the same index cannot collide. + feat_id = info['id'] if isinstance(info['id'], tuple) else int(info['id']) if kind == 'point': if feat_id not in final_map['points']: @@ -365,10 +1694,460 @@ def create_loop(coords): if feat_id not in final_map['straddle_surfs']: final_map['straddle_surfs'][feat_id] = [] final_map['straddle_surfs'][feat_id].extend(res_tags) + + elif kind == 'structured_buffer_surf': + if feat_id not in final_map['structured_buffer_surfs']: + final_map['structured_buffer_surfs'][feat_id] = [] + final_map['structured_buffer_surfs'][feat_id].extend(res_tags) else: - print(f"Warning: Tag {key} lost during fragmentation mapping.") + logger.warning(f"Warning: Tag {key} lost during fragmentation mapping.") + + # DIAG: Final map point summary + if self.verbosity >= 2: + _n_pt_feats = len(final_map.get('points', {})) + _empty_feats = [] + _stale_feats = [] + model_ents = set() + for dim in range(3): + for dt in gmsh.model.getEntities(dim): + model_ents.add((int(dt[0]), int(dt[1]))) + for fid, dimtags in final_map.get('points', {}).items(): + dim0 = [dt for dt in dimtags if isinstance(dt, (tuple, list)) and int(dt[0]) == 0] + if not dim0: + _empty_feats.append(fid) + else: + for dt in dim0: + if (int(dt[0]), int(dt[1])) not in model_ents: + _stale_feats.append((fid, int(dt[1]))) + logger.debug(f"[DIAG] Final map: {_n_pt_feats} point features, " + f"{len(_empty_feats)} empty, {len(_stale_feats)} with stale tags") + if _empty_feats: + logger.debug(f" [DIAG] Empty point feat_ids: {sorted(_empty_feats)}") + if _stale_feats: + logger.debug(f" [DIAG] Stale point (feat_id, tag): {_stale_feats}") + + # Safety net: OCC's fragment map can omit pieces of an input surface + # (observed when a buffer strip with boundaries coincident to the + # densified domain edge splits the domain). An unclaimed 2D entity + # would silently lose its mesh nodes and field sizing downstream, so + # re-attach each orphan to the embedded polygon feature containing it. + claimed_surfaces = set() + for map_key in ('surfaces', 'straddle_surfs', 'structured_buffer_surfs'): + for dimtags in final_map.get(map_key, {}).values(): + for dt in dimtags: + if isinstance(dt, (tuple, list)) and len(dt) >= 2 and int(dt[0]) == 2: + claimed_surfaces.add(int(dt[1])) + orphan_surfaces = [ + int(tag) for dim, tag in gmsh.model.getEntities(2) + if int(tag) not in claimed_surfaces + ] + if orphan_surfaces and polygons_gdf is not None and not polygons_gdf.empty: + embedded_polys = [ + (int(idx), row.geometry) + for idx, row in polygons_gdf.iterrows() + if is_embedded(row) + ] + recovered = 0 + for surf_tag in orphan_surfaces: + try: + cx, cy, _ = gmsh.model.occ.getCenterOfMass(2, surf_tag) + except Exception: + continue + center = Point(cx, cy) + owner = None + for fid, geom in embedded_polys: + if geom.covers(center): + owner = fid + break + if owner is None and embedded_polys: + owner = min(embedded_polys, key=lambda item: item[1].distance(center))[0] + if owner is not None: + final_map['surfaces'].setdefault(owner, []).append((2, surf_tag)) + recovered += 1 + if recovered: + logger.info( + f"Recovered {recovered} orphan surface(s) the fragment map had " + "dropped; re-attached to their containing polygon features." + ) + + self._apply_structured_buffer_meshing(final_map, structured_buffer_specs) return final_map + + @staticmethod + def _entity_length(dim, tag): + try: + return float(gmsh.model.occ.getMass(int(dim), int(tag))) + except Exception: + try: + return float(gmsh.model.getMass(int(dim), int(tag))) + except Exception: + return None + + @staticmethod + def _surface_boundary_point_coords(surf_tag): + """Map of point tag -> (x, y) for a surface's boundary points.""" + try: + boundary_points = gmsh.model.getBoundary( + [(2, int(surf_tag))], oriented=False, recursive=True + ) + except Exception: + return {} + candidates = {} + for dim, tag in boundary_points: + if int(dim) != 0: + continue + try: + xyz = gmsh.model.getValue(0, int(tag), []) + except Exception: + continue + candidates[int(tag)] = (float(xyz[0]), float(xyz[1])) + return candidates + + def _derive_strip_corners_on_surface(self, surf_tag, side_lines, tol): + """Derive the 4 corner point tags of a strip *piece* from its side lines. + + When fragmentation splits a strip (e.g. an embedded zone boundary + crosses it), each piece is still a 4-sided strip whose corners are the + extreme boundary points lying on the original positive/negative offset + curves. Returns corner tags in "Left" order, or None. + """ + if not side_lines: + return None + pos, neg = side_lines + if pos is None or neg is None: + return None + candidates = self._surface_boundary_point_coords(surf_tag) + if len(candidates) < 4: + return None + + def extremes_on(line): + hits = [] + for tag, (x, y) in candidates.items(): + point = Point(x, y) + if line.distance(point) <= tol: + hits.append((float(line.project(point)), tag)) + if len(hits) < 2: + return None + hits.sort() + return hits[0][1], hits[-1][1] + + neg_ends = extremes_on(neg) + pos_ends = extremes_on(pos) + if neg_ends is None or pos_ends is None: + return None + corner_tags = [neg_ends[0], neg_ends[1], pos_ends[1], pos_ends[0]] + if len(set(corner_tags)) != 4: + return None + return corner_tags + + def _locate_corner_tags_on_surface(self, surf_tag, corner_coords, tol): + """Match recorded strip corner coordinates to point tags on a surface. + + Only the surface's own boundary points are considered, so coordinate + collisions with the rest of the model are impossible. Returns the four + point tags in corner order, or None if any corner has no boundary + point within ``tol``. + """ + candidates = self._surface_boundary_point_coords(surf_tag) + if len(candidates) < 4: + return None + + corner_tags = [] + for cx, cy in corner_coords: + best_tag, best_dist = None, None + for tag, (px, py) in candidates.items(): + dist = math.hypot(px - cx, py - cy) + if best_dist is None or dist < best_dist: + best_tag, best_dist = tag, dist + if best_dist is None or best_dist > tol: + return None + corner_tags.append(best_tag) + if len(set(corner_tags)) != 4: + return None + return corner_tags + + def _partition_boundary_chains(self, surf_tag, corner_tags): + """Order a surface's boundary curves into 4 chains cut at the corners. + + Returns a list of (start_corner, end_corner, [curve_tags]) tuples, or + None when the boundary is not a single closed loop through all four + corner points (e.g. the strip was split by fragmentation). + """ + try: + boundary = gmsh.model.getBoundary( + [(2, int(surf_tag))], oriented=False, recursive=False + ) + except Exception: + return None + curve_tags = [int(tag) for dim, tag in boundary if int(dim) == 1] + if len(curve_tags) < 4: + return None + + endpoints = {} + point_curves = {} + for curve in curve_tags: + try: + pts = gmsh.model.getBoundary([(1, curve)], oriented=False, recursive=False) + except Exception: + return None + point_pair = [int(tag) for dim, tag in pts if int(dim) == 0] + if len(point_pair) != 2 or point_pair[0] == point_pair[1]: + return None + endpoints[curve] = point_pair + for point in point_pair: + point_curves.setdefault(point, []).append(curve) + if any(len(curves) != 2 for curves in point_curves.values()): + return None + + corner_set = {int(tag) for tag in corner_tags} + if len(corner_set) != 4 or not corner_set.issubset(point_curves.keys()): + return None + + start = int(corner_tags[0]) + point = start + curve = point_curves[start][0] + chains = [] + chain_start = start + current = [] + visited = set() + for _ in range(len(curve_tags)): + if curve in visited: + return None + visited.add(curve) + current.append(curve) + a, b = endpoints[curve] + point = b if point == a else a + if point in corner_set: + chains.append((chain_start, point, current)) + chain_start = point + current = [] + next_curves = [c for c in point_curves[point] if c != curve] + if len(next_curves) != 1: + return None + curve = next_curves[0] + if current or len(chains) != 4 or chains[-1][1] != start: + return None + return chains + + @staticmethod + def _distribute_chain_points(lengths, total_points): + """Split a chain's transfinite point budget across its curves. + + Returns per-curve point counts whose segment total matches + ``total_points - 1`` exactly, or None if the chain has more curves + than segments. + """ + total_segments = total_points - 1 + n = len(lengths) + if total_segments < n: + return None + total_length = sum(lengths) + segments = [ + max(1, int(round(total_segments * length / total_length))) + for length in lengths + ] + drift = total_segments - sum(segments) + order = sorted(range(n), key=lambda i: -lengths[i]) + attempts = 0 + while drift != 0 and attempts < 10 * n: + i = order[attempts % n] + step = 1 if drift > 0 else -1 + if segments[i] + step >= 1: + segments[i] += step + drift -= step + attempts += 1 + if drift != 0: + return None + return [s + 1 for s in segments] + + def _apply_transfinite_strip(self, surf_tag, corner_tags, lc, thickness): + """Apply a 4-corner transfinite structure to a relocated buffer strip. + + Opposite sides of a transfinite surface must carry equal point counts, + so the along-feature target is computed once from the longer side and + distributed across each side's curves. End caps get ``thickness + 1`` + points, matching gmshflow. Returns True on success. + """ + chains = self._partition_boundary_chains(surf_tag, corner_tags) + if chains is None: + return False + + ct = [int(tag) for tag in corner_tags] + roles = { + frozenset((ct[0], ct[1])): 'side', + frozenset((ct[2], ct[3])): 'side', + frozenset((ct[1], ct[2])): 'cap', + frozenset((ct[3], ct[0])): 'cap', + } + sides, caps = [], [] + for start_corner, end_corner, curves in chains: + role = roles.get(frozenset((start_corner, end_corner))) + if role == 'side': + sides.append(curves) + elif role == 'cap': + caps.append(curves) + else: + return False + if len(sides) != 2 or len(caps) != 2: + return False + + def chain_lengths(chains_group): + result = [] + for curves in chains_group: + lengths = [self._entity_length(1, curve) for curve in curves] + if any(v is None or not math.isfinite(v) or v <= 0 for v in lengths): + return None + result.append(lengths) + return result + + side_lengths = chain_lengths(sides) + cap_lengths = chain_lengths(caps) + if side_lengths is None or cap_lengths is None: + return False + + total_points = max( + 2, + int(round(max(sum(lengths) for lengths in side_lengths) / max(lc, 1e-12))) + 1, + ) + # A cap subdivided into more curves than the strip has cell rows (e.g. + # by a densified domain-boundary vertex) cannot carry thickness+1 + # points; forcing more would interpolate a node row onto the feature + # line, so the caller falls back to recombine-only instead. + cap_divisions = [ + self._distribute_chain_points(lengths, int(thickness) + 1) + for lengths in cap_lengths + ] + if any(divisions is None for divisions in cap_divisions): + return False + + try: + for curves, lengths in zip(sides, side_lengths): + divisions = self._distribute_chain_points(lengths, total_points) + if divisions is None: + return False + for curve, points in zip(curves, divisions): + gmsh.model.mesh.setTransfiniteCurve(int(curve), int(points)) + for curves, divisions in zip(caps, cap_divisions): + for curve, points in zip(curves, divisions): + gmsh.model.mesh.setTransfiniteCurve(int(curve), int(points)) + gmsh.model.mesh.setTransfiniteSurface(int(surf_tag), "Left", ct) + except Exception as e: + warnings.warn( + f"Could not apply transfinite structure to buffer surface {surf_tag}: {e}" + ) + return False + return True + + def _set_default_buffer_curve_divisions(self, surf_tag, lc): + """Recombine-only fallback: seed each boundary curve at ~lc spacing.""" + try: + boundary = gmsh.model.getBoundary( + [(2, int(surf_tag))], oriented=False, recursive=False + ) + except Exception: + boundary = [] + for dim, tag in boundary: + if int(dim) != 1: + continue + length = self._entity_length(1, tag) + if length is None or not math.isfinite(length) or length <= 0: + continue + divisions = max(2, int(round(length / lc)) + 1) + try: + gmsh.model.mesh.setTransfiniteCurve(int(tag), divisions) + except Exception as e: + warnings.warn(f"Could not set transfinite divisions on curve {tag}: {e}") + + def _apply_structured_buffer_meshing(self, final_map, structured_buffer_specs): + """Apply transfinite/recombine constraints to relocated buffer surfaces. + + Runs after fragmentation/dedup so OCC re-tagging cannot break the + structured constraints. Line strips get a true 4-corner transfinite + structure located by their recorded corner coordinates; polygon bands + (annuli) and any strip that was trimmed or split are meshed + recombine-only. + """ + structured_surfaces = final_map.get('structured_buffer_surfs', {}) + if not structured_surfaces: + return + + gmsh.option.setNumber("Mesh.RecombinationAlgorithm", 0) + transfinite_count = 0 + recombine_only_count = 0 + for feat_id, dimtags in structured_surfaces.items(): + spec = structured_buffer_specs.get(feat_id, {}) + lc = max(float(spec.get('lc', self.background_lc or 1.0)), 0.001) + thickness = int(spec.get('thickness', 1)) + strips = [info for info in spec.get('strips', []) if isinstance(info, dict)] + corner_sets = [info['corners'] for info in strips if info.get('corners')] + side_line_sets = [info['side_lines'] for info in strips if info.get('side_lines')] + surf_tags = [ + int(dt[1]) + for dt in dimtags + if isinstance(dt, (tuple, list)) and len(dt) >= 2 and int(dt[0]) == 2 + ] + + n_created = int(spec.get('n_surfaces_created', 0) or 0) + if n_created and len(surf_tags) > n_created and self.verbosity > 0: + logger.info( + f"Structured buffer for feature {feat_id} was split by fragmentation " + f"({n_created} surface(s) became {len(surf_tags)}); applying the " + "transfinite structure per piece." + ) + + tol = max(1e-4, lc * 1e-3) + for surf_tag in surf_tags: + structured = False + # Fast path: the recorded whole-strip corners survived intact. + for corners in corner_sets: + corner_tags = self._locate_corner_tags_on_surface(surf_tag, corners, tol) + if corner_tags is not None: + structured = self._apply_transfinite_strip( + surf_tag, corner_tags, lc, thickness + ) + if structured: + break + # Split/trimmed pieces: re-derive each piece's corners from the + # extreme boundary points on the original offset side lines. + if not structured: + for side_lines in side_line_sets: + corner_tags = self._derive_strip_corners_on_surface( + surf_tag, side_lines, tol + ) + if corner_tags is not None: + structured = self._apply_transfinite_strip( + surf_tag, corner_tags, lc, thickness + ) + if structured: + break + if not structured and (corner_sets or side_line_sets): + warnings.warn( + f"Could not apply transfinite structure to buffer surface " + f"{surf_tag} of feature {feat_id} (the strip was altered by " + "fragmentation, e.g. end caps subdivided where the strip meets " + "the domain boundary); meshing it recombine-only." + ) + if not structured: + self._set_default_buffer_curve_divisions(surf_tag, lc) + try: + gmsh.model.mesh.setRecombine(2, int(surf_tag)) + gmsh.model.mesh.setAlgorithm(2, int(surf_tag), 8) + except Exception as e: + warnings.warn( + f"Could not apply recombination to buffer surface {surf_tag}: {e}" + ) + if structured: + transfinite_count += 1 + else: + recombine_only_count += 1 + + if self.verbosity > 0: + logger.info( + f"Applied structured quad-buffer meshing to " + f"{transfinite_count + recombine_only_count} surface(s) " + f"({transfinite_count} transfinite, {recombine_only_count} recombine-only)." + ) def _setup_fields(self, gmsh_map, polygons_gdf, lines_gdf, points_gdf): """ @@ -381,26 +2160,42 @@ def _setup_fields(self, gmsh_map, polygons_gdf, lines_gdf, points_gdf): refined near points, along lines, and within polygons. """ if self.verbosity > 0: - print(f"--- Setup Fields Debug ---") - print(f"Polygons GDF: {len(polygons_gdf)} rows") - print(f"Gmsh Surface Map: {len(gmsh_map.get('surfaces', {}))} entries") + logger.info("--- Setup Fields Debug ---") + logger.info(f"Polygons GDF: {len(polygons_gdf)} rows") + logger.info(f"Gmsh Surface Map: {len(gmsh_map.get('surfaces', {}))} entries") if not polygons_gdf.empty: first_idx = polygons_gdf.index[0] - print(f"First Poly Index: {first_idx} (Type: {type(first_idx)})") + logger.info(f"First Poly Index: {first_idx} (Type: {type(first_idx)})") if gmsh_map['surfaces']: first_key = list(gmsh_map['surfaces'].keys())[0] - print(f"First Map Key: {first_key} (Type: {type(first_key)})") - print(f"Match? {first_idx in gmsh_map['surfaces']}") + logger.info(f"First Map Key: {first_key} (Type: {type(first_key)})") + logger.info(f"Match? {first_idx in gmsh_map['surfaces']}") else: - print("Gmsh Surface Map is EMPTY.") + logger.info("Gmsh Surface Map is EMPTY.") + # Collect all created Gmsh field ids so we can combine them at the end. field_list = [] - # The global background mesh size is the fallback resolution. - global_max_lc = self.background_lc + # The global background mesh size is always required. + # We create a Constant field for it and always set a background mesh. + if self.background_lc is None: + raise ValueError( + "MeshGenerator.background_lc must be provided. " + "If you don't want to constrain the mesh, pass a very large value." + ) + global_max_lc = float(self.background_lc) + if not math.isfinite(global_max_lc) or global_max_lc <= 0.0: + raise ValueError( + "MeshGenerator.background_lc must be a positive finite number. " + f"Got {self.background_lc!r}." + ) def extract_tags(entry_list): - """Helper to get a clean list of integer tags from Gmsh's output.""" + """Return a clean list of integer tags from Gmsh's dimtag-ish output. + + Gmsh commonly returns lists of (dim, tag) tuples; some maps in this + code also store raw tag ints. We normalize both to an int tag list. + """ clean_tags = [] for item in entry_list: if isinstance(item, (tuple, list)) and len(item) >= 2: @@ -410,190 +2205,564 @@ def extract_tags(entry_list): return clean_tags def get_row_param(row, key, default): - if key in row and not pd.isna(row[key]): return float(row[key]) + if key in row and not pd.isna(row[key]): + return float(row[key]) return float(default) - def add_refinement(entity_dim, entity_tags, size_target, dist_min, dist_max, size_max_limit=None): - if not entity_tags: return None - valid_tags = [float(t) for t in entity_tags] - - if size_max_limit is None: - size_max_limit = global_max_lc - - # To ensure the meshing algorithm converges efficiently, the rate of - # change in element size must be controlled. This heuristic enforces - # a minimum transition distance to prevent the mesh size gradient - # from becoming too steep, which can stall the mesher. - size_diff = size_max_limit - size_target - if size_diff > 0: - min_span_required = size_diff / (0.5 * size_target) - - current_span = dist_max - dist_min - if current_span < min_span_required: - dist_max = dist_min + min_span_required + def _normalize_fields(value): + """Normalize feature field specifications to a list[MeshField]. - if dist_max <= dist_min: - dist_max = dist_min + max(size_target, 1e-3) - - # Create a `Distance` field, which calculates the distance from the specified entities. - f_dist = gmsh.model.mesh.field.add("Distance") - if entity_dim == 0: gmsh.model.mesh.field.setNumbers(f_dist, "PointsList", valid_tags) - elif entity_dim == 1: gmsh.model.mesh.field.setNumbers(f_dist, "CurvesList", valid_tags) - - # Create a `Threshold` field, which uses the `Distance` field to - # define a mesh size that varies linearly from `SizeMin` to `SizeMax` - # over the range `DistMin` to `DistMax`. This is more efficient than `MathEval`. - f_thresh = gmsh.model.mesh.field.add("Threshold") - gmsh.model.mesh.field.setNumber(f_thresh, "InField", f_dist) - gmsh.model.mesh.field.setNumber(f_thresh, "SizeMin", float(size_target)) - gmsh.model.mesh.field.setNumber(f_thresh, "SizeMax", float(size_max_limit)) - gmsh.model.mesh.field.setNumber(f_thresh, "DistMin", float(dist_min)) - gmsh.model.mesh.field.setNumber(f_thresh, "DistMax", float(dist_max)) - - return f_thresh + Supported inputs: + - None / NaN -> [] + - MeshField -> [field] + - list/tuple/set of mixed values -> only MeshField entries are kept + """ + if value is None: + return [] + if isinstance(value, float) and pd.isna(value): + return [] + if isinstance(value, MeshField): + return [value] + if isinstance(value, (list, tuple, set)): + return [v for v in value if isinstance(v, MeshField)] + return [] - # 1. Point-based refinement fields. - for idx, row in points_gdf.iterrows(): - if idx in gmsh_map['points']: - tags = extract_tags(gmsh_map['points'][idx]) - lc = max(get_row_param(row, 'lc', 5.0), 0.001) - d_min = get_row_param(row, 'dist_min', lc * 2.0) - d_max = get_row_param(row, 'dist_max', global_max_lc * 1.5) - - fid = add_refinement(0, tags, lc, d_min, d_max) - if fid: field_list.append(fid) + def _auto_field_from_row(row, background_lc, has_explicit_fields): + """Build the implicit size field that backs a feature's resolution. - # 2. Line-based refinement fields (including straddle barriers). - for idx, row in lines_gdf.iterrows(): - # Standard lines that exist as curves in Gmsh. - if idx in gmsh_map['lines']: - tags = extract_tags(gmsh_map['lines'][idx]) - lc = max(get_row_param(row, 'lc', 10.0), 0.001) - d_min = get_row_param(row, 'dist_min', lc * 1.0) - d_max = get_row_param(row, 'dist_max', global_max_lc * 1.5) - - fid = add_refinement(1, tags, lc, d_min, d_max) - if fid: field_list.append(fid) + Default: a GeometricGrowthField that grows the mesh from the + feature size up to the background size at the feature's growth_factor + (DEFAULT_GROWTH_FACTOR when unset). Created only when the feature is + finer than the background and has no explicit ``fields``. + + Legacy (deprecated): if dist_min/dist_max are supplied, honor them as + the old linear ThresholdField and emit a DeprecationWarning. This path + is kept (even alongside explicit fields) so existing models still mesh. + """ + if background_lc is None or (isinstance(background_lc, float) and pd.isna(background_lc)): + return None + + feature_lc = row.get('lc', None) + if feature_lc is None or (isinstance(feature_lc, float) and pd.isna(feature_lc)): + return None + feature_lc = float(feature_lc) + + dist_min = row.get('dist_min', None) + dist_max = row.get('dist_max', None) + dist_min = None if (dist_min is None or (isinstance(dist_min, float) and pd.isna(dist_min))) else float(dist_min) + dist_max = None if (dist_max is None or (isinstance(dist_max, float) and pd.isna(dist_max))) else float(dist_max) + + if dist_min is not None or dist_max is not None: + # --- Legacy linear ThresholdField (deprecated) --- + warnings.warn( + "dist_min/dist_max are deprecated for feature size transitions; they " + "select the legacy linear ThresholdField. Omit them to use the default " + "GeometricGrowthField (tune it with growth_factor), or pass an explicit " + "ThresholdField in `fields` to keep a linear ramp.", + DeprecationWarning, + stacklevel=2, + ) + # DistMin: at least one local element size; DistMax: broad scale. + if dist_min is None: + dist_min = feature_lc + if dist_max is None: + dist_max = float(background_lc) * 5.0 + dist_min = max(dist_min, feature_lc * 0.5) + # Enforce a gentle gradient relative to SizeMax. + min_span = 3.0 * float(background_lc) + if (dist_max - dist_min) < min_span: + dist_max = dist_min + min_span + if dist_max <= dist_min: + dist_max = dist_min + max(float(background_lc), feature_lc, 1e-3) + return ThresholdField(size_min=feature_lc, dist_min=dist_min, dist_max=dist_max, size_max=background_lc) + + # --- Default GeometricGrowthField --- + # Only when the user has not supplied an explicit field and the + # feature is actually finer than the background (else nothing to do). + if has_explicit_fields or feature_lc >= float(background_lc): + return None + growth = row.get('growth_factor', None) + if growth is None or (isinstance(growth, float) and pd.isna(growth)): + growth = DEFAULT_GROWTH_FACTOR + growth = float(growth) + return GeometricGrowthField(growth_factor=growth) + + # Configure mesh size fields using MeshField objects attached to features. + # + # Data model expectations: + # - ConceptualMesh stores the user's desired behavior in GeoDataFrame rows. + # - Fields are created here (engine side) because the engine has the Gmsh + # tags and is responsible for mapping features -> CAD entities. + # + # How fields can be specified per feature: + # - `fields`: list[MeshField] (the only supported explicit mechanism) + # - resolution (+ growth_factor): default implicit GeometricGrowthField + # - `dist_min/dist_max` (+ lc): DEPRECATED shorthand for a linear ThresholdField + # + # Grouping: + # - We build ONE gmsh field per unique (field parameters + lc). + # - We intentionally do NOT split by geometry type because a single Gmsh + # Distance/Threshold field can target points/curves/surfaces at once. + # - `feature_lc` is part of grouping because Auto* fields compute their + # transition based on the local target size. + # + # Each group accumulates feature ids per geometry type so we can later + # gather all relevant gmsh tags into a single tags_dict. + field_objects = {} + for gdf, geom_type in [(points_gdf, 'points'), (lines_gdf, 'lines'), (polygons_gdf, 'surfaces')]: + for idx, row in gdf.iterrows(): + # 1) Collect explicitly specified fields. + explicit_fields = _normalize_fields(row.get('fields', None)) + row_fields = list(explicit_fields) + + # 2) Add the implicit size field backing the feature's + # resolution: GeometricGrowthField by default, or the legacy + # ThresholdField when dist_min/dist_max are given (deprecated). + auto_field = _auto_field_from_row( + row, global_max_lc, has_explicit_fields=bool(explicit_fields) + ) + if auto_field is not None: + row_fields.append(auto_field) + + if not row_fields: + continue + + # Cache the feature lc for Auto* fields. + feature_lc = row.get('lc', None) + if feature_lc is None or (isinstance(feature_lc, float) and pd.isna(feature_lc)): + feature_lc = None + else: + feature_lc = float(feature_lc) + + for field in row_fields: + if field is None or not isinstance(field, MeshField): + continue + key = (hash(field), feature_lc) + if key not in field_objects: + field_objects[key] = { + 'field': field, + 'feature_lc': feature_lc, + 'feature_ids_by_geom': {'points': [], 'lines': [], 'surfaces': []}, + } + field_objects[key]['feature_ids_by_geom'][geom_type].append(int(idx)) + + # Now create and apply each unique field to the corresponding features. + # We gather all Gmsh entity tags for the features and let the MeshField + # implementation create the appropriate Distance/Threshold/etc field. + for key, info in field_objects.items(): + field = info['field'] + feature_lc = info.get('feature_lc', None) + feature_ids_by_geom = info.get('feature_ids_by_geom', {'points': [], 'lines': [], 'surfaces': []}) - # "Straddle" lines, which were converted into pairs of points. - # Refinement must be applied to these points to resolve the gap. - elif idx in gmsh_map['points']: - is_barrier = row.get('is_barrier', False) - straddle = row.get('straddle_width', 0) - if is_barrier or (straddle and straddle > 0): - tags = extract_tags(gmsh_map['points'][idx]) - lc = max(get_row_param(row, 'lc', 10.0), 0.001) - - d_min = get_row_param(row, 'dist_min', lc * 2.0) - d_max = get_row_param(row, 'dist_max', global_max_lc * 1.5) - - fid = add_refinement(0, tags, lc, d_min, d_max) - if fid: field_list.append(fid) + # Gather all Gmsh tags for the features using this field. + # Note: embedded geometry is mapped under gmsh_map[geom_type]. + # For embed=False polygons, we keep their boundary curves under + # gmsh_map['poly_curves'] so fields can still be applied without + # cutting/fragmenting the domain. + tags_dict = { + 'points': [], + 'lines': [], + 'surfaces': [], + 'embedded_surfaces': [], + 'field_only_surfaces': [], + } - # 3. Polygon-based refinement fields. - for idx, row in polygons_gdf.iterrows(): - if idx in gmsh_map['surfaces']: - tags = extract_tags(gmsh_map['surfaces'][idx]) - - target_lc = get_row_param(row, 'lc', global_max_lc) - border_dens = get_row_param(row, 'border_density', target_lc) - boundary_lc = min(target_lc, border_dens) + # Points + for fid in feature_ids_by_geom.get('points', []): + if fid in gmsh_map.get('points', {}): + tags_dict['points'].extend(extract_tags(gmsh_map['points'][fid])) - if self.verbosity > 1: - print(f"Poly {idx}: Target={target_lc}, Border={boundary_lc}, Global={global_max_lc}") + # Lines + for fid in feature_ids_by_geom.get('lines', []): + if fid in gmsh_map.get('lines', {}): + tags_dict['lines'].extend(extract_tags(gmsh_map['lines'][fid])) + # Straddle/barrier lines may have been converted into points. + elif fid in gmsh_map.get('points', {}): + tags_dict['points'].extend(extract_tags(gmsh_map['points'][fid])) + elif ('line', fid) in gmsh_map.get('structured_buffer_surfs', {}): + # Buffer strips are embedded surfaces; list them as such so + # distance-growth fields target their boundary curves + # (an empty 'embedded_surfaces' would disable the field). + surface_tags = extract_tags(gmsh_map['structured_buffer_surfs'][('line', fid)]) + tags_dict['surfaces'].extend(surface_tags) + tags_dict['embedded_surfaces'].extend(surface_tags) - # Set up a field for the polygon's interior. - if boundary_lc < global_max_lc or target_lc < global_max_lc: - - dim_tags = [(2, int(t)) for t in tags] - boundaries = gmsh.model.getBoundary(dim_tags, combined=True, oriented=False, recursive=False) - curve_tags = [b[1] for b in boundaries if b[0] == 1] - - f_inner = None - - if curve_tags and boundary_lc < target_lc: - # Create a gradient from the finer boundary to the coarser interior. - d_min = get_row_param(row, 'dist_min', 0.0) - d_max_in = get_row_param(row, 'dist_max_in', -1.0) - - if d_max_in > d_min: - d_max_inner = d_max_in - else: - d_max_inner = d_min + (boundary_lc * 5.0) - d_max_inner = max(d_max_inner, d_min + (target_lc - boundary_lc) * 0.2) - - if self.verbosity > 1: - print(f" -> Grading Interior: DistMin={d_min}, DistMax={d_max_inner}, SizeMax={target_lc}") - - f_inner = add_refinement(1, curve_tags, boundary_lc, d_min, d_max_inner, size_max_limit=target_lc) - + # Surfaces + for fid in feature_ids_by_geom.get('surfaces', []): + if fid in gmsh_map.get('surfaces', {}): + surface_tags = extract_tags(gmsh_map['surfaces'][fid]) + # A buffered polygon's outline lives in its band surfaces + # (the interior is inset), so include them for field + # targeting too. + if ('poly', fid) in gmsh_map.get('structured_buffer_surfs', {}): + surface_tags = surface_tags + extract_tags( + gmsh_map['structured_buffer_surfs'][('poly', fid)] + ) + tags_dict['surfaces'].extend(surface_tags) + + try: + embed_val = polygons_gdf.loc[fid].get('embed', True) + embedded = True if pd.isna(embed_val) else bool(embed_val) + except Exception: + embedded = True + + if embedded: + tags_dict['embedded_surfaces'].extend(surface_tags) else: - # Apply a constant mesh size throughout the interior. - if self.verbosity > 1: - print(f" -> Constant Interior: Size={target_lc}") - - f_dist_inner = gmsh.model.mesh.field.add("Distance") - gmsh.model.mesh.field.setNumbers(f_dist_inner, "CurvesList", curve_tags) - - f_const = gmsh.model.mesh.field.add("Threshold") - gmsh.model.mesh.field.setNumber(f_const, "InField", f_dist_inner) - gmsh.model.mesh.field.setNumber(f_const, "SizeMin", target_lc) - gmsh.model.mesh.field.setNumber(f_const, "SizeMax", target_lc) - gmsh.model.mesh.field.setNumber(f_const, "DistMin", 1e22) - gmsh.model.mesh.field.setNumber(f_const, "DistMax", 1e22) - - f_inner = f_const - - # Restrict this field to apply only inside the polygon surface. - if f_inner: - f_rest = gmsh.model.mesh.field.add("Restrict") - gmsh.model.mesh.field.setNumber(f_rest, "IField", f_inner) - gmsh.model.mesh.field.setNumbers(f_rest, "SurfacesList", [float(t) for t in tags]) - field_list.append(f_rest) - - # Set up a field for the polygon's exterior, grading to the global size. - d_max_out = get_row_param(row, 'dist_max_out', 0.0) - - if d_max_out > 0: - dim_tags = [(2, int(t)) for t in tags] - boundaries = gmsh.model.getBoundary(dim_tags, combined=True, oriented=False, recursive=False) - curve_tags = [b[1] for b in boundaries if b[0] == 1] - - if curve_tags: - d_min = get_row_param(row, 'dist_min', 0.0) - if self.verbosity > 1: - print(f" -> Grading Exterior: DistMax={d_max_out}") - - fid_grad = add_refinement(1, curve_tags, boundary_lc, d_min, d_max_out, size_max_limit=global_max_lc) - if fid_grad: field_list.append(fid_grad) - - # 4. Straddle surfaces (placeholder for future transfinite enforcement). - for idx, tags in gmsh_map.get('straddle_surfs', {}).items(): - clean_tags = extract_tags(tags) - for s_tag in clean_tags: - pass - - # 5. Set the final background field. This is a constant field that - # provides the mesh size for any area not covered by other fields. - f_bg = gmsh.model.mesh.field.add("MathEval") - gmsh.model.mesh.field.setString(f_bg, "F", str(global_max_lc)) - field_list.append(f_bg) - - # 6. Combine all fields using a `Min` field. At any point in the - # domain, the mesh size will be the minimum of all active fields. + tags_dict['field_only_surfaces'].extend(surface_tags) + # Field-only polygons (embed=False): apply distance-based fields to boundary curves. + elif fid in gmsh_map.get('poly_curves', {}): + curve_dimtags = gmsh_map['poly_curves'][fid] + tags_dict['lines'].extend(extract_tags(curve_dimtags)) + + if not any(tags_dict.values()): + continue + + # Private metadata for built-in field helpers; custom MeshField + # implementations can ignore it because tag lists remain unchanged. + tags_dict['_verbosity'] = self.verbosity + + # Create the Gmsh field using the provided MeshField object. + f_id = field.create( + gmsh_api=gmsh, + tags_dict=tags_dict, + background_lc=global_max_lc, + feature_lc=feature_lc + ) + + if f_id is not None: + field_list.append(f_id) + + # Crossing refinement: where two quad buffers cross, the lower-priority + # one is trimmed away, leaving a small gap that the unstructured mesher + # would otherwise fill at the background size right next to the dense + # strip rows -- the size jump and quality crater the user sees. Pin each + # crossing region to min(lc) of the two features with a Ball field + # (rotation-agnostic, no OCC geometry added). The Min field below takes + # the smallest requested size, and transfinite strips ignore size fields, + # so the continuous winner is unaffected. + for crossing in getattr(self, '_quad_buffer_crossings', []): + ball = gmsh.model.mesh.field.add("Ball") + gmsh.model.mesh.field.setNumber(ball, "Radius", float(crossing['radius'])) + gmsh.model.mesh.field.setNumber(ball, "XCenter", float(crossing['x'])) + gmsh.model.mesh.field.setNumber(ball, "YCenter", float(crossing['y'])) + gmsh.model.mesh.field.setNumber(ball, "ZCenter", 0.0) + gmsh.model.mesh.field.setNumber(ball, "VIn", float(crossing['size'])) + gmsh.model.mesh.field.setNumber(ball, "VOut", global_max_lc) + gmsh.model.mesh.field.setNumber(ball, "Thickness", 3.0 * float(crossing['size'])) + field_list.append(ball) + + #now lets add the background constant field if specified + if self.background_lc is not None: + const_field = ConstantField(size=self.background_lc) + f_id = const_field.create( + gmsh_api=gmsh, + tags_dict={}, + background_lc=self.background_lc, + feature_lc=None + ) + if f_id is not None: + field_list.append(f_id) + + # Combine all active fields using a Min field and set it as the background mesh. + # At any (x,y), Gmsh will take the smallest requested element size. if field_list: min_field = gmsh.model.mesh.field.add("Min") - field_list = [float(f) for f in field_list] - gmsh.model.mesh.field.setNumbers(min_field, "FieldsList", field_list) + gmsh.model.mesh.field.setNumbers(min_field, "FieldsList", [float(f) for f in field_list]) gmsh.model.mesh.field.setAsBackgroundMesh(min_field) - - # Disable Gmsh's default size-setting mechanisms. We want our fields - # to have complete control over the mesh size. + + # Disable Gmsh's default sizing mechanisms so fields fully control mesh size. + # Otherwise, mesh sizing from points/curvature/boundary can compete with fields. gmsh.option.setNumber("Mesh.MeshSizeExtendFromBoundary", 0) gmsh.option.setNumber("Mesh.MeshSizeFromPoints", 0) gmsh.option.setNumber("Mesh.MeshSizeFromCurvature", 0) - def generate(self, clean_polys, clean_lines, clean_points, output_file=None): + + def _embed_features(self, gmsh_map, polygons_gdf, lines_gdf, points_gdf): + """ + Explicitly embeds features into domain surfaces to ensure mesh conformity. + + This handles cases where fragmentation splits surfaces, requiring + geometric discovery to find the correct surface for points/lines. + """ + if self.verbosity > 0: + logger.info("Explicitly embedding features into domain surfaces...") + + def is_embedded(row): + val = row.get('embed', True) + if pd.isna(val): + return True + return bool(val) + + # 1. Collect Domain Surfaces (Candidate Pool) + domain_surface_tags = set() + if not polygons_gdf.empty: + for idx, row in polygons_gdf.iterrows(): + if is_embedded(row) and idx in gmsh_map.get('surfaces', {}): + for dt in gmsh_map['surfaces'][idx]: + # Ensure we are tracking actual surfaces (dim=2) + if isinstance(dt, (tuple, list)) and len(dt) >= 2 and dt[0] == 2: + domain_surface_tags.add(dt[1]) + + # >>> DIAG: domain surface collection summary + if self.verbosity >= 2: + _gdf_idxs = list(polygons_gdf.index) if not polygons_gdf.empty else [] + _map_keys = list(gmsh_map.get('surfaces', {}).keys()) + _matching = [i for i in _gdf_idxs if i in gmsh_map.get('surfaces', {})] + logger.debug(f"[DIAG] Embed pool: GDF indices={_gdf_idxs}, map keys={_map_keys}, " + f"matched={len(_matching)}, domain_surface_tags={sorted(domain_surface_tags)}") + # Dump bbox of ALL surfaces - shows which surfaces cover which area + _all_surfs = gmsh.model.getEntities(2) + for _s in _all_surfs: + _in_pool = "POOL" if _s[1] in domain_surface_tags else "----" + try: + _sbb = gmsh.model.getBoundingBox(2, _s[1]) + logger.debug(f"[DIAG] surf {_s[1]:3d} [{_in_pool}] " + f"x=[{_sbb[0]:7.1f},{_sbb[3]:7.1f}] " + f"y=[{_sbb[1]:7.1f},{_sbb[4]:7.1f}]") + except Exception: + logger.debug(f"[DIAG] surf {_s[1]:3d} [{_in_pool}] bbox FAILED") + # Which feature id maps to which surface tags? + for _feat_id, _dts in gmsh_map.get('surfaces', {}).items(): + _stags = [int(dt[1]) for dt in _dts if isinstance(dt, (tuple,list)) and dt[0]==2] + logger.debug(f"[DIAG] map[surfaces][{_feat_id}] -> tags {_stags}") + # <<< DIAG + + if not domain_surface_tags: + return + + # >>> DIAG: Accumulator for embed summary + _elog = {'ok': 0, 'conflict': 0, 'skip_bbox': 0, 'skip_no_cand': 0, + 'skip_no_match': 0, 'failed': 0, 'boundary_skip': 0, + 'multi_match': 0, 'inside_failed': 0, + 'conflict_tags': [], 'fail_tags': [], 'boundary_tags': [], + 'multi_tags': [], 'inside_fail_tags': [], 'records': []} + # <<< DIAG + + # Helper for geometric embedding search and application. + # We pre-compute surface bboxes for a fast spatial filter, then confirm + # against trimmed surfaces with gmsh.model.isInside(). Do not use + # getClosestPoint() here: for coplanar OCC surfaces it can project onto + # the support plane outside the trimmed face, causing false multi-surface + # embeds and over-constraining Gmsh. + _surf_bboxes = {} + for _st in domain_surface_tags: + try: + _bb = gmsh.model.getBoundingBox(2, _st) + _surf_bboxes[_st] = _bb # (xmin, ymin, zmin, xmax, ymax, zmax) + except Exception: + logger.debug("No bounding box for domain surface %d; it is " + "excluded from the embedding candidate pool.", _st) + + def _bbox_contains_point(sbb, pt, eps=1e-4): + return ( + sbb[0] - eps <= pt[0] <= sbb[3] + eps and + sbb[1] - eps <= pt[1] <= sbb[4] + eps and + sbb[2] - eps <= pt[2] <= sbb[5] + eps + ) + + def _entity_sample_points(dim, tag, bbox): + xmin, ymin, zmin, xmax, ymax, zmax = bbox + if dim == 0: + return [((xmin + xmax) / 2.0, (ymin + ymax) / 2.0, (zmin + zmax) / 2.0)] + if dim != 1: + return [] + + pmin, pmax = gmsh.model.getParametrizationBounds(1, tag) + lo = float(pmin[0]) + hi = float(pmax[0]) + if not (math.isfinite(lo) and math.isfinite(hi)): + return [] + if hi < lo: + lo, hi = hi, lo + + # Avoid exact endpoints: line ends commonly lie on partition + # boundaries and are ambiguous. Interior samples identify the + # trimmed surface that actually owns the line fragment. + params = [lo + (hi - lo) * f for f in (0.25, 0.5, 0.75)] + points = [] + seen = set() + for param in params: + val = gmsh.model.getValue(1, tag, [param]) + pt = (float(val[0]), float(val[1]), float(val[2])) + key = (round(pt[0], 8), round(pt[1], 8), round(pt[2], 8)) + if key not in seen: + seen.add(key) + points.append(pt) + return points + + def _surface_area(surf_tag): + try: + return float(gmsh.model.occ.getMass(2, int(surf_tag))) + except Exception: + try: + return float(gmsh.model.getMass(2, int(surf_tag))) + except Exception: + return float("inf") + + def embed_entity(dim, tag): + # 1. Verify entity exists + try: + bbox = gmsh.model.getBoundingBox(dim, tag) + except Exception: + _elog['skip_bbox'] += 1 + return + + xmin, ymin, zmin, xmax, ymax, zmax = bbox + + # Check if line is already a boundary of some surface. Boundary + # curves already constrain their adjacent surfaces; explicitly + # embedding them elsewhere duplicates constraints and can make Gmsh + # non-terminating on dense partitioned geometries. + is_boundary_of = set() + if dim == 1: + try: + up, _down = gmsh.model.getAdjacencies(1, tag) + is_boundary_of = {int(v) for v in up} + except Exception: + logger.debug("getAdjacencies failed for curve %d; treating " + "it as interior for embedding.", tag) + if is_boundary_of: + _elog['boundary_skip'] += 1 + _elog['boundary_tags'].append((int(tag), sorted(is_boundary_of))) + return + + # 2. Sample the entity inside its extent. + try: + sample_points = _entity_sample_points(dim, tag, bbox) + except Exception: + sample_points = [] + if not sample_points: + _elog['skip_no_match'] += 1 + return + + # 3. Fast bbox pre-filter: only test surfaces whose bbox contains at + # least one sampled point. + candidates = set() + eps = 1e-4 + for surf_tag, sbb in _surf_bboxes.items(): + if any(_bbox_contains_point(sbb, pt, eps=eps) for pt in sample_points): + candidates.add(int(surf_tag)) + + if not candidates: + _elog['skip_no_cand'] += 1 + return + + # 4. Confirm with isInside(). For lines, require all interior sample + # points to be inside a single trimmed surface. + target_matches = [] + flat_points = [] + for pt in sample_points: + flat_points.extend([pt[0], pt[1], pt[2]]) + for surf_tag in sorted(candidates): + try: + inside_count = int(gmsh.model.isInside(2, int(surf_tag), flat_points)) + if inside_count == len(sample_points): + target_matches.append(surf_tag) + except Exception: + _elog['inside_failed'] += 1 + _elog['inside_fail_tags'].append((int(tag), int(surf_tag))) + + # 5. Embed the entity into the verified surfaces + if target_matches: + target_matches = sorted(set(target_matches)) + if len(target_matches) > 1: + _elog['multi_match'] += 1 + _elog['multi_tags'].append((int(tag), list(target_matches))) + # Nested or overlapping source polygons can still produce + # multiple containing faces. Choose the smallest trimmed + # surface as the most local owner instead of embedding the + # same entity into every containing face. + target_matches = [min(target_matches, key=_surface_area)] + for st in target_matches: + try: + gmsh.model.mesh.embed(dim, [tag], 2, st) + _elog['ok'] += 1 + if self.diagnose: + _elog['records'].append({ + 'dim': int(dim), + 'tag': int(tag), + 'surface': int(st), + 'bbox': tuple(float(v) for v in bbox), + 'sample_points': sample_points, + }) + except Exception as e: + _elog['failed'] += 1 + _elog['fail_tags'].append((tag, str(e)[:60])) + else: + _elog['skip_no_match'] += 1 + + # Iterate and Embed Points + if points_gdf is not None and not points_gdf.empty: + for idx, row in points_gdf.iterrows(): + if is_embedded(row) and idx in gmsh_map.get('points', {}): + for dt in gmsh_map['points'][idx]: + if dt[0] == 0: + embed_entity(0, dt[1]) + + # Iterate and Embed Lines + if lines_gdf is not None and not lines_gdf.empty: + for idx, row in lines_gdf.iterrows(): + if is_embedded(row): + # Standard Lines + if idx in gmsh_map.get('lines', {}): + for dt in gmsh_map['lines'][idx]: + if dt[0] == 1: + embed_entity(1, dt[1]) + # Barrier/Straddle Points (these are points derived from lines) + if idx in gmsh_map.get('points', {}): + for dt in gmsh_map['points'][idx]: + if dt[0] == 0: + embed_entity(0, dt[1]) + + # >>> DIAG: Embed summary + if self.verbosity >= 2: + _filt = _elog.get('skip_filtered', 0) + logger.debug(f"[DIAG] Embed results: {_elog['ok']} OK, " + f"{_elog['conflict']} boundary-conflicts, " + f"{_elog['failed']} failed, " + f"{_elog['skip_bbox']} no-bbox, " + f"{_elog['skip_no_cand']} empty-bbox, " + f"{_filt} filtered-out, " + f"{_elog['skip_no_match']} no-match, " + f"{_elog['boundary_skip']} boundary-skip, " + f"{_elog['multi_match']} multi-match, " + f"{_elog['inside_failed']} inside-failed") + if _filt > 0: + logger.debug(f"[DIAG] *** {_filt} entities found nearby surfaces but NONE " + f"were in domain_surface_tags — likely missing domain surface! ***") + if _elog['conflict_tags']: + uniq = sorted(set(_elog['conflict_tags'])) + logger.debug(f"[DIAG] *** {len(uniq)} unique line tags had BOUNDARY CONFLICTS " + f"(first 10): {uniq[:10]} ***") + if _elog['fail_tags']: + logger.debug(f"[DIAG] *** Failed embeds: {_elog['fail_tags'][:5]} ***") + if _elog['boundary_tags']: + uniq = _elog['boundary_tags'][:10] + logger.debug(f"[DIAG] Boundary line fragments skipped (first 10): {uniq}") + if _elog['multi_tags']: + logger.debug(f"[DIAG] Multi-surface embed candidates collapsed " + f"(first 10): {_elog['multi_tags'][:10]}") + # <<< DIAG + + self.diagnostics['embedding'] = { + 'ok': _elog['ok'], + 'failed': _elog['failed'], + 'skip_bbox': _elog['skip_bbox'], + 'skip_no_cand': _elog['skip_no_cand'], + 'skip_no_match': _elog['skip_no_match'], + 'boundary_skip': _elog['boundary_skip'], + 'multi_match': _elog['multi_match'], + 'inside_failed': _elog['inside_failed'], + 'boundary_tags': list(_elog['boundary_tags']), + 'multi_tags': list(_elog['multi_tags']), + 'fail_tags': list(_elog['fail_tags']), + } + if self.diagnose: + self.diagnostics['embedding']['records'] = list(_elog['records']) + + + def generate(self, clean_polys, clean_lines, clean_points, output_file=None, launch_gmsh_gui=False): """ Executes the full mesh generation workflow. @@ -610,6 +2779,9 @@ def generate(self, clean_polys, clean_lines, clean_points, output_file=None): clean_lines (GeoDataFrame): Snapped and cleaned lines. clean_points (GeoDataFrame): Snapped and cleaned points. output_file (str, optional): If provided, saves the mesh to this path. + launch_gmsh_gui (Boolean, optional): This allow to see triangular mesh results + using the GMSH GUI, and allow to review visually the fields and the triangular + mesh quality Returns: bool: True if generation was successful. @@ -617,12 +2789,53 @@ def generate(self, clean_polys, clean_lines, clean_points, output_file=None): Raises: Exception: If any step in the Gmsh process fails. """ + self.triangular_quality = None + self.element_grid = None self._initialize_gmsh() try: - print("Transferring Geometry to Gmsh...") - gmsh_map = self._add_geometry(clean_polys, clean_lines, clean_points) + logger.info("Transferring Geometry to Gmsh...") + gmsh_map = self._add_geometry(clean_polys, clean_lines, clean_points, launch_gmsh_gui=launch_gmsh_gui) - print("Setting up Resolution Fields...") + # Ensure features are correctly embedded in surfaces before meshing + self._embed_features(gmsh_map, clean_polys, clean_lines, clean_points) + + # >>> DIAG: Post-embed summary + if self.verbosity >= 2: + all_surfs = gmsh.model.getEntities(2) + _with_emb, _without_emb, _total_emb = 0, 0, 0 + for surf_dt in all_surfs: + try: + emb = gmsh.model.mesh.getEmbedded(2, surf_dt[1]) + if emb: + _with_emb += 1 + _total_emb += len(emb) + else: + _without_emb += 1 + except Exception: + _without_emb += 1 + # Count line boundary vs interior in gmsh_map + _map_bnd, _map_int, _map_miss = 0, 0, 0 + for feat_id, dimtags in gmsh_map.get('lines', {}).items(): + for dt in dimtags: + if not (isinstance(dt, (tuple, list)) and len(dt) >= 2): + continue + if int(dt[0]) != 1: + continue + try: + up, _ = gmsh.model.getAdjacencies(1, int(dt[1])) + if len(up) > 0: + _map_bnd += 1 + else: + _map_int += 1 + except Exception: + _map_miss += 1 + logger.debug(f"[DIAG] Post-embed: {_with_emb}/{len(all_surfs)} surfaces have embeddings " + f"({_total_emb} total entities) | " + f"{_without_emb} surfaces empty") + logger.debug(f"[DIAG] Line map: {_map_int} interior, {_map_bnd} boundary, {_map_miss} missing") + # <<< DIAG + + logger.info("Setting up Resolution Fields...") self._setup_fields(gmsh_map, clean_polys, clean_lines, clean_points) # Set the core meshing algorithm. @@ -631,36 +2844,112 @@ def generate(self, clean_polys, clean_lines, clean_points, output_file=None): # Set the number of internal smoothing steps. gmsh.option.setNumber("Mesh.Smoothing", self.smoothing_steps) - print("Generating Triangular Mesh...") + # Tolerance for the initial Delaunay insertion — helps with + # "Could not insert point" from near-degenerate geometry. + gmsh.option.setNumber("Mesh.ToleranceInitialDelaunay", self.tolerance_initial_delaunay) + + logger.info("Generating Triangular Mesh...") gmsh.model.mesh.generate(2) # Run explicit optimization passes after generation for higher quality. if self.optimization_cycles > 0: if self.verbosity > 0: - print(f"Running {self.optimization_cycles} Optimization Cycles (Relocate2D & Laplace2D)...") + logger.info(f"Running {self.optimization_cycles} Optimization Cycles (Relocate2D & Laplace2D)...") for i in range(self.optimization_cycles): if self.verbosity > 1: - print(f" -> Cycle {i+1}/{self.optimization_cycles}") + logger.info(f" -> Cycle {i+1}/{self.optimization_cycles}") # Moves nodes to improve element shape (compactness). gmsh.model.mesh.optimize("Relocate2D",niter=1) # Smooths the mesh to relax gradients (reduces drift). gmsh.model.mesh.optimize("Laplace2D",niter=1) + meshed_surface_tags = self._meshed_surface_tags(gmsh_map, clean_polys) + self.triangular_quality = self._collect_triangular_quality(meshed_surface_tags) + self.element_grid = self._collect_element_grid(clean_polys, meshed_surface_tags) if output_file: gmsh.write(output_file) - - node_tags, coords, _ = gmsh.model.mesh.getNodes() - nodes_3d = np.array(coords).reshape(-1, 3) - self.nodes = nodes_3d[:, :2] - self.node_tags = node_tags + + # --- Node extraction (domain-only) --- + # Do NOT use gmsh.model.mesh.getNodes() without args here. + # That returns nodes from all entities, including standalone 1D meshes + # on curves (e.g. field-only rivers) and any non-fragmented 2D surfaces. + # Those extra nodes can unintentionally constrain downstream Voronoi + # tessellation. + + def _is_embedded_row(row) -> bool: + val = row.get('embed', True) + if pd.isna(val): + return True + return bool(val) + + def _accumulate_nodes(dim: int, ent_tag: int, include_boundary: bool, tag_to_xy: dict[int, tuple[float, float]]): + nt, nc, _ = gmsh.model.mesh.getNodes(dim, int(ent_tag), includeBoundary=bool(include_boundary)) + if len(nt) == 0: + return + pts = np.array(nc, dtype=float).reshape(-1, 3) + for t, p in zip(nt, pts): + tt = int(t) + if tt not in tag_to_xy: + tag_to_xy[tt] = (float(p[0]), float(p[1])) + + tag_to_xy: dict[int, tuple[float, float]] = {} + + # 1) Surfaces of the meshed domain: embedded polygons plus + # straddle/structured-buffer strips (their nodes are Voronoi + # generators too). Field-only surfaces are excluded. + domain_surface_tags = self._meshed_surface_tags(gmsh_map, clean_polys) + + # If we cannot determine domain surfaces from the map, fall back to + # all 2D nodes (still avoids 1D-only nodes). + if not domain_surface_tags: + node_tags, coords, _ = gmsh.model.mesh.getNodes(2, -1, includeBoundary=True) + nodes_3d = np.array(coords, dtype=float).reshape(-1, 3) + self.nodes = nodes_3d[:, :2] + self.node_tags = node_tags + else: + for s in domain_surface_tags: + _accumulate_nodes(2, s, True, tag_to_xy) + + # 2) Embedded constraints (optional safety) + if clean_points is not None and not clean_points.empty and 'embed' in clean_points.columns: + for fid, row in clean_points.iterrows(): + if not _is_embedded_row(row): + continue + if int(fid) in gmsh_map.get('points', {}): + for dimtag in gmsh_map['points'][int(fid)]: + if isinstance(dimtag, (tuple, list)) and len(dimtag) >= 2 and int(dimtag[0]) == 0: + _accumulate_nodes(0, int(dimtag[1]), True, tag_to_xy) + + if clean_lines is not None and not clean_lines.empty and 'embed' in clean_lines.columns: + for fid, row in clean_lines.iterrows(): + if not _is_embedded_row(row): + continue + + if int(fid) in gmsh_map.get('lines', {}): + for dimtag in gmsh_map['lines'][int(fid)]: + if isinstance(dimtag, (tuple, list)) and len(dimtag) >= 2 and int(dimtag[0]) == 1: + _accumulate_nodes(1, int(dimtag[1]), True, tag_to_xy) + # Straddle/barrier lines may have been converted into points. + elif int(fid) in gmsh_map.get('points', {}): + for dimtag in gmsh_map['points'][int(fid)]: + if isinstance(dimtag, (tuple, list)) and len(dimtag) >= 2 and int(dimtag[0]) == 0: + _accumulate_nodes(0, int(dimtag[1]), True, tag_to_xy) + + # Finalize de-duplicated node arrays + node_tags = np.array(list(tag_to_xy.keys()), dtype=np.uint64) + nodes_xy = np.array([tag_to_xy[int(t)] for t in node_tags], dtype=float) + self.nodes = nodes_xy + self.node_tags = node_tags + self.zones_gdf = clean_polys - + if launch_gmsh_gui: + gmsh.fltk.run() self._finalize_gmsh() return True except Exception as e: - print(f"Mesh Generation Failed: {e}") + logger.info(f"Mesh Generation Failed: {e}") self._finalize_gmsh() - raise e \ No newline at end of file + raise e diff --git a/src/vorflow/fields.py b/src/vorflow/fields.py new file mode 100644 index 0000000..fdd8165 --- /dev/null +++ b/src/vorflow/fields.py @@ -0,0 +1,409 @@ +from __future__ import annotations + +import logging +import math +import operator +import warnings + +logger = logging.getLogger(__name__) + + +DEFAULT_GROWTH_FACTOR = 1.2 +_GROWTH_MODELS = {"edge_ratio", "continuous_metric"} + + +def _positive_finite(value, name): + """Return ``value`` as a positive finite float or raise a clear error.""" + try: + value = float(value) + except (TypeError, ValueError) as exc: + raise ValueError(f"{name} must be a positive finite number. Got {value!r}.") from exc + if not math.isfinite(value) or value <= 0.0: + raise ValueError(f"{name} must be a positive finite number. Got {value!r}.") + return value + + +def _positive_integer(value, name): + """Return ``value`` as a positive integer without silently truncating it.""" + if isinstance(value, bool): + raise ValueError(f"{name} must be a positive integer. Got {value!r}.") + try: + value = operator.index(value) + except TypeError as exc: + raise ValueError(f"{name} must be a positive integer. Got {value!r}.") from exc + if value <= 0: + raise ValueError(f"{name} must be a positive integer. Got {value!r}.") + return int(value) + + +def _growth_gradient(growth_factor, growth_model): + """Convert an adjacent-size growth factor to a spatial size gradient.""" + try: + growth_factor = float(growth_factor) + except (TypeError, ValueError) as exc: + raise ValueError( + f"growth_factor must be a finite number greater than 1.0. Got {growth_factor!r}." + ) from exc + if not math.isfinite(growth_factor) or growth_factor <= 1.0: + raise ValueError( + f"growth_factor must be a finite number greater than 1.0. Got {growth_factor!r}." + ) + if not isinstance(growth_model, str) or growth_model not in _GROWTH_MODELS: + choices = ", ".join(sorted(_GROWTH_MODELS)) + raise ValueError(f"growth_model must be one of: {choices}. Got {growth_model!r}.") + if growth_model == "edge_ratio": + return growth_factor, growth_factor - 1.0 + return growth_factor, math.log(growth_factor) + + +class MeshField: + """ + Base class for all mesh size fields. + """ + def create(self, gmsh_api, tags_dict, background_lc, feature_lc=None): + """ + Creates the Gmsh field(s) and returns the field ID. + + Args: + gmsh_api: The gmsh module. + tags_dict (dict): Dictionary of tags {'points': [], 'lines': [], 'surfaces': []}. + background_lc (float): Global background mesh size. + feature_lc (float, optional): The target resolution of the specific feature group. + """ + raise NotImplementedError("Subclasses must implement create()") + + def __eq__(self, other): + """Equality check for grouping.""" + return isinstance(other, self.__class__) and self.__dict__ == other.__dict__ + + def __hash__(self): + """Hash for dictionary keys.""" + # Create a tuple of sorted item pairs to ensure consistent hashing + return hash((self.__class__.__name__, tuple(sorted(self.__dict__.items())))) + + +class DistanceField(MeshField): + """Creates a Gmsh Distance field from points/lines/surfaces tags. + + Internal — not part of the public API. This is a raw building block + (distance-to-feature, not a mesh size) combined by the size fields via + _distance_tags_for_growth(). Its create() signature differs from + MeshField's, so it cannot be passed as a user field via ``fields=``. + """ + + def __init__(self, include_surfaces=True, sampling=20): + self.include_surfaces = bool(include_surfaces) + self.sampling = int(sampling) + + def create(self, gmsh_api, tags_dict): + f_dist = gmsh_api.model.mesh.field.add("Distance") + + has_entities = False + if tags_dict.get('points'): + gmsh_api.model.mesh.field.setNumbers(f_dist, "PointsList", tags_dict['points']) + has_entities = True + if tags_dict.get('lines'): + gmsh_api.model.mesh.field.setNumbers(f_dist, "CurvesList", tags_dict['lines']) + gmsh_api.model.mesh.field.setNumber(f_dist, 'Sampling', self.sampling) + has_entities = True + if self.include_surfaces and tags_dict.get('surfaces'):#TODO check if loops needed + gmsh_api.model.mesh.field.setNumbers(f_dist, "SurfacesList", tags_dict['surfaces']) + gmsh_api.model.mesh.field.setNumber(f_dist, 'Sampling', self.sampling) + has_entities = True + + if not has_entities: + gmsh_api.model.mesh.field.remove(f_dist) + return None + + return f_dist + + +def _surface_boundary_curves(gmsh_api, surface_tags): + """Return boundary curve tags for the given surface tags.""" + curves = [] + seen = set() + for tag in surface_tags: + try: + boundary = gmsh_api.model.getBoundary( + [(2, int(tag))], + combined=False, + oriented=False, + recursive=False, + ) + except Exception: + boundary = [] + + for dim, curve_tag in boundary: + if int(dim) != 1: + continue + curve_tag = int(curve_tag) + if curve_tag not in seen: + seen.add(curve_tag) + curves.append(curve_tag) + return curves + + +def _polygon_surface_tags(tags_dict): + embedded_surfaces = tags_dict.get("embedded_surfaces", None) + if embedded_surfaces is None: + embedded_surfaces = tags_dict.get("surfaces", []) + + field_only_surfaces = tags_dict.get("field_only_surfaces", []) + seen = set() + surface_tags = [] + for tag in list(embedded_surfaces) + list(field_only_surfaces): + tag = int(tag) + if tag not in seen: + seen.add(tag) + surface_tags.append(tag) + return surface_tags + + +def _distance_tags_for_growth(gmsh_api, tags_dict, sampling): + """Build tags for distance growth while keeping polygon interiors flat.""" + polygon_surfaces = _polygon_surface_tags(tags_dict) + boundary_curves = _surface_boundary_curves(gmsh_api, polygon_surfaces) + + growth_tags = { + "points": list(tags_dict.get("points", [])), + "lines": list(tags_dict.get("lines", [])) + boundary_curves, + "surfaces": [], + } + + # If no boundary curves could be recovered, fall back to the old surface + # distance behavior instead of dropping the field. + if polygon_surfaces and not boundary_curves: + logger.warning( + "Warning: could not recover boundary curves for a polygon size " + "field; falling back to surface-distance growth." + ) + growth_tags["surfaces"].extend(polygon_surfaces) + + return DistanceField(include_surfaces=True, sampling=sampling).create( + gmsh_api, growth_tags + ) + + +def _polygon_surface_constant(gmsh_api, surface_tags, size, background_lc): + if not surface_tags: + return None + + const = gmsh_api.model.mesh.field.add("Constant") + gmsh_api.model.mesh.field.setNumber(const, "VIn", float(size)) + gmsh_api.model.mesh.field.setNumber(const, "VOut", float(background_lc)) + # Field-only polygon surfaces are not domain partitions, but Gmsh can + # still evaluate a spatial constant field inside their geometry. + gmsh_api.model.mesh.field.setNumbers( + const, "SurfacesList", [float(t) for t in surface_tags] + ) + return const + + +def _combine_with_polygon_surface_constant( + gmsh_api, growth_field, tags_dict, size, background_lc +): + constant = _polygon_surface_constant( + gmsh_api, _polygon_surface_tags(tags_dict), size, background_lc + ) + if constant is None: + return growth_field + if growth_field is None: + return constant + + f_min = gmsh_api.model.mesh.field.add("Min") + gmsh_api.model.mesh.field.setNumbers( + f_min, "FieldsList", [float(growth_field), float(constant)] + ) + return f_min + +# --- Manual Fields --- + +class ConstantField(MeshField): + """Internal — not part of the public API. + + Used by the engine to set the global background size (which users control + through ``background_lc``). Not useful as a per-feature field: create() + ignores ``tags_dict``, so it cannot scope a size to a feature. Polygon + interior constants are handled by the internal + _polygon_surface_constant() helper because they need SurfacesList scoping + and are combined with a growth field. + """ + + def __init__(self, size): + self.size = float(size) + + def create(self, gmsh_api, tags_dict, background_lc, feature_lc=None): + const = gmsh_api.model.mesh.field.add("Constant") + gmsh_api.model.mesh.field.setNumber(const, "VIn", self.size) + gmsh_api.model.mesh.field.setNumber(const, "VOut", background_lc) + return const + + +class ThresholdField(MeshField): + def __init__(self, size_min, dist_min, dist_max, size_max=None, sampling=20): + self.size_min = float(size_min) + self.dist_min = float(dist_min) + self.dist_max = float(dist_max) + self.size_max = float(size_max) if size_max is not None else None + self.sampling = int(sampling) + def create(self, gmsh_api, tags_dict, background_lc, feature_lc=None): + # 1. Distance field for growth away from features. For polygon + # surfaces, use boundary curves for growth and add a spatial constant + # field below so the polygon interior remains flat. + f_dist = _distance_tags_for_growth(gmsh_api, tags_dict, self.sampling) + if f_dist is None: + return _combine_with_polygon_surface_constant( + gmsh_api, None, tags_dict, self.size_min, background_lc + ) + + # 2. Threshold Field + f_thresh = gmsh_api.model.mesh.field.add("Threshold") + gmsh_api.model.mesh.field.setNumber(f_thresh, "InField", f_dist) + gmsh_api.model.mesh.field.setNumber(f_thresh, "SizeMin", self.size_min) + gmsh_api.model.mesh.field.setNumber(f_thresh, "SizeMax", self.size_max if self.size_max else background_lc) + gmsh_api.model.mesh.field.setNumber(f_thresh, "DistMin", self.dist_min) + gmsh_api.model.mesh.field.setNumber(f_thresh, "DistMax", self.dist_max) + + return _combine_with_polygon_surface_constant( + gmsh_api, f_thresh, tags_dict, self.size_min, background_lc + ) + +class ExponentialField(MeshField): + """Exponential transition controlled by a physical decay length. + + The field is ``H - (H - size_min) * exp(-d / decay_length)``. Its maximum + gradient occurs at the feature and equals ``(H - size_min) / decay_length``. + To keep that gradient below an edge-ratio bound ``r - 1``, choose + ``decay_length >= (H - size_min) / (r - 1)``. + """ + + def __init__(self, size_min, decay_length, size_max=None, sampling=20): + self.size_min = _positive_finite(size_min, "size_min") + self.decay_length = _positive_finite(decay_length, "decay_length") + self.size_max = ( + _positive_finite(size_max, "size_max") if size_max is not None else None + ) + if self.size_max is not None and self.size_max < self.size_min: + raise ValueError("size_max must be greater than or equal to size_min.") + self.sampling = _positive_integer(sampling, "sampling") + + def create(self, gmsh_api, tags_dict, background_lc, feature_lc=None): + background_lc = _positive_finite(background_lc, "background_lc") + s_max = self.size_max if self.size_max is not None else background_lc + if s_max < self.size_min: + raise ValueError( + "background_lc must be greater than or equal to size_min when size_max is omitted." + ) + + f_dist = _distance_tags_for_growth(gmsh_api, tags_dict, self.sampling) + if f_dist is None: + return _combine_with_polygon_surface_constant( + gmsh_api, None, tags_dict, self.size_min, background_lc + ) + + f_math = gmsh_api.model.mesh.field.add("MathEval") + expr = f"{s_max} - ({s_max} - {self.size_min}) * Exp(-F{f_dist} / {self.decay_length})" + gmsh_api.model.mesh.field.setString(f_math, "F", expr) + return _combine_with_polygon_surface_constant( + gmsh_api, f_math, tags_dict, self.size_min, background_lc + ) + +# --- Automatic growth fields --- + + +class GeometricGrowthField(MeshField): + """Grade target edge length away from a feature with a bounded gradient. + + ``growth_factor`` describes geometric characteristic-length growth by + element index. The Gmsh field is deliberately linear in physical distance: + + - ``edge_ratio`` uses gradient ``growth_factor - 1``; + - ``continuous_metric`` uses gradient ``log(growth_factor)``. + + Normal ``MeshGenerator`` use caps the result at ``background_lc`` through + the engine's global ``Min`` field. A direct low-level call to ``create()`` + returns the uncapped growth field. + """ + + def __init__( + self, + growth_factor=DEFAULT_GROWTH_FACTOR, + growth_model="edge_ratio", + sampling=20, + ): + self.growth_factor, self.gradient = _growth_gradient( + growth_factor, growth_model + ) + self.growth_model = growth_model + self.sampling = _positive_integer(sampling, "sampling") + + def create( + self, + gmsh_api, + tags_dict, + background_lc, + feature_lc=None, + sampling=None, + ): + if feature_lc is None: + return None + + cs = _positive_finite(feature_lc, "feature_lc") + cs_dom = _positive_finite(background_lc, "background_lc") + if cs >= cs_dom: + return None + + distance_sampling = ( + self.sampling + if sampling is None + else _positive_integer(sampling, "sampling") + ) + + f_dist = _distance_tags_for_growth(gmsh_api, tags_dict, distance_sampling) + if f_dist is None: + return _combine_with_polygon_surface_constant( + gmsh_api, None, tags_dict, cs, background_lc + ) + + f_math = gmsh_api.model.mesh.field.add("MathEval") + gradient = format(self.gradient, ".15g") + expr = f"{cs} + {gradient} * F{f_dist}" + + gmsh_api.model.mesh.field.setString(f_math, "F", expr) + return _combine_with_polygon_surface_constant( + gmsh_api, f_math, tags_dict, cs, background_lc + ) + + +class AutoExponentialField(GeometricGrowthField): + """Deprecated compatibility name for :class:`GeometricGrowthField`.""" + + def __init__( + self, + growth_factor=DEFAULT_GROWTH_FACTOR, + growth_model="edge_ratio", + sampling=20, + ): + warnings.warn( + "AutoExponentialField is deprecated; use GeometricGrowthField instead.", + DeprecationWarning, + stacklevel=2, + ) + super().__init__(growth_factor, growth_model, sampling) + + +class AutoLinearField(GeometricGrowthField): + """Deprecated compatibility name for :class:`GeometricGrowthField`.""" + + def __init__( + self, + growth_factor=DEFAULT_GROWTH_FACTOR, + sampling=20, + growth_model="edge_ratio", + ): + warnings.warn( + "AutoLinearField is deprecated; use GeometricGrowthField instead.", + DeprecationWarning, + stacklevel=2, + ) + super().__init__(growth_factor, growth_model, sampling) diff --git a/src/vorflow/tessellator.py b/src/vorflow/tessellator.py index f373cdf..76c09b4 100644 --- a/src/vorflow/tessellator.py +++ b/src/vorflow/tessellator.py @@ -1,14 +1,29 @@ +from __future__ import annotations + +import logging +import warnings import numpy as np import geopandas as gpd import pandas as pd -import gmsh -from scipy.spatial import Voronoi -from shapely.geometry import Polygon, Point, LineString, MultiPolygon +from scipy.spatial import Voronoi, cKDTree +from shapely.geometry import Polygon, Point, MultiPolygon from shapely.ops import unary_union, split from shapely.validation import make_valid +logger = logging.getLogger(__name__) + + class VoronoiTessellator: - def __init__(self, mesh_generator, conceptual_mesh,clip_to_boundary=True): + def __init__( + self, + mesh_generator, + conceptual_mesh, + clip_to_boundary=True, + boundary_centering="clip", + boundary_inset_fraction=0.5, + boundary_corner_angle=135.0, + boundary_tolerance=None, + ): """ Initializes the Voronoi tessellator. @@ -23,7 +38,26 @@ def __init__(self, mesh_generator, conceptual_mesh,clip_to_boundary=True): domain boundaries, and feature information. clip_to_boundary (bool): If True, the final Voronoi grid will be clipped to the domain boundary defined in the conceptual model. + boundary_centering (str): ``"clip"`` keeps the historical behavior. + ``"inset_mirror"`` shifts boundary generators inward and adds + mirrored outside ghosts so boundary-cell centers move off the + clipped face. + boundary_inset_fraction (float): Fraction of local boundary-node + spacing used for the inward shift in ``"inset_mirror"`` mode. + boundary_corner_angle (float): Boundary vertices with a local angle + below this value are treated as sharp corners and left unchanged. + boundary_tolerance (float, optional): Distance tolerance used to + classify generator nodes as boundary nodes. """ + if boundary_centering not in {"clip", "inset_mirror"}: + raise ValueError("boundary_centering must be either 'clip' or 'inset_mirror'.") + if boundary_inset_fraction <= 0: + raise ValueError("boundary_inset_fraction must be positive.") + if boundary_corner_angle <= 0 or boundary_corner_angle >= 180: + raise ValueError("boundary_corner_angle must be between 0 and 180 degrees.") + if boundary_tolerance is not None and boundary_tolerance < 0: + raise ValueError("boundary_tolerance must be non-negative when provided.") + self.mg = mesh_generator self.cm = conceptual_mesh self.voronoi_gdf = None @@ -32,6 +66,183 @@ def __init__(self, mesh_generator, conceptual_mesh,clip_to_boundary=True): self.node_tags = mesh_generator.node_tags self.zones_gdf = mesh_generator.zones_gdf self.clip_to_boundary = clip_to_boundary + self.boundary_centering = boundary_centering + self.boundary_inset_fraction = float(boundary_inset_fraction) + self.boundary_corner_angle = float(boundary_corner_angle) + self.boundary_tolerance = boundary_tolerance + + def _domain_geometry(self): + """Return the current meshing domain geometry.""" + if not self.cm.clean_polygons.empty: + domain_geom = unary_union(self.cm.clean_polygons.geometry) + if not domain_geom.is_valid: + domain_geom = make_valid(domain_geom) + return domain_geom + if hasattr(self.cm, 'domain_boundary') and self.cm.domain_boundary: + domain_geom = self.cm.domain_boundary + if not domain_geom.is_valid: + domain_geom = make_valid(domain_geom) + return domain_geom + return None + + def _boundary_tolerance(self, nodes, domain_geom): + if self.boundary_tolerance is not None: + return float(self.boundary_tolerance) + minx, miny, maxx, maxy = domain_geom.bounds + domain_scale = max(maxx - minx, maxy - miny, 1.0) + node_scale = 1.0 + if len(nodes) > 0: + node_scale = max(np.ptp(nodes[:, 0]), np.ptp(nodes[:, 1]), 1.0) + return max(domain_scale, node_scale) * 1e-8 + + def _ring_angle_at_point(self, point, domain_geom, tolerance): + """Return the local ring angle for a boundary vertex, if matched.""" + polygons = [] + if isinstance(domain_geom, Polygon): + polygons = [domain_geom] + elif isinstance(domain_geom, MultiPolygon): + polygons = list(domain_geom.geoms) + + for poly in polygons: + rings = [poly.exterior, *poly.interiors] + for ring in rings: + coords = list(ring.coords) + if len(coords) < 4: + continue + open_coords = coords[:-1] + for i, coord in enumerate(open_coords): + if Point(coord).distance(point) > tolerance: + continue + prev_coord = np.asarray(open_coords[i - 1], dtype=float) + current = np.asarray(coord, dtype=float) + next_coord = np.asarray(open_coords[(i + 1) % len(open_coords)], dtype=float) + v1 = prev_coord - current + v2 = next_coord - current + mag1 = np.linalg.norm(v1) + mag2 = np.linalg.norm(v2) + if mag1 == 0 or mag2 == 0: + return None + cos_theta = np.dot(v1, v2) / (mag1 * mag2) + cos_theta = min(1.0, max(-1.0, cos_theta)) + return float(np.degrees(np.arccos(cos_theta))) + return None + + def _is_sharp_boundary_corner(self, point, domain_geom, tolerance): + angle = self._ring_angle_at_point(point, domain_geom, tolerance) + return angle is not None and angle < self.boundary_corner_angle + + def _local_boundary_tangent(self, boundary, point, spacing): + distance = boundary.project(point) + eps = max(spacing * 0.25, boundary.length * 1e-9, 1e-9) + before = max(0.0, distance - eps) + after = min(boundary.length, distance + eps) + if before == after: + before = max(0.0, distance - 1e-9) + after = min(boundary.length, distance + 1e-9) + p1 = boundary.interpolate(before) + p2 = boundary.interpolate(after) + tangent = np.array([p2.x - p1.x, p2.y - p1.y], dtype=float) + norm = np.linalg.norm(tangent) + if norm == 0: + return None + return tangent / norm + + def _inward_normal(self, domain_geom, point, tangent, offset): + normals = [ + np.array([-tangent[1], tangent[0]], dtype=float), + np.array([tangent[1], -tangent[0]], dtype=float), + ] + probe_distance = max(offset * 0.5, 1e-9) + for normal in normals: + probe = Point(point.x + normal[0] * probe_distance, point.y + normal[1] * probe_distance) + if domain_geom.covers(probe): + return normal + return None + + def _prepare_boundary_centered_nodes(self, nodes, node_tags): + """ + Shift non-corner boundary nodes inward and add mirrored outside ghosts. + + Returns prepared nodes, prepared tags, and a metadata frame keyed by + node_id. Tags only cover real nodes; appended ghosts receive -1 in + _build_raw_voronoi. + """ + if self.boundary_centering != "inset_mirror": + metadata = pd.DataFrame( + { + "node_id": node_tags, + "source_x": nodes[:, 0], + "source_y": nodes[:, 1], + "boundary_centering": "clip", + "boundary_inset": 0.0, + "boundary_centered": False, + } + ) + return nodes, node_tags, np.empty((0, 2)), metadata + + domain_geom = self._domain_geometry() + if domain_geom is None or domain_geom.is_empty: + raise RuntimeError( + "boundary_centering='inset_mirror' requires a generated domain geometry." + ) + + boundary = domain_geom.boundary + tolerance = self._boundary_tolerance(nodes, domain_geom) + points = [Point(float(x), float(y)) for x, y in nodes] + boundary_mask = np.array([boundary.distance(point) <= tolerance for point in points]) + boundary_indices = np.flatnonzero(boundary_mask) + + prepared = nodes.astype(float, copy=True) + ghost_nodes = [] + records = [] + + if len(boundary_indices) > 1: + boundary_xy = nodes[boundary_indices] + # Nearest distinct-neighbor spacing via a KD-tree instead of the + # previous dense N x N distance matrix (quadratic memory). + # Querying k=2 against the de-duplicated coordinates returns the + # node's own coordinate (distance 0) and the nearest *different* + # coordinate, matching the old nearest-nonzero semantics exactly. + unique_xy = np.unique(boundary_xy, axis=0) + if len(unique_xy) > 1: + dists, _ = cKDTree(unique_xy).query(boundary_xy, k=2) + nearest_spacing = dists[:, 1] + else: + nearest_spacing = np.full(len(boundary_xy), np.nan) + spacing_by_index = { + int(idx): float(spacing) + for idx, spacing in zip(boundary_indices, nearest_spacing) + if not np.isnan(spacing) and spacing > 0 + } + else: + spacing_by_index = {} + + for i, (node, tag, point) in enumerate(zip(nodes, node_tags, points)): + centered = False + inset = 0.0 + if i in spacing_by_index and not self._is_sharp_boundary_corner(point, domain_geom, tolerance): + spacing = spacing_by_index[i] + inset = spacing * self.boundary_inset_fraction + tangent = self._local_boundary_tangent(boundary, point, spacing) + normal = None if tangent is None else self._inward_normal(domain_geom, point, tangent, inset) + if normal is not None: + prepared[i] = node + normal * inset + ghost_nodes.append(node - normal * inset) + centered = True + + records.append( + { + "node_id": tag, + "source_x": float(node[0]), + "source_y": float(node[1]), + "boundary_centering": "inset_mirror" if centered else "clip", + "boundary_inset": float(inset if centered else 0.0), + "boundary_centered": bool(centered), + } + ) + + ghosts = np.asarray(ghost_nodes, dtype=float) if ghost_nodes else np.empty((0, 2)) + return prepared, node_tags, ghosts, pd.DataFrame(records) def _build_raw_voronoi(self, nodes, node_tags): """ @@ -50,7 +261,12 @@ def _build_raw_voronoi(self, nodes, node_tags): columns for the generator's node_id, x, and y coordinates. """ if len(nodes) < 3: - print("Error: Not enough nodes to generate Voronoi.") + warnings.warn( + "Not enough generator nodes (<3) to build a Voronoi diagram; " + "returning an empty grid. Check that meshing succeeded and " + "the domain is not degenerate.", + stacklevel=2, + ) return gpd.GeoDataFrame() vor = Voronoi(nodes) @@ -108,19 +324,26 @@ def _enforce_barriers(self, grid_gdf): # We only need to cut barriers that were NOT handled by the "straddle" # method in the mesh generator. Straddled barriers are already aligned. - mask_barrier = self.cm.clean_lines['is_barrier'] == True + # fillna keeps the old `== True` semantics: rows with a missing + # is_barrier value are treated as non-barriers, not as errors. + mask_barrier = self.cm.clean_lines['is_barrier'].fillna(False).astype(bool) if 'straddle_width' in self.cm.clean_lines.columns: mask_no_straddle = (self.cm.clean_lines['straddle_width'].isna()) | (self.cm.clean_lines['straddle_width'] <= 0) else: mask_no_straddle = True + + if 'quad_buffer' in self.cm.clean_lines.columns: + mask_no_quad_buffer = ~self.cm.clean_lines['quad_buffer'].fillna(False).astype(bool) + else: + mask_no_quad_buffer = True - barriers_to_cut = self.cm.clean_lines[mask_barrier & mask_no_straddle] + barriers_to_cut = self.cm.clean_lines[mask_barrier & mask_no_straddle & mask_no_quad_buffer] if barriers_to_cut.empty: return grid_gdf - print(f"Enforcing Barrier Cuts on {len(barriers_to_cut)} lines (Straddle lines skipped)...") + logger.info(f"Enforcing Barrier Cuts on {len(barriers_to_cut)} lines (Straddle lines skipped)...") current_grid = grid_gdf @@ -176,7 +399,7 @@ def _enforce_barriers(self, grid_gdf): cells_to_keep.extend(valid_pieces) except Exception as e: - print(f"Warning: Failed to split cell {cell_row['node_id']}: {e}") + logger.warning(f"Warning: Failed to split cell {cell_row['node_id']}: {e}") # Rebuild the grid with the split cells. if cells_to_remove_indices: @@ -202,11 +425,21 @@ def generate(self): gpd.GeoDataFrame: The final, clean Voronoi grid. """ if self.nodes is None or len(self.nodes) == 0: - print("Error: No nodes found in MeshGenerator.") + warnings.warn( + "No nodes found in MeshGenerator; returning an empty grid. " + "Did MeshGenerator.generate() run successfully?", + stacklevel=2, + ) return gpd.GeoDataFrame() - print(f"Extracting {len(self.nodes)} Nodes from Gmsh...") + logger.info(f"Extracting {len(self.nodes)} Nodes from Gmsh...") nodes, tags = self.nodes, self.node_tags + nodes = np.asarray(nodes, dtype=float) + tags = np.asarray(tags) + if len(tags) != len(nodes): + raise ValueError("MeshGenerator nodes and node_tags must have the same length.") + + nodes, tags, boundary_ghost_nodes, node_metadata = self._prepare_boundary_centered_nodes(nodes, tags) # To create a bounded Voronoi diagram from a finite set of points, a common # technique is to add "ghost" nodes far outside the area of interest. The @@ -223,30 +456,30 @@ def generate(self): [minx - buffer, maxy + buffer] ]) - combined_nodes = np.vstack([nodes, ghost_nodes]) + combined_nodes = np.vstack([nodes, boundary_ghost_nodes, ghost_nodes]) - print("Computing Mathematical Voronoi...") + logger.info("Computing Mathematical Voronoi...") raw_gdf = self._build_raw_voronoi(combined_nodes, tags) - print(f" -> Raw Polygons: {len(raw_gdf)}") + logger.info(f" -> Raw Polygons: {len(raw_gdf)}") # Remove the cells generated by the ghost nodes. raw_gdf = raw_gdf[raw_gdf['node_id'] != -1] - print(f" -> After Ghost Filter: {len(raw_gdf)}") + logger.info(f" -> After Ghost Filter: {len(raw_gdf)}") if raw_gdf.crs is None and self.cm.crs: raw_gdf.set_crs(self.cm.crs, inplace=True) if self.clip_to_boundary: - print("Clipping to Domain Boundary...") - if not self.cm.clean_polygons.empty: - domain_geom = unary_union(self.cm.clean_polygons.geometry) - if not domain_geom.is_valid: - domain_geom = make_valid(domain_geom) - elif hasattr(self.cm, 'domain_boundary') and self.cm.domain_boundary: - domain_geom = self.cm.domain_boundary - else: - print("Error: No domain geometry found (no polygons).") + logger.info("Clipping to Domain Boundary...") + domain_geom = self._domain_geometry() + if domain_geom is None: + warnings.warn( + "No domain geometry found (no polygons); returning an " + "empty grid. Add at least one embedded polygon to the " + "ConceptualMesh, or use clip_to_boundary=False.", + stacklevel=2, + ) return gpd.GeoDataFrame() domain_gdf = gpd.GeoDataFrame( @@ -255,15 +488,15 @@ def generate(self): ) bounded_voronoi = gpd.clip(raw_gdf, domain_gdf) - print(f" -> After Domain Clip: {len(bounded_voronoi)}") + logger.info(f" -> After Domain Clip: {len(bounded_voronoi)}") if len(bounded_voronoi) == 0: - print("Warning: Clipping resulted in 0 cells. Check CRS or Domain Box.") + logger.warning("Warning: Clipping resulted in 0 cells. Check CRS or Domain Box.") return bounded_voronoi else: bounded_voronoi = raw_gdf - print("Enforcing Hydrogeological Zones (Optimization: Point Sampling)...") + logger.info("Enforcing Hydrogeological Zones (Optimization: Point Sampling)...") zones = self.cm.clean_polygons[['geometry', 'zone_id', 'z_order']] # To assign a zone ID to each Voronoi cell, we perform a spatial join @@ -294,15 +527,21 @@ def generate(self): on='node_id', how='left' ) + if self.boundary_centering == "inset_mirror": + zoned_grid = zoned_grid.merge( + node_metadata, + on="node_id", + how="left", + ) - print(f" -> Zones Assigned: {len(zoned_grid)}") + logger.info(f" -> Zones Assigned: {len(zoned_grid)}") # Clipping can sometimes create MultiPolygons; explode them into single parts. zoned_grid = zoned_grid.explode(index_parts=True).reset_index(drop=True) # Enforce barriers by splitting cells. self.final_grid = self._enforce_barriers(zoned_grid) - print(f" -> After Barrier Cuts: {len(self.final_grid)}") + logger.info(f" -> After Barrier Cuts: {len(self.final_grid)}") # Final cleanup after potential splits. self.final_grid = self.final_grid.explode(index_parts=True).reset_index(drop=True) @@ -313,12 +552,12 @@ def generate(self): self.final_grid['centroid_x'] = self.final_grid.geometry.centroid.x self.final_grid['centroid_y'] = self.final_grid.geometry.centroid.y - print(f"Final Voronoi Grid Generated: {len(self.final_grid)} cells.") + logger.info(f"Final Voronoi Grid Generated: {len(self.final_grid)} cells.") return self.final_grid def export_to_shapefile(self, filepath): if self.final_grid is not None and not self.final_grid.empty: self.final_grid.to_file(filepath) - print(f"Saved to {filepath}") + logger.info(f"Saved to {filepath}") else: - print("No grid to export.") \ No newline at end of file + logger.info("No grid to export.") diff --git a/src/vorflow/utils.py b/src/vorflow/utils.py index 1820bb3..5a022a9 100644 --- a/src/vorflow/utils.py +++ b/src/vorflow/utils.py @@ -1,7 +1,293 @@ +from __future__ import annotations + +import logging +import warnings + import numpy as np import geopandas as gpd import pandas as pd -from shapely.geometry import LineString, Polygon, MultiPolygon +from shapely.geometry import LineString, MultiLineString, Point, Polygon, MultiPolygon + + +logger = logging.getLogger(__name__) + + +CONNECTIVITY_COLUMNS = [ + "cell_id_1", + "cell_id_2", + "orig_index_1", + "orig_index_2", + "node_id_1", + "node_id_2", + "center_mode", + "center_1", + "center_2", + "angle", + "ortho_error", + "skewness", + "connector", + "shared_edge", +] + + +def _empty_connectivity(crs=None): + return gpd.GeoDataFrame( + columns=CONNECTIVITY_COLUMNS, + geometry="shared_edge", + crs=crs, + ) + + +def _longest_line(geom): + """Return the longest line component from a shared-boundary geometry.""" + if geom.is_empty: + return None + if isinstance(geom, LineString): + return geom if geom.length > 0 else None + if isinstance(geom, MultiLineString): + lines = [line for line in geom.geoms if line.length > 0] + return max(lines, key=lambda line: line.length) if lines else None + if hasattr(geom, "geoms"): + lines = [] + for part in geom.geoms: + line = _longest_line(part) + if line is not None: + lines.append(line) + return max(lines, key=lambda line: line.length) if lines else None + return None + + +def _representative_point_on_geometry(geom): + """Return a point suitable for projection onto a connector line.""" + if geom.is_empty: + return None + if isinstance(geom, Point): + return geom + if isinstance(geom, LineString): + return geom.interpolate(0.5, normalized=True) + if hasattr(geom, "geoms"): + for part in geom.geoms: + point = _representative_point_on_geometry(part) + if point is not None: + return point + centroid = geom.centroid + return centroid if isinstance(centroid, Point) and not centroid.is_empty else None + + +def _center_point(row, center): + if center == "generator": + return Point(float(row["x"]), float(row["y"])) + if center == "centroid": + return row.geometry.centroid + raise ValueError("center must be either 'generator' or 'centroid'.") + + +def build_connectivity(gdf: gpd.GeoDataFrame, center: str = "generator") -> gpd.GeoDataFrame: + """ + Build a per-face connectivity report for a polygonal grid. + + ``center="generator"`` uses the ``x`` and ``y`` columns and reports the + mathematical Voronoi-dual connectivity. ``center="centroid"`` uses polygon + centroids and reports MODFLOW-facing cell-center connectivity for exported + cells. ``angle`` is the connector-vs-shared-face angle in degrees, with an + ideal value of 90. ``ortho_error`` is the corresponding orthogonality error, + with an ideal value of 0. ``skewness`` is the fractional position along the + connector where the shared face crosses, with an ideal value of 0.5. + ``cell_id_1`` and ``cell_id_2`` are zero-based row positions in ``gdf`` and + are therefore unique even when the GeoDataFrame index is not. ``orig_index_1`` + and ``orig_index_2`` preserve the input index for traceability. The active + geometry is ``shared_edge``; ``connector`` stores the center-to-center line. + """ + if center not in {"generator", "centroid"}: + raise ValueError("center must be either 'generator' or 'centroid'.") + + required = {"geometry"} + if center == "generator": + required.update({"x", "y"}) + missing = required.difference(gdf.columns) + if missing: + raise ValueError( + f"build_connectivity missing required columns: {sorted(missing)}; " + f"required columns for center='{center}': {sorted(required)}" + ) + + if gdf.empty: + return _empty_connectivity(gdf.crs) + + df = gdf.copy() + df["__cell_id"] = np.arange(len(df), dtype=np.int64) + df["__orig_index"] = df.index + df = df.reset_index(drop=True) + + neighbors = gpd.sjoin(df, df, how="inner", predicate="touches") + pairs = neighbors[neighbors.index < neighbors.index_right].copy() + + records = [] + for left_idx, pair in pairs.iterrows(): + right_idx = int(pair["index_right"]) + left = df.loc[left_idx] + right = df.loc[right_idx] + + shared_edge = _longest_line(left.geometry.intersection(right.geometry)) + if shared_edge is None: + continue + + center_1 = _center_point(left, center) + center_2 = _center_point(right, center) + if center_1.is_empty or center_2.is_empty: + continue + + x1, y1 = float(center_1.x), float(center_1.y) + x2, y2 = float(center_2.x), float(center_2.y) + gx = x2 - x1 + gy = y2 - y1 + gmag = np.sqrt(gx * gx + gy * gy) + if gmag == 0: + continue + + coords = list(shared_edge.coords) + if len(coords) < 2: + continue + + ex = coords[-1][0] - coords[0][0] + ey = coords[-1][1] - coords[0][1] + emag = np.sqrt(ex * ex + ey * ey) + if emag == 0: + continue + + cos_theta = abs(gx * ex + gy * ey) / (gmag * emag) + cos_theta = min(1.0, max(0.0, cos_theta)) + angle = float(np.degrees(np.arccos(cos_theta))) + ortho_error = abs(90.0 - angle) + + connector = LineString([(x1, y1), (x2, y2)]) + crossing = connector.intersection(shared_edge) + point = _representative_point_on_geometry(crossing) + if point is None: + point = shared_edge.interpolate(0.5, normalized=True) + skewness = float(connector.project(point) / connector.length) + + record = { + "cell_id_1": int(left["__cell_id"]), + "cell_id_2": int(right["__cell_id"]), + "orig_index_1": left["__orig_index"], + "orig_index_2": right["__orig_index"], + "center_mode": center, + "center_1": center_1, + "center_2": center_2, + "angle": angle, + "ortho_error": float(ortho_error), + "skewness": skewness, + "connector": connector, + "shared_edge": shared_edge, + } + if "node_id" in df.columns: + record["node_id_1"] = left["node_id"] + record["node_id_2"] = right["node_id"] + records.append(record) + + if not records: + return _empty_connectivity(gdf.crs) + + return gpd.GeoDataFrame(records, geometry="shared_edge", crs=gdf.crs) + + +def boundary_connectivity_report( + grid_gdf: gpd.GeoDataFrame, + domain_geom, + *, + center: str = "centroid", + tolerance: float | None = None, +) -> gpd.GeoDataFrame: + """ + Connectivity report restricted to pairs touching the domain boundary. + + Runs :func:`build_connectivity` on ``grid_gdf`` and keeps only the rows + where at least one of the two cells touches the boundary of + ``domain_geom``. Useful to compare the boundary-cell angle/orthogonality + distribution between ``boundary_centering="clip"`` and ``"inset_mirror"`` + runs of the tessellator. ``center="centroid"`` is the meaningful mode for + that comparison: with ``center="generator"`` Voronoi faces are exact + perpendicular bisectors and always report 90 degrees. + + ``tolerance`` defaults to a domain-bbox-scaled value matching the + tessellator's boundary-node classification. + """ + if domain_geom is None or domain_geom.is_empty: + raise ValueError("boundary_connectivity_report requires a non-empty domain geometry.") + if tolerance is None: + minx, miny, maxx, maxy = domain_geom.bounds + tolerance = max(maxx - minx, maxy - miny, 1.0) * 1e-8 + elif tolerance < 0: + raise ValueError("tolerance must be non-negative when provided.") + + connectivity = build_connectivity(grid_gdf, center=center) + if connectivity.empty: + return connectivity + + boundary = domain_geom.boundary + distances = grid_gdf.geometry.reset_index(drop=True).distance(boundary) + boundary_cells = set(np.flatnonzero(distances.to_numpy() <= tolerance)) + + mask = connectivity["cell_id_1"].isin(boundary_cells) | connectivity["cell_id_2"].isin( + boundary_cells + ) + return connectivity[mask].reset_index(drop=True) + + +def _validate_connectivity_report( + connectivity: gpd.GeoDataFrame, + n_cells: int, + *, + require_ortho: bool = False, + require_skewness: bool = False, +) -> None: + required = {"cell_id_1", "cell_id_2"} + if require_ortho: + required.add("ortho_error") + if require_skewness: + required.add("skewness") + + missing = required.difference(connectivity.columns) + if missing: + raise ValueError( + f"connectivity missing required columns: {sorted(missing)}; " + f"required columns for requested metrics: {sorted(required)}" + ) + + if connectivity.empty: + return + + cell_ids = pd.concat( + [connectivity["cell_id_1"], connectivity["cell_id_2"]], + ignore_index=True, + ) + numeric_ids = pd.to_numeric(cell_ids, errors="coerce") + if numeric_ids.isna().any(): + raise ValueError("connectivity cell_id_1/cell_id_2 must be integer row positions.") + + int_ids = numeric_ids.astype(np.int64) + if not np.array_equal(numeric_ids.to_numpy(), int_ids.to_numpy()): + raise ValueError("connectivity cell_id_1/cell_id_2 must be integer row positions.") + + if (int_ids < 0).any() or (int_ids >= n_cells).any(): + raise ValueError( + "connectivity cell_id_1/cell_id_2 values must align to zero-based " + "row positions in the input GeoDataFrame." + ) + + +def _max_pair_metric_by_cell(connectivity: gpd.GeoDataFrame, metric: pd.Series, n_cells: int) -> np.ndarray: + values = np.zeros(n_cells, dtype=float) + if connectivity.empty: + return values + + s1 = metric.groupby(connectivity["cell_id_1"]).max() + s2 = metric.groupby(connectivity["cell_id_2"]).max() + combined = pd.concat([s1, s2], axis=1).max(axis=1) + for cell_id, value in combined.items(): + values[int(cell_id)] = float(value) + return values def calculate_orthogonality(gdf: gpd.GeoDataFrame) -> pd.Series: """ @@ -126,7 +412,12 @@ def calculate_orthogonality(gdf: gpd.GeoDataFrame) -> pd.Series: return final_series -def calculate_mesh_quality(gdf: gpd.GeoDataFrame, calc_ortho: bool = False) -> gpd.GeoDataFrame: +def calculate_mesh_quality( + gdf: gpd.GeoDataFrame, + calc_ortho: bool = False, + calc_skewness: bool = False, + connectivity: gpd.GeoDataFrame | None = None, +) -> gpd.GeoDataFrame: """ Calculates a suite of geometric quality metrics for a Voronoi grid. @@ -135,6 +426,13 @@ def calculate_mesh_quality(gdf: gpd.GeoDataFrame, calc_ortho: bool = False) -> g It is expected to have 'x' and 'y' columns for the generator points. calc_ortho (bool): If True, the orthogonality error will be calculated. This is a more expensive calculation and is disabled by default. + calc_skewness (bool): If True, the maximum per-cell skewness error + ``abs(pair_skewness - 0.5)`` will be calculated. Disabled by default. + connectivity (GeoDataFrame, optional): A precomputed report from + ``build_connectivity(gdf, center=...)``. It must include + ``cell_id_1`` and ``cell_id_2`` as zero-based row positions in + ``gdf`` plus ``ortho_error`` and/or ``skewness`` for the requested + metrics. When provided, it is reused for per-cell aggregation. Returns: gpd.GeoDataFrame: The input GeoDataFrame with added columns for each @@ -154,7 +452,19 @@ def calculate_mesh_quality(gdf: gpd.GeoDataFrame, calc_ortho: bool = False) -> g # convex hull. A perfectly convex polygon has a convexity of 1.0. df['convexity'] = df['area'] / df.geometry.convex_hull.area - # 4. Generator-based metrics (require generator point coordinates). + connectivity_report = None + if connectivity is not None: + connectivity_report = connectivity + _validate_connectivity_report( + connectivity_report, + len(df), + require_ortho=calc_ortho, + require_skewness=calc_skewness, + ) + elif calc_skewness and 'x' in df.columns and 'y' in df.columns: + connectivity_report = build_connectivity(df, center="generator") + + # 4. Generator-based drift metrics (require generator point coordinates). if 'x' in df.columns and 'y' in df.columns: centroids = df.geometry.centroid dx = df['x'] - centroids.x @@ -163,9 +473,27 @@ def calculate_mesh_quality(gdf: gpd.GeoDataFrame, calc_ortho: bool = False) -> g df['centroid_dist'] = np.sqrt(dx*dx + dy*dy) # A non-dimensional measure of the generator/centroid drift. df['drift_ratio'] = df['centroid_dist'] / np.sqrt(df['area']) - - if calc_ortho: + + if calc_ortho: + if connectivity_report is not None and 'ortho_error' in connectivity_report.columns: + df['ortho_error'] = _max_pair_metric_by_cell( + connectivity_report, + connectivity_report['ortho_error'], + len(df), + ) + elif 'x' in df.columns and 'y' in df.columns: df['ortho_error'] = calculate_orthogonality(df) + + if calc_skewness: + if connectivity_report is None or connectivity_report.empty: + df['skewness'] = 0.0 + else: + skew_error = (connectivity_report['skewness'] - 0.5).abs() + df['skewness'] = _max_pair_metric_by_cell( + connectivity_report, + skew_error, + len(df), + ) return df @@ -178,8 +506,8 @@ def summarize_quality(gdf: gpd.GeoDataFrame): if 'compactness' not in gdf.columns: gdf = calculate_mesh_quality(gdf, calc_ortho=False) - print("\n--- Mesh Quality Report ---") - print(f"Total Cells: {len(gdf)}") + logger.info("\n--- Mesh Quality Report ---") + logger.info(f"Total Cells: {len(gdf)}") # 1. Distinguish between internal and boundary cells. # A simple heuristic is that for a boundary cell, its generator point @@ -196,59 +524,61 @@ def summarize_quality(gdf: gpd.GeoDataFrame): internal_df = gdf[~is_boundary] boundary_df = gdf[is_boundary] - print(f" - Internal Cells: {len(internal_df)}") - print(f" - Boundary Cells: {len(boundary_df)}") + logger.info(f" - Internal Cells: {len(internal_df)}") + logger.info(f" - Boundary Cells: {len(boundary_df)}") metrics = ['area', 'compactness', 'convexity'] if 'drift_ratio' in gdf.columns: metrics.append('drift_ratio') if 'ortho_error' in gdf.columns: metrics.append('ortho_error') + if 'skewness' in gdf.columns: + metrics.append('skewness') - print("\n-- Internal Cells Statistics --") + logger.info("\n-- Internal Cells Statistics --") if not internal_df.empty: stats_in = internal_df[metrics].describe(percentiles=[0.05, 0.5, 0.95]) - print(stats_in.T[['min', '5%', '50%', '95%', 'max']].to_string()) + logger.info(stats_in.T[['min', '5%', '50%', '95%', 'max']].to_string()) else: - print("No internal cells.") + logger.info("No internal cells.") - print("\n-- Boundary Cells Statistics --") + logger.info("\n-- Boundary Cells Statistics --") if not boundary_df.empty: stats_bnd = boundary_df[metrics].describe(percentiles=[0.05, 0.5, 0.95]) - print(stats_bnd.T[['min', '5%', '50%', '95%', 'max']].to_string()) + logger.info(stats_bnd.T[['min', '5%', '50%', '95%', 'max']].to_string()) else: - print("No boundary cells.") + logger.info("No boundary cells.") # Provide some diagnostic warnings based on common quality thresholds. - print("\n--- Diagnostics ---") + logger.info("\n--- Diagnostics ---") # Internal cells should be high quality. if not internal_df.empty: slivers = len(internal_df[internal_df['compactness'] < 0.6]) if slivers > 0: - print(f"[WARNING] {slivers} INTERNAL cells have low compactness (< 0.6).") + logger.info(f"[WARNING] {slivers} INTERNAL cells have low compactness (< 0.6).") if 'drift_ratio' in internal_df.columns: high_drift = len(internal_df[internal_df['drift_ratio'] > 0.25]) if high_drift > 0: - print(f"[WARNING] {high_drift} INTERNAL cells have high drift (> 0.25).") + logger.info(f"[WARNING] {high_drift} INTERNAL cells have high drift (> 0.25).") else: - print("[OK] Internal drift is excellent.") + logger.info("[OK] Internal drift is excellent.") # Boundary cells have different geometric norms. if not boundary_df.empty: # Boundary cells are naturally less compact. bad_bnd = len(boundary_df[boundary_df['compactness'] < 0.4]) if bad_bnd > 0: - print(f"[WARNING] {bad_bnd} BOUNDARY cells are potential slivers (< 0.4).") + logger.info(f"[WARNING] {bad_bnd} BOUNDARY cells are potential slivers (< 0.4).") # Boundary cells also have a naturally higher drift. if 'drift_ratio' in boundary_df.columns: high_drift_bnd = len(boundary_df[boundary_df['drift_ratio'] > 0.45]) if high_drift_bnd > 0: - print(f"[WARNING] {high_drift_bnd} BOUNDARY cells have excessive drift (> 0.45).") + logger.info(f"[WARNING] {high_drift_bnd} BOUNDARY cells have excessive drift (> 0.45).") else: - print("[OK] Boundary drift is within geometric norms (~0.34).") + logger.info("[OK] Boundary drift is within geometric norms (~0.34).") def check_geometry_resolution(gdf): @@ -287,7 +617,18 @@ def check_geometry_resolution(gdf): all_lengths.extend(dists) if not all_lengths: - return "No valid segments found." + warnings.warn( + "check_geometry_resolution: no valid segments found in the " + "GeoDataFrame; returning empty statistics.", + stacklevel=2, + ) + return { + "min": float("nan"), + "max": float("nan"), + "mean": float("nan"), + "median": float("nan"), + "count": 0, + } all_lengths = np.array(all_lengths) return { @@ -340,4 +681,4 @@ def resample_geometry(geom, target_spacing): parts = [resample_geometry(p, target_spacing) for p in geom.geoms] return MultiPolygon(parts) - return geom \ No newline at end of file + return geom diff --git a/src/vorflow/viz.py b/src/vorflow/viz.py deleted file mode 100644 index e69de29..0000000 diff --git a/src/vorflow/vorflow.code-workspace b/src/vorflow/vorflow.code-workspace deleted file mode 100644 index 0844037..0000000 --- a/src/vorflow/vorflow.code-workspace +++ /dev/null @@ -1,7 +0,0 @@ -{ - "folders": [ - { - "path": "../.." - } - ] -} \ No newline at end of file diff --git a/tests/conftest.py b/tests/conftest.py new file mode 100644 index 0000000..62db945 --- /dev/null +++ b/tests/conftest.py @@ -0,0 +1,17 @@ +"""Shared pytest fixtures for the vorflow test suite.""" +import gmsh +import pytest + + +@pytest.fixture(autouse=True) +def ensure_gmsh_finalized(): + """Ensure gmsh is finalized before and after each test. + + Gmsh keeps global state; a test that fails mid-run would otherwise leak + an initialized session (with its model contents) into the next test. + """ + if gmsh.is_initialized(): + gmsh.finalize() + yield + if gmsh.is_initialized(): + gmsh.finalize() diff --git a/tests/test_buffer.py b/tests/test_buffer.py new file mode 100644 index 0000000..812dacb --- /dev/null +++ b/tests/test_buffer.py @@ -0,0 +1,699 @@ +import warnings + +import gmsh +import pytest +from shapely.geometry import LineString, Polygon, box + +from vorflow import ConceptualMesh, MeshGenerator, VoronoiTessellator + +pytestmark = pytest.mark.slow # gmsh-heavy end-to-end tests + + + +def _generate_line_buffer_mesh(*, thickness=1, add_crossing_line=False, return_context=False): + cm = ConceptualMesh(crs=None) + cm.add_polygon( + box(0, 0, 10, 4), + zone_id="domain", + resolution=1.0, + densify=True, + ) + cm.add_line( + LineString([(0, 2), (10, 2)]), + line_id="buffered-line", + resolution=1.0, + is_barrier=True, + quad_buffer=True, + quad_buffer_thickness=thickness, + dist_min=0.5, + dist_max=2.0, + ) + if add_crossing_line: + cm.add_line( + LineString([(5, 0), (5, 4)]), + line_id="crossing-line", + resolution=0.5, + is_barrier=False, + dist_min=0.5, + dist_max=1.5, + ) + + clean_polys, clean_lines, clean_points = cm.generate() + mesher = MeshGenerator( + background_lc=1.5, + verbosity=0, + smoothing_steps=0, + optimization_cycles=0, + ) + assert mesher.generate(clean_polys, clean_lines, clean_points) + # A successful run must actually produce mesh nodes covering the domain. + assert mesher.nodes is not None and len(mesher.nodes) > 0 + element_area = mesher.get_element_grid().geometry.area.sum() + domain_area = clean_polys.geometry.area.sum() + assert element_area == pytest.approx(domain_area, rel=1e-2) + if return_context: + return mesher, cm + return mesher + + +def test_line_structured_quad_buffer_produces_mixed_element_grid(): + mesher = _generate_line_buffer_mesh(thickness=1) + element_grid = mesher.get_element_grid() + quads = mesher.get_element_grid("quads") + triangles = mesher.get_element_grid("triangles") + + assert not element_grid.empty + assert not quads.empty + assert not triangles.empty + assert len(quads) + len(triangles) == len(element_grid) + assert quads["is_quad"].all() + assert quads["centroid_y"].between(1.45, 2.55).all() + # Quads inside the domain must receive a valid zone assignment. + assert quads["zone_id"].notna().all() + assert quads["zone_id"].eq("domain").all() + # A thickness-1 strip on a length-10 line at lc=1 is a single structured + # row of ~10 quads, not an arbitrary recombination. + assert 7 <= len(quads) <= 14 + + +def test_line_structured_quad_buffer_thickness_controls_quad_band_area(): + thin = _generate_line_buffer_mesh(thickness=1).get_element_grid("quads") + thick = _generate_line_buffer_mesh(thickness=2).get_element_grid("quads") + + assert not thin.empty + assert not thick.empty + assert thick.geometry.area.sum() > thin.geometry.area.sum() + + +def test_structured_quad_buffer_protects_crossing_feature_corridor(): + baseline_quads = _generate_line_buffer_mesh(thickness=1).get_element_grid("quads") + if gmsh.is_initialized(): + gmsh.finalize() + + mesher = _generate_line_buffer_mesh(thickness=1, add_crossing_line=True) + quads = mesher.get_element_grid("quads") + triangles = mesher.get_element_grid("triangles") + + assert not quads.empty + # The crossing standard line is trimmed out of the strip corridor, so the + # strip interior stays quad-dominated. (The crossing line's size field may + # still grade into the strip and leave a couple of split triangles, but no + # feature nodes are injected.) + strip_interior = LineString([(0, 2), (10, 2)]).buffer(0.4, cap_style=2) + strip_quads = quads[quads.geometry.centroid.within(strip_interior)] + strip_triangles = triangles[triangles.geometry.centroid.within(strip_interior)] + assert len(strip_quads) >= 8 + assert len(strip_triangles) <= max(2, len(strip_quads) // 4) + # The strip structure is preserved despite the crossing feature. + assert abs(len(quads) - len(baseline_quads)) <= max(2, int(0.25 * len(baseline_quads))) + + +def test_curved_line_buffer_produces_structured_quads(): + cm = ConceptualMesh(crs=None) + cm.add_polygon(box(0, 0, 10, 6), zone_id="domain", resolution=1.0, densify=True) + line = LineString([(1, 2), (5, 4), (9, 2)]) + cm.add_line( + line, + line_id="curved", + resolution=1.0, + is_barrier=True, + quad_buffer=True, + quad_buffer_thickness=1, + dist_min=0.5, + dist_max=2.0, + ) + clean_polys, clean_lines, clean_points = cm.generate() + mesher = MeshGenerator(background_lc=1.5, verbosity=0, smoothing_steps=0, optimization_cycles=0) + + with warnings.catch_warnings(record=True) as caught: + warnings.simplefilter("always") + assert mesher.generate(clean_polys, clean_lines, clean_points) + degradations = [ + w for w in caught if "transfinite" in str(w.message) or "recombine-only" in str(w.message) + ] + assert not degradations, [str(w.message) for w in degradations] + + quads = mesher.get_element_grid("quads") + assert not quads.empty + assert quads["is_quad"].all() + # A full structured row of quads hugs the whole curved line. + assert quads.geometry.centroid.apply(lambda p: line.distance(p) < 0.75).all() + assert len(quads) >= round(line.length) - 3 + + +def test_crossing_quad_buffers_are_protected_and_warn(): + cm = ConceptualMesh(crs=None) + cm.add_polygon(box(0, 0, 10, 4), zone_id="domain", resolution=1.0, densify=True) + cm.add_line( + LineString([(0, 2), (10, 2)]), + line_id="horizontal", + resolution=1.0, + is_barrier=True, + quad_buffer=True, + quad_buffer_thickness=1, + ) + cm.add_line( + LineString([(5, 0), (5, 4)]), + line_id="vertical", + resolution=1.0, + is_barrier=True, + quad_buffer=True, + quad_buffer_thickness=1, + ) + clean_polys, clean_lines, clean_points = cm.generate() + mesher = MeshGenerator(background_lc=1.5, verbosity=0, smoothing_steps=0, optimization_cycles=0) + + with pytest.warns(UserWarning, match="crosses a higher-priority protected feature"): + assert mesher.generate(clean_polys, clean_lines, clean_points) + + quads = mesher.get_element_grid("quads") + assert not quads.empty + # Equal z_order/lc/thickness: the horizontal line was added first, so it + # wins the tie-break and stays continuous THROUGH the crossing (one-sided + # trimming) while the vertical one is trimmed there. + winner_at_crossing = quads[ + (quads["centroid_y"].sub(2).abs() < 0.5) & (quads["centroid_x"].sub(5).abs() < 0.6) + ] + assert not winner_at_crossing.empty + horizontal_arm = quads[ + (quads["centroid_y"].sub(2).abs() < 0.5) & (quads["centroid_x"].sub(5).abs() > 1) + ] + vertical_arm = quads[ + (quads["centroid_x"].sub(5).abs() < 0.5) & (quads["centroid_y"].sub(2).abs() > 1) + ] + assert not horizontal_arm.empty + assert not vertical_arm.empty + + +def test_transfinite_survives_fragmentation(): + cm = ConceptualMesh(crs=None) + cm.add_polygon(box(0, 0, 10, 4), zone_id="domain", resolution=1.0, densify=True) + line = LineString([(1, 2), (9, 2)]) + cm.add_line( + line, + line_id="buffered", + resolution=1.0, + is_barrier=True, + quad_buffer=True, + quad_buffer_thickness=1, + ) + cm.add_line( + LineString([(5, 0), (5, 4)]), + line_id="crossing-standard", + resolution=0.5, + is_barrier=False, + ) + clean_polys, clean_lines, clean_points = cm.generate() + mesher = MeshGenerator(background_lc=1.5, verbosity=0, smoothing_steps=0, optimization_cycles=0) + + with warnings.catch_warnings(record=True) as caught: + warnings.simplefilter("always") + assert mesher.generate(clean_polys, clean_lines, clean_points) + degradations = [ + w for w in caught if "transfinite" in str(w.message) or "recombine-only" in str(w.message) + ] + assert not degradations, [str(w.message) for w in degradations] + + quads = mesher.get_element_grid("quads") + assert not quads.empty + # Structured rows: near-uniform quad areas and a count matching length/lc. + areas = quads.geometry.area + assert areas.std() / areas.mean() < 0.35 + assert round(line.length) - 2 <= len(quads) <= round(line.length) + 4 + + +def test_structured_quad_buffer_barrier_is_not_cut_again_by_tessellator(): + mesher, cm = _generate_line_buffer_mesh(thickness=1, return_context=True) + + tessellator = VoronoiTessellator(mesher, cm, clip_to_boundary=True) + grid = tessellator.generate() + + assert len(grid) == len(mesher.node_tags) + + +def test_polygon_structured_quad_buffer_produces_quads(): + cm = ConceptualMesh(crs=None) + cm.add_polygon( + box(0, 0, 10, 6), + zone_id="domain", + resolution=1.5, + densify=True, + ) + cm.add_polygon( + Polygon([(3, 2), (7, 2), (7, 4), (3, 4)]), + zone_id="inner", + resolution=1.0, + z_order=1, + densify=True, + quad_buffer=True, + quad_buffer_thickness=1, + ) + clean_polys, clean_lines, clean_points = cm.generate() + + mesher = MeshGenerator( + background_lc=1.5, + verbosity=0, + smoothing_steps=0, + optimization_cycles=0, + ) + # Polygon bands are recombine-only by design (annulus), which must not be + # reported as a degradation. + with warnings.catch_warnings(record=True) as caught: + warnings.simplefilter("always") + assert mesher.generate(clean_polys, clean_lines, clean_points) + degradations = [ + w for w in caught if "transfinite" in str(w.message) or "recombine-only" in str(w.message) + ] + assert not degradations, [str(w.message) for w in degradations] + + quads = mesher.get_element_grid("quads") + assert not quads.empty + + +def test_node_extraction_covers_all_regions_split_by_buffer_strip(): + # A full-width strip crossing an inner zone splits the domain into pieces + # OCC's fragment map can drop (regression: all generators above the strip + # were lost, producing giant merged-looking Voronoi cells). + cm = ConceptualMesh(crs=None) + cm.add_polygon(box(0, 0, 12, 7), zone_id="domain", resolution=1.5, densify=True) + cm.add_polygon( + Polygon([(4, 2), (8, 2), (8, 5), (4, 5)]), + zone_id="inner-zone", + resolution=1.0, + z_order=1, + densify=True, + ) + cm.add_line( + LineString([(0, 3.5), (12, 3.5)]), + line_id="fault-buffer", + resolution=1.0, + is_barrier=True, + quad_buffer=True, + quad_buffer_thickness=1, + ) + clean_polys, clean_lines, clean_points = cm.generate() + mesher = MeshGenerator(background_lc=1.5, verbosity=0, smoothing_steps=0, optimization_cycles=0) + assert mesher.generate(clean_polys, clean_lines, clean_points) + + element_grid = mesher.get_element_grid() + corner_xy = { + (round(x, 6), round(y, 6)) + for geom in element_grid.geometry + for x, y in geom.exterior.coords[:-1] + } + node_xy = {(round(float(x), 6), round(float(y), 6)) for x, y in mesher.nodes} + missing = corner_xy - node_xy + assert not missing, f"{len(missing)} gmsh mesh nodes missing from Voronoi generators" + + +def test_strip_crossing_embedded_zone_stays_transfinite(): + # Regression: a strip split by an embedded zone boundary degraded to + # recombined triangles. Pieces are now re-cornered from the offset side + # lines and kept transfinite, and densified ring vertices falling inside + # the strip are pushed onto its boundary so the caps stay single curves. + cm = ConceptualMesh(crs=None) + cm.add_polygon(box(0, 0, 12, 7), zone_id="domain", resolution=1.5, densify=True) + cm.add_polygon( + Polygon([(4, 2), (8, 2), (8, 5), (4, 5)]), + zone_id="inner", + resolution=1.0, + z_order=1, + densify=True, + ) + cm.add_line( + LineString([(0, 3.5), (12, 3.5)]), + line_id="fault", + resolution=1.0, + is_barrier=True, + quad_buffer=True, + quad_buffer_thickness=1, + ) + clean_polys, clean_lines, clean_points = cm.generate() + mesher = MeshGenerator(background_lc=1.5, verbosity=0, smoothing_steps=0, optimization_cycles=0) + with warnings.catch_warnings(record=True) as caught: + warnings.simplefilter("always") + assert mesher.generate(clean_polys, clean_lines, clean_points) + degradations = [ + w for w in caught if "transfinite" in str(w.message) or "recombine-only" in str(w.message) + ] + assert not degradations, [str(w.message) for w in degradations] + + quads = mesher.get_element_grid("quads") + triangles = mesher.get_element_grid("triangles") + strip = LineString([(0, 3.5), (12, 3.5)]).buffer(0.4, cap_style=2) + assert triangles[triangles.geometry.centroid.within(strip)].empty + # One structured row of ~12 quads along the 12-length fault. + assert 10 <= len(quads) <= 16 + + +def test_size_field_attached_to_quad_buffer_line_refines_halo(): + # Regression: distance-growth fields on quad_buffer lines were silently + # dropped because the strip surfaces were not listed as embedded surfaces. + # An explicit geometric-growth field must still grade the halo outward from the + # strip (now also the default behavior -- see test_default_field_*). + from vorflow.fields import GeometricGrowthField + + cm = ConceptualMesh(crs=None) + cm.add_polygon(box(0, 0, 20, 12), zone_id="domain", resolution=4.0, densify=True) + cm.add_line( + LineString([(4, 6), (16, 6)]), + line_id="buffered", + resolution=0.5, + quad_buffer=True, + quad_buffer_thickness=1, + fields=[GeometricGrowthField(growth_factor=1.2)], + ) + clean_polys, clean_lines, clean_points = cm.generate() + mesher = MeshGenerator(background_lc=4.0, verbosity=0, smoothing_steps=0, optimization_cycles=0) + assert mesher.generate(clean_polys, clean_lines, clean_points) + + grid = mesher.get_element_grid() + cent = grid.geometry.centroid + # The halo grades element size outward from the strip: elements just off the + # strip are smaller than those out near the coarse domain edge. If the field + # were dropped (the regression), sizes would be uniform. + near = grid[cent.y.sub(6).abs().between(1.0, 3.0)] + far = grid[cent.y.sub(6).abs() > 4.5] + assert not near.empty and not far.empty + assert near.geometry.area.mean() < far.geometry.area.mean() + + +def _generate_polygon_buffer_voronoi(thickness): + zone = Polygon([(3, 3), (9, 3), (9, 7), (3, 7)]) + cm = ConceptualMesh(crs=None) + cm.add_polygon(box(0, 0, 12, 10), zone_id="domain", resolution=1.0, densify=False) + cm.add_polygon( + zone, + zone_id="inner", + resolution=1.0, + z_order=1, + densify=True, + quad_buffer=True, + quad_buffer_thickness=thickness, + ) + clean_polys, clean_lines, clean_points = cm.generate() + mesher = MeshGenerator(background_lc=1.0, verbosity=0, smoothing_steps=0, optimization_cycles=0) + assert mesher.generate(clean_polys, clean_lines, clean_points) + grid = VoronoiTessellator(mesher, cm, clip_to_boundary=True).generate() + return zone, grid + + +def test_polygon_quad_buffer_thickness1_faces_follow_boundary(): + # The zone outline never becomes mesh edges: a single quad row straddles it + # (nodes at +/- lc/2), so the Voronoi faces trace the shapefile shape and + # no cell straddles the outline. + zone, grid = _generate_polygon_buffer_voronoi(1) + centroids = grid.geometry.centroid + assert (centroids.distance(zone.exterior) < 0.05).sum() == 0 + inside_frac = grid.geometry.intersection(zone).area / grid.geometry.area + crossing = ((inside_frac > 0.03) & (inside_frac < 0.97)).sum() + assert crossing == 0 + + +def test_polygon_quad_buffer_thickness2_centers_cells_on_boundary(): + # Two quad rows put a node row on the outline, giving a ring of ~square + # (lc x lc) Voronoi cells centered on the shape. + zone, grid = _generate_polygon_buffer_voronoi(2) + centroids = grid.geometry.centroid + ring = grid[centroids.distance(zone.exterior) < 0.05] + perimeter = zone.exterior.length + assert 0.65 * perimeter <= len(ring) <= 1.35 * perimeter + assert abs(ring.geometry.area.mean() - 1.0) < 0.15 + + +def test_line_quad_buffer_thickness2_produces_square_cells_on_line(): + line = LineString([(1, 5), (11, 5)]) + cm = ConceptualMesh(crs=None) + cm.add_polygon(box(0, 0, 12, 10), zone_id="domain", resolution=1.0, densify=False) + cm.add_line( + line, + line_id="drain", + resolution=1.0, + quad_buffer=True, + quad_buffer_thickness=2, + ) + clean_polys, clean_lines, clean_points = cm.generate() + mesher = MeshGenerator(background_lc=1.0, verbosity=0, smoothing_steps=0, optimization_cycles=0) + assert mesher.generate(clean_polys, clean_lines, clean_points) + grid = VoronoiTessellator(mesher, cm, clip_to_boundary=True).generate() + + on_line = grid[grid.geometry.centroid.distance(line) < 0.05] + assert round(line.length) - 2 <= len(on_line) <= round(line.length) + 3 + areas = on_line.geometry.area + assert areas.std() / areas.mean() < 0.2 + + +def test_narrow_zone_quad_buffer_falls_back_with_warning(): + cm = ConceptualMesh(crs=None) + cm.add_polygon(box(0, 0, 12, 10), zone_id="domain", resolution=1.0, densify=False) + cm.add_polygon( + Polygon([(3, 4.7), (9, 4.7), (9, 5.3), (3, 5.3)]), + zone_id="sliver", + resolution=1.0, + z_order=1, + densify=True, + quad_buffer=True, + quad_buffer_thickness=1, + ) + clean_polys, clean_lines, clean_points = cm.generate() + mesher = MeshGenerator(background_lc=1.0, verbosity=0, smoothing_steps=0, optimization_cycles=0) + with pytest.warns(UserWarning, match="too narrow for a quad_buffer band"): + assert mesher.generate(clean_polys, clean_lines, clean_points) + assert not mesher.get_element_grid().empty + + +def test_buffer_surfaces_do_not_double_mesh_crossing_configuration(): + # Regression: OCC fragment silently refused to cut overlapping faces when a + # trimmed line strip crossed a trimmed polygon band, leaving the domain and + # zone surfaces triangulated on top of the strip quads (duplicate nodes, + # junk Voronoi cells). Embedded polygon surfaces are now built disjoint + # from every buffer footprint, so the elements tile the domain exactly. + cm = ConceptualMesh(crs=None) + cm.add_polygon(box(0, 0, 12, 10), zone_id="domain", resolution=1.0, densify=False) + cm.add_polygon( + Polygon([(3, 3), (9, 3), (9, 7), (3, 7)]), + zone_id="inner", + resolution=1.0, + z_order=1, + densify=True, + quad_buffer=True, + quad_buffer_thickness=1, + ) + cm.add_line( + LineString([(0, 5), (12, 5)]), + line_id="fault", + resolution=1.0, + quad_buffer=True, + quad_buffer_thickness=1, + ) + clean_polys, clean_lines, clean_points = cm.generate() + mesher = MeshGenerator(background_lc=1.5, verbosity=0, smoothing_steps=0, optimization_cycles=0) + # The inner zone has z_order=1, so it wins and stays continuous; the fault + # line (z_order=0) is the lower-priority feature trimmed at the crossing. + with pytest.warns(UserWarning, match="crosses a higher-priority protected feature"): + assert mesher.generate(clean_polys, clean_lines, clean_points) + + element_grid = mesher.get_element_grid() + assert abs(element_grid.geometry.area.sum() - 120.0) < 0.01 + + +def test_quad_buffer_thickness_is_validated(): + cm = ConceptualMesh(crs=None) + + with pytest.raises(ValueError, match="quad_buffer_thickness"): + cm.add_line( + LineString([(0, 0), (1, 0)]), + line_id="bad", + resolution=1.0, + quad_buffer=True, + quad_buffer_thickness=3, + ) + + with pytest.raises(ValueError, match="quad_buffer_thickness"): + cm.add_polygon( + box(0, 0, 1, 1), + zone_id="bad", + resolution=1.0, + quad_buffer=True, + quad_buffer_thickness=0, + ) + + +def _crossing_line_and_band(line_lc=1.0, poly_z_order=0): + """A horizontal quad-buffered line crossing a quad-buffered polygon band. + + The domain is given z_order=-1 so the inner zone (z_order=poly_z_order, + defaulting to 0) survives overlap resolution while keeping a z_order equal to + the line's default 0 -- letting the finer-lc tie-break decide the winner. + """ + cm = ConceptualMesh(crs=None) + cm.add_polygon(box(0, 0, 12, 10), zone_id="domain", resolution=1.0, z_order=-1, densify=True) + cm.add_polygon( + Polygon([(4, 3), (8, 3), (8, 7), (4, 7)]), + zone_id="inner", + resolution=1.0, + z_order=poly_z_order, + densify=True, + quad_buffer=True, + quad_buffer_thickness=1, + ) + cm.add_line( + LineString([(0, 5), (12, 5)]), + line_id="fault", + resolution=line_lc, + quad_buffer=True, + quad_buffer_thickness=1, + ) + clean_polys, clean_lines, clean_points = cm.generate() + mesher = MeshGenerator(background_lc=1.5, verbosity=0, smoothing_steps=0, optimization_cycles=0) + return cm, mesher, (clean_polys, clean_lines, clean_points) + + +def test_crossing_priority_finer_lc_wins(): + # The line (lc=0.5) is finer than the band (lc=1.0), so it wins the priority + # and stays continuous; the band is the one trimmed at the crossing. + _, mesher, clean = _crossing_line_and_band(line_lc=0.5) + with pytest.warns(UserWarning, match=r"polygon feature \d+ crosses a higher-priority"): + assert mesher.generate(*clean) + quads = mesher.get_element_grid("quads") + # The finer line strip runs continuously through the band region at y=5. + line_row = quads[quads["centroid_y"].sub(5).abs() < 0.4] + assert not line_row[line_row["centroid_x"].sub(6).abs() < 0.6].empty + + +def test_crossing_priority_z_order_override(): + # Same geometry, but z_order=10 on the polygon flips the winner: now the + # band stays continuous and the line is trimmed. + _, mesher, clean = _crossing_line_and_band(line_lc=1.0, poly_z_order=10) + with pytest.warns(UserWarning, match=r"line feature \d+ crosses a higher-priority"): + assert mesher.generate(*clean) + # Disjoint tiling is preserved regardless of which feature wins. + assert abs(mesher.get_element_grid().geometry.area.sum() - 120.0) < 0.01 + + +def test_winner_strip_stays_transfinite_through_crossing(): + # Two equal quad buffers cross; the first-added (winning) horizontal strip + # must keep its transfinite structure -- only the trimmed vertical loser may + # degrade to recombine-only. + cm = ConceptualMesh(crs=None) + cm.add_polygon(box(0, 0, 12, 8), zone_id="domain", resolution=1.0, densify=True) + # Interior winner (does not touch the domain boundary, so any degradation + # would come from the crossing, not boundary end caps). + cm.add_line( + LineString([(1, 4), (11, 4)]), + line_id="winner", + resolution=1.0, + quad_buffer=True, + quad_buffer_thickness=1, + ) + cm.add_line( + LineString([(6, 0), (6, 8)]), + line_id="loser", + resolution=1.0, + quad_buffer=True, + quad_buffer_thickness=1, + ) + clean_polys, clean_lines, clean_points = cm.generate() + mesher = MeshGenerator(background_lc=1.5, verbosity=0, smoothing_steps=0, optimization_cycles=0) + with warnings.catch_warnings(record=True) as caught: + warnings.simplefilter("always") + assert mesher.generate(clean_polys, clean_lines, clean_points) + winner_degraded = [ + w for w in caught + if ("transfinite" in str(w.message) or "recombine-only" in str(w.message)) + and "('line', 0)" in str(w.message) + ] + assert not winner_degraded, [str(w.message) for w in winner_degraded] + quads = mesher.get_element_grid("quads") + winner_row = quads[quads["centroid_y"].sub(4).abs() < 0.5] + # Continuous structured row through the crossing at x=6. + assert not winner_row[winner_row["centroid_x"].sub(6).abs() < 0.6].empty + + +def test_partial_crossing_t_junction_records_refinement(): + # A vertical buffer that terminates ON a horizontal buffer (a T-junction) + # must mesh cleanly, conserve area, and register a crossing refinement disk. + cm = ConceptualMesh(crs=None) + cm.add_polygon(box(0, 0, 12, 8), zone_id="domain", resolution=1.0, densify=True) + cm.add_line( + LineString([(0, 4), (12, 4)]), + line_id="trunk", + resolution=1.0, + quad_buffer=True, + quad_buffer_thickness=1, + ) + cm.add_line( + LineString([(6, 0), (6, 4)]), + line_id="branch", + resolution=1.0, + quad_buffer=True, + quad_buffer_thickness=1, + ) + clean_polys, clean_lines, clean_points = cm.generate() + mesher = MeshGenerator(background_lc=1.5, verbosity=0, smoothing_steps=0, optimization_cycles=0) + assert mesher.generate(clean_polys, clean_lines, clean_points) + assert abs(mesher.get_element_grid().geometry.area.sum() - 96.0) < 0.01 + assert len(mesher._quad_buffer_crossings) >= 1 + + +def test_tangential_overlap_drops_sliver(): + # A loser strip overlapping the winner's corridor at a shallow offset leaves + # a thin remnant that must be dropped (not meshed as a sliver surface). + cm = ConceptualMesh(crs=None) + cm.add_polygon(box(0, 0, 12, 8), zone_id="domain", resolution=1.0, densify=True) + cm.add_line( + LineString([(0, 4), (12, 4)]), + line_id="winner", + resolution=1.0, + quad_buffer=True, + quad_buffer_thickness=1, + ) + cm.add_line( + LineString([(0, 4.8), (12, 4.8)]), + line_id="loser", + resolution=1.0, + quad_buffer=True, + quad_buffer_thickness=1, + ) + clean_polys, clean_lines, clean_points = cm.generate() + mesher = MeshGenerator(background_lc=1.5, verbosity=0, smoothing_steps=0, optimization_cycles=0) + with pytest.warns(UserWarning, match=r"dropped \d+ sliver piece"): + assert mesher.generate(clean_polys, clean_lines, clean_points) + + +def test_crossing_refinement_limits_size_jump(): + # With a coarse background, the trimmed gap would fill with large triangles + # next to the dense strip rows. The Ball refinement field pins it to the + # feature size, so elements near the crossing stay close to lc, not + # background_lc. + lc = 1.0 + cm = ConceptualMesh(crs=None) + cm.add_polygon(box(0, 0, 12, 10), zone_id="domain", resolution=lc, densify=True) + cm.add_polygon( + Polygon([(4, 3), (8, 3), (8, 7), (4, 7)]), + zone_id="inner", + resolution=lc, + z_order=1, + densify=True, + quad_buffer=True, + quad_buffer_thickness=1, + ) + cm.add_line( + LineString([(0, 5), (12, 5)]), + line_id="fault", + resolution=lc, + quad_buffer=True, + quad_buffer_thickness=1, + ) + clean_polys, clean_lines, clean_points = cm.generate() + mesher = MeshGenerator(background_lc=3.0, verbosity=0, smoothing_steps=0, optimization_cycles=0) + assert mesher.generate(clean_polys, clean_lines, clean_points) + assert len(mesher._quad_buffer_crossings) >= 1 + + grid = mesher.get_element_grid() + centroids = grid.geometry.centroid + # Around the left crossing point (4, 5), elements stay near lc rather than + # jumping to the background size (area (3.0)**2 = 9). + near = grid[(centroids.x.sub(4).abs() < 1.5) & (centroids.y.sub(5).abs() < 1.5)] + assert not near.empty + assert near.geometry.area.max() < (1.6 * lc) ** 2 diff --git a/tests/test_check_dist.py b/tests/test_check_dist.py new file mode 100644 index 0000000..072736a --- /dev/null +++ b/tests/test_check_dist.py @@ -0,0 +1,153 @@ +import importlib.util +import io +from pathlib import Path +import tarfile +import zipfile + +import pytest + + +ROOT = Path(__file__).resolve().parents[1] +SCRIPT = ROOT / "scripts" / "check_dist.py" +SPEC = importlib.util.spec_from_file_location("check_dist", SCRIPT) +check_dist = importlib.util.module_from_spec(SPEC) +assert SPEC.loader is not None +SPEC.loader.exec_module(check_dist) + + +def _metadata(version="0.1.0rc1"): + requirements = "\n".join( + f"Requires-Dist: {requirement}" + for requirement in ( + "numpy>=1.24", + "pandas>=1.5", + "geopandas>=0.13", + "shapely>=2.0", + "scipy>=1.10", + "gmsh>=4.11", + ) + ) + return ( + "Metadata-Version: 2.4\n" + "Name: vorflow\n" + f"Version: {version}\n" + "Author: rhugman\n" + "Author-email: Oscar Sanchez \n" + "Maintainer-email: Oscar Sanchez \n" + "License-Expression: MIT\n" + "License-File: LICENSE\n" + "Requires-Python: >=3.10\n" + "Project-URL: Repository, https://github.com/oscarfasanchez/vorflow_os\n" + "Project-URL: Issues, https://github.com/oscarfasanchez/vorflow_os/issues\n" + "Project-URL: Changelog, https://github.com/oscarfasanchez/vorflow_os/blob/main/CHANGELOG.md\n" + f"{requirements}\n" + "\n" + "Synthetic package metadata for archive validation tests.\n" + ).encode() + + +def _write_sdist(path, metadata=_metadata(), root="vorflow-0.1.0rc1"): + members = { + f"{root}/pyproject.toml": b"", + f"{root}/README.md": b"", + f"{root}/LICENSE": b"MIT", + f"{root}/src/vorflow/__init__.py": b"", + } + if metadata is not None: + members[f"{root}/PKG-INFO"] = metadata + with tarfile.open(path, "w:gz") as archive: + for name, content in members.items(): + info = tarfile.TarInfo(name) + info.size = len(content) + archive.addfile(info, io.BytesIO(content)) + + +def _write_wheel(path): + dist_info = "vorflow-0.1.0rc1.dist-info" + with zipfile.ZipFile(path, "w") as archive: + archive.writestr("vorflow/__init__.py", "") + archive.writestr(f"{dist_info}/licenses/LICENSE", "MIT") + archive.writestr(f"{dist_info}/METADATA", _metadata()) + + +def test_version_from_tag(): + assert check_dist.version_from_tag("v0.1.0rc1") == "0.1.0rc1" + + +def test_version_from_tag_rejects_production_tag(): + try: + check_dist.version_from_tag("v0.1.0") + except ValueError as error: + assert "release-candidate" in str(error) + else: + raise AssertionError("production tag was accepted") + + +@pytest.mark.parametrize( + "tag", + [ + "0.1.0rc1", + "vnot-rc-tag", + "v0.1.0rc", + "v0.1.0rc1junk", + ], +) +def test_version_from_tag_rejects_malformed_candidate_tags(tag): + with pytest.raises(ValueError, match="release-candidate"): + check_dist.version_from_tag(tag) + + +def test_forbidden_members_are_reported(): + members = [ + "vorflow-0.1.0rc1/src/vorflow/__init__.py", + "vorflow-0.1.0rc1/docs/private-plan.md", + "vorflow-0.1.0rc1/src/vorflow/vorflow.code-workspace", + ] + assert check_dist.forbidden_members(members) == [members[1], members[2]] + + +def test_validate_wheel_accepts_complete_metadata(tmp_path): + wheel = tmp_path / "vorflow-0.1.0rc1-py3-none-any.whl" + _write_wheel(wheel) + + check_dist.validate_wheel(wheel, "0.1.0rc1") + + +def test_validate_sdist_accepts_complete_metadata(tmp_path): + sdist = tmp_path / "vorflow-0.1.0rc1.tar.gz" + _write_sdist(sdist) + + check_dist.validate_sdist(sdist, "0.1.0rc1") + + +def test_validate_sdist_rejects_missing_pkg_info(tmp_path): + sdist = tmp_path / "vorflow-0.1.0rc1.tar.gz" + _write_sdist(sdist, metadata=None) + + with pytest.raises(ValueError, match="PKG-INFO"): + check_dist.validate_sdist(sdist, "0.1.0rc1") + + +def test_validate_sdist_rejects_mismatched_metadata_version(tmp_path): + sdist = tmp_path / "vorflow-0.1.0rc1.tar.gz" + _write_sdist(sdist, metadata=_metadata(version="0.1.0")) + + with pytest.raises(ValueError, match="does not match"): + check_dist.validate_sdist(sdist, "0.1.0rc1") + + +def test_validate_sdist_rejects_wrong_filename(tmp_path): + sdist = tmp_path / "renamed-0.1.0rc1.tar.gz" + _write_sdist(sdist) + + with pytest.raises(ValueError, match="filename"): + check_dist.validate_sdist(sdist, "0.1.0rc1") + + +def test_validate_dist_rejects_duplicate_wheels(tmp_path): + (tmp_path / "one.whl").touch() + (tmp_path / "two.whl").touch() + (tmp_path / "vorflow-0.1.0rc1.tar.gz").touch() + + with pytest.raises(ValueError, match=r"expected one \*\.whl"): + check_dist.validate_dist(tmp_path, "0.1.0rc1") diff --git a/tests/test_conceptual_mesh.py b/tests/test_conceptual_mesh.py index 6c8388b..fb50596 100644 --- a/tests/test_conceptual_mesh.py +++ b/tests/test_conceptual_mesh.py @@ -1,8 +1,10 @@ -import geopandas as gpd +import warnings + import pytest from shapely.geometry import LineString, Point, Polygon from shapely.ops import unary_union +import vorflow.blueprint as blueprint_module from vorflow.blueprint import ConceptualMesh @@ -25,14 +27,46 @@ def test_resolve_overlaps_respects_z_order(): assert pytest.approx(expected_union.area, rel=1e-6) == resolved_union.area -def test_lines_and_points_snap_to_polygons(): +def test_growth_factor_must_exceed_one(): + cm = ConceptualMesh() + square = Polygon([(0, 0), (1, 0), (1, 1), (0, 1)]) + with pytest.raises(ValueError, match="growth_factor"): + cm.add_polygon(square, zone_id=1, resolution=0.5, growth_factor=1.0) + with pytest.raises(ValueError, match="growth_factor"): + cm.add_line(LineString([(0, 0), (1, 0)]), line_id="l", resolution=0.5, growth_factor=0.9) + with pytest.raises(ValueError, match="growth_factor"): + cm.add_point(Point(0, 0), point_id="p", resolution=0.5, growth_factor=True) + + +@pytest.mark.parametrize("growth_factor", [float("nan"), float("inf"), -float("inf")]) +def test_growth_factor_must_be_finite(growth_factor): + cm = ConceptualMesh(crs=None) + with pytest.raises(ValueError, match="finite"): + cm.add_point( + Point(0, 0), + point_id="p", + resolution=0.5, + growth_factor=growth_factor, + ) + + +def test_growth_factor_defaults_to_none_and_is_stored(): cm = ConceptualMesh() + square = Polygon([(0, 0), (1, 0), (1, 1), (0, 1)]) + cm.add_polygon(square, zone_id=1, resolution=0.5) + cm.add_polygon(square, zone_id=2, resolution=0.5, growth_factor=1.3) + assert cm.raw_polygons[0]["growth_factor"] is None + assert cm.raw_polygons[1]["growth_factor"] == 1.3 + + +def test_lines_and_points_snap_to_polygons(): + cm = ConceptualMesh(connectivity_tolerance=1.0) square = Polygon([(0, 0), (2, 0), (2, 2), (0, 2)]) cm.add_polygon(square, zone_id=1) line = LineString([(-0.5, 1.0), (0.5, 1.0)]) - point = Point(-0.0005, 0.5) + point = Point(-0.0005, 0.0) cm.add_line(line, line_id="river", resolution=0.1) cm.add_point(point, point_id="well", resolution=0.1) @@ -49,3 +83,230 @@ def test_lines_and_points_snap_to_polygons(): tolerance = 1e-3 assert snapped_line.distance(boundary) <= tolerance assert snapped_point.distance(boundary) <= tolerance + + +def test_points_outside_domain_are_removed_after_connectivity(): + cm = ConceptualMesh(connectivity_tolerance=0.01) + + square = Polygon([(0, 0), (2, 0), (2, 2), (0, 2)]) + cm.add_polygon(square, zone_id=1) + cm.add_line(LineString([(0, 1), (2, 1)]), line_id="river", resolution=0.5, densify=False) + cm.add_point(Point(-0.05, 1), point_id="outside_well", resolution=0.05) + + _, _, clean_points = cm.generate() + + assert clean_points.empty + + +def test_points_snapped_to_domain_boundary_are_kept(): + cm = ConceptualMesh(connectivity_tolerance=0.1) + + square = Polygon([(0, 0), (2, 0), (2, 2), (0, 2)]) + cm.add_polygon(square, zone_id=1) + cm.add_line(LineString([(0, 1), (2, 1)]), line_id="river", resolution=0.5, densify=False) + cm.add_point(Point(-0.05, 1), point_id="snapped_well", resolution=0.05) + + _, _, clean_points = cm.generate() + + assert len(clean_points) == 1 + assert clean_points.iloc[0].geometry.equals(Point(0, 1)) + + +def test_lines_are_clipped_to_domain_after_connectivity(): + cm = ConceptualMesh(connectivity_tolerance=0.0) + + square = Polygon([(0, 0), (2, 0), (2, 2), (0, 2)]) + cm.add_polygon(square, zone_id=1) + cm.add_line(LineString([(-1, 1), (3, 1)]), line_id="crossing_line", resolution=0.5, densify=False) + + _, clean_lines, _ = cm.generate() + + assert len(clean_lines) == 1 + assert clean_lines.iloc[0].geometry.equals(LineString([(0, 1), (2, 1)])) + + +def test_generate_uses_constructor_connectivity_tolerance(monkeypatch): + cm = ConceptualMesh(connectivity_tolerance=0.25) + square = Polygon([(0, 0), (2, 0), (2, 2), (0, 2)]) + + cm.add_polygon(square, zone_id=1) + cm.add_line(LineString([(0, 0), (1, 0)]), line_id="river", resolution=0.1, densify=False) + cm.add_point(Point(0.1, 0.1), point_id="well", resolution=0.1) + + recorded_tolerances = [] + + def fake_snap(geometry, reference_geometry, tolerance): + recorded_tolerances.append(tolerance) + return geometry + + monkeypatch.setattr(blueprint_module, "snap", fake_snap) + + cm.generate() + + assert recorded_tolerances == [pytest.approx(0.25), pytest.approx(0.25)] + + +def test_generate_can_override_connectivity_tolerance(monkeypatch): + cm = ConceptualMesh(connectivity_tolerance=1.0) + square = Polygon([(0, 0), (2, 0), (2, 2), (0, 2)]) + + cm.add_polygon(square, zone_id=1) + cm.add_line(LineString([(0, 0), (1, 0)]), line_id="river", resolution=0.1, densify=False) + cm.add_point(Point(0.1, 0.1), point_id="well", resolution=0.1) + + recorded_tolerances = [] + + def fake_snap(geometry, reference_geometry, tolerance): + recorded_tolerances.append(tolerance) + return geometry + + monkeypatch.setattr(blueprint_module, "snap", fake_snap) + + cm.generate(connectivity_tolerance=0.05) + + assert recorded_tolerances == [pytest.approx(0.05), pytest.approx(0.05)] + +def test_polygon_simplification(): + """Test that polygons are simplified when tolerance is provided.""" + cm = ConceptualMesh() + + # Create a "noisy" square with a tiny bump on the top edge + # (0,1) -> (0.5, 1.001) -> (1,1) + poly = Polygon([(0, 0), (1, 0), (1, 1), (0.5, 1.001), (0, 1)]) + + # Add with a tolerance larger than the noise (0.001) + cm.add_polygon(poly, zone_id=1, simplify_tolerance=0.01) + + clean_polys, _, _ = cm.generate() + + simplified_geom = clean_polys.iloc[0].geometry + + # The original polygon has 5 vertices + closing = 6 points in exterior ring + # The simplified one should remove the bump, leaving 4 corners + closing = 5 points + assert len(simplified_geom.exterior.coords) == 5 + assert len(simplified_geom.exterior.coords) < len(poly.exterior.coords) + +def test_line_simplification(): + """Test that lines are simplified when tolerance is provided.""" + cm = ConceptualMesh() + # Noisy line: straight but with a midpoint slightly off + line = LineString([(0, 0), (0.5, 0.001), (1, 0)]) + + cm.add_line(line, line_id="noisy_line", resolution=0.1, simplify_tolerance=0.01, densify=False) + + _, clean_lines, _ = cm.generate() + + simplified_line = clean_lines.iloc[0].geometry + # Should be simplified to just start and end points + assert len(simplified_line.coords) == 2 + +def test_point_deduplication(): + """Test that close points are merged and the finest resolution is kept.""" + cm = ConceptualMesh() + p1 = Point(0, 0) + p2 = Point(0.0001, 0) # Very close to p1 + + # Case 1: No simplification (default) -> Should keep both + cm.add_point(p1, "p1", resolution=1.0) + cm.add_point(p2, "p2", resolution=0.5) + + _, _, clean_points = cm.generate() + assert len(clean_points) == 2 + + # Case 2: With simplification -> Should merge + cm2 = ConceptualMesh() + # p2 has finer resolution (0.5), so it should be the one kept + cm2.add_point(p1, "p1", resolution=1.0, simplify_tolerance=0.01) + cm2.add_point(p2, "p2", resolution=0.5, simplify_tolerance=0.01) + + _, _, clean_points_merged = cm2.generate() + + assert len(clean_points_merged) == 1 + + # Verify we kept the point with the finer resolution (0.5) + kept_point = clean_points_merged.iloc[0] + assert kept_point['lc'] == 0.5 + assert kept_point['point_id'] == "p2" + +def test_line_densification_options(): + """Test the three modes of line densification: False, True, and float.""" + cm = ConceptualMesh() + # A line of length 10 + line = LineString([(0, 0), (10, 0)]) + + # 1. densify=False: Should NOT add vertices + cm.add_line(line, "no_densify", resolution=1.0, densify=False) + + # 2. densify=True (default): Should use resolution (1.0) -> ~10 segments + cm.add_line(line, "default_densify", resolution=1.0, densify=True) + + # 3. densify=5.0: Should use custom spacing (5.0) -> ~2 segments + cm.add_line(line, "custom_densify", resolution=1.0, densify=5.0) + + _, clean_lines, _ = cm.generate() + + # Check 1: No densification + l1 = clean_lines[clean_lines['line_id'] == "no_densify"].iloc[0].geometry + assert len(l1.coords) == 2 # Just start and end + + # Check 2: Default densification (lc=1.0) + l2 = clean_lines[clean_lines['line_id'] == "default_densify"].iloc[0].geometry + # Should have 11 points (10 segments) + assert len(l2.coords) == 11 + + # Check 3: Custom densification (val=5.0) + l3 = clean_lines[clean_lines['line_id'] == "custom_densify"].iloc[0].geometry + # Should have roughly 3 points (2 segments) + assert len(l3.coords) == 3 + +@pytest.mark.parametrize("bool_tol", [True, False]) +def test_simplify_tolerance_bool_is_rejected(bool_tol): + cm = ConceptualMesh() + + poly = Polygon([(0, 0), (1, 0), (1, 1), (0, 1)]) + with pytest.raises(ValueError): + cm.add_polygon(poly, zone_id=1, simplify_tolerance=bool_tol) + + line = LineString([(0, 0), (1, 0)]) + with pytest.raises(ValueError): + cm.add_line(line, line_id="l1", resolution=0.1, simplify_tolerance=bool_tol, densify=False) + + pt = Point(0, 0) + with pytest.raises(ValueError): + cm.add_point(pt, point_id="p1", resolution=0.1, simplify_tolerance=bool_tol) + + +@pytest.mark.parametrize("bad_tolerance", [True, False, -1]) +def test_connectivity_tolerance_validation(bad_tolerance): + with pytest.raises(ValueError): + ConceptualMesh(connectivity_tolerance=bad_tolerance) + + +class TestCrsHandling: + def test_geographic_crs_warns(self): + with pytest.warns(UserWarning, match="geographic"): + ConceptualMesh(crs="EPSG:4326") + + def test_projected_crs_does_not_warn(self): + with warnings.catch_warnings(): + warnings.simplefilter("error") + ConceptualMesh(crs="EPSG:32618") + + def test_default_crs_is_none_and_does_not_warn(self): + with warnings.catch_warnings(): + warnings.simplefilter("error") + cm = ConceptualMesh() + assert cm.crs is None + + def test_none_crs_propagates_to_outputs(self): + cm = ConceptualMesh() + cm.add_polygon(Polygon([(0, 0), (10, 0), (10, 10), (0, 10)]), zone_id=1) + clean_polys, _, _ = cm.generate() + assert clean_polys.crs is None + + def test_explicit_projected_crs_propagates_to_outputs(self): + cm = ConceptualMesh(crs="EPSG:32618") + cm.add_polygon(Polygon([(0, 0), (10, 0), (10, 10), (0, 10)]), zone_id=1) + clean_polys, _, _ = cm.generate() + assert clean_polys.crs is not None + assert clean_polys.crs.to_epsg() == 32618 diff --git a/tests/test_fields.py b/tests/test_fields.py new file mode 100644 index 0000000..7c7839c --- /dev/null +++ b/tests/test_fields.py @@ -0,0 +1,248 @@ +"""Direct unit tests for the mesh size field classes. + +Each test builds a minimal gmsh model, calls the field's create(), and reads +the resulting gmsh field options back with gmsh.model.mesh.field.get* so the +refinement parameters the classes promise are actually what gmsh receives. +""" +import math + +import gmsh +import pytest + +from vorflow.fields import ( + AutoExponentialField, + AutoLinearField, + ConstantField, + DistanceField, + ExponentialField, + GeometricGrowthField, + MeshField, + ThresholdField, +) + + +@pytest.fixture +def gmsh_model(): + """A tiny synchronized OCC model: one point, one line, one surface.""" + gmsh.initialize() + gmsh.option.setNumber("General.Terminal", 0) + gmsh.model.add("fields_test") + pt = gmsh.model.occ.addPoint(5, 5, 0) + l1 = gmsh.model.occ.addPoint(0, -2, 0) + l2 = gmsh.model.occ.addPoint(10, -2, 0) + line = gmsh.model.occ.addLine(l1, l2) + rect = gmsh.model.occ.addRectangle(0, 0, 0, 10, 10) + gmsh.model.occ.synchronize() + yield {"point": pt, "line": line, "surface": rect} + gmsh.finalize() + + +def _line_tags(model): + return {"points": [], "lines": [model["line"]], "surfaces": []} + + +class TestDistanceField: + def test_creates_distance_field_with_curve_list(self, gmsh_model): + tag = DistanceField(sampling=33).create(gmsh, _line_tags(gmsh_model)) + assert tag is not None + assert gmsh.model.mesh.field.getType(tag) == "Distance" + curves = gmsh.model.mesh.field.getNumbers(tag, "CurvesList") + assert list(map(int, curves)) == [gmsh_model["line"]] + assert gmsh.model.mesh.field.getNumber(tag, "Sampling") == 33 + + def test_returns_none_for_empty_tags(self, gmsh_model): + tag = DistanceField().create(gmsh, {"points": [], "lines": [], "surfaces": []}) + assert tag is None + + +class TestConstantField: + def test_sets_vin_and_vout(self, gmsh_model): + tag = ConstantField(size=7.5).create(gmsh, {}, background_lc=50.0) + assert gmsh.model.mesh.field.getType(tag) == "Constant" + assert gmsh.model.mesh.field.getNumber(tag, "VIn") == 7.5 + assert gmsh.model.mesh.field.getNumber(tag, "VOut") == 50.0 + + +class TestThresholdField: + def test_sets_all_threshold_options(self, gmsh_model): + field = ThresholdField(size_min=2.0, dist_min=4.0, dist_max=40.0, size_max=25.0) + tag = field.create(gmsh, _line_tags(gmsh_model), background_lc=100.0) + assert gmsh.model.mesh.field.getType(tag) == "Threshold" + assert gmsh.model.mesh.field.getNumber(tag, "SizeMin") == 2.0 + assert gmsh.model.mesh.field.getNumber(tag, "SizeMax") == 25.0 + assert gmsh.model.mesh.field.getNumber(tag, "DistMin") == 4.0 + assert gmsh.model.mesh.field.getNumber(tag, "DistMax") == 40.0 + + def test_size_max_defaults_to_background(self, gmsh_model): + field = ThresholdField(size_min=2.0, dist_min=4.0, dist_max=40.0) + tag = field.create(gmsh, _line_tags(gmsh_model), background_lc=100.0) + assert gmsh.model.mesh.field.getNumber(tag, "SizeMax") == 100.0 + + def test_polygon_surface_gets_constant_interior_via_min(self, gmsh_model): + tags = {"points": [], "lines": [], "surfaces": [gmsh_model["surface"]]} + tag = ThresholdField(2.0, 4.0, 40.0).create(gmsh, tags, background_lc=100.0) + # growth from boundary curves + spatial constant inside -> combined Min + assert gmsh.model.mesh.field.getType(tag) == "Min" + + +class TestExponentialField: + def test_matheval_embeds_decay_and_sizes(self, gmsh_model): + field = ExponentialField(size_min=1.5, decay_length=30.0, size_max=20.0) + tag = field.create(gmsh, _line_tags(gmsh_model), background_lc=100.0) + assert gmsh.model.mesh.field.getType(tag) == "MathEval" + expr = gmsh.model.mesh.field.getString(tag, "F") + assert "30.0" in expr and "1.5" in expr and "20.0" in expr + + @pytest.mark.parametrize( + ("kwargs", "match"), + [ + ({"size_min": 0.0, "decay_length": 30.0}, "size_min"), + ({"size_min": math.nan, "decay_length": 30.0}, "size_min"), + ({"size_min": 1.0, "decay_length": 0.0}, "decay_length"), + ({"size_min": 1.0, "decay_length": math.inf}, "decay_length"), + ( + {"size_min": 2.0, "decay_length": 30.0, "size_max": 1.0}, + "size_max", + ), + ], + ) + def test_rejects_invalid_constructor_values(self, kwargs, match): + with pytest.raises(ValueError, match=match): + ExponentialField(**kwargs) + + def test_rejects_background_smaller_than_size_min(self, gmsh_model): + field = ExponentialField(size_min=2.0, decay_length=30.0) + with pytest.raises(ValueError, match="background_lc"): + field.create(gmsh, _line_tags(gmsh_model), background_lc=1.0) + + +class TestGeometricGrowthField: + def test_is_exported_from_package_root(self): + import vorflow + + assert vorflow.GeometricGrowthField is GeometricGrowthField + + def test_edge_ratio_expression_is_explicitly_linear(self, gmsh_model): + tag = GeometricGrowthField(growth_factor=1.2).create( + gmsh, _line_tags(gmsh_model), background_lc=100.0, feature_lc=2.0 + ) + assert gmsh.model.mesh.field.getType(tag) == "MathEval" + expr = gmsh.model.mesh.field.getString(tag, "F") + assert expr == "2.0 + 0.2 * F1" + assert "Log" not in expr + assert "^" not in expr + + def test_continuous_metric_expression_uses_log_gradient(self, gmsh_model): + tag = GeometricGrowthField( + growth_factor=1.2, growth_model="continuous_metric" + ).create( + gmsh, _line_tags(gmsh_model), background_lc=100.0, feature_lc=2.0 + ) + expr = gmsh.model.mesh.field.getString(tag, "F") + assert expr == "2.0 + 0.182321556793955 * F1" + + def test_defaults_are_shared_and_transparent(self): + field = GeometricGrowthField() + assert field.growth_factor == 1.2 + assert field.growth_model == "edge_ratio" + assert field.sampling == 20 + + def test_constructor_sampling_reaches_distance_field(self, gmsh_model): + tag = GeometricGrowthField(sampling=33).create( + gmsh, _line_tags(gmsh_model), background_lc=100.0, feature_lc=2.0 + ) + assert gmsh.model.mesh.field.getNumber(tag - 1, "Sampling") == 33 + + def test_create_sampling_override_is_retained(self, gmsh_model): + tag = GeometricGrowthField(sampling=20).create( + gmsh, + _line_tags(gmsh_model), + background_lc=100.0, + feature_lc=2.0, + sampling=41, + ) + assert gmsh.model.mesh.field.getNumber(tag - 1, "Sampling") == 41 + + def test_returns_none_without_feature_lc(self, gmsh_model): + tag = GeometricGrowthField().create(gmsh, _line_tags(gmsh_model), 100.0) + assert tag is None + + def test_returns_none_when_feature_not_finer_than_background(self, gmsh_model): + tag = GeometricGrowthField().create( + gmsh, _line_tags(gmsh_model), background_lc=2.0, feature_lc=5.0 + ) + assert tag is None + + @pytest.mark.parametrize("growth_factor", [1.0, 0.9, math.nan, math.inf, -math.inf]) + def test_rejects_invalid_growth_factor(self, growth_factor): + with pytest.raises(ValueError, match="growth_factor"): + GeometricGrowthField(growth_factor=growth_factor) + + @pytest.mark.parametrize("growth_model", ["triangle_centroids", None, []]) + def test_rejects_unknown_growth_model(self, growth_model): + with pytest.raises(ValueError, match="growth_model"): + GeometricGrowthField(growth_model=growth_model) + + @pytest.mark.parametrize("sampling", [0, -1, 1.5, True]) + def test_rejects_invalid_sampling(self, sampling): + with pytest.raises(ValueError, match="sampling"): + GeometricGrowthField(sampling=sampling) + + @pytest.mark.parametrize("feature_lc", [0.0, -1.0, math.nan, math.inf]) + def test_rejects_invalid_feature_size(self, gmsh_model, feature_lc): + with pytest.raises(ValueError, match="feature_lc"): + GeometricGrowthField().create( + gmsh, + _line_tags(gmsh_model), + background_lc=100.0, + feature_lc=feature_lc, + ) + + @pytest.mark.parametrize("background_lc", [0.0, -1.0, math.nan, math.inf]) + def test_rejects_invalid_background_size(self, gmsh_model, background_lc): + with pytest.raises(ValueError, match="background_lc"): + GeometricGrowthField().create( + gmsh, + _line_tags(gmsh_model), + background_lc=background_lc, + feature_lc=2.0, + ) + + def test_growth_model_and_sampling_participate_in_grouping(self): + base = GeometricGrowthField() + assert base != GeometricGrowthField(growth_model="continuous_metric") + assert base != GeometricGrowthField(sampling=21) + + +class TestDeprecatedAutomaticFields: + @pytest.mark.parametrize("field_class", [AutoExponentialField, AutoLinearField]) + def test_deprecated_names_warn_and_delegate(self, gmsh_model, field_class): + with pytest.warns(DeprecationWarning, match="GeometricGrowthField"): + field = field_class(growth_factor=1.2) + assert isinstance(field, GeometricGrowthField) + tag = field.create( + gmsh, _line_tags(gmsh_model), background_lc=100.0, feature_lc=2.0 + ) + assert gmsh.model.mesh.field.getString(tag, "F") == "2.0 + 0.2 * F1" + + +class TestFieldEqualityGrouping: + """__eq__/__hash__ let the engine group identical field specs.""" + + def test_equal_parameters_hash_and_compare_equal(self): + a = ThresholdField(2.0, 4.0, 40.0, 25.0) + b = ThresholdField(2.0, 4.0, 40.0, 25.0) + assert a == b + assert hash(a) == hash(b) + assert len({a, b}) == 1 + + def test_different_parameters_or_types_differ(self): + a = ThresholdField(2.0, 4.0, 40.0) + b = ThresholdField(3.0, 4.0, 40.0) + c = ExponentialField(2.0, 4.0) + assert a != b + assert a != c + + def test_base_class_create_is_abstract(self): + with pytest.raises(NotImplementedError): + MeshField().create(gmsh, {}, 100.0) diff --git a/tests/test_integration_gmsh.py b/tests/test_integration_gmsh.py index d0253ab..a24c0c3 100644 --- a/tests/test_integration_gmsh.py +++ b/tests/test_integration_gmsh.py @@ -1,20 +1,15 @@ +import warnings + import pytest -import geopandas as gpd from shapely.geometry import Polygon, LineString import gmsh from vorflow.blueprint import ConceptualMesh from vorflow.engine import MeshGenerator +from vorflow.fields import GeometricGrowthField from vorflow.tessellator import VoronoiTessellator -@pytest.fixture(autouse=True) -def ensure_gmsh_finalized(): - """Ensure gmsh is finalized before and after each test to prevent state leakage.""" - if gmsh.is_initialized(): - gmsh.finalize() - yield - if gmsh.is_initialized(): - gmsh.finalize() +pytestmark = pytest.mark.slow # gmsh-heavy end-to-end tests def test_gmsh_integration_simple_square(): """ @@ -25,7 +20,7 @@ def test_gmsh_integration_simple_square(): # 10x10 square square = Polygon([(0, 0), (10, 0), (10, 10), (0, 10)]) # Zone ID 1, resolution 2.0 (coarse mesh for speed) - cm.add_polygon(square, zone_id=1, resolution=2.0) + cm.add_polygon(square, zone_id=1, resolution=2.0, dist_max=10.0) clean_polys, clean_lines, clean_points = cm.generate() @@ -59,7 +54,7 @@ def test_gmsh_integration_with_internal_line(): """ cm = ConceptualMesh(crs="EPSG:3857") square = Polygon([(0, 0), (10, 0), (10, 10), (0, 10)]) - cm.add_polygon(square, zone_id=1, resolution=5.0) + cm.add_polygon(square, zone_id=1, resolution=5.0, dist_max=25.0) # Diagonal line with finer resolution line = LineString([(1, 1), (9, 9)]) @@ -81,6 +76,172 @@ def test_gmsh_integration_with_internal_line(): # because of the 1.0 resolution line. assert len(grid) > 10 + +def test_gmsh_integration_tolerates_duplicate_line_vertices(): + """Duplicate consecutive line vertices should not crash mesh generation.""" + cm = ConceptualMesh(crs="EPSG:3857") + square = Polygon([(0, 0), (10, 0), (10, 10), (0, 10)]) + cm.add_polygon(square, zone_id=1, resolution=4.0, dist_max=20.0) + + line = LineString([(1, 1), (5, 5), (5, 5), (9, 9)]) + cm.add_line(line, line_id="duplicate_vertices", resolution=1.0) + + clean_polys, clean_lines, clean_points = cm.generate() + + mg = MeshGenerator(background_lc=4.0, verbosity=0) + success = mg.generate(clean_polys, clean_lines, clean_points) + + assert success + assert mg.nodes is not None + assert len(mg.nodes) > 0 + + +def test_gmsh_integration_tolerates_near_duplicate_line_vertices(): + """Near-zero segments should be cleaned before OCC line creation.""" + cm = ConceptualMesh(crs="EPSG:3857") + square = Polygon([(0, 0), (10, 0), (10, 10), (0, 10)]) + cm.add_polygon(square, zone_id=1, resolution=4.0, dist_max=20.0) + + line = LineString([(1, 8), (5, 8), (5 + 1e-9, 8), (9, 8)]) + cm.add_line(line, line_id="near_duplicate_vertices", resolution=1.0) + + clean_polys, clean_lines, clean_points = cm.generate() + + mg = MeshGenerator(background_lc=4.0, verbosity=0) + success = mg.generate(clean_polys, clean_lines, clean_points) + + assert success + assert mg.nodes is not None + assert len(mg.nodes) > 0 + + +def test_gmsh_integration_with_field_only_line_refinement(): + """A non-embedded (field-only) line should refine the mesh without partitioning it.""" + cm = ConceptualMesh(crs="EPSG:3857") + square = Polygon([(0, 0), (10, 0), (10, 10), (0, 10)]) + cm.add_polygon(square, zone_id=1, resolution=5.0, dist_max=25.0) + + # Field-only diagonal line with finer resolution. + line = LineString([(1, 1), (9, 9)]) + cm.add_line(line, line_id="fault", resolution=1.0, embed=False) + + clean_polys, clean_lines, clean_points = cm.generate() + + mg = MeshGenerator(background_lc=5.0, verbosity=1) + success = mg.generate(clean_polys, clean_lines, clean_points) + assert success + + vt = VoronoiTessellator(mg, cm, clip_to_boundary=True) + grid = vt.generate() + assert not grid.empty + + # Still expect refinement from the line-based size field. + assert len(grid) > 10 + + +def _constant_fields_for_surfaces(surface_tags, expected_vin): + matches = [] + expected_surfaces = {float(tag) for tag in surface_tags} + + for field_id in gmsh.model.mesh.field.list(): + if gmsh.model.mesh.field.getType(field_id) != "Constant": + continue + + surfaces = set(gmsh.model.mesh.field.getNumbers(field_id, "SurfacesList")) + if surfaces != expected_surfaces: + continue + + vin = gmsh.model.mesh.field.getNumber(field_id, "VIn") + if vin == pytest.approx(expected_vin): + matches.append(field_id) + + return matches + + +def test_embedded_polygon_field_has_constant_interior(): + """Embedded polygon size fields should stay constant inside the surface.""" + cm = ConceptualMesh(crs="EPSG:3857") + domain = Polygon([(0, 0), (20, 0), (20, 20), (0, 20)]) + inner = Polygon([(5, 5), (15, 5), (15, 15), (5, 15)]) + + cm.add_polygon(domain, zone_id=1, resolution=10.0, z_order=0) + cm.add_polygon( + inner, + zone_id=2, + resolution=2.0, + z_order=1, + fields=[GeometricGrowthField(growth_factor=1.2)], + ) + clean_polys, clean_lines, clean_points = cm.generate() + + mg = MeshGenerator(background_lc=10.0, verbosity=0) + gmsh.initialize() + try: + gmsh.model.add("embedded_polygon_field") + gmsh_map = mg._add_geometry(clean_polys, clean_lines, clean_points) + mg._setup_fields(gmsh_map, clean_polys, clean_lines, clean_points) + + inner_idx = int(clean_polys.index[clean_polys["zone_id"] == 2][0]) + inner_surfaces = set(gmsh_map["surfaces"][inner_idx]) + inner_surface_tags = { + float(tag) for dim, tag in inner_surfaces if int(dim) == 2 + } + + constant_fields = _constant_fields_for_surfaces(inner_surface_tags, 2.0) + + assert constant_fields, "Expected a constant field inside the embedded polygon surface" + finally: + gmsh.finalize() + + +def test_field_only_polygon_field_has_constant_interior_without_partitioning(): + """Field-only polygons should get flat interior sizing without becoming domain zones.""" + cm = ConceptualMesh(crs="EPSG:3857") + domain = Polygon([(0, 0), (20, 0), (20, 20), (0, 20)]) + field_poly = Polygon([(5, 5), (15, 5), (15, 15), (5, 15)]) + + cm.add_polygon(domain, zone_id=1, resolution=10.0, z_order=0) + cm.add_polygon( + field_poly, + zone_id="field-only", + resolution=2.0, + fields=[GeometricGrowthField(growth_factor=1.2)], + embed=False, + ) + clean_polys, clean_lines, clean_points = cm.generate() + + field_idx = int(clean_polys.index[clean_polys["zone_id"] == "field-only"][0]) + domain_idx = int(clean_polys.index[clean_polys["zone_id"] == 1][0]) + assert bool(clean_polys.loc[field_idx, "embed"]) is False + + mg = MeshGenerator(background_lc=10.0, verbosity=0) + gmsh.initialize() + try: + gmsh.model.add("field_only_polygon_field") + gmsh_map = mg._add_geometry(clean_polys, clean_lines, clean_points) + mg._setup_fields(gmsh_map, clean_polys, clean_lines, clean_points) + + field_surfaces = set(gmsh_map["surfaces"][field_idx]) + field_surface_tags = { + float(tag) for dim, tag in field_surfaces if int(dim) == 2 + } + + constant_fields = _constant_fields_for_surfaces(field_surface_tags, 2.0) + assert constant_fields, "Expected a constant field inside the field-only polygon surface" + + embedded_domain_ids = [ + int(i) + for i, row in clean_polys.iterrows() + if bool(row.get("embed", True)) + ] + assert embedded_domain_ids == [domain_idx] + finally: + gmsh.finalize() + + assert mg.generate(clean_polys, clean_lines, clean_points) + assert len(mg.nodes) > 0 + + def test_gmsh_integration_overlapping_polygon_with_hole(): """ Test the case where an overlapping polygon (Zone 2) has a hole in its center. @@ -91,7 +252,7 @@ def test_gmsh_integration_overlapping_polygon_with_hole(): # 1. Base Domain (Large Square) - Zone 1 # 20x20 square domain = Polygon([(0, 0), (20, 0), (20, 20), (0, 20)]) - cm.add_polygon(domain, zone_id=1, resolution=5.0, z_order=0) + cm.add_polygon(domain, zone_id=1, resolution=5.0, dist_max=25.0, z_order=0) # 2. Overlapping Polygon with Hole (Donut) - Zone 2 # Outer: 5,5 to 15,15 @@ -100,7 +261,7 @@ def test_gmsh_integration_overlapping_polygon_with_hole(): donut_hole = [(8, 8), (12, 8), (12, 12), (8, 12)] donut = Polygon(donut_shell, [donut_hole]) - cm.add_polygon(donut, zone_id=2, resolution=2.0, z_order=1) + cm.add_polygon(donut, zone_id=2, resolution=2.0, dist_max=10.0, z_order=1) # 3. Generate Conceptual Mesh clean_polys, clean_lines, clean_points = cm.generate() @@ -141,3 +302,85 @@ def test_gmsh_integration_overlapping_polygon_with_hole(): total_area = grid.geometry.area.sum() expected_area = domain.area # 400 assert pytest.approx(total_area, rel=0.01) == expected_area + + +def _domain_with_fine_zone(*, growth_factor=None, dist_min=None, dist_max=None, fields=None): + domain = Polygon([(0, 0), (20, 0), (20, 20), (0, 20)]) + fine = Polygon([(8, 8), (12, 8), (12, 12), (8, 12)]) + cm = ConceptualMesh(crs=None) + cm.add_polygon(domain, zone_id="domain", resolution=4.0) + cm.add_polygon( + fine, + zone_id="fine", + resolution=0.5, + z_order=1, + densify=True, + growth_factor=growth_factor, + dist_min=dist_min, + dist_max=dist_max, + fields=fields, + ) + clean = cm.generate() + mg = MeshGenerator(background_lc=4.0, verbosity=0, smoothing_steps=0, optimization_cycles=0) + return mg, clean + + +def test_default_field_is_geometric_growth_and_refines_without_dist_or_fields(): + # A feature finer than the background now refines by default via an implicit + # GeometricGrowthField -- no dist_min/dist_max or explicit fields required, + # and no deprecation warning. + mg, clean = _domain_with_fine_zone() + with warnings.catch_warnings(record=True) as caught: + warnings.simplefilter("always") + assert mg.generate(*clean) + assert not [w for w in caught if issubclass(w.category, DeprecationWarning)] + + grid = mg.get_element_grid() + cent = grid.geometry.centroid + inner = grid[cent.x.between(8, 12) & cent.y.between(8, 12)] + outer = grid[(cent.x < 4) | (cent.x > 16)] + assert not inner.empty and not outer.empty + # Graded halo: cells in the fine zone are much smaller than far away. + assert inner.geometry.area.mean() < 0.25 * outer.geometry.area.mean() + + +def test_dist_params_emit_deprecation_warning_but_still_mesh(): + # The legacy dist_min/dist_max linear-threshold path still works (back-compat) + # but now warns that it is deprecated in favor of GeometricGrowthField. + mg, clean = _domain_with_fine_zone(dist_min=0.5, dist_max=10.0) + with pytest.warns(DeprecationWarning, match="dist_min/dist_max are deprecated"): + assert mg.generate(*clean) + assert not mg.get_element_grid().empty + + +def test_growth_factor_controls_default_refinement_spread(): + # A slower growth factor keeps cells fine over a larger region, so it yields + # more elements than a fast one -- confirming the parameter is wired through. + mg_slow, clean_slow = _domain_with_fine_zone(growth_factor=1.05) + assert mg_slow.generate(*clean_slow) + slow = len(mg_slow.get_element_grid()) + + mg_fast, clean_fast = _domain_with_fine_zone(growth_factor=2.0) + assert mg_fast.generate(*clean_fast) + fast = len(mg_fast.get_element_grid()) + + assert slow > fast + + +def test_engine_rejects_invalid_growth_factor_in_prebuilt_feature_table(): + mg, clean = _domain_with_fine_zone() + clean_polys, clean_lines, clean_points = clean + fine = clean_polys["zone_id"] == "fine" + clean_polys.loc[fine, "growth_factor"] = 1.0 + + with pytest.raises(ValueError, match="growth_factor"): + mg.generate(clean_polys, clean_lines, clean_points) + + +@pytest.mark.parametrize("background_lc", [0.0, -1.0, float("nan"), float("inf")]) +def test_engine_rejects_invalid_background_size(background_lc): + mg, clean = _domain_with_fine_zone() + mg.background_lc = background_lc + + with pytest.raises(ValueError, match="background_lc"): + mg.generate(*clean) diff --git a/tests/test_line_embedding.py b/tests/test_line_embedding.py new file mode 100644 index 0000000..8b8e19f --- /dev/null +++ b/tests/test_line_embedding.py @@ -0,0 +1,236 @@ +""" +Tests for line embedding in the presence of polygons. + +Regression tests for the bug where lines were not properly embedded into +the triangular mesh when polygons were also present. Root causes: + 1. getEntitiesInBoundingBox requires containment, not intersection — tiny + entity bboxes could never contain large domain surfaces. + 2. Boundary lines (created by fragment when a line crosses a polygon edge) + were re-embedded into their own surface, corrupting the mesh. +""" + +import pytest +from shapely.geometry import Polygon, LineString, Point + +from vorflow.blueprint import ConceptualMesh +from vorflow.engine import MeshGenerator, _unit_tangent +from vorflow.tessellator import VoronoiTessellator + + + +def _nodes_near_line(nodes, line, tolerance): + """Count mesh nodes that lie within `tolerance` of a LineString.""" + count = 0 + for x, y in nodes: + pt = Point(x, y) + if line.distance(pt) < tolerance: + count += 1 + return count + + +class TestLineEmbeddingWithPolygons: + """ + Core regression: a line crossing through a domain that also contains + interior polygons must produce mesh nodes along the full line path, + not just at polygon boundaries. + """ + + def test_line_embedded_with_polygon_present(self): + """ + A line crossing through a domain with an interior polygon must + produce nodes along the line — the defining symptom of the bug + was that zero nodes appeared along interior line segments. + """ + cm = ConceptualMesh(crs="EPSG:3857") + + # Large domain + domain = Polygon([(0, 0), (100, 0), (100, 50), (0, 50)]) + cm.add_polygon(domain, zone_id=1, resolution=10.0, z_order=0) + + # Small interior square that the line crosses through + square = Polygon([(40, 15), (60, 15), (60, 35), (40, 35)]) + cm.add_polygon(square, zone_id=2, resolution=5.0, z_order=1) + + # Horizontal line crossing through the square + line = LineString([(10, 25), (90, 25)]) + cm.add_line(line, line_id="crossing_line", resolution=3.0) + + clean_polys, clean_lines, clean_points = cm.generate() + + mg = MeshGenerator(background_lc=10.0, verbosity=0) + success = mg.generate(clean_polys, clean_lines, clean_points) + assert success, "Mesh generation failed" + + # Count nodes near the line — before the fix this was ~0 + nodes_on_line = _nodes_near_line(mg.nodes, line, tolerance=1.0) + + # With resolution=3.0 on an 80-unit line, we expect ~25+ nodes + assert nodes_on_line >= 10, ( + f"Only {nodes_on_line} nodes found near line — " + f"line embedding likely broken (expected >= 10)" + ) + + def test_line_embedded_without_polygon(self): + """ + Baseline: line embedding works correctly without interior polygons. + This should always pass — it's the control case. + """ + cm = ConceptualMesh(crs="EPSG:3857") + + domain = Polygon([(0, 0), (100, 0), (100, 50), (0, 50)]) + cm.add_polygon(domain, zone_id=1, resolution=10.0, z_order=0) + + line = LineString([(10, 25), (90, 25)]) + cm.add_line(line, line_id="simple_line", resolution=3.0) + + clean_polys, clean_lines, clean_points = cm.generate() + + mg = MeshGenerator(background_lc=10.0, verbosity=0) + success = mg.generate(clean_polys, clean_lines, clean_points) + assert success + + nodes_on_line = _nodes_near_line(mg.nodes, line, tolerance=1.0) + assert nodes_on_line >= 10, ( + f"Only {nodes_on_line} nodes near line in no-polygon case" + ) + + def test_line_node_count_comparable_with_and_without_polygons(self): + """ + The number of nodes near a line should be roughly similar whether + or not an interior polygon exists. The original bug caused a near- + total loss of line nodes when polygons were present. + """ + line = LineString([(10, 25), (90, 25)]) + + # Case A: without polygon + cm_a = ConceptualMesh(crs="EPSG:3857") + domain = Polygon([(0, 0), (100, 0), (100, 50), (0, 50)]) + cm_a.add_polygon(domain, zone_id=1, resolution=10.0, z_order=0) + cm_a.add_line(line, line_id="line_a", resolution=3.0) + polys_a, lines_a, pts_a = cm_a.generate() + mg_a = MeshGenerator(background_lc=10.0, verbosity=0) + mg_a.generate(polys_a, lines_a, pts_a) + nodes_a = _nodes_near_line(mg_a.nodes, line, tolerance=1.0) + + # Case B: with polygon + cm_b = ConceptualMesh(crs="EPSG:3857") + cm_b.add_polygon(domain, zone_id=1, resolution=10.0, z_order=0) + square = Polygon([(40, 15), (60, 15), (60, 35), (40, 35)]) + cm_b.add_polygon(square, zone_id=2, resolution=5.0, z_order=1) + cm_b.add_line(line, line_id="line_b", resolution=3.0) + polys_b, lines_b, pts_b = cm_b.generate() + mg_b = MeshGenerator(background_lc=10.0, verbosity=0) + mg_b.generate(polys_b, lines_b, pts_b) + nodes_b = _nodes_near_line(mg_b.nodes, line, tolerance=1.0) + + # Case B should have at least 50% of Case A's nodes + # (it may have more due to the finer polygon resolution) + ratio = nodes_b / max(nodes_a, 1) + assert ratio >= 0.5, ( + f"With-polygon case has {nodes_b} nodes vs {nodes_a} without — " + f"ratio {ratio:.2f} < 0.5, embedding likely broken" + ) + + def test_line_crossing_multiple_polygons(self): + """ + A line that crosses through multiple interior polygons must still + produce nodes along its full length. + """ + cm = ConceptualMesh(crs="EPSG:3857") + + domain = Polygon([(0, 0), (200, 0), (200, 50), (0, 50)]) + cm.add_polygon(domain, zone_id=1, resolution=15.0, z_order=0) + + # Three squares along the line path + for i, x_start in enumerate([30, 80, 140]): + sq = Polygon([ + (x_start, 15), (x_start + 20, 15), + (x_start + 20, 35), (x_start, 35) + ]) + cm.add_polygon(sq, zone_id=10 + i, resolution=5.0, z_order=1) + + line = LineString([(10, 25), (190, 25)]) + cm.add_line(line, line_id="multi_cross", resolution=5.0) + + clean_polys, clean_lines, clean_points = cm.generate() + + mg = MeshGenerator(background_lc=15.0, verbosity=0) + success = mg.generate(clean_polys, clean_lines, clean_points) + assert success + + nodes_on_line = _nodes_near_line(mg.nodes, line, tolerance=1.5) + # 180-unit line at resolution 5 → ~36 segments → ~30+ nodes expected + assert nodes_on_line >= 15, ( + f"Only {nodes_on_line} nodes on line crossing 3 polygons" + ) + + def test_mesh_area_conservation_with_embedded_line(self): + """ + Total mesh area must match the domain area, ensuring no + garbage triangles extend outside the domain. + """ + cm = ConceptualMesh(crs="EPSG:3857") + + domain = Polygon([(0, 0), (100, 0), (100, 50), (0, 50)]) + cm.add_polygon(domain, zone_id=1, resolution=10.0, z_order=0) + + square = Polygon([(40, 15), (60, 15), (60, 35), (40, 35)]) + cm.add_polygon(square, zone_id=2, resolution=5.0, z_order=1) + + line = LineString([(10, 25), (90, 25)]) + cm.add_line(line, line_id="area_test", resolution=3.0) + + clean_polys, clean_lines, clean_points = cm.generate() + + mg = MeshGenerator(background_lc=10.0, verbosity=0) + success = mg.generate(clean_polys, clean_lines, clean_points) + assert success + + vt = VoronoiTessellator(mg, cm, clip_to_boundary=True) + grid = vt.generate() + + total_area = grid.geometry.area.sum() + expected_area = domain.area # 5000 + assert pytest.approx(total_area, rel=0.02) == expected_area, ( + f"Area mismatch: {total_area:.1f} vs {expected_area:.1f} — " + f"possible out-of-domain triangles" + ) + + +class TestUnitTangent: + """Regression tests for the straddle-point tangent probe. + + The old implementation used fixed absolute steps (0.01/0.001 CRS units), + which blended directions across corners of short lines and degenerated + on lines shorter than the step. + """ + + def test_straight_line_tangent(self): + line = LineString([(0, 0), (10, 0)]) + probe = line.length * 1e-4 + for d in (0.0, 5.0, 10.0): + dx, dy = _unit_tangent(line, d, probe) + assert (dx, dy) == pytest.approx((1.0, 0.0), abs=1e-9) + + def test_bent_line_respects_local_direction(self): + # L-shape with legs much shorter than the old 0.01 fixed probe: + # tangent at the start must follow the first leg, at the end the + # second leg -- not the corner-cutting chord. + line = LineString([(0, 0), (0.005, 0), (0.005, 0.005)]) + probe = line.length * 1e-4 + dx, dy = _unit_tangent(line, 0.0, probe) + assert (dx, dy) == pytest.approx((1.0, 0.0), abs=1e-6) + dx, dy = _unit_tangent(line, line.length, probe) + assert (dx, dy) == pytest.approx((0.0, 1.0), abs=1e-6) + + def test_tangent_is_unit_length_everywhere(self): + line = LineString([(0, 0), (3, 4), (10, 4)]) + probe = line.length * 1e-4 + for frac in (0.0, 0.2, 0.5, 0.8, 1.0): + dx, dy = _unit_tangent(line, line.length * frac, probe) + assert dx * dx + dy * dy == pytest.approx(1.0, abs=1e-12) + + def test_degenerate_line_returns_unit_vector(self): + line = LineString([(2, 2), (2, 2)]) + dx, dy = _unit_tangent(line, 0.0, 1e-12) + assert dx * dx + dy * dy == pytest.approx(1.0) diff --git a/tests/test_pipeline.py b/tests/test_pipeline.py index a814166..e477a26 100644 --- a/tests/test_pipeline.py +++ b/tests/test_pipeline.py @@ -55,7 +55,7 @@ def __init__(self): def _build_simple_conceptual_mesh(): cm = ConceptualMesh(crs="EPSG:3857") square = Polygon([(0, 0), (2, 0), (2, 2), (0, 2)]) - cm.add_polygon(square, zone_id=99, border_density=0.5) + cm.add_polygon(square, zone_id=99, densify=0.5) return cm diff --git a/tests/test_point_tracking.py b/tests/test_point_tracking.py new file mode 100644 index 0000000..3a883b5 --- /dev/null +++ b/tests/test_point_tracking.py @@ -0,0 +1,769 @@ +""" +Tests for point entity tracking through the fragment → removeAllDuplicates → healShapes pipeline. + +These tests verify that dim-0 (point) entities added to the Gmsh model survive +each stage of the _add_geometry pipeline and are correctly reflected in the +returned gmsh_map, so that _embed_features and _setup_fields can find them. +""" +import pytest +import gmsh +from shapely.geometry import Point, Polygon, LineString + +from vorflow.blueprint import ConceptualMesh +from vorflow.engine import MeshGenerator + +pytestmark = pytest.mark.slow # gmsh-heavy end-to-end tests + + + +# --------------------------------------------------------------------------- +# Helpers +# --------------------------------------------------------------------------- + +def _build_model(polygon_coords, points, lines=None, + background_lc=5.0, polygon_res=5.0, point_res=1.0, + heal_shapes=False, heal_tolerance=1e-8, + heal_fix_degenerated=True, heal_fix_small_edges=True, + heal_fix_small_faces=True): + """ + Build a ConceptualMesh with a single polygon + N points, run + _add_geometry, and return (mg, gmsh_map, clean_points). + """ + cm = ConceptualMesh(crs="EPSG:3857") + poly = Polygon(polygon_coords) + cm.add_polygon(poly, zone_id=1, resolution=polygon_res, dist_max=25.0) + + for i, pt in enumerate(points): + cm.add_point(pt, point_id=f"pt_{i}", resolution=point_res, dist_min=0, dist_max=5.0) + + if lines: + for i, ln in enumerate(lines): + cm.add_line(ln, line_id=f"ln_{i}", resolution=point_res) + + clean_polys, clean_lines, clean_points = cm.generate() + + mg = MeshGenerator( + background_lc=background_lc, + verbosity=2, + heal_shapes=heal_shapes, + heal_tolerance=heal_tolerance, + heal_fix_degenerated=heal_fix_degenerated, + heal_fix_small_edges=heal_fix_small_edges, + heal_fix_small_faces=heal_fix_small_faces, + ) + mg._initialize_gmsh() + gmsh_map = mg._add_geometry(clean_polys, clean_lines, clean_points) + return mg, gmsh_map, clean_points + + +def _count_mapped_points(gmsh_map): + """Count how many point feature IDs have at least one valid dim-0 tag.""" + n_features_with_tags = 0 + n_total_dim0 = 0 + for feat_id, dimtags in gmsh_map.get('points', {}).items(): + dim0_tags = [dt for dt in dimtags if isinstance(dt, (tuple, list)) and int(dt[0]) == 0] + if dim0_tags: + n_features_with_tags += 1 + n_total_dim0 += len(dim0_tags) + return n_features_with_tags, n_total_dim0 + + +def _verify_tags_exist_in_model(gmsh_map): + """Verify every tag in gmsh_map['points'] actually exists in the synchronized model.""" + model_entities = set() + for dim in range(3): + for dt in gmsh.model.getEntities(dim): + model_entities.add((int(dt[0]), int(dt[1]))) + + missing = [] + for feat_id, dimtags in gmsh_map.get('points', {}).items(): + for dt in dimtags: + if isinstance(dt, (tuple, list)) and len(dt) >= 2: + key = (int(dt[0]), int(dt[1])) + if key not in model_entities: + missing.append((feat_id, key)) + return missing + + +# --------------------------------------------------------------------------- +# Test: Basic point survival (no heal) +# --------------------------------------------------------------------------- + +class TestPointTrackingNoHeal: + """Points should survive fragment + removeAllDuplicates without heal.""" + + def test_single_point_inside_polygon(self): + """One point in the center of a square.""" + mg, gmap, pts = _build_model( + polygon_coords=[(0, 0), (10, 0), (10, 10), (0, 10)], + points=[Point(5, 5)], + heal_shapes=False, + ) + n_feat, n_tags = _count_mapped_points(gmap) + assert n_feat == 1, f"Expected 1 point feature mapped, got {n_feat}" + assert n_tags >= 1, f"Expected >= 1 dim-0 tag, got {n_tags}" + assert _verify_tags_exist_in_model(gmap) == [], "Stale tags in map" + + def test_multiple_points_spread(self): + """Several points spread across a polygon.""" + pts = [Point(2, 2), Point(5, 5), Point(8, 8), Point(3, 7)] + mg, gmap, _ = _build_model( + polygon_coords=[(0, 0), (10, 0), (10, 10), (0, 10)], + points=pts, + heal_shapes=False, + ) + n_feat, n_tags = _count_mapped_points(gmap) + assert n_feat == len(pts), f"Expected {len(pts)} point features, got {n_feat}" + assert n_tags >= len(pts), f"Expected >= {len(pts)} dim-0 tags, got {n_tags}" + assert _verify_tags_exist_in_model(gmap) == [] + + def test_point_on_polygon_vertex(self): + """Point exactly on a polygon vertex — fragment may merge them.""" + mg, gmap, _ = _build_model( + polygon_coords=[(0, 0), (10, 0), (10, 10), (0, 10)], + points=[Point(0, 0)], + heal_shapes=False, + ) + n_feat, n_tags = _count_mapped_points(gmap) + assert n_feat == 1, f"Expected 1 point feature, got {n_feat}" + # The tag might have been merged with the polygon vertex, but the + # map entry must still reference a valid dim-0 entity. + assert n_tags >= 1, f"Expected >= 1 dim-0 tag, got {n_tags}" + assert _verify_tags_exist_in_model(gmap) == [] + + def test_point_on_polygon_edge(self): + """Point on a polygon edge midpoint.""" + mg, gmap, _ = _build_model( + polygon_coords=[(0, 0), (10, 0), (10, 10), (0, 10)], + points=[Point(5, 0)], + heal_shapes=False, + ) + n_feat, n_tags = _count_mapped_points(gmap) + assert n_feat == 1 + assert n_tags >= 1 + assert _verify_tags_exist_in_model(gmap) == [] + + def test_many_points(self): + """29 points (matching user's real case) inside a large polygon.""" + import random + random.seed(42) + pts = [Point(random.uniform(1, 99), random.uniform(1, 99)) for _ in range(29)] + mg, gmap, _ = _build_model( + polygon_coords=[(0, 0), (100, 0), (100, 100), (0, 100)], + points=pts, + heal_shapes=False, + ) + n_feat, n_tags = _count_mapped_points(gmap) + assert n_feat == 29, f"Expected 29 point features, got {n_feat}" + assert n_tags >= 29 + assert _verify_tags_exist_in_model(gmap) == [] + + +# --------------------------------------------------------------------------- +# Test: Points with heal_shapes ON (all fix options OFF) +# --------------------------------------------------------------------------- + +class TestPointTrackingHealAllOff: + """Points should survive when heal_shapes=True but all fix flags are False.""" + + def test_single_point_heal_noop(self): + mg, gmap, _ = _build_model( + polygon_coords=[(0, 0), (10, 0), (10, 10), (0, 10)], + points=[Point(5, 5)], + heal_shapes=True, + heal_tolerance=1e-8, + heal_fix_degenerated=False, + heal_fix_small_edges=False, + heal_fix_small_faces=False, + ) + n_feat, n_tags = _count_mapped_points(gmap) + assert n_feat == 1 + assert n_tags >= 1 + assert _verify_tags_exist_in_model(gmap) == [] + + def test_multiple_points_heal_noop(self): + pts = [Point(2, 2), Point(5, 5), Point(8, 8)] + mg, gmap, _ = _build_model( + polygon_coords=[(0, 0), (10, 0), (10, 10), (0, 10)], + points=pts, + heal_shapes=True, + heal_tolerance=1e-8, + heal_fix_degenerated=False, + heal_fix_small_edges=False, + heal_fix_small_faces=False, + ) + n_feat, n_tags = _count_mapped_points(gmap) + assert n_feat == len(pts), f"Expected {len(pts)}, got {n_feat}" + assert n_tags >= len(pts) + assert _verify_tags_exist_in_model(gmap) == [] + + def test_many_points_heal_noop(self): + """29 points, heal on but all fixes off.""" + import random + random.seed(42) + pts = [Point(random.uniform(1, 99), random.uniform(1, 99)) for _ in range(29)] + mg, gmap, _ = _build_model( + polygon_coords=[(0, 0), (100, 0), (100, 100), (0, 100)], + points=pts, + heal_shapes=True, + heal_tolerance=1e-8, + heal_fix_degenerated=False, + heal_fix_small_edges=False, + heal_fix_small_faces=False, + ) + n_feat, n_tags = _count_mapped_points(gmap) + assert n_feat == 29, f"Expected 29, got {n_feat}" + assert n_tags >= 29 + assert _verify_tags_exist_in_model(gmap) == [] + + def test_large_tolerance_heal_all_off(self): + """heal_tolerance=1 (large) but all fix flags off — should be no-op.""" + pts = [Point(2, 2), Point(5, 5), Point(8, 8)] + mg, gmap, _ = _build_model( + polygon_coords=[(0, 0), (10, 0), (10, 10), (0, 10)], + points=pts, + heal_shapes=True, + heal_tolerance=1.0, + heal_fix_degenerated=False, + heal_fix_small_edges=False, + heal_fix_small_faces=False, + ) + n_feat, n_tags = _count_mapped_points(gmap) + assert n_feat == len(pts), f"Expected {len(pts)}, got {n_feat}" + assert n_tags >= len(pts) + assert _verify_tags_exist_in_model(gmap) == [] + + +# --------------------------------------------------------------------------- +# Test: Points with heal_shapes ON (default fix options) +# --------------------------------------------------------------------------- + +class TestPointTrackingHealDefaults: + """Points should survive healShapes with default fix options at small tolerance.""" + + def test_single_point_heal_defaults(self): + mg, gmap, _ = _build_model( + polygon_coords=[(0, 0), (10, 0), (10, 10), (0, 10)], + points=[Point(5, 5)], + heal_shapes=True, + heal_tolerance=1e-8, + ) + n_feat, n_tags = _count_mapped_points(gmap) + assert n_feat == 1 + assert n_tags >= 1 + assert _verify_tags_exist_in_model(gmap) == [] + + def test_many_points_heal_defaults(self): + import random + random.seed(42) + pts = [Point(random.uniform(1, 99), random.uniform(1, 99)) for _ in range(29)] + mg, gmap, _ = _build_model( + polygon_coords=[(0, 0), (100, 0), (100, 100), (0, 100)], + points=pts, + heal_shapes=True, + heal_tolerance=1e-8, + ) + n_feat, n_tags = _count_mapped_points(gmap) + assert n_feat == 29, f"Expected 29, got {n_feat}" + assert n_tags >= 29 + assert _verify_tags_exist_in_model(gmap) == [] + + +# --------------------------------------------------------------------------- +# Test: Points with large coordinates (projected CRS like user's ~585000) +# --------------------------------------------------------------------------- + +class TestPointTrackingLargeCoords: + """Test with coordinate magnitudes matching real projected CRS data.""" + + ORIGIN_X = 584000.0 + ORIGIN_Y = 2366000.0 + + def _large_poly(self): + ox, oy = self.ORIGIN_X, self.ORIGIN_Y + return [(ox, oy), (ox + 13000, oy), (ox + 13000, oy + 9000), (ox, oy + 9000)] + + def test_large_coords_no_heal(self): + ox, oy = self.ORIGIN_X, self.ORIGIN_Y + pts = [ + Point(ox + 1000, oy + 1000), + Point(ox + 6000, oy + 4500), + Point(ox + 12000, oy + 8000), + ] + mg, gmap, _ = _build_model( + polygon_coords=self._large_poly(), + points=pts, + background_lc=500.0, + polygon_res=500.0, + point_res=100.0, + heal_shapes=False, + ) + n_feat, n_tags = _count_mapped_points(gmap) + assert n_feat == len(pts), f"Expected {len(pts)}, got {n_feat}" + assert n_tags >= len(pts) + assert _verify_tags_exist_in_model(gmap) == [] + + def test_large_coords_heal_all_off(self): + ox, oy = self.ORIGIN_X, self.ORIGIN_Y + pts = [ + Point(ox + 1000, oy + 1000), + Point(ox + 6000, oy + 4500), + Point(ox + 12000, oy + 8000), + ] + mg, gmap, _ = _build_model( + polygon_coords=self._large_poly(), + points=pts, + background_lc=500.0, + polygon_res=500.0, + point_res=100.0, + heal_shapes=True, + heal_tolerance=1.0, + heal_fix_degenerated=False, + heal_fix_small_edges=False, + heal_fix_small_faces=False, + ) + n_feat, n_tags = _count_mapped_points(gmap) + assert n_feat == len(pts), f"Expected {len(pts)}, got {n_feat}" + assert n_tags >= len(pts) + assert _verify_tags_exist_in_model(gmap) == [] + + def test_large_coords_heal_defaults(self): + ox, oy = self.ORIGIN_X, self.ORIGIN_Y + pts = [ + Point(ox + 1000, oy + 1000), + Point(ox + 6000, oy + 4500), + Point(ox + 12000, oy + 8000), + ] + mg, gmap, _ = _build_model( + polygon_coords=self._large_poly(), + points=pts, + background_lc=500.0, + polygon_res=500.0, + point_res=100.0, + heal_shapes=True, + heal_tolerance=1e-8, + ) + n_feat, n_tags = _count_mapped_points(gmap) + assert n_feat == len(pts), f"Expected {len(pts)}, got {n_feat}" + assert n_tags >= len(pts) + assert _verify_tags_exist_in_model(gmap) == [] + + def test_29_points_large_coords_heal_all_off_tol1(self): + """Closest to user's actual scenario: 29 pts, large coords, heal on, all off, tol=1.""" + import random + random.seed(99) + ox, oy = self.ORIGIN_X, self.ORIGIN_Y + pts = [ + Point(ox + random.uniform(500, 12500), oy + random.uniform(500, 8500)) + for _ in range(29) + ] + mg, gmap, _ = _build_model( + polygon_coords=self._large_poly(), + points=pts, + background_lc=500.0, + polygon_res=500.0, + point_res=100.0, + heal_shapes=True, + heal_tolerance=1.0, + heal_fix_degenerated=False, + heal_fix_small_edges=False, + heal_fix_small_faces=False, + ) + n_feat, n_tags = _count_mapped_points(gmap) + assert n_feat == 29, f"Expected 29, got {n_feat}" + assert n_tags >= 29 + missing = _verify_tags_exist_in_model(gmap) + assert missing == [], f"Stale tags: {missing}" + + +# --------------------------------------------------------------------------- +# Test: Points with multiple overlapping polygons +# --------------------------------------------------------------------------- + +class TestPointTrackingMultiPolygon: + """Points inside overlapping polygons (forces non-trivial fragmentation).""" + + def test_points_in_overlapping_polygons_no_heal(self): + cm = ConceptualMesh(crs="EPSG:3857") + cm.add_polygon(Polygon([(0, 0), (10, 0), (10, 10), (0, 10)]), + zone_id=1, resolution=5.0, dist_max=25.0, z_order=0) + cm.add_polygon(Polygon([(3, 3), (7, 3), (7, 7), (3, 7)]), + zone_id=2, resolution=2.0, dist_max=10.0, z_order=1) + cm.add_point(Point(5, 5), point_id="center", resolution=0.5, dist_min=0, dist_max=3) + cm.add_point(Point(1, 1), point_id="outer", resolution=0.5, dist_min=0, dist_max=3) + + clean_polys, clean_lines, clean_points = cm.generate() + mg = MeshGenerator(background_lc=5.0, verbosity=2, heal_shapes=False) + mg._initialize_gmsh() + gmap = mg._add_geometry(clean_polys, clean_lines, clean_points) + + n_feat, n_tags = _count_mapped_points(gmap) + assert n_feat == 2, f"Expected 2, got {n_feat}" + assert n_tags >= 2 + assert _verify_tags_exist_in_model(gmap) == [] + + def test_points_in_overlapping_polygons_heal_all_off(self): + cm = ConceptualMesh(crs="EPSG:3857") + cm.add_polygon(Polygon([(0, 0), (10, 0), (10, 10), (0, 10)]), + zone_id=1, resolution=5.0, dist_max=25.0, z_order=0) + cm.add_polygon(Polygon([(3, 3), (7, 3), (7, 7), (3, 7)]), + zone_id=2, resolution=2.0, dist_max=10.0, z_order=1) + cm.add_point(Point(5, 5), point_id="center", resolution=0.5, dist_min=0, dist_max=3) + cm.add_point(Point(1, 1), point_id="outer", resolution=0.5, dist_min=0, dist_max=3) + + clean_polys, clean_lines, clean_points = cm.generate() + mg = MeshGenerator( + background_lc=5.0, verbosity=2, + heal_shapes=True, heal_tolerance=1.0, + heal_fix_degenerated=False, heal_fix_small_edges=False, heal_fix_small_faces=False, + ) + mg._initialize_gmsh() + gmap = mg._add_geometry(clean_polys, clean_lines, clean_points) + + n_feat, n_tags = _count_mapped_points(gmap) + assert n_feat == 2, f"Expected 2, got {n_feat}" + assert n_tags >= 2 + assert _verify_tags_exist_in_model(gmap) == [] + + +# --------------------------------------------------------------------------- +# Test: Points with lines (combined features) +# --------------------------------------------------------------------------- + +class TestPointTrackingWithLines: + """Points + lines together — fragments create more complex topology.""" + + def test_points_and_line_no_heal(self): + mg, gmap, _ = _build_model( + polygon_coords=[(0, 0), (10, 0), (10, 10), (0, 10)], + points=[Point(5, 5), Point(2, 8)], + lines=[LineString([(1, 1), (9, 9)])], + heal_shapes=False, + ) + n_feat, n_tags = _count_mapped_points(gmap) + assert n_feat >= 2, f"Expected >= 2, got {n_feat}" + assert n_tags >= 2 + assert _verify_tags_exist_in_model(gmap) == [] + + def test_points_and_line_heal_all_off(self): + mg, gmap, _ = _build_model( + polygon_coords=[(0, 0), (10, 0), (10, 10), (0, 10)], + points=[Point(5, 5), Point(2, 8)], + lines=[LineString([(1, 1), (9, 9)])], + heal_shapes=True, + heal_tolerance=1.0, + heal_fix_degenerated=False, + heal_fix_small_edges=False, + heal_fix_small_faces=False, + ) + n_feat, n_tags = _count_mapped_points(gmap) + assert n_feat >= 2, f"Expected >= 2, got {n_feat}" + assert n_tags >= 2 + assert _verify_tags_exist_in_model(gmap) == [] + + def test_point_on_line_endpoint(self): + """Point coincident with a line endpoint — high merge probability.""" + mg, gmap, _ = _build_model( + polygon_coords=[(0, 0), (10, 0), (10, 10), (0, 10)], + points=[Point(1, 1)], + lines=[LineString([(1, 1), (9, 9)])], + heal_shapes=True, + heal_tolerance=1e-8, + heal_fix_degenerated=False, + heal_fix_small_edges=False, + heal_fix_small_faces=False, + ) + n_feat, n_tags = _count_mapped_points(gmap) + assert n_feat >= 1 + assert n_tags >= 1 + assert _verify_tags_exist_in_model(gmap) == [] + + +# --------------------------------------------------------------------------- +# Test: Full pipeline (generate mesh, check for mesh nodes near points) +# --------------------------------------------------------------------------- + +class TestPointEmbeddingEndToEnd: + """Full pipeline: points should produce mesh vertices at their locations.""" + + def _get_mesh_node_near(self, mg, x, y, tol): + """Check if any mesh node is within tol of (x, y).""" + if mg.nodes is None: + return False + import numpy as np + dists = np.sqrt((mg.nodes[:, 0] - x) ** 2 + (mg.nodes[:, 1] - y) ** 2) + return bool(np.any(dists < tol)) + + def test_embedded_point_creates_mesh_vertex_no_heal(self): + cm = ConceptualMesh(crs="EPSG:3857") + cm.add_polygon(Polygon([(0, 0), (10, 0), (10, 10), (0, 10)]), + zone_id=1, resolution=2.0, dist_max=10.0) + cm.add_point(Point(5, 5), point_id="well", resolution=0.5, dist_min=0, dist_max=3) + clean_polys, clean_lines, clean_points = cm.generate() + + mg = MeshGenerator(background_lc=2.0, verbosity=2, heal_shapes=False) + success = mg.generate(clean_polys, clean_lines, clean_points) + assert success + assert self._get_mesh_node_near(mg, 5.0, 5.0, 0.01), \ + "No mesh node found near embedded point (5,5) with heal OFF" + + def test_embedded_point_creates_mesh_vertex_heal_all_off(self): + cm = ConceptualMesh(crs="EPSG:3857") + cm.add_polygon(Polygon([(0, 0), (10, 0), (10, 10), (0, 10)]), + zone_id=1, resolution=2.0, dist_max=10.0) + cm.add_point(Point(5, 5), point_id="well", resolution=0.5, dist_min=0, dist_max=3) + clean_polys, clean_lines, clean_points = cm.generate() + + mg = MeshGenerator( + background_lc=2.0, verbosity=2, + heal_shapes=True, heal_tolerance=1.0, + heal_fix_degenerated=False, heal_fix_small_edges=False, heal_fix_small_faces=False, + ) + success = mg.generate(clean_polys, clean_lines, clean_points) + assert success + assert self._get_mesh_node_near(mg, 5.0, 5.0, 0.01), \ + "No mesh node found near embedded point (5,5) with heal ON (all off, tol=1)" + + def test_multiple_points_create_mesh_vertices_heal_all_off(self): + cm = ConceptualMesh(crs="EPSG:3857") + cm.add_polygon(Polygon([(0, 0), (20, 0), (20, 20), (0, 20)]), + zone_id=1, resolution=5.0, dist_max=25.0) + test_pts = [(5, 5), (15, 5), (10, 15)] + for i, (x, y) in enumerate(test_pts): + cm.add_point(Point(x, y), point_id=f"pt{i}", resolution=1.0, dist_min=0, dist_max=5) + clean_polys, clean_lines, clean_points = cm.generate() + + mg = MeshGenerator( + background_lc=5.0, verbosity=2, + heal_shapes=True, heal_tolerance=1.0, + heal_fix_degenerated=False, heal_fix_small_edges=False, heal_fix_small_faces=False, + ) + success = mg.generate(clean_polys, clean_lines, clean_points) + assert success + + missing = [] + for x, y in test_pts: + if not self._get_mesh_node_near(mg, x, y, 0.1): + missing.append((x, y)) + assert missing == [], f"No mesh node near these points: {missing}" + + def test_large_coords_embedded_point_heal_all_off(self): + """User scenario: large projected coords, heal on, all off, tol=1.""" + ox, oy = 584000.0, 2366000.0 + cm = ConceptualMesh(crs="EPSG:3857") + cm.add_polygon( + Polygon([(ox, oy), (ox + 13000, oy), (ox + 13000, oy + 9000), (ox, oy + 9000)]), + zone_id=1, resolution=500.0, dist_max=2000.0, + ) + test_pts = [ + (ox + 2000, oy + 2000), + (ox + 6500, oy + 4500), + (ox + 11000, oy + 7000), + ] + for i, (x, y) in enumerate(test_pts): + cm.add_point(Point(x, y), point_id=f"well_{i}", resolution=100.0, dist_min=0, dist_max=500) + clean_polys, clean_lines, clean_points = cm.generate() + + mg = MeshGenerator( + background_lc=500.0, verbosity=2, + heal_shapes=True, heal_tolerance=1.0, + heal_fix_degenerated=False, heal_fix_small_edges=False, heal_fix_small_faces=False, + ) + success = mg.generate(clean_polys, clean_lines, clean_points) + assert success + + missing = [] + for x, y in test_pts: + if not self._get_mesh_node_near(mg, x, y, 1.0): + missing.append((x, y)) + assert missing == [], f"No mesh node near these points: {missing}" + + +# --------------------------------------------------------------------------- +# Test: Isolation — raw Gmsh API to prove what removeAllDuplicates/healShapes do +# --------------------------------------------------------------------------- + +class TestRawGmshPointBehavior: + """ + Directly test Gmsh API behavior to isolate whether removeAllDuplicates + or healShapes destroy/renumber dim-0 entities. + """ + + def test_removeAllDuplicates_preserves_interior_point(self): + """A point inside a surface should survive removeAllDuplicates.""" + gmsh.initialize() + gmsh.model.add("test_dup") + occ = gmsh.model.occ + + # Square surface + p1 = occ.addPoint(0, 0, 0) + p2 = occ.addPoint(10, 0, 0) + p3 = occ.addPoint(10, 10, 0) + p4 = occ.addPoint(0, 10, 0) + l1 = occ.addLine(p1, p2) + l2 = occ.addLine(p2, p3) + l3 = occ.addLine(p3, p4) + l4 = occ.addLine(p4, p1) + cl = occ.addCurveLoop([l1, l2, l3, l4]) + s = occ.addPlaneSurface([cl]) + + # Interior point + pt_interior = occ.addPoint(5, 5, 0) + + # Fragment + all_tags = [(2, s), (0, pt_interior)] + out_dt, out_map = occ.fragment(all_tags, []) + + pts_before = set(t for d, t in occ.getEntities(0)) + occ.removeAllDuplicates() + pts_after = set(t for d, t in occ.getEntities(0)) + + # The interior point should not have been removed + # (it's not a duplicate of any vertex) + assert len(pts_after) >= len(pts_before), \ + f"removeAllDuplicates removed points: before={pts_before}, after={pts_after}" + + def test_removeAllDuplicates_merges_coincident_points(self): + """Two coincident points should be merged by removeAllDuplicates.""" + gmsh.initialize() + gmsh.model.add("test_dup_merge") + occ = gmsh.model.occ + + occ.addPoint(5, 5, 0) + occ.addPoint(5, 5, 0) + + pts_before = set(t for d, t in occ.getEntities(0)) + assert len(pts_before) == 2 + + occ.removeAllDuplicates() + pts_after = set(t for d, t in occ.getEntities(0)) + + # After dedup, only one should remain + assert len(pts_after) == 1, f"Expected 1 point after dedup, got {pts_after}" + + def test_healShapes_all_off_preserves_points(self): + """healShapes with all fix options off should not remove points (may renumber).""" + gmsh.initialize() + gmsh.model.add("test_heal_noop") + occ = gmsh.model.occ + + p1 = occ.addPoint(0, 0, 0) + p2 = occ.addPoint(10, 0, 0) + p3 = occ.addPoint(10, 10, 0) + p4 = occ.addPoint(0, 10, 0) + l1 = occ.addLine(p1, p2) + l2 = occ.addLine(p2, p3) + l3 = occ.addLine(p3, p4) + l4 = occ.addLine(p4, p1) + cl = occ.addCurveLoop([l1, l2, l3, l4]) + s = occ.addPlaneSurface([cl]) + pt = occ.addPoint(5, 5, 0) + + all_tags = [(2, s), (0, pt)] + occ.fragment(all_tags, []) + + pts_before_heal = set(t for d, t in occ.getEntities(0)) + n_before = len(pts_before_heal) + + # Save coordinates of interior point for verification + bb = occ.getBoundingBox(0, pt) + pt_coord = (round(bb[0], 6), round(bb[1], 6), round(bb[2], 6)) + + occ.healShapes( + [], tolerance=1.0, + fixDegenerated=False, fixSmallEdges=False, fixSmallFaces=False, + sewFaces=False, makeSolids=False, + ) + pts_after_heal = occ.getEntities(0) + n_after = len(pts_after_heal) + + # NOTE: healShapes renumbers tags even with all options off. + # What matters is that the same NUMBER of points survive and + # coordinates are preserved. + assert n_after == n_before, \ + f"healShapes(all off) lost points: {n_before} -> {n_after}" + + # Verify the interior point's coordinates still exist + found = False + for d, t in pts_after_heal: + bb2 = occ.getBoundingBox(0, t) + c2 = (round(bb2[0], 6), round(bb2[1], 6), round(bb2[2], 6)) + if c2 == pt_coord: + found = True + break + assert found, f"Interior point at {pt_coord} not found after healShapes" + + def test_healShapes_all_off_preserves_points_large_coords(self): + """Same as above but with large coordinates matching user scenario.""" + gmsh.initialize() + gmsh.model.add("test_heal_large") + occ = gmsh.model.occ + + ox, oy = 584000.0, 2366000.0 + p1 = occ.addPoint(ox, oy, 0) + p2 = occ.addPoint(ox + 13000, oy, 0) + p3 = occ.addPoint(ox + 13000, oy + 9000, 0) + p4 = occ.addPoint(ox, oy + 9000, 0) + l1 = occ.addLine(p1, p2) + l2 = occ.addLine(p2, p3) + l3 = occ.addLine(p3, p4) + l4 = occ.addLine(p4, p1) + cl = occ.addCurveLoop([l1, l2, l3, l4]) + s = occ.addPlaneSurface([cl]) + pt = occ.addPoint(ox + 6000, oy + 4500, 0) + + all_tags = [(2, s), (0, pt)] + occ.fragment(all_tags, []) + + n_before = len(occ.getEntities(0)) + bb = occ.getBoundingBox(0, pt) + pt_coord = (round(bb[0], 6), round(bb[1], 6), round(bb[2], 6)) + + occ.healShapes( + [], tolerance=1.0, + fixDegenerated=False, fixSmallEdges=False, fixSmallFaces=False, + sewFaces=False, makeSolids=False, + ) + pts_after = occ.getEntities(0) + n_after = len(pts_after) + + assert n_after == n_before, \ + f"healShapes(all off, tol=1) lost points with large coords: {n_before} -> {n_after}" + + found = False + for d, t in pts_after: + bb2 = occ.getBoundingBox(0, t) + c2 = (round(bb2[0], 6), round(bb2[1], 6), round(bb2[2], 6)) + if c2 == pt_coord: + found = True + break + assert found, f"Interior point at {pt_coord} not found after healShapes (large coords)" + + def test_synchronize_preserves_occ_points(self): + """Verify that occ.synchronize() doesn't lose dim-0 entities.""" + gmsh.initialize() + gmsh.model.add("test_sync") + occ = gmsh.model.occ + + p1 = occ.addPoint(0, 0, 0) + p2 = occ.addPoint(10, 0, 0) + p3 = occ.addPoint(10, 10, 0) + p4 = occ.addPoint(0, 10, 0) + l1 = occ.addLine(p1, p2) + l2 = occ.addLine(p2, p3) + l3 = occ.addLine(p3, p4) + l4 = occ.addLine(p4, p1) + cl = occ.addCurveLoop([l1, l2, l3, l4]) + s = occ.addPlaneSurface([cl]) + pt = occ.addPoint(5, 5, 0) + + all_tags = [(2, s), (0, pt)] + occ.fragment(all_tags, []) + occ.removeAllDuplicates() + + occ_pts_before_sync = set(t for d, t in occ.getEntities(0)) + occ.synchronize() + model_pts_after_sync = set(t for d, t in gmsh.model.getEntities(0)) + + assert occ_pts_before_sync == model_pts_after_sync, \ + f"synchronize lost points: occ={occ_pts_before_sync}, model={model_pts_after_sync}" diff --git a/tests/test_quality_metrics.py b/tests/test_quality_metrics.py new file mode 100644 index 0000000..ab3d19f --- /dev/null +++ b/tests/test_quality_metrics.py @@ -0,0 +1,438 @@ +import geopandas as gpd +import numpy as np +import pandas as pd +import pytest +from shapely.geometry import MultiPolygon, Polygon, box + +from vorflow import ConceptualMesh, MeshGenerator +from vorflow.utils import build_connectivity, calculate_mesh_quality, calculate_orthogonality + + +TRIANGULAR_QUALITY_COLUMNS = [ + "element_tag", + "element_type", + "element_name", + "is_triangle", + "minSICN", + "minDetJac", + "maxDetJac", + "minSJ", + "minSIGE", + "gamma", + "innerRadius", + "outerRadius", + "minIsotropy", + "angleShape", + "minEdge", + "maxEdge", +] + +ELEMENT_GRID_COLUMNS = [ + "element_tag", + "element_type", + "element_name", + "is_triangle", + "is_quad", + "node_tags", + "centroid_x", + "centroid_y", + "geometry", + "zone_id", + "z_order", +] + + + +@pytest.fixture +def paired_polygons(): + poly_a = Polygon([(0, 0), (1, 0), (1, 1), (0, 1)]) + poly_b = Polygon([(1, 0), (2, 0), (2, 1), (1, 1)]) + return gpd.GeoDataFrame( + { + "node_id": [10, 20], + "x": [0.5, 1.5], + "y": [0.5, 0.5], + "geometry": [poly_a, poly_b], + } + ) + + +def test_build_connectivity_reports_generator_based_pair_metrics(paired_polygons): + connectivity = build_connectivity(paired_polygons) + + assert len(connectivity) == 1 + row = connectivity.iloc[0] + assert row["cell_id_1"] != row["cell_id_2"] + assert {row["node_id_1"], row["node_id_2"]} == {10, 20} + assert row["center_mode"] == "generator" + assert row["shared_edge"].length == pytest.approx(1.0) + assert row["connector"].length == pytest.approx(1.0) + assert row["angle"] == pytest.approx(90.0, abs=1e-6) + assert row["ortho_error"] == pytest.approx(0.0, abs=1e-6) + assert row["skewness"] == pytest.approx(0.5, abs=1e-6) + + +def test_build_connectivity_centroid_mode_works_without_generator_columns(paired_polygons): + gdf = paired_polygons.drop(columns=["x", "y"]) + + connectivity = build_connectivity(gdf, center="centroid") + + assert len(connectivity) == 1 + row = connectivity.iloc[0] + assert row["center_mode"] == "centroid" + assert row["angle"] == pytest.approx(90.0, abs=1e-6) + assert row["ortho_error"] == pytest.approx(0.0, abs=1e-6) + assert row["skewness"] == pytest.approx(0.5, abs=1e-6) + + +def test_build_connectivity_generator_mode_still_requires_generator_columns(paired_polygons): + gdf = paired_polygons.drop(columns=["x"]) + + with pytest.raises(ValueError, match="center='generator'"): + build_connectivity(gdf) + + +def test_centroid_mode_exposes_asymmetric_cell_center_error(): + left = Polygon([(0, 0), (1, 0), (1, 2), (0, 2)]) + right = Polygon([(1, 0), (3, 0), (3, 1), (1, 1)]) + gdf = gpd.GeoDataFrame( + { + "node_id": [1, 2], + "x": [0.5, 2.0], + "y": [0.5, 0.5], + "geometry": [left, right], + } + ) + + generator_report = build_connectivity(gdf) + centroid_report = build_connectivity(gdf, center="centroid") + centroid_quality = calculate_mesh_quality( + gdf.drop(columns=["x", "y"]), + calc_ortho=True, + calc_skewness=True, + connectivity=centroid_report, + ) + + assert generator_report.iloc[0]["ortho_error"] == pytest.approx(0.0, abs=1e-6) + assert centroid_report.iloc[0]["center_mode"] == "centroid" + assert centroid_report.iloc[0]["ortho_error"] > 0.0 + assert centroid_report.iloc[0]["skewness"] != pytest.approx(0.5, abs=1e-6) + assert "ortho_error" in centroid_quality.columns + assert "skewness" in centroid_quality.columns + + +def test_build_connectivity_uses_unique_row_ids_when_index_is_duplicated(paired_polygons): + duplicated_index = paired_polygons.copy() + duplicated_index.index = [7, 7] + + connectivity = build_connectivity(duplicated_index) + quality = calculate_mesh_quality( + duplicated_index, + calc_ortho=True, + calc_skewness=True, + connectivity=connectivity, + ) + + assert connectivity[["cell_id_1", "cell_id_2"]].iloc[0].tolist() == [0, 1] + assert connectivity[["orig_index_1", "orig_index_2"]].iloc[0].tolist() == [7, 7] + assert quality["ortho_error"].tolist() == pytest.approx([0.0, 0.0], abs=1e-6) + assert quality["skewness"].tolist() == pytest.approx([0.0, 0.0], abs=1e-6) + + +def test_calculate_mesh_quality_validates_supplied_connectivity_schema(paired_polygons): + connectivity = build_connectivity(paired_polygons).drop(columns=["skewness"]) + + with pytest.raises(ValueError, match="connectivity missing required columns"): + calculate_mesh_quality( + paired_polygons, + calc_skewness=True, + connectivity=connectivity, + ) + + +def test_build_connectivity_skips_point_only_touching_cells(): + gdf = gpd.GeoDataFrame( + { + "x": [0.5, 1.5], + "y": [0.5, 1.5], + "geometry": [box(0, 0, 1, 1), box(1, 1, 2, 2)], + } + ) + + assert build_connectivity(gdf).empty + + +def test_build_connectivity_uses_longest_multilinestring_shared_boundary(): + left = MultiPolygon([box(0, 0, 1, 1), box(0, 2, 1, 4)]) + right = MultiPolygon([box(1, 0, 2, 1), box(1, 2, 2, 5)]) + gdf = gpd.GeoDataFrame( + { + "x": [0.5, 1.5], + "y": [3.0, 3.0], + "geometry": [left, right], + } + ) + + connectivity = build_connectivity(gdf) + + assert len(connectivity) == 1 + assert connectivity.iloc[0]["shared_edge"].length == pytest.approx(2.0) + + +def test_build_connectivity_projects_shared_face_midpoint_when_connector_does_not_cross(): + gdf = gpd.GeoDataFrame( + { + "x": [0.5, 1.5], + "y": [2.0, 2.0], + "geometry": [box(0, 0, 1, 1), box(1, 0, 2, 1)], + } + ) + + connectivity = build_connectivity(gdf) + + assert len(connectivity) == 1 + assert connectivity.iloc[0]["skewness"] == pytest.approx(0.5, abs=1e-6) + + +def test_calculate_orthogonality_regression_value_unchanged(paired_polygons): + result = calculate_orthogonality(paired_polygons) + expected = pd.Series([0.0, 0.0], index=paired_polygons.index) + + pd.testing.assert_series_equal(result, expected) + + +def test_calculate_mesh_quality_skewness_is_opt_in(paired_polygons): + default_quality = calculate_mesh_quality(paired_polygons) + + assert "ortho_error" not in default_quality.columns + assert "skewness" not in default_quality.columns + + connectivity = build_connectivity(paired_polygons) + skew_quality = calculate_mesh_quality( + paired_polygons, + calc_ortho=True, + calc_skewness=True, + connectivity=connectivity, + ) + + assert "ortho_error" in skew_quality.columns + assert "skewness" in skew_quality.columns + assert skew_quality["ortho_error"].tolist() == pytest.approx([0.0, 0.0], abs=1e-6) + assert skew_quality["skewness"].tolist() == pytest.approx([0.0, 0.0], abs=1e-6) + + +def test_get_triangular_quality_requires_generation(): + mesher = MeshGenerator(background_lc=2.0, verbosity=0) + + with pytest.raises(RuntimeError, match="Call MeshGenerator.generate"): + mesher.get_triangular_quality() + + with pytest.raises(RuntimeError, match="Call MeshGenerator.generate"): + mesher.get_element_grid() + + +def test_get_triangular_quality_returns_cached_gmsh_metrics_after_generate(): + cm = ConceptualMesh() + cm.add_polygon( + Polygon([(0, 0), (4, 0), (4, 4), (0, 4)]), + zone_id=1, + resolution=2.0, + dist_max=4.0, + ) + clean_polys, clean_lines, clean_points = cm.generate() + + mesher = MeshGenerator( + background_lc=2.0, + verbosity=0, + smoothing_steps=0, + optimization_cycles=0, + ) + assert mesher.generate(clean_polys, clean_lines, clean_points) + + quality = mesher.get_triangular_quality() + + assert list(quality.columns) == TRIANGULAR_QUALITY_COLUMNS + assert not quality.empty + assert quality["element_tag"].is_unique + assert quality["is_triangle"].all() + metric_values = quality.drop( + columns=["element_tag", "element_type", "element_name", "is_triangle"] + ) + assert np.isfinite(metric_values.to_numpy()).all() + assert quality["gamma"].between(0.0, 1.0).all() + assert quality["minSICN"].between(-1.0, 1.0).all() + + quality_copy = mesher.get_triangular_quality() + quality_copy.loc[quality_copy.index[0], "gamma"] = -999.0 + assert mesher.get_triangular_quality()["gamma"].iloc[0] != -999.0 + + +def test_get_element_grid_returns_cached_gmsh_element_polygons_after_generate(): + cm = ConceptualMesh(crs=None) + cm.add_polygon( + Polygon([(0, 0), (4, 0), (4, 4), (0, 4)]), + zone_id="domain", + resolution=2.0, + dist_max=4.0, + ) + clean_polys, clean_lines, clean_points = cm.generate() + + mesher = MeshGenerator( + background_lc=2.0, + verbosity=0, + smoothing_steps=0, + optimization_cycles=0, + ) + assert mesher.generate(clean_polys, clean_lines, clean_points) + + element_grid = mesher.get_element_grid() + quality = mesher.get_triangular_quality() + + assert list(element_grid.columns) == ELEMENT_GRID_COLUMNS + assert not element_grid.empty + assert len(element_grid) == len(quality) + assert element_grid["element_tag"].is_unique + assert element_grid["element_tag"].tolist() == sorted(element_grid["element_tag"].tolist()) + assert element_grid["is_triangle"].all() + assert not element_grid["is_quad"].any() + assert element_grid.geometry.is_valid.all() + assert (element_grid.geometry.area > 0).all() + assert element_grid["zone_id"].eq("domain").all() + assert "x" not in element_grid.columns + assert "y" not in element_grid.columns + + triangle_grid = mesher.get_element_grid("triangles") + quad_grid = mesher.get_element_grid("quads") + + assert len(triangle_grid) == len(element_grid) + assert quad_grid.empty + + element_grid_copy = mesher.get_element_grid() + element_grid_copy.loc[element_grid_copy.index[0], "element_tag"] = -999 + assert mesher.get_element_grid()["element_tag"].iloc[0] != -999 + + +def test_element_grid_supports_centroid_connectivity_without_generator_columns(): + cm = ConceptualMesh(crs=None) + cm.add_polygon( + Polygon([(0, 0), (6, 0), (6, 4), (0, 4)]), + zone_id=1, + resolution=2.0, + dist_max=4.0, + ) + clean_polys, clean_lines, clean_points = cm.generate() + + mesher = MeshGenerator( + background_lc=2.0, + verbosity=0, + smoothing_steps=0, + optimization_cycles=0, + ) + assert mesher.generate(clean_polys, clean_lines, clean_points) + + element_grid = mesher.get_element_grid() + connectivity = build_connectivity(element_grid, center="centroid") + quality = calculate_mesh_quality( + element_grid, + calc_ortho=True, + calc_skewness=True, + connectivity=connectivity, + ) + + assert not connectivity.empty + assert connectivity["center_mode"].eq("centroid").all() + assert "ortho_error" in quality.columns + assert "skewness" in quality.columns + assert "drift_ratio" not in quality.columns + + +def test_get_element_grid_validates_filter(): + cm = ConceptualMesh(crs=None) + cm.add_polygon( + Polygon([(0, 0), (4, 0), (4, 4), (0, 4)]), + zone_id=1, + resolution=2.0, + ) + clean_polys, clean_lines, clean_points = cm.generate() + + mesher = MeshGenerator(background_lc=2.0, verbosity=0, smoothing_steps=0, optimization_cycles=0) + assert mesher.generate(clean_polys, clean_lines, clean_points) + + with pytest.raises(ValueError, match="element_filter"): + mesher.get_element_grid("hexes") + + +def test_element_grid_and_quality_exclude_field_only_surfaces(): + # embed=False polygons become standalone meshed surfaces in gmsh; their + # elements must not leak into the element grid or quality report. + cm = ConceptualMesh(crs=None) + cm.add_polygon(Polygon([(0, 0), (4, 0), (4, 4), (0, 4)]), zone_id="domain", resolution=2.0) + cm.add_polygon(Polygon([(1, 1), (3, 1), (3, 3), (1, 3)]), zone_id="overlay", embed=False, resolution=2.0) + clean_polys, clean_lines, clean_points = cm.generate() + + mesher = MeshGenerator(background_lc=2.0, verbosity=0, smoothing_steps=0, optimization_cycles=0) + assert mesher.generate(clean_polys, clean_lines, clean_points) + + element_grid = mesher.get_element_grid() + quality = mesher.get_triangular_quality() + + # If the overlay's standalone mesh leaked in, the total element area would + # be ~domain + overlay (16 + 4) instead of the domain alone. + total_area = float(element_grid.geometry.area.sum()) + assert abs(total_area - 16.0) < 1e-6 + assert len(quality) == len(element_grid) + + +def _fake_element_grid(centroid): + geometry = [Polygon([(centroid[0] - 0.1, centroid[1] - 0.1), + (centroid[0] + 0.1, centroid[1] - 0.1), + (centroid[0], centroid[1] + 0.1)])] + return gpd.GeoDataFrame( + { + "element_tag": [1], + "centroid_x": [centroid[0]], + "centroid_y": [centroid[1]], + }, + geometry=geometry, + crs=None, + ) + + +def test_zone_assignment_tie_break_is_deterministic(): + from vorflow.engine import _assign_zones_to_elements + + zone_a = box(0, 0, 1, 1) + zone_b = box(1, 0, 2, 1) + on_border = (1.0, 0.5) + + # With z_order, the higher z_order wins regardless of zone row order. + for order in (["a", "b"], ["b", "a"]): + zones = gpd.GeoDataFrame( + { + "zone_id": order, + "z_order": [2 if z == "b" else 1 for z in order], + "geometry": [zone_b if z == "b" else zone_a for z in order], + }, + geometry="geometry", + crs=None, + ) + result = _assign_zones_to_elements(_fake_element_grid(on_border), zones) + assert result.loc[0, "zone_id"] == "b" + + # Without z_order, the earliest zone row wins, reproducibly. + zones_ab = gpd.GeoDataFrame( + {"zone_id": ["a", "b"], "geometry": [zone_a, zone_b]}, + geometry="geometry", + crs=None, + ) + zones_ba = gpd.GeoDataFrame( + {"zone_id": ["b", "a"], "geometry": [zone_b, zone_a]}, + geometry="geometry", + crs=None, + ) + for zones, expected in ((zones_ab, "a"), (zones_ba, "b")): + results = { + _assign_zones_to_elements(_fake_element_grid(on_border), zones).loc[0, "zone_id"] + for _ in range(3) + } + assert results == {expected} diff --git a/tests/test_release_metadata.py b/tests/test_release_metadata.py new file mode 100644 index 0000000..8e90b81 --- /dev/null +++ b/tests/test_release_metadata.py @@ -0,0 +1,64 @@ +import os +from pathlib import Path +import subprocess +import sys + +try: + import tomllib +except ModuleNotFoundError: # Python 3.10 + import tomli as tomllib + + +ROOT = Path(__file__).resolve().parents[1] + + +def test_release_metadata_is_complete(): + with (ROOT / "pyproject.toml").open("rb") as stream: + data = tomllib.load(stream) + + project = data["project"] + assert data["build-system"]["requires"] == ["setuptools>=77.0.3"] + assert project["version"] == "0.1.0rc1" + assert project["license"] == "MIT" + assert project["license-files"] == ["LICENSE"] + assert project["authors"] == [ + {"name": "Oscar Sanchez", "email": "oscarfasanchez@gmail.com"}, + {"name": "rhugman"}, + ] + assert project["maintainers"] == [ + {"name": "Oscar Sanchez", "email": "oscarfasanchez@gmail.com"} + ] + assert project["dependencies"] == [ + "numpy>=1.24", + "pandas>=1.5", + "geopandas>=0.13", + "shapely>=2.0", + "scipy>=1.10", + "gmsh>=4.11", + ] + assert "License :: OSI Approved :: MIT License" not in project["classifiers"] + + +def test_source_fallback_is_not_a_duplicate_release_version(): + source = (ROOT / "src" / "vorflow" / "__init__.py").read_text( + encoding="utf-8" + ) + assert '__version__ = "0+unknown"' in source + assert '__version__ = "0.0.2"' not in source + + +def test_basic_usage_script_runs_from_a_clean_directory(tmp_path): + env = os.environ.copy() + env["PYTHONPATH"] = str(ROOT / "src") + result = subprocess.run( + [sys.executable, str(ROOT / "examples" / "basic_usage.py")], + cwd=tmp_path, + env=env, + capture_output=True, + text=True, + timeout=180, + check=False, + ) + assert result.returncode == 0, result.stderr + assert "Generated " in result.stdout + assert " Voronoi cells" in result.stdout diff --git a/tests/test_utils.py b/tests/test_utils.py index c919fdd..cce66fa 100644 --- a/tests/test_utils.py +++ b/tests/test_utils.py @@ -1,9 +1,16 @@ +import logging + import geopandas as gpd import numpy as np import pytest -from shapely.geometry import Polygon +from shapely.geometry import LineString, Point, Polygon -from vorflow.utils import calculate_mesh_quality +from vorflow.utils import ( + calculate_mesh_quality, + check_geometry_resolution, + resample_geometry, + summarize_quality, +) @pytest.fixture @@ -33,3 +40,77 @@ def test_calculate_mesh_quality_computes_expected_scalar_metrics(paired_polygons assert quality["compactness"].iloc[0] == pytest.approx(np.pi / 4, rel=1e-5) assert quality["drift_ratio"].iloc[0] == pytest.approx(0.0, abs=1e-8) assert quality["ortho_error"].iloc[0] == pytest.approx(0.0, abs=1e-6) + + +class TestCheckGeometryResolution: + def test_reports_segment_statistics_for_square(self): + square = Polygon([(0, 0), (2, 0), (2, 2), (0, 2)]) + gdf = gpd.GeoDataFrame({"geometry": [square]}) + stats = check_geometry_resolution(gdf) + assert stats["count"] == 4 + assert stats["min"] == pytest.approx(2.0) + assert stats["max"] == pytest.approx(2.0) + assert stats["mean"] == pytest.approx(2.0) + assert stats["median"] == pytest.approx(2.0) + + def test_mixed_geometries_include_lines_and_skip_points(self): + square = Polygon([(0, 0), (1, 0), (1, 1), (0, 1)]) + line = LineString([(0, 0), (3, 4)]) # single 5.0 segment + gdf = gpd.GeoDataFrame({"geometry": [square, line, Point(9, 9)]}) + stats = check_geometry_resolution(gdf) + assert stats["count"] == 5 + assert stats["max"] == pytest.approx(5.0) + + def test_no_segments_warns_and_returns_empty_stats(self): + gdf = gpd.GeoDataFrame({"geometry": [Point(0, 0), Point(1, 1)]}) + with pytest.warns(UserWarning, match="no valid segments"): + stats = check_geometry_resolution(gdf) + assert stats["count"] == 0 + assert np.isnan(stats["min"]) and np.isnan(stats["mean"]) + + +class TestResampleGeometry: + def test_linestring_vertices_evenly_spaced(self): + line = LineString([(0, 0), (10, 0)]) + out = resample_geometry(line, target_spacing=2.5) + coords = np.asarray(out.coords) + assert len(coords) == 5 # 4 segments of 2.5 + spacing = np.linalg.norm(np.diff(coords, axis=0), axis=1) + assert spacing == pytest.approx([2.5] * 4) + assert out.length == pytest.approx(line.length) + + def test_polygon_preserves_shape_and_holes(self): + outer = Polygon( + [(0, 0), (10, 0), (10, 10), (0, 10)], + holes=[[(4, 4), (6, 4), (6, 6), (4, 6)]], + ) + out = resample_geometry(outer, target_spacing=1.0) + assert out.is_valid + assert len(out.interiors) == 1 + assert out.area == pytest.approx(outer.area, rel=1e-6) + seg = np.linalg.norm( + np.diff(np.asarray(out.exterior.coords), axis=0), axis=1 + ) + assert seg.max() <= 1.0 + 1e-9 + + def test_point_and_empty_geometries_pass_through(self): + pt = Point(1, 2) + assert resample_geometry(pt, 1.0) is pt + empty = LineString() + assert resample_geometry(empty, 1.0).is_empty + + +class TestSummarizeQuality: + def test_report_lists_cell_counts(self, paired_polygons, caplog): + quality = calculate_mesh_quality(paired_polygons, calc_ortho=True) + vlog = logging.getLogger("vorflow") + old_propagate = vlog.propagate + vlog.propagate = True # let caplog's root handler see the records + try: + with caplog.at_level(logging.INFO, logger="vorflow.utils"): + summarize_quality(quality) + finally: + vlog.propagate = old_propagate + messages = " ".join(r.getMessage() for r in caplog.records) + assert "Mesh Quality Report" in messages + assert "Total Cells: 2" in messages diff --git a/tests/test_voronoi_tessellator.py b/tests/test_voronoi_tessellator.py index cfcce43..3889749 100644 --- a/tests/test_voronoi_tessellator.py +++ b/tests/test_voronoi_tessellator.py @@ -1,9 +1,12 @@ import geopandas as gpd import numpy as np -from shapely.geometry import Point, Polygon +import pytest +from shapely.geometry import Polygon +from shapely.ops import unary_union from vorflow.blueprint import ConceptualMesh from vorflow.tessellator import VoronoiTessellator +from vorflow.utils import boundary_connectivity_report, build_connectivity class DummyMeshGenerator: @@ -49,3 +52,255 @@ def test_voronoi_clips_to_domain_and_assigns_zones(): assert set(grid["node_id"]) == set(tags) assert "centroid_x" in grid.columns assert "centroid_y" in grid.columns + + +def test_boundary_centering_default_matches_clip_mode(): + cm = _build_conceptual_mesh() + clean_polys, _, _ = cm.generate() + + nodes = np.array( + [ + [0.0, 0.25], + [0.0, 0.75], + [0.5, 0.25], + [0.5, 0.75], + [1.0, 0.25], + [1.0, 0.75], + ] + ) + tags = np.arange(1, len(nodes) + 1) + mesh_gen = DummyMeshGenerator(nodes=nodes, tags=tags, zones_gdf=clean_polys) + + default_grid = VoronoiTessellator(mesh_gen, cm, clip_to_boundary=True).generate() + clip_grid = VoronoiTessellator( + mesh_gen, + cm, + clip_to_boundary=True, + boundary_centering="clip", + ).generate() + + ordered_default = default_grid.sort_values("node_id").reset_index(drop=True) + ordered_clip = clip_grid.sort_values("node_id").reset_index(drop=True) + + assert ordered_default["node_id"].tolist() == ordered_clip["node_id"].tolist() + assert np.allclose(ordered_default["x"], ordered_clip["x"]) + assert np.allclose(ordered_default["y"], ordered_clip["y"]) + assert all( + geom_a.equals_exact(geom_b, tolerance=1e-12) + for geom_a, geom_b in zip(ordered_default.geometry, ordered_clip.geometry) + ) + assert "source_x" not in default_grid.columns + assert "boundary_centered" not in default_grid.columns + + +def test_boundary_inset_mirror_shifts_non_corner_boundary_centers_inward(): + cm = _build_conceptual_mesh() + clean_polys, _, _ = cm.generate() + + nodes = np.array( + [ + [0.0, 0.25], + [0.0, 0.75], + [0.5, 0.25], + [0.5, 0.75], + [1.0, 0.25], + [1.0, 0.75], + ] + ) + tags = np.arange(1, len(nodes) + 1) + mesh_gen = DummyMeshGenerator(nodes=nodes, tags=tags, zones_gdf=clean_polys) + + grid = VoronoiTessellator( + mesh_gen, + cm, + clip_to_boundary=True, + boundary_centering="inset_mirror", + ).generate() + + assert not grid.empty + assert {"source_x", "source_y", "boundary_centering", "boundary_inset", "boundary_centered"}.issubset( + grid.columns + ) + + shifted_left = grid[np.isclose(grid["source_x"], 0.0)] + shifted_right = grid[np.isclose(grid["source_x"], 1.0)] + assert shifted_left["boundary_centered"].all() + assert shifted_right["boundary_centered"].all() + assert (shifted_left["x"] > shifted_left["source_x"]).all() + assert (shifted_right["x"] < shifted_right["source_x"]).all() + assert (grid["boundary_inset"] >= 0.0).all() + + +def test_boundary_inset_mirror_offsets_scale_with_local_spacing(): + cm = _build_conceptual_mesh() + clean_polys, _, _ = cm.generate() + + nodes = np.array( + [ + [0.0, 0.25], + [0.0, 0.75], + [1.0, 0.20], + [1.0, 0.40], + [0.5, 0.5], + ] + ) + tags = np.arange(1, len(nodes) + 1) + mesh_gen = DummyMeshGenerator(nodes=nodes, tags=tags, zones_gdf=clean_polys) + tessellator = VoronoiTessellator(mesh_gen, cm, boundary_centering="inset_mirror") + + prepared, _, ghosts, metadata = tessellator._prepare_boundary_centered_nodes(nodes, tags) + + coarse_inset = metadata.loc[metadata["source_x"] == 0.0, "boundary_inset"].iloc[0] + fine_inset = metadata.loc[metadata["source_x"] == 1.0, "boundary_inset"].iloc[0] + + assert coarse_inset > fine_inset + assert np.isclose(coarse_inset, 0.25) + assert np.isclose(fine_inset, 0.10) + assert len(ghosts) == int(metadata["boundary_centered"].sum()) + assert not np.allclose(prepared, nodes) + + +def test_boundary_inset_mirror_skips_sharp_corners(): + cm = _build_conceptual_mesh() + clean_polys, _, _ = cm.generate() + + nodes = np.array( + [ + [0.0, 0.0], + [0.0, 0.5], + [0.5, 0.5], + [1.0, 0.5], + ] + ) + tags = np.arange(1, len(nodes) + 1) + mesh_gen = DummyMeshGenerator(nodes=nodes, tags=tags, zones_gdf=clean_polys) + tessellator = VoronoiTessellator(mesh_gen, cm, boundary_centering="inset_mirror") + + prepared, _, _, metadata = tessellator._prepare_boundary_centered_nodes(nodes, tags) + + corner_row = metadata[metadata["node_id"] == 1].iloc[0] + assert not bool(corner_row["boundary_centered"]) + assert corner_row["boundary_inset"] == 0.0 + assert np.allclose(prepared[0], nodes[0]) + + +def _staggered_lattice_nodes(): + """Unit-box lattice with boundary nodes on the edges and staggered interior rows.""" + nodes = [] + for x in (0.25, 0.5, 0.75): + nodes.append([x, 0.0]) + nodes.append([x, 1.0]) + for y in (0.25, 0.5, 0.75): + nodes.append([0.0, y]) + nodes.append([1.0, y]) + for x in (0.375, 0.625): + nodes.append([x, 0.25]) + nodes.append([x, 0.75]) + for x in (0.25, 0.5, 0.75): + nodes.append([x, 0.5]) + return np.array(nodes, dtype=float) + + +def test_boundary_connectivity_report_restricts_to_boundary_cells(): + cm = _build_conceptual_mesh() + clean_polys, _, _ = cm.generate() + domain_geom = unary_union(clean_polys.geometry) + + coords = [0.125, 0.375, 0.625, 0.875] + nodes = np.array([[x, y] for x in coords for y in coords]) + tags = np.arange(1, len(nodes) + 1) + mesh_gen = DummyMeshGenerator(nodes=nodes, tags=tags, zones_gdf=clean_polys) + + grid = VoronoiTessellator(mesh_gen, cm, clip_to_boundary=True).generate() + full = build_connectivity(grid, center="centroid") + report = boundary_connectivity_report(grid, domain_geom, center="centroid") + + assert not report.empty + assert len(report) < len(full) + + boundary = domain_geom.boundary + cell_geoms = grid.geometry.reset_index(drop=True) + boundary_cells = { + i for i, geom in enumerate(cell_geoms) if geom.distance(boundary) <= 1e-8 + } + assert ( + report["cell_id_1"].isin(boundary_cells) | report["cell_id_2"].isin(boundary_cells) + ).all() + + interior_pairs = full[ + ~full["cell_id_1"].isin(boundary_cells) & ~full["cell_id_2"].isin(boundary_cells) + ] + assert not interior_pairs.empty + merged = report.merge( + interior_pairs[["cell_id_1", "cell_id_2"]], + on=["cell_id_1", "cell_id_2"], + how="inner", + ) + assert merged.empty + + +def test_inset_mirror_improves_boundary_cell_centroid_orthogonality(): + cm = _build_conceptual_mesh() + clean_polys, _, _ = cm.generate() + domain_geom = unary_union(clean_polys.geometry) + + nodes = _staggered_lattice_nodes() + tags = np.arange(1, len(nodes) + 1) + mesh_gen = DummyMeshGenerator(nodes=nodes, tags=tags, zones_gdf=clean_polys) + + clip_grid = VoronoiTessellator( + mesh_gen, cm, clip_to_boundary=True, boundary_centering="clip" + ).generate() + mirror_grid = VoronoiTessellator( + mesh_gen, cm, clip_to_boundary=True, boundary_centering="inset_mirror" + ).generate() + + clip_report = boundary_connectivity_report(clip_grid, domain_geom, center="centroid") + mirror_report = boundary_connectivity_report(mirror_grid, domain_geom, center="centroid") + + assert not clip_report.empty + assert not mirror_report.empty + + clip_error = clip_report["ortho_error"].mean() + mirror_error = mirror_report["ortho_error"].mean() + assert clip_error > 1.0 # the staggered clip-mode grid is measurably non-orthogonal + assert mirror_error < clip_error + + +def test_boundary_centering_rejects_invalid_mode(): + cm = _build_conceptual_mesh() + clean_polys, _, _ = cm.generate() + mesh_gen = DummyMeshGenerator( + nodes=np.array([[0.2, 0.2], [0.8, 0.2], [0.5, 0.8]]), + tags=np.array([1, 2, 3]), + zones_gdf=clean_polys, + ) + + with pytest.raises(ValueError, match="boundary_centering"): + VoronoiTessellator(mesh_gen, cm, boundary_centering="mirror") + + +class TestExportToShapefile: + def _tessellator_with_grid(self): + cm = _build_conceptual_mesh() + clean_polys, _, _ = cm.generate() + nodes = np.array([[0.2, 0.2], [0.8, 0.2], [0.2, 0.8], [0.8, 0.8]]) + mesh_gen = DummyMeshGenerator(nodes=nodes, tags=[1, 2, 3, 4], zones_gdf=clean_polys) + return VoronoiTessellator(mesh_gen, cm, clip_to_boundary=True) + + def test_writes_readable_shapefile(self, tmp_path): + tess = self._tessellator_with_grid() + grid = tess.generate() + path = tmp_path / "grid.shp" + tess.export_to_shapefile(str(path)) + assert path.exists() + back = gpd.read_file(path) + assert len(back) == len(grid) + assert back.geometry.is_valid.all() + assert back.geometry.area.sum() == pytest.approx(grid.geometry.area.sum()) + + def test_no_grid_writes_nothing(self, tmp_path): + tess = self._tessellator_with_grid() # generate() never called + path = tmp_path / "grid.shp" + tess.export_to_shapefile(str(path)) + assert not path.exists()