Lisser des lignes (Cartographie)

Résumé

Lisse des angles vifs en lignes afin d'améliorer la qualité esthétique ou cartographique.

Pour en savoir plus sur le fonctionnement des outils Lisser des lignes et Lisser un polygone.

Illustration

Utilisation

• Deux méthodes de lissage sont disponibles :

  • La méthode PAEK (Polynomial Approximation with Exponential Kernel, approximation polynomiale avec noyau exponentiel) (PAEK dans Python) lisse les lignes selon une tolérance de lissage. Chaque ligne lissée peut avoir plus de sommets que sa ligne source. Le paramètre Tolérance de lissage contrôle la longueur d'un chemin "mobile" qui sert à calculer les nouveaux sommets. Plus la longueur est courte, plus le niveau de détail est préservé et plus le temps de traitement est long.
  • La méthode Bezier interpolation (Interpolation de Bézier) (BEZIER_INTERPOLATION dans Python) lisse les lignes sans faire appel à une tolérance. Elle crée des courbes de Bézier évaluées qui correspondent aux lignes en entrée.

• Utilisez le paramètre Input barrier layers (Couches d’interruptions en entrée) pour identifier les entités qui ne doivent pas être traversées par des lignes lissées. Les entités interruptions peuvent être des points, des lignes ou des polygones.

• Le traitement de jeux de données volumineux peut dépasser les limites de la mémoire. Dans ces 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.

  Attention :

  Le paramètre d'environnement Partitions cartographiques est ignoré lorsque le paramètre Handling Topological Errors (Traitement des erreurs topologiques) est défini sur Do not check for topological errors (Ne pas détecter les erreurs topologiques) (NO_CHECK dans Python) ou sur Flag topological errors (Signaler les erreurs topologiques) (FLAG_ERRORS in Python).

• 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é.

• 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 SmoLnFlag, qui contiennent respectivement les ID des entités en entrée et les erreurs topologiques de l’entrée. Une valeur SmoLnFlag de 1 indique une erreur topologique ; une valeur 0 (zéro) indique l’absence d’erreur.

  Héritage :

  Avant la version ArcGIS Pro 2.2 de cet outil, le paramètre Preserve endpoint for rings (Conserver l’extrémité des boucles) (endpoint_option dans Python) était utilisé pour indiquer si l’extrémité d’un anneau de polygone isolé obtenu devait être conservé. 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é de la boîte de dialogue de l’outil.

Syntaxe

arcpy.cartography.SmoothLine(in_features, out_feature_class, algorithm, tolerance, {endpoint_option}, {error_option}, {in_barriers})

Paramètre	Explication	Type de données
in_features	Entités lignes à lisser.	Feature Layer
out_feature_class	Classe d'entités en sortie à créer.	Feature Class
algorithm	Spécifie l'algorithme de lissage. PAEK —Acronyme de Polynomial Approximation with Exponential Kernel, approximation polynomiale avec noyau exponentiel. Calcule une ligne lissée qui ne passe pas par les sommets de la ligne en entrée. Il s’agit de l’option par défaut. BEZIER_INTERPOLATION —Ajuste les courbes de Bézier entre les sommets. Les lignes obtenues passent par les sommets des lignes en entrée. Cet algorithme ne requiert pas de tolérance. La sortie contient des courbes de Bézier approximatives.	String
tolerance	Définit la tolérance utilisée par l'algorithme PAEK. Une tolérance supérieure à zéro doit être spécifiée. Vous pouvez choisir une unité préférée. Par défaut, l'unité de l'entité est spécifiée. Si vous utilisez l'algorithme de lissage BEZIER_INTERPOLATION, vous devez entrer 0 comme espace réservé.	Linear Unit
endpoint_option (Facultatif)	Il s'agit d'un ancien paramètre qui n'est plus utilisé. Il était auparavant utilisé pour indiquer si l’extrémité des lignes fermées devait être conservée. 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. Indique s’il faut conserver l’extrémité des lignes fermées. Cette option est valide uniquement avec l'algorithme PAEK. FIXED_CLOSED_ENDPOINT —Conserve l'extrémité d'une ligne fermée. Il s’agit de l’option par défaut. NO_FIXED —Lisse l'extrémité d'une ligne fermée.	Boolean
error_option (Facultatif)	Précise la manière de traiter les erreurs topologiques (qui ont pu s’introduire au cours du processus, notamment les croisements et les superpositions de lignes). NO_CHECK —Ne pas détecter les erreurs topologiques. Il s’agit de l’option par défaut. FLAG_ERRORS —Signaler les erreurs topologiques, le cas échéant. RESOLVE_ERRORS —Résoudre les erreurs topologiques, le cas échéant.	String
in_barriers [in_barriers,...] (Facultatif)	Entrées contenant les entités qui jouent le rôle d’interruptions pour le lissage. Les lignes lissées obtenues ne touchent pas ni ne traversent les entités interruptions. Par exemple, lors du lissage des isolignes, la saisie des entités de point côté comme interruptions garantit que les isolignes lissées ne sont pas lissées sur ces points. La sortie n'enfreindra pas l'altitude comme décrit par les points côtés mesurés.	Feature Layer

Exemple de code

Exemple d'utilisation de l'outil SmoothLine (Fenêtre Python)

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

import arcpy
import arcpy.cartography as CA
arcpy.env.workspace = "C:/data"
CA.SmoothLine("contours.shp", "C:/output/output.gdb/smoothed_contours", "PAEK", 100)

Exemple 2 d'utilisation de l'outil SmoothLine (script autonome)

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

# Name: SmoothLine_Example2.py
# Description: Simplify and then Smooth coastlines
# Import system modules
import arcpy
import arcpy.cartography as CA
# Set environment settings
arcpy.env.workspace = "C:/data/Portland.gdb/Hydrography"
# Set local variables
inCoastlineFeatures = "coastlines"
barriers = "C:/data/Portland.gdb/Structures/buildings"
simplifiedFeatures = "C:/data/PortlandOutput.gdb/coastlines_simplified"
smoothedFeatures = "C:/data/PortlandOutput.gdb/coastlines_smoothed"
# Simplify coastlines.
CA.SimplifyLine(inCoastlineFeatures, simplifiedFeatures, "POINT_REMOVE", 50, 
                "RESOLVE_ERRORS", "KEEP_COLLAPSED_POINTS", "CHECK", barriers)
# Smooth coastlines.
CA.SmoothLine(simplifiedFeatures, smoothedFeatures, "PAEK", 100, "", 
              "FLAG_ERRORS", barriers)

Environnements

Espace de travail courant, Valeur Z en sortie par défaut, Domaine M en sortie, Domaine XY en sortie, Système de coordonnées en sortie, Etendue, Valeurs M en sortie, Valeurs Z en sortie, Espace de travail temporaire, Tolérance XY, Partitions cartographiques

Informations de licence

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