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))
# 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 = 50, 50
x2, y2 = 100, 200
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()
 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)
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()

# 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")

# 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()
3. Develop a program to demonstrate basic geometric operations on the 3D object
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)

# 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()
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)

# 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:
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

pygame.display.flip()

# Quit Pygame
pygame.quit()
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):
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
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()

# Limit the frame rate to 60 FPS

clock.tick(60)

# Quit Pygame
pygame.quit()
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.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

# Display the canvas

cv2.imshow("Image Quadrants", canvas)
cv2.waitKey(0)
cv2.destroyAllWindows()
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.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)
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()
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.jpg" # Replace with the path to your image

try:
img = cv2.imread(image_path)
if img is None:
raise FileNotFoundError("Image not found or cannot be read. Please check
the file path.")
except FileNotFoundError as e:
print(e)
exit()

# 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)
cv2.destroyAllWindows()
10. Write a program to blur and smoothing an image.

import cv2

# Load the image

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

# Make copies to preserve the original image

gaussian_blur = image.copy()
median_blur = image.copy()
bilateral_filter = image.copy()

# Apply Gaussian Blur

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

# Apply Median Blur

cv2.medianBlur(image, 5, median_blur)

# Apply Bilateral Filter

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

# 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()
11. Write a program to contour an image.

import cv2
import numpy as np

# Load the image

image = cv2.imread('image.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

cv2.waitKey(0)
cv2.destroyAllWindows()
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('MANU K L.jpg')

# 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()