Antipodaler Abstand (oder Polygonabruf oder Polygondurchmesser) für konkave Polygone

Ich arbeite an einigen Klassenbeispielen in Python, die in ArcMap implementiert sind, um den antipodalen Abstand innerhalb eines Polygons zu berechnen. Dies ist für konvexe Polygone ziemlich routinemäßig. Für konkave Polygone möchte ich jedoch Lösungen ausschließen (die durch einen Strahl gebildet werden, der die Grenzpunkte verbindet), die nicht vollständig innerhalb des Polygons und nicht an der Polygongrenze liegen oder diese schneiden. Habe ich die Definition falsch interpretiert oder hat dieses Biest einen anderen Namen?

Betrachten Sie diese beiden Polygone

pnts = [[0,0], [0,1], [1,4], [3,5], [5,4], [4,1], [0,0]] # eine geschlossene Schleife konvex

pnts = [[0,0], [2,1], [1,4], [3,5], [5,4], [4,1], [0,0]] # eine geschlossene Schleife konkaves Polygon

In meiner Interpretation sollte dem Punkt 0,0 kein antipodaler Abstand zugeordnet sein, da der Vektor, der ihn mit den anderen Punkten verbindet, das Polygon entweder selbst schneidet oder sich an der Polygongrenze befindet.

Wenn jemand Klarheit über die Definition oder mögliche Lösungen hat, würde ich es begrüßen.

Eine visuelle Darstellung des konvexen Polygons und der gewünschten Linien (rot dargestellt) ist beigefügt (Beispielvektoren von Punkt 0 werden nur angezeigt).

Im konvexen Beispiel hat der erste Punkt keine antipodalen Vektoren, der zweite Punkt jedoch.

BEARBEITEN Ich hatte einige Erfolge bei der Suche mit "Polygonabruf" oder "Polygondurchmesser" im Web. Ich vermute, dass dies das ist, wonach ich suche.

Wenn ich einen Algorithmus schreiben würde, würde ich einfach prüfen, ob eine Linie zwischen zwei Eckpunkten des Polygons eine Linie schneidet, die eine der Kanten bildet. Hier ist mein Pseudocode:

1. Identifizieren Sie alle Eckpunkte und speichern Sie sie in einer Liste
2. Identifizieren Sie alle Kanten und speichern Sie sie in einer Liste (möglicherweise als Scheitelpunktpaare von 1).
3. Ermitteln Sie für jeden Scheitelpunkt den Abstand zu allen anderen Scheitelpunkten, außer:
   1. benachbarte Scheitelpunkte ausschließen (diejenigen, die eine Paarung mit diesem Scheitelpunkt in 2 teilen, vielleicht)
   2. Schließen Sie jede Linie aus, die eine Linie in 2. schneidet, indem Sie etwas von hier verwenden .

4. Speichern Sie alle Validabstände in Bezug auf die Eckpunkte in 1.

5. Machen Sie mit den Ergebnissen, was immer Sie wollen, schreiben Sie neue Zeilen aus, speichern Sie die längste für jedes Polygon ...

Ich bin mir nicht sicher, ob Sie danach suchen, aber Sie können die oben genannten Schritte in ArcPy ausführen.

EDIT: Code für Schritt 2.2:

E = B-A = ( Bx-Ax, By-Ay )
F = D-C = ( Dx-Cx, Dy-Cy ) 
P = ( -Ey, Ex )
h = ( (A-C) * P ) / ( F * P )

Wenn h zwischen 0 und 1 liegt, schneiden sich die Linien, andernfalls nicht. Wenn F * P Null ist, können Sie die Berechnung natürlich nicht durchführen, aber in diesem Fall sind die Linien parallel und schneiden sich daher nur in den offensichtlichen Fällen. Wenn h 1 ist, enden die Linien am selben Punkt. Behandle das so wie du willst! (Ich würde sagen, sie kreuzen sich, es macht mich einfacher.)

Ein weiteres Beispiel für Schritt 2.2 von hier: http://en.wikipedia.org/wiki/Line-line_intersection

Überprüfen Sie zunächst, ob der Nenner nicht gleich 0 ist, was bedeutet, dass die Linien parallel sind.

Stellen Sie dann sicher, dass die oben angegebenen Koordinaten nicht außerhalb des Begrenzungsrahmens der beiden Linien liegen.

Weitere Informationen: http://compgeom.cs.uiuc.edu/~jeffe/teaching/373/notes/x06-sweepline.pdf

Ich wäre versucht, dies mit Engeln zu tun, fast wie eine Sichtlinie. Wenn beim Iterieren der Scheitelpunkte in der Form die Winkel zwischen dem Ursprungsscheitelpunkt und dem Zielscheitelpunkt in einer konsistenten Richtung fortgesetzt werden, sind alle Punkte Kandidaten für das Antipodal. Wenn ein Winkel die Richtung wechselt, wird dieser Punkt durch den vorherigen Punkt ausgeblendet oder ausgeblendet. Wenn es durch den vorherigen Punkt ausgeblendet wird, muss der Punkt übersprungen werden. Wenn der vorherige Punkt ausgeblendet wird, müssen die vorherigen Punkte aus der Kandidatenliste entfernt werden.

1. Erstellen Sie eine PolygonCandidates-Liste
2. Für jeden Scheitelpunkt (Punkt k)
   1. Neue Liste für Kandidaten erstellen (Punkt, Winkel)
   2. Fügen Sie den aktuellen Scheitelpunkt zur Kandidatenliste hinzu (Punkt k)
   3. Iterieren Sie im Uhrzeigersinn um das Polygon für jeden verbleibenden Scheitelpunkt (Punkt i).
      1. Wenn sich der Winkel zum aktuellen Punkt (von Punkt k zu Punkt i) im Uhrzeigersinn fortsetzt, fügen Sie den Punkt hinzu
      2. Wenn sich der Winkel zum aktuellen Punkt gegen den Uhrzeigersinn fortsetzt
      3. Wenn die beiden vorherigen Kandidatenpunkte plus der aktuelle Punkt eine Rechtskurve bilden.
      4. Entfernen Sie den letzten Punkt in der Liste, bis der aktuelle Winkel und der letzte Kandidatenlistenwinkel gegen den Uhrzeigersinn liegen.
      5. Fügen Sie den aktuellen Punkt zur Kandidatenliste hinzu
   4. Fügen Sie alle bis auf die ersten beiden und letzten Kandidatenpunkte zu einer PolygonCandidates-Liste hinzu
3. Suchen Sie den am weitesten entfernten Punkt in der Liste der PolygonCandidates.

Ich bin mir nicht sicher, was ich mit Fällen tun soll, in denen der Ursprung und zwei andere Eckpunkte alle entlang derselben Linie liegen. In diesem Fall wäre der Winkel der gleiche. Wenn Sie ein Polygon mit Löchern hatten, konnten Sie den minimalen / maximalen Winkel jedes Lochs ermitteln und alle Kandidatenpunkte entfernen, die innerhalb dieses Bereichs liegen.

Der Hauptvorteil dieses Ansatzes besteht darin, dass Sie nicht auf den Linienschnittpunkt zwischen dem aktuellen Liniensegment und allen Polygonkanten testen müssen.

Das funktioniert ... denke ich. Ich habe den obigen Pseudocode und die Python aktualisiert, um das Lesen zu erleichtern.

Dies sollte die letzte Bearbeitung sein. Im folgenden Beispiel sollte der größte Anitpole für eine bestimmte Geometrie gefunden werden. Ich habe den Scrip so geändert, dass Punkte und Vektoren verwendet werden, um das Lesen zu erleichtern.

import math
from collections import namedtuple


Point = namedtuple("Point", "position x y")
Vector = namedtuple("Vector", "source dest angle")

def isClockwise(angle1, angle2):
    diff = angle2 - angle1
    #print("         angle1:%s angle2:%s diff: %s" % (angle1, angle2, diff))
    if(diff > math.pi/2):
        diff = diff - math.pi/2
    elif (diff < -math.pi/2):
        diff = diff + math.pi/2
    #print("         diff:%s" % (diff)) 
    if(diff > 0):
        return False
    return True

def getAngle(origin, point):
    return math.atan2(point.y - origin.y, point.x-origin.x)

#returns a list of candidate vertcies.  This will include the first, second, and second to last points 
#the first and last points in the polygon must be the same
#k is the starting position, only vertices after this position will be evaluated
def getCandidates (k, polygon):

    origin = polygon[k]
    candidates = [Vector(k,k,0)]
    prevAngle = 0;
    currentAngle = 0;
    for i in range(k + 1, len(polygon) - 1):

        current = polygon[i]
        #print("vertex i:%s x:%s y:%s  " % (i, current.x, current.y))

        if(i == k+1):
            prevAngle = getAngle(origin, current)
            candidates.append(Vector(k,i,prevAngle))
        else:   
            currentAngle = getAngle(origin, current)
            #print("     prevAngle:%s currentAngle:%s  " % (prevAngle, currentAngle))
            if isClockwise(prevAngle, currentAngle):
                #print("     append")
                candidates.append(Vector(k,i,currentAngle))
                prevAngle = currentAngle
            else:
                #look at the angle between current, candidate-1 and candidate-2
                if(i >= 2):
                    lastCandinate = polygon[candidates[len(candidates) - 1].dest]
                    secondLastCandidate = polygon[candidates[len(candidates) - 2].dest]
                    isleft = ((lastCandinate.x - secondLastCandidate.x)*(current.y - secondLastCandidate.y) - (lastCandinate.y - secondLastCandidate.y)*(current.x - secondLastCandidate.x)) > 0
                    #print("     test for what side of polygon %s" % (isleft))
                    if(i-k >= 2 and not isleft):
                        while isClockwise(currentAngle, candidates[len(candidates) - 1].angle):
                            #print("     remove %s" % (len(candidates) - 1))
                            candidates.pop()
                        #print("     append (after remove)")
                        candidates.append(Vector(k,i,currentAngle))
                        prevAngle = currentAngle

        #for i in range(len(candidates)):
        #   print("candidate i:%s x:%s y:%s a:%s " % (candidates[i][0], candidates[i][1], candidates[i][2], candidates[i][3]))

    return candidates

def calcDistance(point1, point2):
    return math.sqrt(math.pow(point2.x - point1.x, 2) + math.pow(point2.y - point1.y, 2))

def findMaxDistance(polygon, candidates):
    #ignore the first 2 and last result
    maxDistance = 0
    maxVector = Vector(0,0,0);
    for i in range(len(candidates)):
        currentDistance = calcDistance(polygon[candidates[i].source], polygon[candidates[i].dest])
        if(currentDistance > maxDistance):
            maxDistance = currentDistance
            maxVector = candidates[i];
    if(maxDistance > 0):
        print ("The Antipodal distance is %s from %s to %s" % (maxDistance, polygon[candidates[i].source], polygon[candidates[i].dest]))
    else:
        print ("There is no Antipodal distance")

def getAntipodalDist(polygon):
    polygonCandidates = []
    for j in range(0, len(polygon) - 1):
        candidates = getCandidates(j, polygon)
        for i in range(2, len(candidates) - 1):
            #print("candidate i:%s->%s x:%s y:%s  " % (candidates[i].source, candidates[i].dest, candidates[i].x, candidates[i].y))
            polygonCandidates.append(candidates[i])

    for i in range(len(polygonCandidates)):
        print("candidate i:%s->%s" % (polygonCandidates[i].source, polygonCandidates[i].dest))
    findMaxDistance(polygon, polygonCandidates)


getAntipodalDist([Point(0,0,0),Point(1,-2,0),Point(2,-2,3),Point(3,2,2),Point(4,-1,1),Point(5,4,0),Point(6,0,0)])
getAntipodalDist([Point(0,0,0),Point(1,2,1),Point(2,1,4),Point(3,3,5),Point(4,5,4),Point(5,4,1),Point(6,0,0)])
getAntipodalDist([Point(0,0,0),Point(1,1,1),Point(2,2,1),Point(3,1,4),Point(4,3,5),Point(5,5,4),Point(6,4,1),Point(7,0,0)])
getAntipodalDist([Point(0,0,0),Point(1,-1,3),Point(2,1,4),Point(3,3,3),Point(4,2,0),Point(5,-2,-1),Point(6,0,0)])

Ziehen Sie möglicherweise in Betracht, den Datensatz zu triangulieren. Welche Linien, die Polygonkanten gemeinsam haben, lassen sich leicht feststellen, und die übrigen können verglichen werden, um die längsten zu finden? Die Frage ist dann, welchen Triangulationsalgorithmus Sie benötigen.

Es ist nur eine Vermutung, aber ich vermute (ironischerweise), dass die Triangulation "niedrigster Qualität", die man erstellen kann, die gesuchte Linie enthalten muss, z. B. Abb. 1 in https://www.google.co.uk/url?sa=t&rct= j & q = & ESCR = s & source = web & cd = 6 & ved = 0CEoQFjAF & url = http% 3A% 2F% 2Fhrcak.srce.hr% 2Ffile% 2F69457 & ei = alIcUsb6HsLnswbfnYHoDw & USG = AFQjCNHIaykVRBAvv9hlaFJIBlfPLGHKtQ