bluemesh2d 0.1.1.dev0__tar.gz → 0.1.2__tar.gz

{bluemesh2d-0.1.1.dev0 → bluemesh2d-0.1.2}/.github/workflows/build-package.yml

@@ -26,9 +26,10 @@ jobs:
         run: pip install build
 
       - name: Build Python Package
-        run: |
-          rm -rf assets
-          python -m build
+        # NB: never modify the worktree here -- setuptools-scm treats a dirty
+        # tree as "not exactly at the tag" and emits a .devN version instead.
+        # assets/ is kept out of the sdist by MANIFEST.in.
+        run: python -m build
 
       - name: Publish to PyPI
         uses: pypa/gh-action-pypi-publish@release/v1

bluemesh2d-0.1.2/MANIFEST.in

@@ -0,0 +1,3 @@
+prune assets
+prune docs
+prune bluemesh2d_qgis

{bluemesh2d-0.1.1.dev0/bluemesh2d.egg-info → bluemesh2d-0.1.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: bluemesh2d
-Version: 0.1.1.dev0
+Version: 0.1.2
 Summary: BlueMesh2D is a Python-based unstructured mesh-generator for two-dimensional polygonal geometries, providing a range of relatively simple, yet effective two-dimensional meshing algorithms.
 Author-email: Geomatics and Ocean Engineering Group <faugeree@unican.es>
 License-Expression: GPL-3.0-only

{bluemesh2d-0.1.1.dev0 → bluemesh2d-0.1.2}/bluemesh2d/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '0.1.1.dev0'
-__version_tuple__ = version_tuple = (0, 1, 1, 'dev0')
+__version__ = version = '0.1.2'
+__version_tuple__ = version_tuple = (0, 1, 2)
 
-__commit_id__ = commit_id = 'gaa72c9ba7'
+__commit_id__ = commit_id = 'g23470bb1a'

{bluemesh2d-0.1.1.dev0 → bluemesh2d-0.1.2/bluemesh2d.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: bluemesh2d
-Version: 0.1.1.dev0
+Version: 0.1.2
 Summary: BlueMesh2D is a Python-based unstructured mesh-generator for two-dimensional polygonal geometries, providing a range of relatively simple, yet effective two-dimensional meshing algorithms.
 Author-email: Geomatics and Ocean Engineering Group <faugeree@unican.es>
 License-Expression: GPL-3.0-only

{bluemesh2d-0.1.1.dev0 → bluemesh2d-0.1.2}/bluemesh2d.egg-info/SOURCES.txt

@@ -1,5 +1,6 @@
 .gitignore
 LICENSE
+MANIFEST.in
 README.md
 pyproject.toml
 .github/workflows/build-package.yml
@@ -79,16 +80,6 @@ bluemesh2d/poly_data/lake.msh
 bluemesh2d/poly_data/river.msh
 bluemesh2d/poly_test/inpoly.py
 bluemesh2d/poly_test/inpoly_mat.py
-bluemesh2d_qgis/README.md
-bluemesh2d_qgis/__init__.py
-bluemesh2d_qgis/algorithm.py
-bluemesh2d_qgis/deps_installer.py
-bluemesh2d_qgis/icon.png
-bluemesh2d_qgis/metadata.txt
-bluemesh2d_qgis/pipeline.py
-bluemesh2d_qgis/plugin.py
-bluemesh2d_qgis/provider.py
-docs/Tuto_BlueMesh2D_Santander.pdf
 tests/README.md
 tests/__init__.py
 tests/_cases.py

{bluemesh2d-0.1.1.dev0 → bluemesh2d-0.1.2}/bluemesh2d.egg-info/scm_file_list.json

@@ -1,5 +1,6 @@
 {
   "files": [
+    "MANIFEST.in",
     "pyproject.toml",
     "LICENSE",
     "README.md",
@@ -92,6 +93,7 @@
     "bluemesh2d_qgis/__init__.py",
     "bluemesh2d_qgis/provider.py",
     "bluemesh2d_qgis/icon.png",
-    "bluemesh2d_qgis/README.md"
+    "bluemesh2d_qgis/README.md",
+    "assets/mesh_geocean.webp"
   ]
 }

bluemesh2d-0.1.2/bluemesh2d.egg-info/scm_version.json

@@ -0,0 +1,8 @@
+{
+  "tag": "0.1.2",
+  "distance": 0,
+  "node": "g23470bb1a512ed0633fed31ea9c5eff762e66267",
+  "dirty": false,
+  "branch": "HEAD",
+  "node_date": "2026-07-27"
+}

bluemesh2d-0.1.1.dev0/bluemesh2d.egg-info/scm_version.json

@@ -1,8 +0,0 @@
-{
-  "tag": "0.1.0",
-  "distance": 0,
-  "node": "gaa72c9ba725aaa9a33640af00b3c7e7b1252126d",
-  "dirty": true,
-  "branch": "HEAD",
-  "node_date": "2026-07-27"
-}

bluemesh2d-0.1.1.dev0/bluemesh2d_qgis/README.md

@@ -1,227 +0,0 @@
-# BlueMesh2D — QGIS plugin
-
-A self-contained QGIS **Processing** plugin that generates an unstructured
-triangular mesh from a bathymetry GeoTIFF, wrapping a bundled copy of the
-[BlueMesh2D](https://github.com/GeoOcean/BlueMesh2D) library. The output is a
-UGRID NetCDF that loads directly as a QGIS **mesh layer**.
-
-## About BlueMesh2D
-
-`BlueMesh2D` (successor of `PyMesh2D`, part of the BlueMath ecosystem) is a
-pure-Python unstructured mesh generator for two-dimensional polygonal
-geometries. It is a Python translation of
-[`MESH2D`](https://github.com/dengwirda/mesh2d) (Darren Engwirda's MATLAB/
-Octave tool) and a simplified 2D sibling of his C++
-[`JIGSAW`](https://github.com/dengwirda/jigsaw-matlab) mesh generator.
-
-It implements:
-- **Delaunay refinement** and a **Frontal-Delaunay ("delfront")** scheme for
-  generating triangulations from a boundary (PSLG) and a user-defined
-  mesh-size function;
-- **non-linear mesh optimisation** (`smooth`), plus `smood`, an
-  orthogonalization / small-link-merging pass geared at Delft3D-FM
-  flexible-mesh quality requirements;
-- mesh-spacing ("hfun") utilities: gradient limiting, depth/wavelength-based
-  sizing, local-feature-size estimation;
-- geometry and bathymetry pre/post-processing: coastline extraction from
-  raster elevation, polygon resampling, CRS-aware raster/point interpolation,
-  boundary classification (open/land), and export to ADCIRC `.grd` /
-  Delft3D-FM UGRID NetCDF.
-
-The algorithms are "probably-good": they guarantee termination, geometric and
-topological correctness, and worst-case element-quality bounds, while
-supporting user-defined mesh-size functions and multi-part domains. See the
-[BlueMesh2D repository](https://github.com/GeoOcean/BlueMesh2D) for the full
-library, its demos (`python -m bluemesh2d.tridemo <n>`), and references.
-
-This plugin exposes the raster-to-mesh subset of that library — coastline
-extraction, sizing, refinement/smoothing, and export — as QGIS Processing
-algorithms, so the workflow can run without Python scripting and its
-intermediate results (water polygon, size raster, boundary, mesh) become
-ordinary QGIS layers.
-
-## What it does
-
-```
-bathymetry.tif
-   → extract coastline + domain (depth threshold)
-   → depth-based element size  h = clip(a·d² + b·d, hmin, hmax)
-     (+ optional finer 'detail' region)
-   → gradient-limit the size field (smooth, Lipschitz)
-   → refine (delaunay | delfront) → smooth [→ smood orthogonalization]
-   → sample bathymetry onto nodes
-   → write UGRID NetCDF  → load as a QgsMeshLayer
-```
-
-## The algorithms (Processing Toolbox ▸ BlueMesh2D)
-
-The pipeline is available **split into four stages** — each result lands in an
-ordinary (temporary or saved) QGIS layer you can inspect before the next step:
-
-| algorithm | inputs | outputs |
-|---|---|---|
-| **1 – Extract water polygon** | bathy raster; coastline level; optional **deep level** (keeps the band `deep < z ≤ coast`, e.g. water shallower than 300 m); optional **extent polygon** (clips the raster *before* extraction — much faster; buffer then ignored); buffer factor (default −0.05) | water polygon layer |
-| **2 – Build element-size raster (hfun)** *(folder)* | one algorithm **per sizing method** (pick the algorithm, see only its parameters): **2a** depth polynomial `a·d²+b·d`; **2b** wavelength `L(T,d)/N` (Hunt 1979, `hfun_wavenumhunt`); **2c** custom Python (`d`,`x`,`y`,`np`). All share: optional **Water polygon (stage 1)** to limit computation to that area + buffer (much faster than the whole raster), detail polygons, min/max/detail size, gradient and **buffer** (m, −1 = automatic) | GeoTIFF, pixel = element size (m) |
-| **3 – Resample boundary to element size** | water polygon (1), hfun raster (2) | boundary **edges** line layer, styled with visible vertex markers (editable) |
-| **4 – Generate mesh from boundary** | **edges layer (3) — editable: move/delete/add segments first**, hfun raster (2), bathy raster; kind = delaunay/delfront; smooth; optional **smood** (+ *merge small links*, only if triangle-only smood can't remove the last small flow links) | UGRID NetCDF → mesh layer |
-| **5 – Generate boundary conditions** | mesh layer (4); depth threshold (default 20 m) | one **line layer** with a `btype` attribute — **open** / **closed** / **island** — styled by type with visible vertex dots, **editable** (move vertices, or change `btype` to reclassify a segment) |
-| **6 – Export** *(folder)* — **6a** plain UGRID, **6b** UGRID + open BC, **6c** ADCIRC `.grd` | **6a** (default): mesh layer (4) only → `.nc`, no boundary files, no boundary layer needed. **6b**: mesh (4) **+ boundary conditions (5, required)** → `.nc` and, from the `open` features, `Boundary01.pli` / `Riemann.bc` / `FlowFM_bnd.ext`. **6c**: mesh (4) + boundary conditions (5, required) → `.grd` with open/land loops (`open`→open, `closed`+`island`→land), snapping each boundary vertex back to the nearest mesh node so stage-5 edits are honoured | `.nc` / `.nc` + Delft3D-FM BC / `.grd` |
-
-Stage 4 rebuilds the PSLG from the (possibly edited) boundary lines, so you can
-reshape the domain before meshing; likewise stage 6 rebuilds the boundary
-classification from the (possibly edited) stage-5 lines, so you can hand-correct
-which segments are open / closed / island before exporting. The stages also
-chain in the **Graphical Modeler**.
-
-Every step is its own numbered folder under **BlueMesh2D** (`1 - Extract water
-polygon`, `2 - Build element-size raster (hfun)` with 2a/2b/2c inside, `3 -
-Resample boundary...`, ..., `6 - Export` with 6a/6b/6c inside).
-QGIS's Processing toolbox sorts grouped and ungrouped algorithms in two
-separate buckets rather than one merged alphabetical list, so giving every
-step its own group is what keeps them in numeric order 1→6 instead of the
-folders (2, 6) drifting away from the single algorithms.
-
-**CRS handling**: vector layers are always delivered in the input tif's CRS.
-If the tif is *geographic* (e.g. EPSG:4326), a local metric UTM CRS is built
-internally (and embedded in the hfun raster). If the tif is already
-*projected* (e.g. UTM), the whole pipeline runs natively in that CRS — no
-reprojection at all — and the output NetCDF carries metre units with a
-`projected_coordinate_system` grid mapping.
-
-## Install
-
-1. Copy this whole `bluemesh2d_qgis/` folder into your QGIS plugins directory:
-   - **Linux**: `~/.local/share/QGIS/QGIS3/profiles/default/python/plugins/`
-   - **Windows**: `%APPDATA%\QGIS\QGIS3\profiles\default\python\plugins\`
-   - **macOS**: `~/Library/Application Support/QGIS/QGIS3/profiles/default/python/plugins/`
-2. Restart QGIS → **Plugins ▸ Manage and Install Plugins ▸ Installed** → enable
-   **BlueMesh2D**.
-3. The algorithms appear in the **Processing Toolbox** under
-   *BlueMesh2D ▸ 1 - Extract water polygon* (and the following stages).
-
-### Python dependencies (important)
-
-**Automatic (recommended):** on first load the plugin checks QGIS's Python
-and, if packages are missing, opens a dialog listing them with an **Install
-now** button. pip runs inside QGIS's own interpreter — the right one on every
-platform — with `--user`. On Debian/Ubuntu system Python (PEP 668,
-"externally managed"), packages are installed into a small plugin-managed
-virtual environment (`.../profiles/<profile>/python/bluemesh2d_deps`,
-created with `--system-site-packages`) that the plugin adds to `sys.path`
-on load — the system Python is never modified and
-`--break-system-packages` is not needed. If that Python lacks pip entirely
-(no `python3-pip`), pip is bootstrapped into the venv automatically with
-the official `get-pip.py`. On conda-based QGIS the dialog
-shows the `conda install` command instead of running pip. Optional packages
-appear as opt-in checkboxes.
-Restart QGIS after installing. The same dialog can be reopened anytime from
-**Plugins ▸ BlueMesh2D ▸ Check / install dependencies**. The commands below
-are the manual fallback if the dialog's pip fails.
-
-Required in **QGIS's own Python** (all commonly present already):
-
-```
-numpy  scipy  shapely  pyproj  matplotlib  contourpy  rasterio  netCDF4
-```
-
-Optional:
-
-- **`triangle`** — Shewchuk's Triangle, for fast *constrained* Delaunay
-  triangulation. Without it the plugin automatically falls back to a
-  pure-`scipy` *conforming* Delaunay (same mesh character, somewhat slower).
-- **`xarray`** — required only by the **"Apply smood"** option (stage 4 /
-  all-in-one). `bluemesh2d.smood` always builds an in-memory
-  `xarray.Dataset` internally, regardless of the *merge small links*
-  sub-option. It is **not** needed for anything else — in particular every
-  UGRID NetCDF export (stage 6a and the all-in-one output) is written
-  directly with `netCDF4`. If it's missing, the algorithm now fails
-  immediately with a clear message instead of partway through refinement;
-  either install `xarray` or leave "Apply smood" unchecked.
-
-If something is missing, the algorithm names it up front. To install into the
-interpreter QGIS uses:
-
-- **Windows** — open the *OSGeo4W Shell* and run:
-  ```
-  python -m pip install rasterio netCDF4 xarray        # + triangle (optional)
-  ```
-- **Linux** — install into the Python QGIS runs on (Debian/Ubuntu system
-  Python needs `--break-system-packages` with `--user`):
-  ```
-  python3 -m pip install --user rasterio netCDF4 xarray   # + triangle (optional)
-  ```
-- **macOS** — the official QGIS.app bundles its **own** Python, so a plain
-  `python3 -m pip install` (Homebrew/system Python) installs into the wrong
-  interpreter. The reliable way — it works on every bundle layout — is to run
-  pip from inside the **QGIS Python console** (Plugins > Python Console):
-  ```python
-  import pip
-  pip.main(["install", "--user", "rasterio", "netCDF4", "xarray", "contourpy"])   # + "triangle" (optional)
-  ```
-  then **restart QGIS**. `--user` installs into `~/Library/Python/3.x/...`,
-  which QGIS has on its path.
-
-  Notes on the Terminal route: on **recent QGIS bundles** (vcpkg-based,
-  ~3.40+) the bundled interpreter
-  (`/Applications/QGIS.app/Contents/MacOS/python3.12`) **cannot run
-  standalone** — it aborts with `ModuleNotFoundError: No module named
-  'encodings'` because its library prefix is baked to the build machine's
-  path — so use the Python-console method above. On **older bundles** the
-  Terminal command was:
-  ```
-  /Applications/QGIS.app/Contents/MacOS/bin/python3 -m pip install rasterio netCDF4 xarray
-  ```
-  (Adjust the app name if yours is e.g. `QGIS-LTR.app`.) Do **not** use
-  `subprocess` with `sys.executable` from the QGIS console on macOS: there
-  `sys.executable` points to the QGIS application binary, not to Python.
-
-  If you installed QGIS via **conda** (`conda install -c conda-forge qgis`),
-  install the packages into that same conda environment instead:
-  ```
-  conda install -c conda-forge rasterio netcdf4 xarray
-  ```
-
-If `rasterio` clashes with QGIS's bundled GDAL on your platform, run the
-pipeline out-of-process instead (see below).
-
-## Layout
-
-```
-bluemesh2d_qgis/
-├── __init__.py        classFactory (QGIS entry point)
-├── metadata.txt       plugin metadata (hasProcessingProvider=yes)
-├── plugin.py          registers the Processing provider
-├── provider.py        BlueMesh2DProvider
-├── algorithm.py       Processing algorithms
-├── pipeline.py        headless orchestration facade (no QGIS dependency)
-└── bluemesh2d/        bundled copy of the meshing library
-```
-
-`pipeline.py` is the integration seam: it puts the plugin directory on
-`sys.path` so the bundled `bluemesh2d` imports as a top-level package, forces
-the non-interactive `Agg` matplotlib backend (the contour extraction needs it),
-routes progress/cancellation through the algorithm's
-`QgsProcessingFeedback`, and captures the mesher's stdout into the log.
-
-## Usage
-
-- **Bathymetry raster** — GeoTIFF, elevation positive up (depth = −elevation).
-- **Detail region** *(optional)* — a polygon layer; its union is refined down to
-  *Detail min element size*. Digitize it in QGIS or load a file; any CRS (it is
-  reprojected to the raster CRS automatically).
-- **Sizing** — *Min/Max element size*, depth coefficients *a*, *b*, and
-  *Max size gradient* (m/m; lower = smoother, wider fine-to-coarse transitions).
-- **Output** — choose a `.nc` path. On success the mesh is added to the project.
-
-> Element count scales as 1/h². A small *Min size* over a large *Detail region*
-> can produce millions of triangles and exhaust memory — keep the detail area
-> tight and the floor sensible.
-
-## Notes
-
-- The bundled `bluemesh2d` is a **copy** — update it by re-syncing the upstream
-  `bluemesh2d/` package into the plugin root (`rsync -a --exclude=__pycache__
-  --exclude=poly_data <repo>/bluemesh2d/ bluemesh2d_qgis/bluemesh2d/`).
-- Currently exposes the core raster→mesh path. ADCIRC `.grd`, Delft3D-FM forcing
-  (`.pli`/`.bc`/`.ext`) and quality reports exist in the library and can be added
-  as further algorithms.

bluemesh2d-0.1.1.dev0/bluemesh2d_qgis/__init__.py

@@ -1,21 +0,0 @@
-"""BlueMesh2D QGIS plugin package.
-
-QGIS calls :func:`classFactory` to instantiate the plugin.
-"""
-
-
-def classFactory(iface):
-    """Instantiate the plugin (QGIS's mandated plugin entry point).
-
-    Parameters
-    ----------
-    iface : qgis.gui.QgisInterface
-        QGIS application interface, passed in by QGIS.
-
-    Returns
-    -------
-    plugin : plugin.BlueMesh2DPlugin
-        The plugin instance.
-    """
-    from .plugin import BlueMesh2DPlugin
-    return BlueMesh2DPlugin(iface)