Gefundene Linien im geometrischen ArcMap-Netzwerk finden?

Ich habe an einem Projekt gearbeitet, das Linien in einem geometrischen Netzwerk verfolgt. Ich musste die Linienrichtung (Flussrichtung) auf vielen Linien umkehren, damit die Spuren funktionieren. Jetzt bin ich an einem Punkt angelangt, an dem ich den Stammdatensatz aktualisieren und die gleichen Zeilenumkehrungen in der Datenbank vornehmen muss.

Mein Gedanke ist, dass ich ein kleines Arcpy-Skript ausführen würde, um das Zu / Von-XY für jede Zeile mit dem Zu / Von der übereinstimmenden Zeilen im Master-Dataset zu vergleichen - alle, bei denen das Zu-XY mit dem Master von XY (und umgekehrt) übereinstimmt -versa) würde zum Umdrehen aufgezeichnet.

Obwohl ich denke, dass dieses Skript nicht zu schwer zu schreiben sein sollte, frage ich mich jetzt, ob es bereits ein Tool gibt, das die umgedrehten Zeilen für mich identifiziert? Ich konnte noch keinen in ArcToolbox finden, suche aber möglicherweise nach dem Falschen.

Beachten Sie, dass mein Datensatz andere Geometrieänderungen enthält, die ich nicht finden möchte, sondern nur identische übereinstimmende Linien (auf einer ID abgeglichen), bei denen der einzige Unterschied die Richtung ist. Zeilen, in denen XY anders ist, möchte ich ignorieren.

Zum Beispiel die folgenden Linien, die die Linienrichtung zeigen

Die Linien im blauen Bereich, die ich zur Kenntnis nehmen möchte, der einzige Unterschied ist die Linienrichtung. Die Linie im roten Bereich, die ich nicht aufzeichnen möchte, da sich die Linie tatsächlich bewegt hat.

Gibt es in ArcGIS Desktop (10.5) ein Tool, mit dem gespiegelte Linien identifiziert, andere Geometrieänderungen jedoch ignoriert werden können? Wenn ja, welches?

Ich habe gerade das Tool "Feature Changes erkennen" gefunden, das ich gerade teste (es ist sehr, sehr langsam). Ich bin mir nicht sicher, ob dies nur umgedrehte Zeilen oder alles finden wird. Natürlich habe ich die Parameter möglicherweise falsch eingestellt.

Das Tool zum Erkennen von Funktionsänderungen beendete die Verarbeitung - die Ausführung dauerte fast 20 Minuten -, fand jedoch nur 9 Features, bei denen sich die Linienrichtung geändert hatte. Ich erwarte mindestens 10000 gespiegelte Funktionen.

Ich würde ein Wörterbuch verwenden, um das zu tun. Ich bin überrascht, wie schnell sie sind.

import arcpy 

def GetDict(fc,precision):
    fields = ['SHAPE@','OID@']
    # use a dictionary with x1-y1-xn-yn key
    dict = {}
    with arcpy.da.SearchCursor(fc, fields) as cursor:
        for row in cursor:
            fpx = round(row[0].firstPoint.X,precision)
            fpy = round(row[0].firstPoint.Y,precision)
            lpx = round(row[0].lastPoint.X,precision)
            lpy = round(row[0].lastPoint.Y,precision)
            key= u'{0}-{1}-{2}-{3}'.format(fpx,fpy,lpx,lpy)
            if not dict.has_key(key):
                dict[key] = row[0]
    return dict

def GetOIDsOfLinesInNeedofFlipping(fc,dict,precision):
    fields = ['SHAPE@','OID@']
    flipoids = []
    changedoids = [] # polyline has been more than just flipped
    with arcpy.da.SearchCursor(fc, fields) as cursor:
        for row in cursor:
            fpx = round(row[0].firstPoint.X,precision)
            fpy = round(row[0].firstPoint.Y,precision)
            lpx = round(row[0].lastPoint.X,precision)
            lpy = round(row[0].lastPoint.Y,precision)
            ftkey= u'{0}-{1}-{2}-{3}'.format(fpx,fpy,lpx,lpy)
            tfkey= u'{0}-{1}-{2}-{3}'.format(lpx,lpy,fpx,fpy)
            if not dict.has_key(ftkey):
                if dict.has_key(tfkey):
                    flipoids.append(row[1])
                else:
                    changedoids.append(row[1])
    if len(changedoids) > 0:
        print(u'these are not the {0} oids you are looking for'.format(len(changedoids)))
    return flipoids

def FlipPolylines(fc,oids):
    fields = ['SHAPE@','OID@']
    with arcpy.da.UpdateCursor(fc, fields) as cursor:
        for row in cursor:
            if row[1] in oids:
                # https://gis.stackexchange.com/a/67422/59
                if row[0].partCount > 1: 
                    print "Warning: multiple parts! extra parts are automatically trimmed!"
                lp= row[0].getPart(0)
                rPnts=arcpy.Array()
                for i in range(len(lp)): rPnts.append(lp[len(lp)-i-1])
                rPoly=arcpy.Polyline(rPnts)
                row[0] = rPoly
                cursor.updateRow(row)
    return

def main():
    precision = 1
    dict = GetDict(r'H:\filegdbs\sewer.gdb\sewermains',precision) #the "master"
    print(u'keys = {0}'.format(len(dict)))
    oids = GetOIDsOfLinesInNeedofFlipping(r'H:\filegdbs\sewer.gdb\sewermainsflipped',dict,precision)
    print(u'{0} polylines need flipping'.format(len(oids)))
    if len(oids) > 0:
        FlipPolylines(r'H:\filegdbs\sewer.gdb\sewermainsflipped',oids)
    else:
        print("none need flipping")
    return


if __name__ == '__main__':
    main()