Computer Graphics, Fall 2025

Michael Kazhdan

Announcements

Overview

In this assignment you will animate motions for an articulated humanoid figure. You will be given an articulated 3D model and sets of keyframes specifying the orientations of articulated joints at specific time steps. Your job is to interpolate the keyframes smoothly over a time interval so that the articulated figure performs animated actions (e.g., walks, dances, etc.).

An overview of the code you will be using can be found here.

An overview of the .ray file syntax can be found here.

An overview of the .key file syntax can be found here.

Sample actor and key-frame files can be found here.

A (Windows x64) compiled version of the renderer implementing some of the basic features can be found here.

A (Linux) compiled version of the renderer implementing some of the basic features can be found here.

The OpenGL programming Guide is an invaluable resource in assisting with OpenGL implementation. You can find a link to the guide here.

Getting Started

You should use the same code-base as in previous assignments (Assignments.zip), as a starting point. As in the previous assignments, code modification should be relegated to the *.todo.cpp files.

After you copy the provided files to your directory, the first thing to do is compile the program. To do this, you will first have to compile the JPEG library and then compile the assignment4 executable.

On a Windows Machine
Begin by double-clicking on Assignments.sln to open the workspace in Microsoft Visual Studios.

• Compile the Assignment4 executable by right-clicking on "Assignment4" and selecting "Build". (If the JPEG.lib, Image.lib, Ray.lib, and Util.lib libraries have not already been compiled, they will be compiled first.)
• The executable Assignment4.exe is compiled in Release mode for the 64-bit architecture and will be placed in the root directory.

On a Linux Machine

• Type make -f Makefile4 to compile the Assignment4 executable. (If the libImage.a, libRay.a, and libUtil.a libraries have not already been compiled, they will be compiled first.) This assumes that JPEG libraries have already been installed on your machine. (If it hasn't been installed yet, you can install it by typing sudo apt-get install libjpeg-dev.)
• The executable Assignment4 is compiled in Release mode and will be placed in the root directory.
• If you are having trouble linking either to the gl libraries or the glu libraries, you should install the associated packages:

  sudo apt-get install libgl1-mesa-dev libglu1-mesa-dev

  For subsequent assignments, you should also install the glut package:

  sudo apt-get install freeglut3-dev

Code Modifications

• For those of you who have not (properly) implemented the Shape::drawOpenGL for the different subclasses of Ray::Shape and/or Camera::drawOpenGL, implementation of these methods is provided for this assignment. The changes can be found in the following files:
  • Ray/camera.todo.cpp
  • Ray/cylinder.todo.cpp
  • Ray/shapeList.todo.cpp
  • Ray/sphere.todo.cpp

Code Outline

In addition to rendering static models, this assignment will allow you to render animated 3D models. The key to doing this is the class DynamicAffineShape (in Ray/shapeList.[h/cpp]). which represents a transformation node in the scene-graph hierarchy whose value is a function of the time elapsed. This object stores a pointer DynamicAffineShape::_matrix to a Matrix4D. At each frame, the transformation DynamicAffineShape::_matrix is changed, and as a result, OpenGL renders a new image.
More specifically, animation is achieved through the use of the template class KeyFrameData (in Ray/keyFrames.h and Ray/keyFrames.inl). This class:

• Stores the values of the different transformations associated to the different joints at the different key-frames.
• Maintains an array of transformations KeyFrameData::_currentValues corresponding to the values of each joint at the current time-frame. (This is what each DynamicAffineShape::_matrix points to.)
• Has a method KeyFrameData::setCurrentValues responsible for updating the transformations in KeyFrameData::_currentValues by interpolating/approximating the transformations prescribed at the different key-frames.

• TrivialRotationParameter which represents a rotation matrix by a (not necessarily rotation) Matrix3D.
• EulerRotationParameter which represents a transformation by a Point3D storing the triplet of Euler angles.
• MatrixRotationParameter which represents a transformation by a rotation Matrix3D.
• SkewSymmetricRotationParameter which represents a transformation by a skew-symmetric Matrix3D.
• QuaternionRotationParameter which represents a transformation by a unit Quaternion.

How the Executable Works

The executable takes in as a mandatory arguments the input (.ray) .ray file name. Additionally, you can also pass in the dimensions of the viewing window, the complexity of the tesselation for objects like the sphere, the cylinder, and the cone, the manner in which rotations should be parameterized, and the way transformations should be blended. It is invoked from the command line with:

% Assignment4 --in <input ray file> --width <width> --height <height> --cplx <complexity> --parameter <matrix representation> --interpolant <interpolation type>

The --parameter argument specifies how the rotations will be parameterized. Options include

• 1: Rotations are represented by 3x3 matrices, the matrices are blended, and the blended transformation (not necessarily rotation) is returned.
• 2: Rotations are represented by 3x3 matrices, the matrices are blended, and the closest rotation to the blended transformation is returned.
• 3: Rotations are represented by Euler angles, the Euler angles are blended, and the rotation described by the blended Euler angles is returned.
• 4: Rotations are represented by skew-symmetric matrices, the skey-symmetrice matrices are blended, and the exponential of the blended skew-symmetric matrix is returned.
• 5: Rotations are represented by quaternions, the quaternions are blended, and the rotation described by the normalized blended quaternion is returned.

The --interpolant argument specifies how transformations should be blended. Options include:

• 1: Nearest point interpolation
• 2: Linear interpolation
• 3: Catmull-Rom interpolation
• 4: Uniform cubic B-spline approximation

Feel free to add new arguments to deal with the new functionalities you are implementing. Just make sure they are documented.

What You Have to Do

The assignment is worth 15 points. The following is a list of features that you may implement. The number in parentheses corresponds to how many points it is worth.

• (1) The code you receive already parses apart the information in the .key files and makes the appropriate calls in the Window::IdleFunction (in Ray/window.[h/cpp]) to update the values of the parameters. In order to obtain smooth animations, modify the Interpolation::Sample (in Util/interpolation.todo.inl) method to support linear interpolation of the key-frame values. (This should be within the LINEAR case of the switch statement.
  You should assume that the value of the interpolation parameter, t, is always between 0 and 1.
• (2) The default representation of a rotation is by a 3x3 (not necessarily rotation) matrix. Consequently, even if the samples are rotations, interpolation can introduce unwanted scaling (as in the runner's legs in Data/act/test.ray). Modify the code to support parametrization of rotations using Euler angles.
  To do this, you will need to implement the operator EulerRotationParameter::operator() (in Util/geometry.todo.cpp) which transforms the triplet of Euler angles into a rotation matrix.
  Recall that the three Euler angles define a rotation which is the product of a rotation about the x-axes, multiplied on the left by a rotation about the y-axes, multiplied on the left by a rotation about the z-axes.
• (2) Although using Euler angles guarantees that the in-between transformations are rotations, they can result in unwanted artifacts (such as the jiggling of the runner's legs in Data/act/test.ray). To fix this problem, implement nearest rotation interpolation/approximation which blends together rotations and then returnes the closest rotation to the blend.
  To do this, you will need to implement the code in Matrix::closestRotation (in Util/geometry.todo.inl) which returns the rotation closest to the linear transformation described by the Matrix object. (To help you on your way, the methods Matrix::SVD and Matrix::determinant have already been provided, giving the SVD decomposition of an arbitrary matrix as the product of a rotation, a diagonal, and another rotation matrix, and returning the determinant of a matrix. The Singular Value Decomposition is performed in such a way that the diagonal entries are non-negative and strictly non-increasing.)
• (2) Implement quaternion parametrization of rotations.
  To do this, you will need to implement the operator QuaternionRotationParameter::operator() (in Util/geometry.todo.cpp) which generates a 3x3 matrix corresponding to a quaternion. (Keep in mind that the matrix is only a rotation if the quaternion is a unit quaternion.)
• (2) Implement the parametrization of rotations by the 3x3 skew-symmetric matrices.
  To do this, you will need to implement the function Matrix::Exp (in Util/geometry.todo.inl) which computes the exponential of a matrix using the first terms terms of the Taylor approximation. Keep in mind that the Taylor series for the exponential function is:
  exp(X)=1+X+X*X/(2!)+X*X*X/(3!)+...+X**k/(k!)+...
  where X**k represents X raised to the k-th power, and k! is "k factorial" -- k*(k-1)*(k-2)*...*2*1.
• (2) Modify the Interpolation::Sample (in Util/interpolation.todo.inl) method to support Catumull-Rom interpolation of the key-frame values. (This should be within the CATMULL_ROM case of the switch statement.
  
• (2) Modify the Interpolation::Sample (in Util/interpolation.todo.inl) method to support uniform cubic B-spline approximation of the key-frame values. (This should be within the UNIFORM_CUBIC_B_SPLINE case of the switch statement.
  
• (2) Create a .ray file and a .key file describing an interesting animation. Do not use any of the .key files provided with this assignment.
• (2) Add the ability to composite two motions specified in separate .key files onto the same actor at the same time. Augment the .key files to include a #Start time, and linearly blend between motions for the subsets of joints in both .key files during transition periods. Demonstrate this feature with a hand waving motion composited onto a walking cycle.
• (?) Impress us with something we hadn't considered...

The assignment will be graded out of 15 points. In addition to implementing these features, there are several other ways to get more points:

• (1) Submitting one or more videos for the art contests.
• (1) Submitting one or more .ray files for the art contests.
• (1) Submitting one or more .key files for the art contests.
• (2) Winning the video art contest.
• (2) Winning the .ray file art contest.
• (2) Winning the .key file art contest.

It is possible to get more than 15 points. However, after 15 points, each point is divided by 2, and after 17 points, each point is divided by 4. If your raw score is 14, your final score will be 14. If the raw score is 18, you'll get 16.25. For a raw score of 21, you'll get 17.

What to Submit

• A write-up describing what you have implemented and what you did for the art contest. (See the general submission page for more information.)
• For the code, submit geometry.todo.cpp, geometry.todo.inl, and interpolation.todo.inl.
• If you choose to implement "Add the ability to composite two motions", please also submit all your modified files, and give a description of what is modified in the write-up.
• For the art contest, pack the submissions into artcontest.zip.
• In summary, the file tree you upload should look like:
  • writeup.pdf
  • geometry.todo.cpp
  • geometry.todo.inl
  • interpolation.todo.inl
  • [artcontest.zip]
    • awesomevideo.mp4
    • interestingartpiece.ray
    • interestinganimation.[key/act/ray]
    • ...
  • Other files, if needed.
  [NOTE] The autograder for assignment 4 only has one test that checks for compilation.