Automatisation de la résolution des conflits et des workflows de généralisation avec le géotraitement
La généralisation de données implique beaucoup de tâches répétitives et fastidieuses, elle constitue donc un candidat idéal pour l'automatisation. Toutefois, la nature contextuelle et subjective de la généralisation la rend difficile à automatiser. Le cerveau humain est capable de hiérarchiser et de faire des concessions contextuelles simultanément. En revanche, il est beaucoup plus difficile d'indiquer à un ordinateur de faire la même chose avec une série de commandes discrètes.
L'environnement de géotraitement dans ArcGIS est idéal pour établir une structure de généralisation, puisqu'il peut gérer la transformation de données au cours d'étapes isolées distinctes s'appuyant sur des variables de données, d'échelle et spécifiques au produit. Ces étapes peuvent être logiquement reliées entre elles ou même répétées sous forme de boucle dans des scripts ou des modèles pour créer un workflow complexe pouvant être appliqué à une plage de données afin de produire des bases de données à plusieurs échelles pour l'impression ou l'affichage à l'écran. Les tâches peuvent être aisément répétées en séquences sur différents groupes d'entités ou avec différents paramètres combinées de plusieurs manières. Des workflows entiers peuvent être automatisés ou subdivisés en plus petits morceaux après avoir été mis à jour manuellement ou vérifiés.
Combinaison des tâches de généralisation en workflows cartographiques
Le processus de création d'une carte à une plus petite échelle que celle pour laquelle les données étaient prévues commence par une évaluation de l'échelle cible, des caractéristiques d'affichage, symbologie comprise, et de l'utilisation prévue ou sous-jacente de la carte. Puis, des opérations sont effectuées pour réduire le nombre total d'entités sans nuire à la connectivité ou au caractère du jeu de données. Enfin, la complexité de chaque entité est diminuée en supprimant des sommets ou d'autres détails. Cela peut comprendre également la diminution de la complexité dans les attributs d'entité en combinant des sous-catégories similaires d'entités qui seront affichées avec le même symbole. Une fois que la création de la carte commence et que les données sont affichées avec leur symbologie finale à l'échelle finale, les conflits graphiques peuvent être détectés et résolus.
L'organigramme suivant présente une version simplifiée d'un workflow de généralisation et identifie les outils clés de la boîte à outils Cartographie permettant de généraliser les données pour les afficher à une plus petite échelle.
 |
Affichage simplifié des processus et outils de géotraitement correspondants utilisés pour généraliser des données pour un affichage cartographique |
Il est important de comprendre que la plupart des outils de géotraitement génèrent en général de nouvelles données en sortie qui peuvent ensuite être utilisées pour les outils suivants. Cela n'est pas le cas des cartographes, qui suivent en général un workflow caractérisé par l'amélioration incrémentielle des couches d'entités déjà établies dans une carte. La symbologie, les propriétés de la couche et les relations de masquage sont déjà définies, il est donc préférable de modifier les couches d'entrées lors de la résolution des conflits et de la généralisation des opérations pour ne pas perdre ces informations. Pour cette raison, certains des outils de la boîte à outils Cartographie modifient les données en entrée dans les couches symbolisées plutôt que de créer des données. Cette approche est particulièrement facile à gérer et efficace lorsqu'elle est utilisée avec des représentations cartographiques.
Utilisation de représentation pour la prise en charge de la généralisation
Les représentations sont une propriété des classes d'entités de géodatabase qui leur permet d'afficher différemment la géométrie des entités. Plusieurs représentations peuvent être associées aux classes d'entités, ce qui permet à ces dernières d'afficher de différentes manières les mêmes données. Les représentations jouent un rôle primordial dans la généralisation, mais il faut tenir compte du fait qu'une seule classe d'entités est créée pour une échelle spécifique (ou petite plage d'échelles) quel que soit le nombre de représentations qui lui sont associées. Etant donné que les représentations peuvent permettre d'afficher de plusieurs manières un ensemble d'entités cela peut laisser penser qu'elles peuvent servir pour afficher les mêmes entités à plusieurs échelles. Il est possible de réaliser des petits changements harmonieux d'échelles en modifiant légèrement les formes de certaines entités de représentation ou en en masquant quelques-unes. Mais une relation un à un reste cependant maintenue avec les représentations ; chaque entité peut avoir un ou plusieurs affichages, mais les entités ne peuvent pas être combinées pour former de nouvelles entités. Par exemple, un ensemble de bâtiments discrets ne peut pas être modélisé en tant que zone construite uniquement à l'aide de l'affichage d'une représentation. Pour vraiment prendre en charge la cartographie multi-échelle, les entités doivent être traitées convenablement pour éviter une trop grande densité d'entités et une surcharge de détails ainsi que des conflits de symboles. Les outils disponibles dans les jeux d'outils Généralisation et Conflits graphiques peuvent vous aider à y parvenir.
Pour en savoir plus sur la résolution des conflits et la généralisation
Deux paramètres de comportement de mise à jour sont possibles pour les représentations. Le paramètre de mise à jour est une propriété d'une représentation qui est établi lorsqu'une représentation est créée sur une classe d'entités.
 |
Deux comportements de mise à jour sont possibles pour les représentations. |
- Enregistrer la modification dans la géométrie en tant que débrayage de la représentation. Il s'agit du paramètre par défaut. Ce paramètre indique que les modifications apportées à la géométrie des entités seront enregistrées dans un champ BLOB distinct dans la table attributaire de classe d'entités, qui est uniquement accessible par le biais de la représentation employée. La géométrie de base de l'entité stockée dans le champ Forme n'est pas modifiée.
- Modifier la géométrie de l'entité. Avec ce paramètre, les modifications apportées à la géométrie des entités modifieront le champ Forme de la classe d'entités et les autres représentations associées à la classe d'entités seront modifiées en conséquence.
Certains outils de généralisation modifient leurs couches en entrée ; de nouveaux jeux de données ne sont pas créés. Les données produites sont appelées données dérivées d'entrée/de sortie. Nous vous conseillons vivement d'utiliser des couches pointant vers des représentations avec le paramètre Enregistrer la modification dans la géométrie en tant que débrayage de la représentation surtout si vous utilisez les outils de résolution de conflits graphiques (Résoudre les conflits de route, Propager le déplacement ou Résoudre des conflits de bâtiments), car ces outils modifient la géométrie des couches en entrée. Avec ce paramètre, les modifications apportées aux entités avec ces outils sont enregistrées en tant que débrayages dans la représentation et la géométrie d'origine n'est pas modifiée. Cela est très utile, car les formes d'origines des entités (dans le champ Forme) peuvent être comparées aux entités modifiées et elles peuvent être rétablies si les résultats ne conviennent pas.
Attention :Si vous utilisez des couches en entrée pointant vers des représentations avec le paramètre Modifier la géométrie de l'entité dans les outils de résolution des conflits graphiques, les modifications effectuées à l'aide de ces outils remplaceront la géométrie d'origine des entités dans le champ Forme. De même, si vous utilisez une couche qui ne fait pas référence à une représentation (même si des représentations figurent dans la classe d'entités), la géométrie d'origine sera perdue. Si vous travaillez dans l'un de ces modes, nous vous conseillons vivement de faire des copies des classes d'entités en entrée avant de procéder à des modifications.
Les représentations sont également très utiles pour généraliser des données sur des échelles assez grandes. Dans l'idéal, les processus de généralisation doivent être en mesure de traiter directement des réductions d'échelle importantes, mais une échelle intermédiaire est en général nécessaire. La préparation des données pour les afficher graduellement à des échelles intermédiaires peut exagérer les imprécisions, car différentes décisions doivent être prises à mesure que des données détaillées disparaissent. Prenons l'exemple d'une entité A qui est déplacée pour permettre l'affichage d'une entité B sur une carte à grande échelle. Sur une carte à plus petite échelle, l'entité B n'apparaît plus, mais il n'y a aucun moyen aisé de voir que l'entité A a été déplacée ou de déterminer son emplacement d'origine. Dans ce cas, cette imprécision inutile est propagée aux plus petites échelles. Les débrayages de représentation permettent de remédier à cette situation, car vous pouvez rapidement et facilement déterminer visuellement l'emplacement de départ d'une entité et de le rétablir si nécessaire.
Liaison d'outils de généralisation dans ModelBuilder
Les outils de généralisation ont recours à des entrées à valeurs multiples, c'est-à-dire, à une liste d'une ou de plusieurs classes d'entités. Beaucoup d'outils de géotraitement acceptent les valeurs multiples (tel que l'outil Agréger), mais les outils de généralisation sont un peu différents, car ils produisent également des valeurs multiples en sortie. Par conséquent, vous devez maîtriser quelques techniques de ModelBuilder pour produire le modèle que vous souhaitez. Ces techniques sont abordées ci-dessous.
Liaison d'outils avec plusieurs entrées et sorties
Les outils Eclaircir un réseau routier, Résoudre des conflits de routes et Résoudre des conflits de bâtiments produisent des valeurs multiples en sortie. Cela signifie que seuls les outils qui acceptent des entrées à valeurs multiples peuvent utiliser directement les valeurs en sortie de ces outils. Par exemple, si trois couches sont utilisées en tant qu'entrées pour l'outil Eclaircir un réseau routier et si vous souhaitez utiliser ces mêmes trois couches en tant qu'entrées pour l'outil Résoudre des conflits de routes après qu'elles ont été affinées, vous pouvez lier directement les valeurs en sortie de l'outil Eclaircir un réseau routier à l'outil Résoudre des conflits de routes.
 |
Entrées multiples liées à l'outil Résoudre des conflits de routes via l'outil Eclaircir un réseau routier |
Vous pouvez utiliser l'outil Recueillir les valeurs pour ajouter plus de couches en tant qu'entrées. L'exemple suivant montre l'ajout de deux couches supplémentaires à la sortie de l'outil Eclaircir un réseau routier pour créer l'entrée de l'outil Résoudre des conflits de routes.
 |
Utilisation de l'outil Recueillir les valeurs pour ajouter des entrées supplémentaires à la sortie à valeurs multiples de l'outil Eclaircir un réseau routier avant de les lier à l'outil Résoudre des conflits de routes |
Liaison de plusieurs sorties à une sortie unique
Pour lier des outils qui ont une sortie à valeurs multiples à un outil qui accepte une seule entrée, utilisez l'outil Ajouter pour fusionner plusieurs classes d'entités. Un exemple de ce workflow est l'ajout de plusieurs couches de routes en entrée traitées par l'outil Eclaircir un réseau routier en vue de les utiliser comme entrée pour l'outil Fusionner des chaussées séparées, qui accepte une seule entrée.
 |
Utilisation de l'outil Ajouter pour combiner plusieurs sorties dans une seule entrée |
Liaison de plusieurs entrées de façon individuelle
Dans certains cas, il peut être judicieux de transférer plusieurs sorties une à une d'un outil à un autre outil. C'est le cas, si vous ne souhaitez pas que toutes les sorties du premier outil participent au deuxième outil ou si vous souhaitez définir des paramètres spécifiques pour chaque entrée dans le deuxième outil. Par exemple, l'outil Résoudre des conflits de bâtiments permet de contrôler totalement la manière dont chaque couche en entrée est définie en tant qu'interruption. Dans ce cas, utilisez le même ensemble de couches en tant qu'entrées pour les deux outils, mais définissez la sortie du premier outil en tant que pré-condition pour le deuxième outil afin d'appliquer l'ordre de traitement correct, comme il est illustré ci-dessous. Cette approche est uniquement applicable lorsque le premier outil, comme l'outil Résoudre des conflits de routes, modifie des couches en entrée au lieu de créer de nouvelles couches en sortie.
Pour en savoir plus sur l'utilisation de pré-conditions dans ModelBuilder
Dans l'exemple ci-dessous, les trois couches de transport sont utilisées comme entrées pour les deux outils. Cela est possible, car ces couches sont modifiées par l'outil Résoudre des conflits de routes ; de nouvelles classes d'entités en sortie ne sont pas créées. La sortie de l'outil Résoudre des conflits de routes est utilisée en tant que pré-condition pour l'exécution de l'outil Résoudre des conflits de bâtiments afin que l'outil Résoudre des conflits de routes finisse de s'exécuter avant que l'outil Résoudre des conflits de bâtiments ne s'exécute.
 |
Entrées symbolisées
Pour lier des outils qui acceptent uniquement des couches symbolisées, vous devez utiliser l'outil Générer une couche et l'outil Appliquer la symbologie d'une couche pour préparer une couche en sortie à des fins de liaison dans ModelBuilder ainsi que dans des environnements de script.
 |
Utilisation de l'outil Générer une couche et de l'outil Appliquer la symbologie d'une couche pour transmettre des informations de symbole entre les outils |
Exemple de script Python pour préparer des données pour l'affichage à une plus petite échelle
Ce script autonome exécute un workflow exemple s'appuyant sur certains outils de la boîte à outils Cartographie pour généraliser des données à l'échelle 1:25 000 et résoudre les conflits graphiques pour afficher les données à l'échelle 1:50 000.
# Name: cartography_workflow_script.py
# Description: Process features in order to resolve graphic conflicts when
# changing scales from 25K to 50K.
#
# Tools used = Aggregate Polygons, Align Marker To Stroke Or Fill, Apply
# Symbology From Layer, Create Overpass, Create Underpass, Calculate
# Line Caps, Eliminate Polygon Part, Make Feature Layer, Merge
# Divided Roads, Propagate Displacement, Resolve Building Conflicts
# Resolve Road Conflicts, Select, Select Layer By Attribute, Set
# Representation Control Point At Intersect, Set Representation
# Control Point By Angle, Simplify Building,Simplify Line, Simplify
# Polygon, Smooth Line, Smooth Polygon, Thin Road Network
# Minimum ArcGIS version = 10
#
# The geodatabase used in this workflow is assumed to be in c:\data
# - please replace this path to your machine specific folder.
# Import system modules
import arcpy, sys, os
from arcpy import env
# Start the processing
env.workspace = "C:/data/cartography.gdb"
# The data was captured at a scale of 1:24000, and this workflow will produce
# data appropriate for a scale of 1:50000.
# Most of the geoprocessing tools in this workflow require a reference scale
env.referenceScale = "50000"
env.cartographicCoordinateSystem = ""
###############
# HYDROGRAPHY #
###############
# A subset of linear features (rivers/streams) will be processed
# for simplification and smoothing
# A subset of polygonal features (reservoirs/lakes) will be procesed
# for simplification and smoothing
# The workspace is set to the hydrography feature dataset
env.workspace = "C:/data/cartography.gdb/hydrography"
# Linear hydrographic features
arcpy.MakeFeatureLayer_management("streamnetwork", "streamlayer", "", "", "")
# A selection is made for features which are rivers/streams
arcpy.SelectLayerByAttribute_management("streamlayer", "NEW_SELECTION",
'"FCsubtype" = 1')
# In order to reduce the complexity from the streams, vertices are removed using
# the Simplify Line tool
arcpy.SimplifyLine_cartography("streamlayer", "streams_simplified",
"BEND_SIMPLIFY", "100 meters", "RESOLVE_ERRORS")
# In order to reduce the amount or severity of sharp angles, Smooth Line is used
# to improve the shape of the streams
arcpy.SmoothLine_cartography("streams_simplified", "streams",
"BEZIER_INTERPOLATION", "#", "0", 'FLAG_ERRORS')
# Some of the processed features are intermittent rivers or streams and are
# symbolized as dashed lines. When symbolized with representations, the dashes
# can be centered around corners to improve the look of the features. The corners
# are identified as vertices which will be flagged as representation control
# points. Representation symbology is applied to a feature layer in order to be
# processed for control points.
# To place dashes at corners, representation symbology needs to be used by
# the feature layer.
arcpy.MakeFeatureLayer_management("streams", "streamslayer", "", "", "")
# Representation symbology is applied to a feature layer in order to be
# processed for control points.
arcpy.ApplySymbologyFromLayer_management("streamslayer",
"C:/data/stream_symbols.lyr")
# The dashes in the stream symbol will be placed at control points created
# anywhere an angle is less than (or equal to) 130 degrees.
arcpy.SetRepresentationControlPointByAngle_cartography("streamslayer", "130")
# Polygonal hydrographic features
# A selection is made to create a new feature class for reservoirs.
arcpy.Select_analysis("openwater", "reservoirs", '"FCsubtype" = 4')
# A selection is made to create a separate feature class for processing in order
# to generate lakes.
arcpy.Select_analysis("openwater", "water_select", '"FCsubtype" <> 4')
# In order to reduce the complexity from the lakes, vertices are removed using
# the Simplify Line tool.
arcpy.SimplifyPolygon_cartography("water_select", "water_simplified",
"BEND_SIMPLIFY", "100 meters", "0",
"RESOLVE_ERRORS")
# In order to reduce the amount (or severity) of sharp angles, Smooth Line is
# used to improve the shape of the lakes.
arcpy.SmoothPolygon_cartography("water_simplified", "lakes",
"BEZIER_INTERPOLATION", "0", "", "FLAG_ERRORS")
#############
# RAILROADS #
#############
# Set the workspace to the transportation feature dataset
env.workspace = "C:/data/cartography.gdb/transportation"
# In order to reduce the complexity from the railroads, vertices are removed
# using the Simplify Line tool.
arcpy.SimplifyLine_cartography("railnetwork", "rail_simplified",
"BEND_SIMPLIFY", "100 meters", "RESOLVE_ERRORS")
# The Merge Divided Roads tool requires symbolized features, so pre-made
# symbology is provided to the feature layer.
arcpy.MakeFeatureLayer_management("rail_simplified", "railwaylayer", "", "", "")
# In this workflow, the symbology being applied is Representations
arcpy.ApplySymbologyFromLayer_management("railwaylayer",
"C:/data/rail_symbols.lyr")
# The Merge Divided Roads tool will be used to generates single line railroad
# features in place of multiple divided railroad lanes.
arcpy.MergeDividedRoads_cartography("railwaylayer", "level", "25 Meters",
"railways")
# To place markers at corners, representation symbology needs to be used by
# the feature layer.
arcpy.MakeFeatureLayer_management("railways", "railwayslayer", "", "", "")
# Representation symbology is applied to a feature layer in order to be
# processed for control points.
arcpy.ApplySymbologyFromLayer_management("railwayslayer",
"C:/data/rail_symbols.lyr")
# The tick marks in railroad symbol (markers) will be placed at control points
# created anywhere an angle is less than (or equal to) 130 degrees.
arcpy.SetRepresentationControlPointByAngle_cartography("railwayslayer", "130")
###########
# LANDUSE #
###########
# Set the workspace to the landuse feature dataset
env.workspace = "C:/data/cartography.gdb/landuse"
# The polygons which represent landcover have holes in them where buildings are
# located. The holes need to be removed so they will not appear after buildings
# have moved. In this example, any hole which is less than 50 percent of the
# feature's area will be removed.
arcpy.EliminatePolygonPart_management("cultural", "urban_area", "PERCENT", "0",
"50", "CONTAINED_ONLY")
##############
# BOUNDARIES #
##############
# The boundary features have dashed outlines which are not in phase with each
# other on shared edges between features. To make the dashed outlines in phase
# with each other, representation control points are added wherever features
# share coincident vertices. The control points are then added to the features
# symbolized with Representations.
arcpy.SetRepresentationControlPointAtIntersect_cartography
("C:/data/boundaries.lyr", "C:/data/boundaries.lyr")
#########
# ROADS #
#########
# Set the workspace to the transportation feature dataset
env.workspace = "C:/data/cartography.gdb/transportation"
# Linear features
# Roads which are dead ends (or cul-de-sacs) should have their Line ending
# property set to BUTT.
arcpy.CalculateLineCaps_cartography("C:/data/road_symbols.lyr", "BUTT",
"CASED_LINE_DANGLE")
# Thin Road Network identifies a subset of road segments that can be removed from
# the display to create a simplified road network that retains the connectivity
# and general character of the input collection. Features are flagged for removal
# when their attribute value in the "invisible" field equals one. A layer
# definition query can be used to display the resulting simplified feature class.
arcpy.ThinRoadNetwork_cartography("roadnetwork", "500 meters", "invisible",
"level")
# The Merge Divided Roads tool will be used to generates single line road
# features in place of multiple divided road lanes.
arcpy.MergeDividedRoads_cartography("C:/data/road_symbols.lyr", "level",
"25 meters", "roads")
# The Resolve Road Conflicts tool requires symbolized features, so pre-made
# symbology is provided to the feature layer.
arcpy.MakeFeatureLayer_management("roads", "roadslayer", "", "", "")
# In this workflow, the symbology being applied is Representations
arcpy.ApplySymbologyFromLayer_management("roadslayer",
"C:/data/road_symbols.lyr")
# The Resolve Road Conflicts tool does not produce output road layers but instead
# alters the source feature classes of the input road layers. The Resolve Road
# Conflicts tool adjusts line features to ensure that they are graphically
# distinguishable when symbolized at output scale.
arcpy.ResolveRoadConflicts_cartography
("roadslayer", "level", "C:/data/cartography.gdb/buildings/displacement")
# The dashes in the road symbols will be placed at control points created
# anywhere an angle is less than (or equal to) 130 degrees.
arcpy.SetRepresentationControlPointByAngle_cartography("roadslayer", "130")
# Create bridges
# The Create Overpass tool will create a bridge for the roads and a mask for the
# streams wherever a road goes over a steam.
arcpy.CreateOverpass_cartography("roadslayer", "streamslayer", "2 points",
"1 points", "over_mask_fc", "over_mask_rc",
'"BridgeCategory" = 1', "bridges",
"ANGLED", "1 points")
# Create tunnels
# The Create Overpass tool will create a tunnel for the railroads and a mask for
# the railroads wherever a railroad goes under a road.
arcpy.CreateUnderpass_cartography("roadslayer", "railwayslayer", "2 points",
"1 points", "under_mask_fc", "under_mask_rc",
'"RelationshipToSurface" = 3', "tunnels",
"ANGLED", "1 points")
#############
# BUILDINGS #
#############
# Set the workspace to the buildings feature dataset
env.workspace = "C:/data/cartography.gdb/buildings"
# Point features
# When the road features were adjusted by the Resolve Road Conflicts tool, the
# spatial relationship with nearby buildings was affected. A displacement feature
# class was created by that tool in order to record the change applied to the
# roads. This information can be used by the Propagate Displacement tool to apply
# the same change to the point buildings.
# The road displacement is propagated to the point buildings
arcpy.PropagateDisplacement_cartography("point_bldg", "displacement", "AUTO")
# Point buildings will be rotated against nearby linear roads
# The Align Markers To Stroke Or Fill tool can do this with features symbolized
# with Representations.
# A feature layer is made for point buildings
arcpy.MakeFeatureLayer_management("point_bldg", "bldglayer", "", "", "")
# The symbology is switched to Representations
arcpy.ApplySymbologyFromLayer_management("bldglayer", "C:/data/bldg_symbols.lyr")
# The Align Marker to Stroke Or Fill tool is used to align point buildings to
# face road features within 5 points of the buildings
arcpy.AlignMarkerToStrokeOrFill_cartography("bldglayer", "roadslayer",
"5 points", "PERPENDICULAR")
# Polgyonal features
# When the road features were adjusted by the Resolve Road Conflicts tool, the
# spatial relationship with nearby buildings was affected. A displacement
# feature class was created by that tool in order to record the change applied
# to the roads. This information can be used by the Propagate Displacement tool
# to apply the same change to the polygonal buildings.
# The road displacement is propagated to polygon buildings
arcpy.PropagateDisplacement_cartography("footprints", "displacement", "SOLID")
# A selection is made to create a feature class with buildings larger than
# a minimum size
# The small buildings are not appropriate at the new map scale of 1:50,000
arcpy.Select_analysis("footprints", "buildings_select", '"Shape_Area" > 100')
# There is a need to create better spacing between polygon buildings and combine
# them when they share edges or are very close together
# The Aggregate Polygons tool is used to accomplish this task
arcpy.AggregatePolygons_cartography("buildings_select", "large_buildings",
"20 meters", "", "", "ORTHOGONAL")
# In order to reduce the complexity of the buildings, indentations, extensions
# and extra vertices are removed using the Simplify Building tool.
# Buildings require less visible detail at the new scale of 1:50,000.
arcpy.SimplifyBuilding_cartography("large_buildings", "area_bldg", "20 meters",
"0 unknown", "CHECK_CONFLICTS")
# All buildings require further improvements to achieve better spacing between
# themselves and other nearby features. At the new scale of 1:50,000 the
# symbolized buildings may overlap other features and create a visually congested
# map. To improve the visual congestion, the Resolve Building Conflicts tool is
# used. Buildings are improved in the context of their surrounding features.
# These features are considered barriers to buildings. The Resolve Building
# Conflicts tool requires symbolized features and has several options available
# to improve the buildings. Options include: moving or resizing the buildings,
# orienting or snapping the buildings to nearby features, as well as making the
# buildings invisible. Buildings from multiple feature classes can be used as
# inputs to the tool. Barriers from multiple feature classes can be used as
# inputs to the tool. For each barrier, the option is available to specify a snap
# or orient action for the buildings when they are within a specified distance.
# For each barrier, the option is available to specify a minimum distance for
# buildings to maintain between them.
# A feature layer is made for the polygon buildings
arcpy.MakeFeatureLayer_management("area_bldg", "footprintlayer", "", "", "")
# The symbology is switched to Representations
arcpy.ApplySymbologyFromLayer_management("footprintlayer",
"C:/data/footprint_symbols.lyr")
# The Resolve Building Conflicts tool is run with point and polygon buildings
# against roads, streams and railroads. The buildings will be moved away from
# streams and railroads until they reach a minimum distance. The buildings
# within a maximum distance from the roads will be rotated. Further movement
# and rotation may still be required by the tool in order to resolve any
# remaining graphic conflict.
arcpy.ResolveBuildingConflicts_cartography
("footprintlayer;bldglayer", "invisible", "'roadslayer' 'true' '5 meters';
'streamslayer' 'false' '5 meters';'railwayslayer' 'false' '10 meters'",
"10 meters", "20 meters", "level")