J3dboolop
Upcoming SlideShare
Loading in...5
×
 

Like this? Share it with your network

Share

J3dboolop

on

  • 500 views

 

Statistics

Views

Total Views
500
Views on SlideShare
500
Embed Views
0

Actions

Likes
0
Downloads
0
Comments
0

0 Embeds 0

No embeds

Accessibility

Categories

Upload Details

Uploaded via as Adobe PDF

Usage Rights

© All Rights Reserved

Report content

Flagged as inappropriate Flag as inappropriate
Flag as inappropriate

Select your reason for flagging this presentation as inappropriate.

Cancel
  • Full Name Full Name Comment goes here.
    Are you sure you want to
    Your message goes here
    Processing…
Post Comment
Edit your comment

J3dboolop Document Transcript

  • 1. Boolean Operators for Java 3D Semesterarbeit von Urs Frick, Samuel Gerber Fachhochschule Aargau FHA University of Applied Science Aargau Departement Technik Studiengang Informatik Betreuende Dozenten Prof. Dr. Manfred Vogel Prof. Titus Jakob Datum 27. Februar 2004
  • 2. 1 Zusammenfassung Im Rahmen einer Semesterarbeit wurden die Booleschen Operatoren f¨r Java 3D in einem abgeschlossenen Packet implementiert. Die Imple- u mentation setzt auf der Repr¨sentation von soliden K¨rpern als B-Reps a o an. Das Packet wurde im Anschluss an die Semesterarbeit in die Applika- tion C3dQ der Firma CCT aus Griechenland integriert. ¨ In der nachfolgenden Dokumentation wird eine Ubersicht uber Repr¨sen- ¨ a tationen von soliden K¨rpern gegeben und einige L¨sungsans¨tze disku- o o a tiert. Anschliessend wird die Implementation des Packetes im Detail be- schrieben, sowie gezeigt wie das Packet verwendet werden kann.
  • 3. INHALTSVERZEICHNIS 2 Inhaltsverzeichnis 1 Einleitung 4 2 Solid Modeling 6 2.1 Repr¨sentationen . . . . . . . . . . . . . a . . . . . . . . . . . . . . 6 2.2 Boolesche Operatoren . . . . . . . . . . . . . . . . . . . . . . . . 7 2.3 Primitiven-Instanzierung . . . . . . . . . . . . . . . . . . . . . . . 7 2.4 Sweep Repr¨sentation . . . . . . . . . . a . . . . . . . . . . . . . . 7 2.5 Boundary Repr¨sentation . . . . . . . . a . . . . . . . . . . . . . . 9 2.5.1 Ansatz f¨r Boolesche Operatoren u auf B-Reps . . . . . . . 9 2.5.2 Nicht polyedrale B-Reps . . . . . . . . . . . . . . . . . . . 9 2.6 Spatial-Partitioning Representations . . . . . . . . . . . . . . . . 10 2.7 Cell-Decomposition . . . . . . . . . . . . . . . . . . . . . . . . . . 10 2.8 Spatial-Occupancy Enumeration . . . . . . . . . . . . . . . . . . 10 2.9 Octrees . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11 2.10 Constructive Solid Geometry . . . . . . . . . . . . . . . . . . . . 11 3 Aufbau des Packetes 13 3.1 Die Klassen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13 3.1.1 Interface J3DBoolop . . . . . . . . . . . . . . . . . . . . . 13 3.1.2 ConvexSurfaceBoolop . . . . . . . . . . . . . . . . . . . . 14 3.1.3 AnySurfaceBoolOp . . . . . . . . . . . . . . . . . . . . . . 14 3.1.4 Interface TriangleOptimzer . . . . . . . . . . . . . . . . . 14 3.1.5 SimpleMerge . . . . . . . . . . . . . . . . . . . . . . . . . 14 3.1.6 Triangle . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14 3.1.7 MyBoundingBox . . . . . . . . . . . . . . . . . . . . . . . 15 3.1.8 Line . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15 3.1.9 Ray . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16 3.1.10 GeometryConverter . . . . . . . . . . . . . . . . . . . . . 16 3.2 Verwendung des Packetes . . . . . . . . . . . . . . . . . . . . . . 16 3.2.1 Fehler . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17 4 Beschreibung der Algorithmen 19 4.1 Allgemeine Funktionsweise . . . . . . . . . . . . . . . . . . . . . . 19 4.1.1 Zusamenstellung der Listen . . . . . . . . . . . . . . . . . 20 4.2 Alogrithmen in der Klasse Triangle . . . . . . . . . . . . . . . . . 21 4.2.1 Berechnug des Schnittpunktes Line - Ebene . . . . . . . . 22 4.2.2 Bestimmung der Lage eines Schnittpunktes . . . . . . . . 22 4.2.3 Orientierung zu einem anderen Dreieck . . . . . . . . . . 22 4.2.4 Berechnung der Distanz zu einem Punkt . . . . . . . . . . 23 4.2.5 Bestimmung der neu entstehenden Dreiecke . . . . . . . . 23 4.2.6 Die Methode cut . . . . . . . . . . . . . . . . . . . . . . . 24 4.3 Algorithmen in der Klasse AnySurfaceBoolOp . . . . . . . . . . . 25 4.3.1 Schneiden der Dreiecke . . . . . . . . . . . . . . . . . . . . 25 4.3.2 Einordnen der Dreieck . . . . . . . . . . . . . . . . . . . . 26
  • 4. INHALTSVERZEICHNIS 3 4.3.3 Toleranzen . . . . . . . . . . . . . . . . . . . . . . . . . . 26 4.4 Algorithmen in der Klasse ConvexSurfaceBoolOp . . . . . . . . . 27 4.4.1 Einordnen der Dreieck . . . . . . . . . . . . . . . . . . . . 27 4.4.2 Toleranzen . . . . . . . . . . . . . . . . . . . . . . . . . . 27 4.5 Fehler und Performance . . . . . . . . . . . . . . . . . . . . . . . 28 5 Testumgebungen 30 5.1 Darstellung in Mapple . . . . . . . . . . . . . . . . . . . . . . . . 30 5.2 Kontrolle der Schnitte . . . . . . . . . . . . . . . . . . . . . . . . 30 5.3 Das Visualisationstool . . . . . . . . . . . . . . . . . . . . . . . . 30 5.3.1 Kurze Bedinungsanleitung . . . . . . . . . . . . . . . . . . 30 6 Schluss 33 7 Ehrlichkeitserkl¨rung a 35
  • 5. 1 Einleitung 4 1 Einleitung Boolesche Operatoren k¨nnen auf solide K¨rper angewandt werden und Resul- o o tieren wiederum in soliden K¨rpern. Die Operationen die dabei zur Verf¨gung o u stehen sind die Vereinigung, die Differenz und die Schnittmenge. Diese Opera- toren werden verwendet um neue K¨rperformen zu generieren. Diese Methode o findet in 3D Entwicklungsumgebungen eine breite Anwendung. Im Rahmen unserer Semesterabeit ging es darum, diese Operatoren f¨r das u Produkt C3dQ von CCT zu implementieren. Bei C3dQ1 handelt es sich um einen Viewer, der zur Darstellung von 3D-Modellen verwendet wird. Dieser Viewer un- terst¨tzte bis Dato die Booleschen Operatoren nicht. u Bei der Integration der Booleschen Operatoren in das C3dQ wurden zwei L¨sungs- o ans¨tze vorgegeben. Die beiden L¨sungsans¨tze basieren auf verschiedenen Re- a o a pr¨sentationen der K¨rper im 3D Modell. Der eine Ansatzt setzt dabei auf der a o Repr¨sentation mittels B-Reps an, w¨hrend der zweite Ansatz auf einer L¨sung a a o mit NURBS2 basiert. Als Ausgangslage diente uns die Diplomarbeit von Christian Miest und Peter Langhart (“Boolean Operators For Nurbs Using Java 3D“). In dieser Diplom- arbeit wurde der erstere Ansatz teils gel¨st. Die Implementation von Miest und o Langhart wies allerdings zu Beginn unserer Semesterarbeit noch Fehler auf. Die Booleschen Operationen wurden im Zuge der Diplomarbeit in das Datenmodell von C3dQ integriert, die Darstellung der resultierenden K¨rper war allerdings o fehlerbehaftet. Die urspr¨ngliche Zielsetzung unserer Semesterarbiet war es, die Fehler in u der Bestehenden L¨sung zu eliminieren und uns anschliessend auf den L¨sungs- o o ansatz mit NURBS zu konzentrieren. Da die Form dieser Semesterarbiet nicht ein spezifischer Auftrag sondern mehr eine Studie war, wurden die Zielsetzungen in regelm¨ssigen Sitzungen angepasst. Grund f¨r diese Form war, dass man die a u Machbarkeit dieser Ans¨tze nicht garantieren konnte, insbesondere konnte man a nicht voraussagen, ob die L¨sungen in n¨tzlicher Frist realisiert werden konnten. o u Beim L¨sen des ersten Ansatzes bevorzugten wir es ein Packet losgel¨st von o o C3dQ zu entwickeln, dass aber anschliessend leicht in das Programm integriert werden konnte. Das Packet setzte dabei auf dem L¨sungsansatz von Booleschen o Operatoren auf B-Reps an, wie sie in Java 3D verwendet werden um K¨rper o darzustellen. Die L¨sung mit NURBS blieb unrealisiert, da insbesondere die Behandlung von o Spezialf¨llen in der L¨sung mit B-Reps sehr viel Zeit in Anspruch nahm. a o Das Packet wird im Nachzug unserer Semesterarbeit von Samuel Gerber vor Ort bei CCT in Griechenland in C3dQ integriert. 1 See 3d and Query 2 Non Unified Rational B-Splines
  • 6. 1 Einleitung 5 ¨ Nachfolgend wird in diesem Bericht eine Ubersicht uber die Darstellung von ¨ o u ¨ soliden K¨rpern gegeben. Dieser Teil soll eine einf¨hrende Ubersicht uber ver- ¨ schiedene Repr¨sentationsarten von soliden K¨rpern im Raum geben. Ansch- a o liessend wird unser L¨sungsansatz ausf¨hrlich beschrieben. o u Dieses Dokument richtet sich an Personen, die das Packet f¨r ihre eigenen u Zwecke anwenden wollen, und tiefergreifendere Informationen wollen als die Ja- vadokumentation bietet. Insbesondere ist diese Dokument an Personen gerichtet, die an diese Arbeit ankn¨pfen wollen. u An dieser Stelle sei auch Dank an die betreuenden Dozenten M. Vogel und T. Jakob ausgesprochen, die uns w¨hrend der Semesterarbeit mit Tat und Rat a unterst¨tzt haben. u
  • 7. 2 Solid Modeling 6 2 Solid Modeling F¨r eine breite Palette von Anwendungen wird die Repr¨sentation von Soli- u a den K¨rpern ben¨tigt. Oft ist es wichtig zwischen Innen- und Aussenseite ei- o o nes K¨rpers zu unterscheiden, z.B. um Kollisionen von K¨rpern zu detektieren, o o um Lichtbrechungen zu berechnen und entsprechend darzustellen oder bei der Finite-Elemente-Analyse um Belastungen und Temperaturen zu berechnen. ¨ Die Nachfolgende Ubersicht stellt eine Zusammenfassung des Kapitels “Solid Modeling“ aus dem Standardwerk von Foley [4] dar. Hier sollen die M¨glichkeint o zur Darstellung solider K¨rper beschrieben werden. Dabei wird insbesondere o auf die verschiedenen Repr¨sentationsarten eingegangen, wo grunds¨tzlich zwi- a a schen Boundary- und Spatial-Partitioning-Repr¨sentation unterschieden wird. a Erl¨utert wird auch die Eignung der jeweiligen Repr¨sentation f¨r Boolesche a a u Operatoren. 2.1 Repr¨sentationen a An die Repr¨sentation werden gewisse Anspr¨che gestellt. Je nach Anwendung a u muss man Kompromisse eingehen, da entweder auf Performance oder Genau- igkeit verzichtet werden muss. Aus diesem Grund werden in einem Modeling- System oft mehrere Repr¨sentationen verwendet. a Eine Repr¨sentation kann nur eine gewisse Klasse von Objekten darstellen. a Sehr anschaulich wird dies am Beispiel des Instance-Modeling dargestellt. Da- bei k¨nnen nur eine definierte Anzahl von Primitiven instanziert und f¨r die o u Dartstellung verwendet werden. Eine Repr¨sentation muss unmissverst¨ndlich sein. Bei der Repr¨sentation a a a eines W¨rfels mittels seiner Kannten ist z.B. nicht gegeben, ob es sich dabei um u ein Gitternetz oder um einen soliden W¨rfel handelt. Entsprechende Informa- u tionen m¨ssen in der Repr¨sentation enthalten oder grunds¨tzlich definiert sein. u a a Die Eindeutigkeit einer Repr¨sentation sagt aus, ob f¨r ein gegebenes Objekt a u die Repr¨sentation immer die selbe ist. Per Definition ist somit eine Repr¨sen- a a tation eindeutig, wenn f¨r jedes gegebene Objekt nur eine einzige Encodierung u m¨glich ist. Dabei ist das Objekt durch Lage, Form und Orientierung definiert. o Repr¨sentationen unterscheiden sich auch in der Genauigkeit in welcher a K¨per dargestellt werden k¨nnen. Oft k¨nnen K¨rper nur approximiert werden. o o o o Weiter unterscheiden sich Repr¨sentationen in der Einfachheit der Darstellung a und somit auch in der Kompaktheit. Kompakte Repr¨sentationen sind insbe- a sondere bei verteilten Systemen w¨nschenswert. u
  • 8. 2.2 Boolesche Operatoren 7 2.2 Boolesche Operatoren Die Booleschen Operatoren sind eine einfache und intuitive M¨glichkeit um o Objekte miteinander zu Verkn¨pfen. Aus den Booleschen Operatoren entstehen u neue Objekte in der Form von Vereinigungen, Differenzen und Schnitten der Urspr¨nglichen Objekte wie in Abb. 1 gezeigt. u Abbildung 1: Boolesche Operatoren: (a) Objekte A und B, (b) A ∪ B, (c) A ∩ B, (d) A − B, (e) B − A Als Resultat von Booleschen Operationen auf solide K¨rper erwartet man, o dass man wiederum einen soliden K¨rper erh¨lt. Dies ist bei den normalen Boo- o a leschen Operatoren nicht der Fall. Ber¨hren sich, z.B. zwei W¨rfel nur mit einer u u Grenzfl¨che so ist das Resultat ein Rechteck. Aus den normalen Booleschen Ope- a ratoren k¨nnen so solide K¨rper, Fl¨chen, Linien, Punkte und das Null-Objekt o o a entstehen. F¨r unsere Zwecke verwenden wir deshalb die regul¨ren Booleschen Opera- u a toren [1]. Diese f¨hren zu einem soliden K¨rper oder zum Null-Objekt. u o 2.3 Primitiven-Instanzierung Bei der Primitiven-Instanzierung enth¨lt das Modelierungssystem einen be- a grenzten Satz von parametrisierten Objekten. Als Beispiel k¨nnen Zahnr¨der o a angegeben werden. Zahnr¨der werden definiert durch einen Radius, die Dicke, a einer Anzahl von Z¨hnen und die Form der Z¨hne. Die Repr¨sentation von a a a Primitiven-Instanzierung bietet keine M¨glichkeit Objekte mit Booleschen Ope- o ratoren zu kombinieren. 2.4 Sweep Repr¨sentation a Bei der Sweep Repr¨sentation werden 2D-Fl¨chen einer definierten Kurve ent- a a lang gef¨hrt. Den Raum den die Fl¨che ducrhf¨hrt, bildet den resultierenden u a a K¨rper. Folgt die 2D-Fl¨che einer linearen Bahn, so spricht man von einem o a translationalen Sweep oder Extrusions-Sweep (siehe Abb. 3). Bei Rotations- Sweeps wird die 2D-Fl¨che um eine definierte Achse rotiert und bildet so einen a Rotationsk¨rper. Die generelle Form der Sweeps ¨ndert beim Entlangfahren der o a
  • 9. 2.4 Sweep Repr¨sentation a 8 Abbildung 2: Zwei Zahnr¨der definiert mit Primitive Instancing a 2D-Fl¨che an der Kurve die Form der 2D-Fl¨che. Diese sog. generellen Sweeps a a resultieren nicht in einem Soliden K¨rper, wenn die 2D-Fl¨che koplanar zu sich o a selbst verschoben wird. Das Resultat einer Booleschen Operation auf Sweeps stellt im Normalfall kei- nen einfachen Sweep dar und eignet sich deshalb auch nicht zur Anwendung der Booleschen Operatoren. Abbildung 3: Sweeps. (a) 2D Fl¨chen um (b) translationale Sweeps und (c) a rotationale Sweeps zu generieren.
  • 10. 2.5 Boundary Repr¨sentation a 9 2.5 Boundary Repr¨sentation a Bei der Boundary Representation3 werden solide K¨rper durch ihre Grenz- o fl¨chen definiert. Bei der Boundary Repr¨sentation werden oft Polygone als a a Fl¨chenelemente verwendet. Geschwungene Formen k¨nnen dadurch nur apro- a o ximiert werden. Eine Spezialisierung der Boundary Repr¨sentation ist die Darstellung mit a Polyedern. Ein Polyeder ist ein solider K¨rper, der nur durch Polygone begrenzt o wird. Eine weitere Spezialisierung ist die Winged-Edge Repr¨sentation. Hier wird a jede Kannte des K¨rpers durch Pointer auf die Eckpunkte der Kannte definiert. o Weiter verweist die Kante auf die anliegenden Fl¨chen und auf jeweils zwei a austretende Kanten an den Eckpunkten. Diese Repr¨sentation erm¨glicht es a o Punkte und Fl¨chen die mit einer Kante assoziiert sind in konstanter Zeit zu a bestimmen. 2.5.1 Ansatz f¨ r Boolesche Operatoren auf B-Reps u Der Ansatz die Booleschen Operatoren auf diese Repr¨sentationen anzuwen- a den besteht darin jedes Polygon zu untersuchen und n¨tigenfalls zu schneiden. o Anschliessend werden alle Polygone darauf hin untersucht, ob sie relativ zum zweiten Objekt innerhalb oder ausserhalb liegen. Die Polygone werden klassi- fiziert in Polygone, die komplett innerhalb, komplett ausserhalb oder auf der Oberfl¨che des schneidenden K¨rpers liegen. Um ein Polygon zu klassifizieren a o folgt man der Normalen der Polygonfl¨che. Schneidet der Strahl dabei kein Po- a lygon der zweiten Figur, so befindet sich das Polygon ausserhalb. Schneidet der Strahl ein Polygon, so werden die Richtungen der Normalenvektoren der beiden Polygone mittels Kreuzprodukt untersucht. Ein positives Kreuzprodukt indiziert, dass das originale Polygon innerhalb des Objektes liegt. Bei einem negativen Kreuzprodukt liegt das originale Polygon ausserhalb des Objektes. Die weiteren Polygone k¨nnen klassifiziert werden, indem man den Nachbarn o ¨ von klassifizierten Polygonen folgt. Uberschreitet man keine Randpolygone, so erh¨lt das Nachbarpolygon die gleiche Klassifizierung. a 2.5.2 Nicht polyedrale B-Reps Wie bereits erw¨hnt k¨nnen mit Polyedern gekr¨mmte Fl¨chen nur aproximiert a o u a werden. Ein Ansatz besteht darin, B-Reps mit Fl¨chen, die durch Kurven defi- a niert werden, darzustellen. Um Boolesche Operatoren auf solche Fl¨chen anzuwenden, wurden Algorithmen a entwickelt, die mit nicht abgeschlossenen K¨rpern umgehen k¨nnen. o o 3 kurz B-reps
  • 11. 2.6 Spatial-Partitioning Representations 10 2.6 Spatial-Partitioning Representations Bei dieser Art der Repr¨sentation wird ein solider K¨rper in eine Sammlung a o von angrenzenden K¨rpern zerlegt, welche primitiver sind als der urspr¨ngliche o u K¨rper. Diese Primitiven k¨nnen in gr¨sse Position und Paramter variieren. o o o 2.7 Cell-Decomposition In einem System, in dem die Repr¨sentation der Cell-Decomposition angewen- a det wird, besteht ein Set von parametrisierten, primitiven Objekten, den sog. Zellen. Diese Zellen werden “aneinander geklebt“ um den gew¨nschten K¨rper u o darzustellen. Diese Form der Repr¨sentation ist allerdings nicht eindeutig, d.h. a en K¨rper kann auf verschiedene Arten zusammengef¨gt werden. o u 2.8 Spatial-Occupancy Enumeration Die Spatial-Occupancy Enumeration ist ein Spezialfall der Cell-Decomposition. Hier werden immer gleiche Zellen verwendet, die in einem Raster angeordnet sind. Die Zellen werden Voxels (Volumen-Elemente) genannt, in Analogie zu den Pixels. In dieser Darstellung wird also nur unterschieden, ob ein Voxel vorhanden ist oder nicht. Alle K¨rper, die nicht aus Kanten rechtwinklig zu den Koordina- o tenachsen bestehen, m¨ssen mit dieser Darstellungsform approximiert werden. u Entsprechend ist f¨r eine saubere Darstellung eine hohe Aufl¨sung n¨tig, welche u o o eine grosse Datenmenge zur Folge hat. Boolesche Operatoren lassen sich auf Objekte in dieser Repr¨sentation einfach a und intuitiv anwenden. Es handelt sich dabei um einfach Mengenoperationen auf die Zellen. Abbildung 4: Darstellung eines Torus mittels Spatial-Occupancy Enumeration
  • 12. 2.9 Octrees 11 2.9 Octrees Octrees sind eine hierarchische Variante der Spatial-Occupancy. Das Bild wird zuerst durch eine einzige Zelle repr¨sentiert, welche das ganze Objekt einsch- a liesst. Die Zelle wird so lange in Oktanten unterteilt, bis ein Oktant komplet ausserhalb des Objektes liegt oder ein Grenzwert von Unterteilungen erreicht worden ist. Ein Oktant wird je nach Deckungsgrad mit dem Objekt schwarz, weiss oder grau markiert. Weisse und schwarze Oktanten werden nicht mehr weiter unterteilt, w¨hrend graue Oktanten rekursiv untersucht werden m¨ssen. a u Diese Repr¨sentation kann in einem Baum dargestellt werden. Der Baum enth¨lt a a dabei weisse, schwarze und graue Knoten. Blattknoten k¨nnen dabei nur schwarz o oder weiss sein. Die Booleschen Operationen lassen sich direkt im Baum anwenden. Abbildung 5: Objekt dargestellt mittels (a) Spatial-Occupancy Enumeration und (b) mittels Quadtree. 2.10 Constructive Solid Geometry In einem CSG-Baum werden primitive Typen mit Booleschen Operatoren ver- bunden. Die Blattkonten sind primitive Typen, w¨hrend Nicht-Blattknoten Boo- a lesche Operatoren oder Transformationen enthalten. Der Baum wird mit depth- first-search traversiert um das Objekt darzustellen.
  • 13. 2.10 Constructive Solid Geometry 12 Abbildung 6: CSG-Baum
  • 14. 3 Aufbau des Packetes 13 3 Aufbau des Packetes In folgendem Abschnitt wird das Packet beschrieben. Die einzelnen Klassen werden kurz beschrieben und die wichtigsten Methoden erl¨utert. Anschlies- a send wird erkl¨rt wie das Packet verwendet werden kann. a F¨r Anwender dieses Packetes steht auch ein detaillierte Javadokumentation u uber das API4 des Packetes zur Verf¨gung. ¨ u Das Packet arbeitet mit dem Java 3D 1.3 API [6]. Um dieses Kapitel zu verstehen sollten grunds¨tzliche Kenntnisse von Java 3D vorhanden sind. a 3.1 Die Klassen Das Packet besteht aus den Klassen Triangle, Line, Ray, AnyBoolOp, Con- vexBoolop, GeometryConverter, MyBoundingBox und SimpleMerge sowie dem Interface J3Boolop und TriangleOptimizer. Abbildung 8 zeigt das Klassendiagramm des Packetes. 3.1.1 Interface J3DBoolop Das Interface Boolop ist die Schnittstelle um mit dem Packet zu arbeiten. Es stellt folgende drei Methoden zur Verf¨gung: u • void calculateNewSurface(TriangleArray l, TriangleArray r, int operator, TriangleOptimizer optimizer) Mit dieser Methode wird aus l und r eine neue Oberfl¨che berechnet, mittels der Booleschen Operation die mit ope- a rator spezifiziert wird. Mit l und r wird bezeichnet welche Oberfl¨che links a (l) und welche rechts (r) des Operators steht. Die TriangleArrays m¨ssen u jeweils Farbe und Normalen haben, und die entsprechenden Capabilities um die Koordinaten, Anzahl Punkte, Normalen sowie die Farbe zu lesen. Das heisst es muss jeweils f¨r : u – ALLOW COORDINATE READ – LLOW NORMAL READ – ALLOW COUNT READ – ALLOW COLOR READ die Methode setCapability des jeweiligen TriangleArays aufgerufen wer- den (falls diese noch nicht gesetzt sind). Der TriangleOptimizer Parameter kann entweder null sein, wenn keine Optimierung der geschnittenen Drei- ecke stattfinden soll. Oder es kann eine entsprechende Klasse ubergeben ¨ werden, die die resultierenden Dreiecke optimiert. 4 Application Programming Interface
  • 15. 3.1 Die Klassen 14 • void setOperator(int operator) Mit dieser Methode kann der Boolesche Operator ge¨ndert werden. Die Operation ben¨tigt keine neue Berech- a o nung, es m¨ssen nur die entsprechenden Listen kombiniert werden. u • TriangleArray getResultingSurface() Diese Methode gibt die neu resul- tierende Oberfl¨che zur¨ck die mit oben genannter Methode berechnet a u wurde. Die beiden Klassen AnySurfaceBoolOp und ConvexSurfaceBoolOp implemen- tieren diese Schnittstelle. 3.1.2 ConvexSurfaceBoolop Diese Klasse kann verwendet werden um Boolesche Operatoren auf geschlos- sene konvexe Oberfl¨chen anzuwenden. Diese Klasse funktioniert aufgrund des a verwendeten Algorithmus zur Bestimmung ob ein Dreieck innerhalb oder aus- serhalb liegt, nur f¨r konvexe Oberfl¨chen. Ist dadurch jedoch performanter als u a die Klasse AnySurfaceBoolOp. 3.1.3 AnySurfaceBoolOp Diese Klasse ist geeignet, um Boolesche Operatoren auf jegliche geschlossene Oberfl¨chen anzuwenden. Da der Algorithmus, der bestimmt ob ein Dreieck a innerhalb oder ausserhalb liegt, aufwendiger ist erh¨ht sich die Laufzeit zur o Berechnug der neuen Oberfl¨che betr¨chtlich. a a 3.1.4 Interface TriangleOptimzer Dieses Interface wird verwendet um eine Liste von Dreiecken zu optimieren. Das heisst, dass die Anzahl der Dreiecke vermindert wird, ohne die Geometrie, die die Dreiecke darstellen, zu ver¨ndern. a 3.1.5 SimpleMerge Diese Klasse ist ein TriangleOptimizer der versucht benachbarte Dreiecke zu vereinen, sofern dies M¨glich ist. o 3.1.6 Triangle Die Klasse Triangle representiert ein Dreieck im dreidimensionalen Raum. Mit Hilfe dieser Klasse werden die Dreiecke der beiden Oberfl¨chen geschnitten und a in neue Dreicke unterteilt. Die Klasse bietet Methoden an die, das Schneiden von Dreiecken, das Berech- nen von Distanzen zu Punkten, sowie die Berechnung von Schnittpunkten mit Linien und Strahlen erm¨glichen. o Ein Dreieck wird representiert durch (siehe auch Figur 7):
  • 16. 3.1 Die Klassen 15 Abbildung 7: Representation des Dreiecks • Winkel um zu bestimmen ob ein Punkt innerhalb oder ausserhalb liegt: cosA, cosB • Linen der Kanten: lines[3] (Array aus drei Linien) • Eckpunkte: p1, p2, p3 • Normalen f¨r jeden Eckpunkt: norm1, norm2, norm3 u • Normale zur Ebene: normal   x • Mathematische Representation einer Ebene: normal ∗  y  = D z 3.1.7 MyBoundingBox Die Klasse MyBoundingBox wird ben¨tigt um zu uberpr¨fen, ob sich zwei Ob- o ¨ u jekte ber¨hren. Die BoundingBox ist achsenparallel zum Koordinatensystem, u dadurch werden nur zwei Punkte ben¨tigt um die Box zu repr¨sentieren. Des o a weiteren erlaubt die Achsenparallelit¨t eine performante Implementation der a Algorithmen um zu pr¨fen, ob sich zwei BoundingBoxen ber¨hren, sowie die u u Pr¨fung ob die BoundingBox ein anderes Objekt enth¨lt oder ber¨hrt. u a u 3.1.8 Line Die Klasse Line stehlt eine Linie im dreidimensionalen Raum dar. Eine Line wird dargestellt durch einen Startpunkt sowie einem Vektor. Wird der Vektor
  • 17. 3.2 Verwendung des Packetes 16 zum Startpunkt addiert erh¨lt man den Endpunkt. Der Vektor zeigt also in a Richtung des Endpunkts und die L¨nge des Vektors entspricht der L¨nge der a a Linie. 3.1.9 Ray Die Klasse Ray stellt einen Strahl im dreidimensionalen Raum dar. Ein Strahl wird durch einen Startpunkt sowie eine Vektor, der die Richtung des Strahls festh¨lt, repr¨sentiert. a a 3.1.10 GeometryConverter Die Klasse GeometryConverter ist eine Hilfsklasse die es erlaubt verschiedene Java 3D GeometryArray Typen (QuadArray, TriangleStripArray, . . . ) in einen Java 3D TriangleArray zu konvertieren. 3.2 Verwendung des Packetes Um das Packet zu verwenden, muss eine Klasse die das Interface J3DBoolop im- plementiert, erzeugt werden. Im Packet stehen dazu die Klasse AnySurfaceBoo- lOp und ConvexSurfaceBoolOp zur Verf¨gung. Anschliessend kann die Methode u combineSurface aufgerufen werden. Mit getResultingSurface kann der resultie- rende TriangleArray abgerufen werden. Die Methode combineSurface erwartet zwei TriangleArrays. Um von anderen GeometryArrays umzuwandeln, steht die Klasse GeometryConverter zur Verf¨gunng. u Das folgende Code Fragment soll die Anwendung illustrieren. ... TriangeStripArray tsa = someSurface(); QuadStripArray qsa = anOtherSurface(); TriangleArray l = GeometryConverter.createTriangles(tsa); //If tsa has no color call: //Color3f cl=new Color3f(1, 0, 0); //TriangleArray l = GeometryConverter.createTriangles(tsa, cl); TriangleArray r = GeometryConverter.createTriangles(qsa); //If qsa has no color call: //Color3f cr=new Color3f(0, 1, 0); //TriangleArray r = GeometryConverter.createTriangles(qsa, cr); //Set the needed Capabilities l.setCapability(GeometryArray.ALLOW_COORDINATE_READ); l.setCapability(GeometryArray.ALLOW_NORMAL_READ); l.setCapability(GeometryArray.ALLOW_COUNT_READ); l.setCapability(GeometryArray.ALLOW_COLOR_READ); r.setCapability(GeometryArray.ALLOW_COORDINATE_READ); r.setCapability(GeometryArray.ALLOW_NORMAL_READ);
  • 18. 3.2 Verwendung des Packetes 17 r.setCapability(GeometryArray.ALLOW_COUNT_READ); r.setCapability(GeometryArray.ALLOW_COLOR_READ); //Create a Boolen Operator and calculate the Differnce from l to r J3DBoolop bool = new AnySurfaceBoolOp(); bool.combineSurfaces(l,r J3DBoolop.DIFFERENCE, null); //l - r TriangleArray res = bool.getResultingSurface(); .... 3.2.1 Fehler Bei Oberfl¨chen die aus sehr kleinen Dreiecken bestehen kann es vorkommen, a dass Dreiecke falsch klassifiziert werden. Dadurch erscheinen nach der Boole- schen Operation, Dreiecke die nicht dargestellt werden sollten. Im Kapitel 4.5 wird noch detailliert auf diese Fehler eingegangen.
  • 19. 3.2 Verwendung des Packetes 18 Abbildung 8: Klassendiagramm
  • 20. 4 Beschreibung der Algorithmen 19 4 Beschreibung der Algorithmen In diesem Kapitel wird im Detail auf die Algorithmen eingegangen. Der Leser sollte mit dem Java 3D 1.3 API [6] vertraut sein, da Klassen aus diesem API verwendet werden. Die Prinzipien die den Algorithmen zugrunde liegen, ben¨tigen jedoch keine Kenntnisse des Java 3D 1.3 API. Kenntnisse in o linearer Algebra sind jedoch von Vorteil um die Algorithmen zu verstehen. 4.1 Allgemeine Funktionsweise Der allgeimene Ansatz ist leicht erkl¨rt, er besteht grunds¨tzlich aus drei Schrit- a a ten. Nehmen wir an wir wollen die Oberfl¨chen A und B schneiden, dann sieht a der Ablauf wie folgt aus: 1. Es wird jedes Dreick von A mit B geschnitten, anschliessend jedes von B mit A. 2. Die neuen Dreieck von A werden bez¨glich der Orientierung zu B in Listen u f¨r A einsortiert (innen von B, ausssen von B, sowie Spezialf¨llen wenn u a zwei Dreiecke koplanar sind) und umgekehrt. 3. Die Dreiecke werden aus den verschiedenen Listen (je nach Operatoren) zu einer neuen Oberfl¨che zusammengef¨gt. a u Diese drei Schritte sind sowohl in der Klasse AnySurfaceBoolOp wie auch in der Klasse ConvexSurfaceBoolOp gut ersichtlich. Folgende Codeauschnitte aus AnySurfaceBoolOp sollen dies verdeutlichen. Schneiden und Bestimmung der Orientierung (einsortieren in die entspre- chenden Listen): private void calculateNewSurface(List origL, List origR, MyBoundingBox boundsL, MyBoundingBox boundsR) { //List of new triangles with cuts List newLeft = new LinkedList(); List newRight = new LinkedList(); //Split left TriangleArray in inside //and outside right TriangleArray split(origL, origR, boundsR, newLeft); //Split right TriangleArray in inside //and outside left TriangleArray split(origR, origL, boundsL, newRight);
  • 21. 4.1 Allgemeine Funktionsweise 20 //Check orientation of triangles from right Triangles decideOrientation(origL, newRight, outsideR, insideR, bothSameR, bothDiffR, boundsL); //Check orientation of triangles from left Triangles decideOrientation(origR, newLeft, outsideL, insideL, bothSameL, bothDiffL, boundsR); } Zusammenstellen der entsprechenden Listen: private List difference() { List result = new LinkedList(outsideL); Iterator it = insideR.iterator(); while (it.hasNext()) { Triangle tmp = (Triangle) it.next(); result.add(tmp.invert()); } result.addAll(bothDiffL); return result; } private List intersect() { List result = new LinkedList(insideL); result.addAll(insideR); result.addAll(bothSameL); return result; } private List union() { List result = new LinkedList(outsideL); result.addAll(outsideR); result.addAll(bothSameL); return result; } 4.1.1 Zusamenstellung der Listen Im Programm verwenden wir folgende acht Listen: • outsideL • insideL • bothSameL • bothDiffL
  • 22. 4.2 Alogrithmen in der Klasse Triangle 21 • outsideR • insideR • bothSameR • bothDiffR In der Liste outsideL sind alle Dreiecke der linken Oberf¨che, welche ausser- a halb der rechten Oberfl¨che liegen. In der Liste outsideR sind alle Dreiecke der a rechten Oberf¨che, welche ausserhalb der linken Oberfl¨che liegen. a a In der Liste insideL sind alle Dreiecke der linken Oberf¨che, welche innerhalb a der rechten Oberfl¨che liegen. In der Liste insideR sind alle Dreiecke der rechten a Oberf¨che, welche innerhalb der linken Oberfl¨che liegen. a a In bothSameL werden jene Dreiecke von der linken Oberfl¨che gespeichert, a welche nicht eindeutig innerhalb oder ausserhalb der rechten Oberfl¨che liegen a (z.B. bei konplanren Dreiecken), aber aufgrund des Vergleiches der Normalen nur bei der Bildung der Schnittmenge oder der Vereinigung miteinbezogen wer- den m¨ssen. u In bothDiffL werden jene Dreieck gespeichert die ebenfalls nicht eindeutig innerhalb oder ausserhalb liegen, aber aufgrund des Vergleiches der Normalen nur bei der Differenz ber¨cksichtigt werden m¨ssen. u u In bothSameR und bothDiffR werden die Dreieck von der rechten Oberfl¨che a bez¨glich der linken, analog zu bothSameL und bothDiffL, gespeichert. u Dies ergibt nun folgende Kombinationen der Listen: bei Union: outsideL, outsideR, und bothSameL bei Intersect: insideL, insideR und bothSameL bei Difference: outsideL, insideR (hier m¨ssen bei insideR noch die Nor- u malen invertiert werden da diese in die entgegengesetzte Richtung zeigen), und botDiffL 4.2 Alogrithmen in der Klasse Triangle In der Klasse Triangle geschieht das eigentliche Schneiden der Dreieicke. Die Schnitte werden in der Methode cut, mithilfe einiger Methoden die hier be- schrieben werden, berechnet.
  • 23. 4.2 Alogrithmen in der Klasse Triangle 22 4.2.1 Berechnug des Schnittpunktes Line - Ebene Methode: public Point3f intersection(Line l, float intersectTol, float insideTol) Aufgrund der Darstellung des Dreieckes und der Linie (siehe auch Kapitel 3.1) kann mit der Gleichung (1) lamda berechnet werden. N ormale ∗ Startpunkt lamda = D − (1) Richtung ∗ N ormale Liegt nun lamda zwischen 0 und 1 liegt ein Schnittpunkt mit der Ebene vor. Es ist aber noch nicht bestimmt ob dieser innerhalb des Dreieckes liegt. Mit dem Parameter intersectTol kann bestimmt werden wieveil lamda unter 0 oder uber 1 sein kann um trotzdem noch zu schneiden. ¨ 4.2.2 Bestimmung der Lage eines Schnittpunktes Methoden: public bool liesInside(Point3f p, float intersectTol, float insideTol) private bool liesInside(Point3f p, float insideTol) Die Lage eines Punktes wird aufgrund der Cosinuswerte der Winkel berech- net (siehe auch Abbildung 9): • cosA1 = winkel zwischen linie 0 und der linie die mit p1 und p gebildet wird • cosA2 = winkel zwischen linie 2 und der linie die mit p1 und p gebildet wird • cosB1 = winkel zwischen linie 0 und der linie die mit p2 und p gebildet wird Wenn nun cosA1 und cosA2 kleiner cosA sind sowie cosB1 kleiner als cosB, liegt der Punkt innerhalb, ansonsten ausserhalb. Mit dieser Methode wird jedoch nicht gepr¨ft, ob der Punkt auch in der Ebene liegt. Dies ist im Fall eines u Schnittpunktes auch nicht n¨tig. Deshalb gibt es zwei Methoden um die Lage o eines Punktes zu bestimmen. Die eine ist public und berechnet zuerst noch die Distanz zur Ebene und anschliessend die Winkel. Die andere ist privat und berechnet die Distanz nicht. Der Parameter insideTol bestimmt um wieviel cosA und cosB beim Vergleich vergr¨ssert werden. o 4.2.3 Orientierung zu einem anderen Dreieck Methode: public int getOrientationTo(Triangle t, float tol)
  • 24. 4.2 Alogrithmen in der Klasse Triangle 23 Abbildung 9: Bestimmung der Lage Es wird die Distanz von jedem Punkt des zu bestimmenden Dreiecks zu dem bestimmenden Dreieck gemessen (siehe auch Kapitel 4.2.4). Wenn alle positiv sind, liegt das Dreieck ausserhalb. Wenn alle negativ sind, liegt das Dreieck innerhalb. In allen anderen F¨llen wird gepr¨ft ob die Dreiecke koplanar sind. a u Ist dies der Fall wird aufgrund der Normalen bestimmt ob das Dreieck zur Differenz oder zur Schnittmenge geh¨rt. o Der Parameter tol gibt an, wie gross die Distanz sein muss damit der Punkt als nicht auf dem Dreieck liegend klassifiziert wird. 4.2.4 Berechnung der Distanz zu einem Punkt Methode: public double distance(Point3f p) Die Distanz wird berechnet mit der Gleichung (2). normal ∗ punkt − D = dist (2) Die Distanz ist vorzeichenbehaftet, das heisst wenn der Punkt zu dem die Di- stanz gemessen wird in der Richtung der Normalen liegt, ist die Distanz positiv ansonsten negativ. 4.2.5 Bestimmung der neu entstehenden Dreiecke Methode: private List makeCut(Triangle t, float intersectTol, float insideTol, float same- PointTol, float orientTol)
  • 25. 4.2 Alogrithmen in der Klasse Triangle 24 Vorgehen: Triangle A = zu schneidendes Dreieck Triangle B = schneidendes Dreieck 1. Mit allen Linien von A wird untersucht ob ein Schnittpunkt in B entsteht. Falls ein Schnittpunkt entsteht, wird uperpr¨ft ob der Schnittpunkt nicht ¨ u ein Eckpunkt von A ist. Liegt der Schnittpunkt nicht auf einem Eckpunkt, wird der Schnittpunkt in Verbindung mit der Line, auf der er liegt, ge- speichert (darum ein Set key = Nummer der Line, value = Schnittpunkt). Ansonsten wird der Schnittpunkt als Eckpunkt gespeichert. 2. Falls in 1 nicht schon zwei verschieden Schnittpunkte gefunden wurden, wird mit allen Linen von B gepr¨ft, ob ein Schnittpunkt in A ensteht. Falls u in 1 schon ein Schnittpunkt entsteht, wird uberpr¨ft ob der gefundene ¨ u Schnittpunkt nicht schon existiert. Falls dieser nicht schon existiert, wird ein Schnittpunkt der innerhalb von A liegt gespeichert. Aus 1 und 2 entstehen nun folgende f¨nf F¨lle wie das Dreieck geschnitten u a werden kann (siehe auch Abbildung 10, das hellere Dreieck ist dasjenige das geschnitten wird): 1. Zwei Punkte auf Kanten 2. Ein Punkt auf einer Kante, einer innerhalb 3. Zwei Punkte innerhalb 4. Ein Punkt auf einem Eckpunkt, einer auf der Kante 5. Ein Punkt auf einem Eckpunkt, einer innerhalb 4.2.6 Die Methode cut In der Methode cut wird die Methode makeCut f¨r jedes Dreieck in der Liste u cutted augerfuen. Zu beginn befindet sich in der Liste cutted nur ein Dreieck (die eigene Referenz). In der Methode makeCut wird das Dreieck nun, mit Hilfe der in den obigen Abschnitten beschriebenen Methoden, geschnitten. Als Resultat wird eine Liste mit den geschnittenen Dreiecken zur¨ckgegeben. In der Liste u cutted werden diese anstelle des vorherigen Dreieckes eingetragen. Die Methode cut: public void cut(Triangle t, float intersectTol, float insideTol, float samePointTol, float orientTol) { List newCutted = new LinkedList(); Iterator it = cutted.iterator(); while (it.hasNext()) { Triangle current = (Triangle) it.next(); newCutted.addAll(current.makeCut(t, intersectTol, insideTol,
  • 26. 4.3 Algorithmen in der Klasse AnySurfaceBoolOp 25 Abbildung 10: Schnittf¨lle: (a) Fall 1, (b) Fall 2, (c) Fall 3, (d) Fall 4, (e) Fall 5 a samePointTol, orientTol)); it.remove(); } cutted = newCutted; } 4.3 Algorithmen in der Klasse AnySurfaceBoolOp In der Klasse AnySurfaceBoolOp werden alle Dreieck geschnitten und in die richtigen Listen eingeordnet. Sind die neuen Dreiecke berechnet, wird ein Tri- angleArray erstellt, der die neue Oberfl¨che representiert. a 4.3.1 Schneiden der Dreiecke Methode: private void split(List origL, List origR, MyBoundingBox rBounds, List new- Left) In der Methode split wird jedes Dreieck aus der Liste origL (der linken Oberfl¨che) mit allen Dreiecken aus der Liste origR (der rechten Oberfl¨che) a a geschnitten und anschliessend in die Liste newLeft eingetragen. Die Bounding- Box wird ben¨tig um zu uberpr¨fen, ob uberhaupt ein Schnitt m¨glich ist. o ¨ u ¨ o Diese Methode wird zweimal aufgerufen, da immer nur die Dreiecke aus origL geschnitten werden. Da die geschnittenen Dreiecke in einer separaten Liste abgespeichert werden, bleibt die urspr¨ngliche Oberfl¨che erhalten. Diese wird sp¨ter auch noch ben¨tigt u a a o um das Einordnen der Dreiecke in die entsprechende Listen zu vereinfachen und zu beschleunigen.
  • 27. 4.3 Algorithmen in der Klasse AnySurfaceBoolOp 26 4.3.2 Einordnen der Dreieck Methode: private void decideOrientation(List otherSurface, List toDecide, List toAddOut, List toAddIn, List toAddSame, List toAddDiff, MyBoundingBox bounds) Hier wird f¨r jedes Dreieck aus toDecide (der Oberfl¨che deren Dreiecke u a einsortiert werden sollen) ein Strahl berechnet der dem Mittelpunkt des Drei- eckes entspringt und in Richtung der Normalen des Dreieckes zeigt. Nun wird in jedem Dreieck aus der Liste otherSurface (der Oberfl¨che zu der die Dreiecke a einsortiert werden sollen) nach einem Schnittpunkt gesucht. Das Dreieck aus der Liste otherSurface das am n¨chsten bei dem momentan zu vergleichenden a Dreieck ist, wird gespeichert. Am Ende wird aufgrund des gefundenen Dreieckes die Orientierung entschieden. Wurde kein Dreieck vom Strahl getroffen, liegt das Dreieck ausserhalb. Wurde eines getroffen, muss aufgrund des Vergleiches der Normalen entschieden wer- den. Dies geschieht mit Hilfe des Vektorproduktes. Dies liefert den Cosinus des Winkels zwischen den beiden Geraden. Nun werden vier F¨lle unterschieden: a 1. cosinus = 1 und geringe Distanz =¿ Liste f¨r Differenz u 2. cosinus = −1 und geringe Distanz =¿ Liste f¨r Schnittmenge u 3. cosinus >= 0 =¿ Innerhalb 4. cosinus < 0 =¿ Ausserhalb 4.3.3 Toleranzen In der Klasse AnySurfaceBoolOp sind folgende Toleranzen definiert: • INTERSECTION TOLERANCE bestimmt bei Ber¨hrung zweier Dreie- u cke, ob ein Schnitt stattfindet oder nicht. • ORIENTATION TOLERANCE bestimmt wie sensitiv die Lage zu einem anderen Dreieck berechnet wird. • ORIENTATION TOLERANCE2 bestimmt den Schwellenwert, ab wann zwei Dreiecke als koplanar gelten. Diese Einordnung erfolgt aus einem Ver- gleich der Normalen. Ist das Kreuzprodukt der beiden Normalen gr¨sser o als dieser Schwellenwert oder kleiner als das Negative dieses Schwellenwer- tes, gelten die Dreiecke als koplanar. • INSIDE TOLERANCE bestimmt ob ein Punkt noch innerhalb oder aus- serhalb eines Dreieckes liegt. • SAMEPOINT TOLERANCE bestimmt wie nahe zwei Punkte liegen m¨ssen, u um als die selben betrachtet zu werden.
  • 28. 4.4 Algorithmen in der Klasse ConvexSurfaceBoolOp 27 All diese Toleranzen beinflussen, wie die Dreiecke geschnitten und sortiert wer- den. Die Default-Werte sollten nicht ver¨ndert werden, da diese f¨r die meis- a u ten F¨lle optimal sind. Die Default-Werte wurden mittels mehreren Tests eru- a iert. Sollten die Werte trotzdem einmal ver¨ndert werden m¨ssen, kann auf a u diese direkt zugegriffen werden, da die Felder public sind. Sie sollten jedoch nur ver¨ndert werden, wenn man den Code, in dem mit den Toleranzen gerechnet, a wird eingehend studiert hat. Ausser der Toleranz ORIENTATION TOLERANCE2, werden alle f¨r Aufrufe von Methoden aus der Klasse Triangle verwendet (siehe u Kapitel 4.2); 4.4 Algorithmen in der Klasse ConvexSurfaceBoolOp Die Klasse ConvexBoolop erlaubt nur konvexe Oberfl¨chen mit Booleschen Ope- a ratoren zu berechnen. Es wird jedoch nicht uberpr¨ft ob dies der Fall ist. Bei ¨ u Berechnungen mit nicht konvexen Oberfl¨chen entstehen daher falsche Resul- a tate. Das Schneiden der Dreiecke erfolgt wie bei der Klasse AnySurfaceBoolOp (siehe Kapitel 4.3), daher wird hier nur auf das Einordnen der Dreiecke einge- gangen. 4.4.1 Einordnen der Dreieck Methode: private void decideOrientation(List otherSurface, List toDecide, List toAddOut, List toAddIn, List toAddSame, List toAddDiff, MyBoundingBox bounds) Die Methode heisst gleich jedoch wird zur Bestimmung der Lage ein anderer Algorithmus verwendet. Es wird jedes Dreieck aus der Liste toDecide mit den Dreiecken aus der Liste otherSurface verglichen. Dies geschieht mittels der Methode getOrientationTo aus der Klasse Triangle (siehe Kapitel 4.2). Wird nun ein Dreieck als ausserhalb oder zur gemeinsamen Differenz oder zur gemeinsamen Schnittmenge markiert, wird es sogleich in die entsprechende Liste eingeordnet und mit dem n¨chs- a ten fortgefahren. Das Dreieck wird als innerhalb eingeordnet, falls es bei allen Vergleichen nie als ausserhalb eingordnet wurde. 4.4.2 Toleranzen In der Klasse ConvexSurfaceBoolOp sind folgende Toleranzen definiert: • INTERSECTION TOLERANCE bestimmt bei Ber¨hrung zweier Dreie- u cke, ob ein Schnitt stattfindet oder nicht. • ORIENTATION TOLERANCE bestimmt wie sensitiv die Lage zu einem anderen Dreieck berechnet wird. • INSIDE TOLERANCE bestimmt, ob ein Punkt noch innerhalb oder aus- serhalb eines Dreieckes liegt.
  • 29. 4.5 Fehler und Performance 28 • SAMEPOINT TOLERANCE bestimmt wie nahe zwei Punkte liegen m¨ssen u um als die selben betrachtet zu werden. All diese Toleranzen beinflussen, wie die Dreiecke geschnitten und sortiert wer- den. Die Default-Werte sollten nicht ver¨ndert werden, da diese f¨r die meis- a u ten F¨lle optimal sind. Die Default-Werte wurden mittels mehreren Tests eru- a iert. Sollten die Werte trotzdem einmal ver¨ndert werden m¨ssen, kann auf a u diese direkt zugegriffen werden, da die Felder public sind. Sie sollten jedoch nur ver¨ndert werden wenn man den Code, in dem mit den Toleranzen gerechnet a wird, eingehend studiert hat. Alle Toleranzen werden f¨r Aufrufe von Methoden aus der Klasse Triangle ver- u wendet (siehe Kapitel 4.2); 4.5 Fehler und Performance Die Berechnung von Booleschen Operation aufgrund von B-reps ist numerisch gesehen nicht optimal [3]. Bei unserer Implementation k¨nnen wenn Boolesche o Operationen auf Oberfl¨chen mit kleinen Dreiecken angewandt werden, manch- a mal Fehler auftreten. Genau genommen k¨nnen diese Fehler auftreten, sobald o Dreiecke verwendet werden, bei denen zwei Punkte sehr nahe beieinander liegen. Wir vermuten, dass aufgrund der geringen Distanzen zwischen den Punkten der Dreiecke, die Normalen nicht gen¨gend exakt bestimmt werden k¨nnen. u o Um dieses Problem zu l¨sen, gibt es verschiedene Ans¨tze. Anstelle mit float o a Werten zu rechnen, k¨nnte man double Werte verwenden. o Ein anderer Ansatz w¨hre zu uberpr¨fen, ob die resultierenden Dreiecke zusam- a ¨ u menh¨ngend sind. Dies k¨nnte zum Beispiel mit Hilfe eines Graphen geschehen, a o der die Dreiecke verbindet. Diejenigen Dreiecke die nun keine Verbindungen im Graphen haben, k¨nnten so rausgefiltert werden. o Ein schon teilweise implementierter Ansatz ist, dass die Dreiecke, die aus ei- ner Booleschen Operation resultieren, reduziert werden. Dazu bietet das Inter- face TriangleOptimizer jetzt schon die M¨glichkeit. Bei der Booleschen Ope- o ration kann ein Objekt, das diese Interface implementiert, mitgegeben werden. W¨hrend der Berechnug wird f¨r jede Liste des J3DBoolOp die Methode optim- a u ze(List l) des TriangleOptimizer aufgerufen. Dadurch kann vermieden werden, dass solche ung¨nstige Dreiecke entstehen. u Bez¨glich Performance haben wir einiges ausprobiert und implementiert. So u verwenden wir BoundingBoxes um zu uberpr¨fen ob ein Schnitt uberhaupt n¨tig ¨ u ¨ o ist. Auch beim Klassifizieren der Dreiecke kommen die BoundingBoxes zu Ein- satz. Des weiteren ertellten wir eine Variante, bei der die geschnittenen Dreiecke als Graphen dargestellt werden. Da die geschnittenen Dreiecke bez¨glich Lage u bestimmt sind, kann nun mittels depth-first-search uber den Graphen iteriert ¨ werden und so alle Dreiecke eingeordnete werden. Das Aufbauen des Graphen war jedoch aufwendiger als die Berechnung, die dadurch eingespart wurden. So-
  • 30. 4.5 Fehler und Performance 29 mit ist dieser L¨sungansatz bez¨glich Performance nicht zu empfehlen. o u Der Ansatz bietet jedoch die M¨glichkeit den oben beschriebenen Fehler zu o vermeiden, da die Dreiecke nicht uber einen Vergleich der Normalen eingeord- ¨ net werden. Aufgrund von Zeitmangel haben wir diesen Ansatz nicht weiter verfolgt. Er k¨nnte jedoch einfach in das bestehende Packet integriert werden. o Dazu muss nur eine neue Klasse, die das Interface J3DBoolOp implementiert, geschrieben werden. Das Schneiden kann aus den Klassen AnySurfaceBoolOp oder ConvexSurfaceBoolOp ubernommen werden. Das heisst, einzig die Metho- ¨ de decideOrientation der Klasse AnySurfaceBoolOp oder ConvexSurfaceBoolOp m¨sste ge¨ndert werden. Zus¨tzlich musste in der Klasse Triangle noch uber- u a a ¨ pr¨ft werden, ob die Dreiecke nach einem Schnitt die richtige Klassifizierung u aufweisen. Die jetzige Implementation st¨tzt sich nicht darauf, dass die Dreiecke u nach einem Schnitt richtig Klassifiziert sind. Daher kann nicht davon ausgegan- gen werden, dass die Klassifizierung stimmt. Ein Problem bei diesem Ansatz ist, dass Dreiecke die koplanar sind, nicht in die richtige Liste eingeordnet werden k¨nnen (da das einordnen uber die Schnei- o ¨ denden Dreiecke erfolgt, zu diesem Zeitpunkt weiss mann nicht ob das Dreieck allenfalls koplanar ist). Dieser Fall tritt zwar nur ein wenn zwei Oberfl¨chen sich a ber¨hren, doch auch dieser Spezialfall sollte abgedeckt werden. u Optimierungen bez¨glich Performance und Speicherbedarf, k¨nnen allenfalls u o noch durch umschreiben des Codes erzielt werden. Wie zum Beispiel das beim Schneiden der Dreieck zweimal durch alle Dreiecke der beiden Oberfl¨chen ite- a riert wird. Auch die Liste zum speichern der geschnitten Dreiecke ist nicht unbedingt not- wendig. Durch solche Optimierungen wird jedoch die Leserlichkeit des Codes vermin- dert, weshalb wir davon abliessen.
  • 31. 5 Testumgebungen 30 5 Testumgebungen Um das Packet zu testen und nach Fehler zu suchen, schrieben wir einige kleine Programme. 5.1 Darstellung in Mapple In der Klasse DebugUtils befindet sich ein Methode mit der eine Liste von Drei- ecken in ein Maple5 Befehl geschrieben werden kann. In Maple muss dann noch die Bibiliothek plot (Befehl with(plots):) eingebunden werden. Anschliessend k¨nnen die Dreiecke in Mapple dargestellt werden. Dies war hilfreich um zu o testen, ob die Dreiecke richtig geschnitten und eingeordnet wurden. 5.2 Kontrolle der Schnitte Die Klasse TriangleTest schneidet Dreiecke so, dass alle m¨glichen Schnitf¨lle o a auftretten und schreibt f¨r jeden Schnitfall ein File mit dem Maple-Befehl, wel- u cher die geschnittenen Dreiecke darstellt. So kann uberpr¨ft werden, ob die ¨ u Schnitte richtig berechnet werden. 5.3 Das Visualisationstool Um das Packet Debugen zu k¨nnen, entwickelten wir ein kleines Programm das o verschiedene Oberfl¨chen darstellen und kombinieren kann (siehe auch Abb. a 11). Das Programm bietet ausser dem Darstellen der urspr¨nglichen Oberfl¨chen u a und der resultierende Oberfl¨che noch einiges mehr: a • Die Objekte k¨nnen interaktiv per Maus verschoben, rotiert und gezoomt o werden • Solide oder Drahtgitter Darstellung • Einstellen der Toleranzen • Interaktive Wahl des Booleschen Operators • Statistik uber Laufzeit der Berechnung. ¨ 5.3.1 Kurze Bedinungsanleitung Das obere Menu zeigt die Oberfl¨chen an die f¨r den linken (rot) und den rechten a u (gr¨n) Operand gew¨hlt werden k¨nnen. Durch Anklicken wird die entsprechen- u a o de Oberfl¨che im oberen Fenster dargestellt. a 5 Mathematikprogramm: http://www.maplesoft.com/
  • 32. 5.3 Das Visualisationstool 31 Das untere Menu bietet acht verschiedene Schaltfl¨chen an. Die Erste ist a ein Dropdown Menu mit dem der Operator festgelegt werden kann. Der But- ton Calculate berechnet die gew¨nschte Oberfl¨che. Die berechnete Oberfl¨che u a a wird dan im unteren Fenster dargestellt. Mit dem Button Settings k¨nnen die o Toleranzen eingestellt werden, und mit Show Statistics wird die Statistik f¨r u die letzte Berechnung angezeigt. Mit den beiden untersten Schaltfl¨che kann a die Geometrie aus dem unteren Fenster f¨r die gr¨ne oder rote Oberfl¨che, im u u a oberen Fenster, ubernommen werden. ¨ In beiden Fenster kann mit der Maus: • Mit gedr¨ckter rechter Maustaste die Oberfl¨che (¨ber der sich der Maus- u a u zeiger zum Zeitpunkt des dr¨cken befand)rotiert werden. u • Mit gedr¨ckter linker Maustatse die Oberfl¨che verschoben werden. u a • Mit gedr¨ckter linker Maustaste wird durch bewegen der Maus die ganze u Szene gezoomt.
  • 33. 5.3 Das Visualisationstool 32 Abbildung 11: Visualisierung
  • 34. 6 Schluss 33 6 Schluss Den Ansatz, f¨r den wir uns zu Beginn der Semesterarbeit entschieden haben, u das Package losgel¨st von C3dQ zu entwickeln, hat zu einem generell einsetzt- o baren Package mit einer einfachen Schnittstelle gef¨hrt. u Das Packet weist allerdings auch am Schluss der Semesterarbeit noch kleine- re Fehler auf, die in der Dokumentation zum Code erw¨hnt wurden. Wir k¨nnen a o an dieser Stelle lediglich Vermutungen f¨r m¨gliche Fehlerquellen angeben. u o Der L¨sungsansatz mit NURBS wurde im Zuge dieser Semesterarbeit kaum o behandelt. Wir haben einige Literatur uber NURBS [2][5] gelesen, hatten je- ¨ doch zuwenig Zeit uns vertieft in dieses Thema einzuarbeiten. Daher k¨nnen o wir so auch keine Aussage uber die Machbarkeit eines solchen Ansatzes in der ¨ Form einer Semesterarbeit machen. Wir empfehlen darum diesbez¨glich noch u Nachforschungen zu t¨tigen. a Das Packet wird im Anschluss an die Semesterarbeit bei CCT in Athen in die Applikation integriert.
  • 35. LITERATUR 34 Literatur [1] B. Br¨derlein. Computergrafik und Geometrisches Modellieren. Teubner, u 2001. [2] H.-J. Bungartz. Einf¨hrung in die Computergraphik. vieweg, 2002. u [3] D. Cazier. Reliable boolean operations on polyhedral solids thanks to 3d refinement. Technical report, Laboratoire des Sciences de l’Image, de l’Informatique et de la Tldtection Strassbourg, ? [4] J. D. Foley. Computer Graphics - Principle and Practice. Pearson - Addison Wesley, second international edition, 1997. [5] L. Piegl. The NURBS Book. Springer, second edition, 1997. [6] Sun, http://java.sun.com. Java 3D 1.3 API Documentation.
  • 36. 7 Ehrlichkeitserkl¨rung a 35 7 Ehrlichkeitserkl¨rung a Hiermit erkl¨ern wir, Urs Frick und Samuel Gerber, die vorliegende Semester- a arbeit selbstst¨ndig und unter Verwendung der aufgef¨hrten Hilfsmittel erstellt a u zu haben. Windisch, 25. Februar 2004 Urs Frick Samuel Gerber