Il y a 3 scénarios probables que j'essaie de capturer à proximité des distances:

1. Une station de métro d'échange, qui a 2 stations voisines ou plus. C'est-à-dire que la station en question relie 2 routes principales ou plus et a 2 stations voisines ou plus.
2. Une station de métro terminale, qui n'a qu'une seule station voisine. Voici la gare au bout de la ligne.
3. Une station de métro en ligne, qui a exactement 2 stations voisines, l'une des deux approches.

J'essaie de calculer une valeur que l'on pourrait appeler "distance moyenne entre les stations voisines"

Le arcpy.GenerateNearTable_analysis()peut gérer deux options: Distance à l'entité la plus proche et Distance entre toutes les entités.

Quelqu'un a-t-il une méthode intelligente pour résoudre ces scénarios? Notez que chaque station est désignée comme "Interchange", "Terminal" ou "Inline" dans la table attributaire sous le champ "StationType".

Ajoutée:

Voici du code pseudo basé sur la suggestion de @ whuber dans les commentaires. Je n'ai pas encore le temps de comprendre cela, donc si quelqu'un veut essayer, vous serez récompensé par une coche! ;)

J'ai jeté un coup d'œil à la bibliothèque NetworkX et elle semble fonctionner comme je le souhaite.

Étant donné le graphique:

A —― B ―― C ―― D
     |
     E

ainsi que les nœuds et liens:

Nodes = ["A", "B", "C", "D", "E"]
Links = [("A", "B"), ("B", "C"), ("C", "D"), ("B", "E")]

def myFunction(node):
    identify the links that node belongs to
    count the number of links
    calculate the total link lengths
    divide the total link lengths by the number of links
    return someValue

Je crois que votre problème, comme @whuber, a suggéré qu'il serait mieux représenté dans une matrice d'adjacence . Autrement dit, si vous avez le temps et l'envie de comprendre la théorie derrière elle, plutôt que de compter sur un package pour faire le travail pour vous.

Pour un graphe G donné, avec des sommets de {v ₁ , v ₂ , ..., v _n } où _n est le nombre de sommets, vous devez créer une matrice de taille M _{i, j} où i = n et j = n. Chaque sommet est alors représenté dans la _i ème ligne par le nombre de chemins trouvés vers les sommets adjacents dans la _j ème colonne.

Exemple ci-dessous:

Étant donné cette forme légèrement complexe de représentation de vos données relativement simples, vous devrez numéroter vos sommets de manière arbitraire, non représentative d'un ordre logique.

REMARQUE: En supposant qu'aucune station ne boucle sur elle-même, une _k ème ligne n'aura jamais une valeur autre que 0 dans la _k ème colonne. Toutes les définitions ci-dessous supposent que cela est vrai

REMARQUE: en supposant qu'il n'y a pas de lignes simultanées entre la même station, tous les exemples ci-dessous supposent qu'une valeur de cellule ne sera jamais que 1 ou 0. L'exemple ci-dessus suppose également que le déplacement bidirectionnel est autorisé.

Règles d'identification des catégories de stations:

1. Terminal

Un terminal serait identifié par une _k ème ligne ayant une seule colonne qui n'a pas de valeur 0 et dont la valeur est 1. Voir les sommets 1, 2 et 3 dans l'exemple 1 ci-dessus.

2. Jonction

Une jonction serait identifiée par une _k ème ligne ayant plus de deux colonnes contenant une valeur de 1. Voir le sommet 4 dans l'exemple 1 ci-dessus, ou tous les sommets dans l'exemple 3 ci-dessus.

3. Inline

Une station en ligne est signifiée en ayant exactement 2 colonnes dans une _k ème ligne où la valeur est 1. Voir tous les sommets dans l'exemple 2 ci-dessus. (Ignorez le fait que {v ₁ , v ₃ } recoupe {v ₂ , v ₄ }.)

Vous pourriez essayer d'utiliser Shapely . Si vous convertissez vos points arcpy en points galbés, vous pouvez calculer la distance entre les points individuels.

import arcpy
import shapely

arc_point1 = arcpy.Point(1,1)
arc_point2 = arcpy.Point(5,5)

shp_point1 = shapely.geometry.Point(arc_point1.X, arc_point1.Y)
shp_point2 = shapely.geometry.Point(arc_point2.X, arc_point2.Y)

distance = shp_point1.distance(shp_point2)
print "distance:", distance