(PROG 6):import pygame/import random/pygame.

init()/screen_width = 800/
screen_height=600/screen=pygame.display.set_mode((screen_width, screen_height))
/pygame.display.set_caption("Animation Effects")/BLACK = (0, 0, 0)/WHITE = (255, 255, 255)/RED = (255,
0, 0)/GREEN = (0, 255, 0)/BLUE = (0, 0, 255)/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})/running = True
clock = pygame.time.Clock()/while running:/for event in pygame.event.get():
if event.type == pygame.QUIT:/running = False/screen.fill(WHITE)
for obj in objects:/obj["x"] += obj["speed_x"]/obj["y"] += obj["speed_y"]
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"]/pygame.draw.circle(screen, obj["color"], (obj["x"],
obj["y"]), obj["radius"])/pygame.display.flip()/clock.tick(60)/pygame.quit()

(PROG 7) import cv2/import numpy as np/image_path = "image/atc.jpg" img =cv2.imread(image_path)/height,

width, _ = img.shape/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]/canvas = np.zeros((height, width, 3), dtype=np.uint8)/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_leftcanvas[height//2:height, width//2:width] = down_rightcv2.imshow("Image Quadrants",
canvas)/cv2.waitKey(0)/cv2.destroyAllWindows()

(PROG 8) import cv2/import numpy as np/image_path = "image/atc.jpg"/img =

cv2.imread(image_path)/height, width, _ = img.shape/rotation_matrix =
cv2.getRotationMatrix2D((width/2, height/2), 45, 1)/scaling_matrix = np.float32([[1.5, 0, 0], [0, 1.5,
0]])/translation_matrix = np.float32([[1, 0, 100], [0, 1, 50]])/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))/cv2.imshow("Original Image", img)/cv2.imshow("Rotated Image",
rotated_img)/cv2.imshow("Scaled Image", scaled_img)/cv2.imshow("Translated Image",
translated_img)/ cv2.waitKey(0)/cv2.destroyAllWindows()

(PROG 10) import cv2/image = cv2.imread('image/atc.jpg')/gaussian_blur = cv2.GaussianBlur(image, (5,

5), 0)/median_blur = cv2.medianBlur(image, 5)/bilateral_filter = cv2.bilateralFilter(image, 9, 75,
75)/cv2.imshow('Original Image', image) /cv2.imshow('Gaussian Blur',
gaussian_blur)/cv2.imshow('Median Blur', median_blur)/cv2.imshow('Bilateral Filter', bilateral_filter)/
cv2.waitKey(0)/ cv2.destroyAllWindows()

(PROG 11) import cv2/import numpy as np/image = cv2.imread('image/atc.jpg') /gray =

cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)/ret, thresh = cv2.threshold(gray, 0, 255,
cv2.THRESH_BINARY_INV + cv2.THRESH_OTSU)/contours, hierarchy = cv2.findContours(thresh,
cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)/contour_image =
image.copy()/cv2.drawContours(contour_image, contours, -1, (0, 255, 0), 2)/ cv2.imshow('Original
Image', image)/cv2.imshow('Contours', contour_image)/cv2.waitKey(0)/cv2.destroyAllWindows()
 Prog1:import turtle ,,def bresenham_line(x1, y1, x2, y2):,, # dx = abs(x2 - x1),, dy = abs(y2 - y1) ,,
x_step = 1 if x1 < x2 else -1,, y_step = 1 if y1 < y2 else -1 ,, error = 2 * dy - dx,, line_points = [] ,, x, y
= x1, y1 ,,e for _ in range(dx + 1): ,, line_points.append((x, y)),, if error > 0: ,,y += y_step error -= 2
* dx error += 2 * dy x += x_step,, return line_points ,, turtle.setup(500,
500) ,,turtle.speed(0),, x1, y1 = 100, 100,, x2, y2 = 400, 300,, line_points = bresenham_line(x1, y1,
x2, y2),, turtle.penup() ,,turtle.goto(x1, y1),, turtle.pendown(),, for x, y in line_points:,,
turtle.goto(x, y) ,,turtle.exitonclick()

Prog2:import turtle,, import math,, screen = turtle.Screen() screen.bgcolor("white"),, t = turtle.Turtle()

,,t.speed(1),, t.pensize(2) ,, 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),, def draw_circle(x, y, radius, color):,, t.penup() ,t.goto(x, y -
radius) t.pendown(), t.color(color), t.circle(radius),, def translate(x, y, dx, dy):, t.penup(), t.goto(x
+ dx, y + dy) ,,t.pendown(),, def rotate(x, y, angle):,, t.penup(), t.goto(x, y),
t.setheading(angle), t.pendown(),, def scale(x, y, sx, sy):,, t.penup(),, t.goto(x * sx, y * sy),
t.pendown(),, draw_rectangle(-200, 0, 100, 50, "blue"),, translate(-200, 0, 200, 0)
draw_rectangle(0, 0, 100, 50, "blue"),, rotate(0, 0, 45), draw_rectangle(0, 0, 100, 50, "blue"),,
scale(0, 0, 2, 2), draw_rectangle(0, 0, 100, 50, "blue") ,,draw_circle(100, 100, 50, "red") ,,
translate(100, 100, 200, 0) ,draw_circle(300, 100, 50, "red"),, rotate(300, 100, 45),
draw_circle(300, 100, 50, "red") ,, scale(300, 100, 2, 2) draw_circle(600, 200, 50, "red",,
turtle.done()

Prgm4:import cv2,, import numpy as np,, canvas_width = 500,, canvas_height = 500 ,, canvas
= np.ones((canvas_height, canvas_width, 3), dtype=np.uint8) * 255,, obj_points = np.array([[100,
100], [200, 100], [200, 200], [100, 200]], dtype=np.int32) ,, 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]]) ,, 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),, 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) ,,
cv2.imshow("2D Transformations", canvas) ,,cv2.waitKey(0) ,,cv2.destroyAllWindows()

Prgm3:from vpython import canvas, box, cylinder, vector, color, rate,,scene = canvas(width=800,
height=600, background=color.white),,def draw_cuboid(pos, length, width, height, color):,,cuboid
= box(pos=vector(*pos), length=length, width=width, height=height, color=color),, return
cuboid,,def draw_cylinder(pos, radius, height, color):,,cyl = cylinder(pos=vector(*pos),
radius=radius, height=height, color=color),,return cyl,,def translate(obj, dx, dy, dz):,,obj.pos +=
vector(dx, dy, dz),,def rotate(obj, angle, axis):,,obj.rotate(angle=angle, axis=vector(*axis)),,def
scale(obj, sx, sy, sz):,,obj.size = vector(obj.size.x * sx, obj.size.y * sy, obj.size.z * sz),,cuboid =
draw_cuboid((-2, 0, 0), 2, 2, 2,
color.blue),,translate(cuboid, 4, 0, 0),,rotate(cuboid, angle=45, axis=(0, 1, 0)),,scale(cuboid, 1.5,
1.5, 1.5),,cylinder = draw_cylinder((2, 2, 0), 1, 10, color.red),,translate(cylinder, 0, -2, 0),,rotate(cylinder,
angle=30, axis=(1, 0, 0)),,scale(cylinder, 1.5, 1.5, 1.5),,while True:,, rate(30)
 Prgm5:import pygame,,from pygame.locals import *,,from OpenGL.GL import *,,from
OpenGL.GLU import *,,import numpy asnp,,pygame.init(),,display_width = 800,,display_height =
600,,display = pygame.display.set_mode((display_width, display_height), DOUBLEBUF |
OPENGL),,pygame.display.set_caption("3D Transformations"),,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),,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),,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,,running = True,,angle = 0,,while
running:,,for event in pygame.event.get():,,if event.type == pygame.QUIT:,, running = False,,
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT),, glLoadIdentity(),,
glMultMatrixf(translation_matrix),, glRotatef(angle, 1, 1,
0),,glMultMatrixf(rotation_matrix),,glMultMatrixf(scaling_matrix),, glBegin(GL_LINES),,for edge
in edges:,,for vertex in edge:,, glVertex3fv(vertices[vertex]),,glEnd(),,angle += 1,,
pygame.display.flip(),,pygame.quit()

Prgm12:import cv2,,face_cascade = cv2.CascadeClassifier(cv2.data.haarcascades +

'haarcascade_frontalface_default.xml'),,image = cv2.imread('image/face.jpeg'),,gray =
cv2.cvtColor(image, cv2.COLOR_BGR2GRAY),,faces = face_cascade.detectMultiScale(gray,
scaleFactor=1.1, minNeighbors=5, minSize=(30, 30)),,for (x, y, w, h) in faces:,,cv2.rectangle(image,
(x, y), (x + w, y + h), (0, 255, 0), 2),,cv2.imshow('Face Detection',
image),,cv2.waitKey(0),,cv2.destroyAllWindows()

Prgm9:import cv2,,import numpy as np,,image_path = "image/atc.jpg" ,,img =

cv2.imread(image_path),,gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY),,edges = cv2.Canny(gray, 100,
200) ,,kernel = np.ones((5, 5), np.float32) / 25 ,,texture = cv2.filter2D(gray,
-1, kernel),,cv2.imshow("Original Image", img),,cv2.imshow("Edges",
edges),,cv2.imshow("Texture", texture),,cv2.waitKey(0),,cv2.destroyAllWindows()