Redistribuir los vértices de la cadena de líneas a la distancia especificada

Question

Utilizo un programa de modelos de aguas subterráneas llamado GMS, y tiene una función muy útil "Redistribuir vértices" ( más información ). Utilizo esta función todo el tiempo para simplificar y proporcionar regular espaciamientos entre puntos (vértices) en cadenas de líneas.

Véase esta imagen de GMS en la que las líneas negras son el flujo original con espaciamientos irregulares, y las líneas grises han redistribuido los vértices utilizando 50,0 m

No he visto la función equivalente en ningún otro lugar del mundo del procesamiento SIG (Esri, STC, PostGIS, etc.). Redistribuir vértices requiere una distancia de separación especificada, mientras que las funciones de tipo simplificar utilizan una tolerancia y no utilizan un espaciado especificado. ¿Alguien sabe si hay algo equivalente en ArcGIS o en proyectos SIG de código abierto?

Answer 1

Este tipo de tratamiento se realiza mediante referencia lineal . ArcGIS tiene un número de herramientas para trabajar con características referenciadas linealmente, sin embargo para los puntos equidistantes a menudo es más fácil crear un pequeño script para generar los puntos y luego unirlos como nuevas líneas.

En el mundo del código abierto, la mayoría de las bases de datos espaciales tienen esta funcionalidad, al igual que las bibliotecas espaciales como Shapely para Python.

Answer 2

Desde la versión 2.x, PyQGIS tiene un interpolate función similar a la de Shapely :

for distance in xrange(0,lenght_line,20):
     point = line.interpolate(distance) 

mira Cómo crear puntos en una distancia especificada a lo largo de la línea en QGIS？

Answer 3

Adaptando mi respuesta a esta pregunta : Primero haz ~/.qgis2/python/mytools.py :

from qgis.core import (QgsFeature, QgsGeometry,
                       QgsVectorLayer, QgsMapLayerRegistry,
                       QgsField)
from PyQt4.QtCore import QVariant
from qgis.utils import iface
import math

def redistribute_geometry_vertices(geom,dist):
    mylen=geom.length()
    line=geom.asPolyline()
    return QgsGeometry.fromPolyline([geom.interpolate(i*float(dist)).asPoint() for i in range(int(math.ceil(mylen/dist)))])

def selection_update_geometry(userFunction, *args):
    """Redistribute the vertices along a polyline """
    layer = iface.mapCanvas().currentLayer()
    for feature in layer.selectedFeatures():
        geom = feature.geometry()
        newgeom=userFunction(geom,*args)
        layer.changeGeometry(feature.id(),newgeom)

A continuación, seleccione la capa, hágala editable, seleccione las características y escriba esto en la consola:

import mytools
mytools.selection_update_geometry(mytools.redistribute_geometry_vertices,50)

Answer 4

He escrito una función para PostGIS que utiliza funciones de referencia lineal para redistribuir los vértices de las geometrías [Multi]LineString y [Multi]Polygon. Para PostGIS 2.0 y anteriores, ST_LineInterpolatePoint debe ser renombrado a ST_Line_Interpolate_Point .

CREATE OR REPLACE FUNCTION ST_RedistributeVertices(geom geometry, distance double precision)
  RETURNS geometry AS $body$
DECLARE
  num_vert integer;
BEGIN
  CASE
    WHEN GeometryType(geom) ILIKE 'LineString%' THEN
      num_vert := round(ST_Length(geom) / distance);
      IF num_vert = 0 THEN
        num_vert := 1;
      END IF;
      RETURN ST_MakeLine(array_agg(
               ST_LineInterpolatePoint(geom, n::float8 / num_vert::float8)
             )) FROM generate_series(0, num_vert) AS n;
    WHEN GeometryType(geom) ILIKE 'Polygon%' AND ST_NRings(geom) = 1 THEN
      RETURN ST_MakePolygon(ST_RedistributeVertices(ST_ExteriorRing(geom), distance));
    WHEN GeometryType(geom) ILIKE 'Multi%' OR
         GeometryType(geom) ILIKE 'GeometryCollection%' THEN
      RETURN ST_Multi(ST_Collect(g))
        FROM (SELECT ST_RedistributeVertices((ST_Dump(geom)).geom, distance) AS g) AS f;
    ELSE
      RAISE EXCEPTION 'Unhandled geometry %', GeometryType(geom);
  END CASE;
END;
$body$ LANGUAGE plpgsql IMMUTABLE STRICT;

Una advertencia sobre el uso de una técnica de referenciación lineal simple es que los vértices resultantes no están necesariamente espaciados de la manera especificada distance aparte. Esto requeriría una función iterativa más complicada, que está más allá de lo que se puede hacer cómodamente con PL/pgSQL.