Criando pontos na distância especificada ao longo da linha usando o QGIS？

Eu quero usar o QGIS criando pontos ao longo da linha, mas na distância especificada. Encontrei duas ferramentas GRASS na SEXTANTE Toolbox:

• v.to.points
• v.segment

Eu tentei v.to.points , definindo a distância máxima entre pontos em unidades de mapa para 100 e consegui isso:

A segunda foto mostrou um olhar mais atento da parte superior. O resultado foi o que eu quero, mas quero obter menos pontos , mas mesmo que eu defina a distância máxima para 1000 ou 1000000, o resultado é o mesmo.

Tentei usar o v.segment , mas não tinha nenhum arquivo contendo regras de segmento.

Underdark me deu alguns conselhos, e tentei as geometrias de Densify por um intervalo . Primeiro, ele forneceu um shapefile da polilinha da mesma forma que eu inseri e, em seguida, usei nós de extração para tentar obter esses pontos. Mas o resultado foi o mesmo que obtive usando pontos v.to. , não importa o que eu defina o intervalo de distância.

Como posso criar pontos ao longo da linha e na distância especificada?

No console do Python:

• você pode usar o módulo Shapely (como em Como criar pontos equidistantes no QGIS? ) com a função

  point = line.interpolate (distância atual)

• A nova API Python da versão mestre (1.9) possui um comando equivalente (como em Gerando nós de cadeia (distância) no QGIS de Nathan Woodrow)

  point = geom.interpolate (distância atual)

• ou você pode usar álgebra vetorial e cossenos de direção (como em PyQGIS: geometrias, vetores, álgebra vetorial ou cossenos de direção, exemplos de aplicação , em francês)

1) crie uma classe de camada de memória (classe completa (sem atributos) em 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) funções de álgebra vetorial (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) direção cossenos

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

4) linha de processo ou segmentos de linha

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

polilinha, ponto equidistante com Shapely ou PyQGIS2, com cossenos de direção

Então apenas ajuste o intervalo

Agora existe um plugin chamado QChainage que faz exatamente o que você deseja. Você especifica uma distância de intervalo e o plug-in cria pontos ao longo da sua linha no intervalo especificado.

Eu escrevi um script que altera a ferramenta de geometrias Sextante Densify para aceitar uma certa distância. É chamado de geometrias densificar dado um intervalo .

Após executar o Densify, você pode extrair os pontos usando a ferramenta Extrair nós .

Você pode obtê-lo no Github e as instruções de instalação estão no meu blog .

Se você não quiser usar scripts python, basta instalar e usar o plug-in "Profile from line" e ignorar / excluir a coluna de valor raster. A corrente será o que você definir para o intervalo de amostragem.

Bem, não tenho certeza se isso está na versão estável, mas na caixa de ferramentas sextante em 1.9 alfa em Geoalgorithims-> Vector é a opção "Converter linhas em pontos". Funciona um prazer, seja ótimo se ele adicionou um campo para a distância ao longo da linha também.

Interessante, ele adicionou o campo NAME da minha camada vetorial.

Eu tentei colocar o Python Script de Nathan Woodrow funcionando, mas sou péssimo com python. E com o código em geral, parece.

Passei muito tempo lutando com esse problema, mas finalmente consegui mais ou menos o que estava procurando usando o QChainage. O que eu gostaria de compartilhar é algo que pode ajudar outras pessoas. Ao usar a ferramenta de dissolução de geoprocessamento SAGA na linha, o QChainage produz resultados incorretos. O uso de uma ferramenta de dissolução diferente faz com que ela funcione bem.