( ) definiert daher ein Polygon.

Transkript

1 17.4 Polygone Verwendet man Punkte dazu, Flächen zu begrenzen, so entstehen Polygone. Ein Polygon ist eine endliche Folge von Strecken, wobei jeder Endpunkt genau zwei Strecken gemeinsam ist und keine Teilmenge der Streckenfolge diese Eigenschaft besitzt. Hat man n verschiedene Punkte P = { p 1,K,p n und zieht man einen geschlossenen Streckenzug durch alle Punkte, der jeden Punkt genau einmal berührt, so erhält man ein Polygon. Jede Permutation der Punktemenge p i1,p i2,k,p in ( ) definiert daher ein Polygon. Ein Polygon heißt einfach, wenn sich die Kanten nicht schneiden. Ein einfaches Polygon zerlegt die Ebene in zwei disjunkte Teilmengen, die inneren Punkte (geschlossen) und die äußeren Punkte (offen) des Polygons. Ein einfaches Polygon heißt konvex, wenn seine inneren Punkte eine konvexe Menge bilden. (Eine Menge M heißt konvex, wenn mit zwei Punkten p und q auch ihre Verbindungsstrecke pq in M liegt.) 17-34

2 Beispiel: Polygone von Punktmengen Polygon einfaches Polygon konvexes Polygom 17-35

3 Konstruktion eines einfachen Polygons U.-P. Schroeder, Uni Paderborn Während die Konstruktion eines (beliebigen) Polygons bei gegebener Punktemenge trivial ist, bedarf die Kontruktion eines einfachen Polygons schon einiger Überlegung. Wir erreichen die Schnittfreiheit, indem wir einen Randpunkt (einen mit kleinster/größter x- oder y-koordinate) als Mittelpunkt eines (gedachten) Kreises auswählen. Im Bild ist der Punkt p 0 mit der kleinsten x-koordinate gewählt. Alle anderen Punkte liegen in der rechten Halbebene. p 0 Jetzt läßt man von p 0 aus einen Strahl über die Halbebene streichen und nimmt die Punkte in der Reihenfolge in das Polygon auf, in der sie vom Strahl getroffen werden. Liegen mehrere Punkte auf demselben Strahl, so entscheidet der Abstand zum Ausgangspunkt (kleinerer Abstand zuerst) 17-36

4 Implementierung in C++ U.-P. Schroeder, Uni Paderborn void simple_polygon(point *P, index start, index end) { // Builds simple polygon from a given set of points double xmin = infinity; double ymin = infinity; index imin; for (index i = start ; i<=end; i++) // find extreme point if (P[i].x<xmin) (P[i].x=xmin && P[i].y<ymin)) { xmin = P[i].x; ymin = P[i].y; imin = i; for (index i = start ; i<=end; i++) { // calculate slopes and distances for all points if (i!=imin) { dx = P[i].x-xmin; dy= P[i].y-ymin; if (dx!=0) P[i].slope=dy/dx; else P[i].slope=infinity; P[i].dist=sqrt(dx*dx+dy*dy); else { P[i].slope = - infinity; P[i].dist =0; quicksort(p,start,end); // sorts points according slope and distance 17-37

5 17.5 Konvexe Hülle Die konvexe Hülle einer Punktmenge P ist die kleinste konvexe Punktmenge, die alle Punkte aus P enthält. Sie ist ein konvexes Polygon, dessen Eckpunkte Punkte aus P sind. Ihre Bestimmung tritt in einer Reihe von Anwendungen auf, vor allem als Teilproblem innerhalb komplexerer Probleme, z.b.: Kollisionsfreiheit bei Roboterarmen Kleinste Schachtel für einen Gegenstand Formanalyse 17-38

6 Der Einwickel-Algorithmus (gift wrapping, Jarvis s march) Idee: Der Einwickel-Algorithmus geht so vor, wie man üblicherweise Geschenke einwickelt: Man wickelt das Papier oder das Band unter Spannung zyklisch um den Gegenstand. Als Ergebnis erhält man ein eingewickeltes Geschenk, das unabhängig von der Form des Gegenstands konvex ist

7 Ablauf Um den Algorithmus entwickeln zu können, müssen folgende Fragen geklärt werden 1. Wie findet man einen Eckpunkt (Extrempunkt) des Polygons als Startpunkt. 2. Angenommen, man hat bereits mindestens einen Eckpunkt gefunden, wie findet man den nächsten Eckpunkt in der gewählten Reihenfolge (Uhrzeiger- oder Gegenuhrzeigersinn?) Frage 1 ist relativ leicht zu beantworten, denn der linkeste, rechteste, oberste, oder unterste sind alle Eckpunkte. (Bei fehlender Eindeutigkeit nimmt man z.b. den untersten linkesten Punkt) Wir wählen also z.b. den (linkesten) untersten Punkt (kleinstes y) p 0 als Ausgangspunkt. Die konvexe Hülle soll im Gegenuhrzeigersinn konstruiert werden

8 Ablauf des Einwickelns U.-P. Schroeder, Uni Paderborn p 4 p 3 p 2 p 2 p 1 p 1 p 0 p 0 Der nächste Punkt der konvexen Hülle ist offensichtlich derjenige, der von allen verbleibenden Punkten den kleinsten Polarwinkel bezüglich p 0 bildet. Wir berechnen also alle Polarwinkel bezüglich p 0 als Ursprung und bestimmen das Minimum. Dies führt uns zum nächsten Knoten p 1. Ihn wählen wir wieder als Bezugspunkt und berechnen erneut die Polarwinkel, um den Punkt mit dem Minimum als nächsten Polygonpunkt zu finden. Dies setzt sich fort, bis wir beim Ausgangspunkt p 0 wieder angekommen sind

9 17-42 U.-P. Schroeder, Uni Paderborn void gift_wrap(point *P, index start, index end, int &h); { // constructs convex hull by rearranging P: // first h elements of P (beginning at index start) build convex hull; index i,j; index min = start; double th, thmin; for ( i=start+1, i<= end ; i++) // find starting point for wrapping if (P[i].y < P[min].y) min=i; swap(p[min],p[start]); P[end+1] = P[start]; // copy of starting point as last point in P for ( i = start; i<=end; i++) // each step finds a new hull point { min = start; thmin=360.0; for (j=i+1; j<=end+1; j++) // find point with smallest angle { th = theta(p[j],p[i]); // returns polar angle if (th == thmin) // two points collinear: check distance if (distance(p[i],p[j]) < distance(p[i],p[min])) min = j; if (th < thmin) {min = j; thmin = th; if (min!= end+1) swap(p[min],p[i+1]); // new point found else { h = i-start+1; return; // cycle closed

10 Wie bestimmt man den Winkel ϑ? Der übliche mathematische Weg ist: ϑ = arctan y i+1 y i x i+1 x i p i ϑ p i+1 Diese Vorgehensweise hat mehrere Nachteile: Der Arcustangens ist zwar als Bibliotheksfunktion in der Regel verfügbar, seine Berechnung jedoch relativ teuer Die Division durch 0 ( x=0) muß explizit abgefangen werden, und wir müssen prüfen, in welchem Quadranten der Punkt liegt. Da wir nicht am absoluten Wert des Winkels interessiert sind, sondern den Winkel nur als Vergleichskriterium benötigen, genügt uns eine einfacher zu berechnende Funktion ϑ, für die gilt: ϑ(p,q 1 ) < ϑ(p,q 2 ) ϑ (p,q 1 ) < ϑ (p,q 2 ) die also dieselbe Ordnungseigenschaft hat wie ϑ 17-43

11 Einfache Ersatzfunktion für Polarwinkel Eine solche Funktion ist z.b. ϑ = y x + y Dies führt zur folgenden Implementierung der Funktion theta double theta( point p1, point p2) { // returns pseudo polar-angle of p2 with respect to p1 in degrees double th; int dx = p2.x-p1.x; int dy = p2.y-p1.y; int ax = abs(dx); int ay = abs(dy); th = (ax+ay == 0)? 0 : (double) dy/(ax+ay); if (dx<0) th = 2-th; else if (dy<0) th = 4+th; return th*90.0; 17-44

12 Komplexität des Einwickelns Die Bestimmung eines Ausgangspunkts bedeutet eine Minimumbildung auf der Menge der Punkte, also einen Aufwand von O(n) für die Initialisierung. Die Berechnung des (Pseudo-)Winkels (Funktion theta) kann offensichtlich in konstanter Zeit durchgeführt werden Da die innere Schleife für jeden Punkt diesen Winkel berechnet, besitzt sie eine Komplexität von O(n). Die äußere Schleife wird für jeden Eckpunkt des Hüllenpolygons durchgeführt. Bezeichnen wir mit h die Anzahl der Polygonpunkte, so ergibt sich ein Aufwand von O(n h) für den gesamten Algorithmus. Seine Laufzeit hängt daher stark von der Lage der Punkte ab. Im ungünstigten Fall gilt h = O(n) (z.b. wenn alle Punkte auf der Hülle liegen), und der Algorithmus besitzt quadratische asymptotische Laufzeit

13 Quick-Hull U.-P. Schroeder, Uni Paderborn Ein anderer Algorithmus zur Bestimmung der konvexen Hülle basiert wiederum auf dem Prinzip des Teilens und Herrschens. a b Zunächst werden die vier Extrempunkte bezüglich der beiden Koordinatenachsen bestimmt und miteinander verbunden. Alle Punkte innerhalb dieses Vierecks oder auf seinen Kanten sind innere Punkte und kommen als Eckpunkte der konvexen Hülle nicht mehr in Frage

14 Rekursive Struktur Das Interesse konzentriert sich daher auf die verbleibenden vier dreieckigen Bereiche, deren Punkte noch untersucht werden müssen. Jeder dieser vier Bereiche besteht aus einer Grundlinie (a,b) und einer Menge von Punkten, die außerhalb liegen, also eventuelle Polygonpunkte sein können. In jedem dieser Bereiche wird nun jeweils der Extrempunkt c bestimmt als derjenige mit dem maximalen Abstand von der Grundlinie (a,b). (Bei Nichteindeutigkeit wählt man irgendeinen) Verbindet man die Endpunkte der Grundlinie a und b mit dem gefundenen Extrempunkt c, so ergibt sich ein Dreieck, dessen innere Punkte I wiederum als a Hüllenpunkte ausscheiden. Dafür hat man wiederum zwei Bereiche A und B mit Grundlinie (a,c) bzw. (c,b) gefunden, auf die man jetzt rekursiv dasselbe Prinzip anwenden kann, bis keine Punkte mehr außerhalb liegen. A I c B b 17-47

15 Implementierung von Quick-Hull U.-P. Schroeder, Uni Paderborn Wir nehmen an, die Punkte seien als lineare Liste P gegeben Die Liste sei als Klasse vereinbart und unterstütze die Funktionen list Konstruktor append Anhängen von Elementen oder Teillisten clear Entfernen aller Elemente Wir setzen außerdem die Existenz der folgenden Funktionen voraus point* getmin_y(list P); // returns point with min y-coordinate point* getmin_x(list P); // returns point with min x-coordinate point* getmax_y(list P); // returns point with max y-coordinate point* getmax_x(list P); // returns point with max x-coordinate list left_of(list P, point* a, point* b); // returns list of points // left of line segment from a to b point* farest_point(list P, point *a, point *b); // returns point // with maximum distance from segment ab Wir verwenden den Aufzählungstyp: enum direction {north, east, south, west 17-48

16 void quick_hull(list P, list &HP) { // frame procedure for quick-hull: finding the four starter regions list Pts = list();// create list for temporary subset of points list Hpts = list(); point* extr[4]; // array of pointers to the four extreme points extr[north] = getmax_y(p); // finding extreme points in four extr[east] = getmax_x(p); // directions extr[south] = getmin_y(p); extr[west] = getmin_x(p); for (direction d=north; d<=west; d++) { Pts.append(left_of(extr[d], extr[(d+1)%4])); qh(extr[d],extr[(d+1)%4],pts,hpts); HP.append(extr[d]); // add starting point of current segment HP.append(HPts); // add hull points found Pts.clear(); Hpts.clear(); 17-49

17 void qh(point* a, point* b, list P, list &HP) { // recursive calculation of convex hull if (P.empty) return; // base of recursion: no points beyond segment else { list HA =list(); list HB =list(); // lists for hull points list A =list(); list B =list(); // lists for subsets point *c = farest_point(p,a,b); // calculate extreme point A.append(left_of(a,c)); // calculate new subsets B.append(left_of(c,b)); qh(a,c,a,ha); // recursive call subset A HP.append(HA); // add hull points of subset A HP.append(c); // add extreme point c qh(c,b,b,hb); // recursive call subset B HP.append(HB); // add hull points of subset B 17-50

18 Komplexität von Quick-Hull Die Funktionen getmax/getmin sind in linearer Zeit durchzuführen. Auch die Funktionen left_of(.) und farest_point(.) besitzen eine Komplexität von O(n) Die Initialisierung in quick_hull hat also eine Komplexität von O(n). Für die rekursive Prozedur qh bezeichnen wir die Zahl der Punkte mit n ( P = n) Zunächst haben wir einen Aufwand von O(n) für farest_point. Der Aufwand für den rekursiven Aufruf hängt nun von den Mengen A und B ab. Sei A = α, B= β mit α + β =n-1. Ist T(n) die Laufzeit von qh, dann gilt: T( n) = On ( ) + T( α) + T( β) 17-51

19 Um diese Gleichung lösen zu können, müssen wir α und β als Funktionen von n ausdrücken: Gilt α = β = n/2 so erhalten wir die bereits bekannte Rekursionsgleichung Tn ( ) = 2T( n2) + On ( ), die zu T( n) = O( n log n) führt Gilt jedoch α = 0, β = n 1 (oder umgekehrt), so erhalten wir Tn ( ) = T( 0) + Tn 1 ( ) + On ( ) was uns zu T( n) = On ( 2 ) führt Der Algorithmus besitzt also im schlimmsten Fall, wenn der Extrempunkt keine gleichmäßige Zerlegung der Punktmenge erzeugt, sondern alle Punkte in der einen Partition liegen, eine quadratische Laufzeit. (Diese Eigenschaft teilt er mit dem Standard-Quicksort.) Anmerkung: Es gibt für das Problem der konvexen Hülle Algorithmen, die auch eine wc-komplexität von T( n) = O n log n ( ) besitzen