À la suite des commentaires, voici une version qui fonctionne avec des segments de ligne perpendiculaires. Veuillez utiliser avec prudence car je ne l'ai pas testé à fond!
Cette méthode est beaucoup plus maladroite que la réponse de @ whuber - en partie parce que je ne suis pas un très bon programmeur et en partie parce que le traitement vectoriel est un peu un problème. J'espère que cela vous permettra au moins de commencer si vous avez besoin de segments de ligne perpendiculaires.
Vous aurez besoin d'avoir les packages Shapely , Fiona et Numpy Python installés (ainsi que leurs dépendances) pour exécuter ceci.
#-------------------------------------------------------------------------------
# Name: perp_lines.py
# Purpose: Generates multiple profile lines perpendicular to an input line
#
# Author: JamesS
#
# Created: 13/02/2013
#-------------------------------------------------------------------------------
""" Takes a shapefile containing a single line as input. Generates lines
perpendicular to the original with the specified length and spacing and
writes them to a new shapefile.
The data should be in a projected co-ordinate system.
"""
import numpy as np
from fiona import collection
from shapely.geometry import LineString, MultiLineString
# ##############################################################################
# User input
# Input shapefile. Must be a single, simple line, in projected co-ordinates
in_shp = r'D:\Perp_Lines\Centre_Line.shp'
# The shapefile to which the perpendicular lines will be written
out_shp = r'D:\Perp_Lines\Output.shp'
# Profile spacing. The distance at which to space the perpendicular profiles
# In the same units as the original shapefile (e.g. metres)
spc = 100
# Length of cross-sections to calculate either side of central line
# i.e. the total length will be twice the value entered here.
# In the same co-ordinates as the original shapefile
sect_len = 1000
# ##############################################################################
# Open the shapefile and get the data
source = collection(in_shp, "r")
data = source.next()['geometry']
line = LineString(data['coordinates'])
# Define a schema for the output features. Add a new field called 'Dist'
# to uniquely identify each profile
schema = source.schema.copy()
schema['properties']['Dist'] = 'float'
# Open a new sink for the output features, using the same format driver
# and coordinate reference system as the source.
sink = collection(out_shp, "w", driver=source.driver, schema=schema,
crs=source.crs)
# Calculate the number of profiles to generate
n_prof = int(line.length/spc)
# Start iterating along the line
for prof in range(1, n_prof+1):
# Get the start, mid and end points for this segment
seg_st = line.interpolate((prof-1)*spc)
seg_mid = line.interpolate((prof-0.5)*spc)
seg_end = line.interpolate(prof*spc)
# Get a displacement vector for this segment
vec = np.array([[seg_end.x - seg_st.x,], [seg_end.y - seg_st.y,]])
# Rotate the vector 90 deg clockwise and 90 deg counter clockwise
rot_anti = np.array([[0, -1], [1, 0]])
rot_clock = np.array([[0, 1], [-1, 0]])
vec_anti = np.dot(rot_anti, vec)
vec_clock = np.dot(rot_clock, vec)
# Normalise the perpendicular vectors
len_anti = ((vec_anti**2).sum())**0.5
vec_anti = vec_anti/len_anti
len_clock = ((vec_clock**2).sum())**0.5
vec_clock = vec_clock/len_clock
# Scale them up to the profile length
vec_anti = vec_anti*sect_len
vec_clock = vec_clock*sect_len
# Calculate displacements from midpoint
prof_st = (seg_mid.x + float(vec_anti[0]), seg_mid.y + float(vec_anti[1]))
prof_end = (seg_mid.x + float(vec_clock[0]), seg_mid.y + float(vec_clock[1]))
# Write to output
rec = {'geometry':{'type':'LineString', 'coordinates':(prof_st, prof_end)},
'properties':{'Id':0, 'Dist':(prof-0.5)*spc}}
sink.write(rec)
# Tidy up
source.close()
sink.close()
L'image ci-dessous montre un exemple de la sortie du script. Vous introduisez un fichier de formes représentant votre ligne médiane et spécifiez la longueur des lignes perpendiculaires et leur espacement. La sortie est un nouveau fichier de formes contenant les lignes rouges de cette image, chacune ayant un attribut associé spécifiant sa distance depuis le début du profil.
Comme @whuber l'a dit dans les commentaires, une fois arrivé à ce stade, le reste est assez facile. L'image ci-dessous montre un autre exemple avec la sortie ajoutée à ArcMap.
Utilisez l' outil Entité vers raster pour convertir les lignes perpendiculaires en un raster catégoriel. Définissez le raster VALUEcomme Distchamp dans le fichier de formes en sortie. Rappelez - vous aussi de mettre l'outil de Environmentstelle sorte que Extent, Cell sizeet Snap rastersont les mêmes que pour votre DEM sous - jacente. Vous devriez vous retrouver avec une représentation raster de vos lignes, quelque chose comme ceci:
Enfin, convertissez ce raster en une grille entière (à l'aide de l' outil Int ou de la calculatrice raster) et utilisez-le comme zones d'entrée pour l' outil Statistiques zonales en tant que tableau . Vous devriez vous retrouver avec une table de sortie comme celle-ci:
Le VALUEchamp de ce tableau indique la distance depuis le début de la ligne de profil d'origine. Les autres colonnes donnent diverses statistiques (maximum, moyenne, etc.) pour les valeurs de chaque transect. Vous pouvez utiliser ce tableau pour tracer votre profil de résumé.
NB: Un problème évident avec cette méthode est que, si votre ligne d'origine est très ondulée, certaines des lignes de transect peuvent se chevaucher. Les outils de statistiques zonales dans ArcGIS ne peuvent pas traiter les zones qui se chevauchent, donc lorsque cela se produit, l'une de vos lignes de transect aura la priorité sur l'autre. Cela peut ou non être un problème pour ce que vous faites.
Bonne chance!
