Software 3D-Kamera

3D Kamera-Berechnungen

Vor knapp 30 Jahren hatte ich im Rahmen der Entwicklung unserer ersten Software 3D-Engine Kamera-Funktionen hinzugefügt. In diesem Zusammenhang war dann ein entsprechendes Tutorium entstanden, das Internet war noch sehr jung und das Wissen für die Entwicklung von 3D-Engines dort noch äußerst spärlich gesäht. Solche Berechnungen werden natürlich schon seit langer Zeit typischerweise nicht mehr von Hand berechnet, sondern sind Teil von 3D-Engines und Grafik-SDKs wie Direct3D, OpenGL, Vulkan usw. Diese Engines lagern diese Berechnungen dann in Shadern aus, welche auf den GPUs beschleunigt gerechnet bzw ausgeführt werden. Die mathematischen Grundlagen sind aber im Wesentlichen immer noch dieselben. Damals hatte ich Pascal für die Code-Beispiele verwendet, daher habe ich diese einmal auf modernes C# übertragen.  

Bei der Darstellung einer dreidimensionalen Szene auf einem zweidimensionalen Bildschirm muss zunächst bestimmt werden, wie die räumlichen Objekte relativ zur Kamera liegen. Ein Punkt besitzt zunächst eine Position im globalen Koordinatensystem der Szene. Für die anschließende Projektion auf die Bildebene muss diese Position in das Koordinatensystem der Kamera überführt werden, also von Weltkoordinaten zu Kamerakoordinaten, da wir die Objekte nicht direkt im Weltkoordinatensystem drehen wollen, sondern diese feststehen. Die Kameratransformation bildet also eine wesentliche Grundlage jeder 3D-Grafik, unabhängig davon, ob die Darstellung mit einer modernen Grafik-Engine oder mit einer eigenen Implementierung erfolgt.

Das Koordinatensystem der Szene

In einer dreidimensionalen Szene wird jeder Punkt durch drei Koordinaten beschrieben. Die Koordinaten beziehen sich zunächst auf das Weltkoordinatensystem. Auch die Kamera besitzt eine Position innerhalb dieses Koordinatensystems. Diese Position wird mit C bezeichnet. Wir haben also einmal:

\[
P =
\begin{pmatrix}
x\\
y\\
z
\end{pmatrix}
\]

\[
C =
\begin{pmatrix}
c_x\\
c_y\\
c_z
\end{pmatrix}
\]

Um die Position eines Weltpunktes relativ zur Kamera zu bestimmen, wird zunächst die Kameraposition vom Weltpunkt abgezogen. Es entsteht der relative Positionsvektor:

\[P_{\mathrm{rel}} = P-C =
\begin{pmatrix}
x-c_x\\
y-c_y\\
z-c_z
\end{pmatrix}\]

In C# lässt sich dieser Schritt direkt mit dem Vektortyp Vector3 aus dem Namespace System.Numerics ausdrücken:

using System.Numerics;

Vector3 cameraPosition = new Vector3(75f, 12f, 0f);
Vector3 worldPosition  = new Vector3(120f, 30f, 45f);
Vector3 relativePosition = worldPosition - cameraPosition;

Der resultierende Vektor beschreibt die Position des Punktes relativ zum Standort der Kamera. Die Orientierung der Kamera ist zu diesem Zeitpunkt noch nicht berücksichtigt. Kurzer Hinweis: Ich nutze nach wie vor Vector3, also Spaltenvektoren. Anders als in einer 4x4 Matrix mit Hilfsvektoren sind daher die Koordinaten (x,y,z) jeweils untereinander angeordnet. Es ist effektiver zuerst die Translation und dann die Rotation durchzuführen.  Die Translation zur Kameraposition lässt sich damit folgendermaßen darstellen:
\[
\begin{aligned}
e_x &= x - c_x \\
e_y &= y - c_y \\
e_z &= z - c_z
\end{aligned}
\]

Die Orientierung der Kamera

Neben ihrer Position besitzt eine Kamera eine räumliche Orientierung. Sie kann um die drei Koordinatenachsen gedreht werden. Die drei Drehwinkel werden im Folgenden mit α, β und γ bezeichnet:

Winkel Drehachse Beschreibung
α X-Achse Drehung um die horizontale X-Achse
β Y-Achse Drehung um die vertikale Y-Achse
γ Z-Achse Drehung um die Z-Achse

Für die Berechnung werden die Sinus- und Kosinuswerte der drei Winkel benötigt. Zur Vereinfachung der Schreibweise verwenden wir:

\[
\begin{aligned}
s_1 &= \sin(\alpha), & c_1 &= \cos(\alpha)\\
s_2 &= \sin(\beta),  & c_2 &= \cos(\beta)\\
s_3 &= \sin(\gamma), & c_3 &= \cos(\gamma)
\end{aligned}
\]

Die Winkel müssen für die trigonometrischen Funktionen im Bogenmaß vorliegen. Werden die Winkel beispielsweise in Grad gespeichert, erfolgt die Umrechnung mit:

\[
\varphi_{\mathrm{rad}} =
\varphi_{\mathrm{grad}} \cdot \frac{\pi}{180}
\]

Diese Umrechnung erfolgt dann mit:

float alpha = alphaDegrees * MathF.PI / 180f;
float beta  = betaDegrees  * MathF.PI / 180f;
float gamma = gammaDegrees * MathF.PI / 180f;

Rotationsmatrizen

Eine Drehung um eine einzelne Koordinatenachse lässt sich durch entsprechende 3×3-Matrizen beschreiben. Für die drei Achsen ergeben sich Folgende:

Rotation um die X-Achse

\[
R_x(\alpha)=
\begin{bmatrix}
1 & 0 & 0\\
0 & \cos(\alpha) & -\sin(\alpha)\\
0 & \sin(\alpha) & \cos(\alpha)
\end{bmatrix}
\]

Rotation um die Y-Achse

\[
R_y(\beta)=
\begin{bmatrix}
\cos(\beta) & 0 & \sin(\beta)\\
0 & 1 & 0\\
-\sin(\beta) & 0 & \cos(\beta)
\end{bmatrix}
\]

Rotation um die Z-Achse

\[
R_z(\gamma)=
\begin{bmatrix}
\cos(\gamma) & -\sin(\gamma) & 0\\
\sin(\gamma) & \cos(\gamma) & 0\\
0 & 0 & 1
\end{bmatrix}
\]

Jede dieser Matrizen verändert die Orientierung eines Vektors um genau eine Achse. Durch die Multiplikation der drei Matrizen lässt sich eine beliebige Kombination dieser Drehungen zusammenfassen.

Zusammenfassung der Rotationen

Für die weitere Berechnung wird folgende Reihenfolge festgelegt:

R = Rx(α) · Ry(β) · Rz(γ)

Die Matrixmultiplikation ergibt eine einzige kombinierte Rotationsmatrix. Die ausmultiplizierte Matrix enthält damit bereits alle Drehungen. Statt drei einzelne Rotationen nacheinander auszuführen, genügt es, den Vektor einmal mit der kombinierten Matrix zu multiplizieren. Die hier angegebene Matrix ist die festgelegte Rotationsmatrix für die Transformation des relativen Vektors.

\[
R=
\begin{bmatrix}
c_2c_3 & -c_2s_3 & s_2\\
s_1s_2c_3+c_1s_3 &
-s_1s_2s_3+c_1c_3 &
-s_1c_2\\
-c_1s_2c_3+s_1s_3 &
c_1s_2s_3+s_1c_3 &
c_1c_2
\end{bmatrix}
\]

Transformation des Punktes in das Kamerakoordinatensystem

Nach der Berechnung der kombinierten Rotationsmatrix kann der relative Positionsvektor transformiert werden. Die vollständige Berechnung lautet:

\[
P_{\mathrm{Kamera}}=R\cdot(P-C)
\]

Dabei steht R für die kombinierte Rotationsmatrix, P für den Weltpunkt und C für die Kameraposition. Die Matrix wird von links mit dem Spaltenvektor multipliziert. Daraus ergeben sich drei neue Koordinaten:

\[
\begin{aligned}
x' &= r_{11}x_{\mathrm{rel}}
   + r_{12}y_{\mathrm{rel}}
   + r_{13}z_{\mathrm{rel}}\\[6pt]
y' &= r_{21}x_{\mathrm{rel}}
   + r_{22}y_{\mathrm{rel}}
   + r_{23}z_{\mathrm{rel}}\\[6pt]
z' &= r_{31}x_{\mathrm{rel}}
   + r_{32}y_{\mathrm{rel}}
   + r_{33}z_{\mathrm{rel}}
\end{aligned}
\]

Das Ergebnis ist die Position des Punktes im Kamerakoordinatensystem. Die ursprünglichen Weltkoordinaten bleiben dabei unverändert.

Umsetzung in C#

Die Berechnung lässt sich in C# direkt umsetzen. Der folgende Code verwendet System.Numerics.Vector3 für die Vektoren. 

using System;
using System.Numerics;

public static class Camera3D
{
    public static Vector3 TransformToCamera(Vector3 worldPosition, Vector3 cameraPosition, float alphaDegrees, float betaDegrees, float gammaDegrees)
    {
        // Winkel von Grad in Radiant umrechnen
        float alpha = alphaDegrees * MathF.PI / 180f;
        float beta  = betaDegrees  * MathF.PI / 180f;
        float gamma = gammaDegrees * MathF.PI / 180f;

        // Sinus und Kosinus berechnen
        float s1 = MathF.Sin(alpha);
        float c1 = MathF.Cos(alpha);

        float s2 = MathF.Sin(beta);
        float c2 = MathF.Cos(beta);

        float s3 = MathF.Sin(gamma);
        float c3 = MathF.Cos(gamma);

        // Weltposition relativ zur Kamera
        Vector3 relativePosition = worldPosition - cameraPosition;

        // Elemente der kombinierten Rotationsmatrix
        float r11 = c2 * c3;
        float r12 = -c2 * s3;
        float r13 = s2;

        float r21 = s1 * s2 * c3 + c1 * s3;
        float r22 = -s1 * s2 * s3 + c1 * c3;
        float r23 = -s1 * c2;

        float r31 = -c1 * s2 * c3 + s1 * s3;
        float r32 = c1 * s2 * s3 + s1 * c3;
        float r33 = c1 * c2;

        // Matrixmultiplikation mit einem Spaltenvektor
        float x = r11 * relativePosition.X + r12 * relativePosition.Y + r13 * relativePosition.Z;
        float y = r21 * relativePosition.X + r22 * relativePosition.Y + r23 * relativePosition.Z;
        float z = r31 * relativePosition.X + r32 * relativePosition.Y + r33 * relativePosition.Z;
        return new Vector3(x, y, z);
    }
}

Aufruf der Transformation

Die Methode kann anschließend für jeden Punkt der 3D-Szene aufgerufen werden:

Vector3 cameraPosition = new Vector3(75f, 12f, 0f);
Vector3 worldPosition = new Vector3(120f, 30f, 45f);
Vector3 cameraPositionOfPoint = Camera3D.TransformToCamera(worldPosition, cameraPosition, alphaDegrees, betaDegrees, gammaDegrees);

Das Ergebnis enthält die transformierten X-, Y- und Z-Koordinaten des Punktes im Kamerakoordinatensystem. Die Variable cameraPositionOfPoint bezeichnet hier die Position des transformierten Punktes im Kamerakoordinatensystem. Sie ist nicht mit der eigentlichen Kameraposition im Weltkoordinatensystem zu verwechseln.

Verarbeitung mehrerer 3D-Punkte

In einer realen 3D-Szene müssen in der Regel nicht nur einzelne Punkte, sondern komplette Objekte transformiert werden. Ein Objekt besteht beispielsweise aus einer Punktwolke, welche die Geometrie des Objektes beschreiben. Die Weltkoordinaten dieser Punkte sollten nicht überschrieben werden. Stattdessen wird für die transformierten Koordinaten ein separates Array angelegt. Dadurch bleiben die ursprünglichen Geometriedaten erhalten und können jederzeit erneut transformiert werden, beispielsweise wenn sich die Kameraposition oder ihre Orientierung verändert.

Vector3[] worldPoints =
{
    new Vector3(100f,  0f,  0f),
    new Vector3(100f, 50f,  0f),
    new Vector3(100f, 50f, 50f),
    new Vector3(100f,  0f, 50f)
};

Vector3[] cameraPoints = new Vector3[worldPoints.Length];

for (int i = 0; i < worldPoints.Length; i++)
{
    cameraPoints[i] = Camera3D.TransformToCamera(worldPoints[i], cameraPosition, 10f, 25f, 5f);
}

Die Datenstruktur trennt damit klar zwischen der ursprünglichen Geometrie und den für die aktuelle Kamera berechneten Koordinaten. Die Berechnungen sollten grundsätzlich mit Gleitkommazahlen erfolgen. Eine Rundung der Koordinaten ist erst dann sinnvoll, wenn die Werte für die eigentliche Bildschirmdarstellung in Pixelkoordinaten umgerechnet werden.

Von Kamerakoordinaten zur Bildschirmdarstellung

Nach der Kameratransformation liegen die Punkte im Koordinatensystem der Kamera vor. Um sie auf dem Bildschirm darzustellen, müssen sie anschließend auf eine zweidimensionale Bildebene projiziert werden. Bei einer perspektivischen Projektion hängt die Größe eines Objektes von seinem Abstand zur Kamera ab. Weiter entfernte Punkte erscheinen kleiner als nahe Punkte. Eine vereinfachte perspektivische Projektion kann mit folgenden Gleichungen beschrieben werden:

xBild = f · x' / z'
yBild = f · y' / z'

Dabei bezeichnet f die Brennweite beziehungsweise einen entsprechenden Projektionsfaktor. x' und y' sind die transformierten Kamerakoordinaten, z' beschreibt die Tiefe des Punktes. Die Gleichungen setzen eine Kamerakonvention voraus, bei der die positive Z-Achse in Blickrichtung zeigt. Für die tatsächliche Bildschirmdarstellung wird der Projektionsmittelpunkt üblicherweise auf die Mitte des Bildschirms gelegt. Außerdem muss die vertikale Bildschirmachse berücksichtigt werden, da die Y-Koordinate in vielen Bildschirmsystemen nach unten zunimmt.

Ein vereinfachtes Beispiel für die Berechnung der Pixelposition in C#:

float focalLength = 500f;
int screenCenterX = 800;
int screenCenterY = 450;

if (cameraPoint.Z > 0.001f)
{
    float projectedX = focalLength * cameraPoint.X / cameraPoint.Z;
    float projectedY = focalLength * cameraPoint.Y / cameraPoint.Z;
    int pixelX = screenCenterX + (int)projectedX;
    int pixelY = screenCenterY - (int)projectedY;
}

In einer vollständigen Implementierung müssen dann natürlich zusätzlich Punkte behandelt werden, die hinter der Kamera liegen oder sich zu nahe an der Kamera befinden (Clipping usw).

Wir benutzen Cookies
Diese Seite enthält Cookies. Wir verwenden Cookies, um Inhalte und Anzeigen zu personalisieren und die Zugriffe auf unsere Website zu analysieren.