Seguendo i commenti, ecco una versione che funziona con segmenti di linea perpendicolari. Si prega di usare con cautela poiché non l'ho testato a fondo!
Questo metodo è molto più goffo della risposta di @ whuber - in parte perché non sono un programmatore molto bravo, e in parte perché l'elaborazione vettoriale è un po 'faff. Spero che ti inizi almeno se i segmenti di linea perpendicolare sono ciò di cui hai bisogno.
Per eseguire questo, avrai bisogno dei pacchetti Shapely , Fiona e Numpy Python installati (insieme alle loro dipendenze).
#-------------------------------------------------------------------------------
# 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'immagine seguente mostra un esempio dell'output dello script. Inserite uno shapefile che rappresenta la vostra linea centrale e specificate la lunghezza delle linee perpendicolari e la loro spaziatura. L'output è un nuovo file di forma contenente le linee rosse in questa immagine, ognuna delle quali ha un attributo associato che specifica la sua distanza dall'inizio del profilo.
Come ha detto @whuber nei commenti, una volta arrivato a questo punto il resto è abbastanza facile. L'immagine seguente mostra un altro esempio con l'output aggiunto ad ArcMap.
Utilizzare lo strumento Feature to Raster per convertire le linee perpendicolari in un raster categoriale. Impostare il raster VALUEcome Distcampo nel file di forma di output. Ricorda anche di impostare lo strumento Environmentsin modo che Extent, Cell sizee Snap rastersono gli stessi che per il DEM sottostante. Dovresti finire con una rappresentazione raster delle tue linee, qualcosa del genere:
Infine, converti questo raster in una griglia intera (usando lo strumento Int o la calcolatrice raster) e usalo come zone di input per lo strumento Statistiche zonali come tabella . Dovresti finire con una tabella di output come questa:
Il VALUEcampo in questa tabella indica la distanza dall'inizio della linea del profilo originale. Le altre colonne forniscono varie statistiche (massimo, media ecc.) Per i valori in ciascun transetto. È possibile utilizzare questa tabella per tracciare il profilo di riepilogo.
NB: Un ovvio problema con questo metodo è che, se la linea originale è molto irregolare, alcune delle linee di transetto potrebbero sovrapporsi. Gli strumenti di statistica zonale in ArcGIS non sono in grado di gestire le zone sovrapposte, quindi quando ciò accade una delle tue linee di transetto avrà la precedenza sull'altra. Questo può o meno essere un problema per quello che stai facendo.
In bocca al lupo!
