Merge pull request #8 from IGNF/fix-integration

Misc Clean up

Author: leavauchier

.pre-commit-config.yaml

@@ -0,0 +1,20 @@
+# See https://dev.to/m1yag1/how-to-setup-your-project-with-pre-commit-black-and-flake8-183k
+# for pre-commits setup
+# See https://pre-commit.com for more information
+# See https://pre-commit.com/hooks.html for more hooks
+repos:
+  - repo: https://github.com/pycqa/isort
+    rev: 6.0.1
+    hooks:
+      - id: isort
+        args: ["--profile=black"] 
+        name: isort (python)
+  - repo: https://github.com/ambv/black
+    rev: 25.1.0
+    hooks:
+      - id: black
+        language_version: python3.10
+  - repo: https://github.com/pre-commit/pre-commit-hooks
+    rev: v2.0.0
+    hooks:
+      - id: flake8

CHANGELOG.md

@@ -1,4 +1,9 @@
 # CHANGELOG
+- lint
+- ajout de pre-commit hooks pour appliquer le lint au moment des commits
+- patchwork crée lui-même les sous-dossiers dont chaque étape a besoin
+- correctif pour la recherche de correspondance des las dans le csv de matching
+
 ## 1.1.0
 - modification de chemin pour pouvoir passer dans la gpao
 - coupure des chemins de fichiers en chemins de répertoires/nom de fichiers pour pouvoir les utiliser sur docker + store

README.md

@@ -2,13 +2,13 @@
 Patchwork est un outil permettant d'enrichir un fichier lidar à haute densité avec des points d'un fichier à basse densité dans les secteurs où le premier fichier n'a pas de point mais où le second en possède.
 
 ## Fonctionnement
-Les données en entrée sont:  
-- un fichier lidar que l'ont souhaite enrichir  
-- un fichier lidar contenant des points supplémentaires  
-  
-En sortie il y a :  
-- Un fichier, copie du premier en entrée, enrichi des points voulu  
-  
+Les données en entrée sont:
+- un fichier lidar que l'ont souhaite enrichir
+- un fichier lidar contenant des points supplémentaires
+
+En sortie il y a :
+- Un fichier, copie du premier en entrée, enrichi des points voulus
+
 Les deux fichiers d'entrée sont découpés en tuiles carrées, généralement d'1m². Si une tuile du fichier à enrichir ne contient aucun point ayant le classement qui nous intéresse, on prend les points de la tuile de même emplacement du fichier de points supplémentaire.
 
 L'appartenance à une tuile est décidée par un arrondi par défaut, c'est-à-dire que tous les éléments de [n, n+1[ (ouvert en n+1) font parti de la même tuile.
@@ -30,31 +30,31 @@ Le script d'ajout de points peut être lancé via :
 ```
 python main.py filepath.DONOR_FILE=[chemin fichier donneur] filepath.RECIPIENT_FILE=[chemin fichier receveur] filepath.OUTPUT_FILE=[chemin fichier de sortie] [autres options]
 ```
-Les différentes options, modifiables soit dans le fichierconfigs/configs_patchwork.yaml, soit en ligne de commande comme indiqué juste au-dessus :  
-    
-filepath.DONOR_DIRECTORY : Le répertoire du fichier qui peut donner des points à ajouter  
-filepath.DONOR_NAME : Le nom du fichier qui peut donner des points à ajouter  
-filepath.RECIPIENT_DIRECTORY : Le répertoire du fichier qui va obtenir des points en plus  
-filepath.RECIPIENT_NAME : Le nom du fichier qui va obtenir des points en plus  
-filepath.OUTPUT_DIR : Le répertoire du fichier en sortie  
-filepath.OUTPUT_NAME : Le nom du fichier en sortie  
-filepath.OUTPUT_INDICES_MAP_DIR : Le répertoire de sortie du fichier d'indice  
-filepath.OUTPUT_INDICES_MAP_NAME : Le nom de sortie du fichier d'indice  
-
-DONOR_CLASS_LIST : Défaut [2, 9]. La liste des classes des points du fichier donneur qui peuvent être ajoutés.  
+Les différentes options, modifiables soit dans le fichier `configs/configs_patchwork.yaml`, soit en ligne de commande comme indiqué juste au-dessus :
+
+filepath.DONOR_DIRECTORY : Le répertoire du fichier qui peut donner des points à ajouter
+filepath.DONOR_NAME : Le nom du fichier qui peut donner des points à ajouter
+filepath.RECIPIENT_DIRECTORY : Le répertoire du fichier qui va obtenir des points en plus
+filepath.RECIPIENT_NAME : Le nom du fichier qui va obtenir des points en plus
+filepath.OUTPUT_DIR : Le répertoire du fichier en sortie
+filepath.OUTPUT_NAME : Le nom du fichier en sortie
+filepath.OUTPUT_INDICES_MAP_DIR : Le répertoire de sortie du fichier d'indice
+filepath.OUTPUT_INDICES_MAP_NAME : Le nom de sortie du fichier d'indice
+
+DONOR_CLASS_LIST : Défaut [2, 22]. La liste des classes des points du fichier donneur qui peuvent être ajoutés.
 RECIPIENT_CLASS_LIST : Défaut [2, 3, 9, 17]. La liste des classes des points du fichier receveur qui, s'ils sont absents dans une cellule, justifirons de prendre les points du fichier donneur de la même cellule
 TILE_SIZE : Défaut 1000. Taille du côté de l'emprise carrée représentée par les fichiers lidar d'entrée
-PATCH_SIZE : Défaut 1. taille en mètre du côté d'une cellule (doit être un diviseur de TILE_SIZE, soit pour 1000 : 0.25, 0.5, 2, 4, 5, 10, 25...)  
+PATCH_SIZE : Défaut 1. taille en mètre du côté d'une cellule (doit être un diviseur de TILE_SIZE, soit pour 1000 : 0.25, 0.5, 2, 4, 5, 10, 25...)
 
 Le script de sélection/découpe de fichier lidar peut être lancé via :
 ```
-python lidar_filepath.py filepath.DONOR_DIRECTORY=[répertoire_fichiers_donneurs] filepath.RECIPIENT_DIRECTORY=[répertoire_fichiers_receveurs] filepath.SHP_NAME=[nom_shapefile] filepath.SHP_DIRECTORY=[répertoire_shapefile] filepath.CSV_NAME=[nom_fichier_csv] filepath.CSV_DIRECTORY=[répertoire_fichier_csv] filepath.OUTPUT_DIRECTORY=[chemin_de_sortie]
+python lidar_selecter.py filepath.DONOR_DIRECTORY=[répertoire_fichiers_donneurs] filepath.RECIPIENT_DIRECTORY=[répertoire_fichiers_receveurs] filepath.SHP_NAME=[nom_shapefile] filepath.SHP_DIRECTORY=[répertoire_shapefile] filepath.CSV_NAME=[nom_fichier_csv] filepath.CSV_DIRECTORY=[répertoire_fichier_csv] filepath.OUTPUT_DIRECTORY=[chemin_de_sortie]
 ```
 
-filepath.DONOR_DIRECTORY: Le répertoire contenant les fichiers lidar donneurs  
-filepath.RECIPIENT_DIRECTORY: Le répertoire contenant les fichiers lidar receveurs  
-filepath.SHP_NAME: Le nom du shapefile contenant l'emprise du chantier qui délimite les fichiers lidar qui nous intéressent  
-filepath.SHP_DIRECTORY: Le répertoire du fichier shapefile  
-filepath.CSV_NAME: Le nom du fichier csv qui lie les différents fichiers donneurs et receveurs  
-filepath.CSV_DIRECTORY: Le répertoire du fichier csv 
-filepath.OUTPUT_DIRECTORY: le répertoire recevant les fichiers lidar découpés  
+filepath.DONOR_DIRECTORY: Le répertoire contenant les fichiers lidar donneurs
+filepath.RECIPIENT_DIRECTORY: Le répertoire contenant les fichiers lidar receveurs
+filepath.SHP_NAME: Le nom du shapefile contenant l'emprise du chantier qui délimite les fichiers lidar qui nous intéressent
+filepath.SHP_DIRECTORY: Le répertoire du fichier shapefile
+filepath.CSV_NAME: Le nom du fichier csv qui lie les différents fichiers donneurs et receveurs
+filepath.CSV_DIRECTORY: Le répertoire du fichier csv
+filepath.OUTPUT_DIRECTORY: le répertoire recevant les fichiers lidar découpés

constants.py

@@ -9,11 +9,13 @@ dependencies:
   - numpy
   - geopandas==0.*
   - shapely>=2.0.3
+  - rasterio
   # ------------- logging ------------- #
   - loguru
     # --------- hydra configs --------- #
   - hydra-core
   - hydra-colorlog
   # ----------- linting --------------- #
-  - flake8
-  - rasterio
+  - pre-commit
+  - black
+  - flake8

environment.yml

@@ -3,7 +3,7 @@
 import hydra
 from omegaconf import DictConfig
 
-from patchwork import patchwork
+from patchwork.patchwork import patchwork
 
 
 @hydra.main(config_path="configs/", config_name="configs_patchwork.yaml", version_base="1.2")

main.py

@@ -0,0 +1,10 @@
+# INTERNAL CONSTANTS, NOT TO BE CHANGED
+CLASSIFICATION_STR = "classification"
+PATCH_X_STR = "patch_x"
+PATCH_Y_STR = "patch_y"
+DONOR_SUBDIRECTORY_NAME = "donor"
+RECIPIENT_SUBDIRECTORY_NAME = "recipient"
+
+COORDINATES_KEY = "coordinates"
+DONOR_FILE_KEY = "donor_file"
+RECIPIENT_FILE_KEY = "recipient_file"

patchwork/constants.py

@@ -1,18 +1,18 @@
-import os 
+import os
 
 import numpy as np
-from omegaconf import DictConfig
-import rasterio as rs
-from rasterio.transform import from_origin
 import pandas as pd
+import rasterio as rs
+from omegaconf import DictConfig
 from pandas import DataFrame
+from rasterio.transform import from_origin
 
-from tools import get_tile_origin_from_pointcloud
-from constants import PATCH_X_STR, PATCH_Y_STR
+from patchwork.constants import PATCH_X_STR, PATCH_Y_STR
+from patchwork.tools import get_tile_origin_from_pointcloud
 
 
 def create_indices_grid(config: DictConfig, df_points: DataFrame) -> np.ndarray:
-    """ create a binary grid matching the tile the points of df_points are from, where each patch is equal to:
+    """create a binary grid matching the tile the points of df_points are from, where each patch is equal to:
     1 if the patch has at least one point of df_points
     0 if the patch has no point from df_points
     """
@@ -40,14 +40,23 @@ def create_indices_map(config: DictConfig, df_points: DataFrame):
     corner_x, corner_y = get_tile_origin_from_pointcloud(config, df_points)
 
     grid = create_indices_grid(config, df_points)
-    output_indices_map_path = os.path.join(config.filepath.OUTPUT_INDICES_MAP_DIR, config.filepath.OUTPUT_INDICES_MAP_NAME)
+    os.makedirs(config.filepath.OUTPUT_INDICES_MAP_DIR, exist_ok=True)
+    output_indices_map_path = os.path.join(
+        config.filepath.OUTPUT_INDICES_MAP_DIR, config.filepath.OUTPUT_INDICES_MAP_NAME
+    )
 
     transform = from_origin(corner_x, corner_y, config.PATCH_SIZE, config.PATCH_SIZE)
-    indices_map = rs.open(output_indices_map_path, 'w', driver='GTiff',
-                          height=grid.shape[0], width=grid.shape[1],
-                          count=1, dtype=str(grid.dtype),
-                          crs=config.CRS,
-                          transform=transform)
+    indices_map = rs.open(
+        output_indices_map_path,
+        "w",
+        driver="GTiff",
+        height=grid.shape[0],
+        width=grid.shape[1],
+        count=1,
+        dtype=str(grid.dtype),
+        crs=config.CRS,
+        transform=transform,
+    )
     indices_map.write(grid, 1)
     indices_map.close()
 

indices_map.py patchwork/indices_map.pyindices_map.py renamed to patchwork/indices_map.py

@@ -2,59 +2,62 @@
 import pathlib
 import timeit
 
-import hydra
-from omegaconf import DictConfig
 import geopandas as gpd
+import hydra
 import laspy
-from laspy import ScaleAwarePointRecord
-from shapely import box
 import numpy as np
+from laspy import ScaleAwarePointRecord
+from loguru import logger
+from omegaconf import DictConfig
 from pandas import DataFrame
+from shapely import box
 from shapely.geometry import MultiPolygon
 from shapely.vectorized import contains
-from loguru import logger
 
-import constants as c
-from tools import identify_bounds, get_tile_origin_from_pointcloud, crop_tile
+import patchwork.constants as c
+from patchwork.tools import crop_tile, get_tile_origin_from_pointcloud, identify_bounds
 
 
-@hydra.main(config_path="configs/", config_name="configs_patchwork.yaml", version_base="1.2")
+@hydra.main(config_path="../configs/", config_name="configs_patchwork.yaml", version_base="1.2")
 def patchwork_dispatcher(config: DictConfig):
-    data = {c.COORDINATES_KEY: [],
-            c.DONOR_FILE_KEY: [],
-            c.RECIPIENT_FILE_KEY: []
-            }
+    data = {c.COORDINATES_KEY: [], c.DONOR_FILE_KEY: [], c.RECIPIENT_FILE_KEY: []}
     df_result = DataFrame(data=data)
     # preparing donor files:
-    select_lidar(config,
-                 config.filepath.DONOR_DIRECTORY,
-                 config.filepath.OUTPUT_DIRECTORY,
-                 c.DONOR_SUBDIRECTORY_NAME,
-                 df_result,
-                 c.DONOR_FILE_KEY,
-                 True
-                 )
+    select_lidar(
+        config,
+        config.filepath.DONOR_DIRECTORY,
+        config.filepath.OUTPUT_DIRECTORY,
+        c.DONOR_SUBDIRECTORY_NAME,
+        df_result,
+        c.DONOR_FILE_KEY,
+        True,
+    )
     # preparing recipient files:
-    select_lidar(config,
-                 config.filepath.RECIPIENT_DIRECTORY,
-                 config.filepath.OUTPUT_DIRECTORY,
-                 c.RECIPIENT_SUBDIRECTORY_NAME,
-                 df_result,
-                 c.RECIPIENT_FILE_KEY,
-                 False,
-                 )
-    df_result.to_csv(os.path.join(config.filepath.CSV_DIRECTORY, config.filepath.CSV_NAME), index=False) 
+    select_lidar(
+        config,
+        config.filepath.RECIPIENT_DIRECTORY,
+        config.filepath.OUTPUT_DIRECTORY,
+        c.RECIPIENT_SUBDIRECTORY_NAME,
+        df_result,
+        c.RECIPIENT_FILE_KEY,
+        False,
+    )
+
+    pathlib.Path(config.filepath.CSV_DIRECTORY).mkdir(exist_ok=True)
+    df_result.to_csv(
+        os.path.join(config.filepath.CSV_DIRECTORY, config.filepath.CSV_NAME), index=False, encoding="utf-8"
+    )
 
 
 def cut_lidar(las_points: ScaleAwarePointRecord, shapefile_geometry: MultiPolygon) -> ScaleAwarePointRecord:
-    shapefile_contains_mask = contains(shapefile_geometry, np.array(las_points['x']), np.array(las_points['y']))
+    shapefile_contains_mask = contains(shapefile_geometry, np.array(las_points["x"]), np.array(las_points["y"]))
     return las_points[shapefile_contains_mask]
 
 
 def update_df_result(df_result: DataFrame, df_key: str, corner_string: str, file_path: str):
     # corner_string not yet in df_result
-    if not corner_string in list(df_result[c.COORDINATES_KEY]):
-        new_row = {c.COORDINATES_KEY:corner_string, c.DONOR_FILE_KEY: "", c.RECIPIENT_FILE_KEY:""}
+    if corner_string not in list(df_result[c.COORDINATES_KEY]):
+        new_row = {c.COORDINATES_KEY: corner_string, c.DONOR_FILE_KEY: "", c.RECIPIENT_FILE_KEY: ""}
         new_row[df_key] = file_path
         df_result.loc[len(df_result)] = new_row
         return df_result
@@ -64,13 +67,15 @@ def update_df_result(df_result: DataFrame, df_key: str, corner_string: str, file
     return df_result
 
 
-def select_lidar(config: DictConfig,
-                 input_directory:str,
-                 output_directory:str,
-                 subdirectory_name: str,
-                 df_result:DataFrame,
-                 df_key: str,
-                 to_be_cut: bool):
+def select_lidar(
+    config: DictConfig,
+    input_directory: str,
+    output_directory: str,
+    subdirectory_name: str,
+    df_result: DataFrame,
+    df_key: str,
+    to_be_cut: bool,
+):
     """
     Walk the input directory searching for las files, and pick the ones that intersect with the shapefile.
     When a las file is half inside the shapfile, it is cut if "to_be_cut" is true, otherwise it kept whole
@@ -83,6 +88,13 @@ def select_lidar(config: DictConfig,
 
     time_old = timeit.default_timer()
     time_start = time_old
+
+    directory_path = os.path.join(output_directory, subdirectory_name)
+    # Create output dir only if asked to cut
+    # Otherwise  the input file is intended to be used directly (no copy to the output directory)
+    if to_be_cut:
+        pathlib.Path(directory_path).mkdir(parents=True, exist_ok=True)
+
     for root, _, file_names in os.walk(input_directory):
 
         for file_name in file_names:
@@ -95,7 +107,6 @@ def select_lidar(config: DictConfig,
                 raw_las_points = las_file.read().points
                 min_x, max_x, min_y, max_y = identify_bounds(config.TILE_SIZE, raw_las_points)
                 intersect_area = shapefile_geometry.intersection(box(min_x, min_y, max_x, max_y)).area
-
                 # if intersect area == 0, this tile is fully outside the shapefile
                 if intersect_area == 0:
 
@@ -105,9 +116,6 @@ def select_lidar(config: DictConfig,
                     time_old = time_new
                     continue
 
-                directory_path = os.path.join(output_directory, subdirectory_name)
-                pathlib.Path(directory_path).mkdir(parents=True, exist_ok=True)
-
                 las_points = crop_tile(config, raw_las_points)
                 x_corner, y_corner = get_tile_origin_from_pointcloud(config, las_points)