In der vergangenen Woche hatten wir ein paar nützliche,
grafisch geometrische Algorithmen kennengelernt.
Und dieses Kapitel möchte ich heute zu Ende bringen mit einem
letzten Problem.
Und das in der Computergrafik
Dem Windowing und Clipping. Und dazu möchte ich zunächst
die beiden Begriffe, die da drin stechen.
Kurz erläutern. Wir haben den Begriff des Window unter einem Window
verstehen wir den abzubildenden Bereich aus oder Ausschnitt aus dem Weltkoordinatensystem.
Also wenn wir uns das hier so auf unsere natürliche Umwelt übertragen denken,
dann können wir uns vorstellen,
wir werfen einen Blick aus dem Fenster und sehen die Landschaft da draußen,
die Szene da draußen mit den Gebäuden, mit der Vegetation.
Und unser Fenster schneidet praktisch einen Teil dieser gesamten Szene dort draußen aus.
Die Szene ist, das wissen wir alle, aus Erfahrung erheblich größer.
Sie setzt sich in alle Rechnungen beliebig Waldfahrt,
aber durch das Fenster sehen wir nur einen gewissen Ausschnitt davon,
der eben von der Größe,
durch die Größe des Fensters begrenzt ist
Und das ist der Ausschnitt, den wir als Window bezeichnen.
Anders als eine bekannte Firma, die Computer herstellt und vor allen Dingen nein.
Betriebssysteme herstellt und die unter Window ein wenig anderes versteht.
Der zweite Begriff, der in Ergänzung zu dem Begriff Window
zu sehen ist, ist der Begriff Viewport.
Der Viewport ist tatsächlich der Teil bis Zielkoordinatensystems,
denen wir auf unserem Gerät, unserem Ausgabegerät sehen wollen.
Also auf unseren Bildschirmen oder auf unserem Druckerplotter. Das,
was da also als Ausschnitt definiert ist und wohin wir
Grafik ausgeben wollen, diesen Ausschnitt nennen wir Viewport.
Und in der Regel bilden wir auf den Viewport
ein Window ab oder auch mehrere Windows
Dazu müssen wir dann Transformationen durchführen, mit Transformationen kennen Sie
sich alle jetzt inzwischen ja sehr gut aus. Wir müssen Transformationen durchführen,
diese Transformationen werden im grafischen Kernsystem, GKS zweistufig durchgeführt,
und zwar zunächst im ersten Schritt, wird eine Normierungstransformation durchgeführt,
aus dem Weltkoordinatensystem in sogenannte Normalize Device Coordinals, NDC abgekürzt.
Und mit diesen Normalize Device Coordinals wird dann gearbeitet,
das ist praktisch so ein symbolisches Ausgabegerät,
Und erst wenn wir eine konkrete Ausgabe auf ein ganz bestimmtes physikalisches Gerät,
wie auf einen Bildschirm, einen Drucker oder ähnliches machen,
dann transformieren wir in einem zweiten Schritt der Gerätetransformation von den Normalized Devices Coordinals in den eigentlichen Geräteviewport.
Und es können natürlich für jede Anwendung unterschiedliche Transformationen spezifiziert werden.
Ziel dieses ganzen Verfahrens des Windowing ist eine Geräteunabhängigkeit
Das heißt, wir wollen also das Format unseres Ausgabegerätes vollkommen entkoppeln von der Ausschnittbildung,
sodass wir den Inhalt eines Fensters eines Windows in unterschiedlicher Weise
dann auch auf unterschiedliche Geräte ausgeben können.
Darüber hinaus sagte vorhin schon, können natürlich mehrere Windows auch einen Viewpark benutzen.
Das heißt also, ich kann Informationen, die ich in
unterschiedlichen Windows zusammengestellt habe, dann auf einen Viewpod ausgeben.
Natürlich kann umgekehrt der Inhalt eines Windows auch auf beliebig viele Viewpods ausgegeben werden.
Wichtig ist dann noch, dass Window und Viewpod in der
Regel als Axtparallele Rechtecke angesehen werden. Das heißt also,
wir stellen uns das in der Regel so vor,
dass ein Window ein Fenster in unserer Welt,
in unserer Weltkoordinaten, irgendwie Axt parallel zum Weltkoordinatensystem ausgerichtet ist.
Das ist ja in etwa auch das,
was unserer täglichen Erfahrung entspricht
Unsere Fensterrahmen,
wenn wir es nicht gerade mit sehr avantgardistischen Architekten zu tun haben,
sind an den Seiten senkrecht und die Unter- und Oberkante ist horizontal.
Und damit haben wir also ein, oh, das Synatensystem,
das praktisch parallel zu unserem Weltkoordinatensystem in der Szene,
in der wir uns bewegen, ausgerichtet ist.
Und ähnlich gilt es dann eben auch für die Viewparts.
Da haben wir in den meisten Anwendungsfällen ja Viewparts,
die parallel,
Axt parallel zu unseren Gerätekoordinaten
ausgerichtet sind
So. Das Problem, das wir nun haben, ist,
dass unsere Szene ja beliebig groß sein kann. Das heißt,
die Objekte, die wir da definiert haben mit den Methoden des geometrischen Modellierens,
die wir kennengelernt haben, können von ihrer Anzahl her beliebig groß sein,
in ihrer Anordnung eine beliebig große Ausdehnung haben.
Und dann haben wir irgendwo eine Untermenge, die durch unser Fenster zu sehen ist.
Und wir wollen dann natürlich Irgendwo den Berechnungsaufwand für unseren Rechner reduzieren,
für die grafische Darstellung und zunächst einmal vorab versuchen herauszufinden,
welche Teile aus unserer Szene überhaupt durch unser Fenster gesehen werden können und
welche Teile außerhalb unseres Fensterrands liegen und damit also überhaupt nicht im Fenster gesehen und damit auch nicht im Viewbart dargestellt werden können.
Das heißt also, unsere Clipping-Algorithmen sind Algorithmen,
die die Darstellungselemente, also Punkte, Kantenflächen,
die ganz oder teilweise außerhalb unseres Fensters, beziehungsweise unseres YouPods liegen, abschneiden.
Und bei den meisten Grafiksystemen setzt dieser Schritt schon bei der Window-Youper-Transformation an.
Das heißt also, wenn wir einmal unsere Daten aufbereitet,
Aufbereitung durchführen, dann machen wir das für Unwindow und können das für beliebig viele Viewpods weiterverwenden.
So, wie finden wir jetzt raus, ob von dieser Kante,
von dieser blauen Kante, die irgendwo beginnt, quer durch unsere Window verläuft.
Auf der anderen Seite wieder hinausläuft, wie finden wir heraus,
welche Teile nicht im Window liegen und damit nicht dargestellt werden müssen.
Und wie finden wir heraus, wo diese Anfangs- und Endpunkte
des sichtbaren Anteiles an einer solchen Kante liegen.
Das ist unsere Aufgabe. Dazu haben sich unterschiedliche Menschen Gedanken gemacht,
einer der frühesten Algorithmen, die dazu entwickelt worden sind und
die auch heute noch Anwendung finden
Ist der Algorithmus von Conan Sutherland. Dieser Algorithmus geht so vor,
dass die gesamte Bild-Ebene erarbeitet dann eben im View-Part-Goarding-Naten-System.
Dass die gesamte Bild-Ebene in neun Regionen aufgeteilt wird.
Und zwar in die Regionen, die um unseren View-Part angeordnet sind.
Wir haben also ein View-Part, und der liegt in
der Mitte unserer Betrachteten beliebig großen Unendlich großen Bildebene.
Und dann können wir neun Regionen bestimmen.
Drei Regionen, die oberhalb unseres Viewpart liegen.
Drei Regionen, die unterhalb unseres Viewpart liegen.
Drei Regionen, die links von unserem Viewpart liegen.
Drei Regionen, die rechts von unserem Viewpart liegen.
Und unserem Viewpart selbst. Das sind dann also die neuen Regionen.
Und sie sehen, ich habe jetzt natürlich Regionen doppelt gezählt,
nämlich die, die hier über die Diagonalen liegen.
Die liegen sowohl oberhalb als auch links bzw. rechts
Hier unterhalb und links beziehungsweise rechts. Wir haben also
diese gesamte Ebene in dieser neuen Regionen unterteilt.
Und jetzt kommt ein kleiner Trick. Wir betrachten jede Kante,
die in unserem geometrischen Modell auftaucht.
Die Endpunkte der Kante und prüfen, ob ihre Projektion oder
in welcher dieser Regionen ihre Projektion liegt
Wenn, der Endpunkt im Viewport liegt, dann erhält die Kante,
der Punkt, einen vierstelligen Code mit 4 Nullen.
Wenn ein Endpunkt einer solchen Kante oberhalb des Viewports liegt,
dann erhält dieser Punkt einen Code, bei dem einen vierstelligen Bitcode,
bei dem das höchstwertige Bit auf eins gesetzt wird.
Und da sehen Sie, die drei Regionen,
die oberhalb des Jupperts liegen, die haben einen Bitcode,
bei dem der höchstwertige, das höchstwertige Bit auf eins gesetzt ist.
Bei den Endpunkten, die unterhalb des Viewports liegen,
wird das zweite Bit von links auf eins gesetzt,
bei denen die rechts vom Viewport liegen,
wird das dritte Bit auf eins gesetzt und bei denen die Links von Viewpart liegen,
wird das vierte Biet auf 1 gesetzt.
Das heißt, ein Punkt kann jetzt zum Beispiel sowohl oberhalb
als auch links vom Viewpart liegen und dadurch wird das Höchstwertige
und das Niedrigstwertige Bit auf 1 gesetzt.
Die anderen auf null. So. Wenn wir für alle Kantenendpunkte einen solchen Bitcode vergeben haben,
dann können wir durch ganz einfache Vergleiche sehen,
ob eine Kante garantiert, ganz innerhalb des Viewports liegt.
Oder ob sie garantiert außerhalb des Viewports liegt. Das können wir
dann durch einfache Vergleiche der Bitcodes dieser Kanten miteinander durchführen.
Und wir können das ja schon praktisch auf den ersten Blick sehen,
wenn der Code für beide Endpunkte gleich null ist,
dann wissen wir, die gesamte Kante ist, liegt innerhalb des Viewports.
Wenn der Bitcode der beiden Endpunkte unserer kannte,
mit durch ein logisches und miteinander verknüpft, verschieden von null ist,
dann liegt diese Kante garantiert ganz außerhalb unseres Viewports.
Ich gehe nochmal in das vorige Bild zurück.
Die logische Unverknüpfung wird immer dann ungleich null, wenn für
beide Endpunkte der Kante ein- und dasselbe Bit gesetzt ist.
Und wenn ein und dasselbe Bit gesetzt ist,
dann liegt die Kante entweder komplett oberhalb oder komplett unterhalb oder komplett
rechts oder komplett links.
Das heißt,
sie kann garantiert unseren Viewport
nicht schneiden
So haben wir also durch ganz einfache logische Vergleiche der Bitcodes
schon herausgefunden, ob wir kannten überhaupt weiter überprüfen müssen.
Wir haben die Kanten, die identifiziert,
die garantiert komplett im Viewpart liegen und komplett dargestellt werden müssen.
Und wir haben die Kanten identifiziert, die garantiert außerhalb
des Viewparts liegen und damit garantiert nicht dargestellt werden müssen.
Und nur bei aller Übrigen,
das können auch noch eine ganze Menge sein,
müssen wir dann überprüfen
Ob tatsächlich ein Teil dieser Kanten unseren Viewport kreuzt.
Und da müssen wir dann die Schnittpunkte der Gradengleichung dieser Kanten
mit den Viewport-Kanten berechnen und den Teil praktisch isolieren,
den Teil der Kante isolieren, den wir im Viewport darstellen wollen.
So, diese Auswertung ist dann auch wieder einfach,
wenn wir die Kanten über die Gradengleichung definieren,
dann Es gibt sich der Schnittpunkt mit dem linken Rand unseres Fewparts als Schnittpunkt-Koordinate XS,
gleich XL.
XL ist also die Absisse des linken Viewpart-Randes.
Und Y ergibt sich aus der geraden Leitgleichung zu YS,
gleich Y1 plus XL minus X1 mal M.
Ein ganz analog können wir für den rechten Rand dann
X natürlich sofort bestimmen. Das entspricht der Absisse des Rechten
Viewpart-Randes und Y eben wieder aus der geraden Gleichung,
aus der Punktsteigungsform der geraten Gleichung
Analog für den unteren Rand,
da ergibt sich der Schnittpunkt XS zu X1 plus Y,
U für die Unterkante des Viewparts minus Y1 durch M und YS ist dann gleich der Ardinate,
der Unterkante und entsprechendes gilt für den oberen Rand.
So, damit haben wir also Schnittpunkte berechnet unserer Kante mit den Geraden,
die vier Ränder unseres Viewparts begrenzen und können die jetzt entsprechend wieder auswerten und sehen,
ob die so berechnete Teilkante jetzt unserem Viewpart schneidet oder nicht.
So, das ist also ein Verfahren von Coen und Satherland.
Und das sind der Praxis also sehr viel eingesetzt wird.
Und wie Sie gesehen haben, es ist ein sehr einfaches,
übersichtliches Verfahren und auch ein sehr schnelles Verfahren.
Und das muss es ja sein, denn wir müssen uns ja überlegen,
dass unsere Szene wirklich eine sehr große Anzahl von Eckpunkten und Kanten
haben kann, die hier berücksichtigt werden müssen.
Nachdem Colen und Sutherland, diesen Algorithmus veröffentlicht hatten und er
schon eine Weile in der Praxis eingesetzt wurde,
kamen zwei andere Herren, nämlich Lian und Baski.
Und meinten, eigentlich müsste man das noch ein kleines bisschen schneller machen können.
Und Geschwindigkeit ist eben in der Computergrafik ein ganz wichtiges Ziel.
Und die beiden Lyang und Baski haben sich darum einen Algorithmus ausgedacht.
Der folgendermaßen vorgeht. Sie haben auch wieder
ihren Viewport
Als Zentrum, ihres Bildkoordinatensystem-Universums angesehen, der Bildebene. Und sie haben gesagt,
jede Kante des Viewports teilt die gesamte Bildebene in zwei Halbebenen.
Eine Halbebene, die, achso, noch vorweg,
die Kanten des Viewports werden als gerichtete Kanten angenommen.
Das ist sehr wichtig bei diesem Verfahren. So,
dann gibt es also eben eineinhalb Ebene,
die in Bezug auf die Richtung der Kante
rechts liegt
Diese Halbebene liegt garantiert außerhalb des Viewports. Und eine Halbebene,
die in Bezug auf die gerichtete Kante links liegt und in dieser Halbebene liegt der Viewport.
Und das gilt für alle vier Kanten. Ja,
wir können also um alle vier Kanten herumlaufen und immer sehen,
rechts von dieser Kante liegt der Teil unserer Bildebene,
der hinterher garantiert nicht grafisch dargestellt werden muss.
Und links liegt der Teil, von dem ein Aufschnitt im Viewport
dargestellt werden muss. So, und der Durchschnitt aller Halbebenen,
in denen der Viewport liegt, ergibt dann den Viewport selbst.
Nun muss man also nur noch herausfinden, welche Kanten unserer Objekte
in ihrer Projektion irgendwo den Viewport durchqueren. Und da sind Lyang und Basky so vorgegangen,
dass sie gesagt haben,
wir beschreiben die Kanten in einer Parameterform und zwar so,
dass wir die Hab siehste,
der Kante beschreiben als X1 plus Thema X2 minus X1. Und entsprechend die Ardinate der Kante als Y1 plus Thema Y2 minus Y1. Sie sehen,
das ist nichts weiter als eine lineare Interpolation zwischen den beiden Endpunkten,
die gegeben sind durch die Koordinaten X1, Y,
1 und X2 Y2.
Wenn wir also zwei Punkte gegeben haben,
P1 und P2, die irgendwo in der Bildebene liegen,
dann können wir die gerade Verbindung zwischen diesen beiden Punkten
eben über diese beiden parametrischen Gleichungen beschreiben.
Unser Parameter Tee variiere im Definitionsintervall von 0 bis 1.
So, jetzt kann man als nächstes feststellen,
dass Inviewport diese acht Gleichungen gelten
Es werden zwei weitere Variable eingeführt, PI mit I gleich 1 bis 4 und QI
bis mit I gleich 1 bis 4. Und die PI geben die Differenz,
P1 und P2,
die Differenz in X-Richtung zwischen Anfangs- und Endpunkt an und P3 und B4,
die Differenz in Y-Richtung zwischen Anfangs- und Endpunkt und Sie sehen,
P2 und B4 sind jeweils praktisch der negative Wert von P1 und P3.
Analog dazu werden also Q1 bis Q4 definiert und die entsprechend
im Prinzip unseren Gleichungen für P1 bis P4 nur verwenden sie anstelle des der Koordinaten des zweiten Punktes,
die Koordinaten,
die Absissen unserer Viewport Außenkante rechts bzw. links
Und das Gleiche gilt für Q3 und Q4 für die obere und
die untere Tante unseres Viewports. So, wenn wir diese vier,
diese acht gleich holen in P und Q aufgestellt haben,
dann können wir sagen, dass für die Teile der Kanten,
die im Viewport verlaufen, diese Ungleichung gilt,
dass nämlich PI mal Tee,
kleiner oder gleich QI ist.
Und das für alle vier Kanten
Ich habe Ihnen hier mal ein kleines Beispiel dargestellt. Nehmen wir an,
wir hätten zwei Punkte, P1 und P2,
P1 liege links von der rechten Kante unseres Viewports und P2
liege rechts von der rechten Kante des Viewports,
was ja bedeutet,
dass diese Kante unseren rechten Rand des Viewports schneidet
Wir können jetzt sagen, die Ungleichung PI Maltee,
kleiner gleich QI beschreiben, je eine der sichtbaren Halbebenen,
die durch die Begrenzungskanten des Viewports definiert sind.
Dann gilt, wenn QI größer gleich Null ist für alle I,
dann liegt der Punkt P1 im sichtbaren Bereich.
Das heißt, er liegt also innerhalb des Viewports.
Zum Vergleich nochmal
QI größer gleich, null. Bedeutet, diese vier Gleichungen
ergeben alle ein positives Ergebnis oder das Ergebnis null.
Wenn wir uns das zum Beispiel mal für die zweite Gleichung hier ansehen,
Q2, da wir hier den Vergleich mit dem rechten Rand haben,
wäre dann QRecht, X rechts,
minus X1. Das wäre diese Differenz und diese Differenz ist
ganz offensichtlich positiv
Und das können Sie also vom Prinzip her für die anderen
drei Ränder genauso machen. So, dann gilt weiterhin,
wenn P.I. größer ist als QI, in diesen Gleichungen,
dann verlässt die Kante unseren Viewport über den Rand I.
Also wenn P.I. größer als QI ist,
verlässt die Kante unseren Viewport im sichtbaren Bereich
über in den Rand
Wenn PI kleiner als QI ist, dann geht unsere Kante
in den Viewport hinein über den Viewport Rand I.
Und wenn PI gleich null ist,
dann verläuft die betrachtete Kante parallel zur entsprechenden Begrenzungskante unseres Viewports.
Wenn unsere Kante, unsere betrachtete Kante,
die Viewport-Kanten schneidet, müssen wir jetzt noch herausfinden,
für welche Parameterwerte
Dieser Schnitt auftritt, damit wir den sichtbaren Bereich oder den
sichtbaren Teil unserer Kante identifizieren können. Und die Schnittpunkte unserer Kante,
unserer Geraden mit dem Begrenzungskanten des Viewports, die ergeben sich für die PI-Ungleichnull,
PI gleich null, hatten wir ja gesehen,
dann haben wir eine Kante parallel zur Begrenzungskante des Viewports,
die interessiert uns nicht.
Aber für diejenigen PI-Ungleichnull ergibt sich Der Schnittpunkt für den Parameter
wird Tee gleich Q durch PI, QI durch PI.
Das heißt also, für unsere beiden Parameterwerte beim Eingang unserer Kante
in den Viewport und beim Verlassen der Kante aus unserem Viewport gilt,
beim Eingang T1 ist das Maximum von QI durch PI,
für QI kleiner PI oder
Wenn unsere Kante im Viewport beginnt. Und entsprechend beim Verlassen
des Viewports ergibt sich der Parameterwert für das Ende des
sichtbaren Bereiches der Kante durch den Quotienten QI durch PE,
für PE größer QI oder 1,
falls die Kante den Viewport nicht verlässt.
Das heißt, wenn sie innerhalb des Viewports endet,
dann erhält der Parameter Wert eben
sein Maximum
So, auch dieser Algorithmus ist sehr elegant und sehr schnell.
Und Lyan und Baski haben die beiden Algorithmen mit einigen Millionen
beliebig gewählter Kanten getestet. Und sie mussten zugeben,
dass der Algorithmus von Conan und Fotherland mit deutlich weniger Gleitkammeroperationen
auskommt als ihr eigener.
Aber dass ihr eigener Algorithmus trotz allem ungefähr um ein Drittel
schneller ist
als der Algorithmus von Conan und Satherland
So, ich glaube, das hat danach niemand
mehr so richtig überprüft. Und man kann sagen,
beide Algorithmen sind sehr schnell, beide sind recht elegant.
Und welchen man wählt, das hängt auch davon ab,
welche einem besser gefällt, ja?
Welche Zeitkongressitäten haben die denn? Also wie skalieren die?
Versagen die jetzt größeren Briefräusthemen? Ja. Das hängt natürlich
von der Geschwindigkeit des Prozessors ab.
Ich habe da jetzt keinen aktuellen Daten mehr.
Das liegt alles schon einige Jahrzehnte zurück
als diese Algorithmen entwickelt
Zum ersten Mal zum Einsatz gebracht worden sind.
Und der einzige Vergleich ist eben, der Algorithmen untereinander,
die waren damals auf den relativ langsamen Prozessoren schon schnell genug,
dass also Bilder unheimlich schnell aufgebaut worden sind.
Aber ich habe also keine Ahnung,
wie das jetzt mit aktuellen Prozessoren aussieht und Grafikprozessoren aussieht,
wie schnell die da tatsächlich sind.
Aber Zeitkomplexitätsmaße gezahlt
So. Damit möchte ich dieses Kapitel abschließen, das Kapitel über die grafisch-geometrischen Algorithmen.
Und ins nächste Kapitel eintreten, das Kapitel photometrisches Modellieren.
Wir wollen den Einstieg in dieses Kapitel machen über wieder ein Problem,
das relativ eng mit dem Problem zusammenhängt,
mit dem Problem der Kanten, die außerhalb beziehungsweise innerhalb unseres Viewports liegen.
Hier wollen wir uns mit Kanten bzw. Flächen beschäftigen, die innerhalb des Viewports liegen,
aber verdeckt sind durch andere Flächen und darum nicht sichtbar sind.
Das heißt also, in der Computergrafik,
in der grafischen Darstellung haben wir ein zweischrittiges Verfahren,
wir filtern zunächst einmal alle die, beziehungsweise Flächen aus,
die garantiert nicht im Viewport dargestellt werden müssen.
Mit denen müssen wir uns gar nicht mehr beschäftigen.
Und dann suchen wir die Kanten beziehungsweise Flächen,
die zwar rein geometrisch im Viewport auftauchen können,
die aber dann durch andere Objektteile unserer Szene verdeckt sind und darum nicht grafisch dargestellt werden müssen.
Und das wäre dann das Erste, womit wir uns beschäftigen wollen.
Dann möchte ich ein kleines Experiment mit ihnen machen,
bevor wir dann in die tatsächlichen photometrischen Modelle einsteigen und uns dann unterschiedliche Beleuchtungsmodelle,
globale Beleuchtungsmodelle, lokale Beleuchtungsmodelle ansehen und sehen,
was man da in der Computergrafik machen kann und wie man das anstellt.
Und da wollen wir uns zunächst einmal mit den
traditionellen Schattierungsalgorithmen oder Shading-Algorithmen beschäftigen und dann uns dem großen,
Entschuldigung, mit dem großen Gebiet des Fotorealismus
zu wenden
Und schließlich noch einen Ausblick wagen in neuere Entwicklungen auf dem Gebiet der Computergrafik,
in denen man sich dann vom Fotorealismus wieder abwendet.
Und darin nicht das große Ziel der grafischen Darstellung zieht,
sondern im sogenannten Nicht-Fotorealismus. So, das erste Problem,
mit dem wir uns also beschäftigen wollen,
ist die Identifikation von Kanten bzw. Flächen,
die innerhalb einer eines Viewportes nicht sichtbar sind,
weil sie durch andere Kanten beziehungsweise Flächen,
die in Viewport angeordnet sind, verdeckt werden.
Wir stellen uns also vor, wir hätten eine Szene,
die wir durch unser Fenster durchaus sehen könnten,
der Big da drüben auf dieses schöne Haus da.
Wir haben hier eine Betrachtungsposition,
symbolisiert durch diesen Punkt hier, hier sei unser Auge angeordnet,
unser Auge schaut in die Szene hinein und die Frage ist,
was kann das Auge aus dieser Position in der Szene wahrnehmen und was kann es nicht wahrnehmen,
weil es eben durch andere Flächenteile verdeckt ist.
Für diese, für die Lösung dieses Problems gibt es eine Vielzahl unterschiedlicher Algorithmen,
von denen ich ihnen ein paar exemplarisch vorstellen möchte.
Und diese große Vielzahl von Algorithmen, die es da überhaupt gibt,
die lässt sich grob kategorisieren in sogenannte Objektraumalgorithmen,
im Prioritätslistenalgorithmen und in Bildraumalgorithmen
Objektraum, Algorithmen, arbeiten, wie der Name schon sagt,
im Objektraum, also im Prinzip im Weltkoordinatensystem.
Da können wir wieder unterscheiden zwischen kantenorientierten und flächenorientierten Algorithmen. Die Prioritätslisten,
Algorithmen sind Algorithmen,
die sowohl im Objektraum als auch im Bildraum arbeiten und die zum Ziel haben,
die Generierung von Bildfolgen möglichst zu beschleunigen und sich da Wissen
aus Bild- und Objektraum zunutze zu machen,
um möglichst schnell Bildfolgen erzeugen zu können
Und die Bildraumalgorithmen, wie der Name schon sagt, arbeiten also komplett im Bildraum.
Und auch da unterscheiden wir wieder zwischen sogenannten flächenorientierten Algorithmen und punktorientierten Algorithmen.
Die Auswahl eines geeigneten Algorithmus vor einer Anwendung,
die ist in der Regel abhängig von der Art der Anwendung.
Das heißt, haben wir eine Animation geplant,
wollen wir also Bild folgen in schneller Geschwindigkeit erzeugen oder Wollen wir Einzelbilder erzeugen,
bei denen das dann auf ein paar Sekunden Berechnungszeit mehr oder weniger nicht ankommt?
Dann ist die Auswahl des Algorithmus auch abhängig von der Komplexität der Szene.
Sind da nur wenige relativ einfach geformte Objekte in der Szene zu sehen,
die dargestellt werden müssen oder handelt es sich um eine Szene,
die aus sehr vielen sehr komplex geformten Objekten besteht.
Und schließlich hängt die Wahl des Algorithmus auch von den Eigenschaften der Ausgabegeräte ab,
die wir heute in der Form eigentlich nicht mehr so berücksichtigen müssen,
da wir in der Regel ja nur noch mit Rasterdisplays arbeiten und selten Vektordisplays beziehungsweise weg dort zeichnende,
grafische Ausgabegeräte verwenden.
So, ich möchte zunächst einmal ein paar wichtige Merkmale und
Eigenschaften der unterschiedlichen Algorithmen zusammenfassen,
zunächst einmal bei den Objektraumalgorithmen
Objektraum-Algorithmen sind sehr präzise. Sie sind im Prinzip genauso genau
wie die Berechnungsgenauigkeit unseres Computers ist. Das bedeutet,
dass wir aus unserer Szene,
wenn wir sie mithilfe eines solchen Objektraum-Algorithmus zunächst einmal beschrieben haben und
die Darstellung berechnet haben, dann auch Ausschnittsvergrößerungen durchführen können,
die eine sehr hohe Genauigkeit haben
Allerdings haben die Objektraumalgorithmen auch den Nachteil, dass bei Ihnen
der Berechnungsaufwand gewaltig steigt mit der Anzahl der darzustellenden Objekte.
Das heißt also,
wenn wir sehr viele Objekte sehr komplex gestaltete Objekte,
also mit vielen Flächen und Kanten,
berechnen,
müssen für die grafische Darstellung oder berücksichtigen müssen für die grafische Darstellung,
dann werden die Objektraumalgorithmen
sehr aufwendig
Die Prioritätslisten, Algorithmen, sagte schon, die dienen der Beschleunigung.
Vor allem der Erstellung von Bildfolgen in Animationen oder Filmen.
Oder auch in Computerspielen. Hier werden potenzielle gegenseitige Verdeckungen zwischen Flächen
eines Objektes und Kanten eines anderen Objektes schon vorab im Objektraum ermittelt.
Das heißt also, hier geht diese Ermittlung mit der
hohen Genauigkeit des Objektraumes durchgeführt
Dafür ist dann auch ein entsprechend großer Wechenaufwand erforderlich.
Aber das reicht, wenn man das vorab mal gemacht hat,
die eigentlichen Abbildungsberechnungen, die erfolgen dann im Bildraum.
Und diese Abbildungsberechnungen für den Bildraum sind vergleichsweise schnell,
wie wir dann jetzt bei den Bildraumalgorithmen sehen werden.
Die haben den Nachteil oder Vorteil, dass sie genau so
präzise sind, wie die Rasteauflösung unseres jeweiligen Ausgabegerätes.
Das bedeutet, wenn wir Vergrößerungen einer solchen Abbildung machen,
dann wird praktisch jedes Pixel, das wir berechnet haben, einfach aufgeblasen.
Und die Vergrößerung wird im Prinzip sehr ungenau und damit unbefriedigend.
Der Rechenaufwand ist abhängig von der Bildauflösung, das heißt,
der ist im Prinzip begrenzt,
der hängt ab von der Anzahl der Pixel in unserem Bild.
Genau können wir jetzt sagen,
für die Objektraumalgorithmen gilt dass ihr Berechnungsaufwand in der Ordnung Endquadrat liegt,
wobei N die Anzahl der Objekte in der Szene ist,
vorbei Objekte, Flächenelemente sind.
Bei Bildraumalgorithmen sieht es dann so aus, dass ihr Berechnungsaufwand von
der Ordnung N mal P ist und P ist die Anzahl der Bildpixel.
Das heißt, haben wir wenige Objekte in unserer Szene,
die wir darstellen wollen, dann kann unser Objektraum im Vergleich
zur Anzahl der Pixel auf unserem Bildschirm dann können unsere Objektraumalgorithmen deutlich schneller sein.
Haben wir aber sehr viele komplexe Objekte in unserer Szene,
dann sind in der Regel die Bildraum-Algorithmen die schnelleren. So,
ich möchte Ihnen jetzt exemplarisch ein paar Algorithmen vorstellen und Ihnen zeigen,
ein paar recht unterschiedliche Algorithmen vorstellen und Ihnen zeigen,
wie man solche Probleme bisher gelöst hat.
Der erste Algorithmus ist der sogenannte Floating Horizon Algorithmus,
die Methode des gleitenden Horizontes
Der zweite Algorithmus, der sonst immer angewendet wird,
ist der Algorithmus des Blackface Calling, das Entfernen, abgewandter Flächen.
Dann möchte ich Ihnen einen Algorithmus mit beschreiben,
der als Steven Puffer-Algorithmus oder auch Z-Buffer Algorithm oder bei den Amerikanern Sieber Algorithm genannt wird.
Dann einen Bildschirmzeilen-Algorithmus, der Ihnen, das kann dein Algorithmus,
der Ihnen vom Prinzip her dann gleich sehr bekannt vorkommen sollte,
weil wir in der vergangenen Woche in einem anderen Kontext einen Algorithmus kennengelernt haben,
der ganz ähnlich funktioniert.
Und last but not least, ein schönes Beispiel,
den sogenannten Maler-Algorithmus oder auch Paint is Argorithm. So,
die Methode des gleitenden Horizontes lässt sich sehr schön einsetzen,
wenn wir solche Landschaften grafisch darstellen wollen.
Wir haben also irgendwie ein Modell einer Landschaft,
die möglichst bizarr gestaltet sein kann, oder sagen,
wir beliebig, bizarr gestaltet sein kann,
so eine vereiste Gebirgslandschaft oder so eine Berglandschaft mit grünen Hängen und so weiter.
Und die Frage ist, wie kann man das möglichst schnell?
Und gut, darstellen, grafisch darstellen, aus irgendeiner Perspektive gesehen.
Und da verwenden wir also die Methode des gleitenden Horizonts.
Wir gehen davon aus, dass wir unsere Fläche beschreiben können
in der Farm F von XYZ gleich Null.
Und dann schneiden wir diese Fläche, mit Parallelen,
Ebenen, Equitistanten, Ebenen, die parallel zur XY-Ebene,
also zur Bildebene, verlaufen in gleichmäßigen Abständen.
Delta Z. Und ich habe hier mal das Ganze sehr vereinfacht dargestellt
für einen der hübschen Maulwurfshügel, da unten auf der Wiese.
Ich habe also einen Maulwurfshügel herausgenommen,
ihn dann auch noch vereinfacht zu einem Pyramidenstumpf
Wir stellen uns vor, wir wollten den Blick über die Wiese,
so schräg über den Maulwurfshügel hinweg mit diesem Verfahren darstellen.
Und wenn uns das mit dem Maulwurfshügel gelingt,
dann sollte sonst mit den Alpern oder den Pyranäen oder dem Himala
ja auch eigentlich im Prinzip auch gelingen. So,
unser Maulwurfshügel, wenn wir ihn mit Ebenen zum Schnitt bringen,
die senkrecht auf der Blickrichtung stehen und in gleichmäßigen Abstanden praktisch in die Szene hineinwandern,
dann kriegen wir solche Profile.
Solange wir noch auf der Ebenen Wiese sind,
die der Maulwurf noch nicht weiter berührt hat,
sind unsere Schnitte der Ebene mit der Ebenen Wiese natürlich geraten.
So, und jetzt kommen wir also bei der nächsten Ebene an den Fuß des Maulwurfshügels.
Und da schneiden wir so ein kleines Stückchen in diesen Wahlwurfshügel hinein.
Und erhalten jetzt eine Profilinie, die so aussieht.
Gehen wir wieder ein Stückchen weiter, dann erhalten wir eine neue Profilinie,
bei der wir schon sehen können, aha,
an der Stelle erhebt sich der Maulwurfshügel noch ein Stückchen höher.
Bei der nächsten erhebt er sich noch
ein Stückchen höher
Der nächsten wieder ein Stück höher. Und dann haben wir
auch den Gipfel des Maulwurfs Hügels erreicht. Wenn wir dann weitergehen,
die nächste Ebene mit unserer Wiese zum Schnitt bringen,
dann wird sich da auch ein Profil ergeben im Schnitt mit dem Maulwurfshügel.
Nur diese Profilinie sehen wir hier nicht mehr, weil sie
von dieser höheren, die weiter vorne liegt, verdeckt wird.
Und das Gleiche gilt dann für die und ist dahinter,
sehen wir dann wieder eine Profilinie,
die dann vollkommen horizontal verläuft,
eine gerade ist,
bei der unser Maulwurfshügel
nicht mehr getroffen worden ist
Und das ist im Prinzip schon die Methode des Gleitenden Horizontes.
Wir lassen unseren Horizont von unserem Beobachtungspunkt aus immer weiter in die Szene hineingleiten und prüfen,
ob das, was wir als Schnittlinie,
als Konturlinie zwischen einer Schnittebene parallel zur Bildebene und der Landschaftskontur erhalten,
ob das von einer Konturlinie,
die uns näher liegt,
verdeckt wird oder nicht
Wenn es nicht verdeckt wird,
dann wird es als neue, verdeckende Kontur übernommen,
wenn es verdeckt wird, wird es ignoriert.
So, ich habe das hier mal ein bisschen spaghetti-mäßig dargestellt.
Wir fangen also bei einem Betrachtungspunkt an und schneiden unsere Landschaft,
unserer Szene mit parallelen Ebenen,
die senkrecht auf der Blickrichtung stehen
Und generieren daraus unsere Schnittkurven unserer Schnittlinien. Diese Schnittlinien sollten
dann natürlich aufsteigend sortiert sein. Das heißt also,
die nächstgelegene, die kriegen wir als erste,
dann die, die dahinter liegt und so weiter.
Wir fangen also mit derjenigen an,
die uns am nächsten liegt und können als erstes einmal sagen,
die ist garantiert in ihrer vollen Länge sichtbar.
Und dann malen wir die auch als Konturliege auf
Und wir betrachten diese Schnittlinie als unseren aktuellen Horizont.
Dann nehmen wir uns die nächste Konturlinie, die als nächste dahinter liegt,
und vergleichen die schrittweise in X-Richtung in Absissen-Richtung mit der Konturlinie,
die wir als aktuellen Horizont gespeichert haben.
Und da stellen wir fest, dieser Punkt liegt tiefer,
hat eine niedrigere Ordinate, Als der Punkt auf dem aktuellen Horizont,
also kann er nicht sichtbar sein.
Das Gleiche gilt für den. Er liegt tiefer,
als auf dem aktuellen Horizont. Also kann er nicht sichtbar
sein. Dieser liegt höher als auf dem aktuellen Horizont.
Also wird er sichtbar. Das Gleiche gilt hier,
da, da, da, bis dahin.
Dann kommen wir wieder zu einem Punkt,
der tiefer liegt und damit nicht sichtbar sein kann und so weiter.
So, nachdem wir das gemacht haben,
speichern wir Die neu gefundenen Punkte, die oberhalb des aktuellen Horizontes liegen,
als Teile unseres neuen aktuellen Horizontes.
Das heißt, unser aktueller Horizont verläuft jetzt so.
Und die Teile der Kanten hier sind jetzt nicht mehr interessant.
Wenn wir jetzt also die nächste Schnittkurve mit unserer Ebene betrachten,
die das Gelände schneidet,
dann vergleichen wir die mit dem neuen aktuellen Horizont und prüfen,
welche Teile dieser Schnittkurve liegen höher als der aktuelle Horizont
Und die werden dann als aktueller Horizont gespeichert und die,
die tiefer liegen, die können wir ignorieren,
die sieht man sowieso nicht.
Ja? Das ist ein unheimlich simpler und sehr anschaulicher Algorithmus.
So, das war mal eine besondere Anwendung.
Die Methode des gleitenden Horizontes,
Floating Horizon für eine besondere Anwendung der Sichtbarkeit oder der Lösung
des Sichtbarkeitsproblems
Allgemein, wenn wir Objekte haben,
die so etwa in der Art modelliert worden sind,
wie wir das im geometrischen Modellieren kennengelernt haben.
Dann können wir sagen, diese Objekte sind in der Regel dann,
wenn sie grafisch dargestellt werden sollen, Objekte,
die durchgehend zweidimensional mannigfaltig sind.
Und die jeweils ein Volumen begrenzen. Das heißt also,
es sind Volumina, die durch eine individuelle Oberfläche begrenzt werden.
Und wir müssen jetzt herausfinden, Zum einen,
welche Teile dieser Oberflächen sind sichtbar. Der erste Schritt,
den wir da machen, ist zu prüfen,
welche Teile sind eigentlich von meinem Beobachtungsstandpunkt aus Rückseiten der einzelnen Objekte.
Diese Rückseiten sind ja garantiert nicht sichtbar. Das heißt also,
wenn wir die Rückseiten der Objekte identifizieren können,
dann wird so im Schnitt wahrscheinlich schon die Hälfte aller Oberflächenbereiche wegfallen.
Für die brauchen wir dann
gar keine weiteren Betrachtungen mehr durchzuführen
Und dieses Identifizieren der Rückseiten,
das macht man mit den sogenannten Bugface Kulling,
indem man also die abgewandten Flächen identifiziert und ausortiert.
Die Grundidee beim Bugface Kulling ist die,
dass wir sagen,
die Betrachtungsrichtung aus der wir in die Szene hineinschauen und
die Flächennormale eines Flächenelementes schließen einen Winkel miteinander ein
Wenn dieser Winkel größer ist als 180, größer ist als 90 Grad,
dann ist dieses Flächenelement garantiert nicht sichtbar. Oder anders formuliert,
wenn der Vektor unserer Betrachtungsrichtung und der normalen Vektor des Flächenelementes
in denselben Halbraum weisen, dann ist dieses Flächenelement nicht sichtbar.
Und der Halbraum wird praktisch so definiert,
dass wir die Normalebene zu unserer Betrachtungsrichtung definieren und dann sagen können,
wir haben eineinhalb Raum,
in dem wir selber uns aufhalten und eineinhalb Raum der jenseits der Betrachtungsebene liegt.
Der Vektor meiner Betrachtungsrichtung weist in den Raum jenseits der Betrachtungsebene,
der Schnittebene und wenn der normalen Vektor eines Flächenelementes ebenfalls in diesen Halbraum weist,
egal ob er das direkt macht oder unter irgendeinem Winkel,
aber wenn er in diesen Halbraum hineinweist,
dann ist diese Fläche garantiert nicht sichtbar.
Ja, ich denke, das ist relativ einfach und einsichtig.
Und wie können wir das herausfinden? Wir können einfach das Skalatprodukt
zwischen Flächennormale und Vektor der Betrachtungsrichtung bilden und für abgesandte Flächen,
das heißt also für Flächen, die dann garantiert nicht sichtbar sind,
ist dieses Skalatprodukt positiv.
Damit haben wir die Flächen aussortiert, Oberflächenelemente,
die abgewandt sind und damit garantiert nicht sichtbar sind.
Das bedeutet aber nicht, dass alle anderen,
die uns im Prinzip zugewandt sind, dann auch sichtbar sind.
Denn wenn sie mal eine Handfläche betrachten, dann können sie sofort erkennen,
mein Handrücken ist von ihrer Seite aus nicht zu sehen.
Der ist abgewandt, nicht sichtbar. Das heißt also,
wie der aussieht, darum brauchen sie sich bei der grafischen
Grafstellung gar nicht zu kümmern.
Der wird gar nicht dargestellt. Aber die Innenseite der Hand
ist sichtbar
Wenn ich jetzt meine Hand so verbiege,
dann sehen Sie bei meinen Fingern den Handrücken.
Ja, die Flächennormalen weisen also in den Halbraum,
in dem sie sich jetzt aufhalten. Von meiner Handinnenfläche,
von dieser Fläche weisen die Flächennormalen ebenfalls in den Halbraum,
in dem sie sich aufhalten.
Das heißt also nach dem Backface-Calling-Algorithmus sind das Flächenelemente,
die ihnen zugewandt sind.
Trotzdem sehen Sie sie nicht
Ja. Weil sie nämlich durch andere Flächenteile in derselben Szene verdeckt sind. Das heißt also,
dieser Backfacekulling-Algorithmus ist ein schöner Algorithmus, der uns zunächst einmal gestattet,
alles auszusortieren, was garantiert nicht sichtbar ist,
das verfindet zur Fahrt und uns mit unseren Problemen darauf zu konzentrieren,
zu sagen, so, jetzt müssen wir bei dem,
was potenziell sichtbar ist, was uns also zugewandt ist,
die Teile herausfinden,
die dann tatsächlich sichtbar sind.
Und das ist die Aufgabe, mit der sich die sogenannten Hinline- und Hidden-Surface-Algorithmen beschäftigen.
Beim Backface-Calling-Algorithmus können wir noch einen Sonderfall sofort identifizieren,
wenn unser Objekt, das wir da untersucht haben,
ein Konvexer-Polyeder ist, dann hat das Blackface-Calling für dieses Objekt,
wenn es alleine in der Szene ist,
damit auch das gesamte Hidden-Line bzw. Hidden-Surface-Problem gelöst
Denn alles, was da potenziell sichtbar ist, ist auch tatsächlich sichtbar.
Das wäre also so etwas. Dieses... Dieses Ding hier
von außen wäre so ein konvexes Polyeda mit ganz kleinen Flächenelementen.
Das heißt, wenn sie hier also einmal festgestellt haben,
welche Flächenelemente ihnen zugewandt sind, dann wissen sie auch,
welchen Teil man sieht. Sobald das Objekt Irgendwelche Beulen hat,
die nach innen gehen, dann ist es nicht mehr konvex.
Und dann können eben Selbstverdeckungen auftreten, wie hier bei meiner Hand.
Und dann müssen wir weiter untersuchen. Ja, Bergfacekulling,
speziell bei Convexen, Polyedern, reduziert die Anzahl der
darzustellenden Flächenelemente im Schnitt auf die Hälfte der vorhandenen Flächenelemente.
Und damit ist das Backfacekulling ein großer Effizienzgewinn für das Objekttraum oder für alle Objekttraumverfahren.
So, nun möchte ich Ihnen einen Algorithmus einmal etwas näher
vorstellen, den sogenannten Tiefenpuffer-Algorithmus oder auch Set-Puffer-Algorithm.
Das ist ein typischer, typisches Bildtraumverfahren. Dieses Verfahren verwendet eine Datenstruktur,
ein zweidimensionales Array und da wird für jedes Pixel unseres View-Parts
der Z-Wert des darzustellenden Oberflächenpunktes in diesem Ray gespeichert.
Das heißt also, die Entfernung von der Bild-Ebene.
Und dieses Array nennen wir also den Z-Puffer oder Tiefenpuffer oder Z-Buffer.
In diesem Array stehen am Ende die Z-Werte der Oberflächenpunkte,
die den Betrachtungspunkt am nächsten liegen.
Und dann wissen wir, dieser Oberflächenpunkt kann dargestellt werden.
Die Größe dieses Arrays entspricht dann eben der Ausdehnung und sowas Viewboss.
Das heißt also, ist maximal so groß wie unser Bildschirm,
auf dem wir unsere Darstellung durchführen fallen.
Der Algorithmus funktioniert so, wir löschen zunächst einmal den Bildausschnitt,
das heißt, wir füllen unseren Bildspeicher mit der Hintergrundfarbe,
die unsere Szene erhalten soll.
Und dann initialisieren wir unseren tiefen Puffer mit minus unendlich.
Sprich, mit dem größtmöglichen negativen Wert,
den unser Rechner darstellen kann
So, dann gehen wir einfach die Flächen durch,
von denen wir vorher mit unserem Backface-Kulling festgestellt haben, dass sie potenziell sichtbar sind.
Gehen also eine Fläche nach der anderen durch und berechnen dann in
der Projektion dieser Fläche in unserer Bildebene für jedes unserer Pixel.
Aus der Bildebene die Farbe und die Tiefe. Das heißt
, den Abstand zum Betrachtungspunkt. Und wenn dieser Abstand,
den wir da berechnen, größer ist, als die Tiefe,
die aktuell in unserem tiefen Puffer abgelegt ist,
dann ersetzen wir die dort abgelegte Tiefe durch unseren jetzt aktuellen Abstand und schreiben den Farbwert für diesen Punkt in unserem Bildspeicher.
Und wenn das Z kleiner ist, als die Tiefe,
die in unserem tiefen Puffer steht, dann können wir den Punkt ignorieren,
dann sieht man ihn nicht, dann wird er durch ein anderes Flächenelement verdeckt.
So, zur Berechnung von Z,
das heißt dem Abstand von unserem Beobachtungspunkt aus,
wenn wir davon ausgehen, dass wir ein faszinierte Oberfläche eines Gegenstandes haben,
das also die Flächenelemente, die Gegenstand an der Oberfläche begrenzen,
aus Ebenen kleinen Flächenelementen zusammengesetzt sind, dann variiert unser Z entlang einer Bildschirmzeile linear.
Das heißt also, wir können einfach durchinkrementieren,
unser neues Delta Z finden, wenn wir den Nachbarpunkt kennen.
Das heißt, wir können also innerhalb einer Fläche durch lineare Inkrementierung,
um Delta Z direkt die Entfernung eines neuen Punktes bestimmen,
vom Betrachtungsstandpunkt, wenn wir seinen Nachbarpunkt bereits kennen.
Dadurch wird der Berechnungsaufwand
erheblich niedriger
So. Damit haben wir uns über einen Tiefenpuffer beschrieben und
in Abhängigkeit davon unseren Bildpuffer beschrieben und dann können wir,
wenn wir auf die Weise sämtliche Flächenelemente betrachtet haben,
unseren Bildpuffer einfach ausgeben und wir haben unser Bild und
es sieht alle verdeckten Flächenteile tatsächlich nicht sichtbar
So, ein anderer Algorithmus, den ich Ihnen hier vorstellen möchte, ist der Bildfirm-Zeilen-Algorithmus,
der sogenannte Scanline-Algorithm. Beim Scanline-Algorithm können wir uns vorstellen,
das ist ein ganz einfacher Flächenfüll-Algorithmus, so wie der Strafuralgorithmus,
den wir uns in der vergangenen Woche angeguckt haben.
Das heißt also, wenn wir einen irgendwie geartete Polygon umrandete,
ebene Fläche haben, die wir grafisch darstellen wollen,
dann können wir genauso vorgehen, wie beim Schraffuralgorithmus.
Wir identifizieren den Punkt mit der kleinsten und dem Punkt, mit der größten Ordinate. Und dann beginnen wir beim Punkt mit der kleinsten Ordinate,
inkrementieren unsere Scanline, unsere Bildschirmzeile, um eins,
sodass wir also in die erste Bildschirmzeile oberhalb des Punktes mit der kleinsten Ordinate kommen,
dann berechnen wir die Schnittpunkte dieser Scanline mit den relevanten Kanten unseres Polygons und wissen,
dass wir im Bereich zwischen einem ungeraden Schnittpunkt und den nächsten geraden Schnittpunkt,
die Scanline zeichnen müssen,
also darstellen müssen auf dem Bildschirm und von dort zum nächsten ungeraden Punkt,
Schnittpunkt wieder nicht zeichnen,
aber zum nächsten geraden Punkt wieder zeichnen,
also genauso wie wir das beim Schraffuralgorithmus in der vergangenen Woche
kennengelernt haben
So, ja, hier noch einmal zum, Entschuldigung,
zur Darstellung der Scanline-Punkte,
das hatte ich Ihnen schon gesagt,
wir können also praktisch für alle i größer Null,
für alle Schnittpunkte der Scanline mit unserem Polygonkanten,
beginnend bei dem Element der Scanline,
das also am weitesten linksaußen liegt,
die Scanline darstellen bis zum i plus ersten Punkt und da
erhält es den praktisch den Farbwert der durchquerten Polygonfläche und von dort bis zum i plus zweiten Punkt wird nicht dargestellt vom i plus zweiten bis zum i plus dritten wird wieder dargestellt und so weiter.
Ein weiterer schöner Algorithmus ist der sogenannte Maler Algorithmus oder auch Painters Algorithm.
Das ist ein Algorithmus, der sowohl im Objektraum als auch im Bildraum arbeitet.
Hier gehen wir zunächst einmal sämtliche Polygonflächen in unserem,
in unserer Szene durch, sämtliche Flächenelemente,
bei denen wir vorher durch den Bug Facecalling-Algorithmus festgestellt haben,
dass sie uns zugewandt sind.
Alle anderen brauchen wir nicht zu berücksichtigen. Und diese Polygonflächen,
die sortieren wir jetzt nach dem kleinsten Setwert der jeweiligen Fläche,
das heißt bezüglich ihrer Entfernung von Betrachtungspunkt.
Und dann beginnen wir mit der entferntesten Fläche
So, wenn wir also, ähm,
wir haben immer Freude, wir müssen dann wieder lesen.
Für heute, danke Ihnen, für das Produkt,
das wir aufmerksamkeiten,
die Füße und eine Bildung