Simplifier des lignes (Cartographie)

Résumé

Simplifie les lignes en supprimant les sommets relativement extérieurs tout en conservant leur forme globale.

Illustration

Comparaison des quatre algorithmes de simplification utilisés par l’outil Simplifier des lignes

Utilisation

  • Cet outil utilise des algorithmes de simplification répondant à des objectifs différents. Pour en savoir plus sur ces algorithmes, reportez-vous à Fonctionnement des outils Simplifier des lignes et Simplifier un polygone.

    • L’algorithme Retain critical points (Conserver les points critiques) (Douglas-Peucker) (algorithm='POINT_REMOVE' dans Python) fonctionne en identifiant et en supprimant les sommets relativement redondants afin de simplifier les données pour un affichage à des échelles plus petites. Il s’agit de l’algorithme de simplification le plus rapide dans cet outil. Cet algorithme est souvent utilisé pour la compression des données ou pour une simplification grossière. L'angularité des lignes résultantes augmente significativement au fur et à mesure que la tolérance s'accroît. Cet algorithme est basé sur l'algorithme de Douglas-Peucker : Douglas, David and Peucker, Thomas, "Algorithms for the reduction of the number of points required to represent a digitized line or its caricature," The Canadian Cartographer. 10(2), 112–22 (1973).
    • L’algorithme Retain critical bends (Conserver les courbes critiques) (Wang-Müller) (algorithm='BEND_SIMPLIFY' dans Python) fonctionne en identifiant et en éliminant les courbes relativement non significatives pour simplifier les données pour l’affichage à des échelles plus petites. Il est généralement plus fidèle à la géométrie en entrée que l’algorithme Retain critical points (Conserver les points critiques) (Douglas-Peucker), mais peut prendre plus de temps à traiter. Cet algorithme est basé sur l’algorithme défini dans l’ouvrage de Wang, Zeshen et Müller, Jean-Claude, « Line Generalization Based on Analysis of Shape Characteristics », Cartography and Geographic Information Systems 25(1), 3–15 (1998).
    • L'algorithme Conserver les surfaces effectives pondérées (Zhou-Jones) (algorithm='WEIGHTED_AREA' en Python) fonctionne en identifiant tout d'abord les triangles de la surface effective pour chaque sommet. Ces triangles sont ensuite pondérés par un ensemble de mesures afin de comparer la platitude, l'inclinaison et la convexité de chaque surface. Les surfaces pondérées guident la suppression de leurs sommets correspondants afin de simplifier la ligne tout en conservant autant de caractère que possible. Cet algorithme est basé sur l’algorithme défini dans l’ouvrage de Zhou, Sheng et Jones, Christopher B., « Shape-Aware Line Generalisation with Weighted Effective Area », Fisher, Peter F. (Ed.), Developments in Spatial Handling: 11th International Symposium on Spatial Handling, 369–80 (2005).
    • L’algorithme Retain effective areas (Conserver les surfaces effectives) (Visvalingam-Whyatt) (algorithm='EFFECTIVE_AREA' dans Python) identifie les triangles de surface effective de chaque sommet pour guider la suppression des sommets, ce qui permet de simplifier la ligne tout en préservant au maximum son caractère. Cet algorithme est basé sur l’algorithme défini dans l’ouvrage de Visvalingam, M. et Whyatt, J. D., « Line Generalisation by Repeated Elimination of the Smallest Area », Cartographic Information Systems Research Group (CISRG) Discussion Paper 10, The University of Hull (1992).

  • Le paramètre Tolérance de simplification détermine le degré de simplification. Plus la tolérance est grande, plus la géométrie finale est grossière. Des tolérances plus petites génèrent une géométrie plus fidèle à l'entrée. MinSimpTol et les champs MaxSimpTol sont ajoutés à la sortie pour enregistrer la tolérance qui était utilisée.

    Héritage :

    Au cours de la résolution topologique, des versions de l'outil ArcGIS Pro 1.4 modifiaient la tolérance sur une base par entité et enregistraient ces valeurs dans les champs MinSimpTol et MaxSimpTol. Maintenant, les valeurs de ces champs de tolérance sont identiques et égaux à la tolérance spécifiées dans le paramètre Simplification Tolerance (Tolérance de simplification). Veillez à modifier les modèles existants ou les scripts qui se fient sur un de ces champs.

    • Pour l'algorithme Conserver les points critiques (Douglas-Peucker), la tolérance est la distance perpendiculaire autorisée maximum entre chaque sommet et la nouvelle ligne créée.
    • Pour l'algorithme Conserver les courbes critiques (Wang-Müller), la tolérance est le diamètre d'un cercle qui avoisine une courbe significative.
    • Pour l’algorithme Retain weighted effective areas (Conserver les surfaces effectives pondérées) (Zhou-Jones), le carré de la tolérance est la surface d’un triangle significatif défini par trois sommets adjacents. Plus un triangle dévie de la forme équilatérale, plus la pondération attribuée est élevée et moins il est probable qu’il soit supprimé.
    • Pour l’algorithme Retain effective areas (Conserver les surfaces effectives) (Visvalingam-Whyatt), le carré de la tolérance est la surface d’un triangle significatif défini par trois sommets adjacents.

  • Utilisez le paramètre Conserver les points éliminés (collapsed_point_option dans Python) pour créer une classe d'entités ponctuelles pour enregistrer les extrémités de toutes les lignes qui sont inférieures à la tolérance spatiale des données. La sortie du point est dérivée ; elle utilisera le même nom et le même emplacement que la classe d’entités en sortie (Output feature class) (out_feature_class dans Python) mais avec un suffixe _Pnt. La classe d'entités linéaires en sortie contient tous les champs présents dans la classe d'entités en entrée. La classe d'entités points en sortie ne contient aucun de ces champs.

  • La classe d'entités linéaires en sortie est correcte d'un point de vue topologique. Toute erreur topologique dans les données en entrée est signalée dans la classe d’entités linéaires en sortie. La classe d’entités en sortie inclut deux champs supplémentaires : InLine_FID et SimLnFlag qui contiennent respectivement les ID d’entité en entrée et les erreurs topologiques de l’entrée. Une valeur SimLnFlag de 1 indique qu’une erreur topologique est présente. La valeur 0 (zéro) indique qu’aucune erreur n’est présente.

    Héritage :

    Avant la version ArcGIS Pro 1.4 de cet outil, des erreurs topologiques pouvaient être générées pendant le traitement. Les paramètres Détecter les erreurs topologiques (error_checking_option dans Python) et Résoudre les erreurs topologiques (error_resolving_option dans Python) ont été incluses pour identifier et résoudre en option ces erreurs. Ces paramètres sont encore inclus dans la syntaxe de l'outil pour la compatibilité des scripts et des modèles, mais sont désormais ignorés et masqués à partir de la boîte de dialogue de l'outil. Le champ SimLnFlag était utilisé pour indiquer les erreurs topologiques introduites par l’outil lors du traitement. Maintenant ce champ indique les erreurs présentes dans l'entrée.

  • Utilisez le paramètre Couches de barrière en entrée pour identifier les entités qui ne doivent pas être traversées par des lignes simplifiées. Les entités interruptions peuvent être des points, des lignes ou des polygones.

  • Les domaines et sous-types sont copiés vers la sortie, même si l’environnement Transfert des domaines de champ, des sous-types et des règles attributaires n’est pas sélectionné.

  • Le traitement de jeux de données volumineux peut dépasser les limites de la mémoire. Dans ce cas, envisagez de traiter les données en entrée par partition en identifiant une classe d’entités surfaciques pertinente dans le paramètre d’environnement Partitions cartographiques. Les portions des données, définies par les limites des partitions, sont traitées séquentiellement. La classe d'entités résultante sera transparente et cohérente aux tronçons de partition. Reportez-vous à Généralisation de jeux de données volumineux à l'aide de partitions pour en savoir plus.

Syntaxe

arcpy.cartography.SimplifyLine(in_features, out_feature_class, algorithm, tolerance, {error_resolving_option}, {collapsed_point_option}, {error_checking_option}, {in_barriers})
ParamètreExplicationType de données
in_features

Entités linéaires en entrée à simplifier.

Feature Layer
out_feature_class

Classe d'entités linéaires en sortie à simplifier. Elle contient tous les champs présents dans la classe d'entités en entrée. La classe d'entités linéaires en sortie est correcte d'un point de vue topologique. L’outil n’introduit pas d’erreurs de topologie, mais des erreurs topologiques dans les données en entrée sont signalées dans la classe d’entités linéaires en sortie. La classe d’entités en sortie inclut deux champs supplémentaires : InLine_FID et SimLnFlag qui contiennent respectivement les ID d’entité en entrée et les erreurs topologiques en entrée. Une valeur SimLnFlag de 1 indique une erreur topologique en entrée ; 0 (zéro) indique l’absence d’erreur en entrée.

Feature Class
algorithm

Spécifie l'algorithme de simplification de lignes.

  • POINT_REMOVE Conserve les points critiques qui contribuent à la forme globale d’une ligne et supprime tous les autres points (Douglas-Peucker). Il s’agit de l’option par défaut.
  • BEND_SIMPLIFY Conserve les courbes critiques dans une ligne et élimine les courbes superflues (Wang-Müller).
  • WEIGHTED_AREAConserve les sommets qui forment les triangles de surface effective qui ont été pondérées selon la forme du triangle (Zhou-Jones).
  • EFFECTIVE_AREA Conserve les sommets qui forment les triangles de surface effective (Visvalingam-Whyatt).
String
tolerance

La tolérance qui détermine le degré de simplification. Vous pouvez choisir une unité préférée ; sinon, les unités de l'entrée seront utilisées. MinSimpTol et les champs MaxSimpTol sont ajoutés à la sortie pour enregistrer la tolérance qui était utilisée lors du traitement.

  • Pour l'algorithme POINT_REMOVE, la tolérance est la distance perpendiculaire autorisée maximum entre chaque sommet et la nouvelle ligne créée.
  • Pour l'algorithme BEND_SIMPLIFY, la tolérance est le diamètre d'un cercle qui avoisine une courbe significative.
  • Pour l’algorithme WEIGHTED_AREA, le carré de la tolérance est la surface d’un triangle significatif défini par trois sommets adjacents. Plus un triangle dévie de la forme équilatérale, plus la pondération attribuée est élevée et moins il est probable qu’il soit supprimé.
  • Pour l’algorithme EFFECTIVE_AREA, le carré de la tolérance est la surface d’un triangle significatif défini par trois sommets adjacents.
Linear Unit
error_resolving_option
(Facultatif)
Héritage :

Il s'agit d'un ancien paramètre qui n'est plus utilisé. Il était précédemment utilisé pour stipuler la façon dont les erreurs topologiques, éventuellement introduites lors du traitement, étaient gérées. Ce paramètre est encore inclus dans la syntaxe de l'outil pour la compatibilité des scripts et des modèles, mais est désormais ignoré et masqué à partir de la boîte de dialogue de l'outil.

Boolean
collapsed_point_option
(Facultatif)

Indiquez s'il convient de créer une classe d'entité ponctuelle en sortie pour stocker les extrémités de toutes les lignes qui sont inférieures à la tolérance spatiale. La sortie du point est dérivée ; elle utilisera le même nom et le même emplacement que le paramètre out_feature_class, mais avec un suffixe _Pnt.

  • KEEP_COLLAPSED_POINTSEnregistre les extrémités des lignes de longueur nulle dans une classe d’entités ponctuelles en sortie dérivée. Il s’agit de l’option par défaut.
  • NO_KEEPNe crée pas de classe d’entités ponctuelles en sortie dérivée.
Boolean
error_checking_option
(Facultatif)
Remarque :

Il s'agit d'un ancien paramètre qui n'est plus utilisé. Il était précédemment utilisé pour stipuler la façon dont les erreurs topologiques, éventuellement introduites lors du traitement, étaient gérées. Ce paramètre est encore inclus dans la syntaxe de l'outil pour la compatibilité des scripts et des modèles, mais est désormais ignoré et masqué à partir de la boîte de dialogue de l'outil.

Boolean
in_barriers
[in_barriers,...]
(Facultatif)

Entrées contenant les entités pour agir en tant que barrières pour simplification. Les lignes simplifiées obtenues ne toucheront pas ni ne traverseront les entités interruptions. Par exemple, lors de la simplification des isolignes, l’entrée des entités de point côté comme interruptions garantit que les isolignes simplifiées ne simplifieront pas ces points. La sortie n'enfreindra pas l'altitude comme décrit par les points côtés mesurés.

Feature Layer

Sortie dérivée

NomExplicationType de données
out_point_feature_class

Lorsque le paramètre Keep collapsed points (Conserver les points éliminés) (collapsed_point_option dans Python) est utilisé, une classe d’entités ponctuelles en sortie est créée pour enregistrer les extrémités de toutes les lignes inférieures à la tolérance spatiale des données.

Classe d’entités

Exemple de code

Exemple d'utilisation de l'outil SimplifyLine (fenêtre Python)

Le script de fenêtre Python suivant montre comment utiliser l'outil SimplifyLine en mode immédiat.

import arcpy
import arcpy.cartography as CA
arcpy.env.workspace = "C:/data"
CA.SimplifyLine("roads.shp", 
                "C:/output/output.gdb/simplified_roads", 
                "POINT_REMOVE", 
                20)
2e exemple d'utilisation de l'outil SimplifyLine (script autonome)

Le script autonome suivant illustre l'utilisation de l'outil SimplifyLine.

# Name: SimplifyLine_Example2.py
# Description: Simplify line features from two feature classes, rivers and coastlines,
# while maintaining their connections
# Import system modules
import arcpy
import arcpy.management as DM
import arcpy.cartography as CA
 
# Set environment settings
arcpy.env.workspace = "C:/data/Portland.gdb/Hydrography"
 
# Set local variables
inRiverFeatures = "rivers"
inCoastlineFeatures = "coastlines"
mergedFeatures = "C:/data/PortlandOutput.gdb/merged_lines"
simplifiedFeatures = "C:/data/PortlandOutput.gdb/merged_lines_simplified"
tempLayer = "tempLyr"
outRiverFeatureClass = "C:/data/PortlandOutput.gdb/rivers_final"
outCoastlineFeatureClass = "C:/data/PortlandOutput.gdb/coastlines_final"
# Merge rivers and coastlines into one feature class, 
# assuming that they have a common f-code field 
# with value 40 for rivers and 80 for coastlines.
DM.Merge(inRiverFeatures, inCoastlineFeatures, mergedFeatures)
# Simplify all lines.
CA.SimplifyLine(mergedFeatures, 
                simplifiedFeatures, 
                "BEND_SIMPLIFY", 
                100, 
                "KEEP_COLLAPSED_POINTS")
 
# Select rivers and coastlines by their f-code values 
# and put them in separate feature classes.
DM.MakeFeatureLayer(simplifiedFeatures, tempLayer, "f-code = 40")
DM.CopyFeatures(tempLayer, outRiverFeatureClass)
DM.MakeFeatureLayer(simplifiedFeatures, tempLayer, "f-code = 80")
DM.CopyFeatures(tempLayer, outCoastlineFeatureClass)

Informations de licence

  • Basic: Non
  • Standard: Oui
  • Advanced: Oui

Rubriques connexes