The camera is important because it determines how a scene is presented to the viewer, shaping their perception of space, depth, and composition. By defining the perspective and field of view, it controls what is visible and how it appears, ensuring the visual output aligns with the desired artistic or functional intent.
 | Camera Model |  |
The camera model simulates how a physical camera works by defining how rays are cast into a 3D scene and how these rays intersect with objects to form an image. The camera acts as the viewer's eye, projecting rays from its position through each pixel of the image plane and into the 3D world to determine what is visible from that point of view.
The essential elements of a camera model in ray tracing are:
• Position: Where the camera is placed in the 3D space.
• Orientation: The direction the camera is facing (usually given by an eye or view direction).
• Image Plane: A 2D plane where the scene will be projected.
• Field of View (FoV): The angular extent of the scene that is visible through the camera.
• Aspect Ratio: The width-to-height ratio of the image.
A simple pinhole camera model can be described by casting rays from the camera origin through the image plane. The rays follow this equation:
\[
\text{Ray}(t) = \text{cameraPosition} + t \cdot \text{rayDirection}
\]
Example Code: Simple Pinhole Camera Model in JavaScript
class Camera {
constructor(cameraPosition, lookAt, upVector, fov, aspectRatio) {
this.position = cameraPosition;
this.aspectRatio = aspectRatio;
this.fov = fov;
const w = normalize(subtract(cameraPosition, lookAt)); // View direction
const u = normalize(cross(upVector, w)); // Right direction
const v = cross(w, u); // Up direction
const halfHeight = Math.tan(fov / 2);
const halfWidth = aspectRatio * halfHeight;
this.lowerLeftCorner = subtract(
subtract(subtract(this.position, scale(u, halfWidth)),
scale(v, halfHeight)),
w
);
this.horizontal = scale(u, 2 * halfWidth);
this.vertical = scale(v, 2 * halfHeight);
}
getRay(u, v) {
return new Ray(
this.position,
add(
add(this.lowerLeftCorner, scale(this.horizontal, u)),
subtract(scale(this.vertical, v), this.position)
)
);
}
}
| Projective Camera Models | |
Projective camera models introduce perspective projection, which mimics how a real camera or the human eye perceives depth. In a projective camera model, parallel lines converge at a vanishing point, creating the illusion of depth.
A perspective projection matrix is often used to transform 3D points into a normalized 2D image plane with the following matrix equation:
\[
P_{\text{perspective}} =
\begin{bmatrix}
\frac{1}{\tan(\frac{fov}{2}) \cdot \text{aspect}} & 0 & 0 & 0 \\
0 & \frac{1}{\tan(\frac{fov}{2})} & 0 & 0 \\
0 & 0 & \frac{z_{\text{far}} + z_{\text{near}}}{z_{\text{near}} - z_{\text{far}}} & \frac{2 \cdot z_{\text{far}} \cdot z_{\text{near}}}{z_{\text{near}} - z_{\text{far}}} \\
0 & 0 & -1 & 0
\end{bmatrix}
\]
This matrix defines how a point in 3D is transformed into 2D coordinates on the screen. The focal length and field of view affect how the depth is perceived.
Example Code: Projective Camera Model in JavaScript
ript
class ProjectiveCamera {
constructor(fov, aspect, near, far) {
this.projectionMatrix = [
[1 / (aspect * Math.tan(fov / 2)), 0, 0, 0],
[0, 1 / Math.tan(fov / 2), 0, 0],
[0, 0, (near + far) / (near - far), (2 * near * far) / (near - far)],
[0, 0, -1, 0]
];
}
project(point) {
const [x, y, z, w] = multiplyMatrixAndPoint(this.projectionMatrix, point);
return [x / w, y / w];
}
}
| Environment Camera | |
An environment camera captures the entire surrounding scene in a spherical (or sometimes cubic) format. This type of camera is typically used in rendering environments, such as generating 360-degree panoramas or applying environment mapping techniques in shaders.
For an environment camera, rays are projected outward in all directions, effectively capturing a 360-degree view. In a ray-tracing context, this means that the ray direction is determined based on the pixels position on a sphere surrounding the camera.
Spherical CoordinatesTo generate rays for an environment camera, we can use spherical coordinates. The direction of the ray is defined by two angles: (azimuthal angle) and (polar angle).
\[
x = \sin(\phi) \cos(\theta)
\]
\[
y = \cos(\phi)
\]
\[
z = \sin(\phi) \sin(\theta)
\]
Example Code: Environment Camera in JavaScript
class EnvironmentCamera {
constructor(position) {
this.position = position;
}
getRay(u, v) {
const theta = 2 * Math.PI * u; // Azimuth angle
const phi = Math.PI * v; // Polar angle
const direction = new Vector3(
Math.sin(phi) * Math.cos(theta),
Math.cos(phi),
Math.sin(phi) * Math.sin(theta)
);
return new Ray(this.position, direction);
}
}
| Realistic Cameras | |
Realistic cameras aim to simulate the physical attributes of real-world cameras, such as lens distortion, aperture size, and depth of field. These cameras go beyond simple pinhole models by incorporating lens systems that refract light according to real-world optics principles. The key parameters are:
• Aperture: Determines how much light is allowed through, affecting the exposure and depth of field.
• Lens System: A series of lenses that can bend and focus light.
• Focal Length: The distance between the lens and the image plane, affecting the magnification and field of view.
The equation for depth of field, influenced by the aperture and focal length, is:
\[
b = \frac{f \cdot s}{s - f}
\]
Where:
- \( b \) is the image distance (where the image is focused).
- \( f \) is the focal length.
- \( s \) is the subject distance (distance from the camera to the object being photographed).
Example Code: Realistic Camera in JavaScript
class RealisticCamera {
constructor(lensRadius, focalDistance) {
this.lensRadius = lensRadius;
this.focalDistance = focalDistance;
}
getRay(u, v, sensorPoint) {
const lensPoint = randomPointInDisk(this.lensRadius);
const focusPoint = scale(subtract(sensorPoint, lensPoint), this.focalDistance);
const direction = normalize(subtract(focusPoint, lensPoint));
return new Ray(lensPoint, direction);
}
}
function randomPointInDisk(radius) {
let x, y;
do {
x = 2 * Math.random() - 1;
y = 2 * Math.random() - 1;
} while (x * x + y * y >= 1);
return new Vector3(x * radius, y * radius, 0);
}
|
