A continuación de los comentarios, aquí hay una versión que funciona con segmentos de línea perpendiculares. ¡Utilice con precaución ya que no lo he probado a fondo!
Este método es mucho más torpe que la respuesta de @ whuber, en parte porque no soy un buen programador y en parte porque el procesamiento de vectores es un poco falso. Espero que al menos te ayude a comenzar si los segmentos de línea perpendicular son lo que necesitas.
Deberá tener instalados los paquetes Shapely , Fiona y Numpy Python (junto con sus dependencias) para ejecutar esto.
#-------------------------------------------------------------------------------
# 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()
La imagen a continuación muestra un ejemplo de la salida del script. Se alimenta en un archivo de forma que representa su línea central y especifica la longitud de las líneas perpendiculares y su espaciado. El resultado es un nuevo archivo de forma que contiene las líneas rojas en esta imagen, cada una de las cuales tiene un atributo asociado que especifica su distancia desde el inicio del perfil.
Como ha dicho @whuber en los comentarios, una vez que hayas llegado a esta etapa, el resto es bastante fácil. La imagen a continuación muestra otro ejemplo con la salida agregada a ArcMap.
Use la herramienta Característica a ráster para convertir las líneas perpendiculares en un ráster categórico. Configure el ráster VALUEpara que sea el Distcampo en el archivo de forma de salida. Asimismo, recuerda a configurar la herramienta Environmentsde manera que Extent, Cell sizey Snap rasterson los mismos que para su DEM subyacente. Debería terminar con una representación ráster de sus líneas, algo como esto:
Finalmente, convierta este ráster en una cuadrícula entera (usando la herramienta Int o la calculadora ráster), y úselo como zonas de entrada para la herramienta Estadística zonal como tabla . Debería terminar con una tabla de salida como esta:
El VALUEcampo en esta tabla proporciona la distancia desde el inicio de la línea de perfil original. Las otras columnas dan varias estadísticas (máximo, promedio, etc.) para los valores en cada transecto. Puede usar esta tabla para trazar su perfil de resumen.
NB: Un problema obvio con este método es que, si su línea original es muy ondulada, algunas de las líneas transectas pueden superponerse. Las herramientas de estadísticas zonales en ArcGIS no pueden tratar con zonas superpuestas, por lo que cuando esto suceda, una de sus líneas de transecto tendrá prioridad sobre la otra. Esto puede o no ser un problema para lo que estás haciendo.
¡Buena suerte!
