bluemesh2d 0.1.1.dev0__py3-none-any.whl

bluemesh2d/geom_util/proj_util.py

@@ -0,0 +1,250 @@
+import numpy as np
+import pyproj
+from shapely.ops import transform
+
+
+def get_utm_crs_from_crs(crs):
+    """Return a UTM CRS suited to the given geographic CRS.
+
+    Parameters
+    ----------
+    crs : pyproj.CRS
+        Input coordinate reference system.
+
+    Returns
+    -------
+    pyproj.CRS
+        UTM CRS for the origin of ``crs``, or ``crs`` unchanged if already projected.
+    """
+    if crs.is_projected:
+        return crs
+    transformer = pyproj.Transformer.from_crs(crs, "EPSG:4326", always_xy=True)
+    lon0, lat0 = transformer.transform(0, 0)
+    utm_zone = int((lon0 + 180) / 6) + 1
+    epsg_code = 326 if lat0 >= 0 else 327
+    return pyproj.CRS.from_epsg(epsg_code * 100 + utm_zone)
+
+def get_local_utm_crs(crs, x=None, y=None, bbox=None):
+    """Return a local Transverse Mercator CRS centered on the data.
+
+    If ``crs`` is already projected, it is returned unchanged. Otherwise the
+    data center is converted to WGS84 and a Transverse Mercator projection is
+    built with that central meridian and origin latitude (units in metres).
+
+    Parameters
+    ----------
+    crs : pyproj.CRS
+        CRS of the input data (geographic or projected).
+    x, y : array-like, optional
+        Point coordinates (same size). Ignored if bbox is provided.
+    bbox : tuple, optional
+        (xmin, ymin, xmax, ymax) in the input CRS.
+        Used if (x, y) are not provided.
+
+    Returns
+    -------
+    pyproj.CRS
+        Projected CRS in meters, centered on the data's area.
+    """
+    crs = pyproj.CRS.from_user_input(crs)
+    if crs.is_projected:
+        return crs
+
+    # Compute the center in the source CRS
+    if bbox is not None:
+        xmin, ymin, xmax, ymax = bbox
+        x_center = (xmin + xmax) / 2.0
+        y_center = (ymin + ymax) / 2.0
+    elif x is not None and y is not None:
+        x_center = np.nanmean(np.asarray(x))
+        y_center = np.nanmean(np.asarray(y))
+    else:
+        raise ValueError("Provide either (x, y) or bbox.")
+
+    # Convert the center to WGS84
+    transformer = pyproj.Transformer.from_crs(crs, "EPSG:4326", always_xy=True)
+    lon_center, lat_center = transformer.transform(x_center, y_center)
+
+    # Local Transverse Mercator: central meridian = lon_center, origin latitude = lat_center
+    # k=1 at the central meridian, units in meters
+    wkt = (
+        f'PROJCS["UTM local",'
+        f'GEOGCS["WGS 84",DATUM["WGS_1984",SPHEROID["WGS 84",6378137,298.257223563]],'
+        f'PRIMEM["Greenwich",0],UNIT["degree",0.0174532925199433]],'
+        f'PROJECTION["Transverse_Mercator"],'
+        f'PARAMETER["latitude_of_origin",{lat_center}],'
+        f'PARAMETER["central_meridian",{lon_center}],'
+        f'PARAMETER["scale_factor",1],'
+        f'PARAMETER["false_easting",0],'
+        f'PARAMETER["false_northing",0],'
+        f'UNIT["metre",1]]'
+    )
+    return pyproj.CRS.from_wkt(wkt)
+
+def get_proj_crs_from_ll(lon0, lat0):
+    """Create a local Transverse Mercator CRS centered on given coordinates.
+
+    Designed to match Delft3D-FM cartesian distance calculations when
+    ``jsferic=0``: Transverse Mercator with scale factor ``k=1.0`` at the
+    central meridian, units in metres.
+
+    Parameters
+    ----------
+    lon0 : float
+        Longitude of the projection center (degrees).
+    lat0 : float
+        Latitude of the projection center (degrees).
+
+    Returns
+    -------
+    pyproj.CRS
+        Local Transverse Mercator CRS in metres, centered on ``(lon0, lat0)``.
+
+    Notes
+    -----
+    Uses ``k=1.0`` for local accuracy rather than the UTM standard ``k=0.9996``.
+    """
+
+    # Use k=1.0 for better local accuracy (vs k=0.9996 for UTM)
+    # This matches Delft3D's local plane projection behavior
+    proj_local = pyproj.CRS.from_proj4(
+        f"+proj=tmerc +lat_0={lat0} +lon_0={lon0} +k=1.0 +x_0=0 +y_0=0 +datum=WGS84 +units=m +no_defs"
+    )
+    return proj_local
+
+
+def reproject_node(node, crs_from, crs_to):
+    """Reproject 2D vertex coordinates from one CRS to another.
+
+    Parameters
+    ----------
+    node : ndarray of shape (N, 2)
+        Array of vertex coordinates to be reprojected.
+    crs_from : pyproj.CRS
+        Source coordinate reference system.
+    crs_to : pyproj.CRS
+        Target coordinate reference system.
+
+    Returns
+    -------
+    ndarray of shape (N, 2)
+        Reprojected vertex coordinates.
+    """
+
+    node = np.asarray(node)
+    transformer = pyproj.Transformer.from_crs(crs_from, crs_to, always_xy=True)
+    x2, y2 = transformer.transform(node[:, 0], node[:, 1])
+    return np.column_stack((x2, y2))
+
+
+def reproject_geometry(geom, crs_from, crs_to):
+    """Reproject a Shapely geometry or coordinate array between CRSs.
+
+    Parameters
+    ----------
+    geom : ndarray of shape (N, 2) or shapely geometry
+        Coordinates or geometry to reproject.
+    crs_from : pyproj.CRS or str
+        Source coordinate reference system.
+    crs_to : pyproj.CRS or str
+        Target coordinate reference system.
+
+    Returns
+    -------
+    ndarray or shapely geometry
+        Reprojected geometry or coordinate array (same type as input).
+    """
+
+    transformer = pyproj.Transformer.from_crs(crs_from, crs_to, always_xy=True)
+    return transform(transformer.transform, geom).buffer(0)
+
+
+import contextlib as _contextlib
+
+
+@_contextlib.contextmanager
+def bundled_raster_data_env():
+    """Point rasterio's bundled GDAL/PROJ at their own data files.
+
+    Hosts like QGIS export ``GDAL_DATA``/``PROJ_LIB`` for *their* libraries;
+    a pip rasterio wheel (which bundles its own GDAL and PROJ) would then
+    read foreign -- usually newer -- data files and fail with obscure errors
+    (``proj.db DATABASE.LAYOUT`` mismatches and the like). This context uses
+    rasterio's own configuration channels only (``rasterio.Env`` and its
+    private PROJ search path), so the process environment -- and therefore
+    the host's pyproj/PROJ -- is never touched. A no-op when rasterio is not
+    a wheel (Linux system packages have no bundled data dirs).
+    """
+    import os
+
+    try:
+        import rasterio
+        base = os.path.dirname(rasterio.__file__)
+    except Exception:
+        yield
+        return
+
+    gdal_data = os.path.join(base, "gdal_data")
+    proj_data = os.path.join(base, "proj_data")
+    if os.path.isdir(proj_data):
+        try:  # binds rasterio's own PROJ (only) to its own database
+            from rasterio._env import set_proj_data_search_path
+            set_proj_data_search_path(proj_data)
+        except Exception:
+            pass
+    if os.path.isdir(gdal_data):
+        with rasterio.Env(GDAL_DATA=gdal_data):
+            yield
+        return
+    yield
+
+
+def require_georeferenced(dataset, what="bathymetry raster"):
+    """Raise a clear error when a raster has no CRS or no geotransform.
+
+    Without these the pipeline can't place the coastline / mesh in the world:
+    a missing CRS otherwise crashes deep in a PROJ call, and a missing
+    geotransform (rasterio substitutes the identity affine) would silently
+    produce geometry in pixel coordinates. Fail early with an actionable
+    message instead.
+    """
+    if dataset.crs is None:
+        raise ValueError(
+            f"The {what} has no coordinate reference system (CRS). Assign one "
+            "(in QGIS: right-click the layer -> Properties -> Source -> Set "
+            "CRS, or `gdal_edit.py -a_srs EPSG:xxxx file.tif`) before meshing.")
+    if dataset.transform.is_identity:
+        raise ValueError(
+            f"The {what} is not georeferenced: it has no geotransform, so map "
+            "and pixel coordinates are the same. Georeference it (assign a "
+            "geotransform or a world file) before meshing.")
+
+
+def _raster_crs(src):
+    """Build a pyproj CRS from an open rasterio dataset, robustly.
+
+    Prefer the EPSG code (a single, well-trodden PROJ database lookup) over
+    parsing the full WKT: the WKT parser resolves the datum against the PROJ
+    database and has been observed to hard-crash (access violation) in some
+    QGIS/PROJ builds. Falls back to WKT only when there is no EPSG code.
+
+    Parameters
+    ----------
+    src : rasterio.io.DatasetReader
+        Open rasterio dataset.
+
+    Returns
+    -------
+    crs : pyproj.CRS
+        CRS of ``src``.
+    """
+    import pyproj
+
+    try:
+        epsg = src.crs.to_epsg()
+    except Exception:
+        epsg = None
+    if epsg:
+        return pyproj.CRS.from_epsg(epsg)
+    return pyproj.CRS.from_wkt(src.crs.to_wkt())
+

bluemesh2d/geomesh_util/border_util.py

@@ -0,0 +1,283 @@
+import numpy as np
+from shapely.geometry import LinearRing, Point, Polygon
+
+
+def read_poly_from_dat(dat_path, delimiter=None):
+    """Read polygon contours from a ``.dat`` file into PSLG node/edge arrays.
+
+    Contours are separated by ``NaN NaN`` rows. Each contour is closed and
+    concatenated into global node and edge arrays.
+
+    Parameters
+    ----------
+    dat_path : str
+        Path to the ``.dat`` file.
+    delimiter : str, optional
+        Delimiter for :func:`numpy.loadtxt`. Default is auto-detected.
+
+    Returns
+    -------
+    node : ndarray of shape (N, 2)
+        Vertex coordinates ``(x, y)``.
+    edge : ndarray of shape (M, 2), dtype int
+        Edge connectivity (0-based vertex indices).
+    """
+
+    # Load file
+    p0 = np.loadtxt(dat_path, delimiter=delimiter)
+    if p0.shape[1] < 2:
+        raise ValueError("The .dat file must contain at least two columns: x y")
+
+    # Find NaN separators
+    isnan = np.isnan(p0[:, 0])
+    s = np.where(isnan)[0]
+    s = np.concatenate(([0], s, [len(p0)]))
+
+    node = []
+    edge = []
+    cont = 0
+
+    # Loop over polygons
+    for i in range(len(s) - 1):
+        p = p0[s[i] : s[i + 1], :]
+        p = p[~np.isnan(p[:, 0])]  # remove NaN rows
+        if len(p) == 0:
+            continue
+
+        n = len(p)
+        # Close the polygon by connecting last point to first
+        c = np.column_stack([np.arange(0, n), np.arange(1, n + 1)])
+        c[-1, 1] = 0  # last edge closes to first
+
+        # Apply offset to edge indices
+        c = c + cont
+
+        # Append
+        node.append(p)
+        edge.append(c)
+
+        cont += n  # offset for next polygon
+
+    # Concatenate all nodes and edges
+    node = np.vstack(node)
+    edge = np.vstack(edge).astype(int)
+
+    return node, edge
+
+
+def _split_edges_at_discontinuity(edges):
+    """Split an edge list wherever consecutive rows share no vertex."""
+    if edges is None or edges.size == 0:
+        return []
+    edges = np.asarray(edges, dtype=int)
+    n = len(edges)
+    if n == 1:
+        return [edges]
+    
+    chunks = []
+    start = 0
+    
+    for i in range(1, n):
+        a, b = int(edges[i, 0]), int(edges[i, 1])
+        a_prev, b_prev = int(edges[i - 1, 0]), int(edges[i - 1, 1])
+        # Check if current edge shares a vertex with previous
+        shared = (a == a_prev or a == b_prev or b == a_prev or b == b_prev)
+        
+        if not shared:
+            # Discontinuity: cut here
+            chunks.append(edges[start:i])
+            start = i
+    
+    # Add the last chunk
+    chunks.append(edges[start:])
+    return chunks
+
+
+def _ordered_edges_to_chains(edges):
+    """Order edges into chains, then split at discontinuities."""
+    if edges is None or edges.size == 0:
+        return []
+    edges = np.asarray(edges, dtype=int)
+    n = len(edges)
+    
+    # Build adjacency
+    adj = {}
+    for i in range(n):
+        u, v = int(edges[i, 0]), int(edges[i, 1])
+        if u not in adj:
+            adj[u] = []
+        adj[u].append((i, v))
+        if v not in adj:
+            adj[v] = []
+        adj[v].append((i, u))
+    
+    used = set()
+    ordered_chains = []
+
+    def extend_forward(last_v, lst, used_set):
+        while True:
+            cands = [(ei, other) for ei, other in adj[last_v] if ei not in used_set]
+            if not cands:
+                break
+            ei, other = cands[0]
+            lst.append((int(edges[ei, 0]), int(edges[ei, 1])))
+            used_set.add(ei)
+            last_v = other
+
+    def extend_backward(first_v, lst, used_set):
+        while True:
+            cands = [(ei, other) for ei, other in adj[first_v] if ei not in used_set]
+            if not cands:
+                break
+            ei, other = cands[0]
+            lst.insert(0, (int(edges[ei, 0]), int(edges[ei, 1])))
+            used_set.add(ei)
+            first_v = other
+
+    # Build chains per connected component
+    for start_i in range(n):
+        if start_i in used:
+            continue
+        a0, b0 = int(edges[start_i, 0]), int(edges[start_i, 1])
+        chain = [(a0, b0)]
+        used.add(start_i)
+        extend_forward(b0, chain, used)
+        extend_backward(a0, chain, used)
+        ordered_chains.append(np.array(chain, dtype=int))
+
+    if not ordered_chains:
+        return []
+    
+    # Concatenate all chains into one ordered array
+    flat = np.vstack(ordered_chains)
+    
+    # Split at discontinuities (consecutive rows without shared vertex)
+    return _split_edges_at_discontinuity(flat)
+
+
+def _chain_edges_to_nodelist(edge_arr):
+    """Ordered (m, 2) edges -> 1D array of node indices."""
+    if edge_arr is None or len(edge_arr) == 0:
+        return np.array([], dtype=int)
+    edge_arr = np.asarray(edge_arr, dtype=int)
+    out = [int(edge_arr[0, 0]), int(edge_arr[0, 1])]
+    for i in range(1, len(edge_arr)):
+        a, b = int(edge_arr[i, 0]), int(edge_arr[i, 1])
+        if a == out[-1]:
+            out.append(b)
+        elif b == out[-1]:
+            out.append(a)
+        elif a == out[0]:
+            out.insert(0, b)
+        elif b == out[0]:
+            out.insert(0, a)
+        else:
+            out.append(a)
+            out.append(b)
+    return np.array(out, dtype=int)
+
+
+def identify_boundary(vert, tria, z, zlim=0.0, Manual_open_boundary=None):
+    """Classify open and land boundaries from a triangulated mesh.
+
+    Boundary edges are the mesh edges adjacent to only one triangle. They are
+    tagged open when mean nodal elevation exceeds ``zlim`` or the edge midpoint
+    lies inside ``Manual_open_boundary``. Contours are ordered and split at
+    discontinuities.
+
+    Parameters
+    ----------
+    vert : ndarray of shape (N, 2)
+        Node coordinates ``(x, y)``.
+    tria : ndarray of shape (M, 3)
+        Triangle connectivity (0-based node indices).
+    z : ndarray of shape (N,)
+        Nodal elevation values.
+    zlim : float, optional
+        Elevation threshold; edges with mean elevation above this are open.
+        Default is 0.0.
+    Manual_open_boundary : shapely.geometry.Polygon, optional
+        Edges whose midpoint lies inside this polygon are classified as open.
+
+    Returns
+    -------
+    dict
+        Dictionary with keys:
+
+        - ``edge_tag`` : ndarray of shape (K, 3), ``(node1, node2, tag)``
+          (tag 1 = open, 2 = land)
+        - ``edge_open`` : ndarray of shape (L, 2), flat open-boundary edges
+        - ``edge_land`` : ndarray of shape (P, 2), flat land-boundary edges
+        - ``open_contours`` : list of 1D node-index arrays (one per contour)
+        - ``land_contours`` : list of 1D node-index arrays (one per contour)
+    """
+    edges = np.vstack([tria[:, [0, 1]], tria[:, [1, 2]], tria[:, [2, 0]]])
+    edges = np.sort(edges, axis=1)
+    edges_sorted, counts = np.unique(edges, axis=0, return_counts=True)
+    edge_free = edges_sorted[counts == 1]
+    if edge_free.size == 0:
+        return {
+            "edge_tag": np.empty((0, 3), dtype=int),
+            "edge_open": np.empty((0, 2), dtype=int),
+            "edge_land": np.empty((0, 2), dtype=int),
+            "open_contours": [],
+            "land_contours": [],
+        }
+
+    edge_open_list = []
+    edge_land_list = []
+    for (a, b) in edge_free:
+        zmean = 0.5 * (z[a] + z[b])
+        mid = (vert[a] + vert[b]) / 2.0
+        in_manual = (
+            Manual_open_boundary.contains(Point(mid))
+            if Manual_open_boundary is not None
+            else False
+        )
+        if zmean > zlim or in_manual:
+            edge_open_list.append([a, b])
+        else:
+            edge_land_list.append([a, b])
+
+    edge_open = (
+        np.array(edge_open_list, dtype=int)
+        if edge_open_list
+        else np.empty((0, 2), dtype=int)
+    )
+    edge_land = (
+        np.array(edge_land_list, dtype=int)
+        if edge_land_list
+        else np.empty((0, 2), dtype=int)
+    )
+
+    open_chains = _ordered_edges_to_chains(edge_open)
+    land_chains = _ordered_edges_to_chains(edge_land)
+
+    open_contours = [_chain_edges_to_nodelist(c) for c in open_chains]
+    land_contours = [_chain_edges_to_nodelist(c) for c in land_chains]
+
+    edge_open_flat = (
+        np.vstack(open_chains) if open_chains else np.empty((0, 2), dtype=int)
+    )
+    edge_land_flat = (
+        np.vstack(land_chains) if land_chains else np.empty((0, 2), dtype=int)
+    )
+
+    tag_open = np.ones((edge_open_flat.shape[0], 1), dtype=int)
+    tag_land = np.full((edge_land_flat.shape[0], 1), 2, dtype=int)
+    edge_tag_parts = []
+    if edge_open_flat.shape[0] > 0:
+        edge_tag_parts.append(np.hstack([edge_open_flat, tag_open]))
+    if edge_land_flat.shape[0] > 0:
+        edge_tag_parts.append(np.hstack([edge_land_flat, tag_land]))
+    edge_tag = (
+        np.vstack(edge_tag_parts) if edge_tag_parts else np.empty((0, 3), dtype=int)
+    )
+
+    return {
+        "edge_tag": edge_tag,
+        "edge_open": edge_open_flat,
+        "edge_land": edge_land_flat,
+        "open_contours": open_contours,
+        "land_contours": land_contours,
+    }