COMPUTER GRAPHICS AND FUNDAMENTALS OF IMAGE PROCESSING 21CS63
Module-2
2D and 3D graphics with OpenGL: 2D Geometric Transformations: Basic 2D Geometric
Transformations, matrix representations and homogeneous coordinates, 2D Composite
transformations, other 2D transformations, raster methods for geometric transformations,
OpenGL raster transformations, OpenGL geometric transformations function,
3D Geometric Transformations: Translation, rotation, scaling, composite 3D transformations,
other 3D transformations, OpenGL geometric transformations functions.
Two-Dimensional Geometric Transformations
Operations that are applied to the geometric description of an object to change its position,
orientation, or size are called geometric transformations.
Basic Two-Dimensional Geometric Transformations
The geometric-transformation functions that are available in all graphics packages are those for
translation, rotation, and scaling.
Two-Dimensional Translation
We perform a translation on a single coordinate point by adding offsets to its coordinates
so as to generate a new coordinate position.
We are moving the original point position along a straight-line path to its new location.
To translate a two-dimensional position, we add translation distances tx and ty to the
original coordinates (x, y) to obtain the new coordinate position (x’, y’) as shown in
Figure
NOOR SUMAIYA, [Link], DEPT OF CSE, TOCE Page 1
COMPUTER GRAPHICS AND FUNDAMENTALS OF IMAGE PROCESSING 21CS63
The translation values of x’ and y’ is calculated as
The translation distance pair (tx, ty) is called a translation vector or shift vector Column
vector representation is given as
This allows us to write the two-dimensional translation equations in the matrix Form.
Translation is a rigid-body transformation that moves objects without deformation.
Code:
class wcPt2D {
public:
GLfloat x, y;
};
void translatePolygon (wcPt2D * verts, GLint nVerts, GLfloat tx, GLfloat ty)
GLint k;
for (k = 0; k < nVerts; k++) {
verts [k].x = verts [k].x + tx;
verts [k].y = verts [k].y + ty;
NOOR SUMAIYA, [Link], DEPT OF CSE, TOCE Page 2
COMPUTER GRAPHICS AND FUNDAMENTALS OF IMAGE PROCESSING 21CS63
glBegin (GL_POLYGON);
for (k = 0; k < nVerts; k++)
glVertex2f (verts [k].x, verts [k].y);
glEnd ( );
Two-Dimensional Rotation
We generate a rotation transformation of an object by specifying a rotation axis and a
rotation angle.
A two-dimensional rotation of an object is obtained by repositioning the object along a
circular path in the xy plane.
In this case, we are rotating the object about a rotation axis that is perpendicular to the xy
plane (parallel to the coordinate z axis).
Parameters for the two-dimensional rotation are the rotation angle θ and a position (xr,
yr ), called the rotation point (or pivot point), about which the object is to be rotated.
A positive value for the angle θ defines a counterclockwise rotation about the pivot point,
as in above Figure , and a negative value rotates objects in the clockwise direction.
The angular and coordinate relationships of the original and transformed point positions
are shown in Figure
NOOR SUMAIYA, [Link], DEPT OF CSE, TOCE Page 3
COMPUTER GRAPHICS AND FUNDAMENTALS OF IMAGE PROCESSING 21CS63
In this figure, r is the constant distance of the point from the origin, angle φ is the original
angular position of the point from the horizontal, and θ is the rotation angle.
we can express the transformed coordinates in terms of angles θ and φ as
The original coordinates of the point in polar coordinates are
Substituting expressions of x and y in the equations of x’ and y’ we get
We can write the rotation equations in the matrix form
P’ = R· P
Where the rotation matrix is,
Rotation of a point about an arbitrary pivot position is illustrated in Figure
NOOR SUMAIYA, [Link], DEPT OF CSE, TOCE Page 4
COMPUTER GRAPHICS AND FUNDAMENTALS OF IMAGE PROCESSING 21CS63
The transformation equations for rotation of a point about any specified rotation position
(xr , yr ):
Code:
class wcPt2D {
public:
GLfloat x, y;
};
void rotatePolygon (wcPt2D * verts, GLint nVerts, wcPt2D pivPt, GLdouble theta)
{
wcPt2D *
vertsRot; GLint k;
for (k = 0; k < nVerts; k++) {
vertsRot [k].x = pivPt.x + (verts [k].x - pivPt.x) * cos (theta) -
(verts [k].y - pivPt.y) * sin (theta);
vertsRot [k].y = pivPt.y + (verts [k].x - pivPt.x) * sin (theta) + (verts [k].y -
pivPt.y) * cos (theta);
}
glBegin (GL_POLYGON);
for (k = 0; k < nVerts; k++)
glVertex2f (vertsRot [k].x, vertsRot [k].y);
glEnd ( );
}
NOOR SUMAIYA, [Link], DEPT OF CSE, TOCE Page 5
COMPUTER GRAPHICS AND FUNDAMENTALS OF IMAGE PROCESSING 21CS63
Two-Dimensional Scaling
To alter the size of an object, we apply a scaling transformation.
A simple two dimensional scaling operation is performed by multiplying object positions
(x, y) by scaling factors sx and sy to produce the transformed coordinates (x’, y’):
The basic two-dimensional scaling equations can also be written in the following matrix
form
Where S is the 2 × 2 scaling matrix
Any positive values can be assigned to the scaling factors sx and sy.
Values less than 1 reduce the size of objects
Values greater than 1 produce enlargements.
Specifying a value of 1 for both sx and sy leaves the size of objects unchanged.
When sx and sy are assigned the same value, a uniform scaling is produced, which
maintains relative object proportions.
Unequal values for sx and sy result in a differential scaling that is often used in design
applications.
In some systems, negative values can also be specified for the scaling parameters. This
not only resizes an object, it reflects it about one or more of the coordinate axes.
Figure below illustrates scaling of a line by assigning the value 0.5 to both sx and sy
We can control the location of a scaled object by choosing a position, called the fixed
point, that is to remain unchanged after the scaling transformation.
NOOR SUMAIYA, [Link], DEPT OF CSE, TOCE Page 6
COMPUTER GRAPHICS AND FUNDAMENTALS OF IMAGE PROCESSING 21CS63
Coordinates for the fixed point, (x f , yf ), are often chosen at some object position, such
as its centroid but any other spatial position can be selected.
For a coordinate position (x, y), the scaled coordinates (x’, y’) are then calculated from
the following relationships:
We can rewrite Equations to separate the multiplicative and additive terms as
Where the additive terms x f (1 − sx) and yf (1 − sy) are constants for all points in the
object.
Code:
class wcPt2D {
public:
GLfloat x, y;
};
void scalePolygon (wcPt2D * verts, GLint nVerts, wcPt2D fixedPt, GLfloat sx, GLfloat sy)
{
wcPt2D vertsNew;
GLint k;
for (k = 0; k < nVerts; k++) {
vertsNew [k].x = verts [k].x * sx + fixedPt.x * (1 - sx);
vertsNew [k].y = verts [k].y * sy + fixedPt.y * (1 - sy);
}
glBegin (GL_POLYGON);
for (k = 0; k < nVerts; k++)
glVertex2f (vertsNew [k].x, vertsNew [k].y);
glEnd ( );
}
Matrix Representations and Homogeneous Coordinates
NOOR SUMAIYA, [Link], DEPT OF CSE, TOCE Page 7
COMPUTER GRAPHICS AND FUNDAMENTALS OF IMAGE PROCESSING 21CS63
Each of the three basic two-dimensional transformations (translation, rotation, and
scaling) can be expressed in the general matrix form
With coordinate positions P and P’ represented as column vectors.
Matrix M1 is a 2 × 2 array containing multiplicative factors, and M2 is a two-element
column matrix containing translational terms.
For translation, M1 is the identity matrix.
For rotation or scaling, M2 contains the translational terms associated with the pivot point
or scaling fixed point.
Homogeneous Coordinates
Multiplicative and translational terms for a two-dimensional geometric transformation
can be combined into a single matrix if we expand the representations to 3 × 3 matrices
We can use the third column of a transformation matrix for the translation terms, and all
transformation equations can be expressed as matrix multiplications.
We also need to expand the matrix representation for a two-dimensional coordinate
position to a three-element column matrix.
A standard technique for accomplishing this is to expand each two dimensional
coordinate-position representation (x, y) to a three-element representation (xh, yh, h),
called homogeneous coordinates, where the homogeneous parameter h is a nonzero value
such that
A general two-dimensional homogeneous coordinate representation could also be written
as (h· x, h· y, h).
A convenient choice is simply to set h = 1. Each two-dimensional position is then
represented with homogeneous coordinates (x, y, 1).
The term homogeneous coordinates is used in mathematics to refer to the effect of this
representation on Cartesian equations.
Two-Dimensional Translation Matrix
The homogeneous-coordinate for translation is given by
NOOR SUMAIYA, [Link], DEPT OF CSE, TOCE Page 8
COMPUTER GRAPHICS AND FUNDAMENTALS OF IMAGE PROCESSING 21CS63
This translation operation can be written in the abbreviated form
with T(tx, ty) as the 3 × 3 translation matrix
Two-Dimensional Rotation Matrix
Two-dimensional rotation transformation equations about the coordinate origin can be
expressed in the matrix form
The rotation transformation operator R(θ ) is the 3 × 3 matrix with rotation parameter θ.
Two-Dimensional Scaling Matrix
A scaling transformation relative to the coordinate origin can now be expressed as the
matrix multiplication
The scaling operator S(sx, sy ) is the 3 × 3 matrix with parameters sx and sy
Inverse Transformation
For translation, we obtain the inverse matrix by negating the translation distances.
Thus, if we have two-dimensional translation distances tx and ty, the inverse
translation matrix is
NOOR SUMAIYA, [Link], DEPT OF CSE, TOCE Page 9
COMPUTER GRAPHICS AND FUNDAMENTALS OF IMAGE PROCESSING 21CS63
An inverse rotation is accomplished by replacing the rotation angle by its negative.
A two-dimensional rotation through an angle θ about the coordinate origin has the
inverse transformation matrix
We form the inverse matrix for any scaling transformation by replacing the scaling
parameters with their reciprocals. the inverse transformation matrix is
Two-Dimensional Composite Transformations
Forming products of transformation matrices is often referred to as a concatenation, or
composition, of matrices if we want to apply two transformations to point position P,
the transformed location would be calculated as
The coordinate position is transformed using the composite matrixM, rather than
applying the individual transformations M1 and then M2.
Composite Two-Dimensional Translations
If two successive translation vectors (t1x, t1y) and (t2x, t2y) are applied to a two
dimensional coordinate position P, the final transformed location P’ is calculated as
where P and P’ are represented as three-element, homogeneous-coordinate column
vectors
Also, the composite transformation matrix for this sequence of translations is
NOOR SUMAIYA, [Link], DEPT OF CSE, TOCE Page 10
COMPUTER GRAPHICS AND FUNDAMENTALS OF IMAGE PROCESSING 21CS63
Composite Two-Dimensional Rotations
Two successive rotations applied to a point P produce the transformed position
By multiplying the two rotation matrices, we can verify that two successive rotations are
additive:
R(θ2) · R(θ1) = R(θ1 + θ2)
So that the final rotated coordinates of a point can be calculated with the composite
rotation matrix as
P’ = R(θ1 + θ2) · P
Composite Two-Dimensional Scaling
Concatenating transformation matrices for two successive scaling operations in two
dimensions produces the following composite scaling matrix
General Two-Dimensional Pivot-Point Rotation
NOOR SUMAIYA, [Link], DEPT OF CSE, TOCE Page 11
COMPUTER GRAPHICS AND FUNDAMENTALS OF IMAGE PROCESSING 21CS63
We can generate a two-dimensional rotation about any other pivot point (xr , yr ) by
performing the following sequence of translate-rotate-translate operations:
1. Translate the object so that the pivot-point position is moved to the coordinate origin.
2. Rotate the object about the coordinate origin.
3. Translate the object so that the pivot point is returned to its original position.
The composite transformation matrix for this sequence is obtained with the
concatenation.
which can be expressed in the form
where T(−xr , −yr ) = T−1(xr , yr ).
General Two-Dimensional Fixed-Point Scaling
NOOR SUMAIYA, [Link], DEPT OF CSE, TOCE Page 12
COMPUTER GRAPHICS AND FUNDAMENTALS OF IMAGE PROCESSING 21CS63
To produce a two-dimensional scaling with respect to a selected fixed position (x f , yf ),
when we have a function that can scale relative to the coordinate origin only. This
sequence is
1. Translate the object so that the fixed point coincides with the coordinate origin.
2. Scale the object with respect to the coordinate origin.
3. Use the inverse of the translation in step (1) to return the object to its original
position.
Concatenating the matrices for these three operations produces the required scaling
matrix:
General Two-Dimensional Scaling Directions
Parameters sx and sy scale objects along the x and y directions.
We can scale an object in other directions by rotating the object to align the desired
scaling directions with the coordinate axes before applying the scaling transformation.
Suppose we want to apply scaling factors with values specified by parameters s1 and s2
in the directions shown in Figure
NOOR SUMAIYA, [Link], DEPT OF CSE, TOCE Page 13
COMPUTER GRAPHICS AND FUNDAMENTALS OF IMAGE PROCESSING 21CS63
The composite matrix resulting from the product of these three transformations is
Other Two-Dimensional Transformations
Two such transformations
1. Reflection
2. Shear
Reflection
A transformation that produces a mirror image of an object is called a reflection.
For a two-dimensional reflection, this image is generated relative to an axis of reflection
by rotating the object 180◦ about the reflection axis.
Reflection about the line y = 0 (the x axis) is accomplished with the transformation
Matrix
This transformation retains x values, but “flips” the y values of coordinate positions.
The resulting orientation of an object after it has been reflected about the x axis is shown
in Figure
NOOR SUMAIYA, [Link], DEPT OF CSE, TOCE Page 14
COMPUTER GRAPHICS AND FUNDAMENTALS OF IMAGE PROCESSING 21CS63
A reflection about the line x = 0 (the y axis) flips x coordinates while keeping y
coordinates the same. The matrix for this transformation is
Figure below illustrates the change in position of an object that has been reflected about
the line x = 0.
We flip both the x and y coordinates of a point by reflecting relative to an axis that is
perpendicular to the xy plane and that passes through the coordinate origin the matrix
representation for this reflection is
An example of reflection about the origin is shown in Figure
NOOR SUMAIYA, [Link], DEPT OF CSE, TOCE Page 15
COMPUTER GRAPHICS AND FUNDAMENTALS OF IMAGE PROCESSING 21CS63
If we choose the reflection axis as the diagonal line y = x (Figure below), the reflection
matrix is
To obtain a transformation matrix for reflection about the diagonal y = −x, we could
concatenate matrices for the transformation sequence:
1. Clockwise rotation by 45◦
2. Reflection about the y axis
3. Counterclockwise rotation by 45◦. The resulting transformation matrix is
NOOR SUMAIYA, [Link], DEPT OF CSE, TOCE Page 16
COMPUTER GRAPHICS AND FUNDAMENTALS OF IMAGE PROCESSING 21CS63
Shear
A transformation that distorts the shape of an object such that the transformed shape
appears as if the object were composed of internal layers that had been caused to slide
over each other is called a shear.
Two common shearing transformations are those that shift coordinate x values and those
that shift y values. An x-direction shear relative to the x axis is produced with the
transformation Matrix which transforms coordinate positions as
which transforms coordinate positions as
Any real number can be assigned to the shear parameter shx Setting parameter shx to the
value 2, for example, changes the square into a parallelogram is shown below. Negative
values for shx shift coordinate positions to the left.
A unit square (a) is converted to a parallelogram (b) using the x -direction shear with shx
= 2.
We can generate x-direction shears relative to other reference lines with
Now, coordinate positions are transformed as
NOOR SUMAIYA, [Link], DEPT OF CSE, TOCE Page 17
COMPUTER GRAPHICS AND FUNDAMENTALS OF IMAGE PROCESSING 21CS63
A y-direction shear relative to the line x = xref is generated with the transformation
Matrix
which generates the transformed coordinate values
Raster Methods for Geometric Transformations
Raster systems store picture information as color patterns in the frame buffer.
Therefore, some simple object transformations can be carried out rapidly by manipulating
an array of pixel values
Few arithmetic operations are needed, so the pixel transformations are particularly
efficient.
Functions that manipulate rectangular pixel arrays are called raster operations and
moving a block of pixel values from one position to another is termed a block transfer, a
bitblt, or a pixblt.
Figure below illustrates a two-dimensional translation implemented as a block transfer of
a refresh-buffer area
Translating an object from screen position (a) to the destination position shown in (b) by moving
a rectangular block of pixel values. Coordinate positions Pmin and Pmax specify the limits of the
rectangular block to be moved, and P0 is the destination reference position.
NOOR SUMAIYA, [Link], DEPT OF CSE, TOCE Page 18
COMPUTER GRAPHICS AND FUNDAMENTALS OF IMAGE PROCESSING 21CS63
Rotations in 90-degree increments are accomplished easily by rearranging the elements
of a pixel array.
We can rotate a two-dimensional object or pattern 90◦ counterclockwise by reversing the
pixel values in each row of the array, then interchanging rows and columns.
A 180◦ rotation is obtained by reversing the order of the elements in each row of the
array, then reversing the order of the rows.
Figure below demonstrates the array manipulations that can be used to rotate a pixel
block by 90◦ and by 180◦.
For array rotations that are not multiples of 90◦, we need to do some extra processing.
The general procedure is illustrated in Figure below.
Each destination pixel area is mapped onto the rotated array and the amount of overlap
with the rotated pixel areas is calculated.
A color for a destination pixel can then be computed by averaging the colors of the
overlapped source pixels, weighted by their percentage of area overlap.
Pixel areas in the original block are scaled, using specified values for sx and sy, and then
mapped onto a set of destination pixels.
The color of each destination pixel is then assigned according to its area of overlap with
the scaled pixel areas.
NOOR SUMAIYA, [Link], DEPT OF CSE, TOCE Page 19
COMPUTER GRAPHICS AND FUNDAMENTALS OF IMAGE PROCESSING 21CS63
OpenGL Raster Transformations
A translation of a rectangular array of pixel-color values from one buffer area to another
can be accomplished in OpenGL as the following copy operation:
glCopyPixels (xmin, ymin, width, height, GL_COLOR);
The first four parameters in this function give the location and dimensions of the pixel
block; and the OpenGL symbolic constant GL_COLOR specifies that it is color values
are to be copied.
A block of RGB color values in a buffer can be saved in an array with the function
glReadPixels (xmin, ymin, width, height, GL_RGB, GL_UNSIGNED_BYTE,
colorArray);
If color-table indices are stored at the pixel positions, we replace the constant GL RGB
with GL_COLOR_INDEX.
To rotate the color values, we rearrange the rows and columns of the color array, as
described in the previous section. Then we put the rotated array back in the buffer with
glDrawPixels (width, height, GL_RGB, GL_UNSIGNED_BYTE,
colorArray);
A two-dimensional scaling transformation can be performed as a raster operation in
OpenGL by specifying scaling factors and then invoking either glCopyPixels or
glDrawPixels
For the raster operations, we set the scaling factors with
glPixelZoom (sx, sy);
We can also combine raster transformations with logical operations to produce various
effects with the exclusive or operator.
NOOR SUMAIYA, [Link], DEPT OF CSE, TOCE Page 20
COMPUTER GRAPHICS AND FUNDAMENTALS OF IMAGE PROCESSING 21CS63
OpenGL Functions for Two-Dimensional Geometric Transformations
To perform a translation, we invoke the translation routine and set the components for the
three-dimensional translation vector.
In the rotation function, we specify the angle and the orientation for a rotation axis that
intersects the coordinate origin.
In addition, a scaling function is used to set the three coordinate scaling factors relative to
the coordinate origin. In each case, the transformation routine sets up a 4 × 4 matrix that
is applied to the coordinates of objects that are referenced after the transformation call.
Basic OpenGL Geometric Transformations
A 4× 4 translation matrix is constructed with the following routine
glTranslate* (tx, ty, tz);
Translation parameters tx, ty, and tz can be assigned any real-number values, and
the single suffix code to be affixed to this function is either f (float) or d (double).
For two-dimensional applications, we set tz = 0.0; and a two-dimensional position
is represented as a four-element column matrix with the z component equal to 0.0.
example: glTranslatef (25.0, -10.0, 0.0);
Similarly, a 4 × 4 rotation matrix is generated with
glRotate* (theta, vx, vy, vz);
where the vector v = (vx, vy, vz) can have any floating-point values for its
components.
This vector defines the orientation for a rotation axis that passes through the
coordinate origin.
If v is not specified as a unit vector, then it is normalized automatically before the
elements of the rotation matrix are computed.
The suffix code can be either f or d, and parameter theta is to be assigned a
rotation angle in degree.
NOOR SUMAIYA, [Link], DEPT OF CSE, TOCE Page 21
COMPUTER GRAPHICS AND FUNDAMENTALS OF IMAGE PROCESSING 21CS63
For example, the statement: glRotatef (90.0, 0.0, 0.0, 1.0);
We obtain a 4 × 4 scaling matrix with respect to the coordinate origin with the following
routine:
glScale* (sx, sy, sz);
The suffix code is again either f or d, and the scaling parameters can be assigned
any real-number values.
Scaling in a two-dimensional system involves changes in the x and y dimensions,
so a typical two-dimensional scaling operation has a z scaling factor of 1.0
Example: glScalef (2.0, -3.0, 1.0);
OpenGL Matrix Operations
The glMatrixMode routine is used to set the projection mode which designates the matrix
that is to be used for the projection transformation.
We specify the modelview mode with the statement
glMatrixMode (GL_MODELVIEW);
which designates the 4×4 modelview matrix as the current matrix
Two other modes that we can set with the glMatrixMode function are the texture
mode and the color mode.
The texture matrix is used for mapping texture patterns to surfaces, and the color
matrix is used to convert from one color model to another.
The default argument for the glMatrixMode function is GL_MODELVIEW.
With the following function, we assign the identity matrix to the current matrix:
glLoadIdentity ( );
Alternatively, we can assign other values to the elements of the current matrix using
glLoadMatrix* (elements16);
A single-subscripted, 16-element array of floating-point values is specified with
parameter elements16, and a suffix code of either f or d is used to designate the data type
The elements in this array must be specified in column-major order
NOOR SUMAIYA, [Link], DEPT OF CSE, TOCE Page 22
COMPUTER GRAPHICS AND FUNDAMENTALS OF IMAGE PROCESSING 21CS63
To illustrate this ordering, we initialize the model view matrix with the following code:
glMatrixMode (GL_MODELVIEW);
GLfloat elems [16];
GLint k;
for (k = 0; k < 16; k++)
elems [k] = float (k);
glLoadMatrixf (elems);
Which produces the matrix
We can also concatenate a specified matrix with the current matrix as follows:
glMultMatrix* (otherElements16);
Again, the suffix code is either f or d, and parameter otherElements16 is a 16-element,
single-subscripted array that lists the elements of some other matrix in column-major
order.
Thus, assuming that the current matrix is the modelview matrix, which we designate as
M, then the updated model view matrix is computed as
M = M· M’
The glMultMatrix function can also be used to set up any transformation sequence with
individually defined matrices.
For example,
glMatrixMode (GL_MODELVIEW); glLoadIdentity ( ); // Set
current matrix to the identity. glMultMatrixf (elemsM2); //
Postmultiply identity with matrix M2.
glMultMatrixf (elemsM1); // Postmultiply M2 with matrix M1.
produces the following current model view matrix:
M = M2 · M1
NOOR SUMAIYA, [Link], DEPT OF CSE, TOCE Page 23
COMPUTER GRAPHICS AND FUNDAMENTALS OF IMAGE PROCESSING 21CS63
NOOR SUMAIYA, [Link], DEPT OF CSE, TOCE Page 24