1. Practicing with Cameras (15 Points)

1.1. 360-degree Renders (5 points)

1.2 Re-creating the Dolly Zoom (10 points)

2. Practicing with Meshes (10 Points)

2.1 Constructing a Tetrahedron (5 points)

2.2 Constructing a Cube (5 points)

3. Re-texturing a mesh (10 points)

4. Camera Transformations (10 points)

I'm using the following interpretation to construct the relative transformations from $R_0$ and $T_0$:

• $\mathbf{x}_B = R_{BA} \mathbf{x}_A + T_{BA}$
  • $R_{BA}$ is the rotation matrix that describes the orientation of coordinate frame A as viewed from frame B. It transforms the coordinates of a vector from frame A's system to frame B's system.
  • $T_{BA}$ is the translation vector that points from the origin of frame B to the origin of frame A, with its coordinates expressed in frame B.
• In case of relative transformations i.e from coordinate frames $A$ -> $B$ -> $C$
  • $\mathbf{x}_C = (R_{CB}R_{BA})\mathbf{x}_A + (R_{CB}T_{BA} + T_{CB})$

R_relative = [[0.,  1., 0.],
             [-1., 0.,  0.],
             [ 0.,  0., 1.]]
T_relative = [0, 0, 0]

R_relative = [[1, 0, 0], 
            [0, 1, 0], 
            [0, 0, 1]]
T_relative = [0, 0, 3]

R_relative = [[1, 0, 0], [0, 1, 0], [0, 0, 1]]
T_relative = [0.5000, -0.5000,  0.0000]

R_relative = [[0.,  0.,  1.],
        [ 0.,  1.,  0.],
        [-1.,  0., 0.]]
T_relative = [-3.,  0.,  3.]

5. Rendering Generic 3D Representations (45 Points)

5.1 Rendering Point Clouds from RGB-D Images (10 points)

5.2 Parametric Functions (10 + 5 points)

superformula

5.3 Implicit Surfaces (15 + 5 points)

Tradeoffs between rendering as a mesh vs a point cloud:

Aspect	Mesh	Point Cloud
Rendering Quality	Produces smooth, shaded surfaces with correct occlusion, normals, and lighting (better for holes).	Good for sparse data, but points may appear noisy; occlusion quality is worse unless heavily densified.
Rendering Speed	Rasterization cost roughly proportional to number of faces; a mesh is often more efficient than an overly-dense point cloud for the same visual quality.	Usually faster to rasterize for small counts; very large point clouds can overwhelm the points rasterizer.
Memory / Storage	Stores vertices + faces; compact representation since connectivity conveys a lot of information.	Stores positions ± colors; needs a lot of samples to match mesh visual fidelity implying larger memory footprint.
Ease of Use	Requires connectivity (or extraction, e.g. marching cubes). Tools like marching cubes make implicit→mesh conversion simple, but it adds a processing step.	Trivial to generate from parametric formulas — no connectivity needed. Good for quick prototyping.
Downstream Tasks	Needed for topology-aware operations, collision detection, UV mapping, and real-time rendering in engines.	Useful for sensor data, SLAM, and learning tasks where connectivity is unknown.

6. Do Something Fun (10 points)

In this, I try to render any generic mesh by using normalization to fit it inside a unit grid and reorient the y axis.

(Extra Credit) 7. Sampling Points on Meshes (10 points)