Résumé
Simplifie les contours des polygones en supprimant les sommets relativement extérieurs tout en conservant leur forme globale.
Illustration
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 contours polygonaux résultants 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 correspondant pour simplifier le contour polygonal tout en conservant le plus de caractère possible. Cet algorithme est basé sur l’algorithme défini dans l’ouvrage de Zhou, Sheng et Jones, Christopher B., (2005)., « 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 le contour du polygone 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. Les champs MinSimpTol et MaxSimpTol sont ajoutés à la sortie pour enregistrer la tolérance qui était utilisée.
- Pour l’algorithme Retain critical points (Douglas-Peucker) (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.
Tous les polygones dont la superficie est inférieure au paramètre Surface minimale sont supprimés de la classe d'entités en sortie. Pour un groupe de polygones adjacents qui partagent des tronçons communs, la surface minimum s'applique à la superficie totale du groupe. Utilisez le paramètre Conserver les points éliminés pour conserver un enregistrement des polygones supprimés en tant qu'entités surfaciques.
Les polygones multi-parties sont simplifiés en tant que parties individuelles.
Utilisez le paramètre Keep collapsed points (Conserver les points éliminés) (collapsed_point_option dans Python) pour créer une classe d’entités ponctuelles afin d’enregistrer les points qui représentent tous les polygones ayant été supprimés car inférieurs à la surface minimum. La sortie du point est dérivée ; elle utilisera le même nom et le même emplacement que le paramètre Output feature class (Classe d’entités en sortie) (out_feature_class dans Python), mais avec un suffixe _Pnt. La classe d'entités surfaciques 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 surfaciques 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 surfaciques en sortie. La classe d’entités en sortie inclut deux champs supplémentaires : InPoly_FID et SimPgnFlag, qui contiennent respectivement les ID des entités en entrée et les erreurs topologiques ou les divergences de l’entrée.
Les valeurs du champ SimPgnFlag sont les suivantes :
- SimPgnFlag = 0 indique l’absence d’erreur.
- SimPgnFlag = 1 indique la présence d’une erreur topologique.
- SimPgnFlag = 2 indique que des entités ont été fractionnées par une partition et qu’elles ont désormais une surface inférieure à la surface minimum après simplification. Cet indicateur est susceptible de n’apparaître que sur une partie de l’entité fractionnée. Ces entités sont toutes conservées dans la classe d’entités en sortie. Cette situation se produit uniquement lorsque le paramètre d’environnement Cartographic Partitions (Partitions cartographiques) est employé.
Héritage :
Dans les versions précédentes de cet outil, des erreurs topologiques pourraient être générées pendant le traitement. Le paramètre Handling topological errors (Traitement des erreurs topologiques) (error_option dans Python) 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.
Le champ SimPgnFlag était utilisé pour signaler les erreurs topologiques dans la classe d’entités en sortie qui étaient introduites par l’outil en cours de traitement. Ce champ signale désormais les erreurs présentes dans l’entrée. En outre, au cours de la résolution topologique, des versions précédentes des outils modifiaient la tolérance sur une base par entité, et enregistraient ces valeurs dans les champs MinSimpTol et MaxSimpTol. Dans la mise en œuvre actuelle, les valeurs de ces champs 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.
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 polygones simplifiés. 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 de façon séquentielles. Les classes d'entités en sortie résultantes seront transparentes et cohérentes au niveau des 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.SimplifyPolygon(in_features, out_feature_class, algorithm, tolerance, {minimum_area}, {error_option}, {collapsed_point_option}, {in_barriers})| Paramètre | Explication | Type de données |
in_features | Entités surfaciques en entrée à simplifier. | Feature Layer |
out_feature_class | Classe d'entités surfaciques en sortie simplifiée. Elle contient tous les champs présents dans la classe d'entités en entrée. La classe d'entités surfaciques 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 indiquées dans la classe d’entités surfaciques en sortie. La classe d’entités en sortie inclut deux champs supplémentaires, InPoly_FID et SimPgnFlag, qui contiennent respectivement les ID des entités en entrée et les erreurs topologiques ou les divergences en entrée. Les valeurs de SimPgnFlag sont les suivantes :
| Feature Class |
algorithm | Spécifie l'algorithme de simplification des polygones à utiliser.
| 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. Les champs MinSimpTol et MaxSimpTol sont ajoutés à la sortie pour enregistrer la tolérance qui était utilisée lors du traitement.
| Linear Unit |
minimum_area (Facultatif) | Superficie minimale pour qu'un polygone soit conservé. La valeur par défaut est de zéro, auquel cas tous les polygones sont conservés. Vous pouvez choisir une unité préférée pour la valeur précisée ; sinon, les unités de l'entrée seront utilisées. | Areal Unit |
error_option (Facultatif) | Héritage :Il s'agit d'un ancien paramètre qui n'est plus utilisé. Il était auparavant utilisé pour indiquer 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 du modèle, mais est désormais ignoré et masqué à partir de la boîte de dialogue de l'outil. | String |
collapsed_point_option (Facultatif) | Indique s’il convient de créer une classe d’entités ponctuelles en sortie pour enregistrer les centres des polygones supprimés car inférieurs au paramètre minimum_area. La sortie du point est dérivée ; elle portera le même nom que la classe d’entités en sortie du polygone que vous avez spécifiée via le paramètre out_feature_class, mais avec un suffixe _Pnt, situé dans le même dossier.
| Boolean |
in_barriers [in_barriers,...] (Facultatif) | Les entrées contenant les entités jouant le rôle de barrières pour simplification. Les polygones simplifiés obtenus ne toucheront pas ni ne traverseront les entités interruptions. Par exemple, lors de la simplification des zones forestières, les polygones forestiers simplifiés résultants ne traversent pas les entités de route définies comme limites. | Feature Layer |
Sortie dérivée
| Nom | Explication | Type 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 points qui représentent tous les polygones supprimés car inférieurs à la surface minimum. | Classe d’entités |
Exemple de code
Le script de fenêtre Python suivant montre comment utiliser l'outil SimplifyPolygon en mode immédiat.
import arcpy
import arcpy.cartography as CA
arcpy.env.workspace = "C:/data"
CA.SimplifyPolygon("soils.shp", "C:/output/output.gdb/simplified_soils", "POINT_REMOVE", 100)Le script autonome suivant illustre l'utilisation de l'outil SimplifyPolygon.
# Name: SimplifyPolygon_Example2.py
# Description: Eliminate small islands before simplifying and smoothing lake boundaries
# 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
inLakeFeatures = "lakes"
eliminatedFeatures = "C:/data/PortlandOutput.gdb/lakes_eliminated"
simplifiedFeatures = "C:/data/PortlandOutput.gdb/lakes_simplified"
smoothedFeatures = "C:/data/PortlandOutput.gdb/lakes_smoothed"
# Eliminate small islands in lake polygons.
DM.EliminatePolygonPart(inLakeFeatures, eliminatedFeatures, 100, "OR", 0, "CONTAINED_ONLY")
# Simplify lake polygons.
CA.SimplifyPolygon(eliminatedFeatures, simplifiedFeatures, "POINT_REMOVE", 50, 200, "#", "KEEP_COLLAPSED_POINTS")
# Smooth lake polygons.
CA.SmoothPolygon(simplifiedFeatures, smoothedFeatures, "PAEK", 100, "FLAG_ERRORS")Environnements
Informations de licence
- Basic: Non
- Standard: Oui
- Advanced: Oui
Rubriques connexes
Vous avez un commentaire à formuler concernant cette rubrique ?