bluemesh2d 0.1.1.dev0__py3-none-any.whl

bluemesh2d/geomesh_util/interpolation_mesh.py

@@ -0,0 +1,318 @@
+import numpy as np
+import pyproj
+import rasterio
+from scipy.interpolate import LinearNDInterpolator
+from scipy.ndimage import map_coordinates, distance_transform_edt
+from scipy.spatial import cKDTree
+
+
+def interpolate_from_xyz(
+    x, y, z,
+    vert,
+    method="rbf",
+    rbf_function="cubic",
+    epsilon=None,
+):
+    """Interpolate scattered values at arbitrary target coordinates.
+
+    Parameters
+    ----------
+    x, y : ndarray of shape (N,)
+        Coordinates of scattered data points.
+    z : ndarray of shape (N,)
+        Scalar values at the scattered points.
+    vert : ndarray of shape (M, 2) or (M, 3)
+        Target coordinates where interpolation is evaluated.
+    method : {'linear', 'nearest', 'rbf'}, optional
+        Interpolation method. ``'linear'`` uses
+        :class:`scipy.interpolate.LinearNDInterpolator`; ``'nearest'`` uses a
+        KD-tree; ``'rbf'`` uses :class:`scipy.interpolate.RBFInterpolator``.
+    rbf_function : str, optional
+        RBF kernel (e.g. ``'cubic'``, ``'thin_plate_spline'``). Used only when
+        ``method='rbf'``.
+    epsilon : float, optional
+        RBF shape parameter. Auto-estimated when ``None``.
+
+    Returns
+    -------
+    values_interp : ndarray of shape (M,)
+        Interpolated values at ``vert`` (negated; NaN replaced by 0).
+    """
+
+    # Remove invalid points
+    mask = np.isfinite(x) & np.isfinite(y) & np.isfinite(z)
+    x, y, z = x[mask], y[mask], z[mask]
+    points = np.column_stack((x, y))
+
+    # Interpolation method
+    if method == "linear":
+        interp = LinearNDInterpolator(points, z, fill_value=np.nan)
+        values_interp = interp(vert[:, 0], vert[:, 1], vert[:, 2])
+
+    elif method == "nearest":
+        tree = cKDTree(points)
+        _, idx = tree.query(vert)
+        values_interp = z[idx]
+
+    elif method == "rbf":
+        # lazy import: RBFInterpolator needs scipy >= 1.7, and old QGIS
+        # bundles (e.g. macOS LTR with scipy 1.5) must still be able to use
+        # the other methods
+        try:
+            from scipy.interpolate import RBFInterpolator
+        except ImportError as exc:
+            raise ImportError(
+                "method='rbf' needs scipy >= 1.7 (RBFInterpolator); this "
+                "environment has an older scipy -- use method='linear' or "
+                "'nearest' instead.") from exc
+        interp = RBFInterpolator(points, z, kernel=rbf_function, epsilon=epsilon)
+        values_interp = interp(vert)
+
+    else:
+        raise ValueError("method must be 'linear', 'nearest', or 'rbf'")
+
+    # Handle NaNs
+    values_interp = - np.asarray(values_interp, dtype=float)
+    values_interp[np.isnan(values_interp)] = 0
+
+    return values_interp
+
+
+def interpolate_from_tiff(
+    tiff_path, vert, input_crs=None, order=3, mode="constant", cval=np.nan,
+    invert_z=False, nodata_value=None, max_cells=None
+):
+    """Interpolate GeoTIFF raster values at mesh node coordinates.
+
+    Only the window covering the mesh nodes is read (decimated when very
+    large), so an oversized bathymetry raster is sampled without being read
+    in full.
+
+    Parameters
+    ----------
+    tiff_path : str
+        Path to the GeoTIFF file.
+    vert : ndarray of shape (N, 2)
+        Node coordinates ``(x, y)`` in ``input_crs``.
+    input_crs : str or pyproj.CRS, optional
+        CRS of ``vert``. If ``None``, assumes the raster CRS.
+    order : int, optional
+        Interpolation order for :func:`scipy.ndimage.map_coordinates` (0 =
+        nearest, 1 = bilinear, 3 = bicubic). Default is 3.
+    mode : str, optional
+        Boundary handling mode. Default is ``'constant'``.
+    cval : float, optional
+        Fill value outside the domain when ``mode='constant'``. Default is
+        ``np.nan``.
+    invert_z : bool, optional
+        By default the raster stores elevation (positive up) and node values
+        are depth ``-value``. Set ``True`` for a depth-positive-down raster,
+        giving ``+value``. Default ``False``.
+    nodata_value : float or None, optional
+        Elevation (positive up) assigned to nodata / non-finite pixels.
+        ``None`` (default) fills them from the nearest valid pixel.
+    max_cells : int or None, optional
+        Decimate the read window above this many cells. ``None`` sizes it to
+        available RAM.
+
+    Returns
+    -------
+    z : ndarray of shape (N,)
+        Node values: depth (``-elevation``), or ``+value`` if ``invert_z``.
+    """
+    from bluemesh2d.feedback import _available_ram_bytes
+    from bluemesh2d.geom_util.proj_util import (
+        bundled_raster_data_env, require_georeferenced)
+    from bluemesh2d.geomesh_util.depth_field import (
+        _cell_center_offset, _read_window_decimated)
+
+    if max_cells is None:
+        avail = _available_ram_bytes() or 4_000_000_000
+        max_cells = int(min(120_000_000, max(4_000_000, 0.15 * avail / 16.0)))
+    sign = 1.0 if invert_z else -1.0
+
+    with bundled_raster_data_env(), rasterio.open(tiff_path) as src:
+        require_georeferenced(src)
+        raster_crs = src.crs
+        nodata = src.nodata
+
+        # node coordinates in the raster CRS, and the window that covers them
+        if (input_crs is not None
+                and pyproj.CRS.from_user_input(input_crs) != raster_crs):
+            transformer = pyproj.Transformer.from_crs(
+                input_crs, raster_crs, always_xy=True).transform
+            xs, ys = transformer(vert[:, 0], vert[:, 1])
+        else:
+            xs, ys = np.asarray(vert[:, 0]), np.asarray(vert[:, 1])
+        bbox = (float(np.min(xs)), float(np.min(ys)),
+                float(np.max(xs)), float(np.max(ys)))
+        center_off = _cell_center_offset(src)  # 0.5 Area / 0.0 Point
+        band, transform, _ = _read_window_decimated(src, bbox, max_cells)
+        band = band.astype(np.float64)
+
+    if nodata is not None:
+        band = np.where(band == nodata, np.nan, band)
+    else:
+        band = np.where(~np.isfinite(band), np.nan, band)
+
+    if np.isnan(band).any():
+        if nodata_value is None:
+            mask = np.isnan(band)
+            if mask.all():
+                band = np.zeros_like(band)  # nothing valid to fill from
+            else:
+                _, indices = distance_transform_edt(mask, return_indices=True)
+                band = band[tuple(indices)]
+        else:
+            band = np.where(np.isnan(band), float(nodata_value), band)
+    band_filled = band
+
+    inv_transform = ~transform
+    cols, rows = inv_transform * (xs, ys)
+    # the transform is corner-referenced (index k -> corner); for Area rasters
+    # band[i, j] is the cell CENTRE value, so shift by half a cell to sample
+    # centres (no half-cell shift). Point rasters use offset 0. Rim points
+    # falling outside the centre grid are handled by the nearest-fill branch.
+    cols = cols - center_off
+    rows = rows - center_off
+
+    mask_inside = (
+        (cols >= 0) & (cols < band.shape[1]) &
+        (rows >= 0) & (rows < band.shape[0])
+    )
+
+    z = np.full_like(np.asarray(xs, dtype=float), np.nan, dtype=float)
+
+    if np.any(mask_inside):
+        z[mask_inside] = sign * map_coordinates(
+            band_filled,
+            [rows[mask_inside], cols[mask_inside]],
+            order=order,
+            mode=mode,
+            cval=cval,
+            prefilter=False,
+        )
+
+    if np.any(~mask_inside):
+        rows_clip = np.clip(rows, 0, band.shape[0] - 1)
+        cols_clip = np.clip(cols, 0, band.shape[1] - 1)
+        z[~mask_inside] = sign * band_filled[
+            rows_clip[~mask_inside].astype(int),
+            cols_clip[~mask_inside].astype(int)]
+
+    return z
+
+
+def interpolate_from_xr(
+    ds,
+    vert,
+    order=3,
+    mode="constant",
+    cval=np.nan,
+    x_name='lon',
+    y_name='lat',
+    z_name="elevation",
+    fill_nan=True,
+    handle_out_of_bounds="nearest",
+):
+    """Interpolate bathymetry from an xarray dataset at mesh node coordinates.
+
+    Parameters
+    ----------
+    ds : xarray.Dataset
+        Dataset with coordinate and elevation variables.
+    vert : ndarray of shape (N, 2)
+        Node coordinates ``(lon, lat)`` in degrees (EPSG:4326).
+    order : int, optional
+        Interpolation order (0 = nearest, 1 = bilinear, 3 = bicubic). Default is 3.
+    mode : str, optional
+        Boundary handling mode for :func:`scipy.ndimage.map_coordinates`.
+        Default is ``'constant'``.
+    cval : float, optional
+        Fill value outside the domain when ``mode='constant'``. Default is
+        ``np.nan``.
+    x_name, y_name : str, optional
+        Names of the longitude and latitude coordinate variables in ``ds``.
+    z_name : str, optional
+        Name of the elevation variable in ``ds``. Default is ``'elevation'``.
+    fill_nan : bool, optional
+        If ``True``, fill NaN values in the dataset with the nearest valid
+        value. Default is ``True``.
+    handle_out_of_bounds : {'nearest', 'nan', 'clip'}, optional
+        Strategy for points outside the dataset extent. Default is ``'nearest'``.
+
+    Returns
+    -------
+    z : ndarray of shape (N,)
+        Interpolated depth values at mesh nodes (positive for ocean depth).
+    """
+
+    lon = ds[x_name].values
+    lat = ds[y_name].values
+    band = np.asarray(ds[z_name].values).astype(float)
+    
+    # Handle NaN values in band (e.g., land mask)
+    if fill_nan and np.isnan(band).any():
+        mask = np.isnan(band)
+        _, indices = distance_transform_edt(mask, return_indices=True)
+        band = band[tuple(indices)]
+
+    # Extract coordinates (assumed to be lon/lat)
+    xs, ys = vert[:, 0], vert[:, 1]
+
+    # np.interp returns indices even for out-of-bounds values (extrapolates)
+    lon_idx = np.interp(xs, lon, np.arange(len(lon)))
+    lat_idx = np.interp(ys, lat, np.arange(len(lat)))
+    
+    # Identify points inside/outside domain
+    lon_min, lon_max = lon.min(), lon.max()
+    lat_min, lat_max = lat.min(), lat.max()
+    
+    mask_inside = (
+        (xs >= lon_min) & (xs <= lon_max) &
+        (ys >= lat_min) & (ys <= lat_max)
+    )
+    
+    # Initialize output array
+    z = np.full_like(xs, np.nan, dtype=float)
+    
+    # Interpolate points inside domain
+    if np.any(mask_inside):
+        # Clip indices to valid range for map_coordinates
+        lat_idx_clip = np.clip(lat_idx[mask_inside], 0, len(lat) - 1)
+        lon_idx_clip = np.clip(lon_idx[mask_inside], 0, len(lon) - 1)
+        
+        z[mask_inside] = -map_coordinates(
+            band,
+            [lat_idx_clip, lon_idx_clip],
+            order=order,
+            mode=mode,
+            cval=cval,
+            prefilter=(order > 1)  # Prefilter only for order > 1 (bicubic)
+        )
+    
+    if np.any(~mask_inside):
+        if handle_out_of_bounds == "nearest":
+            # Use nearest neighbor for out-of-bounds points
+            lat_idx_clip = np.clip(lat_idx[~mask_inside], 0, len(lat) - 1).astype(int)
+            lon_idx_clip = np.clip(lon_idx[~mask_inside], 0, len(lon) - 1).astype(int)
+            z[~mask_inside] = -band[lat_idx_clip, lon_idx_clip]
+        elif handle_out_of_bounds == "clip":
+            # Clip coordinates to domain and interpolate
+            xs_clip = np.clip(xs[~mask_inside], lon_min, lon_max)
+            ys_clip = np.clip(ys[~mask_inside], lat_min, lat_max)
+            lon_idx_clip = np.interp(xs_clip, lon, np.arange(len(lon)))
+            lat_idx_clip = np.interp(ys_clip, lat, np.arange(len(lat)))
+            lat_idx_clip = np.clip(lat_idx_clip, 0, len(lat) - 1)
+            lon_idx_clip = np.clip(lon_idx_clip, 0, len(lon) - 1)
+            z[~mask_inside] = -map_coordinates(
+                band,
+                [lat_idx_clip, lon_idx_clip],
+                order=order,
+                mode=mode,
+                cval=cval,
+                prefilter=(order > 1)
+            )
+        # else: "nan" - already initialized with NaN
+
+    return z

bluemesh2d/geomesh_util/merge_circumcenters.py

@@ -0,0 +1,268 @@
+"""Merge circumcenters along small dual links into quadrilateral faces.
+
+Identifies short flow links, merges adjacent triangle pairs into quads, and
+rebuilds a mixed tri/quad UGRID dataset compatible with Delft3D-FM export.
+"""
+
+import numpy as np
+import xarray as xr
+
+from .grd_util import build_ugrid_arrays_mixed, triangulate_mixed_face_row_to_tris
+
+
+def _faces_list_from_ds(ds: xr.Dataset) -> list:
+    """0-based polygon faces (len 3 or 4) from ``mesh2d_face_nodes``."""
+    face_nodes_raw = np.asarray(ds["mesh2d_face_nodes"].values, dtype=np.int64)
+    start = int(ds["mesh2d_face_nodes"].attrs.get("start_index", 1))
+    if start == 1:
+        face0b = np.full_like(face_nodes_raw, -1)
+        valid = face_nodes_raw > 0
+        face0b[valid] = face_nodes_raw[valid] - 1
+    else:
+        face0b = face_nodes_raw.copy()
+    faces: list = []
+    for row in face0b:
+        nodes = row[row >= 0]
+        if nodes.size >= 3:
+            faces.append(nodes.astype(np.int64, copy=True))
+    return faces
+
+
+def _mixed_faces_to_triangles(vert_xy: np.ndarray, faces: list) -> np.ndarray:
+    """Expand mixed faces to triangle rows using the merge diagonal ``(v1, v2)``."""
+    xy = np.asarray(vert_xy, dtype=np.float64)[:, :2]
+    tris: list = []
+    for f in faces:
+        fn = np.asarray(f, dtype=np.int64).reshape(-1)
+        if fn.size < 3:
+            continue
+        tris.extend(triangulate_mixed_face_row_to_tris(xy, fn))
+    if not tris:
+        return np.empty((0, 3), dtype=np.int64)
+    return np.asarray(tris, dtype=np.int64)
+
+
+def _signed_area_quad(vert, quad):
+    """Signed area (doubled) of quadrilateral for orientation check."""
+    v = vert[quad]
+    return (
+        (v[1, 0] - v[0, 0]) * (v[2, 1] - v[0, 1])
+        - (v[2, 0] - v[0, 0]) * (v[1, 1] - v[0, 1])
+        + (v[2, 0] - v[1, 0]) * (v[3, 1] - v[1, 1])
+        - (v[3, 0] - v[1, 0]) * (v[2, 1] - v[1, 1])
+    )
+
+
+def _merge_small_links_into_faces(tria, edge_cc, small_link_indices, vert):
+    """Merge triangle pairs along small links into quadrilateral faces."""
+    merged = set()
+    quads = []
+    for idx in small_link_indices:
+        e = edge_cc[idx]
+        v1, v2, t1, t2 = int(e[0]), int(e[1]), int(e[2]), int(e[3])
+        if t2 < 0 or t1 in merged or t2 in merged:
+            continue
+        tri1 = tria[t1]
+        tri2 = tria[t2]
+        mask1 = (tri1 != v1) & (tri1 != v2)
+        mask2 = (tri2 != v1) & (tri2 != v2)
+        if not np.any(mask1) or not np.any(mask2):
+            continue
+        a = int(tri1[mask1][0])
+        b = int(tri2[mask2][0])
+        quad = np.array([a, v1, b, v2], dtype=np.int32)
+        if _signed_area_quad(vert, quad) < 0:
+            quad = np.array([a, v2, b, v1], dtype=np.int32)
+        quads.append((t1, t2, quad))
+        merged.add(t1)
+        merged.add(t2)
+
+    faces_list = []
+    for t1, t2, q in quads:
+        faces_list.append(q)
+    for i in range(len(tria)):
+        if i not in merged:
+            faces_list.append(tria[i])
+    return faces_list
+
+
+def _rebuild_ds_from_form(ds_ori, ugrid_arrays):
+    """Rebuild an xarray dataset preserving the structure of ``ds_ori``."""
+
+    def _da(name, data, dims, attrs=None):
+        if name in ds_ori.variables and hasattr(ds_ori.variables[name], "attrs"):
+            base_attrs = dict(ds_ori.variables[name].attrs)
+        else:
+            base_attrs = {}
+        if attrs:
+            base_attrs.update(attrs)
+        return xr.DataArray(data=data, dims=dims, attrs=base_attrs)
+
+    coords = {
+        "mesh2d_node_x": _da(
+            "mesh2d_node_x",
+            ugrid_arrays["node_x"],
+            ("mesh2d_nNodes",),
+        ),
+        "mesh2d_node_y": _da(
+            "mesh2d_node_y",
+            ugrid_arrays["node_y"],
+            ("mesh2d_nNodes",),
+        ),
+    }
+
+    data_vars = {
+        "mesh2d_node_z": _da(
+            "mesh2d_node_z",
+            ugrid_arrays["node_z"],
+            ("mesh2d_nNodes",),
+        ),
+        "mesh2d_edge_x": _da(
+            "mesh2d_edge_x",
+            ugrid_arrays["edge_x"],
+            ("mesh2d_nEdges",),
+        ),
+        "mesh2d_edge_y": _da(
+            "mesh2d_edge_y",
+            ugrid_arrays["edge_y"],
+            ("mesh2d_nEdges",),
+        ),
+        "mesh2d_edge_nodes": _da(
+            "mesh2d_edge_nodes",
+            ugrid_arrays["edge_nodes"],
+            ("mesh2d_nEdges", "Two"),
+        ),
+        "mesh2d_edge_faces": _da(
+            "mesh2d_edge_faces",
+            ugrid_arrays["edge_faces"],
+            ("mesh2d_nEdges", "Two"),
+        ),
+        "mesh2d_face_nodes": _da(
+            "mesh2d_face_nodes",
+            ugrid_arrays["face_nodes"],
+            ("mesh2d_nFaces", "mesh2d_nMax_face_nodes"),
+        ),
+        "mesh2d_face_x": _da(
+            "mesh2d_face_x",
+            ugrid_arrays["face_x"],
+            ("mesh2d_nFaces",),
+        ),
+        "mesh2d_face_y": _da(
+            "mesh2d_face_y",
+            ugrid_arrays["face_y"],
+            ("mesh2d_nFaces",),
+        ),
+        "mesh2d_face_x_bnd": _da(
+            "mesh2d_face_x_bnd",
+            ugrid_arrays["face_x_bnd"],
+            ("mesh2d_nFaces", "mesh2d_nMax_face_nodes"),
+        ),
+        "mesh2d_face_y_bnd": _da(
+            "mesh2d_face_y_bnd",
+            ugrid_arrays["face_y_bnd"],
+            ("mesh2d_nFaces", "mesh2d_nMax_face_nodes"),
+        ),
+    }
+
+    # Copy non-mesh variables from ds_ori (e.g. wgs84, mesh2d topology variable)
+    mesh_dims = {
+        "mesh2d_nNodes",
+        "mesh2d_nEdges",
+        "mesh2d_nFaces",
+        "mesh2d_nMax_face_nodes",
+    }
+    for k in ds_ori.variables:
+        if k in coords or k in data_vars:
+            continue
+        v = ds_ori.variables[k]
+        if set(v.dims) & mesh_dims:
+            continue
+        data_vars[k] = xr.DataArray(
+            data=ds_ori[k].values.copy(),
+            dims=v.dims,
+            attrs=dict(v.attrs),
+        )
+
+    ds_final = xr.Dataset(data_vars=data_vars, coords=coords, attrs=dict(ds_ori.attrs))
+    return ds_final
+
+
+def merge_circumcenters(
+    ds_ori,
+    removesmalllinkstrsh=0.1,
+    jsferic=1,
+):
+    """Merge triangle pairs with small circumcenter links into quads.
+
+    Identifies short dual flow links, merges each adjacent triangle pair into
+    one quadrilateral, and rebuilds a Delft3D-FM UGRID dataset with the same
+    structure as ``ds_ori``.
+
+    Parameters
+    ----------
+    ds_ori : xarray.Dataset
+        Input UGRID Delft3D-FM mesh.
+    removesmalllinkstrsh : float, optional
+        Threshold for small flow links. Default is 0.1.
+    jsferic : int, optional
+        Coordinate mode: ``1`` treats node coordinates as lon/lat degrees;
+        ``0`` treats them as planar ``x/y``. Default is 1.
+
+    Returns
+    -------
+    ds_final : xarray.Dataset
+        Rebuilt mesh with small links replaced by quads.
+        ``mesh2d_nMax_face_nodes`` is 4; triangles are padded in the fourth
+        node column.
+    """
+    node_x = np.asarray(ds_ori["mesh2d_node_x"].values, dtype=np.float64)
+    node_y = np.asarray(ds_ori["mesh2d_node_y"].values, dtype=np.float64)
+    node_z = np.asarray(ds_ori["mesh2d_node_z"].values, dtype=np.float64)
+    vert = np.column_stack([node_x, node_y])
+
+    faces_in = _faces_list_from_ds(ds_ori)
+
+    # Triangulate mixed faces to a *triangle proxy* using the same diagonal
+    # (v1, v2) logic as the rest of the pipeline/export.
+    tria = _mixed_faces_to_triangles(vert, faces_in)
+    tria = np.asarray(tria, dtype=np.int32)
+
+    # IMPORTANT: use the same small-link metric as ortho_merge.orthogonalize,
+    # so our dual checks and merge decisions are consistent.
+    from ..ortho_merge import orthogonalize as ortho
+    from ..ortho_merge.geometry import build_edges_from_tria
+
+    edge_nodes, edge_faces = build_edges_from_tria(tria)
+    nlinktoosmall, small_edge_indices = ortho.compute_small_links_from_arrays(
+        node_x=node_x,
+        node_y=node_y,
+        face_nodes=tria,
+        edge_nodes=edge_nodes,
+        edge_faces=edge_faces,
+        removesmalllinkstrsh=float(removesmalllinkstrsh),
+        jsferic=jsferic,
+    )
+
+    if nlinktoosmall > 0:
+        # Build edge_cc compatible with `_merge_small_links_into_faces`:
+        # [v1, v2, t1, t2] where t1/t2 are adjacent face indices in `tria`.
+        edge_cc = np.column_stack(
+            [
+                edge_nodes[:, 0],
+                edge_nodes[:, 1],
+                edge_faces[:, 0],
+                edge_faces[:, 1],
+            ]
+        ).astype(np.int32, copy=False)
+
+        faces_list = _merge_small_links_into_faces(
+            tria, edge_cc, small_edge_indices, vert
+        )
+    else:
+        # No small links detected: keep the existing mixed topology.
+        faces_list = [np.asarray(f, dtype=np.int32).copy() for f in faces_in]
+
+    NODE = np.column_stack([vert[:, 0], vert[:, 1], node_z])
+    ugrid_arrays = build_ugrid_arrays_mixed(NODE, faces_list)
+    ds_final = _rebuild_ds_from_form(ds_ori, ugrid_arrays)
+    return ds_final