2024

Q.1
i. Give applications of Computer Graphics.
ii. What is antialiasing? Explain any 3 antialiasing techniques.
iii. Compare DDA and BRESENHAM line drawing algorithms.
iv. Explain Viewing transformation pipeline.
v. Give a fractal dimension of Koch curve.
Q.2
a. Given a line AB where A(O,O) and B( 1,3) find out all the coordinates of line
AB using DDA algorithm.
b. Describe different traditional animation techniques
Q.3
a. Describe homogeneous coordinates.
b. Describe with a neat diagram Boundary Fill and Flood fill algorithm.
Q.4
a. Derive window to viewport coordinate transformation.
b. Derive matrix for 2D rotation at any arbitrary (fix) point.
Q.5
a. Give properties of the Bezier curve.
b. Describe with neat diagram Sutherland Hodgman polygon clipping
algorithm.
Q.6
a. Describe with a neat diagram Depth Buffer algorithm.
b. What Is projection? Explain with neat diagram different perspective
projections.

Q.1

i. Applications of Computer Graphics

Computer graphics have numerous applications across various fields, including:

- Entertainment : Used in movies and video games for creating realistic visual
effects and animations.

- Advertising and Marketing : Enables the design of eye-catching advertisements

and promotional materials, enhancing consumer engagement.

- Architecture and Design : Facilitates the creation of 3D models and visualizations,

allowing architects to present designs more effectively.
- Medical Imaging : Assists in visualizing complex medical data from scans like
MRIs and CTs, improving diagnosis and treatment planning.

- Education : Enhances learning through interactive simulations and visual aids in

subjects like science and mathematics.

ii. What is Antialiasing? Explain any 3 Antialiasing Techniques

Antialiasing is a technique used in computer graphics to reduce the visual distortions
known as aliasing, which results in jagged edges on curved lines or diagonal edges.

Three Antialiasing Techniques :

1. Supersampling Anti-Aliasing (SSAA) :

- Renders images at a higher resolution than the display resolution and then
downscales them, resulting in smoother edges.
- Provides high-quality output but is computationally expensive.

2. Multisample Anti-Aliasing (MSAA) :

- Samples multiple locations at the edges of polygons rather than sampling every
pixel, blending these samples to create smoother transitions along the edges.
- Offers a good balance between image quality and performance.

3. Fast Approximate Anti-Aliasing (FXAA) :

- A post-processing technique that analyzes the rendered image to identify and
smooth out high-contrast edges without requiring additional rendering at higher
resolutions.
- Fast and efficient but may introduce slight blurring.

iii. Compare DDA and Bresenham Line Drawing Algorithm

| Feature | DDA Algorithm | Bresenham's Algorithm |
|---------------------------|------------------------------------|-----------------------------------|
| Arithmetic | Floating-point (real arithmetic) | Integer arithmetic |
| Operations | Uses multiplication and division | Only addition and
subtraction |
| Speed | Slower due to real arithmetic | Faster due to integer
operations |
| Accuracy | Less accurate | Highly accurate |
| Complexity | More complex | Simpler implementation |

iv. Explain Viewing Transformation Pipeline

The viewing transformation pipeline is a series of transformations that convert a 3D
scene into a 2D representation suitable for display. The key steps include:

1. World Coordinate Scene Construction : Initial object creation in world

coordinates.
2. Window Definition : Defining a window within the world coordinate system that
specifies the region of interest.
3. Viewport Mapping : Mapping the window to a viewport on the display device
where the window's contents will be rendered.
4. Coordinate Transformation : Transforming world coordinates to viewing
coordinates, normalizing them for easier mapping.
5. Device Coordinate Mapping : Finally converting normalized viewing coordinates
into device coordinates for accurate rendering on various devices.

v. Fractal Dimension of Koch Curve

The Koch curve has a fractal dimension calculated using the formula:

D = \frac{\log(N)}{\log(r)}

where N=4 (number of self-similar pieces) and r=3 (scaling factor). Thus,

D = \frac{\log(4)}{\log(3)} \approx 1.26186

This indicates that the Koch curve has a fractal dimension of approximately 1.26186
, representing its complexity between a line (dimension 1) and a plane (dimension 2).

---

Q.2

a. DDA Algorithm for Line AB from A(0,0) to B(1,3)

Using the DDA algorithm, we can find all coordinates of line AB:

```python
def dda_line_drawing(x0, y0, x1, y1):
dx = x1 - x0
 dy = y1 - y0
steps = max(abs(dx), abs(dy))
x_increment = dx / steps
y_increment = dy / steps

x = x0
y = y0
line_coordinates = [(round(x), round(y))]

for _ in range(steps):
x += x_increment
y += y_increment
line_coordinates.append((round(x), round(y)))

return line_coordinates

line_coords = dda_line_drawing(0, 0, 1, 3)
print("DDA Line Coordinates:")
for coord in line_coords:
print(coord)
```

Output :
```
DDA Line Coordinates:
(0, 0)
(0, 1)
(1, 2)
(1, 3)
```

b. Traditional Animation Techniques

Traditional animation techniques include:

- Hand-drawn Animation : Each frame is drawn by hand on paper or digitally;

frames are then photographed or scanned to create motion.

- Cel Animation : Involves drawing characters on transparent sheets (cels) placed

over static backgrounds; this allows for reusing backgrounds across scenes.
- Stop Motion Animation : Physical objects are moved in small increments between
individually photographed frames to create the illusion of movement when played back.

---

Q.3

a. Homogeneous Coordinates
Homogeneous coordinates extend traditional Cartesian coordinates by adding an extra
dimension, allowing for easier representation of transformations such as translation,
scaling, and rotation using matrix multiplication. A point (x, y) in 2D becomes
(wx, wy, w) in homogeneous coordinates.

b. Boundary Fill and Flood Fill Algorithms

- Boundary Fill Algorithm : Fills an area bounded by a specific color by starting from
a seed point and spreading outward until it reaches the boundary color.

- Flood Fill Algorithm : Similar to boundary fill but fills an area until it encounters a
different color rather than stopping at a boundary color.

Diagram : Both algorithms can be illustrated with examples showing how they fill
areas based on initial seed points.

---

Q.4

a. Window to Viewport Coordinate Transformation

The transformation from window coordinates to viewport coordinates involves scaling
and translating points from one coordinate system to another based on their respective
dimensions.

Given:
- Window defined by corners (x_wmin, y_wmin) and (x_wmax, y_wmax) .
- Viewport defined by corners (x_vmin, y_vmin) and (x_vmax, y_vmax) .

The transformation can be derived using linear equations that map points from the
window to viewport coordinates.

b. Matrix for 2D Rotation at Any Arbitrary Point

To rotate a point around an arbitrary point (h, k) , the transformation matrix can be
derived as follows:

1. Translate the point (-h, -k) .

2. Rotate using standard rotation matrix:

R(\theta) =
\begin{bmatrix}
\cos(\theta) & -\sin(\theta) \\
\sin(\theta) & \cos(\theta)
\end{bmatrix}

3. Translate back by (h, k) .

The complete transformation matrix combines these steps into one matrix multiplication.

---

Q.5

a. Properties of Bezier Curves

- Control Points : Defined by control points that determine the shape of the curve.
- Degree : The degree of the curve is one less than the number of control points.
- Continuity : Bezier curves are continuous and smooth at their endpoints.
- Affine Invariance : Transformations such as translation or scaling affect control
points but not the shape of the curve itself.

b. Sutherland-Hodgman Polygon Clipping Algorithm

The Sutherland-Hodgman algorithm clips polygons against rectangular clipping
windows by processing each edge against each clipping boundary iteratively.

Diagram : Illustrates how vertices are processed against each clipping edge to
determine which parts of the polygon remain after clipping.

---

Q.6

a. Depth Buffer Algorithm

The depth buffer algorithm manages visibility in rendering scenes by maintaining a
depth value for each pixel on the screen; it determines which surfaces are visible based
on their distance from the viewer.

Diagram : Shows how depth values are compared during rendering to decide which
pixels are drawn over others based on depth information.

b. Projection in Computer Graphics

Projection refers to mapping 3D points onto a 2D plane (the screen).

Different types include:

- Orthographic Projection : Parallel projection where lines remain parallel; objects

maintain their size regardless of distance.

- Perspective Projection : Lines converge at a vanishing point; objects appear

smaller as they move further away from the viewer.

Diagram : Illustrates both projection types with examples showing how objects are
represented differently based on projection methods used.
2023
Q.I
I . Compare DDA and BRESENHAM line drawing algorithm.
2. Give application of computer graphics.
3. Explain with neat diagram rasterization,
4. Give a fractal dimension of the KOCH curve.
5. Define Projection, Describe perspective projection with neat diagram.
Q.2
l. Given a triangle ABC where A(O,O), B( 10, IO) and C(20,O), scale the given triangle
ABC 2-unit in X direction and 0.5-unit in Y direction. Find out the new coordinate of
triangle ABC after scaling.
2. Explain with a neat diagram Sutherland and Hodgman polygon clipping algorithm in
detail.
Q.3
l. Derive window to viewport coordinate transformation.
2. Give properties of the Bezier curve.
Q.4
I. Derive Midpoint circle generation algorithm.
2. Give principles of animation
Q.5
l. Explain with neat diagram Area Sub division (Warnock's) algorithm to remove hidden
surfaces.
2. Derive matrix for 2D rotation transformation.
Q.6
I. Explain point clipping algorithm.
2. Give pseudo code for 4-connect Boundary fill algorithm.
3 Give transformation matrix for 3D — Translation, Scaling, Rotation (about x, y, z axis)
4. Explain with neat diagram composite transformation for scaling.
5. Given a line AB where A(O,O) and B(l,3) find out all the coordinate of line AB using
DDA
algorithm.
Q.I

1. Compare DDA and Bresenham Line Drawing Algorithm

| Feature | DDA Algorithm | Bresenham's Algorithm |
|---------------------------|------------------------------------|-----------------------------------|
| Arithmetic | Uses floating-point (real arithmetic) | Uses integer arithmetic
|
| Operations | Involves multiplication and division | Only addition and subtraction
|
| Speed | Slower due to real arithmetic | Faster due to integer operations |
| Accuracy | Less accurate due to rounding errors| Highly accurate |
| Complexity | More complex | Simpler implementation |
| Ideal Use Case | Suitable for low-resolution displays| Preferred for real-time
applications|

2. Applications of Computer Graphics

Computer graphics are used in various fields, including:

- Entertainment: Film and video game industries for creating animations and visual
effects.

- Medical Imaging: Visualization of complex medical data from scans such as MRIs and
CTs.

- Education: Interactive simulations and visual aids enhance learning in subjects like
science and mathematics.

- Architecture: 3D modeling helps architects visualize buildings before construction.

- Advertising: Creation of visually appealing advertisements and marketing materials.

3. Explain Rasterization with Neat Diagram

Rasterization is the process of converting vector graphics (shapes defined by
mathematical equations) into raster images (pixel-based images). The key steps
include:

1. Input Vector Data: Shapes like lines, polygons, or curves.

2. Scan Conversion: Determining which pixels correspond to the shapes.
3. Pixel Coloring: Assigning colors to the determined pixels based on the shape's
attributes.

Diagram: A diagram would show a vector line being converted into a series of pixels on
a grid, illustrating how the line is rasterized.

4. Fractal Dimension of Koch Curve

The Koch curve has a fractal dimension calculated using the formula:

D = \frac{\log(N)}{\log(r)}

where:
- N = 4 (number of self-similar pieces)
- r = 3 (scaling factor)

Thus,

D = \frac{\log(4)}{\log(3)} \approx 1.26186

This indicates that the Koch curve has a fractal dimension of approximately 1.26186,
reflecting its complexity between a line (dimension 1) and a plane (dimension 2).

5. Define Projection; Describe Perspective Projection with Neat Diagram

Projection refers to the method of mapping 3D points onto a 2D plane, such as a
computer screen or paper.

Perspective Projection creates a sense of depth by simulating how objects appear

smaller as they move further away from the viewer. In perspective projection:

- Parallel lines converge at a vanishing point.

- Objects farther from the camera appear smaller than those closer.

Diagram: A diagram would illustrate a 3D scene with lines converging at a vanishing

point on a 2D plane, showing how objects are projected.

---
Q.2

1. Scaling Triangle ABC

Given triangle ABC with vertices:
- A(0,0)
- B(10,10)
- C(20,0)

To scale the triangle by 2 units in the X direction and 0.5 units in the Y direction, we
apply the scaling transformation:

\text{New Coordinates} = \text{Original Coordinates} \times

\begin{bmatrix}
S_x & 0 \\
0 & S_y
\end{bmatrix}

where S_x = 2 and S_y = 0.5.

Calculating new coordinates:

- A' = (0 2, 0 0.5) = (0, 0)
- B' = (10 2, 10 0.5) = (20, 5)
- C' = (20 2, 0 0.5) = (40, 0)

The new coordinates after scaling are:

- A'(0,0)
- B'(20,5)
- C'(40,0)

2. Sutherland-Hodgman Polygon Clipping Algorithm

The Sutherland-Hodgman algorithm clips polygons against rectangular clipping
windows by processing each edge against each clipping boundary iteratively.

Steps:
1. Initialize an output list with the vertices of the polygon.
2. For each edge of the clipping window:
- For each vertex of the polygon:
 - Determine if it is inside or outside the clipping boundary.
- If inside, add it to the output list.
- If crossing an edge, calculate the intersection point and add it to the output list.
3. Repeat until all edges have been processed.

Diagram: Illustrates how vertices are processed against each clipping edge to
determine which parts remain after clipping.

---

Q.3

1. Window to Viewport Coordinate Transformation

The transformation from window coordinates to viewport coordinates involves scaling
and translating points from one coordinate system to another based on their respective
dimensions.

Given:
- Window defined by corners W_{\text{min}}(x_wmin, y_wmin) and
W_{\text{max}}(x_wmax, y_wmax).
- Viewport defined by corners V_{\text{min}}(x_vmin, y_vmin) and
V_{\text{max}}(x_vmax, y_vmax).

The transformation can be derived using linear equations:

x_v = x_vmin + \frac{(x_w - x_wmin)(x_vmax - x_vmin)}{(x_wmax - x_wmin)}

y_v = y_vmin + \frac{(y_w - y_wmin)(y_vmax - y_vmin)}{(y_wmax - y_wmin)}

This maps points from window coordinates to viewport coordinates.

2. Properties of Bezier Curves

- Control Points: Defined by control points that determine the shape of the curve.

- Degree: The degree of a Bezier curve is one less than the number of control points.

- Continuity: Bezier curves are continuous and smooth at their endpoints.

- Affine Invariance: Transformations such as translation or scaling affect control points
but not the shape of the curve itself.

---

Q.4

1. Derive Midpoint Circle Generation Algorithm

The Midpoint Circle Algorithm is used for drawing circles in computer graphics efficiently
using integer arithmetic.

1. Start with an initial point on the circle's circumference at (r, 0).

2. Use symmetry to determine points in all octants.
3. Calculate decision parameters based on pixel positions.
4. Incrementally plot points based on whether you stay inside or cross the circle's
boundary.

The decision parameter p_k is calculated as follows:

- If p_k < 0, choose (x+1,y).
- If p_k \geq 0, choose (x+1,y-1).

This continues until x > y.

2. Principles of Animation
The principles of animation include:

1. Squash and Stretch: Gives weight and volume to characters as they move.

2. Anticipation: Prepares viewers for an action by showing preliminary movements.

3. Staging: Directs attention to important elements in a scene.

4. Straight Ahead Action and Pose-to-Pose Action: Two approaches for creating
animation sequences; one is fluid while the other is more controlled.

5. Follow Through and Overlapping Action: Ensures that parts of characters continue
moving after an action has stopped.
6. Slow In and Slow Out: Creates realism by having movements start slowly, speed up,
then slow down again before stopping.

7. Arc Movement: Natural movement follows arcs rather than straight lines.

8. Secondary Action: Adds more dimension to characters without distracting from

primary actions.

9. Timing and Spacing: Determines how fast or slow movements occur based on timing
frames between actions.

10. Exaggeration: Enhances features or actions for comedic or dramatic effect without
losing believability.

---

Q.5

1. Area Subdivision (Warnock's) Algorithm for Hidden Surface Removal

The Warnock algorithm subdivides areas recursively until it can determine visibility
within each section based on depth information.

1. Divide the screen area into smaller rectangles until each rectangle contains either all
visible or all hidden surfaces.
2. For each rectangle:
- If it contains only one surface visible from that area, render it directly.
- If multiple surfaces are present, further subdivide until manageable visibility
determination can be made.

Diagram: Illustrates how areas are subdivided recursively until visibility can be
determined clearly for rendering.

2. Derive Matrix for 2D Rotation Transformation

To rotate a point around the origin by an angle \theta, use:

R(\theta) =
\begin{bmatrix}
\cos(\theta) & -\sin(\theta) \\
\sin(\theta) & \cos(\theta)
\end{bmatrix}

For rotation about an arbitrary point (h,k):

1. Translate point to origin:

T(-h,-k)

2. Apply rotation matrix R(\theta).

3. Translate back:

T(h,k)

The complete transformation matrix combines these steps into one matrix multiplication
sequence.

---

Q.6

1. Point Clipping Algorithm

Point clipping algorithms determine whether a point lies within a defined clipping window
or area:

1. Define clipping boundaries (e.g., rectangular window).

2. For each point:
- Check if it lies within these boundaries using conditions like:
- x_{min} < x < x_{max}
- y_{min} < y < y_{max}
3. If conditions are met, point is visible; otherwise, it is clipped out.

2. Pseudocode for 4-connect Boundary Fill Algorithm

```plaintext
function BoundaryFill(x, y, fillColor, boundaryColor):
if GetPixelColor(x,y) != boundaryColor AND GetPixelColor(x,y) != fillColor:
SetPixelColor(x,y, fillColor)
 BoundaryFill(x+1,y, fillColor,boundaryColor)
BoundaryFill(x-1,y, fillColor,boundaryColor)
BoundaryFill(x,y+1, fillColor,boundaryColor)
BoundaryFill(x,y-1, fillColor,boundaryColor)
```

3. Transformation Matrix for 3D – Translation, Scaling, Rotation (About X,Y,Z Axis)

- Translation Matrix (T(dx, dy, dz))

T=
\begin{bmatrix}
1 & 0 & 0 & dx \\
0 & 1 & 0 & dy \\
0 & 0 & 1 & dz \\
0&0&0&1
\end{bmatrix}

- Scaling Matrix (S(s_x,s_y,s_z))

S=
\begin{bmatrix}
s_x & 0 & 0 & 0 \\
0 & s_y & 0 & 0 \\
0 & 0 & s_z & 0 \\
0&0&0&1
\end{bmatrix}

- Rotation About X-Axis (R_x(\theta))

R_x =
\begin{bmatrix}
1&0& 0 & 0\\
0 & \cos(\theta) & -\sin(\theta) & 0\\
0 & \sin(\theta) & \cos(\theta) & 0\\
0& 0 & 0 & 1\\
\end{bmatrix}
- Rotation About Y-Axis (R_y(\theta))

R_y =
\begin{bmatrix}
\cos(\theta) & 0 & \sin(\theta) & 0\\
{ } { } { } { } { } { } { } { } { } { }
\\
-\sin(\theta)& { } { } { } { }
& \cos(\theta)& { }
& { }
& { }
& { }
& { }
& { }
\\
& { }
& { }
& { }
& { }
& { }
& { }
& { }
& { }
& { }
\\

Point Clipping Algorithm

The point clipping algorithm is used in computer graphics to determine whether a point
lies within a specified rectangular clipping window. The primary goal is to discard points
that fall outside the defined region, ensuring that only relevant points are processed for
rendering.

Steps in Point Clipping Algorithm

1. Define the Clipping Window: Establish a rectangular area defined by its minimum and
maximum coordinates (xmin, ymin) and (xmax, ymax).
2. Check Point Position: For each point P(x, y) :
- If x < xmin or x > xmax or y < ymin or y > ymax , the point is outside the clipping
window.
- If the point lies within these bounds, it is considered inside the clipping window.
 Example
- For a clipping window defined by (1, 1) and (4, 4):
- Point (2, 3) is inside.
- Point (5, 2) is outside.

Pseudo Code for 4-Connected Boundary Fill Algorithm

The 4-connected boundary fill algorithm fills an area with a specified color until it
reaches a boundary color. Here’s the pseudo code:

```plaintext
function boundaryFill4(x, y, fill_color, boundary_color):
if (getPixel(x, y) != boundary_color and getPixel(x, y) != fill_color):
setPixel(x, y, fill_color)
boundaryFill4(x + 1, y, fill_color, boundary_color) // Right
boundaryFill4(x - 1, y, fill_color, boundary_color) // Left
boundaryFill4(x, y + 1, fill_color, boundary_color) // Down
boundaryFill4(x, y - 1, fill_color, boundary_color) // Up
```
This algorithm recursively checks and fills adjacent pixels that are not part of the
boundary color until all reachable pixels are filled.

Transformation Matrix for 3D

In 3D graphics, transformations such as translation, scaling, and rotation can be

represented using matrices. Here are the transformation matrices for each operation:

Translation
To translate a point P(x,y,z) by tx , ty , and tz :

T = \begin{bmatrix}
1 & 0 & 0 & tx \\
0 & 1 & 0 & ty \\
0 & 0 & 1 & tz \\
0&0&0&1
\end{bmatrix}

Scaling
To scale a point P(x,y,z) by factors sx , sy , and sz :

S = \begin{bmatrix}
sx & 0 & 0 & 0 \\
0 & sy & 0 & 0 \\
0 & 0 & sz & 0 \\
0&0&0&1
\end{bmatrix}

Rotation
For rotation about the axes:
- Rotation about X-axis by angle \theta :

R_x = \begin{bmatrix}
1 & 0 & 0 & 0 \\
0 & \cos(\theta) & -\sin(\theta) & 0 \\
0 & \sin(\theta) & \cos(\theta) & 0 \\
0&0&0&1
\end{bmatrix}

- Rotation about Y-axis by angle \theta :

R_y = \begin{bmatrix}
\cos(\theta) & 0 & \sin(\theta) & 0 \\
0 & 1 & 0 & 0 \\
-\sin(\theta) & 0 & \cos(\theta) & 0 \\
0&0&0&1
\end{bmatrix}

- Rotation about Z-axis by angle \theta :

R_z = \begin{bmatrix}
\cos(\theta) & -\sin(\theta) & 0 & 0 \\
\sin(\theta) & \cos(\theta) & 0 & 0 \\
0 & 0 & 1 & 0 \\
0&0&0&1
\end{bmatrix}
Composite Transformation for Scaling with Diagram

Composite transformations involve combining multiple transformations into one. For

scaling in a composite transformation:

Steps:
1. Define Scaling Factors: Choose scaling factors for each axis ( sx, sy, sz ).
2. Create Scaling Matrix: Use the scaling matrix defined above.
3. Apply Transformation: Multiply the scaling matrix with the original coordinates of the
object.

Diagram:
```
Original Object ---> Scaling ---> Transformed Object
```
This diagram illustrates how an object is transformed from its original state to a scaled
version.

DDA Algorithm for Line AB

Given points A(0,0) and B(1,3), we can use the Digital Differential Analyzer (DDA)
algorithm to find all coordinates of line segment AB.

Steps:
1. Calculate differences:
- dx = x_B - x_A = 1 - 0 = 1
- dy = y_B - y_A = 3 - 0 = 3
2. Determine steps required:
- Steps = max(|dx|, |dy|) = max(1,3) = 3
3. Calculate increments:
- x_{inc} = dx / steps = 1 /3 = ~0.33
- y_{inc} = dy / steps =3/3=1

Coordinates Calculation:
Starting from A(0,0):
- Step i=1: (x_1,y_1)=(x_0 + x_{inc}, y_0 + y_{inc})=(~0.33 , ~1)
- Step i=2: (x_2,y_2)= (x_1 + x_{inc}, y_1 + y_{inc})=(~066 , ~2)
- Step i=3: (x_3,y_3)= (x_2 + x_{inc}, y_2 + y_{inc})=(~1 , ~3)

Thus the coordinates of line AB using DDA are approximately:

- A(0,0)
- (~033 , ~1)
- (~066 , ~2)
- B(1,3)
This method effectively generates pixel coordinates along the line segment from A to B
using incremental calculations.

2023
Q.1
a)What are homogeneous coordinates? Write a homogenous transformation matrix for
translation, scaling, and rotation.
b)Explain the Working of the Raster scan system with a neat diagram,
c)Explain any 5 principles Of animation.
d)Scale a triangle A(4,4), B(12,4) and with scaling factor Sx= 2 and Sy—1.
Q.2
a)Write a midpoint circle drawing algorithm. Apply this algorithm to find pixel
coordinates of the circular boundary only for the first quadrant, whose radius is 8
units.
b)Rotate a line segment with endpoint A (3,3) to in a clockwise direction by
an angle 45 degrees by keeping A (3,3) as fixed point. Find new transformed
coordinates of a line.
Q.3
a)Explain Flood fill and boundary fill algorithm with a suitable example. Write merits
and demerits of the same.
b)Derive transformation matrix for 2D rotation about a fixed point.
Q.4
a) Explain the z-buffer algorithm for hidden surface removal with a suitable example.
b) Explain Sutherland-Hodgeman polygon clipping algorithm with a suitable example.
Q.5
a) What is Bezier curve? Write important properties of the Bezier curve.
b) What do you mean by line clipping? Explain Cohen-Sutherland line clipping
algorithm with a suitable example.
Q6
a)Write a note on 3D projections.
b)What is animation? Explain key frame animation.
c)What are the properties of fractals? Explain how the Koch curve is constructed.
Calculate the dimensions of Koch curve.
d)What do you mean by aliasing? Explain any two Anti-aliasing techniques.
Q.1
a) Homogeneous Coordinates

Homogeneous coordinates are an extension of traditional Cartesian coordinates used in

projective geometry. They allow for the representation of points at infinity and facilitate the use
of matrix operations for transformations. A point in 2D space represented in homogeneous
coordinates is given as (x, y, w) , where w is a non-zero scalar. The corresponding Cartesian
coordinates can be retrieved by normalizing: (x/w, y/w) .

Homogeneous Transformation Matrices

1. Translation by (h, k) :

T = \begin{bmatrix}
1 & 0 & h \\
0 & 1 & k \\
0&0&1
\end{bmatrix}

2. Scaling by factors S_x and S_y :

S = \begin{bmatrix}
S_x & 0 & 0 \\
0 & S_y & 0 \\
0&0&1
\end{bmatrix}

3. Rotation by an angle \theta :

R = \begin{bmatrix}
\cos(\theta) & -\sin(\theta) & 0 \\
\sin(\theta) & \cos(\theta) & 0 \\
0&0&1
\end{bmatrix}

b) Working of the Raster Scan System

A Raster scan system is a method used in computer graphics to display images on a screen. It
works by scanning each row of pixels from top to bottom and left to right, converting the image
into a series of horizontal lines.
 Diagram:
```
+---------------------+
| Row 1: Pixel Data |
+---------------------+
| Row 2: Pixel Data |
+---------------------+
| Row n: Pixel Data |
+---------------------+
```

Working:
1. The display device starts at the top-left corner.
2. It processes each pixel in the current row sequentially.
3. Once a row is completed, it moves to the next row down.
4. This continues until all rows are processed, resulting in a complete image being displayed.

c) Principles of Animation

1. Squash and Stretch: This principle gives a sense of weight and volume to animated objects
by stretching or squashing them during motion.

2. Anticipation: Preparing the audience for an action by creating subtle movements that precede
the main action.

3. Staging: Presenting an idea clearly through effective composition, lighting, and timing to
ensure the audience understands what is happening.

4. Follow Through and Overlapping Action: Allowing parts of a character or object to continue
moving after the main action has stopped, adding realism.

5. Timing and Spacing: Controlling the speed of motion and the distance between frames to
create fluid movement that conveys weight and realism.

d) Scaling a Triangle

To scale triangle vertices A(4,4), B(12,4), and C(8,10) with scaling factors S_x = 2 and S_y = 1
:

New Coordinates Calculation:

- For point A:
- A' = (4 S_x, 4 S_y) = (4 2, 4 1) = (8, 4)

- For point B:
 - B' = (12 S_x, 4 S_y) = (12 2, 4 1) = (24, 4)

- For point C:
- C' = (8 S_x, 10 S_y) = (8 2, 10 1) = (16, 10)

Thus, the new coordinates after scaling are:

- A'(8,4)
- B'(24,4)
- C'(16,10)

Q.2

a) Midpoint Circle Drawing Algorithm

The Midpoint Circle Drawing Algorithm efficiently determines pixel positions for drawing a circle
using integer arithmetic.

Algorithm Steps:
1. Initialize parameters:
- Set radius r = 8 .
- Start at point (x,y) = (0,r) = (0,8) .

2. Calculate initial decision parameter:

- P_0 = 1 - r .

3. Iterate through each pixel in the first quadrant:

```plaintext
while x <= y:
plotPixel(x,y)
if P < 0:
P += 2x + 3
else:
P += 2x - 2y + 5
y -= 1
x += 1
```

First Quadrant Pixel Coordinates for Radius = 8:

- The calculated points will be:
- (0,8), (1,7), (2,7), (3,6), (4,4), (5,3), (6,2), (7,1), (8,0).

b) Rotate Line Segment

To rotate line segment with endpoint A(3,3) clockwise by an angle of 45^\circ:

Rotation Matrix:

R_{45} =
\begin{bmatrix}
\cos(-45^\circ) & -\sin(-45^\circ)\\
\sin(-45^\circ) & \cos(-45^\circ)
\end{bmatrix}
=
\begin{bmatrix}
\frac{\sqrt{2}}{2} & -\frac{\sqrt{2}}{2}\\
\frac{\sqrt{2}}{2} & \frac{\sqrt{2}}{2}
\end{bmatrix}

New Coordinates Calculation for Point B(6,9):

Translate B relative to A:
- Translate B to origin:
B'=(6-3),(9-3)=B'(3,6)

Apply rotation:

B'' =
R_{45}
\begin{bmatrix}
3\\
6
\end{bmatrix} =
\begin{bmatrix}
\frac{\sqrt{2}}{2}(3)-\frac{\sqrt{2}}{2}(6)\\
\frac{\sqrt{2}}{2}(3)+\frac{\sqrt{2}}{2}(6)
\end{bmatrix} =
\begin{bmatrix}
-\frac{3\sqrt{2}}{2}\\
\frac{9\sqrt{2}}{2}
\end{bmatrix}

Translate back to original position A(3,3):

- New B coordinates after rotation:
B_{new} = (-\frac{3\sqrt{2}}{2}+3,\frac{9\sqrt{2}}{2}+3)
Q.3

a) Flood Fill and Boundary Fill Algorithms

Flood Fill Algorithm fills an area with a specific color starting from a seed point until it encounters
boundaries.

Example:
Starting from point inside an area filled with color X until reaching boundary color Y.

Boundary Fill Algorithm fills an area until it reaches a boundary color without filling across
boundaries.

Merits and Demerits:

| Merits | Demerits |
|---------------------------------|-----------------------------------|
| Simple implementation | Can be slow for large areas |
| Works well for complex shapes | May require more memory |

b) Transformation Matrix for Rotation about a Fixed Point

To rotate about a fixed point P(px, py) :

1. Translate point P to origin.

2. Apply rotation.
3. Translate back.

The transformation matrix is given by:

M=
T(px,-py)
R(\theta)
T(-px,+py)
=
T(px,-py)
=
\begin{bmatrix}
1 & 0 & px\\
0 & 1 & py\\
0&0&1
\end{bmatrix}
\times
R(\theta)
\times
T(-px,+py)
=
R(\theta)=
=
\begin{bmatrix}
cos(\theta)& -sin(\theta)& px\\
sin(\theta)& cos(\theta)& py\\
0&0&1
\end{bmatrix}

Q.4

a) Z-buffer Algorithm for Hidden Surface Removal

The Z-buffer algorithm is used in computer graphics to determine which surfaces are visible in a
scene based on depth information.

Steps:
1. Initialize Z-buffer with maximum depth values.
2. For each pixel on the screen:
- Compare depth of incoming pixel with current Z-buffer value.
- If incoming pixel is closer than current Z-value:
- Update Z-buffer with new depth.
- Update color buffer with new pixel color.

Example:
Consider two overlapping triangles; only the triangle closer to the viewer will be rendered based
on Z-values stored in the buffer.

b) Sutherland-Hodgeman Polygon Clipping Algorithm

The Sutherland-Hodgeman algorithm clips polygons against rectangular clipping windows.

Steps:
1. Start with input polygon vertices.
2. For each edge of the clipping window:
- Determine intersections with polygon edges.
- Decide whether vertices are inside or outside.
- Construct new clipped polygon based on these decisions.
Example:
Clipping a triangle against a rectangular window will yield new vertices that define the visible
portion of the triangle within the window bounds.

Q.5
a) Bezier Curve

A Bezier curve is a parametric curve used in computer graphics and related fields that uses
control points to define its shape.

Important Properties:
- Defined by control points; more control points yield more complex curves.
- The curve always starts at the first control point and ends at the last control point.
- It is smooth and continuous; derivatives exist at all points along the curve.

b) Line Clipping

Line clipping refers to algorithms that determine which portions of lines are within a defined
viewing area or clipping window.

Cohen-Sutherland Line Clipping Algorithm:

This algorithm uses region codes to quickly identify whether lines are completely inside or
outside:

1. Assign region codes based on line endpoints.

2. Check combinations of codes to determine visibility.
3. Clip lines based on intersection calculations with clipping boundaries if necessary.

Example:
If line endpoints have codes indicating they are outside the window's bounds but intersect with
it; only visible segments are retained.

Q6
a) Note on 3D Projections
3D projections convert three-dimensional objects into two-dimensional representations on
screens or paper while preserving spatial relationships among objects through perspective or
orthographic projection techniques.
b) Animation and Key Frame Animation

Animation is creating motion through sequential images or frames displayed rapidly to give an
illusion of movement.

Key Frame Animation involves defining critical frames at significant points in time; intermediate
frames are generated through interpolation between these keyframes.

c) Properties of Fractals

Fractals exhibit self-similarity across different scales; they have intricate detail at every level of
magnification.

Koch Curve Construction:

The Koch curve is constructed as follows:

1. Start with an equilateral triangle.

2. Divide each side into three equal segments.
3. Create an equilateral triangle on the middle segment pointing outward.
4. Remove the base segment of this triangle.
5. Repeat indefinitely on each line segment created.

Dimensions Calculation:

The Koch curve has a fractal dimension calculated using box-counting methods that yield
dimensions greater than one but less than two due to its infinite complexity.

d) Aliasing

Aliasing occurs when high-frequency signals become indistinguishable from lower frequencies
during sampling processes in digital graphics or audio signals.

Anti-aliasing Techniques:

1. Supersampling: Involves rendering at higher resolutions then downscaling to reduce jagged

edges.

2. Multisampling Anti-aliasing (MSAA): Samples multiple locations within each pixel and
averages colors to smooth edges without significant performance costs compared to
supersampling techniques.
2022
Q.1
a) Give the difference between a random scan display and raster scan display.
b) Define Aliasing, Describe-different antialiasing techniques.
c) Compare DDA and BRESENHAM line drawing algorithms.
d) Explain,point clipping algorithm.
e) Give a Fractal dimension forKOCH curve.
Q.2
a) Derive formula for mid-point circle algorithm.
Qb) Given a line ABVhere and B(O,O) calculate all the points of line AB using DDA algorithm.
Q3
a) With a neat diagram explain Composite Transformation.
b) Describe what Homogeneous coordinates are.
Q.4
a) With a neat diagram explain window to viewport coordinate transformation.
b) with a neat diagram explains the Sutherland Hodgman algorithm.
Q.5
a)Define projection with neat diagram describe planar geometric projection.
b) Describe properties of BEZIER curve.
Q.6
a) Describe various principles of traditional animation.
b) Write short note on Depth buffer algorithm.

Q.1

a) Difference Between Random Scan Display and Raster Scan Display

| Aspect | Random Scan Display | Raster Scan Display

|
|----------------------------|---------------------------------------------|---------------------------------------------|
| Rendering Method | Directly draws lines or shapes on the screen based on coordinates. |
Scans pixels sequentially in a grid pattern to render images. |
| Image Quality | High-quality graphics with smooth curves and lines. | High resolution but
may suffer from pixelation. |
| Speed | Slower for complex images; efficient for vector graphics. | Faster rendering
for complex images due to pixel-based approach. |
| Memory Usage | Requires less memory as only endpoints are stored. | Higher memory
consumption as each pixel's intensity is stored. |
| Cost | Generally more expensive due to specialized hardware. | Typically less
expensive and more widely adopted. |
| Use Cases | Suitable for applications requiring precise vector graphics (CAD). |
Commonly used in televisions and computer monitors for realistic displays. |
Random scan displays excel in precision and quality for vector graphics, while raster scan
displays are more versatile and cost-effective for general use [1][2][3][5].

b) Aliasing and Anti-aliasing Techniques

Aliasing refers to the visual artifacts that occur when high-frequency signals are sampled
insufficiently, resulting in jagged edges or distortions in digital images.

Anti-aliasing Techniques:
1. Supersampling: Renders the image at a higher resolution than needed, then downsamples to
the target resolution, smoothing out edges.

2. Multisampling Anti-aliasing (MSAA): Samples multiple points within each pixel and averages
their colors, reducing jaggedness without significant performance loss.

3. Post-Processing Filters: Applies algorithms after rendering to smooth edges, such as

Gaussian blur or FXAA (Fast Approximate Anti-Aliasing).

4. Coverage Sampling: Determines how much of a pixel is covered by the geometry and adjusts
the color accordingly.

5. Edge Smoothing Techniques: Uses techniques like morphological anti-aliasing to identify and
smooth edges based on pixel connectivity [1][2].

c) Comparison of DDA and BRESENHAM Line Drawing Algorithms

| Feature | DDA Algorithm | Bresenham's Algorithm |

|--------------------------|--------------------------------------------|----------------------------------------------|
| Methodology | Uses floating-point arithmetic for calculations. | Uses integer arithmetic,
making it faster and more efficient. |
| Complexity | Simpler implementation but slower due to floating-point operations. | More
complex but faster due to integer-only calculations. |
| Precision | Can produce smoother lines but may introduce rounding errors. | Produces
precise lines with no rounding errors. |
| Performance | Slower performance, especially for long lines due to floating-point
calculations. | Faster performance, especially for longer lines due to efficient pixel selection. |
| Use Case | Suitable for simple applications where precision is not critical. | Preferred in
applications requiring fast rendering of lines, such as real-time graphics [1][2].

d) Point Clipping Algorithm

The point clipping algorithm determines whether a point lies within a defined rectangular clipping
window.
 Steps:
1. Define the clipping window by its minimum and maximum coordinates: (xmin, ymin) and
(xmax, ymax).
2. For each point P(x, y) :
- Check if x < xmin or x > xmax or y < ymin or y > ymax .
- If any condition is true, the point is outside the clipping window; otherwise, it is inside.

This algorithm efficiently discards points outside the specified region before further processing
[1][6].

e) Fractal Dimension of Koch Curve

The Koch curve is a well-known fractal that exhibits self-similarity and infinite complexity.

Calculation of Fractal Dimension:

The fractal dimension D of the Koch curve can be calculated using the formula:

D = \frac{\log(N)}{\log(1/r)}

where:
- N = 4 (the number of segments after one iteration),
- r = 3 (the scaling factor since each segment is divided into 3 equal parts).

Thus,

D = \frac{\log(4)}{\log(3)} \approx 1.2619

This indicates that the Koch curve has a fractal dimension greater than 1 but less than 2,
reflecting its complexity [1].

Q.2

a) Derive Formula for Mid-Point Circle Algorithm

The Midpoint Circle Algorithm calculates pixel positions to draw a circle using integer arithmetic.

Derivation:
1. Start with a circle centered at the origin with radius r .
2. The equation of the circle is given by:

x^2 + y^2 = r^2

3. The algorithm uses symmetry; only one-eighth of the circle needs to be computed.
4. Begin with initial point (0, r) .
5. Calculate decision parameter p = 1 - r .
6. For each point (x, y) :
- If p < 0 , plot next point using:
- p = p + 2x + 3
- If p \geq 0 , plot next point using:
- p = p + 2x - 2y + 5; y--
- Increment x .

This results in an efficient way to compute circle points using integer arithmetic [1].

b) Calculate Points of Line AB Using DDA Algorithm

Given line segment AB where A(0,0) and B(0,0):

Steps:
1. Calculate differences:
- dx = x_B - x_A = 0 - 0 = 0
- dy = y_B - y_A = 0 - 0 = 0

2. Determine steps required:

- Steps = max(|dx|, |dy|) = max(0, 0) = 0

Since both points are identical, only point A(0,0) will be plotted.

Q3

a) Composite Transformation Diagram

Composite transformations involve combining multiple transformations (translation, scaling,

rotation).

Diagram:
```
Original Object ---> Transformation Matrix ---> Transformed Object
```

Each transformation matrix is multiplied together in sequence to create a single composite

transformation matrix that can be applied to all vertices of an object simultaneously.

b) Homogeneous Coordinates

Homogeneous coordinates extend traditional Cartesian coordinates by adding an extra

dimension, enabling easier representation of transformations through matrix multiplication.
In homogeneous coordinates, a point (x,y) becomes represented as (x,y,w) , where w \neq 0 .
To convert back to Cartesian coordinates:

(x', y') = \left(\frac{x}{w}, \frac{y}{w}\right)

This representation allows for simpler computations involving translations, scaling, and rotations
using matrices [1].

Q4
a) Window to Viewport Coordinate Transformation

The window-to-viewport transformation maps coordinates from a defined window in world space
to a viewport on the display screen.
Diagram:
```
+-------------------+ +-------------------+
| Window | | Viewport |
+-------------------+ +-------------------+
```
Steps:
1. Define the window's corners in world coordinates.
2. Define the viewport's corners in screen coordinates.
3. Calculate scaling factors based on the dimensions of both.
4. Apply translation based on the position of both corners.
The transformation ensures that objects within the window are displayed correctly within the
viewport [1].

b) Sutherland-Hodgeman Algorithm Diagram

The Sutherland-Hodgeman algorithm clips polygons against a rectangular clipping window.
Diagram:
```
Input Polygon ----> Clipping Window ----> Clipped Polygon
```
Steps:
1. Start with input polygon vertices.
2. For each edge of the clipping window:
- Determine intersections with polygon edges.
- Classify vertices as inside or outside.
- Construct new clipped polygon based on these classifications.

This process continues until all edges have been processed [1].
 Q5
a) Definition of Projection with Diagram
Projection refers to mapping three-dimensional objects onto two-dimensional surfaces while
preserving spatial relationships.
Diagram:
```
3D Object ---> Projection Plane ---> 2D Image
```
In planar geometric projection, objects are projected onto a flat surface using parallel rays or
perspective methods.

b) Properties of Bezier Curve

A Bezier curve is defined by control points that influence its shape:
Properties:
- Defined by polynomial equations based on control points.
- Always passes through the first and last control points.
- The curve is smooth and continuous; derivatives exist at all points.
- The degree of the curve increases with additional control points.
- Useful in computer graphics for modeling smooth curves and shapes [1].

Q6
a) Principles of Traditional Animation
Traditional animation relies on several key principles:
1. Squash and Stretch: Gives weight and volume by deforming objects during motion.
2. Anticipation: Prepares viewers for an action by creating subtle movements before major
actions.
3. Staging: Clearly presents an idea through effective composition and timing.
4. Follow Through and Overlapping Action: Allows parts of characters or objects to continue
moving after main actions have stopped.
5. Timing and Spacing: Controls speed and distance between frames to create realistic motion
[1].
b) Depth Buffer Algorithm
The Depth Buffer Algorithm, also known as Z-buffering, manages visibility in rendered scenes
by storing depth information:

Steps:
1. Initialize a depth buffer with maximum values.
2. For each pixel rendered:
- Compare depth values; if closer than current buffer value:
- Update depth buffer with new value.
- Update color buffer with new pixel color.

This ensures that only visible surfaces are displayed correctly without hidden surfaces
interfering [1].