Bounding Box

2.9.4 Bounding bewegte Bounding Boxen

Es gibt zwei einfache Fälle: Erstens, wenn die Keyframe-Matrizen gleich sind, können wir willkürlich nur die Starttransformation anwenden, um die vollständigen Grenzen zu berechnen. Zweitens, wenn die Transformation nur Skalierung und/oder Translation umfasst, dann begrenzt der Begrenzungsrahmen, der die transformierten Positionen des Begrenzungsrahmens sowohl zum Start- als auch zum Endzeitpunkt einschließt, die gesamte Bewegung. Um zu sehen, warum dies so ist, betrachten wir die Position eines transformierten Punktes p als eine Funktion der Zeit; wir bezeichnen diese Funktion von zwei Matrizen, einem Punkt und einer Zeit mit a(M0, M1, p, t).

where s0,0 das entsprechende Element der Skalenmatrix für M0 ist, s0,0′ das gleiche Skalenmatrixelement für M1 ist und die Elemente der Translationsmatrix ebenfalls mit d bezeichnet werden. (Wir haben hier d für „delta“ gewählt, da t bereits für die Zeit steht.) Als lineare Funktion von t liegen die Extrema dieser Funktion bei den Start- und Endzeiten. Die anderen Koordinaten und der Fall für eine verallgemeinerte Skala folgen auf ähnliche Weise.

〈AnimatedTransform Method Definitions〉 + ≡

Bounds3f AnimatedTransform::MotionBounds(const Bounds3f &b) const {

if (!actuallyAnimated)

return (*startTransform)(b);

if (hasRotation == false)

return Union((*startTransform)(b), (*endTransform)(b));

〈Return motion bounds accounting for animated rotation 108〉

}

Für den allgemeinen Fall mit animierten Rotationen kann die Bewegungsfunktion Extrema an Punkten in der Mitte des Zeitbereichs haben. Wir kennen keine einfache Methode, um diese Punkte zu finden. Viele Renderer lösen dieses Problem, indem sie eine große Anzahl von Zeitpunkten im Zeitbereich abtasten, die interpolierte Transformation an jedem dieser Punkte berechnen und die Vereinigung aller entsprechenden transformierten Bounding Boxes vornehmen. Hier werden wir eine fundiertere Methode entwickeln, mit der wir diese Bewegungsgrenzen robust berechnen können.

Wir verwenden eine etwas einfachere konservative Grenze, bei der die Bewegung der acht Ecken des Begrenzungsrahmens einzeln berechnet wird und die Vereinigung dieser Grenzen gefunden wird.

〈Rückgabe der Bewegungsgrenzen unter Berücksichtigung der animierten Rotation〉 ≡ 108

Bounds3f bounds;

for (int corner = 0; corner <8; ++corner)

bounds = Union(bounds, BoundPointMotion(b.Corner(corner)));

return bounds;

Das Ergebnis ist ziemlich komplex, wenn man es ausdehnt, vor allem wegen des Slerp und der Umwandlung des resultierenden Quaternions in eine Matrix; ein Computeralgebrasystem ist eine Voraussetzung für die Arbeit mit dieser Funktion.

wobei θ der Arcuskosinus des Punktprodukts der beiden Quaternionen ist und die fünf Koeffizienten ci 3-Vektoren sind, die von den beiden Matrizen und der Position p abhängen. Diese Spezialisierung hat sich bewährt, da wir die Funktion für einen gegebenen Punkt bei vielen Zeitwerten auswerten müssen.

Wir haben nun zwei Aufgaben: Zunächst müssen wir bei einem Paar von Keyframe-Matrizen und einem Punkt p in der Lage sein, die Werte der Koeffizienten ci effizient zu berechnen. Dann müssen wir angesichts der relativ einfachen Funktion, die durch ci und θ definiert ist, die Nullstellen von Gleichung (2.12) finden, die die Zeitpunkte darstellen können, zu denen Bewegungsextrema auftreten.

Angesichts der ki-Koeffizienten und eines bestimmten Punktes p, dessen Bewegung wir begrenzen wollen, können wir also die Koeffizienten ci der Ableitungsfunktion in Gleichung (2.12) effizient berechnen. Die Struktur DerivativeTerm kapselt diese Koeffizienten und diese Berechnung.

〈AnimatedTransform Private Data〉 + ≡

struct DerivativeTerm {

DerivativeTerm(Float c, Float x, Float y, Float z)

: kc(c), kx(x), ky(y), kz(z) { }

Float kc, kx, ky, kz;

Float Eval(const Point3f &p) const {

return kc + kx * p.x + ky * p.y + kz * p.z;

}

};

Die Attribute c1 – c5 speichern Ableitungsinformationen entsprechend den fünf Termen in Gleichung (2.12). Die drei Array-Elemente entsprechen den drei Dimensionen des Raums.

〈AnimatedTransform Private Data〉 + ≡

DerivativeTerm c1, c2, c3, c4, c5;

Das Fragment 〈Compute terms of motion derivative function〉 im AnimatedTransform-Konstruktor, das hier nicht enthalten ist, initialisiert diese Terme über automatisch generierten Code. Da dafür einige tausend Fließkommaoperationen erforderlich sind, ist es hilfreich, diese Arbeit einmal zu erledigen und über mehrere Bounding-Box-Ecken zu amortisieren. Die Koeffizienten ki lassen sich leichter berechnen, wenn wir von einem kanonischen Zeitbereich ausgehen; später müssen wir die t-Werte der Nullen der Bewegungsfunktion auf den tatsächlichen Verschlusszeitbereich umrechnen.

Gegeben die Koeffizienten ki auf der Grundlage der Keyframe-Matrizen, berechnet BoundPointMotion() eine robuste Begrenzung der Bewegung von p.

〈AnimatedTransform Method Definitions〉 + ≡

Bounds3f AnimatedTransform::BoundPointMotion(const Point3f &p) const {

Bounds3f bounds((*startTransform)(p), (*endTransform)(p));

Float cosTheta = Dot(R, R);

Float theta = std::acos(Klammer(cosTheta, -1, 1));

for (int c = 0; c <3; ++c) {

〈Finde alle Bewegungsableitungs-Nullstellen für die Komponente c 111〉

〈Erweiterung des Begrenzungsrahmens für alle gefundenen Bewegungsableitungs-Nullstellen 111〉

}

return bounds;

Die Funktion IntervalFindZeros(), die in Kürze vorgestellt wird, findet numerisch Nullstellen von Gleichung (2.12). Bis zu vier sind möglich.

〈Finde beliebige Bewegungsableitungs-Nullstellen für die Komponente c〉 ≡ 110

Float-Nullstellen;

int nZeros = 0;

IntervalFindZeros(c1.Eval(p), c2.Eval(p), c3.Eval(p), c4.Eval(p),

c5.Eval(p), theta,

Intervall(0., 1.), Nullen, &nZeros);

Die Nullen werden über t ∈ gefunden, so dass wir innerhalb des Zeitbereichs interpolieren müssen, bevor wir die Methode zur Transformation des Punktes zum entsprechenden Zeitpunkt aufrufen. Beachten Sie auch, dass das Extremum nur in einer der Dimensionen x, y und z liegt, so dass die Schranken nur in dieser einen Dimension aktualisiert werden müssen. Der Einfachheit halber verwenden wir hier nur die Funktion Union(), die alle Dimensionen berücksichtigt, auch wenn zwei ignoriert werden könnten.

〈Erweiterung des Begrenzungsrahmens für jede gefundene Bewegungsableitung Nullen〉 ≡ 110

for (int i = 0; i <nZeros; ++i) {

Point3f pz = (*this)(Lerp(zeros, startTime, endTime), p);

bounds = Union(bounds, pz);

}

Das Finden von Nullstellen der Bewegungsableitungsfunktion, Gleichung (2.12), kann nicht algebraisch erfolgen; es sind numerische Methoden erforderlich. Glücklicherweise verhält sich die Funktion gut – sie ist ziemlich glatt und hat eine begrenzte Anzahl von Nullstellen. (Erinnern Sie sich an die Darstellung in Abbildung 2.18, die ein ungewöhnlich komplexer Vertreter war.)

Wir könnten zwar eine auf der Bisektion basierende Suche oder die Newton-Methode verwenden, aber wir würden riskieren, Nullen zu übersehen, wenn die Funktion die Achse nur kurz kreuzt. Daher werden wir die Intervallarithmetik verwenden, eine Erweiterung der Arithmetik, die Einblicke in das Verhalten von Funktionen über Wertebereiche gibt, was es ermöglicht, Nullstellen von Funktionen robust zu finden.

Um die Grundidee der Intervallarithmetik zu verstehen, betrachten wir zum Beispiel die Funktion f (x) = 2x. Wenn wir ein Intervall von Werten ∈ ℝ haben, dann können wir sehen, dass über dem Intervall, der Bereich von f das Intervall ist. Mit anderen Worten: f () ⊂ .

Mit anderen Worten: Wenn wir zwei Werte addieren, von denen einer im Bereich und der zweite im Bereich liegt, dann muss das Ergebnis im Bereich liegen.

Die Intervallarithmetik hat die wichtige Eigenschaft, dass die Intervalle, die sie liefert, konservativ sind. Insbesondere, wenn f () ⊂ und c > 0 ist, dann wissen wir sicher, dass kein Wert in f negativ ist. Im Folgenden wird gezeigt, wie man Gleichung (2.12) über Intervalle berechnet und die konservativen Schranken der berechneten Intervalle nutzt, um effizient kleine Intervalle mit Nulldurchgängen zu finden, in denen reguläre Wurzelfindungsmethoden zuverlässig eingesetzt werden können.