Obtenir un point sur une polyligne à partir de points d'extrémité étant donné la distance le long de la polyligne

J'ai le point de départ et le point final d'une polyligne. Comment puis-je obtenir un point sur cette polyligne à partir de points d'extrémité spécifiés par la distance donnée.

Comment puis-je obtenir cela en utilisant arcpy à condition que ce script fonctionne sur ArcView sans importer de modules ( comme cette réponse ). J'essaie de ne pas coder en dur les valeurs.

Question connexe:

• Comment créer un point le long d'une ligne à distance donnée
• Interpoler des points le long d'une ligne dans Python pour ArcGIS Desktop?

Cela ressemble au "référencement linéaire" et cet ensemble d'outils serait disponible dans ArcView. De plus, vous pouvez créer un script pour cet outil très facilement.

Lien vers l'aide ESRI pour le référencement linéaire

En fonction de vos besoins, comme l'a mentionné @LouisH, l'utilisation du référencement linéaire est certainement la voie à suivre. J'ai bricolé du code qui devrait répondre à votre besoin de ne pas coder en dur, mais plutôt de les demander comme paramètres.

Comme explication, l'outil de référencement linéaire utilisé ci-dessous prend "Routes", dans votre cas les traits de la ligne, et place "Events", dans votre cas les points, le long d'eux en fonction d'un champ de distance. Il en résulte un FeatureLayer, qui est stocké en mémoire, ce qui est la raison de la dernière fonction qui copie les fonctionnalités dans une classe de sortie.

import arcpy
import os
from arcpy import env

#Working directory
wkspace        = arcpy.GetParameterAsText(0)
#Line feature class
rtecls         = arcpy.GetParameterAsText(1)
#Line Unique ID
rtecls_ID      = arcpy.GetParameterAsText(2)
#Table of points to be located
pnttbl         = arcpy.GetParameterAsText(3)
#Field in point table that references line point will be located along
pttbl_rteid    = arcpy.GetParameterAsText(4)
#Distance field in point table
pttbl_dst      = arcpy.GetParameterAsText(5)
#Output Layer, layer is stored in memory.  Features still need to be copied to feature class saved to disk
outlayer       = arcpy.GetParameterAsText(6)
#Output Feature Class - If shapefile, make sure to include ".shp" at the end.
outclass       = arcpy.GetParameterAsText(7)

#Type of feature being located
fttype = "POINT"

#Set Workspace
env.workspace = wkspace

#Build String for input parameters in Linear Referencing tool
pt_props = pttbl_rteid + " " + fttype + " " + pttbl_dst

#Output featureclass path
outfclass = wkspace + os.sep + outclass

# Execute MakeRouteEventLayer
arcpy.MakeRouteEventLayer_lr (rtecls, rtecls_ID, pnttbl, pt_props, outlayer)

#Save feature layer to feature class on disk
arcpy.CopyFeatures_management(outlayer, outfclass)

Modifier - Une chose à laquelle vous devez penser avec cet outil, et probablement toute opération pour localiser des points en fonction de la distance de la fin d'une ligne, est de quelle extrémité de la ligne vous commencerez. L'outil de référencement linéaire, par exemple, fonctionne en fonction de la direction numérisée d'une ligne. Il sera important de vous assurer que vous disposez d'un moyen d'identifier le point final sur lequel vos mesures sont basées.

Résoudre un problème de référence linéaire comme celui-ci without importing any modulesest hors de ma portée.

J'ai utilisé Shapely(package python pour la manipulation et l'analyse des géométries géospatiales 2D. Et il est sous licence BSD :-))

téléchargez-le d' ici . La version 2.6 qui est la seule à prendre en charge arcgis 10 arcpy..Il s'agit d'une installation simple (taille de 1,5 Mo)

et maintenant voici le script arcpy pour atteindre le but .. pardonnez mon python..seulement aujourd'hui j'ai appris les boucles, les tuples etc :)

import arcpy
import math
from arcpy import env

env.workspace = r"C:\testshape"

desc = arcpy.Describe("Rivers.shp")
shapefieldname = desc.ShapeFieldName

rows = arcpy.SearchCursor("Rivers.shp")

temptup = ()

# get ESRI geometries out of their cage..
for row in rows:

    feat = row.getValue(shapefieldname)
    partnum = 0
    for part in feat:
        for pnt in feat.getPart(partnum):
            if pnt:
                temptup += ((pnt.X, pnt.Y),)
            else:
                print "Interior Ring:"
        partnum += 1    

# and now the shapely magic :)

import shapely
from shapely.geometry import LineString
lnstr = LineString(temptup)
rsltPoint = lnstr.interpolate(0.5)
print(rsltPoint.x,rsltPoint.y)

remarque : cela ne fonctionnera pas si l'entité a des segments de courbe

J'ai trouvé cette question en essayant de faire ce que je pense est la même chose. Je voulais que tout se fasse via arcpy. L'utilisation du référencement linéaire n'avait pas de sens pour moi car je n'ai pas déjà les événements ponctuels (et je ne pouvais pas comprendre comment utiliser LR pour les obtenir). Le nœud de ce que j'ai fini par utiliser était

    line = arcpy.Polyline(arrayPts)
    pt = line.positionAlongLine (0.99, 'True')

Cela nécessite Arc 10.1 ou supérieur; Je n'ai pas pu déterminer si cela était disponible en dessous du niveau de licence ArcInfo que j'ai (ArcView spécifié par OP).

Dans mon exemple ci-dessus, je voulais un point non pas à une distance fixe, mais par un pourcentage de la longueur totale de la ligne. Pour ce faire, j'ai fourni le deuxième argument facultatif à positionAlongLine. Vous sautez le deuxième argument si vous voulez simplement spécifier une distance absolue. Voici le doc .

L'exemple de code plus complet est

import numpy
ptsList = list()
id = 0

with arcpy.da.SearchCursor('flFL', ["SHAPE@"]) as cursor:
    for row in cursor: 
        arrayPts = row[0].getPart()
        line = arcpy.Polyline(arrayPts)
        pt = line.positionAlongLine (0.99, 'True')
        ptsList.append((id, (pt.getPart().X, pt.getPart().Y)))
        id += 1

array = numpy.array([ptsList], \
numpy.dtype([('idfield',numpy.int32),('XY', '<f8', 2)]))

SR = arcpy.Describe("flFL").spatialReference
arcpy.da.NumPyArrayToFeatureClass(array, 'nsegSamplePts', ['XY'], SR)

'flFL'est ma fonctionCouche de lignes sur laquelle je veux localiser les points. Fonctionne assez rapidement. NumPyArrayToFeatureClassétait un très bon moyen de sauvegarder tous mes points dans une fonctionClasse (merci à mon collègue Curtis pour cette partie!). Avait expérimenté avec Append_managementmais c'était un peu plus lent.

Cela peut être exagéré, mais si vous avez accès à l'extension Network Analysis, vous pouvez créer un réseau à partir de vos polylignes, puis créer des zones de service autour de vos points d'entrée, en spécifiant la taille SA comme distance d'intérêt. Voici un exemple superficiel à 111 mètres SA du point:

Il faudrait ensuite trouver des points où SA franchit la ligne.

Je pense que vous pouvez l'obtenir avec la méthode Feature Vertices To Points (Data Management). vous pouvez obtenir plus d'informations ici .

ou vous pouvez consulter Split Line At Point (Gestion des données) ici .

ils ne suffisent pas entièrement mais vous pouvez écrire votre propre code ...

J'espère que ça t'aide...