diff --git a/README.md b/README.md
index fbcb111b..0a62326d 100644
--- a/README.md
+++ b/README.md
@@ -1,6 +1,8 @@
-# LIDRO
+# LIDRO (Aplanissement des surfaces d'eau pour la génération de modèles numériques de terrain à partir de données Lidar)
+
+Lidro est un outil permettant de créer automatiquement des points virtuels le long des surfaces d'eau afin de créer des modèles numériques cohérents avec les modèles hydrologiques.
+Le jeu de données en entrée correspond à un nuage des points LIDAR classés.
-Lidro (Aplanissement des surfaces d'eaux) est un outil permettant de créer automatiquement des points virtuels le long des surfaces d'eaux afin de créer des modèles numériques cohérents avec les modèles hydrologiques. Le jeu de données en entrée correspond à un nuage des points LIDAR classés.
Ce processus a été mis en place après plusieurs mois d'échanges (ateliers) avec le CEREMA et l'Université Gustave Eiffel afin d'améliorer la génération des Modèles Numériques de Terrains issus du projet LIDAR HD. L'IGN s'est inspiré du code développé par Frédéric PONS : https://github.com/CEREMA/filino
## Contexte
@@ -9,15 +11,34 @@ Pour créer des modèles numériques cohérents avec les modèles hydrologiques,
Cette modélisation des surfaces hydrographiques se décline en 3 grands enjeux :
* Mise à plat des surfaces d’eau marine
* Mise à plat des plans d’eau intérieurs (lac, marais, etc.)
-* Mise en plan des grands cours d’eau (>5m large) pour assurer l’écoulement. A noter que pour l'instant seulement cette étape est développée.
+* Mise à plat des grands cours d’eau (>5m large) pour assurer l’écoulement. **A noter : Pour l'instant, seule cette partie est développée dans LIDRO.**
## Traitement
+### Objectif
+L’écoulement de l'eau n’est pas toujours cohérent sur les MNT produits à partir des données LIDAR classées.
-
+Par exemple ci-dessous un AVANT/APRES de la production d'un MNT SANS les points virtuels (MNT classé) / AVEC les points vrituels (MNT optimisé).
+
+
+
+Ci-dessous un autre exemple d'AVANT/APRES de la production d'un MNT SANS les points virtuels / AVEC les points vrituels.
+
+
+
+Ces deux phénomènes (triangulation et la présence de cuvettes artéfacts) peuvent-être du par :
+* l'absence de points "sols" au niveaux des berges
+* la quasi-absence de points sur l'eau
+
+Du point de vue de l’usage métier, l’écoulement étant rendu cohérent le long des cours d’eau, les grosses triangulations et les cuvettes artefacts sont par conséquent supprimées.
+L'objectif de LIDRO est de rendre l’écoulement cohérent (selon des altitudes décroissantes) sur les grands cours d’eaux.
+
+### Les données en ENTREES
-Les données en entrées :
-- dalles LIDAR classées
-- données vectorielles représentant le réseau hydrographique issu des différentes bases de données IGN (BDUnis, BDTopo, etc.) / ! \ requête SQL fait manuellement pour le moment. Exemple de requête SQL sur le bloc PM du LIDAR HD
+Dans LIDRO, vous aurez besoin de deux données en entrées :
+- de dalles LIDAR classées
+- de données vectorielles représentant le réseau hydrographique issu des différentes bases de données IGN (BDUni et/ou BDTopo : tronçons hydrographiques, etc.)
+
+Ci-dessous, un exemple de requête SQL pour réccupérer l'emprise des grands tronçons hydrographiques (> 5m de larges) sur le bloc PM du LIDAR HD.
```
WITH emprise_PM AS (SELECT st_GeomFromText('POLYGON((875379.222972973 6431750.0,
875379.222972973 6484250.0,
@@ -32,48 +53,40 @@ WHERE NOT gcms_detruit
AND classe_de_largeur NOT IN ('Entre 0 et 5 m', 'Sans objet')
AND position_par_rapport_au_sol='0'
```
+### Processus pour les grands cours d'eau (> 5m de large)
+
+
+Le processus mis en place se décompose en quatre parties :
+* 1- Création de masques hydrographiques à l'échelle de la dalle LIDAR.
+
+* 2- Création de masques hydrographiques pré-filtrés à l'échelle du chantier.
-Trois grands axes du processus à mettre en place en distanguant l'échelle de traitement associée :
-* 1- Création de masques hydrographiques à l'échelle de la dalle LIDAR
-* 2- Création de masques hydrographiques pré-filtrés à l'échelle du chantier, soit :
- * la suppression de ces masques dans les zones ZICAD/ZIPVA
+* 3- Création automatiques des tronçons hydrographiques - les "squelettes hydrographiques" des masques hydrographiques - c'est-à-dire les lignes internes indiquant le sens de l'écoulement de l'eau.
+
+* 4- Création de points virtuels correspondant à une grille régulière (paramétrable) à l'intérieur des masques hydrographiques.
+
+Cette étape comprend :
+ * la suppression de ces masques dans les zones ZICAD/ZIPVA : étape manuelle, à réaliser sous QGIS par exemple
+ * la suppression des ces masques en dehors des grands cours d'eau, et leurs nettoyage : étape manuelle, à réaliser sous QGIS par exemple
* la suppression des aires < 150 m² (paramétrable)
- * la suppression des aires < 1000 m² hors BD IGN (grands cours d'eau < 5m de large)
-A noter que pour l'instant, la suppression des masques hydrographiques en dehors des grands cours d'eau et le nettoyage de ces masques s'effectuent manuellement. Ce processus sera développé prochainement en automatique.
-* 3*- Pour les grands cours d'eaux, il existe une étape intermédaire : Création des squelettes internes des masques hydrographiques, c'est-à-dire les lignes internes indiquant le sens de l'écoulement de l'eau pour les grands cours d'eaux.
-* 4- Création de points virtuels le long de deux entités hydrographiques :
- * Grands cours d'eau (> 5 m de large dans la BD Unis).
- * Surfaces planes (mer, lac, étang, etc.) (pas encore développé)
+
+
-### Traitement des grands cours d'eau (> 5 m de large dans la BD Unis).
+### Détails du processus de création des points virtuels pour les grands cours d'eau (>5m de large)
-Il existe plusieurs étapes intermédiaires :
-* 1- création automatique du tronçon hydrographique ("Squelette hydrographique", soit les tronçons hydrographiques dans la BD Unis) à partir de l'emprise du masque hydrographique "écoulement".
-/ ! \ EN AMONT : Appariement, contrôle et correction manuels des masques hydrographiques "écoulement" (rivières) et du squelette hydrographique
-
-A l'échelle de l'entité hydrographique :
-* 2- Récupérer tous les points LIDAR considérés comme du "SOL" situés à la limite de berges (masque hydrographique) moins N mètres
-Pour les cours d'eau supérieurs à 150 m de long :
-* 3- Transformer les coordonnées de ces points (étape précédente) en abscisses curvilignes
-* 4- Générer un modèle de régression linéaire afin de générer tous les N mètres une valeur d'altitude le long du squelette de cette rivière. Les différents Z le long des squelettes HYDRO doivent assurer l'écoulement. Il est important de noter que tous les 50 mètres semble une valeur correcte pour appréhender la donnée. Cette valeur s'explique en raison de la précision altimétrique des données LIDAR (20 cm) ET que les rivières françaises correspondent à des cours d’eau naturels dont la pente est inférieure à 1%.
-/ ! \ Pour les cours d'eau inférieurs à 150 m de long, le modèle de régression linéaire ne fonctionne pas. La valeur du premier quartile sera calculée sur l'ensemble des points d'altitudes du LIDAR "SOL" (étape 2) et affectée pour ces entités hydrographiques (< 150m de long) : aplanissement.
-* 5- Création de points virtuels nécessitant plusieurs étapes intermédiaires :
- * Création des points virtuels 2D espacés selon une grille régulière tous les N mètres (paramétrable) à l'intérieur du masque hydrographique "écoulement"
- * Affecter une valeur d'altitude à ces points virtuels en fonction des "Z" calculés à l'étape précédente (interpolation linéaire ou aplanissement)
-
-### Traitement des surfaces planes (mer, lac, étang, etc.) (EN ATTENTE)
-Pour rappel, l'eau est considérée comme horizontale sur ce type de surface.
-/ ! \ EN ATTENTE / ! \
-Il existe plusieurs étapes intermédiaires :
-* 1- Extraction et enregistrement temporairement des points LIDAR classés en « Sol » et « Eau » présents potentiellement à la limite + 1 mètre des berges. Pour cela, on s'appuie sur l'emprise du masque hydrographique "surface plane" apparaier, contrôler et corriger par la "production" (SV3D) en amont (étape manuelle). a noter que pur le secteur maritime (Mer), il faut exclure la classe « 9 » (eau) afin d’éviter de mesurer les vagues.
-* 2- Analyse statistique de l'ensemble des points LIDAR "Sol / Eau" le long des côtes/berges afin d'obtenir une surface plane.
- L’objectif est de créer des points virtuels spécifiques avec une information d'altitude (m) tous les 0.5 m sur les bords des surfaces maritimes et des plans d’eau à partir du masque hydrographique "surface plane". Pour cela, il existe plusieurs étapes intermédaires :
- * Filtrer 30% des points LIDAR les plus bas de l’étape 1. afin de supprimer les altitudes trop élevées
- * Analyser la répartition en Z de ces points afin d’extraire une seule valeur d’altitude selon l’objet hydrographique :
- * Pour les Plans d’eau : l’altitude correspond à la ligne basse de la boxplot, soit la valeur minimale en excluant les valeurs aberrantes,
- * Pour la Mer : l’altitude correspond à la ligne basse de la boxplot, soit la valeur minimale en excluant les valeurs aberrantes
+A l'échelle de l'entité hydrographique, soit du masque hydrographique, la création des points virtuels consiste à :
+* 1- Récupérer tous les points LIDAR considérés comme du "SOL" situés à la limite de berges (masques hydrographiques) moins N mètres (distance paramétrable).
+
+Pour les cours d'eau SUPERIEURS A 150 M de long, il existe des étapes intermédiaires (étapes A. et B.):
+* A- Transformer les coordonnées de ces points (étape 1.) en abscisses curvilignes
+* B- Générer un modèle de régression linéaire afin de générer tous les N mètres une valeur d'altitude le long du squelette de cette rivière. Les différents Z le long des squelettes HYDRO doivent assurer l'écoulement. Il est important de noter que tous les 50 mètres semble une valeur correcte pour appréhender la donnée. Cette valeur s'explique en raison de la précision altimétrique des données LIDAR (20 cm) ET que les rivières françaises correspondent à des cours d’eau naturels dont la pente est inférieure à 1%.
+
+Pour les cours d'eau INFERIEURS A 150 m de long, le modèle de régression linéaire ne fonctionne pas. La valeur du premier quartile sera calculée sur l'ensemble des points d'altitudes du LIDAR "SOL" (étape 2) et affectée pour ces entités hydrographiques (< 150m de long) : aplanissement.
+
+* 2.1 Création des points virtuels 2D espacés selon une grille régulière tous les N mètres (paramétrable) à l'intérieur du masque hydrographique "écoulement"
+* 2.2 Affecter une valeur d'altitude à ces points virtuels en fonction des "Z" calculés à l'étape précédente (interpolation linéaire ou aplanissement)
## Installation des dépendances (conda)
@@ -112,10 +125,20 @@ git submodule update --init --recursive
```
## Utilisation
-Lidro se lance sur un seul fichier LAS/LAZ ou sur un Dossier
+LIDRO se lance sur un seul fichier LAS/LAZ ou sur un Dossier
Voir les tests fonctionnels en bas du README.
+## L'arborescence du projet
+* ``` configs/```: un dossier contenant un fichier de paramètres ```configs_lidro.yaml```.
+* ``` data/ ```: un dossier lié à un dépot git ```lidar-data``` contenant plusieurs juex de données différents pour tester LIDRO
+* ``` images/ ```: un dossier contenant des images JPG contenues dans le README.md
+* ``` lidro/ ```: un dossier contenant l'ensembles des fonctions développées pour lancer LIDRO
+* ``` scripts/ ```: un dossier contenant plusieurs fichiers ```.sh``` de tests fonctionnels
+* ``` test/ ```: un dossier contenant tous les tests unitaires des différentes fonctions développées dans le dossier ```lidro/```
+* ``` README ```: ce fichier
+* ``` environment.yml ```: le fichier permettant de créer l'environnement conda dans lequel lidro peut être utilisé
+
## Tests
### Tests fonctionnels
@@ -161,6 +184,8 @@ Pour lancer les tests :
python -m pytest -s
```
+
+## Les différentes étapes pour lancer LIDRO en ligne de commande dans un environnement conda dédié
### 1) Création des masques HYDRO des grands cours d'eau à l'échelle de la dalle LIDAR
Pour fonctionner, la création des masques HYDRO 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 modifier en ligne de commande lors de l'exécution du script avec :
@@ -182,7 +207,9 @@ Autres paramètres disponibles :
* Les dalles LIDAR classées.
##### Données de sorties
-* Les masques HYDRO.
+* Des fichiers GeoJSON représentant les masques HYDRO à l'échelle des dalles LIDAR.
+
+
Figure 1 : Masques hydrographiques à l'échelle de la dalle LIDAR
### 2) Fusion des masques HYDRO des grands cours d'eaux
@@ -206,8 +233,12 @@ Autres paramètres disponibles :
* Les masques HYDRO à l'échelle des dalles LIDAR.
##### Données de sorties
-* Le masque HYDRO fusionné à l'échelle du projet.
+* Un fichier GeoJSON représentant le masque HYDRO fusionné à l'échelle du projet, au format ".GeoJSON", soit un masque HYDRO corrigé et nettoyé :
+ * hors des zones de ZICAD/ZIPVA,
+ * en dehors des zones de petits/moyens cours d'eau,
+ * ayant des aires > 150 m² (paramétrable).
+
Figure 2 : Masques hydrographiques fusionnés
### 3) Création des squelettes hydrographiques des grands cours d'eaux
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 :
@@ -243,15 +274,16 @@ Autres paramètres disponibles :
##### Données d'entrées
* Le masque HYDRO fusionné à l'échelle du projet.
-##### Données de sorties
-* Le squelette HYDRO à l'échelle du projet.
+##### Données de sorties Figure 1 : Masques hydrographiques à l'échelle de la dalle LIDAR
+* Un fichier GeoJSON représentant le squelette HYDRO à l'échelle du projet.
+
Figure 3 : Squelettes hydrographiques à l'échelle du chantier
-### 4) étapes 1 & 2. Création des points virtuels (grille régulière tous les N mètres) à l'intérieur des grands cours d'eaux
-Pour fonctionner, la création des points virtuels 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.
+### 4) étape 1. Création des points tous les N mètres le long des squelettes hydrographiques, et récupération les N plus proches voisins points LIDAR "SOL"
+Pour fonctionner, la création des points tous les N mètres le long des squelettes hydrographiques 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 modifier en ligne de commande lors de l'exécution du script avec :
```
-python -m lidro.main_create_virtual_points [nom_paramètre_1]=[valeur_du_paramètre_1] [nom_paramètre_2]=[valeur_du_paramètre_2]
+python -m lidro.main_extract_points_from_skeleton [nom_paramètre_1]=[valeur_du_paramètre_1] [nom_paramètre_2]=[valeur_du_paramètre_2]
```
##### Paramètres
Options généralement passées en paramètres :
@@ -259,13 +291,39 @@ Options généralement passées en paramètres :
* io.input_mask_hydro : Le chemin contenant le masque HYDRO fusionné (ex."./data/merge_mask_hydro/dataset_2/MaskHydro_merge.geosjon").
* io.input_skeleton= Le chemin contenant le squelette hydrographique (ex. "./data/skeleton_hydro/dataset_2/skeleton_hydro.geojson")
* io.dir_points_skeleton : Le chemin contenant l'ensemble des N points du squelette créés à l'échelle des dalles LIDAR ( ex. "./tmp/point_skeleton/").
-* io.output_dir : Le chemin du dossier de sortie (les points virtuels à l'échelle du projet).
+* io.output_dir : Le chemin du dossier de sortie (les points tous les N mètres le long des squelettes hydrographiques).
Autres paramètres disponibles :
* virtual_point.filter.keep_neighbors_classes : Les classes LIDAR (par défaut "sol" et "eau") à conserver pour analyser les bordures de berges le long des grands cours d'eaux.
* virtual_point.vector.distance_meter : La distance en mètres entre deux points consécutifs le long des squelettes hydrographiques.
* virtual_point.vector.buffer : La taille de la zone tampon en mètres pour trouver les points LIDAR.
* virtual_point.vector.k : Le nombre de voisins les plus proches à trouver avec KNN.
+
+##### Données d'entrées
+* Le masque HYDRO fusionné à l'échelle du projet.
+* Le squelette HYDRO à l'échelle du projet.
+* Les dalles LIDAR classées.
+
+##### Données de sorties
+* Un fichier GeoJSON représentant les points tous les N mètres le long des squelettes hydrographiques.
+
+
Figure 4 : Points tous les N mètres le long des squelettes hydrographiques
+
+### 4) étape 2. Création des points virtuels (grille régulière tous les N mètres) à l'intérieur des grands cours d'eaux
+Pour fonctionner, la création des points virtuels 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 modifier en ligne de commande lors de l'exécution du script avec :
+```
+python -m lidro.main_create_virtual_points [nom_paramètre_1]=[valeur_du_paramètre_1] [nom_paramètre_2]=[valeur_du_paramètre_2]
+```
+##### Paramètres
+Options généralement passées en paramètres :
+* io.input_dir : Le chemin du dossier contenant l'ensemble des données d'entrée (ex. "./data/").
+* io.input_mask_hydro : Le chemin contenant le masque HYDRO fusionné (ex."./data/merge_mask_hydro/dataset_2/MaskHydro_merge.geosjon").
+* io.input_skeleton= Le chemin contenant le squelette hydrographique (ex. "./data/skeleton_hydro/dataset_2/skeleton_hydro.geojson")
+* io.dir_points_skeleton : Le chemin contenant l'ensemble des N points du squelette créés à l'échelle des dalles LIDAR ( ex. "./tmp/point_skeleton/").
+* io.output_dir : Le chemin du dossier de sortie (les points virtuels à l'échelle du projet).
+
+Autres paramètres disponibles :
* virtual_point.vector.river_length : La longueur minimale en mètres d'une rivière pour utiliser le modèle de régression linéaire.
* pointcloud.points_grid_spacing : L'espacement entre les points de la grille en mètres.
* pointcloud.virtual_points_classes : Le choix du numéro de classification pour les points virtuels dans les nuages de points LIDAR.
@@ -276,7 +334,7 @@ Autres paramètres disponibles :
* Les dalles LIDAR classées.
##### Données de sorties
-* Les points virtuels (grille règluière tous les N mètre) à l'échelle du projet.
+* Un nuage de point LIDAR au format ".LAZ" représentant les points virtuels (grille règluière tous les N mètre) à l'échelle du projet.
* Un fichier GeoJSON "mask_skeletons_exclusions" indiquant spatialement quels entités HYDRO (masques) présentent un problèmes de géoémtries au niveau de squelettes HYDRO. Conséquence, dans ces entités HYDRO, aucuns points virtuels n'ont pu être calculés. (Options)
* Un fichier GeoJSON "mask_hydro_no_virtual_points" indiquant spatialement quels entités HYDRO (masques) ne détiennent aucuns points "SOL" le long de ces berges. Conséquence, dans ces entités HYDRO, aucuns points virtuels n'ont pu être calculés. (Options)
* Un fichier GeoJSON "mask_hydro_no_virtual_points_with_regression" indiquant spatialement quels entités HYDRO (masques) le modèle de régression linéaire n'a pas pu être calculés. Conséquence, dans ces entités HYDRO, aucuns points virtuels n'ont pu être calculés. (Options)
@@ -300,9 +358,24 @@ Options généralement passées en paramètres :
* Les points virtuels (grille règluière tous les N mètre) à l'échelle du projet
##### Données de sorties
-* Les dalles LIDAR classées avec leurs points virtuels (grille règluière tous les N mètre)
* Un fichier GeoJSON "tiles_from_las" représentant l'emprise des dalles LIDAR du chantier. Pour chaque dalle, on retrouve :
** tile_id : identifiant unique "coordonnée mimimum X" + "_" + "coordonnée maximale Y" de l'emprise de la dalle LIDAR.
** tilename_las : nom de la dalle LIDAR en entrée.
** geometry : l'emprise de la dalle LIDAR (POLYGONE).
+* Les dalles LIDAR classées avec leurs points virtuels (grille règluière tous les N mètres) au format ".LAZ".
+
+
Figure 5 : Points virtuels à l'échelle de la dalle LIDAR
+
+## Correction du bug "zones de cuvettes sous les ponts"
+Dans la branche ```rectify_model_under_bridge``` (https://github.com/IGNF/lidro/tree/rectify_model_under_bridge), un correctif a été développé, mais est moins abouti que le code de la branche `main` (notamment en termes de tests).
+Ce correctif consiste à vérifier que les modèles de régréssion linéaire calculés le long du squelette s'écoulement progressivement le long du cours d'eau, c'est-à-dire éviter les zones de cuvettes sous les ponts.
+
+D'un point de vue logique, cela signifie : "Si Dernier point squelette AMONT < Premier point squelette AVAL alors ALERTE".
+
+
+
+
+Ainsi, après l'étape de génération du modèle de régréssion linéaire et donc avant la génération des points virtuels, une étape intermédiaire a été mis en place pour éviter ces "alertes". Elle consiste à corriger les valeurs Z des N points du squelette jusqu'à le Z du squelette aval est égal au dernier point Z du squelette amont.
+
+
diff --git a/images/alerte_squelette.png b/images/alerte_squelette.png
new file mode 100644
index 00000000..4b820e69
Binary files /dev/null and b/images/alerte_squelette.png differ
diff --git a/images/correction_alerte_squelette.png b/images/correction_alerte_squelette.png
new file mode 100644
index 00000000..5291a4e0
Binary files /dev/null and b/images/correction_alerte_squelette.png differ
diff --git a/images/correction_manuelle_masque_hydro.jpg b/images/correction_manuelle_masque_hydro.jpg
new file mode 100644
index 00000000..c1ebb49c
Binary files /dev/null and b/images/correction_manuelle_masque_hydro.jpg differ
diff --git a/images/cuvettes_artefects.jpg b/images/cuvettes_artefects.jpg
new file mode 100644
index 00000000..b98115c2
Binary files /dev/null and b/images/cuvettes_artefects.jpg differ
diff --git a/images/extraction_n_points_squelette.jpg b/images/extraction_n_points_squelette.jpg
new file mode 100644
index 00000000..071a89e6
Binary files /dev/null and b/images/extraction_n_points_squelette.jpg differ
diff --git a/images/masque_hydro_dalles.jpg b/images/masque_hydro_dalles.jpg
new file mode 100644
index 00000000..67bcf37f
Binary files /dev/null and b/images/masque_hydro_dalles.jpg differ
diff --git a/images/masque_hydro_merge.jpg b/images/masque_hydro_merge.jpg
new file mode 100644
index 00000000..18781bd0
Binary files /dev/null and b/images/masque_hydro_merge.jpg differ
diff --git a/images/mnt_avant_apres.jpg b/images/mnt_avant_apres.jpg
new file mode 100644
index 00000000..015eaa8b
Binary files /dev/null and b/images/mnt_avant_apres.jpg differ
diff --git a/images/points_virtuels.jpg b/images/points_virtuels.jpg
new file mode 100644
index 00000000..d3193cb7
Binary files /dev/null and b/images/points_virtuels.jpg differ
diff --git a/images/squelette_hydro.jpg b/images/squelette_hydro.jpg
new file mode 100644
index 00000000..6130e0a5
Binary files /dev/null and b/images/squelette_hydro.jpg differ
diff --git a/lidro/create_virtual_point/vectors/extract_points_around_skeleton.py b/lidro/create_virtual_point/vectors/extract_points_around_skeleton.py
index 7bd4b11b..d23250bc 100644
--- a/lidro/create_virtual_point/vectors/extract_points_around_skeleton.py
+++ b/lidro/create_virtual_point/vectors/extract_points_around_skeleton.py
@@ -45,9 +45,8 @@ def extract_points_around_skeleton_points_one_tile(
k (int): the number of nearest neighbors to find
"""
# Step 1 : Crop filtered pointcloud by Mask Hydro with buffer
- input_dir_points = os.path.join(input_dir, "pointcloud")
tilename = os.path.splitext(filename)[0] # filename to the LAS file
- input_pointcloud = os.path.join(input_dir_points, filename) # path to the LAS file
+ input_pointcloud = os.path.join(input_dir, filename) # path to the LAS file
logging.info(f"\nCroping filtered pointcloud by Mask Hydro with buffer for tile : {tilename}")
# Croping filtered pointcloud by Mask Hydro with buffer for tile
points_clip = read_filter_and_crop_pointcloud(input_pointcloud, str(input_mask_hydro_buffer), classes)
diff --git a/test/create_virtual_point/vectors/test_extract_points_around_skeleton.py b/test/create_virtual_point/vectors/test_extract_points_around_skeleton.py
index 170ffec8..abd2062d 100644
--- a/test/create_virtual_point/vectors/test_extract_points_around_skeleton.py
+++ b/test/create_virtual_point/vectors/test_extract_points_around_skeleton.py
@@ -11,7 +11,7 @@
)
TMP_PATH = Path("./tmp/create_virtual_point/vectors/extract_points_around_skeleton")
-INPUT_DIR = Path("./data/tile_0830_6291")
+INPUT_DIR = Path("./data/tile_0830_6291/pointcloud")
MASK_HYDRO = "./data/tile_0830_6291/mask_hydro_merge/MaskHydro_merge.geojson"
POINTS_SKELETON = "./data/tile_0830_6291/skeleton/points_along_skeleton.geojson"
OUTPUT_GEOJSON = TMP_PATH / "Semis_2021_0830_6291_LA93_IGN69_points_skeleton.geojson"
diff --git a/test/test_main_extract_points_from_skeleton.py b/test/test_main_extract_points_from_skeleton.py
index 99954331..627db76f 100644
--- a/test/test_main_extract_points_from_skeleton.py
+++ b/test/test_main_extract_points_from_skeleton.py
@@ -18,7 +18,7 @@ def setup_module(module):
def test_main_run_okay():
cmd = f"""python -m lidro.main_extract_points_from_skeleton \
- io.input_dir={INPUT_DIR}\
+ io.input_dir={INPUT_DIR}/pointcloud \
io.input_filename=Semis_2021_0830_6291_LA93_IGN69.laz \
io.input_mask_hydro="{INPUT_DIR}/mask_hydro_merge/MaskHydro_merge.geojson"\
io.input_skeleton="{INPUT_DIR}/skeleton/skeleton_hydro.geojson"\
@@ -28,7 +28,7 @@ def test_main_run_okay():
def test_main_extract_points_skeleton_input_file():
- input_dir = INPUT_DIR
+ input_dir = INPUT_DIR / "pointcloud"
output_dir = OUTPUT_DIR / "main_extract_points_skeleton_input_file"
input_filename = "Semis_2021_0830_6291_LA93_IGN69.laz"
input_mask_hydro = INPUT_DIR / "mask_hydro_merge/MaskHydro_merge.geojson"
@@ -111,7 +111,7 @@ def test_main_extract_points_skeleton_fail_wrong_input_dir():
def test_main_extract_points_skeleton_fail_no_output_dir():
- input_dir = INPUT_DIR
+ input_dir = INPUT_DIR / "pointcloud"
input_mask_hydro = INPUT_DIR / "mask_hydro_merge/MaskHydro_merge.geojson"
input_skeleton = INPUT_DIR / "skeleton/skeleton_hydro.geojson"
distances_meters = 5
@@ -137,7 +137,7 @@ def test_main_extract_points_skeleton_fail_no_output_dir():
def test_main_extract_points_skeleton_fail_no_input_mask_hydro():
- input_dir = INPUT_DIR
+ input_dir = INPUT_DIR / "pointcloud"
output_dir = OUTPUT_DIR / "main_no_input_dir"
input_skeleton = INPUT_DIR / "skeleton/skeleton_hydro.geojson"
distances_meters = 5
@@ -163,7 +163,7 @@ def test_main_extract_points_skeleton_fail_no_input_mask_hydro():
def test_main_extract_points_skeleton_fail_no_input_skeleton():
- input_dir = INPUT_DIR
+ input_dir = INPUT_DIR / "pointcloud"
output_dir = OUTPUT_DIR / "main_no_input_dir"
input_mask_hydro = INPUT_DIR / "mask_hydro_merge/MaskHydro_merge.geojson"
distances_meters = 5