Gerard Maggiolino 16-889 Project 1

Problem 1.1

We generate multiple rotations and translations with pytorch3d.renderer.cameras.look_at_view_transform(dist=3, elev=30, azim=ang) where the ang varies in [0, 360]. We then create an FoVPerspectiveCamera with that rotation and translation, render, and save the image. We get this gif.

Problem 1.2

Here we just use the formula on Wikipedia that relates image width to FOV and distance, although we could derive it as well from geometry. In Python that's:
distance = initial_distance / (2 * math.tan(0.5 * math.radians(fov)))

Problem 2.1

We defined an .obj file and specified the vertices and faces. Then we reused the same cow rendering code from the first problem, but with a new .obj file.

Problem 2.2

Similar to 2.1, we just defined a cube obj file.

Problem 3

I chose [1, 0, 1] for c1 and [0, 1, 0] for c2 as they're the furthest away from each other by euclidean distance, without really thinking about which colors they are. After rendering, we can see it's green and purple.

Problem 4

We only need to use:


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

because this is a 90 degree rotation in the z-axis. To help myself convert from rotations about axes to rotation matrices I used the following website: https://www.andre-gaschler.com/rotationconverter/

Here, the cow just gets smaller, which looks like a translation directly backwards.


T_relative = [0, 0, 1]

brings us back and gives us:

Here, it looks like the camera has moved to the right, up, and forward a bit, maybe with rotation. Because rotation is more complicated to reason about, we try to achieve the same look with just translation. I find that an absolute translation of [.4, -.4, 2.4] gives similar results, so the relative is:


T_relative = [.4, -.4, -.4]

Here, we need to be careful since we want to rotate the camera 90 degrees to the left but doing so will also rotate the translation. I first figure out in world coordinates where we want the camera to be, then work backwards to figure out relative transforms. The absolute transform is

R=[[0, 0., 1], [0, 1., 0], [-1, 0, 0]], T=
[0, 0, 3]

which is a positive 90 degree rotation about the y axis (where the rotation is apply to T). However, setting R_relative to that will rotate T as well to [3, 0, 0], so we apply a relative transform of [-3, 0, 3] to reset it back to [0, 0, 3]. This gives us:


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

Problem 5.1

In one gif we have camera 1, camera 2, and the output from both cameras.

Problem 5.2

Here we copied the sphere function but changed the generation parameters and rendering to get a 360 view.

Problem 5.3

It's difficult to compare the two approaches as they seem to be for pretty different purposes. If we want to see a smooth visualization, we should use a mesh, as getting a smooth surface with a point cloud requires a very large amount of points. However, if we want a coarse visualization, the point cloud is much more efficient in both memory and rendering speed. We do not need to be concerned with lighting and ray tracing, we can just display points in 3D space. Because of voxels, building a mesh is cubed in memory requirement, with points being linear in the number of points. Again, one isn't better or worse, but they serve different purposes as they're visually different.

Problem 6

Because it's Valentine's day soon, I made Taubin's heart surface. Normally represented by the implicit equation, I converted it to the parametric equation and plotted a point cloud. I also colored it a gradient of red and purple. I also used a varying viewpoint, so that you'd see both above and under the heart in a loop that meets at the center.