Skeleton

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:
 
@@ -114,22 +114,23 @@ Pour fonctionner, la création de squelettes a besoin d'une série de paramètre
 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 :  
-SKELETON.FILE_PATH.MASK_INPUT_PATH : Le chemin d'entrée des masques des cours d'eau
-SKELETON.FILE_PATH.SKELETON_LINES_OUTPUT_PATH : Le chemin de sortie des squelettes uniquement (pas de fichier de sortie si laissé à vide)
-SKELETON.FILE_PATH.GAP_LINES_OUTPUT_PATH : Le chemin de sortie des lignes franchissant des ponts uniquement (pas de fichier de sortie si laissé à vide)
-SKELETON.FILE_PATH.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_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
+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
+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,31 +53,26 @@ virtual_point:
     # The number of nearest neighbors to find with KNeighbors
     k: 20
 
-SKELETON:
-  FILE_PATH:
-    MASK_INPUT_PATH:
-    SKELETON_LINES_OUTPUT_PATH:  # only branches' skeleton (if empty, no file is created)
-    GAP_LINES_OUTPUT_PATH:  # only new lines to close gaps (if empty, no file is created)
-    GLOBAL_LINES_OUTPUT_PATH:  # lines from both the skeletons and the gap lines
-
-  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.
+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_NAME: bduni_france_consultation
-    DB_HOST: bduni_consult.ign.fr
-    DB_USER:
-    DB_PASSWORD:
-    DB_PORT: 5432
+  db_uni:
+    db_using_db: True # if false, the DB won't be queried
+    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
+  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

lidro/create_mask_hydro/rasters/create_mask_raster.py

@@ -35,20 +35,21 @@ def create_occupancy_map(points: np.array, tile_size: int, pixel_size: float, or
 
 def detect_hydro_by_tile(filename: str, tile_size: int, pixel_size: float, classes: List[int], dilation_size: int):
     """ "Detect hydrographic surfaces in a tile from the classified points of the input pointcloud
-    An hydrographic surface is define as a surface where there is no points from any class different from water
-The output hydrographic surface mask is dilated to make sure that the masks are continuous when merged with their neighbours
-    Args:
-        filename (str): input pointcloud
-        tile_size (int): size of the raster grid (in meters)
-        pixel_size (float): distance between each node of the raster grid (in meters)
-        classes (List[int]): List of classes to use for the binarisation (points with other
-                    classification values are ignored)
-        dilation_size (int): size for dilatation raster
+        An hydrographic surface is defined as a surface where there is no points from any class different from water
+    The output hydrographic surface mask is dilated to make sure that the masks are continuous when merged with their
+    neighbours
+        Args:
+            filename (str): input pointcloud
+            tile_size (int): size of the raster grid (in meters)
+            pixel_size (float): distance between each node of the raster grid (in meters)
+            classes (List[int]): List of classes to use for the binarisation (points with other
+                        classification values are ignored)
+            dilation_size (int): size of the structuring element for dilation
 
-    Returns:
-        smoothed_water (np.array):  2D binary array (x, y) of the water presence from the point cloud
-        pcd_origin (list): top left corner of the tile containing the point cloud
-        (infered from pointcloud bounding box and input tile size)
+        Returns:
+            smoothed_water (np.array):  2D binary array (x, y) of the water presence from the point cloud
+            pcd_origin (list): top left corner of the tile containing the point cloud
+            (infered from pointcloud bounding box and input tile size)
     """
     # Read pointcloud, and extract coordinates (X, Y, Z, and classification) of all points
     array, crs = read_pointcloud(filename)
@@ -68,6 +69,8 @@ def detect_hydro_by_tile(filename: str, tile_size: int, pixel_size: float, class
     # Apply a mathematical morphology operations: DILATION
     # / ! \ NOT "CLOSING", due to the reduction in the size of hydro masks (tile borders)
     # / ! \ WITH "CLOSING" => Masks Hydro are no longer continuous, when they are merged
-    water_mask = scipy.ndimage.binary_dilation(detected_water, structure=np.ones((dilation_size, dilation_size))).astype(np.uint8)
+    water_mask = scipy.ndimage.binary_dilation(
+        detected_water, structure=np.ones((dilation_size, dilation_size))
+    ).astype(np.uint8)
 
-    return water_mask, pcd_origin
+    return water_mask, pcd_origin

lidro/create_mask_hydro/vectors/convert_to_vector.py

@@ -10,7 +10,9 @@
 from lidro.create_mask_hydro.rasters.create_mask_raster import detect_hydro_by_tile
 
 
-def create_hydro_vector_mask(filename: str, output: str, pixel_size: float, tile_size: int, classes: list, crs: str, dilatation_size: int):
+def create_hydro_vector_mask(
+    filename: str, output: str, pixel_size: float, tile_size: int, classes: list, crs: str, dilatation_size: int
+):
     """Create a vector mask of hydro surfaces in a tile from the points classification of the input LAS/LAZ file,
     and save it as a GeoJSON file.
 

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
 
 
@@ -58,7 +61,7 @@ def main_on_one_tile(filename):
         input_file = os.path.join(input_dir, filename)  # path to the LAS file
         output_file = os.path.join(output_dir, f"MaskHydro_{tilename}.GeoJSON")  # path to the Mask Hydro file
         logging.info(f"\nCreate Mask Hydro 1 for tile : {tilename}")
-        create_hydro_vector_mask(input_file, output_file, pixel_size, tile_size, classe, crs, dilatation_size)
+        create_hydro_vector_mask(input_file, output_file, pixel_size, tile_size, classe, crs, dilation_size)
 
     if initial_las_filename:
         # Lauch creating mask by one tile:
@@ -69,5 +72,6 @@ def main_on_one_tile(filename):
         for file in os.listdir(input_dir):
             main_on_one_tile(file)
 
+
 if __name__ == "__main__":
     main()

lidro/main_create_skeleton_lines.py

@@ -27,7 +27,7 @@ def run(config: DictConfig):
         - config (DictConfig): the config dict from hydra
     """
 
-    gdf_hydro_global_mask = gpd.read_file(config.SKELETON.FILE_PATH.MASK_INPUT_PATH)
+    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)
@@ -37,8 +37,8 @@ def run(config: DictConfig):
     # 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.SKELETON.FILE_PATH.GAP_LINES_OUTPUT_PATH and validated_candidates:
-        gdf_gap_lines.to_file(config.SKELETON.FILE_PATH.GAP_LINES_OUTPUT_PATH, driver='GeoJSON')
+    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"
@@ -55,13 +55,13 @@ def run(config: DictConfig):
     # 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.SKELETON.FILE_PATH.GAP_LINES_OUTPUT_PATH:
-        gdf_branch_lines.to_file(config.SKELETON.FILE_PATH.SKELETON_LINES_OUTPUT_PATH, driver='GeoJSON')
+    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.SKELETON.FILE_PATH.GLOBAL_LINES_OUTPUT_PATH, driver='GeoJSON')
+    gdf_global_lines.to_file(config.io.skeleton.global_lines_output_path, driver='GeoJSON')
 
 
 if __name__ == "__main__":

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

@@ -4,7 +4,7 @@
 from shapely.ops import unary_union
 
 
-def close_holes(polygon: Polygon, min_hole_area):
+def close_holes(polygon: Polygon, min_hole_area)-> Polygon:
     """Remove small holes (surface < 100 m²)
 
     Args:
@@ -26,4 +26,4 @@ def close_holes(polygon: Polygon, min_hole_area):
         shell=polygon.exterior, holes=interior_holes_filter)
 
 
-    return final_polygon
+    return final_polygon