VISHWESHWARAYA TECHNOLOGICAL UNIVERSITY

BELGAVI -590018

G MADEGOWDA INSTITUTE OF TECHNOLOGY

MANDYA,BHARATHINAGAR Karnataka 571422

COMPUTER GRAPHICS AND IMAGE PROCESSING LABORATORY

(21CSL66)

LAB MANUAL

PALLAVI R
Asst.Professor, GMIT
(AIML Branch)
 PROGRAM LIST

PART-A Programs

1. Bresenham’s Algorithm
2. 2D object geometric operations
3. 3D object geometric operations
4. 2D transformation basic objects
5. 3D transformation basic objects
6. Animation effects on simple objects
7. display image into 4 quadrants
8. rotation, scaling, and translation on an image.
9. Filtering techniques
10. blur and smoothing an image.
11. contour an image.
12. detect a face/s in an image.
 CG LAB MANUAL

1. Develop a program to draw a line using Bresenham’s line

drawing technique.

import turtle

def bresenham_line(x1, y1, x2, y2):

# Calculate the deltas

dx = abs(x2 - x1)

dy = abs(y2 - y1)

# Determine the step direction for each axis

x_step = 1 if x1 < x2 else -1

y_step = 1 if y1 < y2 else -1

# Initialize the error term

error = 2 * dy - dx

# Initialize the line points

line_points = []

# Start at the first point

x, y = x1, y1

# Draw the line

for _ in range(dx + 1):

# Add the current point to the line

line_points.append((x, y))

21CSL66
 CG LAB MANUAL

# Update the error term and adjust the coordinates

if error > 0:

y += y_step

error -= 2 * dx

error += 2 * dy

x += x_step

return line_points

# Example usage

turtle.setup(500, 500)

turtle.speed(0) # Fastest drawing speed

x1, y1 = 100, 100

x2, y2 = 400, 300

line_points = bresenham_line(x1, y1, x2, y2)

# Draw the line

turtle.penup()

turtle.goto(x1, y1)

turtle.pendown()

for x, y in line_points:

turtle.goto(x, y)

turtle.exitonclick()

21CSL66
 CG LAB MANUAL

output

21CSL66
 CG LAB MANUAL

2. Develop a program to demonstrate basic geometric operations on

the 2D object

import turtle

import math

# Set up the turtle screen

screen = turtle.Screen()

screen.bgcolor("white")

# Create a turtle instance

t = turtle.Turtle()

t.speed(1) # Set the drawing speed (1 is slowest, 10 is fastest)

t.pensize(2) # Set the pen size

# Define a function to draw a rectangle

def draw_rectangle(x, y, width, height, color):

t.penup()

t.goto(x, y)

t.pendown()

t.color(color)

for _ in range(2):

t.forward(width)
t.left(90)

21CSL66
 CG LAB MANUAL

t.forward(height)

t.left(90)

# Define a function to draw a circle

def draw_circle(x, y, radius, color):

t.penup()

t.goto(x, y - radius)

t.pendown()

t.color(color)

t.circle(radius)

# Define a function to translate a 2D object

def translate(x, y, dx, dy):

t.penup()

t.goto(x + dx, y + dy)

t.pendown()

# Define a function to rotate a 2D object

def rotate(x, y, angle):

t.penup()

t.goto(x, y)

t.setheading(angle)

t.pendown()

21CSL66
 CG LAB MANUAL

# Define a function to scale a 2D object

def scale(x, y, sx, sy):

t.penup()

t.goto(x * sx, y * sy)

t.pendown()

# Draw a rectangle

draw_rectangle(-200, 0, 100, 50, "blue")

# Translate the rectangle

translate(-200, 0, 200, 0)

draw_rectangle(0, 0, 100, 50, "blue")

# Rotate the rectangle

rotate(0, 0, 45)

draw_rectangle(0, 0, 100, 50, "blue")

# Scale the rectangle

scale(0, 0, 2, 2)

draw_rectangle(0, 0, 100, 50, "blue")

# Draw a circle

draw_circle(100, 100, 50, "red")

# Translate the circle

translate(100, 100, 200, 0)

draw_circle(300, 100, 50, "red")

21CSL66
 CG LAB MANUAL

# Rotate the circle

rotate(300, 100, 45)

draw_circle(300, 100, 50, "red")

# Scale the circle

scale(300, 100, 2, 2)

draw_circle(600, 200, 50, "red")

# Keep the window open until it's closed

turtle.done()

output

21CSL66
 CG LAB MANUAL

3. Develop a program to demonstrate basic geometric operations on

the 3D object

from vpython import canvas, box, cylinder, vector, color, rate

# Create a 3D canvas

scene = canvas(width=800, height=600, background=color.white)

# Define a function to draw a cuboid

def draw_cuboid(pos, length, width, height, color):

cuboid = box(pos=vector(*pos), length=length, width=width, height=height,

color=color)

return cuboid

# Define a function to draw a cylinde

def draw_cylinder(pos, radius, height, color):

cyl = cylinder(pos=vector(*pos), radius=radius, height=height, color=color)

return cyl

# Define a function to translate a 3D object

def translate(obj, dx, dy, dz):

obj.pos += vector(dx, dy, dz)

# Define a function to rotate a 3D object

def rotate(obj, angle, axis):

obj.rotate(angle=angle, axis=vector(*axis))

# Define a function to scale a 3D object

21CSL66
 CG LAB MANUAL

def scale(obj, sx, sy, sz):

obj.size = vector(obj.size.x * sx, obj.size.y * sy, obj.size.z * sz)

# Draw a cuboid

cuboid = draw_cuboid((-2, 0, 0), 2, 2, 2, color.blue)

# Translate the cuboid

translate(cuboid, 4, 0, 0)

# Rotate the cuboid

rotate(cuboid, angle=45, axis=(0, 1, 0))

# Scale the cuboid

scale(cuboid, 1.5, 1.5, 1.5)

# Draw a cylinder

cylinder = draw_cylinder((2, 2, 0), 1, 10, color.red)

# Translate the cylinder

translate(cylinder, 0, -2, 0)

# Rotate the cylinder

rotate(cylinder, angle=30, axis=(1, 0, 0))

# Scale the cylinder

scale(cylinder, 1.5, 1.5, 1.5)

# Keep the 3D scene interactive

while True:

rate(30) # Set the frame rate to 30 frames per second

21CSL66
 CG LAB MANUAL

output

21CSL66
 CG LAB MANUAL

4. Develop a program to demonstrate 2D transformation on basic

objects

import cv2

import numpy as np

# Define the dimensions of the canvas

canvas_width = 500

canvas_height = 500

# Create a blank canvas

canvas = np.ones((canvas_height, canvas_width, 3), dtype=np.uint8) * 255

# Define the initial object (a square)

obj_points = np.array([[100, 100], [200, 100], [200, 200], [100, 200]],

dtype=np.int32)

# Define the transformation matrices

translation_matrix = np.float32([[1, 0, 100], [0, 1, 50]])

rotation_matrix = cv2.getRotationMatrix2D((150, 150), 45, 1)

scaling_matrix = np.float32([[1.5, 0, 0], [0, 1.5, 0]])

# Apply transformations

translated_obj = np.array([np.dot(translation_matrix, [x, y, 1])[:2] for x, y in

obj_points], dtype=np.int32)

rotated_obj = np.array([np.dot(rotation_matrix, [x, y, 1])[:2] for x, y in

translated_obj], dtype=np.int32)

scaled_obj = np.array([np.dot(scaling_matrix, [x, y, 1])[:2] for x, y in rotated_obj],

dtype=np.int32)

21CSL66
 CG LAB MANUAL

# Draw the objects on the canvas

cv2.polylines(canvas, [obj_points], True, (0, 0, 0), 2)

cv2.polylines(canvas, [translated_obj], True, (0, 255, 0), 2)

cv2.polylines(canvas, [rotated_obj], True, (255, 0, 0), 2)

cv2.polylines(canvas, [scaled_obj], True, (0, 0, 255), 2)

# Display the canvas

cv2.imshow("2D Transformations", canvas)

cv2.waitKey(0)

cv2.destroyAllWindows()

output

21CSL66
 CG LAB MANUAL

5. .Develop a program to demonstrate 3D transformation on 3D

objects
import pygame

from pygame.locals import *

from OpenGL.GL import *

from OpenGL.GLU import *

import numpy as np

# Initialize Pygame

pygame.init()

# Set up the display

display_width = 800

display_height = 600

display = pygame.display.set_mode((display_width, display_height), DOUBLEBUF |

OPENGL)

pygame.display.set_caption("3D Transformations")

# Set up OpenGL

glClearColor(0.0, 0.0, 0.0, 1.0)

glEnable(GL_DEPTH_TEST)

glMatrixMode(GL_PROJECTION)

gluPerspective(45, (display_width / display_height), 0.1, 50.0)

glMatrixMode(GL_MODELVIEW)

21CSL66
 CG LAB MANUAL

# Define the 3D object (a cube)

vertices = np.array([
[-1, -1, -1],
[1, -1, -1],
[1, 1, -1],
[-1, 1, -1],
[-1, -1, 1],
[1, -1, 1],
[1, 1, 1],
[-1, 1, 1]
], dtype=np.float32)

edges = np.array([
[0, 1], [1, 2], [2, 3], [3, 0],
[4, 5], [5, 6], [6, 7], [7, 4],
[0, 4], [1, 5], [2, 6], [3, 7]
], dtype=np.uint32)

# Set up the transformation matrices

translation_matrix = np.eye(4, dtype=np.float32)

translation_matrix[3, :3] = [0, 0, -5]

rotation_matrix = np.eye(4, dtype=np.float32)

scaling_matrix = np.eye(4, dtype=np.float32)

scaling_matrix[0, 0] = 1.5

scaling_matrix[1, 1] = 1.5

scaling_matrix[2, 2] = 1.5

# Main loop

running = True

angle = 0

while running:

21CSL66
 CG LAB MANUAL

for event in pygame.event.get():

if event.type == pygame.QUIT:

running = False

# Clear the display

glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT)

# Apply transformations

glLoadIdentity()

glMultMatrixf(translation_matrix)

glRotatef(angle, 1, 1, 0)

glMultMatrixf(rotation_matrix)

glMultMatrixf(scaling_matrix)

# Draw the 3D object

glBegin(GL_LINES)

for edge in edges:

for vertex in edge:

glVertex3fv(vertices[vertex])

glEnd()

# Update the rotation angle

angle += 1

# Swap the front and back buffers

21CSL66
 CG LAB MANUAL

pygame.display.flip()

# Quit Pygame

pygame.quit()

output

21CSL66
 CG LAB MANUAL

6. Develop a program to demonstrate Animation effects on simple

objects.
import pygame

import random

# Initialize Pygame

pygame.init()

# Set up the display

screen_width = 800

screen_height = 600

screen = pygame.display.set_mode((screen_width, screen_height))

pygame.display.set_caption("Animation Effects")

# Define colors

BLACK = (0, 0, 0)

WHITE = (255, 255, 255)

RED = (255, 0, 0)

GREEN = (0, 255, 0)

BLUE = (0, 0, 255)

# Define object properties

num_objects = 10

objects = []

for _ in range(num_objects):

21CSL66
 CG LAB MANUAL

x = random.randint(50, screen_width - 50)

y = random.randint(50, screen_height - 50)

radius = random.randint(10, 30)

color = random.choice([RED, GREEN, BLUE])

speed_x = random.randint(-5, 5)

speed_y = random.randint(-5, 5)

objects.append({"x": x, "y": y, "radius": radius, "color": color, "speed_x": speed_x,

"speed_y": speed_y})

# Main loop

running = True

clock = pygame.time.Clock()

while running:

# Handle events

for event in pygame.event.get():

if event.type == pygame.QUIT:

running = False

# Clear the screen

screen.fill(WHITE)

# Update and draw objects

for obj in objects:

# Move the object

21CSL66
 CG LAB MANUAL

obj["x"] += obj["speed_x"]

obj["y"] += obj["speed_y"]

# Bounce off the edges

if obj["x"] - obj["radius"] < 0 or obj["x"] + obj["radius"] > screen_width:

obj["speed_x"] = -obj["speed_x"]

if obj["y"] - obj["radius"] < 0 or obj["y"] + obj["radius"] > screen_height:

obj["speed_y"] = -obj["speed_y"]

# Draw the object

pygame.draw.circle(screen, obj["color"], (obj["x"], obj["y"]), obj["radius"])

# Update the display

pygame.display.flip()

clock.tick(60) # Limit the frame rate to 60 FPS

# Quit Pygame

pygame.quit()

output

21CSL66
CG LAB MANUAL

21CSL66
 CG LAB MANUAL

7. Write a Program to read a digital image. Split and display image

into 4 quadrants, up, down, right and left.
import cv2

import numpy as np

# Load the image

image_path = "image/atc.jpg" # Replace with the path to your image

img = cv2.imread(image_path)

# Get the height and width of the image

height, width, _ = img.shape

# Split the image into four quadrants

up_left = img[0:height//2, 0:width//2]

up_right = img[0:height//2, width//2:width]

down_left = img[height//2:height, 0:width//2]

down_right = img[height//2:height, width//2:width]

# Create a blank canvas to display the quadrants

canvas = np.zeros((height, width, 3), dtype=np.uint8)

# Place the quadrants on the canvas

canvas[0:height//2, 0:width//2] = up_left

canvas[0:height//2, width//2:width] = up_right

canvas[height//2:height, 0:width//2] = down_left

canvas[height//2:height, width//2:width] = down_right

21CSL66
 CG LAB MANUAL

# Display the canvas

cv2.imshow("Image Quadrants", canvas)

cv2.waitKey(0)

cv2.destroyAllWindows()

output

21CSL66
 CG LAB MANUAL

8. Write a program to show rotation, scaling, and translation on an

image.

import cv2

import numpy as np

# Load the image

image_path = "image/atc.jpg" # Replace with the path to your image

img = cv2.imread(image_path)

# Get the image dimensions

height, width, _ = img.shape

# Define the transformation matrices

rotation_matrix = cv2.getRotationMatrix2D((width/2, height/2), 45, 1) # Rotate by 45

degrees

scaling_matrix = np.float32([[1.5, 0, 0], [0, 1.5, 0]]) # Scale by 1.5x

translation_matrix = np.float32([[1, 0, 100], [0, 1, 50]]) # Translate by (100, 50)

# Apply transformations

rotated_img = cv2.warpAffine(img, rotation_matrix, (width, height))

scaled_img = cv2.warpAffine(img, scaling_matrix, (int(width*1.5), int(height*1.5)))

translated_img = cv2.warpAffine(img, translation_matrix, (width, height))

# Display the original and transformed images

cv2.imshow("Original Image", img)

cv2.imshow("Rotated Image", rotated_img)

21CSL66
 CG LAB MANUAL

cv2.imshow("Scaled Image", scaled_img)

cv2.imshow("Translated Image", translated_img)

# Wait for a key press and then close all windows

cv2.waitKey(0)

cv2.destroyAllWindows()

output

21CSL66
CG LAB MANUAL

21CSL66
CG LAB MANUAL

21CSL66
 CG LAB MANUAL

9. Read an image and extract and display low-level features such as

edges, textures using filtering techniques.

import cv2

import numpy as np

# Load the image

image_path = "image/atc.jpg" # Replace with the path to your image

img = cv2.imread(image_path)

# Convert the image to grayscale

gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)

# Edge detection

edges = cv2.Canny(gray, 100, 200) # Use Canny edge detector

# Texture extraction

kernel = np.ones((5, 5), np.float32) / 25 # Define a 5x5 averaging kernel

texture = cv2.filter2D(gray, -1, kernel) # Apply the averaging filter for texture
extraction

# Display the original image, edges, and texture

cv2.imshow("Original Image", img)

cv2.imshow("Edges", edges)

cv2.imshow("Texture", texture)

# Wait for a key press and then close all windows

cv2.waitKey(0)

21CSL66
 CG LAB MANUAL

cv2.destroyAllWindows()
output

21CSL66
CG LAB MANUAL

21CSL66
 CG LAB MANUAL

10. Write a program to blur and smoothing an image.

import cv2

# Load the image

image = cv2.imread('image/atc.jpg')

# Gaussian Blur

gaussian_blur = cv2.GaussianBlur(image, (5, 5), 0)

# Median Blur

median_blur = cv2.medianBlur(image, 5)

# Bilateral Filter

bilateral_filter = cv2.bilateralFilter(image, 9, 75, 75)

# Display the original and processed images

cv2.imshow('Original Image', image)

cv2.imshow('Gaussian Blur', gaussian_blur)

cv2.imshow('Median Blur', median_blur)

cv2.imshow('Bilateral Filter', bilateral_filter)

# Wait for a key press to close the windows

cv2.waitKey(0)

cv2.destroyAllWindows()

21CSL66
 CG LAB MANUAL

output

21CSL66
 CG LAB MANUAL

11. Write a program to contour an image.

import cv2

import numpy as np

# Load the image

image = cv2.imread('image/atc.jpg')

# Convert the image to grayscale

gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)

# Apply binary thresholding

ret, thresh = cv2.threshold(gray, 0, 255, cv2.THRESH_BINARY_INV +

cv2.THRESH_OTSU)

# Find contours

contours, hierarchy = cv2.findContours(thresh, cv2.RETR_EXTERNAL,

cv2.CHAIN_APPROX_SIMPLE)

# Create a copy of the original image to draw contours on

contour_image = image.copy()

# Draw contours on the image

cv2.drawContours(contour_image, contours, -1, (0, 255, 0), 2)

# Display the original and contour images

cv2.imshow('Original Image', image)

cv2.imshow('Contours', contour_image)

# Wait for a key press to close the windows

21CSL66
 CG LAB MANUAL

cv2.waitKey(0)
cv2.destroyAllWindows()

output

21CSL66
 CG LAB MANUAL

12. Write a program to detect a face/s in an image.

import cv2

# Load the cascade classifier for face detection

face_cascade = cv2.CascadeClassifier(cv2.data.haarcascades +
'haarcascade_frontalface_default.xml')

# Load the image

image = cv2.imread('image/face.jpeg')

# Convert the image to grayscale

gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)

# Detect faces in the grayscale image

faces = face_cascade.detectMultiScale(gray, scaleFactor=1.1, minNeighbors=5,

minSize=(30, 30))

# Draw rectangles around the detected faces

for (x, y, w, h) in faces:

cv2.rectangle(image, (x, y), (x + w, y + h), (0, 255, 0), 2)

# Display the image with detected faces

cv2.imshow('Face Detection', image)

# Wait for a key press to close the window

cv2.waitKey(0)

cv2.destroyAllWindows()

21CSL66
 CG LAB MANUAL

output

21CSL66