Création de points à une distance spécifiée le long de la ligne à l'aide de QGIS？

Je veux utiliser QGIS pour créer des points le long de la ligne, mais à une distance spécifiée. J'ai trouvé deux outils GRASS dans SEXTANTE Toolbox:

• v.to.points
• v.segment

J'ai essayé v.to.points , en définissant la distance maximale entre les points en unités de carte à 100 et j'ai obtenu ceci:

La deuxième photo montre un gros plan de la photo du haut. Le résultat est ce que je veux, mais je veux obtenir moins de points , mais même si je fixe la distance maximale à 1000 ou 1000000, le résultat est le même.

J'ai essayé d'utiliser v.segment , mais je n'avais aucun fichier contenant des règles de segment.

Underdark m'a donné quelques conseils et j'ai essayé les géométries Densify avec un intervalle . Tout d'abord, cela m'a donné un fichier de formes polyligne identique à celui que j'ai entré, puis j'ai utilisé des nœuds d'extraction pour essayer d'obtenir ces points. Mais le résultat était le même que j'ai obtenu en utilisant des points v.to. , peu importe ce que je définissais l'intervalle de distance.

Comment puis-je créer des points le long de la ligne et à une distance spécifiée？

Dans la console Python:

• vous pouvez utiliser le module Shapely (comme dans Comment créer des points équidistants dans QGIS? ) avec la fonction

  point = ligne.interpoler (distance actuelle)

• La nouvelle API Python de la version principale (1.9) a une commande équivalente (comme dans Génération de nœuds de chaînage (distance) dans QGIS de Nathan Woodrow)

  point = geom.interpolate (distance actuelle)

• ou vous pouvez utiliser l'algèbre vectorielle et les cosinus de direction (comme dans PyQGIS: géométries, vecteurs, algèbre vectorielle ou cosinus de direction, exemples d'application , en français)

1) créer une classe de couche mémoire (classe complète (sans attributs) sur 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) fonctions d'algèbre vectorielle (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) cosinus de direction

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

4) Traiter la ligne ou les segments de ligne

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

Résultats

polyligne, point équidistant avec Shapely ou PyQGIS2, avec cosinus de direction

Ensuite, ajustez simplement l'intervalle

Il existe maintenant un plugin appelé QChainage qui fait exactement ce que vous voulez. Vous spécifiez une distance d'intervalle et le plugin crée des points le long de votre ligne à l'intervalle spécifié.

J'ai écrit un script qui modifie l'outil de géométrie Sextante Densify pour accepter une certaine distance. Cela s'appelle densifier les géométries avec un intervalle .

Après avoir exécuté Densify, vous pouvez extraire les points à l'aide de l' outil Extraire les nœuds .

Vous pouvez l'obtenir auprès de Github et les instructions d'installation sont sur mon blog .

Si vous ne voulez pas jouer avec les scripts python, vous pouvez simplement installer et utiliser le plugin "Profile from line" et ignorer / supprimer la colonne des valeurs raster. Le chaînage sera celui que vous aurez défini pour l'intervalle d'échantillonnage.

Eh bien, je ne sais pas si c'est dans la version stable, mais dans la boîte à outils sextante sur 1.9 alpha sous Geoalgorithims-> Vector est l'option "Convertir les lignes en points". Fonctionne bien, soyez génial si cela ajoute un champ pour la distance le long de la ligne.

Intéressant, il a cependant ajouté le champ NAME de ma couche vectorielle.

J'ai essayé de faire fonctionner ce script Python par Nathan Woodrow, mais je crains avec python. Et avec le code en général, il semble.

J'ai passé beaucoup de temps à lutter contre ce problème, mais j'ai finalement obtenu plus ou moins ce que je cherchais en utilisant QChainage. Ce que je voudrais partager, c'est quelque chose qui peut aider les autres. Lors de l'utilisation de l'outil de dissolution de géotraitement SAGA sur la ligne, QChainage produit des résultats incorrects. L'utilisation d'un outil de dissolution différent le fait fonctionner correctement.