close

Anmelden

Neues Passwort anfordern?

Anmeldung mit OpenID

Finite Element Method Quadtree-Verfahren Dr. Jamel

EinbettenHerunterladen
Finite Element Method
Quadtree-Verfahren
Dr. Jamel Tazarki
Diese Forschungsarbeit entstand am Institut für Mathematik
der Universität München.
Teil1
Inhalt
I. Vorwort und Zusammenfassung der Resultate
II. Problemstellung und Modellierung
- Grundlagen der finiten Elemente
III. Halbautomatischer Netzgenerator
- Beschreibung des Algorithmus
- Automatische Erzeugung der inneren Knoten
- Koordinatentransformation
- Funktion des Dreieck-Moduls
IV. Quadtree Codierungsverfahren
- Quadtree-Codierung
- Modifizierte Quadtree-Codierung
- Minimaler Quadtree
V. Die vollautomatische Netzgenerierung
- Netzkontrollparameter
- Diskretisierung der Randkanten
- Diskretisierung der inneren Bereiches
- Komprimierung
VI. Quadrate- und Randglättung
- Finite Element -Netztopologie mittels des modifizierten Quadtree
- Rechenzeit
VII. Anhang
- Modifizierter Octree-Netzgenerator
VIII. Literaturverzeichnis
Vorwort und Zusammenfassung der Resultate
Die vorliegende Arbeit handelt von Verfahren, die eine automatische Netzgenerierung auf geometrischen
Objekten allgemeiner Art ermöglichen. In Letzter Zeit wurde intensiv an der Entwicklung automatischer
Netzgenerierungsalgorithmen gearbeitet, die die Diskretisierung von Objekten relativ allgemeiner Form
ermöglichen, ohne dass dabei interaktive Eingriffe nötig sind. Dieses Interesse an der automatischen
Netzgenerierung ist im Bedarf an finiten Elementen für komplizierte dreidimensionale, geometrische
Formen begründet. Als Beispiel wird der QuadtreeNetzgenerator im Kapitel IV behandelt, der das Gebiet
eines Objektes als eine disjunkte Menge von Quadraten darstellt. Jedes Quadrat hat eine Adresse, die in
einem hierarchischen Baum („quadtree“) gespeichert ist. Der modifizierte Quadtree und der ursprüngliche
Quadtree haben die gleiche Struktur: Das Objekt, für das ein Finite-Elemente-Netz erzeugt wird, ist in einem
Quadrat platziert. Dieses Quadrat stellt die Wurzel des Baumes dar. Die Wurzel wird dann in vier Quadrate
unterteilt, die die Kinder der Wurzel des Baumes genannt werden. Der Rest des Baumes wird durch ein
rekursives Verfahren definiert. Der Aufteilungsgrad ( „tree level of the quadrant „) eines beliebig
ausgewählten Quadrates gibt an, wie viele Aufteilungen ( Subdivisionen ) des ursprünglichen Quadrates ,
genannt „ Wurzel „, notwendig waren, um dieses ausgewählte Quadrat zu erhalten.
Das Thema dieser Arbeit erfordert gewisse Vorkenntnisse über die Theorie der finiten Elemente, die ganz
kurz in Kapitel II besprochen werden. Im Kapitel II werden auch zwei Beispiele angegeben, die es einem
erlauben, die Funktion und die Nützlichkeit des Netzgenerators zu zeigen. Es wird die Strukturausgabe eines
Netzgenerators erklärt, die als Struktureingabe für ein Finite-Elemente-Programm dient. Im Kapitel III wird
der halbautomatische Netzgenerator behandelt, der ein guter Kompromiss zwischen der vollständigen
Methode und der manuellen Methode ist. Die erste Methode ist nicht flexibel, und die zweite Methode ist
sehr langsam und besonders fehlerhaft. In diesem Verfahren der halbautomatischen Netzgenerierung
bestimmt der Benutzer die Grenzknoten. Für die Erzeugung der inneren Knoten werden zwei Algorithmen
vorgeschlagen: Der erste Algorithmus heißt „ Koordinatentransformation „ und der zweite „ Punkt-Modul „.
Nach Erzeugung der inneren Knoten werden sie vom Programm anschließend verbunden, um Dreiecke zu
schaffen, die die ganze Oberfläche bedecken.
Kapitel IV ist eine Erweiterung des Kapitels III: Hier wird die Quadtree-Codierung definiert und die
benötigten Informationen für den Netzgenerator im Baum gespeichert. Außerdem wird im Besonderen
gezeigt, wie man die sogenannten beschnittenen Quadrate ( „cut quadrants“ ) einführen kann, ohne die
Struktur des Baumes zu zerstören. In diesem Kapitel dürfen die Schnittpunkte der Quadrate mit der
Objektgrenze nur ganzzahlige Koordinaten haben.
Im Abschnitt 3 des Kapitels IV wird ein minimaler Quadtree gesucht. Die Walddarstellung wird eingeführt,
und es wird insbesondere gezeigt (Theorem 4.30), dass die schwarz-weiße Darstellung die beste
Approximation für das Objekt liefert.
Kapitel V ist eine Beschreibung des vollautomatischen Netzgenerators („ fully automatic methods „). Es
besteht aus zwei Teilen:
1) Erzeugung des modifizierten Quadtree.
2) Durchführung der Netztopologie ( „mesh topologie „ ) für jedes einzelne Quadrat unter Verwendung
der im Baum enthaltenen Informationen.
In diesem Verfahren sind die Schnittpunkte reelle Zahlen, was zu Schwierigkeiten führt:
1) Die Benutzung von reellen Zahlen für die Schnittpunkte bewirkt die Einführung von kleinen
Segmenten in den modifizierten Quadtree. Diese kleinen Segmente sind ein Hindernis für die
Erzeugung eines guten Finite-Elemente-Netzes. Deshalb werden diese kleinen Segmente beseitigt
(collapsed ).
2) Die Grenzquadrate haben eine beliebige geometrische Form, was die Benutzung von Schablonen
(„templates“) unmöglich macht.
Die Glättungsprozedur wird angewandt, um die Gestalt der Quadrate und der Elemente zu verbessern. Am
Ende wird die Rechenzeit besprochen. Im Anhang wird der dreidimensionale Fall behandelt. Die Octree
wird eingeführt und die Resultate des Quadtree erweitert.
Grundbegriffe
Die mechanische Spannung (Formelzeichen σ) ist die Kraft pro Flächeneinheit, die in einer gedachten
Schnittfläche durch einen Körper wirkt.
Allgemein ist die Spannung σ der Betrag der Kraft F pro Flächeninhalt A:
Die an einer bestimmten Stelle wirkenden Spannungen werden in ihrer Gesamtheit durch die Spannungen in
drei Schnittflächen beschrieben, die sich an der Stelle kreuzen, also durch drei Vektoren mit je drei
Komponenten; diese bilden zusammengenommen den Spannungstensor.
Die einfachste Darstellung hat der Spannungstensor, wenn man die drei Schnittflächen jeweils senkrecht zu
einer Richtung eines kartesischen Koordinatensystems wählt. Die drei Kräfte in den drei Schnittflächen
entsprechen den Zeilen der folgenden Matrix:
Im Doppelindex beschreibt der erste Index, in welche Richtung der äußere Normaleinheitsvektor der
Schnittfläche zeigt (sprich an welchem Schnittufer gewirkt wird) und der zweite Index, in welcher Richtung
die Spannung wirkt.
.
Die Diagonalelemente σ stellen dabei die Normalspannungen dar, also die Kräfte, die senkrecht zur Fläche
wirken. Sie werden je nach Richtung Zugspannung (positives Vorzeichen) oder Druckspannung (negatives
Vorzeichen) (und deren skalare Größe Druck) genannt. Die nichtdiagonalen Elemente τ werden als
Schubspannungen bezeichnet. Sie wirken tangential zur Fläche, stellen also eine Belastung auf Scherung
dar.
Im Doppelindex beschreibt der erste Index, in welche Richtung der äußere Normaleinheitsvektor der
Schnittfläche zeigt (sprich an welchem Schnittufer gewirkt wird) und der zweite Index, in welcher Richtung
die Spannung wirkt.
Der Schubspannungsverlauf dient der Veranschaulichung der auftretenden Schubspannungen zur
Bezugsachse innerhalb eines mit einer Querkraft belasteten Profils. Greift die Querkraft außerhalb des
Schubmittelpunktes an, tritt Torsion auf.
Der Schubspannungsverlauf dient der Veranschaulichung der auftretenden Schubspannungen zur
Bezugsachse innerhalb eines mit einer Querkraft belasteten Profils. Greift die Querkraft außerhalb des
Schubmittelpunktes an, tritt Torsion auf.
Analog zu der Normalspannung σ, die senkrecht zur Schnittebene steht, definieren wir eine Schubspannung
τ tangential zur Schnittebene.
Normalspannung/-verformung - Schubspannung/-verformung
Durch die Schubbeanspruchung erfährt der Körper als Formänderung die sog. Gleitung mit dem Gleitwinkel
γ.
Hooke´sches Gesetz für Schubbeanspruchung
Es gibt einen linearen Zusammenhang zwischen Schubspannung, τ und Gleitwinkel γ im elastischen
Bereich.
τ=G·γ
mit
τ = Schubspannung
γ = Gleitwinkel
G= Schubmodul
Wobei G, der Schubmodul, ist eine Materialkonstante, die Auskunft über die linear-elastische Verformung
eines Bauteils infolge einer Scherkraft oder Schubspannung gibt.
Drehmoment
Das Drehmoment (oder auch Moment) spielt für Drehbewegungen die gleiche Rolle wie die Kraft für
geradlinige Bewegungen. Ein Drehmoment kann die Rotation eines Körpers beschleunigen oder bremsen
und den Körper verwinden oder verbiegen.
Zwei gleich große, aber genau in entgegengesetzter Richtung wirkende Kräfte auf verschiedenen
Wirkungslinien nennt man Kräftepaar. Ein Kräftepaar erzeugt ein Drehmoment gleich das Produkt der
Kräfte mal der Abstand der Wirkungslinien.
Wirkt eine Kraft F senkrecht auf einen Hebelarm der Länge r, so ergibt sich der Betrag des Drehmoments
aus der Länge des Hebelarms multipliziert mit dem Betrag der Kraft: M = r*F
Allgemein wird das Drehmoment durch das Vektorprodukt aus Abstandsvektor und Kraftvektor berechnet:
Wirken mehrere Kräfte
an verschiedenen Punkten
Vektorsumme der einzelnen Drehmomente:
ein, so ist das gesamte Drehmoment die
Koordinaten Transformation
Wir betrachten zwei kartesische Koordinatensysteme S(x,y) und
mit einer gemeinsamen z-Achse
und gemeinsamem Ursprung.
sei gegenüber S um den Winkel α um die z-Achse gedreht. Ein Punkt P, der im Koordinatensystem S die
Koordinaten
hat, besitzt dann im Koordinatensystem
die Koordinaten
:
Beispiel:
Wir betrachten den folgenden Balken. In Konten 1 und 2 sind Schnittkräfte
Es gilt:
Im Knoten gilt genauso:
und
Jetzt betrachten wir den dreidimensionalen Fall. Die Basisvektoren im globalen System sind
im lokalen System
.
Die Verschiebung lässt sich jeweils wie folgt definieren:
daraus folgt:
Genauso gilt:
Wir setzen:
Somit gilt:
und
und
Quadtree allgemein
Das Quadrat, mit dem * in seinem Zentrum, hat den Grad (level) 2
Mit Hilfe der Informationen, die in dem Quadrat gespeichert sind, ist es möglich, den Teil des Objektes, der
im Quadrat liegt, zu bestimmen. Wenn der Quadtree seine definierte Form erreicht hat, dann wird jedes
Quadrat daraufhin untersucht, ob es zu seinem Nachbarquadrat einen Unterschied von einem Grad (level)
aufweist. Somit unterscheiden sich im endgültigen Netz zwei benachbarte finite Elemente nur noch
geringfügig voneinander. Die für die Herstellung der passenden Netztopologie in jedem Quadrat benötigte
Information steht im Quadtree zur Verfügung. Der ursprüngliche Quadtree - Netz - Generator benützt nur
eine bestimmte Anzahl von Netztopologien („ mesh topologies“) für die Quadrate.
Bemerkung: Bei der Anwendung des modifizierten Quadtree für die Netzgenerierung wird jedes Quadrat
einzeln betrachtet. Auf diese weise sucht das Programm das optimale Netz für jedes Quadrat.
Problemstellung und Modellbildung
Grundlagen der finiten Elemente
Die Finite-Elemente-Methode hat sich in den letzten 2 Jahrzehnten zu einem der wichtigsten
Näherungsverfahren einer Reihe von Feldproblemen, wie der Festigkeitslehre, Strömungslehre,
Elektrotechnik usw. entwickelt. Sie ist heute für viele Ingenieure fester Bestandteil ihrer Ausbildung und
ihrer wissenschaftlichen und praktischen Tätigkeit geworden. Keine andere Methode hat bisher eine
vergleichbar breite Anwendung gefunden. Die Universalität der FEM und ihre Anpassungsfähigkeit an
spezielle Bedingungen haben zur Ausarbeitung großer problemorientierter Programmsysteme, aber auch
spezieller Programme für sehr unterschiedliche Aufgaben geführt. Die Entwicklung der FEM ist eng mit der
Entwicklung der EDV verknüpft. Die effektive Anwendung der FEM setzt einen leistungsfähigen Computer
und eine nutzerfreundliche periphere Gerätetechnik voraus. Sie führt dann zu wesentlichen
Rationalisierungseffekten in vielen Bereichen der Ingenieurarbeit und ermöglicht darüber hinaus eine
numerische Lösung einer Berechnung nur schwer oder gar nicht zugänglicher Probleme.
In der FEM führt man erst die Knoten im Objekt ein. Dann wird das Bauteil in Elemente zerlegt. Zum
Beispiel kann jedes Element ein Stab oder ein Dreieck sein. Nach dem Aufbringen der äußeren Lasten
verschiebt sich ein Knoten um den Verschiebungsvektor d=(u,v.w).
Der Spannungsbegriff
Die auf einen Körper aufgebrachten äußeren Kräfte rufen im Inneren Kräfte hervor. In der Schnittfläche
werden in dessen Schwerpunkt derart Kräfte und Momente angebracht, dass der Teilkörper im
Gleichgewicht mit den äußeren Kräften steht. Diese Schnittgrößen existieren allerdings in Wirklichkeit
nicht, sondern sind nur auf der Schnittfläche als Flächenkräfte vorhanden. Diese Flächenkräfte heißen
Spannungen.
S1 = [σxx,τxy,τxz]
S2 = [σyx,τyy,τyz]
S3 = [σzx,τzy,τzz]
S1 ist die Spannung für die Schnittebene parallel zu der YZ Ebene. Die Senkrechte zur Schnittebene heißt
Normalspannung und wird mit „σ“ bezeichnet. Spannungen, die in der Schnittebene liegen, heißen
Schubspannungen. Sie werden mit τ bezeichnet. S2 ist die Spannung für die Schnittebene parallel zur ZXEbene und S3 ist die Spannung für die Schnittebene parallel zur XY-Ebene.
Verzerrungen
Die Verzerrung beschreibt die Dehnung eines Punktes unseres Bauteils durch die Belastung.
Die Matrixsteifigkeitsmethode
Das Prinzip der Matrixsteifigkeitsmethode ist grundlegend für die FEM und hat als Basis den linearen
Zusammenhang zwischen den äußeren Kräften, bzw. Momenten und der Verschiebung bzw. Verdrehung in
den Angriffspunkten. Wir erhalten die sogenannte
Steifigkeitsbeziehung: F = K * W (#)
Wobei F: array (1..n) of real W : array (l..n) of real
Die Matrix K heißt Steifigkeitsmatrix.
Wenn wir voraussetzen, dass die Kräfte F(l)...F(n) bekannt sind, ist das Gleichungssystem (#) nach den
W(l)...W(n) aufzulösen. Man spricht von der Verschiebungsmethode oder auch Matrixsteifigkeitsmethode.
Nehmen wir hingegen an, dass die Verschiebungen bekannt sind, ist (#) nach den Kräften aufzulösen. Dies
ist die Kraftmethode.
Bemerkung :
Das Programm zur finiten Element-Methode verlangt vom Benutzer die folgenden Eingaben:
1) Die Beschreibung der Geometrie des Bauteils mittels der Knotennummern. Die Knotennummern mit
ihren Koordinaten werden im Datenblock (KOOR) abgelegt.
2) Zuordnung der Knoten zu den Elementen. Je nach Elemententyp werden jedem Element 2 oder mehr
Knotennummern zugeordnet. Diese Zuordnung geschieht im Datenblock ELEM.
3) Elementspezifische Daten wie Elastizitätskonstante, Querkontraktion, Dicke des Elements,
Querschnittfläche usw. werden in einem Datenblock (REF) abgespeichert.
4) Die Belastungen, also Einzelkräfte und Einzelmomente an Knoten werden mit den Knotennummern
in dem Datenblock BELA angegeben.
5) Die Randbedingungen, d. h. Knoten mit Sollverschiebungen sind im Datenblock (RAND)
einzutragen.
Beispiele
Die Beispiele sollen die Struktureingaben für das FEM-Programm verdeutlichen.
Beispiel
Auf das folgende Objekt wirken die Auflagerkräfte Auflagekräfte (reaction force) Rfxl, Rfyl, Rfy2 und die
äußeren Kräfte (external forces) Efx3 und Efy4
In dem nächsten Bild generiere ich dazu ein Stabwerk aus 5 Stäben (FEM) und ich nehme an, dass die
innere Fläche hohl ist:
Ich nummeriere die Stäbe und die Knoten wie folgt:
Ich setzte α=45° und L=1000 mm:
Für den folgenden Stab nehmen wir an:
1)
2)
3)
4)
5)
6)
7)
Er kann nur Kräfte in Längsrichtung aufnehmen.
Die Kraft Fi1 verursacht die Verschiebung u1
Die Kraft F i2 verursacht die Verschiebung u2
Der Stab hat die Querschnittsfläche A=150mm2
Der Stab hat die Elastizität E=105000 N/ mm2
Der Stab hat die Länge L= 1m
α =45°
In dem ij-Koordinatensystem gilt
Und
Die Senkrechte zur Schnittebene ist die Normalspannung σxx.
===>
===> (da u(0) = u1 und u(L)=u2)
===>
Und (da Fi2 = -Fi1)
Die Nullkräfte Fj1 und Fj2 entsprechen die Nullverschiebungen v1 und v2.
Daraus folgt:
Beispiel:
Im globalen xy-Koordinatensystem gilt (Koordinaten-Transformation):
die Länge vom Stab I ist L1 = 500mm
die Länge vom Stab III ist L3 = 500mm
die Länge vom Stab II ist L1 = cos(45°) * 500mm = 0,707 * 500 = 353,553mm
die Länge vom Stab IV ist L1 = cos(45°) * 500mm = 0,707 * 500 = 353,553mm
die Länge vom Stab V ist L1 = cos(45°) * 500mm = 0,707 * 500 = 353,553mm
Koordinate
Knotennummer
1
2
3
4
Elemente
Elementnr.
1
2
3
4
5
x-Koordinate
0.0
500.
750.
250.
Referenznr.
I
II
III
IV
V
Knotenanzahl
2
2
2
2
2
y-Koordinate
0.0
0.0
250.
250.
Knoten-1
1
2
4
2
1
Knoten-2
2
3
3
4
4
Fx1I + Fx1V = Rfx1
Fy1I + Fy1V = Rfy1
Fx2I + Fx2II + Fx2IV= Rfx2
Fy2I + Fy2II + Fy2IV= Rfy2
Fx3II + Fx3III = Efx3
Fy3II + Fy3III = Efy3
Fx4III + Fx4IV + Fx4V = Efx4
Fy4III + Fy4IV + Fy4V = Efy4
Daraus folgt:
=f.
f= (A*E)/L = (75*105000)/500 = 15750N/mm
Wobei:
Rfx1; Rfy1 und Rfy2, u2, u3, v3, u4 und v4 sind unbekannt und u1=0; v1=0; v2=0; Rfx2 = 0; Efx3= -250
N; Efy3=0; Efx4 =0 und Efy4=-500 N
Ich löse zuerst das reduzierte Gleichungssystem:
Mit dem Cholesky-Verfahren (siehe http://www.go4tunisia.de/PDF/maths_appliquees.pdf ) bekommen wir
die folgende Lösung:
Wobei u1=0; v1=0 und v2=0.
Genauso können wir mit dem nächsten reduzierten Gleichungssystem die Kräfte Rfx1, Rfy1; Rfy2
berechnen:
Daraus folgt:
Jetzt können wir als nächstes die inneren Stabkräfte berechnen:
Wir betrachten Stab IV:
Sei L4 die Länge vom Stab IV und LV die Länge vom Stab V.
Es gilt
(LIV)2 + (LV) 2 = L2 Pythagoras' Satz , da der Winkel in Konten 4 gleich 90° ist.
===>
===>
==>
===>
Wir müssen nur noch die globalen Kräfte in die Längskräfte transformieren:
Wobei α=90° + 45° = 135° ; cosα = cos(135) = -0,707 und sinα = sin(135) = 0,707
===>
====>
In Stab IV gilt:
Beispiel
Oft ist eine Strukturaufbereitung per Hand viel zu zeitaufwendig und fehleranfällig. Die Struktureingabe
(d.h. die Eingaben für das FEM- Programm) wird daher mit einem Netzgenerator erzeugt. Als Beispiel
behandeln wir ein Kuppeldach aus Stäben. Die Kuppel besteht aus 84 Knoten und 228 Stäben. Die Struktur
wurde mit einem Netzgeneratorprogramm1 erzeugt, das die spezielle symmetrische Konstruktion
berücksichtigt. Die Kuppel ist in den Bildern kl und k2 mit Hilfe eines Plot-Programms dargestellt.
1
das ich in java geschrieben habe und das bestellt werden kann
Figur k1
Figur k2: die Kuppel
Die Strukturausgabe des Netzgeneratorprogramms, die als Eingabe für das Programm zur finiten ElementeMethode dient, ist unten gegeben.
Koordinaten:
Knotennummer
1
usw.
84
X-Koordinate
12000.000
usw.
l804.605
Y-Koordinate
0.0
usw.
-1041.889
Z-Koordinate
0.0
usw.
118l7.693
Elemente
Elementnummer
1
usw.
228
Referenznummer
l
usw.
1
Knotenanzahl
2
usw.
2
Knoten l
l
usw.
84
Knoten 2
2
usw.
73
BELLASTUNG
Knotennummer
Lastfall
13
13
84
1
1
1
Last-in-XRichtung
0.0
0.0
0.0
Last-in-YRichtung
0.0
0.0
0.0
Last-in-ZRichtung
-24000
-24000
-14000
Das Programm lässt sich leicht dahingehend ändern, dass eine kombinierte Stab-Balkenstruktur entsteht.
Bei der Methode der FEM mit Hilfe der Netzgenerierung wird die gegebene Aufgabe diskretisiert, indem
ganz allgemein das Grundgebiet in einfache Teilgebiete. den sogenannten Elementen, zerlegt wird. Bei
gewissen Aufgabenstellungen ist die Aufteilung in Elemente durch das Problem bereits vorgegeben. Man
denkt dabei beispielsweise an ein räumliches Fachwerk, bei welchem die einzelnen Stäbe die Elemente der
Konstruktion bilden. Dasselbe gilt etwa auch bei Rahmenkonstruktionen. wo die einzelnen Balken oder
sogar unterteilte Balkenstücke die Elemente der Aufgabe darstellen. Im Fall von zweidimensionalen
Feldproblemen oder elastomechanischen Aufgaben wird das Grundgebiet G in Dreiecke, Parallelogramme,
krummlinige Dreiecke oder Vierecke eingeteilt, wie dies etwa in Figur 1 angedeutet ist . Selbst wenn nur
Figur 1.
geradlinige Elemente verwendet werden. erreicht man mit einer entsprechend feinen Diskretisierung eine
recht gute Approximation des Grundgebietes. Krummlinige Elemente erhöhen selbstverständlich die Güte
der Annäherung des Grundgebietes. Jedenfalls erlaubt diese Disktretisierung eine äußerst flexible und auch
dem Problem angepasste Erfassung des Grundgebietes. Allerdings Muss unbedingt darauf geachtet werden,
dass Paare von allzu spitzen und damit allzu stumpfe Winkel in den Elementen vermieden werden, um
numerische Schwierigkeiten zu vermeiden. Sodann wird das gegebene Gebiet durch die Fläche der
approximierenden Elemente ersetzt.
Bei räumlichen Problemen erfolgt eine Diskretisierung des dreidimensionalen Gebietes in TetraederElemente, Quaderelemente oder anderen dem Problem angepassten möglicherweise auch krummflächig
berandeten Elementen. In jedem der Elemente wird für die gesuchte Funktion, bzw. allgemeiner, für die das
Problem beschreibenden Funktionen, ein problemgerechter Ansatz gewählt. Im Besonderen eignen sich
dazu ganz rationale Funktionen in den unabhängigen Raumkoordinaten. Für eindimensionale Elemente
(Stäbe, Balken) kommen Polynome ersten, zweiten, dritten und gelegentlich sogar höheren Grades in Frage.
Bei zweidimensionalen Problemen finden lineare, quadratische und höhergradige Polynome der Form
U(x,y) = c1 +c2x + c3y
U(x,y) = c1 +c2x + c3y +c4x2 +c5xy +c6y2
oder etwa bilineare Ansätze
U(x,y) = c1 +c2x + c3y + c4yx
Verwendung. Die Art des Ansatzes hängt dabei einerseits von der Form des Elementes ab und anderseits
kann auch das zu behandelnde Problem den zu wählenden Ansatz beeinflussen. Denn die Ansatzfunktionen
müssen beim Übergang von einem Element ins benachbarte ganz bestimmte problemabhängige
Stetigkeitsbedingungen erfüllen. Die Stetigkeitsanforderungen sind häufig aus physikalischen Gründen
offensichtlich. Sie sind aus mathematischen Gründen auch erforderlich.
Hat etwa u(x,y) die Bedeutung der Verschiebung eines kontinuierlichen Mediums in Z-Richtung, so muss
diese Funktion offenbar beim Übergang von einem Element zu anderen stetig sein, um die Kontinuität des
Materials zu gewährleisten. Im Fall der Balken- oder Plattenbiegung sind die Stetigkeitsanforderungen
höher, indem dort aus analogen physikalischen Gründen sogar die Stetigkeit der ersten Ableitung, bzw. der
beiden ersten partiellen Ableitungen gefordert werden muss.
Halbautomatische Netzgenerierung
Wir beginnen mit der Erläuterung der halbautomatischen Netzgenerierung als Vorbereitung für die
Erklärung der vollautomatischen Netzgenerierung.
Die Aufgabe des Netzgenerierungsalgorithmus ist es unter anderem, die vom Benutzer eingegebene Menge
von Daten ( "data input" ) unter folgenden Bedingungen zu verkleinern.
1) Der Benutzer kann die Dichte der Elemente (element density) an jedem Ort des Objektes bestimmen.
2) Die Elemente müssen so beschaffen sein, dass sie bei Aneinanderreihung in einer Fläche eine
überlappungsfreie und lückenlose Überdeckung des Objektes ergeben, das heißt. sie müssen in ihrer
geometrischen Form eine gewisse Regelmäßigkeit enthalten. Diese Regelmäßigkeit besteht zum
Beispiel bei einem Dreieck aus Gleichschenkligkeit (equilateral). oder bei einem Viereck aus der
Rechtwinkligkeit der Innenwinkel. Der Netzgenerierungsalgorithmus versucht bei der Überdeckung
des Objektes diesen Idealzustand so gut wie möglich zu erreichen.
3) Der Algorithmus muss fähig sein. jede komplizierte geometrische Form eines beliebigen Objektes
bearbeiten zu können.
4) Der Algorithmus muss ökonomisch (economical) sein, um zum Beispiel minimale Rechenzeit zu
benötigen, und er soll so wenig Benutzereingriffe wie möglich erfordern.
Beschreibung des Algorithmus
Die Ränder des zweidimensionalen Objektes werden jeweils durch einen Polygonzug approximiert. In
Zukunft wird die Grenze mit fR bezeichnet, wobei „ f „ von dem französischen Wort „fronntiere„ stammt.
Definition
Unter der Grenze eines Objektes versteht man den Rand des Objektes. Das Objekt kann auch Löcher haben
und der Rand eines solchen Loches gehört genauso wie der äußere Rand zu der Grenze des Objektes.
Der Benutzer muss die Koordinaten der Grenzknoten bestimmen. Der Algorithmus wird die inneren Knoten
des Objektes erzeugen und die gesamten Knoten verbinden. um Dreiecke, die die ganze Objektfläche
bedecken, zu schaffen.
Die Dreiecke müssen Eigenschaften von gleichschenkligen ("equi1ateral") Dreiecken haben. Da die Form
der Dreiecke besonders von den Positionen der Knoten abhängt, versuchen wir eine optimale Lösung zu
finden, die gleichschenklige Dreiecke erzeugt: Die Form der Dreiecke kann durch ein Glättungsverfahren
verbessert werden, das die Position der Knoten verschiebt. In diesem Abschnitt hat unser Algorithmus zwei
Stufen.
1) Die Knoten werden einzeln vom Benutzer und automatisch vom Programm erzeugt.
2) Die Knoten werden zu Dreiecken verbunden. Die bei der Netzgenerierung entstehenden Punkte
werden durchnummeriert, und der Netzgenerierungsalgorithmus verbindet die einzelnen Punkte
Figur 0 :
derart, dass das dadurch entstehende Netz aus möglichst gleichschenkligen Dreiecken besteht. Um ihn
besser erklären zu können, wird der Algorithmus aus vier unabhängigen Modulen konstruiert. die wir
"Eingabe". " Punkt ", "Dreieck" und "Glättung" nennen, siehe dazu Figur 0.
Es gibt zwei Algorithmen für das Punkt-Modul, die wir " Punkt-Modul-Generator " und " Erzeugung der
Oberflächenknoten " nennen.
Im Folgenden werden drei Algorithmen erklärt. die dann später angewendet werden.
Das Objekt, für das ein Netz erzeugt wird, wird mit S bezeichnet.
Algorithmus1
Figur 01: die planare Struktur
Wir teilen den Kreis in n-Teile auf und berechnen die x- und y-Koordinate der Punkte auf dem Kreis.
Diese Punkte fügen wir einem Polygon-Objekt hinzu. Hier ist das Java-Programm:
package com.bmw.prolo.graphics;
// Autor: Dr. Jamel Tazarki
import java.awt.*;
import java.awt.event.*;
public class nEck
extends Frame {
public nEck() {
setSize(400, 400);
addWindowListener(new WindowAdapter() {
public void windowClosing(WindowEvent e) {
System.exit(0);
}
});
}
private void drawNeck(Graphics g, int x, int y, int r,
int n, boolean filled) {
Polygon p = new Polygon();
for (int i = 0; i < n; i++) {
p.addPoint( (int) (x + r * Math.cos(i * 2 * Math.PI / n)),
(int) (y + r * Math.sin(i * 2 * Math.PI / n)));
}
if (filled == true) {
g.fillPolygon(p);
}
else {
g.drawPolygon(p);
}
}
/**
* Draws a n-Eck polygon with the given parameter
*/
public void drawNeck(Graphics g, int x, int y, int rayon,
int anzahl_der_sagemente) {
drawNeck(g, x, y, rayon, anzahl_der_sagemente, false);
}
/**
* Draws a filled n-Eck polygon with the given parameter
*/
public void fillNeck(Graphics g, int x, int y, int r, int n) {
drawNeck(g, x, y, r, n, true);
}
public void paint(Graphics g) {
// fillNeck( g, 100, 100, 50, 6 );
// drawNeck( Graphics g, int x, int y, int rayon, int anzahl_der_sagemente )
drawNeck(g, 200, 200, 120, 10);
}
public static void main(String args[]) {
nEck poly = new nEck();
poly.show();
}
}
Hier ist das Output des Java-Programms:
Figur 02: die polygon-förmige Region R
Figur 03: R“ wird aus R erzeugt
Figur 04: Polygon Z
Algorithmus2
Figur 05: Das ursprüngliche Viereck .
Figur 06:Das endgültige Viereck nach der Anwendung des Algorithmus. Wobei, die Kantenlänge „r“ der
inneren Quadrate muss in beiden Rechteckseiten ganzzahlig enthalten sein.
Algorithmus3
Bemerkung: r ist der Dichtigkeitsfaktor des Polygons Z
Funktion der „Eingabe“
1) Das Objekt, für das ein Finite-Elemente-Netz erzeugt wird, wird definiert. Wir nennen unser Objekt
"O" (siehe Bild 01).
2) wir entwerfen eine Approximation "R" für "O" (siehe Bild 2). Dabei gilt:
a) Die Grenze ER des Bereiches R besteht aus Polygonzügen (siehe Bild 2).
b) fR approximiert die Grenze des Objektes O.
3) Der Entwerfer muss die Koordinaten der Knoten, die an der Grenze fR liegen, bestimmen.
4) Es wird ein Bereich R' entworfen, wie es im Algorithmusl erklärt wurde. Dafür muss der Entwerfer
einen Wert für Epsilon angeben ( siehe Bild 03 ).
5) Der Bereich R wird in eine Menge von disjunkten Regionen Z(1),Z(2),...,Z(n) unterteilt (siehe Bild
3). Dabei gilt:
a) Der Rand jeder Region Z(i) (für alle i) ist ein Polygon, wir nennen dieses Polygon fZ(i).
b) R ist in der Vereinigung von Z(l),Z(2)...Z(n) enthalten.
6) Für jedes Polygon Z(i) wird der Algorithmus3 angewendet. Dafür muss man einen wert für r(i)
angeben.
Figur 07: Das Polygon Z von Figur O6 wird in einem Rechteck platziert
Figur 08: über dem Rechteck von Figur 07 wird ein gradliniges Gitter platziert
Automatische Erzeugung der inneren Knoten
Funktion des Punkt-Moduls
Als erstes wird von dem Punktmodul ein neues Polygon R" entworfen (siehe Algorithmus 1 und Bild 4). Es
muss darauf geachtet werden, dass die Dreieckserzeugung keine Dreiecke mit Winkeln, die wesentlich
kleiner als 60 sind, erzeugt und auch keine Dreiecke, die direkt an der Grenze fR liegen. Deshalb muss man
fordern, dass die vom Punktmodul erzeugten Knoten in dem Gebiet R" liegen. Die inneren Knoten werden
in jeder Region Z(i) separat erzeugt. Die Erzeugung wird folgenderweise durchgeführt:
1) Wir beginnen mit i = 1 ( i läuft von 1 bis n ). Das Punktmodul platziert die Zone Z(i) in einem
Rechteck ("rectangle") und zwar im kleinsten, das Z(i) enthalten kann. Mittels eines geradlinigen
Gitters mit der Gitterkonstanten r(i) teilt danach der Algorithmus das Viereck in lauter Quadrate mit
der Kantenlänge r(i) auf. Die Länge und die Breite des Rechtecks sind durch r<i teilbar.
2) wir beginnen mit dem ganz linken oberen Quadrat, das in Z(í) und im Gitter enthalten ist. Der
Prozess läuft von links nach rechts und jedes Mal wird versucht in einem Quadrat einen Knoten zu
erzeugen: Ein Knoten k wird dann als innerer Knoten eines Quadrates akzeptiert, wenn k im
Durschnitt von R" und Z(i) liegt, und wenn alle anderen Knoten (Grenzknoten und fixierte innere
Knoten) außerhalb der r(i) - Umgebung von k liegen (siehe Fig.5).Für jedes Quadrat sind fünf
Versuche zu machen, um einen inneren Knoten zu erhalten. Falls diese fünf Versuche fehlschlagen,
dann enthält dieses Quadrat keinen Knoten und es wird das nächste Quadrat untersucht. Dieser
Prozess wird solange wiederholt, bis alle Quadrate im Durschnitt von Z(i) und R getestet sind.
Danach wird das Polygon mit dem nächsthöheren Index untersucht, und die Strategie wird
wiederholt, um die Knoten im Durschnitt von R und Z(i+l) zu erzeugen. Es ist klar, dass die Dichte
der Knoten innerhalb von Z(i) durch r(i) kontrolliert wird, wobei r(i) von dem Benutzer bestimmt
wurde. Je kleiner der Wert von r(i) ist, desto feiner ist die Dreieckserzeugung. Die resultierende
Verteilung der automatisch erzeugten Knoten der Region in Figur 2 mit der Dichte von Figur 3 wird
in Figur 6 gezeigt.
Figur 6: endgültige Knotenverteilung
Das Java Programm finden Sie auf www.go4tunisia.de
Koordinaten-Transformation
Hier wird ein zweiter Algorithmus für die Erzeugung der inneren Knoten besprochen.
Körperorientierten Koordinatensystem (Body oriented coordinates) wurden für dreidimensionale Regionen
mit sechs Flächen definiert.
Es gibt zwei Transformationen:
i) Eine Transformation im zweidimensionalen Raum von körperorientierten Koordinatensystem in
kartesische Koordinaten.
ii) Eine Transformation im dreidimensionalen Raum von körperorientierten Koordinatensystem in
kartesische Koordinaten.
Bemerkung :
1) Die Grenzknoten sind vorgegeben.
2) Die Dichte der inneren Knoten hängt von der Dichte der Grenzknoten ab.
Man benötigt die Grenzknoten, um die Koordinaten der inneren Knoten zu berechnen. Das Verfahren wird
in drei Stufen unterteilt:
1) Der Oberflächenknotengenerator bildet (maps) den betrachteten Flächenrand auf den Rand des
Einheitsquadrates (unit square) ab.
2) Die Koordinaten (ξ,eta) der inneren Knoten des Einheitsquadrates werden entsprechend der Dichte
der Grenzknoten bestimmt.
3) Mit Hilfe der ersten Transformation werden die Koordinaten der inneren Knoten im kartesischen
System berechnet.
Der Volumenknotengenerator ist auch in drei Stufen unterteilt:
1) Der Volumenknotengenerator bildet die Oberfläche eines dreidimensionalen Körpers auf die
Oberfläche eines dreidimensionalen Einheitswürfels ab.
2) Der Volumenknotengenerator bestimmt die Koordinaten (ξ,eta,gamma) der inneren Knoten des
Einheitswürfels entsprechend der Dichtigkeit der Grenzknoten.
3) Mit Hilfe der zweiten Transformation werden die Koordinaten der inneren Knoten im kartesischen
System berechnet.
Es wird nur der Oberflächenknotengenerator bearbeitet.
Theorem: Koordinatentransformation
Es existiert eine Koordinatentransformation zwischen den kartesischen und körperorientierten
Koordinatensystemen.
Beweis:
Es werden die zwei Koordinatensysteme von Figur 7 betrachtet.
Dabei gilt:
a) 0 < xi < 1 und 0 < eta <1.
b) der fettgedruckte Rand ist die Grenze einer beliebigen Fläche.
Figur 7 : Kartesisches und körperorientiertes Koordinatensystem
c)
d)
e)
f)
eta (ŋ)= 0 auf der Grenzlinie, die die Nummer 1 hat (Fig. 7).
eta = 1 auf der Grenzlinie, die die Nummer 2 hat.
ξ (ξ) = 0 auf der Grenzlinie. die mit 3 bezeichnet ist.
ξ = 1 auf der Grenzlinie, die mit 4 bezeichnet ist.
Die Funktionen f1(ξ), g1( ξ ), h1(ξ) bestimmen x , y , z entlang der Grenzlinie. die mit 1 bezeichnet is.
Andere Grenzfunktionen können für die anderen Grenzlinien definiert werden.
Entlang der Grenzlinie 1 (eta=0) gilt x = f1 (ξ), y = g1( ξ ) und z = h1(ξ).
Entlang der Grenzlinie 2 (eta=1) gilt x=f2 (ξ), y = g2(ξ) und z = h2(x).
Entlang der Grenzlinie 3 (ξ =0) gilt: x = f3 (eta), y= g3(eta) und z = h3 (eta)
Entlang der Grenzlinie 4 ( ξ =1) gilt: x = f4 (eta), y = g4(eta) und z = h4 (eta).
Mit Hilfe dieser Funktionen kann man die Transformation so interpolieren:
Ähnliche Gleichungen können für y(ξ,eta) und z(ξ,eta) definiert werden.
Folgerung :
Man braucht nur die Koordinaten (ξ,eta) der inneren Knoten zu finden : Die kartesischen Koordinaten kann
man mit Hilfe der obigen Transformation erhalten.
Bemerkung:
In der Gleichung 1 wurden die Grenzfunktionen verwendet. Sie werden in dem folgenden Theorem
berechnet.
Ich definiere zwei Indizes i und j (Element von N) ,um die Knoten zu bezeichnen.
- imin < i < imax und i verhält sich wie ξ und
- jmin < j < jmax und j verhält sich wie eta
Jeder Knoten (Innere und Grenzknoten) ist mit Hilfe von (i,j) festgelegt.
Behauptung: Es existieren zwei Funktionen f1 und g1, so dass folgendes gilt:
Beweis:
Betrachte eta = 0 und j = min.
ξijmin = (Die Länge des Randes 1 vom Ursprung zum Knotenpunkt (i,imin)/(Gesamtlänge des Randes 1).
Dabei gilt:
und
In ähnlicher weise werden auch für jeden Grenzknoten ξij und ŋij definiert.
wir setzen:
Man kann eine lineare Interpolation machen, um die Grenzfunktionen zu bestimmen. q.e.d.
Bemerkung :
Mit Hilfe der Gleichung 2 wurde der betrachtete Flächenrand auf den Rand des Einheitsquadrates (unit
square) abgebildet: Die Koordinaten der Grenzpunkte sind in dem abgeschlossenen Intervall (0,1) enthalten.
Unter der Annahme, dass die Koordinaten der Schnittpunkte der zwei Segmente von Figur 8 die inneren
Knoten darstellen, gilt folgendes:
Die Lage des Schnittpunktes zweier Segmente der Figur 8 hängt davon ab, wo die Endpunkte der Segmente
im körperorientierten Koordinatensystem des Einheitsquadrats liegen.
Beweis:
Man braucht nur die Gleichungen der beiden Geraden, die die zwei Segmente enthalten, zu finden und zu
prüfen. ob der Punkt
auf diesen Geraden liegt.
Figur 8: Körperorientiertes Koordinatensystem eines Einheitsquadrats
Zusammenfassung
Das Programm wurde mit Hilfe der Prinzipien, die oben eingeführt wurden, entworfen. Es besteht aus den
drei folgenden Stufen:
1) Die Grenzfunktionen, sowie ξ und eta werden für jede Grenzlinie mit Hilfe der Gleichung 2
berechnet.
2) Mit Hilfe der Gleichung 3 werden ξ und eta für die inneren Knoten berechnet.
3) Mit Hilfe der Gleichung 1 werden die Koordinaten (x,y,z) der inneren Knoten berechnet.
Auf den Seiten 32 bis 36 befindet sich ein Programm für den Oberflächenknotengenerator.
Funktion des Dreieck-Moduls
wir nehmen an, daß die Knoten vom Punktmodul erzeugt wurden. Wir beschreiben jetzt. wie der
Algorithmus die Knoten verbinden wird, um die Dreieckserzeugung durchführen zu können. Sei Q die
Menge aller Grenz- und Innenknoten, und EQ die Teilmenge von Q, die die Knoten enthält, die von dem
Benutzer auf fR bestimmt wurden. wir wählen für die Durchlaufrichtung von fR den Umlaufsinn des
Uhrzeigers. Das Polygon hat eine innere Fläche, die auf der linken Seite des Segments, das zwei
aufeinanderfolgende externe Punkte von EQ verbindet, liegt. Erst werden zwei beliebige
aufeinanderfolgende Knoten A und B in Q gewählt. (Der Prozess fängt bei den Knoten von ER an). Das Ziel
ist es, einen Knoten C in Q zu suchen. um zu erreichen, dass C auf der linken Seite von AB liegt und dass
das Dreieck ABC gleichschenklig ist. Seien Cl bis C6 die Knoten. die von dem Prozess determiniert wurden.
Für jedes 0 < k < 7 liegt Ck auf der linken Seite von AB und verkleinert auf Q - ( Cl , C2.... C6 ) die Länge
AC + CB. Wir nennen diese Ck's Auswahlkandidaten für die Erzeugung des soeben beschriebenen Dreiecks
mit der Basis ( AB ). Dieser Prozess wird in Figur 8a illustriert.
Figur 8a
Das Problem ist es jetzt, ein Ck in (C1,....C6) auszuwählen, um ein neues Dreieck ABCk zu definieren. Der
Bewerber wird erst getestet: (sei k=1 am Anfang) Es wird für jedes k geprüft, ob das Dreieck ABCk ein
früher erzeugtes Dreieck oder ein Segment von fR überschneidet. In diesem Fall wird Ck kein Bewerber
mehr sein, um ein Dreieck mit der Basis AB zu bilden. Wir sagen, dass Ck ungeeignet ist. Das gleiche Ck
wird noch einmal daraufhin getestet, ob das Dreieck ABCk einen Bewerber Cj enthält, wobei 0 < j < 7 und j
ungleich k ist. Wenn das der Fall ist, dann wird Ck nicht mehr von der Funktion Dreieckmodul betrachtet.
Wir sagen dass Ck abgestoßen wird.
In Figur9 ist C1 im Dreieck ABC4 enthalten. Deshalb ist C1 ungeeignet. Die Determination von Ck in
(C1,C2,CE,C4,C5› in Figur 8a hängt von 2 Überlegungen ab.
1) wie ist die Abweichung des Dreiecks ABCk von der equilateralen Form?
2) was sind die Folgen aus der Benutzung von ACk oder CkB als Basisseiten in späteren Stufen?
Figur 9 zeigt. daß der 2. obengenannte Punkt sehr wichtig ist: Die Dreiecke ABC2 und AC2C3 sind
equilateral, aber das Dreieck C2BC1, das in einem späteren Zeitpunkt als die Dreiecke ABC2 und AC2C3
erzeugt wurde, ist kein Equilateraldreieck.
Figur 9: mögliche Konsequenz der Wahl von ABC2 als optimales Element
Definition:
ABC ist ein beliebiges Dreieck. „l“ ist die Länge der längsten Seite von ABC und „L“ ist der Abstand
zwischen dieser Seite und dem Knoten, der gegenüber dieser Seite liegt.
Es gilt ABC ist genau dann equilateral, wenn
(L/l) = exp(0,5 * Log(3/4))
Wir benutzen diesen Wert als Maß für die Abweichung des Dreiecks ABC von dem equilateralen Dreieck.
Mit diesen Bemerkungen im Gedächtnis werden die nächsten Stufen dazu benutzt, eine optimale Erzeugung
eines Elements zu erreichen, dessen Basis AB ist. wir starten mit k = 1, und wir betrachten nicht die C‘s, die
ungeeignet sind.
Im Folgenden wird ein Algorithmus für die Erzeugung der Dreiecke angegeben. Wir fangen mit dem
Dreieck an. das die Basis (AB) hat.
Die Kommentare zu diesem Algorithmus stehen zwischen „/*“ und „*/“.
Der Algorithmus besteht aus zwei wichtigen Stufen:
a) Für jedes k schätzen wir die schlimmste Konsequenz ab, wenn wir ABCk als Element auswählen.
Dies entspricht dem Wert von βk
b) Wir behalten den Punkt k, welcher die am wenigsten schlimme Abschätzung hat.
Die Funktion des Glättungsmoduls
Die Glättungsprozedur wird angewandt, um die Gestalt der Elemente zu verbessern. Die Technik wurde
entworfen, um die Form der Dreiecke so zu verbessern, dass die Dreiecke nicht zu viel von
Equilateraldreiecken abweichen.
Ein planares Gebiet mit zwei Löschern und nicht konstante innerer Dichte
Es wurden bereits die inneren Knoten und 25 Elemente erzeugt.
Das endgültige Netz
Polygon
Zuerst berechnen wir die Koordinaten der Knoten. Ein Knoten „k“ wird dann als innerer Knoten akzeptiert,
wenn „k“ innerhalb des Objektes liegt, und wenn alle anderen Knoten (Grenzknoten und fixierte innere
Knoten) außerhalb der r-Umgebung von „k“ liegen. Es ist klar, dass die Dichte der Knoten innerhalb des
Objektes durch „r“ kontrolliert wird, wobei „r“ von dem Benutzer bestimmt wird. Je kleiner der Wert von
„r“ ist, desto feiner ist die Dreieckserzeugung.
Die resultierende Verteilung der automatisch erzeugten Knoten des Polygons mit der Dichte r=3 ist wie
folgt:
Die resultierende Verteilung der automatisch erzeugten Knoten des Polygons mit der Dichte r=10 ist wie
folgt:
Die resultierende Verteilung der automatisch erzeugten Knoten des Polygons mit der Dichte r=15 ist wie
folgt:
Hier folgt das Java-Programm:
package com.bmw.prolo.graphics;
// Autor: Dr. Jamel Tazarki
import java.awt.Color;
import java.awt.Dimension;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.Insets;
import java.util.Random;
import javax.swing.JFrame;
import javax.swing.JPanel;
import javax.swing.SwingUtilities;
import java.applet.*;
import java.awt.*;
import java.awt.Polygon;
import java.awt.event.MouseAdapter;
import java.awt.event.MouseEvent;
import java.awt.Point;
class Surface
extends JPanel {
void triangle(Graphics g, int x1, int y1,
int x2, int y2, int x3, int y3) {
g.drawLine(x1, y1, x2, y2);
g.drawLine(x2, y2, x3, y3);
g.drawLine(x3, y3, x1, y1);
}
static double quadrat(double n) {
return n * n;
}
private void doDrawing(Graphics g) {
BasicStroke thick = new BasicStroke(3f);
Graphics2D g2d = (Graphics2D) g;
g2d.setStroke(thick);
g2d.setColor(Color.blue);
Dimension size = getSize();
Insets insets = getInsets();
int[] xcoords = new int[300];
int[] ycoords = new int[300];
int[] xcoordsFilter = new int[300];
int[] ycoordsFilter = new int[300];
boolean distanceOkay = false;
double distance_ = 0;
for (int i = 0; i < xcoordsFilter.length; i++) {
xcoordsFilter[i] = 0;
ycoordsFilter[i] = 0;
}
int xPoly[] = {50, 150, 225, 275, 350, 175, 30};
int yPoly[] = {50, 50, 25, 125, 150, 275, 200};
Polygon poly = new Polygon(xPoly, yPoly, xPoly.length);
g2d.drawPolygon(poly);
Point p1 = new Point(12, 45);
Point p2 = new Point(200, 300);
Point p3 = new Point();
double u;
Point mp = new Point();
double m;
double perpendicular_to_m;
Point unit_perpendicular_vector = new Point();
int w = size.width - insets.left - insets.right;
int h = size.height - insets.top - insets.bottom;
Random r = new Random();
for (int i = 0; i < 300; i++) {
int x = Math.abs(r.nextInt()) % w;
int y = Math.abs(r.nextInt()) % h;
xcoords[i] = x;
ycoords[i] = y;
}
for (int i = 0; i < xcoords.length; i++) {
System.out.println("i=" + i);
distanceOkay = true;
if (i == 0) {
xcoordsFilter[0] = xcoords[0];
ycoordsFilter[0] = ycoords[0];
g2d.setColor(Color.red);
g2d.drawLine(xcoords[i], ycoords[i], xcoords[i], ycoords[i]);
}
for (int j = 0; j < xcoordsFilter.length; j++) {
if ( ( (xcoordsFilter[j] > 0) && (ycoordsFilter[j] > 0))) {
distance_ = Math.sqrt( (xcoords[i] - xcoordsFilter[j]) *
(xcoords[i] - xcoordsFilter[j]) +
(ycoords[i] - ycoordsFilter[j]) *
(ycoords[i] - ycoordsFilter[j]));
System.out.println(distance_);
if (distance_ < 30) { // radius hier setzen
distanceOkay = false;
}
}
}
if (distanceOkay) {
if (poly.contains(xcoords[i], ycoords[i])) {
g2d.drawLine(xcoords[i], ycoords[i], xcoords[i], ycoords[i]);
System.out.println("distanceOkay");
}
}
else {
System.out.println("distanceNot_Okay");
}
xcoordsFilter[i] = xcoords[i];
ycoordsFilter[i] = ycoords[i];
}
}
// @Override
public void paintComponent(Graphics g) {
super.paintComponent(g);
doDrawing(g);
}
public class Points
extends JFrame {
public Points() {
initUI();
}
private void initUI() {
setTitle("Points");
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
getContentPane().add(new Surface());
setSize(400, 350);
setLocationRelativeTo(null);
}
}
public static void main(String[] args) {
SwingUtilities.invokeLater(new Runnable() {
Surface surface2 = new Surface();
Points ps2 = surface2.new Points();
// @Override
public void run() {
ps2.setVisible(true);
}
});
}
}
Wir beschreiben jetzt, wie der Algorithmus die Knoten verbinden wird, um die Dreieckserzeugung
durchführen zu können. Es wird für jedes Konten „k“ geprüft, ob das Dreieck ABCk ein früher erzeugtes
Dreieck oder ein Segment von fR überschneidet. In diesem Fall wird Ck kein Bewerber mehr sein, um ein
Dreieck mit der Basis AB zu bilden. Wir sagen, dass Ck ungeeignet ist. Das gleiche Ck wird noch einmal
daraufhin getestet, ob das Dreieck ABCk einen Bewerber Cj enthält, wobei 0 < j < 7 und j ungleich k ist.
Wenn das der Fall ist, dann wird Ck nicht mehr von der Funktion Dreieckmodul betrachtet. Wir sagen dass
Ck abgestoßen wird.
Wir lassen das Java-Programm die Dreiecke erzeugen:
Das endgültige Netz
Hier folgt das Java-Programm:
// TriangleMesh
// Autor: Dr. Jamel Tazarki
package com.bmw.prolo.graphics;
import java.awt.Color;
import java.awt.Dimension;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.Insets;
import java.util.Random;
import javax.swing.JFrame;
import javax.swing.JPanel;
import javax.swing.SwingUtilities;
import java.util.*;
import java.applet.*;
import java.awt.*;
import java.awt.Polygon;
import java.awt.event.MouseAdapter;
import java.awt.event.MouseEvent;
import java.awt.Point;
class TriangleMesh1
extends JPanel {
void triangle(Graphics g, int x1, int y1,
int x2, int y2, int x3, int y3) {
g.drawLine(x1, y1, x2, y2);
g.drawLine(x2, y2, x3, y3);
g.drawLine(x3, y3, x1, y1);
}
// *****************************************
//************* quadrat ********************
//******************************************
static double quadrat(double n) {
return n * n;
}
// *********************************************
//************* createPointP1 ********************
//**********************************************
static Point createPointP1(Polygon poly, int w, int h) {
Point p1 = new Point();
boolean outside = true;
Random r = new Random();
while (outside) {
int x = Math.abs(r.nextInt()) % w;
int y = Math.abs(r.nextInt()) % h;
if (poly.contains(x, y)) {
p1.x = x;
p1.y = y;
outside = false;
}
}
return p1;
}
// *********************************************
//************* createPointP1 ********************
//**********************************************
static Point createPointP1(Polygon poly, int w, int h, int minimalDistance,
int i, int j) {
Point p1 = new Point();
int x = (int) (w / minimalDistance) * i;
p1.x = x;
p1.y = j;
return p1;
}
// *********************************************
//************* createPointP2 ********************
//**********************************************
static Point createPointP2(Polygon poly, int w, int h, Point p,
int minimalDistance, int i, int j) {
Point p2 = new Point();
int x = (int) (w / minimalDistance) * i;
p2.x = x;
p2.y = j;
return p2;
}
// *********************************************
//************* createPointP2 ********************
//**********************************************
static Point createPointP2(Polygon poly, int w, int h, Point p,
int minimalDistance) {
Point p2 = new Point();
boolean outside = true;
Random r = new Random();
double distance = 0;
outside = true;
while (outside) {
int x = Math.abs(r.nextInt()) % (w - minimalDistance);
int y = Math.abs(r.nextInt()) % (h - minimalDistance);
if (poly.contains(x, y)) {
distance = Math.sqrt( (x - p.getX()) * (x - p.getX()) +
(y - p.getY()) * (y - p.getY()));
if (distance < minimalDistance) {
p2.x = x;
p2.y = y;
outside = false;
}
}
}
return p2;
}
// *********************************************
//************* createPointP3 ********************
//**********************************************
static int getHight(Polygon poly, Point p1, Point p2, int minimalDistance,
int flag) {
Point p3 = new Point();
boolean outside = true;
Random r = new Random();
double distance = 0;
int sidelength;
double m; // The slope of the segment from P1 to P2
Point mp = new Point();
double u;
sidelength = (int) Math.sqrt(quadrat(p1.getX() - p2.getX()) +
quadrat(p1.getY() - p2.getY()));
mp.x = (int) ( (p1.getX() + p2.getX()) / 2);
mp.y = (int) ( (p1.getY() + p2.getY()) / 2);
m = (p1.getY() - p2.getY()) / (p1.getX() - p2.getX());
u = flag * (sidelength * Math.sqrt(3)) / 2;
p3.x = (int) (mp.getX() + (m * u) / Math.sqrt(1 + m * m));
p3.y = (int) (mp.getY() - (u) / Math.sqrt(1 + m * m));
return (int) u;
}
// *********************************************
//************* cleanBoundory ********************
//**********************************************
static void cleanBoundory(Graphics g, Polygon poly) {
g.setColor(Color.white);
for (int j = 0; j <= 3000; j++) {
for (int i = 0; i <= 4000; i++) {
if (!poly.contains(i, j)) {
g.drawLine(i, j, i, j);
}
}
}
return;
}
// *********************************************
//************* createPointP3 ********************
//**********************************************
static Point createPointP3(Polygon poly, Point p1, Point p2,
int minimalDistance, int flag) {
Point p3 = new Point();
boolean outside = true;
Random r = new Random();
double distance = 0;
int sidelength;
double m; // The slope of the segment from P1 to P2
Point mp = new Point();
double u;
sidelength = (int) Math.sqrt(quadrat(p1.getX() - p2.getX()) +
quadrat(p1.getY() - p2.getY()));
mp.x = (int) ( (p1.getX() + p2.getX()) / 2);
mp.y = (int) ( (p1.getY() + p2.getY()) / 2);
m = (p1.getY() - p2.getY()) / (p1.getX() - p2.getX());
u = flag * (sidelength * Math.sqrt(3)) / 2;
p3.x = (int) (mp.getX() + (m * u) / Math.sqrt(1 + m * m));
p3.y = (int) (mp.getY() - (u) / Math.sqrt(1 + m * m));
return p3;
}
// *********************************************
//************* doDrawing **********************
//**********************************************
private void doDrawing(Graphics g) {
Graphics2D g2d = (Graphics2D) g;
g2d.setColor(Color.blue);
Dimension size = getSize();
Insets insets = getInsets();
int[] xcoords = new int[300];
int[] ycoords = new int[300];
boolean distanceOkay = false;
double distance_ = 0;
int sideLengthOfTheTriangle = 50;
// ****************
int xPoly[] = {
50, 150, 225, 275, 350, 175, 30};
int yPoly[] = {
50, 50, 25, 125, 150, 275, 200};
Polygon poly = new Polygon(xPoly, yPoly, xPoly.length);
g2d.drawPolygon(poly);
// ********************************
Point p1 = new Point();
Point p2 = new Point();
Point p3 = new Point();
int sidelength;
double u;
int i = 0;
Point mp = new Point();
double m; // The slope of the segment from P1 to P2
Random r = new Random();
boolean outside = true;
int hight = 0;
int hight1 = 0;
int w = size.width - insets.left - insets.right;
int h = size.height - insets.top - insets.bottom;
int xcoordinate = (int) (size.width / sideLengthOfTheTriangle);
int ycoordinate = (int) (size.height / sideLengthOfTheTriangle);
boolean firstRun = true;
for (int j = 0; j <= 100 * ycoordinate; ) {
for (i = 0; i <= 10 * xcoordinate; ) {
p1 = this.createPointP1(poly, size.width, size.height,
sideLengthOfTheTriangle, i, hight);
i++;
p2 = this.createPointP2(poly, size.width, size.height, p1,
sideLengthOfTheTriangle, i, hight);
xcoords[0] = (int) p1.getX();
ycoords[0] = (int) p1.getY();
xcoords[1] = (int) p2.getX();
ycoords[1] = (int) p2.getY();
p3 = createPointP3(poly, p1, p2, 50, 1);
if (firstRun) {
hight1 = getHight(poly, p1, p2, 50, 1);
firstRun = false;
}
xcoords[2] = (int) p3.getX();
ycoords[2] = (int) p3.getY();
if (poly.contains(p3.getX(), p3.getY()) ||
poly.contains(p2.getX(), p2.getY()) ||
poly.contains(p1.getX(), p1.getY())) {
g.drawLine( (int) p1.getX(), (int) p1.getY(), (int) p2.getX(),
(int) p2.getY());
g.drawLine( (int) p2.getX(), (int) p2.getY(), (int) p3.getX(),
(int) p3.getY());
g.drawLine( (int) p3.getX(), (int) p3.getY(), (int) p1.getX(),
(int) p1.getY());
System.out.println("(" + (int) p1.getX() + "," + (int) p1.getY() +
"); " + "(" + (int) p2.getX() + "," +
(int) p2.getY() + "); " + "(" + (int) p3.getX() +
"," + (int) p3.getY() + ")");
}
}
j = j + hight1;
hight = hight + hight1;
}
cleanBoundory(g2d, poly);
// ************************************
} // End of doDrawing
// @Override
public void paintComponent(Graphics g) {
super.paintComponent(g);
doDrawing(g);
}
public class Points
extends JFrame {
public Points() {
initUI();
}
private void initUI() {
setTitle("Points");
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
getContentPane().add(new TriangleMesh1());
setSize(400, 350);
setLocationRelativeTo(null);
}
}
public static void main(String[] args) {
SwingUtilities.invokeLater(new Runnable() {
TriangleMesh1 triangleMesh2 = new TriangleMesh1();
Points ps2 = triangleMesh2.new Points();
// @Override
public void run() {
ps2.setVisible(true);
}
});
}
}
Hier sind die Koordinaten der berechneten Knoten:
(203,30); (210,30); (206,23)
(210,30); (217,30); (213,23)
(217,30); (224,30); (220,23)
(224,30); (231,30); (227,23)
(189,36); (196,36); (192,29)
(196,36); (203,36); (199,29)
(203,36); (210,36); (206,29)
(210,36); (217,36); (213,29)
(217,36); (224,36); (220,29)
(224,36); (231,36); (227,29)
(168,42); (175,42); (171,35)
(175,42); (182,42); (178,35)
(182,42); (189,42); (185,35)
(189,42); (196,42); (192,35)
(196,42); (203,42); (199,35)
(203,42); (210,42); (206,35)
(210,42); (217,42); (213,35)
(217,42); (224,42); (220,35)
(224,42); (231,42); (227,35)
(231,42); (238,42); (234,35)
(154,48); (161,48); (157,41)
(161,48); (168,48); (164,41)
(168,48); (175,48); (171,41)
(175,48); (182,48); (178,41)
(182,48); (189,48); (185,41)
(189,48); (196,48); (192,41)
(196,48); (203,48); (199,41)
(203,48); (210,48); (206,41)
(210,48); (217,48); (213,41)
(217,48); (224,48); (220,41)
(224,48); (231,48); (227,41)
(231,48); (238,48); (234,41)
(49,54); (56,54); (52,47)
(56,54); (63,54); (59,47)
(63,54); (70,54); (66,47)
(70,54); (77,54); (73,47)
(77,54); (84,54); (80,47)
(84,54); (91,54); (87,47)
(91,54); (98,54); (94,47)
(98,54); (105,54); (101,47)
(105,54); (112,54); (108,47)
(112,54); (119,54); (115,47)
(119,54); (126,54); (122,47)
(126,54); (133,54); (129,47)
(133,54); (140,54); (136,47)
(140,54); (147,54); (143,47)
(147,54); (154,54); (150,47)
(154,54); (161,54); (157,47)
(161,54); (168,54); (164,47)
(168,54); (175,54); (171,47)
(175,54); (182,54); (178,47)
(182,54); (189,54); (185,47)
(189,54); (196,54); (192,47)
(196,54); (203,54); (199,47)
(203,54); (210,54); (206,47)
(210,54); (217,54); (213,47)
(217,54); (224,54); (220,47)
(224,54); (231,54); (227,47)
(231,54); (238,54); (234,47)
(238,54); (245,54); (241,47)
(42,60); (49,60); (45,53)
(49,60); (56,60); (52,53)
(56,60); (63,60); (59,53)
(63,60); (70,60); (66,53)
(70,60); (77,60); (73,53)
(77,60); (84,60); (80,53)
(84,60); (91,60); (87,53)
(91,60); (98,60); (94,53)
(98,60); (105,60); (101,53)
(105,60); (112,60); (108,53)
(112,60); (119,60); (115,53)
(119,60); (126,60); (122,53)
(126,60); (133,60); (129,53)
(133,60); (140,60); (136,53)
(140,60); (147,60); (143,53)
(147,60); (154,60); (150,53)
(154,60); (161,60); (157,53)
(161,60); (168,60); (164,53)
(168,60); (175,60); (171,53)
(175,60); (182,60); (178,53)
(182,60); (189,60); (185,53)
(189,60); (196,60); (192,53)
(196,60); (203,60); (199,53)
(203,60); (210,60); (206,53)
(210,60); (217,60); (213,53)
(217,60); (224,60); (220,53)
(224,60); (231,60); (227,53)
(231,60); (238,60); (234,53)
(238,60); (245,60); (241,53)
(42,66); (49,66); (45,59)
(49,66); (56,66); (52,59)
(56,66); (63,66); (59,59)
(63,66); (70,66); (66,59)
(70,66); (77,66); (73,59)
(77,66); (84,66); (80,59)
(84,66); (91,66); (87,59)
(91,66); (98,66); (94,59)
(98,66); (105,66); (101,59)
(105,66); (112,66); (108,59)
(112,66); (119,66); (115,59)
(119,66); (126,66); (122,59)
(126,66); (133,66); (129,59)
(133,66); (140,66); (136,59)
(140,66); (147,66); (143,59)
(147,66); (154,66); (150,59)
(154,66); (161,66); (157,59)
(161,66); (168,66); (164,59)
(168,66); (175,66); (171,59)
(175,66); (182,66); (178,59)
(182,66); (189,66); (185,59)
(189,66); (196,66); (192,59)
(196,66); (203,66); (199,59)
(203,66); (210,66); (206,59)
(210,66); (217,66); (213,59)
(217,66); (224,66); (220,59)
(224,66); (231,66); (227,59)
(231,66); (238,66); (234,59)
(238,66); (245,66); (241,59)
(245,66); (252,66); (248,59)
(42,72); (49,72); (45,65)
(49,72); (56,72); (52,65)
(56,72); (63,72); (59,65)
(63,72); (70,72); (66,65)
(70,72); (77,72); (73,65)
(77,72); (84,72); (80,65)
(84,72); (91,72); (87,65)
(91,72); (98,72); (94,65)
(98,72); (105,72); (101,65)
(105,72); (112,72); (108,65)
(112,72); (119,72); (115,65)
(119,72); (126,72); (122,65)
(126,72); (133,72); (129,65)
(133,72); (140,72); (136,65)
(140,72); (147,72); (143,65)
(147,72); (154,72); (150,65)
(154,72); (161,72); (157,65)
(161,72); (168,72); (164,65)
(168,72); (175,72); (171,65)
(175,72); (182,72); (178,65)
(182,72); (189,72); (185,65)
(189,72); (196,72); (192,65)
(196,72); (203,72); (199,65)
(203,72); (210,72); (206,65)
(210,72); (217,72); (213,65)
(217,72); (224,72); (220,65)
(224,72); (231,72); (227,65)
(231,72); (238,72); (234,65)
(238,72); (245,72); (241,65)
(245,72); (252,72); (248,65)
(42,78); (49,78); (45,71)
(49,78); (56,78); (52,71)
(56,78); (63,78); (59,71)
(63,78); (70,78); (66,71)
(70,78); (77,78); (73,71)
(77,78); (84,78); (80,71)
(84,78); (91,78); (87,71)
(91,78); (98,78); (94,71)
(98,78); (105,78); (101,71)
(105,78); (112,78); (108,71)
(112,78); (119,78); (115,71)
(119,78); (126,78); (122,71)
(126,78); (133,78); (129,71)
(133,78); (140,78); (136,71)
(140,78); (147,78); (143,71)
(147,78); (154,78); (150,71)
(154,78); (161,78); (157,71)
(161,78); (168,78); (164,71)
(168,78); (175,78); (171,71)
(175,78); (182,78); (178,71)
(182,78); (189,78); (185,71)
(189,78); (196,78); (192,71)
(196,78); (203,78); (199,71)
(203,78); (210,78); (206,71)
(210,78); (217,78); (213,71)
(217,78); (224,78); (220,71)
(224,78); (231,78); (227,71)
(231,78); (238,78); (234,71)
(238,78); (245,78); (241,71)
(245,78); (252,78); (248,71)
(42,84); (49,84); (45,77)
(49,84); (56,84); (52,77)
(56,84); (63,84); (59,77)
(63,84); (70,84); (66,77)
(70,84); (77,84); (73,77)
(77,84); (84,84); (80,77)
(84,84); (91,84); (87,77)
(91,84); (98,84); (94,77)
(98,84); (105,84); (101,77)
(105,84); (112,84); (108,77)
(112,84); (119,84); (115,77)
(119,84); (126,84); (122,77)
(126,84); (133,84); (129,77)
(133,84); (140,84); (136,77)
(140,84); (147,84); (143,77)
(147,84); (154,84); (150,77)
(154,84); (161,84); (157,77)
(161,84); (168,84); (164,77)
(168,84); (175,84); (171,77)
(175,84); (182,84); (178,77)
(182,84); (189,84); (185,77)
(189,84); (196,84); (192,77)
(196,84); (203,84); (199,77)
(203,84); (210,84); (206,77)
(210,84); (217,84); (213,77)
(217,84); (224,84); (220,77)
(224,84); (231,84); (227,77)
(231,84); (238,84); (234,77)
(238,84); (245,84); (241,77)
(245,84); (252,84); (248,77)
(252,84); (259,84); (255,77)
(42,90); (49,90); (45,83)
(49,90); (56,90); (52,83)
(56,90); (63,90); (59,83)
(63,90); (70,90); (66,83)
(70,90); (77,90); (73,83)
(77,90); (84,90); (80,83)
(84,90); (91,90); (87,83)
(91,90); (98,90); (94,83)
(98,90); (105,90); (101,83)
(105,90); (112,90); (108,83)
(112,90); (119,90); (115,83)
(119,90); (126,90); (122,83)
(126,90); (133,90); (129,83)
(133,90); (140,90); (136,83)
(140,90); (147,90); (143,83)
(147,90); (154,90); (150,83)
(154,90); (161,90); (157,83)
(161,90); (168,90); (164,83)
(168,90); (175,90); (171,83)
(175,90); (182,90); (178,83)
(182,90); (189,90); (185,83)
(189,90); (196,90); (192,83)
(196,90); (203,90); (199,83)
(203,90); (210,90); (206,83)
(210,90); (217,90); (213,83)
(217,90); (224,90); (220,83)
(224,90); (231,90); (227,83)
(231,90); (238,90); (234,83)
(238,90); (245,90); (241,83)
(245,90); (252,90); (248,83)
(252,90); (259,90); (255,83)
(42,96); (49,96); (45,89)
(49,96); (56,96); (52,89)
(56,96); (63,96); (59,89)
(63,96); (70,96); (66,89)
(70,96); (77,96); (73,89)
(77,96); (84,96); (80,89)
(84,96); (91,96); (87,89)
(91,96); (98,96); (94,89)
(98,96); (105,96); (101,89)
(105,96); (112,96); (108,89)
(112,96); (119,96); (115,89)
(119,96); (126,96); (122,89)
(126,96); (133,96); (129,89)
(133,96); (140,96); (136,89)
(140,96); (147,96); (143,89)
(147,96); (154,96); (150,89)
(154,96); (161,96); (157,89)
(161,96); (168,96); (164,89)
(168,96); (175,96); (171,89)
(175,96); (182,96); (178,89)
(182,96); (189,96); (185,89)
(189,96); (196,96); (192,89)
(196,96); (203,96); (199,89)
(203,96); (210,96); (206,89)
(210,96); (217,96); (213,89)
(217,96); (224,96); (220,89)
(224,96); (231,96); (227,89)
(231,96); (238,96); (234,89)
(238,96); (245,96); (241,89)
(245,96); (252,96); (248,89)
(252,96); (259,96); (255,89)
(259,96); (266,96); (262,89)
(42,102); (49,102); (45,95)
(49,102); (56,102); (52,95)
(56,102); (63,102); (59,95)
(63,102); (70,102); (66,95)
(70,102); (77,102); (73,95)
(77,102); (84,102); (80,95)
(84,102); (91,102); (87,95)
(91,102); (98,102); (94,95)
(98,102); (105,102); (101,95)
(105,102); (112,102); (108,95)
(112,102); (119,102); (115,95)
(119,102); (126,102); (122,95)
(126,102); (133,102); (129,95)
(133,102); (140,102); (136,95)
(140,102); (147,102); (143,95)
(147,102); (154,102); (150,95)
(154,102); (161,102); (157,95)
(161,102); (168,102); (164,95)
(168,102); (175,102); (171,95)
(175,102); (182,102); (178,95)
(182,102); (189,102); (185,95)
(189,102); (196,102); (192,95)
(196,102); (203,102); (199,95)
(203,102); (210,102); (206,95)
(210,102); (217,102); (213,95)
(217,102); (224,102); (220,95)
(224,102); (231,102); (227,95)
(231,102); (238,102); (234,95)
(238,102); (245,102); (241,95)
(245,102); (252,102); (248,95)
(252,102); (259,102); (255,95)
(259,102); (266,102); (262,95)
(42,108); (49,108); (45,101)
(49,108); (56,108); (52,101)
(56,108); (63,108); (59,101)
(63,108); (70,108); (66,101)
(70,108); (77,108); (73,101)
(77,108); (84,108); (80,101)
(84,108); (91,108); (87,101)
(91,108); (98,108); (94,101)
(98,108); (105,108); (101,101)
(105,108); (112,108); (108,101)
(112,108); (119,108); (115,101)
(119,108); (126,108); (122,101)
(126,108); (133,108); (129,101)
(133,108); (140,108); (136,101)
(140,108); (147,108); (143,101)
(147,108); (154,108); (150,101)
(154,108); (161,108); (157,101)
(161,108); (168,108); (164,101)
(168,108); (175,108); (171,101)
(175,108); (182,108); (178,101)
(182,108); (189,108); (185,101)
(189,108); (196,108); (192,101)
(196,108); (203,108); (199,101)
(203,108); (210,108); (206,101)
(210,108); (217,108); (213,101)
(217,108); (224,108); (220,101)
(224,108); (231,108); (227,101)
(231,108); (238,108); (234,101)
(238,108); (245,108); (241,101)
(245,108); (252,108); (248,101)
(252,108); (259,108); (255,101)
(259,108); (266,108); (262,101)
(266,108); (273,108); (269,101)
(35,114); (42,114); (38,107)
(42,114); (49,114); (45,107)
(49,114); (56,114); (52,107)
(56,114); (63,114); (59,107)
(63,114); (70,114); (66,107)
(70,114); (77,114); (73,107)
(77,114); (84,114); (80,107)
(84,114); (91,114); (87,107)
(91,114); (98,114); (94,107)
(98,114); (105,114); (101,107)
(105,114); (112,114); (108,107)
(112,114); (119,114); (115,107)
(119,114); (126,114); (122,107)
(126,114); (133,114); (129,107)
(133,114); (140,114); (136,107)
(140,114); (147,114); (143,107)
(147,114); (154,114); (150,107)
(154,114); (161,114); (157,107)
(161,114); (168,114); (164,107)
(168,114); (175,114); (171,107)
(175,114); (182,114); (178,107)
(182,114); (189,114); (185,107)
(189,114); (196,114); (192,107)
(196,114); (203,114); (199,107)
(203,114); (210,114); (206,107)
(210,114); (217,114); (213,107)
(217,114); (224,114); (220,107)
(224,114); (231,114); (227,107)
(231,114); (238,114); (234,107)
(238,114); (245,114); (241,107)
(245,114); (252,114); (248,107)
(252,114); (259,114); (255,107)
(259,114); (266,114); (262,107)
(266,114); (273,114); (269,107)
(35,120); (42,120); (38,113)
(42,120); (49,120); (45,113)
(49,120); (56,120); (52,113)
(56,120); (63,120); (59,113)
(63,120); (70,120); (66,113)
(70,120); (77,120); (73,113)
(77,120); (84,120); (80,113)
(84,120); (91,120); (87,113)
(91,120); (98,120); (94,113)
(98,120); (105,120); (101,113)
(105,120); (112,120); (108,113)
(112,120); (119,120); (115,113)
(119,120); (126,120); (122,113)
(126,120); (133,120); (129,113)
(133,120); (140,120); (136,113)
(140,120); (147,120); (143,113)
(147,120); (154,120); (150,113)
(154,120); (161,120); (157,113)
(161,120); (168,120); (164,113)
(168,120); (175,120); (171,113)
(175,120); (182,120); (178,113)
(182,120); (189,120); (185,113)
(189,120); (196,120); (192,113)
(196,120); (203,120); (199,113)
(203,120); (210,120); (206,113)
(210,120); (217,120); (213,113)
(217,120); (224,120); (220,113)
(224,120); (231,120); (227,113)
(231,120); (238,120); (234,113)
(238,120); (245,120); (241,113)
(245,120); (252,120); (248,113)
(252,120); (259,120); (255,113)
(259,120); (266,120); (262,113)
(266,120); (273,120); (269,113)
(35,126); (42,126); (38,119)
(42,126); (49,126); (45,119)
(49,126); (56,126); (52,119)
(56,126); (63,126); (59,119)
(63,126); (70,126); (66,119)
(70,126); (77,126); (73,119)
(77,126); (84,126); (80,119)
(84,126); (91,126); (87,119)
(91,126); (98,126); (94,119)
(98,126); (105,126); (101,119)
(105,126); (112,126); (108,119)
(112,126); (119,126); (115,119)
(119,126); (126,126); (122,119)
(126,126); (133,126); (129,119)
(133,126); (140,126); (136,119)
(140,126); (147,126); (143,119)
(147,126); (154,126); (150,119)
(154,126); (161,126); (157,119)
(161,126); (168,126); (164,119)
(168,126); (175,126); (171,119)
(175,126); (182,126); (178,119)
(182,126); (189,126); (185,119)
(189,126); (196,126); (192,119)
(196,126); (203,126); (199,119)
(203,126); (210,126); (206,119)
(210,126); (217,126); (213,119)
(217,126); (224,126); (220,119)
(224,126); (231,126); (227,119)
(231,126); (238,126); (234,119)
(238,126); (245,126); (241,119)
(245,126); (252,126); (248,119)
(252,126); (259,126); (255,119)
(259,126); (266,126); (262,119)
(266,126); (273,126); (269,119)
(273,126); (280,126); (276,119)
(35,132); (42,132); (38,125)
(42,132); (49,132); (45,125)
(49,132); (56,132); (52,125)
(56,132); (63,132); (59,125)
(63,132); (70,132); (66,125)
(70,132); (77,132); (73,125)
(77,132); (84,132); (80,125)
(84,132); (91,132); (87,125)
(91,132); (98,132); (94,125)
(98,132); (105,132); (101,125)
(105,132); (112,132); (108,125)
(112,132); (119,132); (115,125)
(119,132); (126,132); (122,125)
(126,132); (133,132); (129,125)
(133,132); (140,132); (136,125)
(140,132); (147,132); (143,125)
(147,132); (154,132); (150,125)
(154,132); (161,132); (157,125)
(161,132); (168,132); (164,125)
(168,132); (175,132); (171,125)
(175,132); (182,132); (178,125)
(182,132); (189,132); (185,125)
(189,132); (196,132); (192,125)
(196,132); (203,132); (199,125)
(203,132); (210,132); (206,125)
(210,132); (217,132); (213,125)
(217,132); (224,132); (220,125)
(224,132); (231,132); (227,125)
(231,132); (238,132); (234,125)
(238,132); (245,132); (241,125)
(245,132); (252,132); (248,125)
(252,132); (259,132); (255,125)
(259,132); (266,132); (262,125)
(266,132); (273,132); (269,125)
(273,132); (280,132); (276,125)
(280,132); (287,132); (283,125)
(287,132); (294,132); (290,125)
(294,132); (301,132); (297,125)
(35,138); (42,138); (38,131)
(42,138); (49,138); (45,131)
(49,138); (56,138); (52,131)
(56,138); (63,138); (59,131)
(63,138); (70,138); (66,131)
(70,138); (77,138); (73,131)
(77,138); (84,138); (80,131)
(84,138); (91,138); (87,131)
(91,138); (98,138); (94,131)
(98,138); (105,138); (101,131)
(105,138); (112,138); (108,131)
(112,138); (119,138); (115,131)
(119,138); (126,138); (122,131)
(126,138); (133,138); (129,131)
(133,138); (140,138); (136,131)
(140,138); (147,138); (143,131)
(147,138); (154,138); (150,131)
(154,138); (161,138); (157,131)
(161,138); (168,138); (164,131)
(168,138); (175,138); (171,131)
(175,138); (182,138); (178,131)
(182,138); (189,138); (185,131)
(189,138); (196,138); (192,131)
(196,138); (203,138); (199,131)
(203,138); (210,138); (206,131)
(210,138); (217,138); (213,131)
(217,138); (224,138); (220,131)
(224,138); (231,138); (227,131)
(231,138); (238,138); (234,131)
(238,138); (245,138); (241,131)
(245,138); (252,138); (248,131)
(252,138); (259,138); (255,131)
(259,138); (266,138); (262,131)
(266,138); (273,138); (269,131)
(273,138); (280,138); (276,131)
(280,138); (287,138); (283,131)
(287,138); (294,138); (290,131)
(294,138); (301,138); (297,131)
(301,138); (308,138); (304,131)
(308,138); (315,138); (311,131)
(35,144); (42,144); (38,137)
(42,144); (49,144); (45,137)
(49,144); (56,144); (52,137)
(56,144); (63,144); (59,137)
(63,144); (70,144); (66,137)
(70,144); (77,144); (73,137)
(77,144); (84,144); (80,137)
(84,144); (91,144); (87,137)
(91,144); (98,144); (94,137)
(98,144); (105,144); (101,137)
(105,144); (112,144); (108,137)
(112,144); (119,144); (115,137)
(119,144); (126,144); (122,137)
(126,144); (133,144); (129,137)
(133,144); (140,144); (136,137)
(140,144); (147,144); (143,137)
(147,144); (154,144); (150,137)
(154,144); (161,144); (157,137)
(161,144); (168,144); (164,137)
(168,144); (175,144); (171,137)
(175,144); (182,144); (178,137)
(182,144); (189,144); (185,137)
(189,144); (196,144); (192,137)
(196,144); (203,144); (199,137)
(203,144); (210,144); (206,137)
(210,144); (217,144); (213,137)
(217,144); (224,144); (220,137)
(224,144); (231,144); (227,137)
(231,144); (238,144); (234,137)
(238,144); (245,144); (241,137)
(245,144); (252,144); (248,137)
(252,144); (259,144); (255,137)
(259,144); (266,144); (262,137)
(266,144); (273,144); (269,137)
(273,144); (280,144); (276,137)
(280,144); (287,144); (283,137)
(287,144); (294,144); (290,137)
(294,144); (301,144); (297,137)
(301,144); (308,144); (304,137)
(308,144); (315,144); (311,137)
(315,144); (322,144); (318,137)
(322,144); (329,144); (325,137)
(329,144); (336,144); (332,137)
(35,150); (42,150); (38,143)
(42,150); (49,150); (45,143)
(49,150); (56,150); (52,143)
(56,150); (63,150); (59,143)
(63,150); (70,150); (66,143)
(70,150); (77,150); (73,143)
(77,150); (84,150); (80,143)
(84,150); (91,150); (87,143)
(91,150); (98,150); (94,143)
(98,150); (105,150); (101,143)
(105,150); (112,150); (108,143)
(112,150); (119,150); (115,143)
(119,150); (126,150); (122,143)
(126,150); (133,150); (129,143)
(133,150); (140,150); (136,143)
(140,150); (147,150); (143,143)
(147,150); (154,150); (150,143)
(154,150); (161,150); (157,143)
(161,150); (168,150); (164,143)
(168,150); (175,150); (171,143)
(175,150); (182,150); (178,143)
(182,150); (189,150); (185,143)
(189,150); (196,150); (192,143)
(196,150); (203,150); (199,143)
(203,150); (210,150); (206,143)
(210,150); (217,150); (213,143)
(217,150); (224,150); (220,143)
(224,150); (231,150); (227,143)
(231,150); (238,150); (234,143)
(238,150); (245,150); (241,143)
(245,150); (252,150); (248,143)
(252,150); (259,150); (255,143)
(259,150); (266,150); (262,143)
(266,150); (273,150); (269,143)
(273,150); (280,150); (276,143)
(280,150); (287,150); (283,143)
(287,150); (294,150); (290,143)
(294,150); (301,150); (297,143)
(301,150); (308,150); (304,143)
(308,150); (315,150); (311,143)
(315,150); (322,150); (318,143)
(322,150); (329,150); (325,143)
(329,150); (336,150); (332,143)
(336,150); (343,150); (339,143)
(343,150); (350,150); (346,143)
(35,156); (42,156); (38,149)
(42,156); (49,156); (45,149)
(49,156); (56,156); (52,149)
(56,156); (63,156); (59,149)
(63,156); (70,156); (66,149)
(70,156); (77,156); (73,149)
(77,156); (84,156); (80,149)
(84,156); (91,156); (87,149)
(91,156); (98,156); (94,149)
(98,156); (105,156); (101,149)
(105,156); (112,156); (108,149)
(112,156); (119,156); (115,149)
(119,156); (126,156); (122,149)
(126,156); (133,156); (129,149)
(133,156); (140,156); (136,149)
(140,156); (147,156); (143,149)
(147,156); (154,156); (150,149)
(154,156); (161,156); (157,149)
(161,156); (168,156); (164,149)
(168,156); (175,156); (171,149)
(175,156); (182,156); (178,149)
(182,156); (189,156); (185,149)
(189,156); (196,156); (192,149)
(196,156); (203,156); (199,149)
(203,156); (210,156); (206,149)
(210,156); (217,156); (213,149)
(217,156); (224,156); (220,149)
(224,156); (231,156); (227,149)
(231,156); (238,156); (234,149)
(238,156); (245,156); (241,149)
(245,156); (252,156); (248,149)
(252,156); (259,156); (255,149)
(259,156); (266,156); (262,149)
(266,156); (273,156); (269,149)
(273,156); (280,156); (276,149)
(280,156); (287,156); (283,149)
(287,156); (294,156); (290,149)
(294,156); (301,156); (297,149)
(301,156); (308,156); (304,149)
(308,156); (315,156); (311,149)
(315,156); (322,156); (318,149)
(322,156); (329,156); (325,149)
(329,156); (336,156); (332,149)
(336,156); (343,156); (339,149)
(343,156); (350,156); (346,149)
(35,162); (42,162); (38,155)
(42,162); (49,162); (45,155)
(49,162); (56,162); (52,155)
(56,162); (63,162); (59,155)
(63,162); (70,162); (66,155)
(70,162); (77,162); (73,155)
(77,162); (84,162); (80,155)
(84,162); (91,162); (87,155)
(91,162); (98,162); (94,155)
(98,162); (105,162); (101,155)
(105,162); (112,162); (108,155)
(112,162); (119,162); (115,155)
(119,162); (126,162); (122,155)
(126,162); (133,162); (129,155)
(133,162); (140,162); (136,155)
(140,162); (147,162); (143,155)
(147,162); (154,162); (150,155)
(154,162); (161,162); (157,155)
(161,162); (168,162); (164,155)
(168,162); (175,162); (171,155)
(175,162); (182,162); (178,155)
(182,162); (189,162); (185,155)
(189,162); (196,162); (192,155)
(196,162); (203,162); (199,155)
(203,162); (210,162); (206,155)
(210,162); (217,162); (213,155)
(217,162); (224,162); (220,155)
(224,162); (231,162); (227,155)
(231,162); (238,162); (234,155)
(238,162); (245,162); (241,155)
(245,162); (252,162); (248,155)
(252,162); (259,162); (255,155)
(259,162); (266,162); (262,155)
(266,162); (273,162); (269,155)
(273,162); (280,162); (276,155)
(280,162); (287,162); (283,155)
(287,162); (294,162); (290,155)
(294,162); (301,162); (297,155)
(301,162); (308,162); (304,155)
(308,162); (315,162); (311,155)
(315,162); (322,162); (318,155)
(322,162); (329,162); (325,155)
(329,162); (336,162); (332,155)
(336,162); (343,162); (339,155)
(28,168); (35,168); (31,161)
(35,168); (42,168); (38,161)
(42,168); (49,168); (45,161)
(49,168); (56,168); (52,161)
(56,168); (63,168); (59,161)
(63,168); (70,168); (66,161)
(70,168); (77,168); (73,161)
(77,168); (84,168); (80,161)
(84,168); (91,168); (87,161)
(91,168); (98,168); (94,161)
(98,168); (105,168); (101,161)
(105,168); (112,168); (108,161)
(112,168); (119,168); (115,161)
(119,168); (126,168); (122,161)
(126,168); (133,168); (129,161)
(133,168); (140,168); (136,161)
(140,168); (147,168); (143,161)
(147,168); (154,168); (150,161)
(154,168); (161,168); (157,161)
(161,168); (168,168); (164,161)
(168,168); (175,168); (171,161)
(175,168); (182,168); (178,161)
(182,168); (189,168); (185,161)
(189,168); (196,168); (192,161)
(196,168); (203,168); (199,161)
(203,168); (210,168); (206,161)
(210,168); (217,168); (213,161)
(217,168); (224,168); (220,161)
(224,168); (231,168); (227,161)
(231,168); (238,168); (234,161)
(238,168); (245,168); (241,161)
(245,168); (252,168); (248,161)
(252,168); (259,168); (255,161)
(259,168); (266,168); (262,161)
(266,168); (273,168); (269,161)
(273,168); (280,168); (276,161)
(280,168); (287,168); (283,161)
(287,168); (294,168); (290,161)
(294,168); (301,168); (297,161)
(301,168); (308,168); (304,161)
(308,168); (315,168); (311,161)
(315,168); (322,168); (318,161)
(322,168); (329,168); (325,161)
(329,168); (336,168); (332,161)
(28,174); (35,174); (31,167)
(35,174); (42,174); (38,167)
(42,174); (49,174); (45,167)
(49,174); (56,174); (52,167)
(56,174); (63,174); (59,167)
(63,174); (70,174); (66,167)
(70,174); (77,174); (73,167)
(77,174); (84,174); (80,167)
(84,174); (91,174); (87,167)
(91,174); (98,174); (94,167)
(98,174); (105,174); (101,167)
(105,174); (112,174); (108,167)
(112,174); (119,174); (115,167)
(119,174); (126,174); (122,167)
(126,174); (133,174); (129,167)
(133,174); (140,174); (136,167)
(140,174); (147,174); (143,167)
(147,174); (154,174); (150,167)
(154,174); (161,174); (157,167)
(161,174); (168,174); (164,167)
(168,174); (175,174); (171,167)
(175,174); (182,174); (178,167)
(182,174); (189,174); (185,167)
(189,174); (196,174); (192,167)
(196,174); (203,174); (199,167)
(203,174); (210,174); (206,167)
(210,174); (217,174); (213,167)
(217,174); (224,174); (220,167)
(224,174); (231,174); (227,167)
(231,174); (238,174); (234,167)
(238,174); (245,174); (241,167)
(245,174); (252,174); (248,167)
(252,174); (259,174); (255,167)
(259,174); (266,174); (262,167)
(266,174); (273,174); (269,167)
(273,174); (280,174); (276,167)
(280,174); (287,174); (283,167)
(287,174); (294,174); (290,167)
(294,174); (301,174); (297,167)
(301,174); (308,174); (304,167)
(308,174); (315,174); (311,167)
(315,174); (322,174); (318,167)
(322,174); (329,174); (325,167)
(28,180); (35,180); (31,173)
(35,180); (42,180); (38,173)
(42,180); (49,180); (45,173)
(49,180); (56,180); (52,173)
(56,180); (63,180); (59,173)
(63,180); (70,180); (66,173)
(70,180); (77,180); (73,173)
(77,180); (84,180); (80,173)
(84,180); (91,180); (87,173)
(91,180); (98,180); (94,173)
(98,180); (105,180); (101,173)
(105,180); (112,180); (108,173)
(112,180); (119,180); (115,173)
(119,180); (126,180); (122,173)
(126,180); (133,180); (129,173)
(133,180); (140,180); (136,173)
(140,180); (147,180); (143,173)
(147,180); (154,180); (150,173)
(154,180); (161,180); (157,173)
(161,180); (168,180); (164,173)
(168,180); (175,180); (171,173)
(175,180); (182,180); (178,173)
(182,180); (189,180); (185,173)
(189,180); (196,180); (192,173)
(196,180); (203,180); (199,173)
(203,180); (210,180); (206,173)
(210,180); (217,180); (213,173)
(217,180); (224,180); (220,173)
(224,180); (231,180); (227,173)
(231,180); (238,180); (234,173)
(238,180); (245,180); (241,173)
(245,180); (252,180); (248,173)
(252,180); (259,180); (255,173)
(259,180); (266,180); (262,173)
(266,180); (273,180); (269,173)
(273,180); (280,180); (276,173)
(280,180); (287,180); (283,173)
(287,180); (294,180); (290,173)
(294,180); (301,180); (297,173)
(301,180); (308,180); (304,173)
(308,180); (315,180); (311,173)
(28,186); (35,186); (31,179)
(35,186); (42,186); (38,179)
(42,186); (49,186); (45,179)
(49,186); (56,186); (52,179)
(56,186); (63,186); (59,179)
(63,186); (70,186); (66,179)
(70,186); (77,186); (73,179)
(77,186); (84,186); (80,179)
(84,186); (91,186); (87,179)
(91,186); (98,186); (94,179)
(98,186); (105,186); (101,179)
(105,186); (112,186); (108,179)
(112,186); (119,186); (115,179)
(119,186); (126,186); (122,179)
(126,186); (133,186); (129,179)
(133,186); (140,186); (136,179)
(140,186); (147,186); (143,179)
(147,186); (154,186); (150,179)
(154,186); (161,186); (157,179)
(161,186); (168,186); (164,179)
(168,186); (175,186); (171,179)
(175,186); (182,186); (178,179)
(182,186); (189,186); (185,179)
(189,186); (196,186); (192,179)
(196,186); (203,186); (199,179)
(203,186); (210,186); (206,179)
(210,186); (217,186); (213,179)
(217,186); (224,186); (220,179)
(224,186); (231,186); (227,179)
(231,186); (238,186); (234,179)
(238,186); (245,186); (241,179)
(245,186); (252,186); (248,179)
(252,186); (259,186); (255,179)
(259,186); (266,186); (262,179)
(266,186); (273,186); (269,179)
(273,186); (280,186); (276,179)
(280,186); (287,186); (283,179)
(287,186); (294,186); (290,179)
(294,186); (301,186); (297,179)
(301,186); (308,186); (304,179)
(28,192); (35,192); (31,185)
(35,192); (42,192); (38,185)
(42,192); (49,192); (45,185)
(49,192); (56,192); (52,185)
(56,192); (63,192); (59,185)
(63,192); (70,192); (66,185)
(70,192); (77,192); (73,185)
(77,192); (84,192); (80,185)
(84,192); (91,192); (87,185)
(91,192); (98,192); (94,185)
(98,192); (105,192); (101,185)
(105,192); (112,192); (108,185)
(112,192); (119,192); (115,185)
(119,192); (126,192); (122,185)
(126,192); (133,192); (129,185)
(133,192); (140,192); (136,185)
(140,192); (147,192); (143,185)
(147,192); (154,192); (150,185)
(154,192); (161,192); (157,185)
(161,192); (168,192); (164,185)
(168,192); (175,192); (171,185)
(175,192); (182,192); (178,185)
(182,192); (189,192); (185,185)
(189,192); (196,192); (192,185)
(196,192); (203,192); (199,185)
(203,192); (210,192); (206,185)
(210,192); (217,192); (213,185)
(217,192); (224,192); (220,185)
(224,192); (231,192); (227,185)
(231,192); (238,192); (234,185)
(238,192); (245,192); (241,185)
(245,192); (252,192); (248,185)
(252,192); (259,192); (255,185)
(259,192); (266,192); (262,185)
(266,192); (273,192); (269,185)
(273,192); (280,192); (276,185)
(280,192); (287,192); (283,185)
(287,192); (294,192); (290,185)
(294,192); (301,192); (297,185)
(28,198); (35,198); (31,191)
(35,198); (42,198); (38,191)
(42,198); (49,198); (45,191)
(49,198); (56,198); (52,191)
(56,198); (63,198); (59,191)
(63,198); (70,198); (66,191)
(70,198); (77,198); (73,191)
(77,198); (84,198); (80,191)
(84,198); (91,198); (87,191)
(91,198); (98,198); (94,191)
(98,198); (105,198); (101,191)
(105,198); (112,198); (108,191)
(112,198); (119,198); (115,191)
(119,198); (126,198); (122,191)
(126,198); (133,198); (129,191)
(133,198); (140,198); (136,191)
(140,198); (147,198); (143,191)
(147,198); (154,198); (150,191)
(154,198); (161,198); (157,191)
(161,198); (168,198); (164,191)
(168,198); (175,198); (171,191)
(175,198); (182,198); (178,191)
(182,198); (189,198); (185,191)
(189,198); (196,198); (192,191)
(196,198); (203,198); (199,191)
(203,198); (210,198); (206,191)
(210,198); (217,198); (213,191)
(217,198); (224,198); (220,191)
(224,198); (231,198); (227,191)
(231,198); (238,198); (234,191)
(238,198); (245,198); (241,191)
(245,198); (252,198); (248,191)
(252,198); (259,198); (255,191)
(259,198); (266,198); (262,191)
(266,198); (273,198); (269,191)
(273,198); (280,198); (276,191)
(280,198); (287,198); (283,191)
(287,198); (294,198); (290,191)
(28,204); (35,204); (31,197)
(35,204); (42,204); (38,197)
(42,204); (49,204); (45,197)
(49,204); (56,204); (52,197)
(56,204); (63,204); (59,197)
(63,204); (70,204); (66,197)
(70,204); (77,204); (73,197)
(77,204); (84,204); (80,197)
(84,204); (91,204); (87,197)
(91,204); (98,204); (94,197)
(98,204); (105,204); (101,197)
(105,204); (112,204); (108,197)
(112,204); (119,204); (115,197)
(119,204); (126,204); (122,197)
(126,204); (133,204); (129,197)
(133,204); (140,204); (136,197)
(140,204); (147,204); (143,197)
(147,204); (154,204); (150,197)
(154,204); (161,204); (157,197)
(161,204); (168,204); (164,197)
(168,204); (175,204); (171,197)
(175,204); (182,204); (178,197)
(182,204); (189,204); (185,197)
(189,204); (196,204); (192,197)
(196,204); (203,204); (199,197)
(203,204); (210,204); (206,197)
(210,204); (217,204); (213,197)
(217,204); (224,204); (220,197)
(224,204); (231,204); (227,197)
(231,204); (238,204); (234,197)
(238,204); (245,204); (241,197)
(245,204); (252,204); (248,197)
(252,204); (259,204); (255,197)
(259,204); (266,204); (262,197)
(266,204); (273,204); (269,197)
(273,204); (280,204); (276,197)
(280,204); (287,204); (283,197)
(35,210); (42,210); (38,203)
(42,210); (49,210); (45,203)
(49,210); (56,210); (52,203)
(56,210); (63,210); (59,203)
(63,210); (70,210); (66,203)
(70,210); (77,210); (73,203)
(77,210); (84,210); (80,203)
(84,210); (91,210); (87,203)
(91,210); (98,210); (94,203)
(98,210); (105,210); (101,203)
(105,210); (112,210); (108,203)
(112,210); (119,210); (115,203)
(119,210); (126,210); (122,203)
(126,210); (133,210); (129,203)
(133,210); (140,210); (136,203)
(140,210); (147,210); (143,203)
(147,210); (154,210); (150,203)
(154,210); (161,210); (157,203)
(161,210); (168,210); (164,203)
(168,210); (175,210); (171,203)
(175,210); (182,210); (178,203)
(182,210); (189,210); (185,203)
(189,210); (196,210); (192,203)
(196,210); (203,210); (199,203)
(203,210); (210,210); (206,203)
(210,210); (217,210); (213,203)
(217,210); (224,210); (220,203)
(224,210); (231,210); (227,203)
(231,210); (238,210); (234,203)
(238,210); (245,210); (241,203)
(245,210); (252,210); (248,203)
(252,210); (259,210); (255,203)
(259,210); (266,210); (262,203)
(266,210); (273,210); (269,203)
(49,216); (56,216); (52,209)
(56,216); (63,216); (59,209)
(63,216); (70,216); (66,209)
(70,216); (77,216); (73,209)
(77,216); (84,216); (80,209)
(84,216); (91,216); (87,209)
(91,216); (98,216); (94,209)
(98,216); (105,216); (101,209)
(105,216); (112,216); (108,209)
(112,216); (119,216); (115,209)
(119,216); (126,216); (122,209)
(126,216); (133,216); (129,209)
(133,216); (140,216); (136,209)
(140,216); (147,216); (143,209)
(147,216); (154,216); (150,209)
(154,216); (161,216); (157,209)
(161,216); (168,216); (164,209)
(168,216); (175,216); (171,209)
(175,216); (182,216); (178,209)
(182,216); (189,216); (185,209)
(189,216); (196,216); (192,209)
(196,216); (203,216); (199,209)
(203,216); (210,216); (206,209)
(210,216); (217,216); (213,209)
(217,216); (224,216); (220,209)
(224,216); (231,216); (227,209)
(231,216); (238,216); (234,209)
(238,216); (245,216); (241,209)
(245,216); (252,216); (248,209)
(252,216); (259,216); (255,209)
(259,216); (266,216); (262,209)
(56,222); (63,222); (59,215)
(63,222); (70,222); (66,215)
(70,222); (77,222); (73,215)
(77,222); (84,222); (80,215)
(84,222); (91,222); (87,215)
(91,222); (98,222); (94,215)
(98,222); (105,222); (101,215)
(105,222); (112,222); (108,215)
(112,222); (119,222); (115,215)
(119,222); (126,222); (122,215)
(126,222); (133,222); (129,215)
(133,222); (140,222); (136,215)
(140,222); (147,222); (143,215)
(147,222); (154,222); (150,215)
(154,222); (161,222); (157,215)
(161,222); (168,222); (164,215)
(168,222); (175,222); (171,215)
(175,222); (182,222); (178,215)
(182,222); (189,222); (185,215)
(189,222); (196,222); (192,215)
(196,222); (203,222); (199,215)
(203,222); (210,222); (206,215)
(210,222); (217,222); (213,215)
(217,222); (224,222); (220,215)
(224,222); (231,222); (227,215)
(231,222); (238,222); (234,215)
(238,222); (245,222); (241,215)
(245,222); (252,222); (248,215)
(252,222); (259,222); (255,215)
(70,228); (77,228); (73,221)
(77,228); (84,228); (80,221)
(84,228); (91,228); (87,221)
(91,228); (98,228); (94,221)
(98,228); (105,228); (101,221)
(105,228); (112,228); (108,221)
(112,228); (119,228); (115,221)
(119,228); (126,228); (122,221)
(126,228); (133,228); (129,221)
(133,228); (140,228); (136,221)
(140,228); (147,228); (143,221)
(147,228); (154,228); (150,221)
(154,228); (161,228); (157,221)
(161,228); (168,228); (164,221)
(168,228); (175,228); (171,221)
(175,228); (182,228); (178,221)
(182,228); (189,228); (185,221)
(189,228); (196,228); (192,221)
(196,228); (203,228); (199,221)
(203,228); (210,228); (206,221)
(210,228); (217,228); (213,221)
(217,228); (224,228); (220,221)
(224,228); (231,228); (227,221)
(231,228); (238,228); (234,221)
(238,228); (245,228); (241,221)
(245,228); (252,228); (248,221)
(84,234); (91,234); (87,227)
(91,234); (98,234); (94,227)
(98,234); (105,234); (101,227)
(105,234); (112,234); (108,227)
(112,234); (119,234); (115,227)
(119,234); (126,234); (122,227)
(126,234); (133,234); (129,227)
(133,234); (140,234); (136,227)
(140,234); (147,234); (143,227)
(147,234); (154,234); (150,227)
(154,234); (161,234); (157,227)
(161,234); (168,234); (164,227)
(168,234); (175,234); (171,227)
(175,234); (182,234); (178,227)
(182,234); (189,234); (185,227)
(189,234); (196,234); (192,227)
(196,234); (203,234); (199,227)
(203,234); (210,234); (206,227)
(210,234); (217,234); (213,227)
(217,234); (224,234); (220,227)
(224,234); (231,234); (227,227)
(231,234); (238,234); (234,227)
(238,234); (245,234); (241,227)
(91,240); (98,240); (94,233)
(98,240); (105,240); (101,233)
(105,240); (112,240); (108,233)
(112,240); (119,240); (115,233)
(119,240); (126,240); (122,233)
(126,240); (133,240); (129,233)
(133,240); (140,240); (136,233)
(140,240); (147,240); (143,233)
(147,240); (154,240); (150,233)
(154,240); (161,240); (157,233)
(161,240); (168,240); (164,233)
(168,240); (175,240); (171,233)
(175,240); (182,240); (178,233)
(182,240); (189,240); (185,233)
(189,240); (196,240); (192,233)
(196,240); (203,240); (199,233)
(203,240); (210,240); (206,233)
(210,240); (217,240); (213,233)
(217,240); (224,240); (220,233)
(224,240); (231,240); (227,233)
(105,246); (112,246); (108,239)
(112,246); (119,246); (115,239)
(119,246); (126,246); (122,239)
(126,246); (133,246); (129,239)
(133,246); (140,246); (136,239)
(140,246); (147,246); (143,239)
(147,246); (154,246); (150,239)
(154,246); (161,246); (157,239)
(161,246); (168,246); (164,239)
(168,246); (175,246); (171,239)
(175,246); (182,246); (178,239)
(182,246); (189,246); (185,239)
(189,246); (196,246); (192,239)
(196,246); (203,246); (199,239)
(203,246); (210,246); (206,239)
(210,246); (217,246); (213,239)
(217,246); (224,246); (220,239)
(119,252); (126,252); (122,245)
(126,252); (133,252); (129,245)
(133,252); (140,252); (136,245)
(140,252); (147,252); (143,245)
(147,252); (154,252); (150,245)
(154,252); (161,252); (157,245)
(161,252); (168,252); (164,245)
(168,252); (175,252); (171,245)
(175,252); (182,252); (178,245)
(182,252); (189,252); (185,245)
(189,252); (196,252); (192,245)
(196,252); (203,252); (199,245)
(203,252); (210,252); (206,245)
(210,252); (217,252); (213,245)
(126,258); (133,258); (129,251)
(133,258); (140,258); (136,251)
(140,258); (147,258); (143,251)
(147,258); (154,258); (150,251)
(154,258); (161,258); (157,251)
(161,258); (168,258); (164,251)
(168,258); (175,258); (171,251)
(175,258); (182,258); (178,251)
(182,258); (189,258); (185,251)
(189,258); (196,258); (192,251)
(196,258); (203,258); (199,251)
(203,258); (210,258); (206,251)
(140,264); (147,264); (143,257)
(147,264); (154,264); (150,257)
(154,264); (161,264); (157,257)
(161,264); (168,264); (164,257)
(168,264); (175,264); (171,257)
(175,264); (182,264); (178,257)
(182,264); (189,264); (185,257)
(189,264); (196,264); (192,257)
(196,264); (203,264); (199,257)
(154,270); (161,270); (157,263)
(161,270); (168,270); (164,263)
(168,270); (175,270); (171,263)
(175,270); (182,270); (178,263)
(182,270); (189,270); (185,263)
(161,276); (168,276); (164,269)
(168,276); (175,276); (171,269)
(175,276); (182,276); (178,269)
Autor
Document
Kategorie
Kunst und Fotos
Seitenansichten
4 321
Dateigröße
1 270 KB
Tags
1/--Seiten
melden