Join Whatsapp Channel: https://whatsapp.

com/channel/0029VaA9uVVIiRp0RS5li20r

Module 2
Q1. What is the need of a Homogeneous Coordinate System? Explain Translation, Rotation
and Scaling in 2D Homogeneous Coordinate System with matrix representation. OR
Explain translation, rotation, scaling in 2D homogeneous coordinate system with matrix
representation. OR Explain the basic 2D geometric transformations in detail with snippet
of code for each.
Ans: The Homogeneous Coordinate System is a method used in computer graphics and image
processing to extend the Cartesian coordinate system to simplify mathematical transformations,
such as translation, rotation, and scaling. It allows these transformations to be represented as matrix
multiplications, providing a unified framework for handling various geometric operations.

Need for Homogeneous Coordinates

1. Unified Transformation Representation: Homogeneous coordinates allow for the
representation of all geometric transformations (translation, rotation, scaling) using matrix
operations. This simplifies the mathematical formulation and computation involved in
transforming objects.

2. Translation Representation: In the Cartesian coordinate system, translation cannot be

represented using a simple 2D matrix. Homogeneous coordinates use a 3x3 matrix to
include translation along with rotation and scaling, thus making all transformations
compatible with matrix multiplication.

3. Mathematical Convenience: By using homogeneous coordinates, translation and other

transformations can be combined into a single matrix operation, making it easier to apply
multiple transformations in sequence.

4. Handling Perspective Transformations: Homogeneous coordinates are also crucial for

representing and handling perspective transformations, which are common in 3D graphics
and require the extension of the coordinate system to accommodate perspective
projections.

Homogeneous Coordinates in 2D
In 2D graphics, a point (x,y) is represented in homogeneous coordinates as (xh,yh,h), where h is a
nonzero scaling factor. The Cartesian coordinates can be recovered using:
x=xh/h y=yh/h
A common choice is to set h=1, which simplifies the homogeneous coordinates to (x,y,1).
Join Whatsapp Channel: https://whatsapp.com/channel/0029VaA9uVVIiRp0RS5li20r

Q2. Write a note on inverse transformations. Derive matrices for each.

Ans: In computer graphics, transformations such as translation, rotation, and scaling are
fundamental operations for manipulating objects. The inverse of a transformation is crucial
for various operations like undoing transformations, reverse engineering, and solving
equations involving transformations. To understand inverse transformations, it's important
to derive the inverse matrices for translation, rotation, and scaling in 2D.
Join Whatsapp Channel: https://whatsapp.com/channel/0029VaA9uVVIiRp0RS5li20r
Join Whatsapp Channel: https://whatsapp.com/channel/0029VaA9uVVIiRp0RS5li20r

Q3. Explain general two dimensional pivot point rotation and derive the composite matrix.
OR What is concatenation of transformation? Explain the following considering 2D: i)
Rotation about a fixed point ii) Scaling about a fixed point. OR Explain two-dimensional
pivot point scaling with neat sequences of an object. Explain with matrix representations
and equations.
Ans: In computer graphics, concatenation of transformations refers to the process of combining
multiple geometric transformations into a single transformation matrix. This is crucial for efficiently
applying a series of transformations to objects, such as translation, rotation, and scaling.

To concatenate transformations, you perform matrix multiplication of the individual transformation

matrices in the order the transformations are applied. The resulting matrix represents the combined
effect of all the transformations.
Join Whatsapp Channel: https://whatsapp.com/channel/0029VaA9uVVIiRp0RS5li20r
Join Whatsapp Channel: https://whatsapp.com/channel/0029VaA9uVVIiRp0RS5li20r

Rotation Sequence around a pivot point

Scaling Sequence around

Q4. Explain i) Reflection and ii) Shear OR Briefly explain shear method of two-dimensional
transformations. OR Briefly explain reflection method of two-dimensional
transformations. OR Explain shear and reflection transformation technique.
Ans :
Reflection Transformation
Definition: A reflection transformation produces a mirror image of an object relative to a specified
axis. In 2D graphics, the reflection results in the image being mirrored across an axis of reflection.
Join Whatsapp Channel: https://whatsapp.com/channel/0029VaA9uVVIiRp0RS5li20r
Join Whatsapp Channel: https://whatsapp.com/channel/0029VaA9uVVIiRp0RS5li20r

Q5. Explain OpenGL raster transformations and OpenGL geometric transformation

functions.
Ans:
OpenGL Raster Transformations and Geometric Transformations
In OpenGL, transformations are categorized into raster transformations and geometric
transformations. Both play crucial roles in manipulating and rendering graphics. Here’s an overview
of how each type of transformation is handled:

OpenGL Raster Transformations

Raster transformations deal with operations on pixel data in the framebuffer. These operations are
essential for manipulating pixel images directly.

1. Copying Pixels:
• Function: glCopyPixels(xmin, ymin, width, height, GL_COLOR)
• Description: Copies a block of pixel values from one part of the framebuffer to another.
The parameters specify the source and destination rectangle in terms of position and
dimensions, and GL_COLOR indicates that color values are copied.
• Example Usage: If you want to copy a 100x100 pixel block from the position (50, 50) to
another location, you would call:
glCopyPixels(50, 50, 100, 100, GL_COLOR);

2. Reading Pixels:
• Function: glReadPixels(xmin, ymin, width, height, GL_RGB,
GL_UNSIGNED_BYTE, colorArray)
• Description: Reads a block of pixel color values from the framebuffer into an array. The
parameters specify the block size and format of the data (e.g., GL_RGB for color data).
• Example Usage: To read a 100x100 block of pixels into an array:
glReadPixels(50, 50, 100, 100, GL_RGB, GL_UNSIGNED_BYTE, colorArray);

3. Drawing Pixels:
• Function: glDrawPixels(width, height, GL_RGB, GL_UNSIGNED_BYTE,
colorArray)
• Description: Writes pixel color values from an array to the framebuffer. The parameters
specify the dimensions of the block and the format of the data.
• Example Usage: To draw a 100x100 pixel block from an array:
glDrawPixels(100, 100, GL_RGB, GL_UNSIGNED_BYTE, colorArray);
Join Whatsapp Channel: https://whatsapp.com/channel/0029VaA9uVVIiRp0RS5li20r

4. Scaling Pixels:
Function: glPixelZoom(sx, sy)
Description: Sets the scaling factors for the x and y dimensions when drawing or copying pixel
blocks. sx and sy are the scaling factors for the x and y directions, respectively.
Example Usage: To scale pixel data by a factor of 2 in the x direction and 0.5 in the y direction:
glPixelZoom(2.0, 0.5);

5. Logical Operations:
• Description: Raster operations can be combined with logical operations (like XOR) to
produce various visual effects. This is often used for operations like masking or special
effects.

OpenGL Geometric Transformations

Geometric transformations manipulate objects in 3D space and are performed using matrix
operations. In OpenGL, all transformations are handled in 3D, but you can easily perform 2D
transformations by setting the z-component to zero.

1. Translation:
• Function: glTranslate* (tx, ty, tz)
• Description: Translates objects by a vector (tx, ty, tz). The suffix f is used for floats, and d
for doubles.
• Example Usage: To translate an object 25 units right and 10 units down:
• glTranslatef(25.0f, -10.0f, 0.0f);

2. Rotation:
• Function: glRotate* (theta, vx, vy, vz)
• Description: Rotates objects by an angle theta around the axis defined by the vector (vx, vy,
vz). The vector is normalized if not a unit vector. The suffix f is for floats, and d for doubles.
• Example Usage: To rotate an object 90 degrees around the z-axis:
• glRotatef(90.0f, 0.0f, 0.0f, 1.0f);

3. Scaling:
• Function: glScale* (sx, sy, sz)
• Description: Scales objects by factors sx, sy, and sz in the x, y, and z directions, respectively.
The suffix f is for floats, and d for doubles.
• Example Usage: To scale an object by a factor of 2 in the x direction, -3 in the y direction,
and 1 in the z direction:
• glScalef(2.0f, -3.0f, 1.0f);

Q6. 3D Transformations
Ans : Three-Dimensional Transformations Using Homogeneous Coordinates
In 3D graphics, transformations such as translation, rotation, and scaling are fundamental operations
applied to objects in the scene. These transformations can be represented efficiently using
homogeneous coordinates and 4×4 matrices, which facilitate the combination and application of
multiple transformations.

Homogeneous Coordinates
In homogeneous coordinates, a 3D point (x,y,z) is represented as a 4-dimensional vector (x,y,z,w),
where w is a scale factor. For most purposes, w is set to 1. Thus, a point (x,y,z) in Cartesian
coordinates is represented as (x,y,z,1) in homogeneous coordinates.
Join Whatsapp Channel: https://whatsapp.com/channel/0029VaA9uVVIiRp0RS5li20r
Join Whatsapp Channel: https://whatsapp.com/channel/0029VaA9uVVIiRp0RS5li20r

Q7. Explain different OpenGL routines used for manipulating display window.
Ans : OpenGL provides a range of routines for manipulating and managing the display window,
which is the area where the rendered graphics are displayed. These routines are essential for
controlling the view, handling user inputs, and managing the visual output of an application. Below
are some key OpenGL routines used for manipulating the display window:

1. glViewport
Purpose: Defines the region of the window where OpenGL will render the graphics.
Usage: void glViewport(GLint x, GLint y, GLsizei width, GLsizei height);
• x, y: Specify the lower-left corner of the viewport rectangle.
• width, height: Specify the width and height of the viewport.
Description: glViewport sets the viewport, which maps the normalized device coordinates to
window coordinates. It determines the area of the window that OpenGL will use for rendering.

2. glScissor
Purpose: Defines a rectangular region of the window for pixel operations, such as rendering and
copying.
Usage: void glScissor(GLint x, GLint y, GLsizei width, GLsizei height);
• x, y: Specify the lower-left corner of the scissor box.
• width, height: Specify the width and height of the scissor box.
Description: glScissor restricts the drawing area to the defined rectangle, allowing you to perform
operations only within that region. It's useful for rendering to specific parts of the window or
implementing effects like masking.

3. glClear
Purpose: Clears the specified buffers to preset values.
Usage: void glClear(GLbitfield mask);
• mask: A bitwise OR of the buffers to be cleared (e.g., GL_COLOR_BUFFER_BIT,
GL_DEPTH_BUFFER_BIT, GL_STENCIL_BUFFER_BIT).
Description: glClear is used to reset the buffer(s) to their initial state, which is essential at the
beginning of a new frame. For example, GL_COLOR_BUFFER_BIT clears the color buffer, resetting
the color of the window.

4. glClearColor
Purpose: Sets the color used by glClear to clear the color buffer.
Usage: void glClearColor(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha);
• red, green, blue, alpha: Specify the color values for clearing (range from 0.0 to 1.0).
Join Whatsapp Channel: https://whatsapp.com/channel/0029VaA9uVVIiRp0RS5li20r

Description: glClearColor defines the color used to clear the color buffer when glClear is called with
GL_COLOR_BUFFER_BIT.

5. glDrawBuffer
Purpose: Selects the buffer to which OpenGL will send output.
Usage: void glDrawBuffer(GLenum mode);
• mode: Specifies the buffer to which OpenGL should draw (e.g., GL_COLOR_ATTACHMENT0,
GL_BACK, GL_FRONT).
Description: glDrawBuffer is used to specify which color buffer (front, back, or multiple
attachments) OpenGL will draw to. It is particularly useful in multi-buffered environments or when
using framebuffers.

6. glReadBuffer
Purpose: Specifies the buffer from which OpenGL will read.
Usage: void glReadBuffer(GLenum mode);
• mode: Specifies the buffer to read from (e.g., GL_COLOR_ATTACHMENT0, GL_BACK,
GL_FRONT).
Description: glReadBuffer sets the color buffer from which pixel data is read. This is used in
functions like glReadPixels to fetch pixel data from the specified buffer..

7. glSwapBuffers
Purpose: Swaps the front and back buffers in double-buffered contexts.
Usage: void glSwapBuffers();
Description: In a double-buffered context, glSwapBuffers swaps the back buffer (where drawing
occurs) with the front buffer (displayed to the screen). This helps in reducing flicker and providing
smoother animations.

8. glFlush
Purpose: Forces OpenGL to execute all pending commands.
Usage: void glFlush();
Description: glFlush ensures that all OpenGL commands are executed as soon as possible. It is
useful for ensuring that rendering commands are processed immediately, especially when you want
to see results before continuing execution.

9. glFinish
Purpose: Blocks until all OpenGL commands have been executed.
Usage: void glFinish();
Description: glFinish waits until all previously issued OpenGL commands are completed. It provides
a way to synchronize rendering with the CPU, useful when you need to ensure that all rendering is
finished before performing subsequent operations.

10. glEnable and glDisable

Purpose: Enable or disable various OpenGL capabilities.
Usage: void glEnable(GLenum cap); void glDisable(GLenum cap);
• cap: Specifies the capability to enable or disable (e.g., GL_DEPTH_TEST, GL_BLEND).
Description: glEnable and glDisable are used to control various states and features in OpenGL, such
as depth testing, blending, or culling. These capabilities affect how rendering is performed and how
objects are displayed.

11. glViewportArray
Purpose: Sets multiple viewports in one call (available in OpenGL 3.3 and later).
Usage: void glViewportArrayv(GLuint first, GLsizei count, const GLfloat *v);
• first: Starting index for the viewports.
• count: Number of viewports to set.
Join Whatsapp Channel: https://whatsapp.com/channel/0029VaA9uVVIiRp0RS5li20r

• v: Array of viewport parameters (x, y, width, height).

Description: glViewportArray allows for the setting of multiple viewports at once, which is useful for
rendering to multiple viewports or splits in the window.

Q8. Explain the following open GL geometric transformation functions

a. glMatrixMode().
b. glPopMatrix.

In OpenGL, geometric transformations are crucial for manipulating and positioning objects within
the 3D scene. Two essential functions for handling these transformations are glMatrixMode and
glPopMatrix. Here’s a detailed explanation of each function:

a. glMatrixMode
Purpose: Selects which matrix stack is the target for subsequent matrix operations.

Usage: void glMatrixMode(GLenum mode);

• mode: Specifies which matrix stack to operate on. Common values include:
• GL_MODELVIEW: The modelview matrix stack, used for transformations of objects
in the scene.
• GL_PROJECTION: The projection matrix stack, used to define the camera
perspective or orthographic projection.
• GL_TEXTURE: The texture matrix stack, used for texture transformations.
• GL_COLOR: Used for color matrix transformations in some OpenGL implementations.

Description:
• glMatrixMode sets the current matrix stack to the one specified by the mode parameter.
After setting the matrix mode, all subsequent matrix operations (such as glLoadIdentity,
glTranslatef, glRotatef, and glScalef) will affect the currently selected matrix stack.
• This function is important because OpenGL maintains separate matrix stacks for different
purposes. For example, transformations affecting the placement and orientation of objects
(like rotation and translation) are applied to the modelview matrix, while transformations
affecting how objects are projected onto the screen (like perspective adjustments) are
applied to the projection matrix.

Example:
glMatrixMode(GL_MODELVIEW); // Switch to modelview matrix stack
glLoadIdentity(); // Reset the modelview matrix
glTranslatef(1.0f, 2.0f, 3.0f); // Translate the object by (1, 2, 3)

glMatrixMode(GL_PROJECTION); // Switch to projection matrix stack

glLoadIdentity(); // Reset the projection matrix
glOrtho(-1.0, 1.0, -1.0, 1.0, 1.0, 10.0); // Set orthographic projection

b. glPopMatrix
Purpose: Pops the top matrix from the current matrix stack and replaces the top matrix with the one
that was previously on the stack.

Usage:
void glPopMatrix();

Description:
• glPopMatrix removes the top matrix from the current matrix stack and replaces it with the
matrix that was previously saved on the stack by glPushMatrix. It effectively restores the
matrix state to what it was before the most recent glPushMatrix call.
Join Whatsapp Channel: https://whatsapp.com/channel/0029VaA9uVVIiRp0RS5li20r

• This function is useful for temporarily changing the matrix state for a specific transformation
or drawing operation and then reverting to the previous matrix state without having to
manually keep track of matrix changes.
Example:
glMatrixMode(GL_MODELVIEW); // Switch to modelview matrix stack
glPushMatrix(); // Save the current modelview matrix

// Apply transformations for a specific object

glTranslatef(1.0f, 2.0f, 3.0f);
glRotatef(45.0f, 1.0f, 0.0f, 0.0f);
// Draw the object here...

glPopMatrix(); // Restore the previous modelview matrix state

// The modelview matrix is now back to the state before the translation and rotation

Summary:
• glMatrixMode is used to select which matrix stack (modelview, projection, or texture) is
currently active, so that subsequent matrix operations affect the chosen stack.
• glPopMatrix is used to revert to the matrix state saved by the most recent glPushMatrix call,
allowing for temporary changes to be undone easily.
These functions help manage complex transformations and ensure that changes to matrix states are
handled efficiently and correctly.