Tworzenie punktów w określonej odległości wzdłuż linii za pomocą QGIS？

Chcę używać QGIS do tworzenia punktów wzdłuż linii, ale w określonej odległości. W SEXTANTE Toolbox znalazłem dwa narzędzia GRASS ：

• v.to. punkty
• v.segment

Próbowałem v.to. punktów , ustawiając maksymalną odległość między punktami w jednostkach mapy na 100 i otrzymałem to ：

Drugie zdjęcie pokazało dokładne spojrzenie z górnego. Rezultat był tym, czego chcę, ale chcę uzyskać mniej punktów , ale nawet ustawiłem maksymalną odległość na 1000 lub 1000000, wynik był taki sam.

Próbowałem użyć v.segment , ale nie miałem pliku zawierającego reguły segmentów.

Podmrok dał mi kilka rad i spróbowałem geometrii Densify z pewnym odstępem czasu . Najpierw dał mi plik kształtu polilinii taki sam, jak na wejściu, a następnie użyłem ekstraktów z węzłów, aby spróbować uzyskać te punkty. Ale wynik był taki sam, jak w przypadku punktów v.to. , bez względu na to, co ustawiłem interwał odległości.

Jak mogę tworzyć punkty wzdłuż linii i w określonej odległości？

W konsoli Python:

• możesz użyć modułu Shapely (jak w Jak tworzyć równo odległe punkty w QGIS? ) z funkcją

  point = line.interpolate (currentdistance)

• Nowe API Pythona w wersji master (1.9) ma równoważne polecenie (jak w Generowanie węzłów pikietażowych (odległość) w QGIS Nathana Woodrowa)

  point = geom.interpolate (currentdistance)

• lub możesz użyć algebry wektorowej i cosinusów kierunkowych (jak w PyQGIS: geometria, wektory, algebry wektorowej lub cosinusów kierunkowych, przykłady zastosowań , w języku francuskim)

1) Utwórz klasę warstwy pamięci (klasa pełna (bez atrybutów) na 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) funkcje algebry wektorowej (z 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) kierunek cosinus

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

4) linia procesowa lub odcinki linii

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

Wyniki

polilinia, punkt w równej odległości z Shapely lub PyQGIS2, z cosinusami kierunku

Następnie dostosuj interwał

Jest teraz wtyczka o nazwie QChainage, która robi dokładnie to, co chcesz. Podajesz odległość interwału, a wtyczka tworzy punkty wzdłuż linii w określonym interwale.

Napisałem skrypt, który zmienia narzędzie geometrii Sextante Densify na akceptowanie pewnej odległości. Nazywa się to geometriami Densify z określonym interwałem .

Po uruchomieniu Densify możesz wyodrębnić punkty za pomocą narzędzia Wyodrębnij węzły .

Możesz go pobrać z Github, a instrukcje instalacji znajdują się na moim blogu .

Jeśli nie chcesz korzystać ze skryptów Pythona, możesz po prostu zainstalować wtyczkę „Profil z linii” i użyć jej oraz zignorować / usunąć kolumnę wartości rastrowej. Pikietaż będzie taki, jak ustawiony interwał próbkowania.

Nie jestem pewien, czy jest to wersja stabilna, ale w przyborniku sextante na wersji 1.9 alfa pod Geoalgorytmami-> Wektor jest opcja „Konwertuj linie na punkty”. Działa przysmak, bądź świetny, jeśli dodał również pole do odległości wzdłuż linii.

Ciekawe, że dodał pole NAME z mojej warstwy wektorowej.

Próbowałem uruchomić ten skrypt Pythona autorstwa Nathana Woodrowa, ale mam do czynienia z Pythonem. I wydaje się, że z kodem w ogóle.

Długo walczyłem z tym problemem, ale w końcu dostałem mniej więcej to, czego szukałem za pomocą QChainage. Chciałbym się podzielić tym, co może pomóc innym. Podczas korzystania z narzędzia do rozpuszczania geoprzetwarzania SAGA na linii, QChainage generuje nieprawidłowe wyniki. Użycie innego narzędzia do rozpuszczania powoduje jego prawidłowe działanie.