Skeleton

.env_example

@@ -0,0 +1,2 @@
+DB_UNI_USER='TO_BE_DEFINED'
+DB_UNI_PASSWORD='TO_BE_DEFINED'

.github/workflows/ci.yaml

@@ -30,5 +30,8 @@ jobs:
           generate-run-shell: true
       - name: Unit test
         shell: micromamba-shell {0}
-        run: python -m pytest -s --log-cli-level DEBUG
-
+        run: |
+          cp .env_example .env
+          sed -i "s/DB_UNI_USER='TO_BE_DEFINED'/DB_UNI_USER=${{ secrets.DB_UNI_USER }}/g" .env
+          sed -i "s/DB_UNI_PASSWORD='TO_BE_DEFINED'/DB_UNI_PASSWORD=${{ secrets.DB_UNI_PASSWORD }}/g" .env
+          python -m pytest -s --log-cli-level DEBUG

.gitignore

@@ -1,3 +1,7 @@
 **/__pycache__
 tmp
-**.log
+**.log
+
+.env
+
+outputs/

README.md

@@ -77,7 +77,7 @@ pre-commit install
 ```
 
 ## Données de test
-Les données de test se trouvent dans un autre projet ici : http://gitlab.forge-idi.ign.fr/Lidar/lidro-data
+Les données de test se trouvent dans un autre projet ici : https://github.com/IGNF/lidro-data
 
 Ce projet est un sous module git, qui sera téléchargé dans le dossier `data`, via la commande:
 
@@ -108,3 +108,29 @@ Pour lancer les tests :
 ```
 python -m pytest -s
 ```
+### paramètres pour créer les squelettes des cours d'eau
+Pour fonctionner, la création de squelettes a besoin d'une série de paramètres, certains ayant une valeur par défaut, d'autres non. Les paramètres se trouvent dans le fichier configs/configs_lidro.yaml. On peut soit les y modifier, soit les modifer en ligne de commande lors de l'exécution du script avec :
+```
+python lidro/main_create_skeleton_lines.py [nom_paramètre_1]=[valeur_du_paramètre_1] [nom_paramètre_2]=[valeur_du_paramètre_2]
+```
+ces paramètres sont :  
+io.skeleton.mask_input_path : Le chemin d'entrée des masques des cours d'eau
+io.skeleton.skeleton_lines_output_path : Le chemin de sortie des squelettes uniquement (pas de fichier de sortie si laissé à vide)
+io.skeleton.gap_lines_output_path : Le chemin de sortie des lignes franchissant des ponts uniquement (pas de fichier de sortie si laissé à vide)
+io.skeleton.global_lines_output_path : Le chemin de sortie des lignes et des squelettes ensemble
+
+skeleton.max_gap_width : La distance maximale envisagée pour franchir des ponts
+skeleton.max_bridges : Le nombre maximal de ponts entre deux bras séparés de cours d'eau
+skeleton.gap_width_check_db : La distance à partir de laquelle on vérifie via la base de données s'il y a bien un pont
+skeleton.ratio_gap : la proportion de la ligne franchissant un pont qui est comparé en base pour voir s'il y a bien un pont (trop grande et on pourrait trouver un pont qui ne correspond pas)
+
+skeleton.db_uni.db_using_db : # Si à faux, la base de données ne sera pas utilisée (prévu pour être utilisé que s'il n'y pas d'accès à la base de données)
+skeleton.db_uni.db_name : Le nom de la base de données
+skeleton.db_uni.db_host : l'adresse de la base de données
+skeleton.db_uni.db_user : L'utilisateur de la base de données
+skeleton.db_uni.db_password : Le mot de passe de l'utilisateur
+skeleton.db_uni.db_port : La port de connexion avec la base de données
+
+skeleton.branch.voronoi_max_length : LA longuer maximum des lignes individuelles des squelettes
+skeleton.branch.water_min_size : La longueur minimal à partir de laquelle une ligne de squelette sera automatiquement gardée (trop petite, et il y aura des sortes "d'aiguilles" qui apparaitront. Trop grande, et certains afluents ne seront pas détectés)
+skeleton.branch.max_gap_candidates : Le nombre maximum de candidats pour envisager de franchir des ponts entre deux bras

configs/configs_lidro.yaml

@@ -19,6 +19,12 @@ io:
   no_data_value: -9999
   tile_size: 1000
 
+  skeleton:
+    mask_input_path: null
+    skeleton_lines_output_path: null # only branches' skeleton (if empty, no file is created)
+    gap_lines_output_path: null # only new lines to close gaps (if empty, no file is created)
+    global_lines_output_path: null # lines from both the skeletons and the gap lines
+
 mask_generation:
   raster:
     # size for dilatation
@@ -47,6 +53,27 @@ virtual_point:
     # The number of nearest neighbors to find with KNeighbors
     k: 20
 
+skeleton:
+  max_gap_width: 200 # distance max in meter of any gap between 2 branches we will try to close with a line
+  max_bridges: 1 # number max of bridges that can be created between 2 branches
+  gap_width_check_db: 20 # for a gap at least this wide, we check with db_uni if there is a bridge. Smaller than that, we assume a line automatically exists
+  ratio_gap: 0.25 # when checking if a candidate line to close a gap intersects a bridge in BD UNI, that's the ratio ]0.1] of the line to consider.
+                  # we only check part of the line, because when the line is really long it can intersect with bridges not corresponding to that line,
+                  # so we make the line smaller
+
+  db_uni:
+    db_using_db: True # if false, the DB won't be queried (expected to be used only in case you don't have access to the database)
+    db_name: bduni_france_consultation
+    db_host: bduni_consult.ign.fr
+    db_user: null
+    db_password: null
+    db_port: 5432
+
+  branch:
+    voronoi_max_length: 2 # max size of a voronoi line
+    water_min_size: 500 # min size of a skeleton line to be sure not to be removed (should be at least more than half the max river width)
+    max_gap_candidates: 3 # max number of candidates to close a gap between 2 branches
+
 hydra:
   output_subdir: null
   run:

environment.yml

@@ -16,6 +16,8 @@ dependencies:
   - pdal>=2.6
   - python-pdal>=3.2.1
   - shapely>=2.0.3
+  - psycopg[binary]
+  - python-dotenv
     # --------- hydra configs --------- #
   - hydra-core
   - hydra-colorlog

lidro/create_mask_hydro/rasters/create_mask_raster.py

@@ -73,4 +73,4 @@ def detect_hydro_by_tile(filename: str, tile_size: int, pixel_size: float, class
         detected_water, structure=np.ones((dilation_size, dilation_size))
     ).astype(np.uint8)
 
-    return water_mask, pcd_origin
+    return water_mask, pcd_origin

lidro/main_create_mask.py

@@ -3,11 +3,14 @@
 
 import logging
 import os
+import sys
 
 import hydra
 from omegaconf import DictConfig
 from pyproj import CRS
 
+sys.path.append('../lidro')
+
 from lidro.create_mask_hydro.vectors.convert_to_vector import create_hydro_vector_mask
 
 

lidro/main_create_skeleton_lines.py

@@ -0,0 +1,68 @@
+""" Main script for creating skeleton lines inside masks
+"""
+import sys
+
+import hydra
+from omegaconf import DictConfig
+
+import geopandas as gpd
+import pandas as pd
+from shapely.geometry import Point
+
+sys.path.append('../lidro')
+
+from lidro.skeleton.create_skeleton_lines import create_branches_list, create_branches_pair, select_candidates
+from lidro.skeleton.branch import Branch, line_merge
+
+
+@hydra.main(version_base="1.2", config_path="../configs/", config_name="configs_lidro.yaml")
+def run(config: DictConfig):
+    """
+    Get whole hydrographic skeleton lines, based on
+    a geojson file containing multiple river contours.
+    The result file will contain "skeleton" lines running in the middle of
+    those contours to describe the flow of the rivers, and lines crossing the contours
+    to join with the skeleton lines, as bridge and other elements may "break" river contours
+    args:
+        - config (DictConfig): the config dict from hydra
+    """
+
+    gdf_hydro_global_mask = gpd.read_file(config.io.skeleton.mask_input_path)
+    crs = gdf_hydro_global_mask.crs  # Load a crs from input
+
+    branches_list = create_branches_list(config, gdf_hydro_global_mask, crs)
+    branches_pair_list = create_branches_pair(config, branches_list)
+    validated_candidates = select_candidates(config, branches_pair_list)
+
+    # create the gap lines from the selected candidates
+    gap_lines_list = [validated_candidate.line for validated_candidate in validated_candidates]
+    gdf_gap_lines = gpd.GeoDataFrame(geometry=gap_lines_list).set_crs(crs, allow_override=True)
+    if config.io.skeleton.gap_lines_output_path and validated_candidates:
+        gdf_gap_lines.to_file(config.io.skeleton.gap_lines_output_path, driver='GeoJSON')
+
+    # add the extremities used on each branch to close a gap to the list of gap_point of that branch,
+    # to create a new line toward that extremity and know not to remove it during the "simplify"
+    for candidate in validated_candidates:
+        candidate.branch_1.gap_points.append(Point(candidate.extremity_1))
+        candidate.branch_2.gap_points.append(Point(candidate.extremity_2))
+
+    # get skeletons for all branches
+    for branch in branches_list:
+        branch: Branch
+        branch.create_skeleton()
+        branch.simplify()
+
+    # putting all skeleton lines together, and save them if there is a path
+    branch_lines_list = [branch.gdf_skeleton_lines for branch in branches_list]
+    gdf_branch_lines = gpd.GeoDataFrame(pd.concat(branch_lines_list, ignore_index=True))
+    if config.io.skeleton.skeleton_lines_output_path:
+        gdf_branch_lines.to_file(config.io.skeleton.skeleton_lines_output_path, driver='GeoJSON')
+
+    # saving all lines
+    gdf_global_lines = gpd.GeoDataFrame(pd.concat([gdf_branch_lines, gdf_gap_lines], ignore_index=True))
+    gdf_global_lines = line_merge(gdf_global_lines, crs)  # merge lines into polylines
+    gdf_global_lines.to_file(config.io.skeleton.global_lines_output_path, driver='GeoJSON')
+
+
+if __name__ == "__main__":
+    run()

lidro/main_create_virtual_point.py

@@ -3,13 +3,16 @@
 
 import logging
 import os
+import sys
 
 import geopandas as gpd
 import hydra
 import pandas as pd
 from omegaconf import DictConfig
 from pyproj import CRS
 
+sys.path.append('../lidro')
+
 from lidro.create_virtual_point.vectors.extract_points_around_skeleton import (
     extract_points_around_skeleton_points_one_tile,
 )

lidro/main_merge_mask.py

@@ -3,11 +3,14 @@
 
 import logging
 import os
+import sys
 
 import hydra
 from omegaconf import DictConfig
 from pyproj import CRS
 
+sys.path.append('../lidro')
+
 from lidro.merge_mask_hydro.vectors.merge_vector import merge_geom
 
 

lidro/merge_mask_hydro/vectors/close_holes.py

@@ -26,4 +26,4 @@ def close_holes(polygon: Polygon, min_hole_area)-> Polygon:
         shell=polygon.exterior, holes=interior_holes_filter)
 
 
-    return final_polygon
+    return final_polygon