Exercices

1. Paysage et biodiversité

Contexte:

Dans le cadre de l'analyse du paysage on essaie de déterminer le potentiel de biodiversité des paysages. Ce potentiel est lié aux composantes du paysage et à sa mosaïque agricole. L'objectif dans cet exercice est d'extraire des métriques du paysage sur les cellules d'une grille. Les métriques attendues sont:

1. La richesse spécifique \(R_s\) des cultures (le nombre de cultures différentes dans la cellule). $$ R_s = \sum_{n=1}^{N}1 $$ avec \(N\) le nombre de cultures différentes dans la cellule.

2. L'inverse de l'indice de biodiversité simpson \(S\): $$ S = \frac{1}{\sum_{n=1}^{N} p_{i}²} $$

   Avec \(p_i\) la proportion de la culture \(i\) calculée sur l'aire totale des cultures et \(N\) le nombre de cultures différentes dans la cellule.

3. La moyenne de l'aire des parcelles agricoles \(\overline{A_p}\)

   \[ \overline{A_p} = \frac{\sum_{i=1}^{N}A_i}{N} \]

   Avec \(A_i\) l'aire de la parcelle \(i\) et \(N\) le nombre de parcelles dans la cellule \(C\).

4. La surface de milieux semi-naturel: $$ 1 - \frac{A_{artificiel} + A_{parcelles}}{A_{total}} $$

   avec \(A_{artificiel}\) la surface totale des structures artificielles et \(A_{parcelles}\) la surface de culture, toute culture totale.

Pour toutes ces métriques les aires concernées sont sont celles qui superposent exactement la cellule. Il faut donc couper les géométries au niveau de la cellule.

Énoncé:

Écrivez un algorithme processing qui prend en entrée:

• Une couche de parcelles agricoles.
• Un champ de la couche de parcelles agricoles qui contient le type de culture.
• Une couche de structures artificielles.
• Une taille de cellule pour la grille avec comme valeur minimale \(500m\) et maximale \(2km\).

Et qui retourne en sortie, au format de couche vectorielle, une grille où chaque entité est une cellule de la grille et contient les 4 métriques nécessaire au calcul du potentiel de biodiversité.

Écrivez des fonctions que vous pourrez utiliser dans la méthode processAlgorithm() afin d'améliorer la lisibilité du code. Ces fonctions peuvent être écrites en haut du script ou bien en tant que méthode de classe selon votre choix.

Données:

• Les données des parcelles sont accessibles dans la couche « RPG » (fichier RPG.gpkg). Le champ "CODE_CULTU" donne le type de culture.

• Les structures artificielles sont données dans la couche « Artificial » (fichier ARTIFICIELLES.gpkg).

Aide

1. Écrivez une fonction pour faire la requête spatiale d'entités qui intersectent un rectangle (QgsRectangle) et qui coupe les géométries pour conserver que la surface qui superpose le rectangle. La fonction a la signature suivante:

   def spatial_query_clip(layer: QgsVectorLayer, extent: QgsRectangle) -> list[QgsFeature]:
       ...
   

2. Écrivez une fonction pour calculer chacune des métriques à partir de liste de QgsFeature avec les signatures suivantes:

   def richness(features: list[QgsFeature], field: str) -> int:
       ...
   
   def simpson_diversity(features: list[QgsFeature], field: str) -> float:
       ...
   
   def mean_field_size(features: list[QgsFeature]) -> float:
       ...
   
   def semi_natural_cover(
       crop_features: list[QgsFeature],
       artificial_features: list[QgsFeature],
       cell_area: float,
       ) -> float:
       ...
   

3. Créez vos paramètres d'algorithmes processing dans initAlgorithm() pour:

   • Récupérer la couche de cultures.
   • Récupérer la couche de structures artificielles.
   • Récupérer le champ de la couche artificielle qui contient le code de culture ("CODE_CULTU").
   • Récupérer la taille des cellules de la grille.

4. Écrivez la fonction processAlgorithm() de votre algorithme.

   1. Récupérer vos paramètres définis dans initAlgorithm().
   2. Construisez le sink pour la couche de sortie avec les champs pour chaque métrique.
   3. Construisez la grille avec un algorithme processing.
   4. Itérer sur chaque entité/cellule de la grille, faites les requêtes spatiales nécessaire et calculez les métriques avec vos fonctions. Ajoutez la feature à votre couche de sortie.
5. Ajoutez une barre de progression.

2. Estimation de la largeur des haies

Contexte:

La caractérisation des haies bocagères est utile dans de nombreux champs de recherches à l'échelle du paysage tels que l'écologie ou l'étude des effets micro-climatiques en agriculture.

Dans cet exercice on essaie d'estimer la largeur des haies à partir de leur polygones et de leur axe médian.

NB: L'axe médian et une géométrie de type ligne qui représente le squelette de la haie. Il est sensé être à égale distance des segments de chaque côté du polygone.

Plusieurs méthodes sont possibles pour faire cette estimation de manière plus ou moins précises, vous en trouverez deux ci-dessous:

Méthode 1: Estimation approximative

1. Créer des points à distances égales le long de l'axe médian de la haie.
2. Pour chaque point calculer la distance entre le point et le segment du polygone de la haie le plus proche.
3. Calculer la moyenne de la distance multiplié par 2 pour tout les points.

Cette méthode est simple à implémenter mais est sensible aux aspérités du polygone. Le segment le plus proche du point pourrait ne pas respecter la perpendicularité à l'axe médian.

Méthode 2: Estimation avancée

Pour éviter les problèmes mentionnés dans al méthode 2 on peut utiliser des transect perpendiculaire à l'axe médian.

1. Créer des points à distances égales le long de l'axe médian de la haie.
2. Grouper ces points dans une nouvelle géométrie de type ligne.
3. Construire les transect perpendiculaire à la ligne.
4. Couper les transects avec le polygone.
5. Calculer la moyenne de la longueur des transects multiplié par 2 pour tout les points.

Énoncé:

Écrivez un algorithme processing pour estimer la largeur des haies selon chacune des méthodes. L'algorithme doit retourner la couche de polygone de haies avec un nouveau champ "Width". Donnez la possibilité à l'utilisateur de définir une distance entre les points d'estimation de la largeur. Plus la distance sera faible plus l'estimation sera précise mais le temps de calcul sera plus long.

Écrivez la logique algorithmique dans des fonctions qui seront utilisées dans la méthode processAlgorithm.

Une fois les deux algorithmes faits, regroupez-les dans un unique algorithme en ajoutant un paramètre permettant à l'utilisateur de choisir une méthode ou l'autre.

Données:

Pour cet exercice vous pouvez utiliser le geopackage « HAIES » (fichier HAIES.gpkg) composé des couches « polygons » et « arcs ». Ces couches possèdent des champs permettant de faire le lien entre une haie et son axe médian:

• "eid": L'identifiant d'un axe médian.
• "pid": L'identifiant d'un polygone.

Servez-vous de ces identifiants pour associer un polygone et son axe médian.

Tip

Les algorithmes processing suivants vous seront utiles:

• « Point le long d'une géométrie » ("native:pointsalonglines").
• « Points vers lignes » ("native:pointstopath").
• « Transect » ("native:transect").

Les méthodes suivantes de la classe QgsGeometry vous seront utiles:

• closestSegmentWithContext()
• asPoints()

NB: Les méthodes de comparaison de géométries ou de modifications de géométries éventuellement nécessaires seront à trouver dans la documentation et dans les TDs précédents.

Aide

1. Utilisez l'algorithme « Point le long d'une géométrie » pour créer les points à distances égale sur les axes médian.

2. Utilisez l'algorithme « Points vers lignes » pour construire les lignes qui connectent les points issus de l'étape précédente.

Méthode 1:

1. Écrivez une fonction permettant de récupérer la ligne de la couche de lignes issue de l'étape précédente qui correspond à la haie de l'entité polygone de la couche « polygons ».

   def get_line(polygon: QgsFeature, arc_layer: QgsVectorLayer) -> QgsFeature:
       ...
   

2. Écrivez une fonction permettant de calculer la moyenne de la largeur du polygone en calculant la distance au polygone à chaque point.

   def approximative_width(polygon: QgsFeature, line: QgsFeature) -> float:
       ...
   

3. Itérer sur les polygones de « polygons », récupérez la ligne et calculez la largeur pour chaque polygone. Ajoutez l'entité avec le champ largeur à la couche de polygones de sortie.

Méthode 2:

1. Utilisez l'algorithme « Transect » pour créer les points à distances égale sur les axes médian.

2. Écrivez une fonction permettant de récupérer les transects de la couche de transects issue de l'étape précédente qui correspondent à la haie de l'entité polygone de la couche « polygons ».

   def get_transects(polygon: QgsFeature, arc_layer: QgsVectorLayer) -> QgsFeature:
       ...
   

3. Écrivez une fonction permettant de calculer la moyenne de la largeur du polygone depuis les transects.

   def accurate_width(polygon: QgsFeature, line: QgsFeature) -> float:
       ...
   

4. Itérer sur les polygones de « polygons », calculez les transects et calculez la largeur pour chaque polygone. Ajoutez l'entité avec le champ largeur à la couche de polygones de sortie.

NB: Les fonctions get_line() et get_transects() sont équivalentes, vous pouvez les grouper dans une fonction générique.