Name: Kashish Gandhi Andrew ID: kgandhi2
A full turntable of the cow mesh, sweeping the camera azimuth from 0° to 360°.
Field of view and camera distance change together so the cow’s apparent size stays constant while the background perspective warps.
Vertices: 4 · Faces: 4
Vertices: 8 · Faces: 12
color1 (front, smallest z) = [0, 0, 1]
(blue) color2 (back, largest z) =
[1, 0, 0] (red)
Each vertex’s color is linearly interpolated between the two based on its normalized z-position along the front-to-back axis.
Baseline render, produced by R_0, T_0:
R_relative rotates the camera 90° around its own viewing axis (a roll, using the rotation matrix [[0,-1,0],[1,0,0],[0,0,1]]). This doesn’t change the camera’s position or what point it’s looking at — it just spins the captured image itself, so the cow appears rotated 90° within the frame (lying on its side) rather than the camera having moved anywhere in the scene. T_relative is zero, since no repositioning is needed for a pure roll.
R_relative rotates the camera 180° around the vertical (y) axis ([[-1,0,0],[0,1,0],[0,0,-1]]), orbiting it all the way around the cow to view it from directly behind, at the same height and angle as the baseline. T_relative = [0,0,6] compensates for the fact that applying this rotation to the original translation flips the camera to the wrong side of the origin (behind, rather than in front); adding this restores the camera to a sensible viewing distance in front of the cow’s back, roughly matching the baseline’s distance.
R_relative is the same 180° rotation around the y-axis as Transform 2, again viewing the cow from behind. T_relative = [0,0,4.5] applies the same repositioning correction as Transform 2, but with a smaller magnitude — placing the camera noticeably closer to the cow than in Transform 2, so the cow appears larger in frame while still viewed from behind.
R_relative rotates the camera 90° around the vertical (y) axis ([[0,0,1],[0,1,0],[-1,0,0]]), orbiting it a quarter-turn around the cow to view its side profile instead of its front or back. T_relative = [-3,0,3] corrects the camera’s position after this rotation — the rotation alone leaves the camera off-axis and at the same depth as the object itself, so this term re-centers the camera and restores a sensible viewing distance directly out from the cow’s side.
Left to right: point cloud from image 1, point cloud from image 2, and the union of both.
Torus (10 pts) — sampled from the parametric torus equation, hole clearly visible while rotating.
Bonus shape (5 pts) — sphere, sampled from the parametric sphere equation.
Torus mesh (10 pts) — extracted via marching cubes from the implicit torus function.
Meshes and point clouds are pretty different when it comes to quality, speed, memory, and how easy they are to build.
Quality. Meshes look smooth and solid because the triangles connect to each other. There are no gaps, and lighting/shading looks continuous across the surface. Point clouds don’t have any connections between points, so each point is just drawn as a small dot. If you don’t have enough points, you can see gaps between them, especially when looking at the object from the side.
Speed. Point clouds are quick to make since you don’t need to figure out how points connect. But to make a point cloud look as solid as a mesh, you usually need way more points than the mesh needs vertices. So a mesh might actually render faster overall for the same visual quality, even though building a point cloud is simpler.
Memory. A mesh has to store the vertices and also the face list (which vertices connect to form each triangle). A point cloud just stores the points themselves, no connection info needed. So point clouds use less memory per point, but meshes usually need fewer points total to look good, so it evens out depending on the situation.
Ease of building. Point clouds are way easier to create. You can just plug numbers into a formula and get points out, like we did with the parametric sphere and torus. Meshes need extra work: you either have to manually figure out the triangle connections (like we did for the cube and tetrahedron), or use something like marching cubes to build the triangles for you from an implicit function. That’s more work than just outputting points.
Other uses. Meshes are better if you want to do more with the shape later, like smoothing it out, deforming it, or running physics simulations, since the mesh knows what’s inside vs outside. Point clouds don’t have that info built in, so they’re more limited for that kind of stuff.
Bonus shape (5 pts) — metaball pair, blended via an implicit field.
For this part, I made a snowman using multiple shapes combined into one scene with join_meshes_as_scene. The snowman is 3 spheres stacked on top of each other, biggest on the bottom and smallest on top for the head. I built these spheres myself using the same parametric equation from part 5.2, but this time as an actual mesh with triangles instead of just points (I looped over theta and phi and connected nearby points into triangles). I also added 2 small cubes: an orange one for the nose sticking out of the head, and a black one on top for the hat. The tricky part was making sure every piece used the same type of texture before combining them. join_meshes_as_scene gives an error if you try to combine a mesh that uses per-vertex colors with a mesh that uses an image texture, so I had to load everything with flat colors instead of using an actual image texture on any part.
Original mesh, then point clouds sampled with 10, 100, 1000, and 10000 points (area-weighted face sampling + random barycentric coordinates), shown side by side.