Crear puntos en una distancia especificada a lo largo de la línea usando QGIS？

Quiero usar QGIS creando puntos a lo largo de la línea, pero a una distancia especificada. Encontré dos herramientas de GRASS en SEXTANTE Toolbox ：

• v.to.points
• v.segmento

Intenté v.to.points , estableciendo la distancia máxima entre puntos en unidades de mapa a 100 y obtuve esto:

La segunda foto mostró una mirada cercana desde la superior. El resultado fue lo que quería, pero quiero obtener menos puntos , pero incluso establecí la distancia máxima a 1000, o 1000000, el resultado fue el mismo.

Traté de usar v.segment , pero no tenía ningún archivo que contenga reglas de segmento.

Underdark me dio algunos consejos, y probé geometrías de densificación dado un intervalo . Primero me dio un archivo de forma de polilínea igual que ingresé, y luego usé nodos de extracción para tratar de obtener esos puntos. Pero el resultado fue el mismo que obtuve usando v.to.points , sin importar lo que establezca el intervalo de distancia.

¿Cómo puedo crear puntos a lo largo de la línea y en una distancia especificada?

En la consola de Python:

• puede usar el módulo Shapely (como en ¿Cómo crear puntos equidistantes en QGIS? ) con la función

  punto = línea.interpolar (distancia actual)

• La nueva API de Python de la versión maestra (1.9) tiene un comando equivalente (como en Generación de nodos de PK (distancia) en QGIS de Nathan Woodrow)

  punto = geom.interpolate (currentdistance)

• o puede usar álgebra vectorial y cosenos de dirección (como en PyQGIS: geometrías, vectores, álgebra vectorial o cosenos de dirección, ejemplos de aplicación , en francés)

1) crear una clase de capa de memoria (clase completa (sin atributos) en crea_mem_layer.py )

class Create_vlayer(object):
    '''creation of a virtual layer''' 
     def __init__(self,nom,type):
         self.type=type
         self.name = nom
         self.layer =  QgsVectorLayer(self.type, self.name , "memory")
         self.pr =self.layer.dataProvider() 
     def create_point(self,geometry):
         # add point to the layer
         self.seg = QgsFeature()
         self.seg.setGeometry(QgsGeometry.fromPoint(geometry))
         self.pr.addFeatures([self.seg])
         self.layer.updateExtents()
     @property
     def display_layer(self):
         #end of layer and display layer 
         QgsMapLayerRegistry.instance().addMapLayers([self.couche])

2) funciones de álgebra vectorial (de algèbre_vect_PyQGIS.py )

import math 
def mag(point):
    # magnitude of a vector
    return math.sqrt(point.x()**2 + point.y()**2)
def diff(point2, point1):
    # substraction betwen two vector
    return QgsPoint(point2.x()-point1.x(), point2.y() - point1.y())
def length(point1,point2):
    # with PyQGIS: sqrDist
    return math.sqrt(point1.sqrDist(point2))

3) cosenos de dirección

def dircos(point):
    cosa = point.x() / mag(point)
    cosb = point.y()/ mag(point)
    return cosa,cosb

4) línea de proceso o segmentos de línea

def pairs(list):
    # list pairs iteration 
    for i in range(1, len(list)):
    yield list[i-1], list[i]

layer = qgis.utils.iface.activeLayer()
# interval between points
interval = 5 m
# create virtual layer
gen_pt  = Create_vlayer("mid5", "Point")

for elem in layer():
    line = elem.geometry()
    for seg_start, seg_end in pairs(line.asPolyline()):
       line_start = QgsPoint(seg_start)
       line_end = QgsPoint(seg_end)
       # mid point = vector coordinates [x2-x1,y2-y1]
       pointm =diff(line_end, line_start)
       # direction cosines of the segment
       cosa,cosb = dircos(pointm)
       # length of the segment
       lg = length(line_end, line_start)
       # generate and add points to the virtual layer 
       for i in range(interval,lg,interval):
           gen_pt.create_point(QgsPoint(line_start.x()  + (i * cosa), line_start.y() + (i*cosb)))

# display layer
gen_pt.display_layer

Resultados

polilínea, punto equidistante con Shapely o PyQGIS2, con cosenos de dirección

Luego solo ajusta el intervalo

Ahora hay un complemento llamado QChainage que hace exactamente lo que quieres. Usted especifica una distancia de intervalo y el complemento crea puntos a lo largo de su línea en el intervalo especificado.

He escrito un guión que cambia la herramienta de geometrías Sextante Densify para aceptar una cierta distancia. Se llama geometrías densificadas dado un intervalo .

Después de ejecutar Densify, puede extraer los puntos con la herramienta Extraer nodos .

Puede obtenerlo de Github e instalar las instrucciones en mi blog .

Si no desea andar con scripts de Python, simplemente puede instalar y usar el complemento "Perfil de línea" e ignorar / eliminar la columna de valor ráster. El PK será lo que establezca el intervalo de muestreo.

Bueno, no estoy seguro si esto está en la versión estable, pero en la caja de herramientas sextante en 1.9 alfa en Geoalgorithims-> Vector es la opción "Convertir líneas en puntos". Funciona de maravilla, sé genial si también agregó un campo para la distancia a lo largo de la línea.

Sin embargo, fue interesante agregar el campo NOMBRE de mi capa vectorial.

Intenté hacer que Python Script de Nathan Woodrow funcionara, pero apestaba con Python. Y con el código en general parece.

Pasé mucho tiempo luchando con este problema, pero finalmente obtuve más o menos lo que estaba buscando usando QChainage. Lo que me gustaría compartir es algo que puede ayudar a otros. Cuando se utiliza la herramienta de disolución de geoprocesamiento SAGA en la línea, QChainage produce resultados incorrectos. El uso de una herramienta de disolución diferente hace que funcione bien.