Search and Intersection

Präsentation zum Thema: "Search and Intersection"—  Präsentation transkript:

1 Search and Intersection
Schnitt zweier Segmente Schnitt von Segment und Dreieck Punkt im Polygon Schnitt konvexer Polygone

2 Schnitt zweier Segmente - Grundlagen
Lab b A Segment Menge aller Punkte auf einer Geraden zwischen zwei Punkten a und b a p(1/2) Darstellung eines Segmentes ? Sei A = b – a. Jeder Punkt auf Lab kann durch die Vektorsumme p(s) = a + sA dargestellt werden. Beispiele: p(0) = a p(1) = a + A = a + b – a = b p(1/2) = (a + b)/2 => p(s) für s  [0,1] repräsentiert alle Punkte auf dem Segment ab

3 Schnitt zweier Segmente - math. Umsetzung
Gegeben seien nun zwei Segmente ab : p(s) = a + sA für s  [0,1] cd : q(t) = c + tC für t  [0,1] d a c b Schnittpunkt der Segmente Der Schnittpunkt der Segmente ab und cd wird durch diejenigen Werte von s und t spezifiziert, für die p(s) = q(t) gilt: a + sA = c + tC Diese Vektorgleichung beinhaltet zwei Gleichungen mit zwei Unbekannten, nämlich die x- und y-Gleichungen, mit jeweils s und t als Unbekannte. Als Lösung dieses Gleichungssystems ergibt sich: s = [ax(dy – cy) + cx(ay – dy) + dx(cy – ay)] / D t = – [ax(cy – by) + bx(ay – cy ) + cx(by – ay)] / D D = ax(dy – cy) + bx(cy – dy) + dx(by – ay) + cx(ay – by) D = 0  Segmente sind parallel

4 Schnitt zweier Segmente - Quellcode
#define X 0 #define Y 1 typedef enum {FALSE, TRUE} bool; #define DIM 2 typedef int tPointi[DIM]; typedef double tPointd[DIM]; bool SegSegInt( tPointi a, tPointi b, tPointi c, tPointi d, tPointd p ) { double s, t; double num, denom; denom = a[X] * (double) ( d[Y] – c[Y] ) + b[X] * (double) ( c[Y] – d[Y] ) + d[X] * (double) ( b[Y] – a[Y] ) + c[x] * (double) ( a[Y] – b[Y] ) ; if ( denom == 0.0 ) return FALSE; num = a[X] * (double) ( d[Y] – c[Y] ) + c[X] * (double) ( a[Y] – d[Y] ) + d[X] * (double) ( c[Y] – a[Y] ); s = num / denom; num = - ( a[X] * (double) ( c[Y] – b[Y] ) + b[X] * (double) ( a[Y] – c[Y] ) + c[X] * (double) ( b[Y] – a[Y] ) ); t = num / denom; p[X] = a[X] + s * ( b[X] – a[X] ); p[Y] = a[Y] + s * ( b[Y] – a[Y] ); if ( ( 0.0 <= s ) && ( s <= 1.0) && ( 0.0 <= t) && ( t <<= 1.0) ) return TRUE; else return FALSE; }

5 Schnitt zweier Segmente
Schwächen des Quellcodes: Bei parallelen Segmenten wird standardmäßig „FALSE“ zurückgegeben, obwohl auch diese sich schneiden (überlappen) können. Da viele Anwendungen zwischen echtem („proper“) und entartetem („improper“) Schnitt unterscheiden müssen, wäre es sinnvoll, diese Information, z.B. codiert als Character-Wert, zurückzuliefern. Beispiel: „e“ : Segmente überlappen kollinear, teilen mindestens einen Punkt ( e = „edge“) „v“ : Endpunkt des einen Segmentes ist auf dem anderen Segment, aber „e“ trifft nicht zu ( v = „vertex“) „1“ : Schnitt ist „proper“; Segmente teilen einen Punkt und weder „e“, noch „v“ treffen zu „0“ : Segmente schneiden sich nicht

6 Schnitt zweier Segmente – verbesserter Quellcode
char SegSegInt( tPointi a, tPointi b, tPointi c, tPointi d, tPointd p ) { double s, t; double num, denom; char code; // denom bestimmen if ( denom == 0.0 ) return ParallelInt(a,b,c,d,p); // num bestimmen für s if ( num == 0.0 || num == denom) code = ‘v‘; s = num / denom; // num bestimmen für t t = num / denom; // p[X] und p[Y] bestimmen if ( ( 0.0 <= s ) && ( s <= 1.0) && ( 0.0 <= t) && ( t <<= 1.0) ) code = ‘1‘; else if ( ( 0.0 > s ) || ( s > 1.0) || ( 0.0 > t) || ( t > 1.0) ) code = ‘0‘; return code; } Bei parallelen Segmenten: Sonderbehandlung durch Funktion ParallelInt(…) Anwendung: - Schnitt konvexer Polygone (später)

7 Schnitt Segment / Dreieck - Grundlagen
Anwendung: Ray – Tracing Gegeben sei ein Segment qr und ein Dreieck T = abc. 1. Schritt : Bestimmung des Schnittpunktes von qr mit der Ebene π, die T enthält. Ebenengleichung: π : Ax + By + Cz = D bzw. als Punktprodukt geschrieben: π : (x, y ,z) * (A, B, C) = D N = (A, B, C) ist Normalenvektor der Ebene π. π N = (A,B,C) p = (x,y,z) D/ |N| (0,0,0)

8 Schnitt Segment / Dreieck – Schnitt Segment/Ebene
Wie auch im Zweidimensionalen kann jeder Punkt p auf dem Segment qr durch die Gleichung p(t) = q + t * (r – q) ( t  [0,1]) dargestellt werden. Gesucht ist nun ein Wert für den Parameter t, so dass p(t) auf der Ebene π liegt. Da jeder Punkt p = (x,y,z) auf π der Ebenengleichung (x,y,z) * (A,B,C) = D genügen muss, gilt: Gilt t  [0,1], dann schneidet Das Segment qr die Ebene π. t eingesetzt in p(t) liefert die Koordinaten des Schnitt- punktes von qr mit π

9 Schnitt Segment / Dreieck – Projektion in 2D
2. Schritt : Liegt der Schnittpunkt p von Segment qr und Ebene π innerhalb von T = abc? Beobachtung : Eigentlich zweidimensionales Problem! Lösung : Projektion des Dreiecks abc und p auf zwei Dimensionen. r Projektion : Streichen einer Koordinate in T =  abc und in p. Problem : Was, wenn π z.B. vertikal zur xy – Ebene liegt ? π p q Streichen derjenigen Koordinate, die im Normalenvektor N der Ebene π am größten ist. p‘ z y x

10 Schnitt Segment / Dreieck – signed areas
Es gilt : p liegt in T, falls der projizierte Punkt p‘ innerhalb des projizierten Dreiecks T‘ liegt. Wie stellt man die Lage von p‘ zu T‘ fest? => Berechnung von ‘signed areas‘ bezüglich p‘ : Deutung: Alle 3 areas positiv oder negativ: p‘ ist streng innerhalb von T‘ 2 areas „0“: p‘ liegt auf Eckpunkt 1 area „0“: p‘ liegt auf Kante, falls die beiden anderen areas die gleichen Vorzeichen haben +-- +-+ 2 --+ 1 +++ ++- -++ -+-

11 Punkt im Polygon - Ray Crossings
Gegeben ist ein fixes Polygon P und ein Punkt q. Dieser Abschnitt beschäftigt sich mit Möglichkeiten, herauszufinden, ob q in P liegt oder nicht. 2 Fälle: 1. Polygon konvex: LeftOn – Test für jede Kante des Polygons 2. Polygon nicht konvex: - Winding Number - Ray Crossings Anmerkung: Obwohl beide Algorithmen in O(n) arbeiten, ist die Methode der Ray Crossings bis zu 20mal schneller.

12 Punkt im Polygon – Winding number
Idee: Man steht auf Punkt q und betrachtet Punkt p, der einmal auf dem Rand des Polygons entgegen dem Uhrzeigersinn entlangläuft, bis er wieder seine Ursprungs- position erreicht hat. q P Beobachtung: q ∉ P : totale Drehung 0 q  P : totale Drehung 2π (Drehung gegen Uhrzeigersinn: positiv!)

13 Punkt im Polygon – Winding number
Die Winding Number von q bezüglich P ist die Anzahl der Umdrehungen die ein, auf dem Rand von P entlanglaufender Punkt p um q macht: Die totale Winkeldrehung geteilt durch 2π ( da man am Ende wieder die Ausgangsorientierung erreicht hat, ist die totale Winkel- drehung ein Vielfaches von 2π und also die Winding Number eine ganze Zahl ) Problem des Algorithmus: Abhängigkeit von Fließpunkt-Berechnungen ( speziell: trigonometrische Berech. ) => bis zu 20mal langsamer als Ray – Crossings – Algorithmus

14 Punkt im Polygon – Ray Crossings
25 Idee: Ziehe von q aus einen Strahl in beliebige (z.B. x- ) Richtung und zähle die Schnitte mit dem Rand von P. Ist diese Zahl ungerade, liegt q innerhalb von P, sonst nicht. Beispiele: q1 : 3 Schnitte => q1  P q2 : 2 Schnitte => q2  P Aber: Betrachte q3! Was, wenn der Strahl eine Ecke trifft, oder kollinear mit einer Kante verläuft? 16 20 15 21 22 q1 18 14 13 23 19 17 q2 P 12 26 10 24 8 27 6 9 q3 2 7 4 5 11 3 1

15 Punkt im Polygon – Ray Crossings
Problem: Der von q ausgehende Strahl R trifft Ecke von P oder verläuft kollinear zu einer Kante von P. Beobachtung: Die meisten Schwierigkeiten kann man umgehen, indem man folgende Regel aufstellt: Damit eine Kante e von P als Schnitt zählt, muss folgendes gelten: 1. Einer von e‘s Endpunkten muss streng oberhalb von R liegen 2. Der zweite Endpunkt von e muss auf oder unterhalb von R liegen 3. Die x-Koordinate des Schnittpunktes muss echt größer als die von q sein. ( => keine Kante, die kollinear mit R verläuft kann als Schnitt zählen )

16 Punkt im Polygon – Ray Crossings
Unter Beachtung der eben genannten Regel, ergibt sich nun folgende Situation: 25 Dicke Kanten und schwarze Ecken gelten als „innerhalb von P“ , dünne Kanten und weiße Ecken Gelten als „außerhalb von P“. Problem für Punkte gelöst, die echt innerhalb von P liegen. Aber: Inkonsistente Behandlung für Punkte, die auf dem Rand von P liegen! ( P ist geschlossenes Gebilde => Punkte auf dem Rand von P sollen als „innerhalb“ gelten ) 16 20 15 22 21 18 14 13 23 19 17 P 12 26 10 8 24 27 6 9 2 7 5 11 4 3 1

17 Punkt im Polygon – Ray Crossings
Lösung: Ziehe von q ausgehend zusätzlich einen Strahl in (–x) – Richtung. Für Kanten e von P gelten hierbei umgekehrte Voraussetzungen um als Schnitt zu zählen: 1. Einer von e‘s Endpunkten muss streng unterhalb von R liegen 2. Der zweite Endpunkt von e muss auf oder oberhalb von R liegen 3. Die x-Koordinate des Schnittpunktes muss echt kleiner als die von q sein. Ergeben sich nun unterschiedliche Ergebnisse für die entgegengesetzten Strahlen, so gilt q  P. Aber: Diese Methode funktioniert nur für Punkte, die innerhalb einer Kante von P liegen, nicht jedoch für die Ecken von P ! => Zu Beginn des Algorithmus einfachen Test durchführen, ob q Kante ist.

18 Punkt im Polygon – Ray Crossings – Quellcode
char InPoly( tPointi q, tPolygoni P, int n) { int i, i1; //point index int d; //dimension index double x; //x intersection of e with ray int RCross = 0; //number of right edge/ray crossings int LCross = 0; //number of left edge/ray crossings bool RStrad, LStrad; //flags indicating the edge strads //the x - axis //Shift so that q is the origin. Note this destroys polygon for( i = 0; i < n; i++ ) { for( d = 0; d < DIM; d++ ) P[i][d] = P[i][d] - q[d]; } //For each edge e = (i-1,i), see if crosses ray for( i = 0; i < n; i++) { //first check if q = (0,0) is vertex if( P[i][X] == 0 && P[i][y] == 0) return 'v'; i1 = ( i + n - 1) % n; //Check if e straddles x axis, with bias above/below RStrad = ( P[i][Y] > 0 ) != ( P[i1][Y] > 0 ); LStrad = ( P[i][Y] < 0 ) != ( P[i1][Y] < 0 ); if(RStrad || LStrad) { //Compute intersection of e with x - axis x = ( P[i][X] * P[i1][Y] - P[i1][X] * P[i][Y]) / (double)(P[i1][Y] - P[i][Y]); if (RStrad && x > 0 ) RCross ++; if (LStrad && x < 0 ) LCross ++; } //q on an edge if L/RCross counts are not the same parity if( ( RCross % 2) != ( LCross % 2) ) return 'e'; //q inside iff an odd number of crossings if ( RCross % 2) == 1) return 'i'; else return 'o'; ‘i‘ : q liegt streng innerhalb von P ‘o‘ : q liegt streng außerhalb von P ‘e‘ : q liegt auf Kante, aber ist kein Endpunkt ‘v‘ : q ist Ecke von P

19 Punkt im Polyeder Methode: Ray Crossings
Funktioniert im Prinzip wie in 2D, aber: keine Sonderbehandlung für Spezialfälle, sondern: Generierung eines Zufallsstrahls.

20 Schnitt konvexer Polygone
Der Schnitt zweier beliebiger Polygone mit m und n Ecken kann die quadratische Komplexität Ω(nm) haben : Beschränkt man sich jedoch auf konvexe Polygone, ergibt sich die lineare Komplexität O(n+m). Der erste lineare Algorithmus wurde 1978 von Shamos gefunden. Im Folgenden wird ein Algorithmus vorgestellt, der 1982 von O‘Rourke entwickelt wurde.

21 Schnitt konvexer Polygone – Algorithmus von O‘Rourke
Gegeben sind zwei konvexe Polygone, Q und P, deren Ränder gegen den Uhrzeigersinn orientiert sind. A und B sind gerichtete Kanten auf den Rändern von Q und P. Grundsätzliche Idee: A und B „jagen“ einander, d.h. sie durchlaufen die Kanten von Q und P gegen den Uhrzeigersinn und adjustieren ihre Geschwindigkeiten so, dass sie sich bei jedem Schnitt der Ränder von Q und P treffen: A P B Q

22 Schnitt konvexer Polygone – Algorithmus von O‘Rourke
Grundstruktur des Algorithmus: Algorithm: INTERSECTION OF CONVEX POLYGONS Choose A and B arbitrarily. repeat if A intersects B then Check for termination. Update an inside flag. Advance either A or B, depending on geometric conditions. until both A and B cycle their polygons. Handle P  Q =  and Q  P and P  Q cases. Schwierigkeit des Algorithmus liegt darin, Regeln für das Weitersetzen von A und B zu finden!

23 Schnitt konvexer Polygone – Algorithmus von O‘Rourke
Idee: Wenn B auf die Gerade „zielt“, die A enthält, diese aber nicht schneidet, dann wird B weitergesetzt, um näher an einen möglichen Schnittpunkt mit A zu gelangen. ( alle durchgezogenen Linien in der Graphik) Diese Situation kann folgendermaßen beschrieben werden: Sei H(A) die offene Halbebene auf der linken Seite von A. „A x B > 0“ soll bedeuten, dass die z-Koordinate des Kreuzproduktes > 0 ist. ( => die kürzeste Drehung von A nach B ist gegen den Uhrzeigersinn )

24 Schnitt konvexer Polygone – Algorithmus von O‘Rourke
falls A x B > 0 und b  H(A), oder falls A x B < 0 und b  H(A), => B wird weitergesetzt falls A x B < 0 und a  H(B), oder falls A x B > 0 und a  H(B), => A wird weitergesetzt ( B x A = - A x B ) A x B Halfplane Condition Advance Rule > b  H(A) A > b  H(A) B . < a  H(B) B < a  H(B) A

25 Schnitt konvexer Polygone – Details des Algorithmus
Polygone Q und P sind Arrays von Eckpunkten, die über die Variablen a und b indiziert werden. a1 und b1 indizieren jeweils die Eckpunkte, die eine Position vor a und b liegen. a1 ist Anfangspunkt von A, a Endpunkt von A ( Entsprechendes für B ) a1 A 4 6 P 5 b1 a 5 3 B 4 Q b 2 1 3 2 1

26 Schnitt konvexer Polygone – Details des Algorithmus
4 6 P Am Anfang des Algorithmus ist das inside-flag auf „unknown“ gesetzt. Die Kanten A und B laufen nun solange weiter (entsprechend den geometrischen Vorraussetzungen), bis sie sich zum ersten Mal schneiden. Dieser Schnittpunkt ist der erste Eckpunkt des Schnittpolygons S. Außerdem wird nun das inside-flag auf „Pin“ oder „Qin“ gesetzt. Solange nun „Qin“ gilt, gehören die Kanten von A zu S, bei „Pin“ die von B. Bei jedem Schnittpunkt von A und B kann sich der Wert des inside-flags ändern! Außerdem gehört jeder Schnittpunkt von A und B zu S. 5 b1 a 5 3 B S 4 Q b 2 1 3 2 1

27 Schnitt konvexer Polygone – Details des Algorithmus
Abbruchbedingung: Der Algorithmus ist fertig, wenn A und B ihre Polygone einmal umlaufen haben. Jedoch gibt es mögliche Fälle, in denen eine der beiden Kanten nie nie weitergesetzt wird. Die Hauptschleife des Algorithmus bricht ab, wenn: - A und B ihre Polygone einmal umlaufen haben, oder - eine der beiden Kanten ihr Polygon zweimal umlaufen hat Anmerkung: Ist die inside – Flag nach Beendigung der Hauptschleife noch immer auf „unknown“ gesetzt, weiß man, dass sich die Polygone nicht geschnitten haben!

28 Schnitt konvexer Polygone – Algorithmus / Sonderfälle
A und B überlappen und sind entgegengesetzt orientiert => Die Kante der Überlappung ist der gesamte Schnitt der beiden Polygone P Q A B A und B sind parallel ( A x B = 0) und a ist rechts von B, sowie b rechts von A => P  Q =  a P B Q A b

29 Search and Intersection - Ausblick
Weitere Themen, die unter „Search and Intersection“ fallen, aber aufgrund ihres Umfangs in diesem Vortrag nicht mehr behandelt werden können, sind z.B.: - der Schnitt von nicht-konvexen Polygonen - Extrempunkte von Polygonen - Extrempunkte von Polytopen - Lage eines Punktes in der Ebene