2.8 Applying Transformations

We can now define routines that perform the appropriate matrix multiplications to transform points and vectors. We will overload the function application operator to describe these transformations; this lets us write code like:

Point3f p = ...; Transform T = ...; Point3f pNew = T(p);

2.8.1 Points

The point transformation routine takes a point left-parenthesis x comma y comma z right-parenthesis and implicitly represents it as the homogeneous column vector left-bracket x y z Baseline 1 right-bracket Superscript upper T Baseline period It then transforms the point by premultiplying this vector with the transformation matrix. Finally, it divides by w to convert back to a nonhomogeneous point representation. For efficiency, this method skips the division by the homogeneous weight, w , when w equals 1 , which is common for most of the transformations that will be used in pbrt—only the projective transformations defined in Chapter 6 will require this division.

<<Transform Inline Functions>>= 
template <typename T> inline Point3<T> Transform::operator()(const Point3<T> &p) const { T x = p.x, y = p.y, z = p.z; T xp = m.m[0][0]*x + m.m[0][1]*y + m.m[0][2]*z + m.m[0][3]; T yp = m.m[1][0]*x + m.m[1][1]*y + m.m[1][2]*z + m.m[1][3]; T zp = m.m[2][0]*x + m.m[2][1]*y + m.m[2][2]*z + m.m[2][3]; T wp = m.m[3][0]*x + m.m[3][1]*y + m.m[3][2]*z + m.m[3][3]; if (wp == 1) return Point3<T>(xp, yp, zp); else return Point3<T>(xp, yp, zp) / wp; }

2.8.2 Vectors

The transformations of vectors can be computed in a similar fashion. However, the multiplication of the matrix and the column vector is simplified since the implicit homogeneous w coordinate is zero.

<<Transform Inline Functions>>+=  
template <typename T> inline Vector3<T> Transform::operator()(const Vector3<T> &v) const { T x = v.x, y = v.y, z = v.z; return Vector3<T>(m.m[0][0]*x + m.m[0][1]*y + m.m[0][2]*z, m.m[1][0]*x + m.m[1][1]*y + m.m[1][2]*z, m.m[2][0]*x + m.m[2][1]*y + m.m[2][2]*z); }

2.8.3 Normals

Normals do not transform in the same way that vectors do, as shown in Figure 2.14.

Figure 2.14: Transforming Surface Normals. (a) Original circle, with the normal at a point indicated by an arrow. (b) When scaling the circle to be half as tall in the  y direction, simply treating the normal as a direction and scaling it in the same manner gives a normal that is no longer perpendicular to the surface. (c) A properly transformed normal.

Although tangent vectors transform in the straightforward way, normals require special treatment. Because the normal vector bold n and any tangent vector bold t on the surface are orthogonal by construction, we know that

bold n dot bold t equals bold n Superscript upper T Baseline bold t equals 0 period

When we transform a point on the surface by some matrix bold upper M , the new tangent vector bold t prime at the transformed point is bold upper M bold t . The transformed normal bold n prime should be equal to bold upper S bold n for some 4 times 4 matrix bold upper S . To maintain the orthogonality requirement, we must have

StartLayout 1st Row 1st Column 0 2nd Column equals left-parenthesis bold n prime right-parenthesis Superscript upper T Baseline bold t Superscript prime Baseline 2nd Row 1st Column Blank 2nd Column equals left-parenthesis bold upper S bold n right-parenthesis Superscript upper T Baseline bold upper M bold t 3rd Row 1st Column Blank 2nd Column equals left-parenthesis bold n right-parenthesis Superscript upper T Baseline bold upper S Superscript upper T Baseline bold upper M bold t period EndLayout

This condition holds if bold upper S Superscript upper T Baseline bold upper M equals bold upper I , the identity matrix. Therefore, bold upper S Superscript upper T Baseline equals bold upper M Superscript negative 1 , and so bold upper S equals left-parenthesis bold upper M Superscript negative 1 Baseline right-parenthesis Superscript upper T Baseline comma and we see that normals must be transformed by the inverse transpose of the transformation matrix. This detail is one of the main reasons why Transforms maintain their inverses.

Note that this method does not explicitly compute the transpose of the inverse when transforming normals. It just indexes into the inverse matrix in a different order (compare to the code for transforming Vector3fs).

<<Transform Inline Functions>>+=  
template <typename T> inline Normal3<T> Transform::operator()(const Normal3<T> &n) const { T x = n.x, y = n.y, z = n.z; return Normal3<T>(mInv.m[0][0]*x + mInv.m[1][0]*y + mInv.m[2][0]*z, mInv.m[0][1]*x + mInv.m[1][1]*y + mInv.m[2][1]*z, mInv.m[0][2]*x + mInv.m[1][2]*y + mInv.m[2][2]*z); }

2.8.4 Rays

Transforming rays is conceptually straightforward: it’s a matter of transforming the constituent origin and direction and copying the other data members. (pbrt also provides a similar method for transforming RayDifferentials.)

The approach used in pbrt to manage floating-point round-off error introduces some subtleties that require a small adjustment to the transformed ray origin. The <<Offset ray origin to edge of error bounds>> fragment handles these details; it is defined in Section 3.9.4, where round-off error and pbrt’s mechanisms for dealing with it are discussed.

<<Transform Inline Functions>>+=  
inline Ray Transform::operator()(const Ray &r) const { Vector3f oError; Point3f o = (*this)(r.o, &oError); Vector3f d = (*this)(r.d); <<Offset ray origin to edge of error bounds and compute tMax>> 
Float lengthSquared = d.LengthSquared(); Float tMax = r.tMax; if (lengthSquared > 0) { Float dt = Dot(Abs(d), oError) / lengthSquared; o += d * dt; tMax -= dt; }
return Ray(o, d, tMax, r.time, r.medium); }

2.8.5 Bounding Boxes

The easiest way to transform an axis-aligned bounding box is to transform all eight of its corner vertices and then compute a new bounding box that encompasses those points. The implementation of this approach is shown below; one of the exercises for this chapter is to implement a technique to do this computation more efficiently.

<<Transform Method Definitions>>+=  
Bounds3f Transform::operator()(const Bounds3f &b) const { const Transform &M = *this; Bounds3f ret(M(Point3f(b.pMin.x, b.pMin.y, b.pMin.z))); ret = Union(ret, M(Point3f(b.pMax.x, b.pMin.y, b.pMin.z))); ret = Union(ret, M(Point3f(b.pMin.x, b.pMax.y, b.pMin.z))); ret = Union(ret, M(Point3f(b.pMin.x, b.pMin.y, b.pMax.z))); ret = Union(ret, M(Point3f(b.pMin.x, b.pMax.y, b.pMax.z))); ret = Union(ret, M(Point3f(b.pMax.x, b.pMax.y, b.pMin.z))); ret = Union(ret, M(Point3f(b.pMax.x, b.pMin.y, b.pMax.z))); ret = Union(ret, M(Point3f(b.pMax.x, b.pMax.y, b.pMax.z))); return ret; }

2.8.6 Composition of Transformations

Having defined how the matrices representing individual types of transformations are constructed, we can now consider an aggregate transformation resulting from a series of individual transformations. Finally, we will see the real value of representing transformations with matrices.

Consider a series of transformations bold upper A bold upper B bold upper C . We’d like to compute a new transformation bold upper T such that applying bold upper T gives the same result as applying each of bold upper A , bold upper B , and bold upper C in reverse order; that is, bold upper A left-parenthesis bold upper B left-parenthesis bold upper C left-parenthesis normal p right-parenthesis right-parenthesis right-parenthesis equals bold upper T left-parenthesis normal p right-parenthesis . Such a transformation bold upper T can be computed by multiplying the matrices of the transformations bold upper A , bold upper B , and bold upper C together. In pbrt, we can write:

Transform T = A * B * C;

Then we can apply T to Point3fs p as usual, Point3f pp = T(p), instead of applying each transformation in turn: Point3f pp = A(B(C(p))).

We use the C++ * operator to compute the new transformation that results from postmultiplying a transformation with another transformation t2. In matrix multiplication, the left-parenthesis i comma j right-parenthesis th element of the resulting matrix is the inner product of the i th row of the first matrix with the j th column of the second.

The inverse of the resulting transformation is equal to the product of t2.mInv * mInv. This is a result of the matrix identity

left-parenthesis bold upper A bold upper B right-parenthesis Superscript negative 1 Baseline equals bold upper B Superscript negative 1 Baseline bold upper A Superscript negative 1 Baseline period

<<Transform Method Definitions>>+=  
Transform Transform::operator*(const Transform &t2) const { return Transform(Matrix4x4::Mul(m, t2.m), Matrix4x4::Mul(t2.mInv, mInv)); }

2.8.7 Transformations and Coordinate System Handedness

Certain types of transformations change a left-handed coordinate system into a right-handed one, or vice versa. Some routines will need to know if the handedness of the source coordinate system is different from that of the destination. In particular, routines that want to ensure that a surface normal always points “outside” of a surface might need to flip the normal’s direction after transformation if the handedness changes.

Fortunately, it is easy to tell if handedness is changed by a transformation: it happens only when the determinant of the transformation’s upper-left 3 times 3 submatrix is negative.

<<Transform Method Definitions>>+=  
bool Transform::SwapsHandedness() const { Float det = m.m[0][0] * (m.m[1][1] * m.m[2][2] - m.m[1][2] * m.m[2][1]) - m.m[0][1] * (m.m[1][0] * m.m[2][2] - m.m[1][2] * m.m[2][0]) + m.m[0][2] * (m.m[1][0] * m.m[2][1] - m.m[1][1] * m.m[2][0]); return det < 0; }