COMPUTER VISION AND IMAGE PROCESSING

LAB SESSION
INTRODUCTION TO OPENCV

COURSE INSTRUCTOR: Dr. Roopa B S

 The OpenCV library
• Open Computer Vision Library: a collection of open source
algorithms for computer vision and image processing
• Originally developed by Intel, then funded and supported by Willow
Garage. Currently a non-profit foundation (www.opencv.org)
• Code is released under the BSD license – free for both academicals
and commercial use
• Main language: C/C++, with optimized routines (multi-thread,
SIMD, ..)
• Current version: 4.9.0
• Freely downloadable from:
• http://sourceforge.net/projects/opencvlibrary
• Available for Windows, Linux, iOS. Currently supporting also Android
 Exercise 1 – “invert grey”
• Compute the “negative” of a grayscale image
• Given a grayscale image (range of each pixel between [0 255]),
substitute each pixel having intensity I with the value: 255-I
 Exercise 2 – “invert RGB”
• Same as before, but in this case we want to compute the negative of a
color image.
• The image has 3 channels, representing the 3 RGB values
• The intensity of each channel ranges between [0 255]
• For each image pixel, we need to substitute the (B,G,R) triplet with its
«inverse» (255-B, 255-G, 255-R)
 Exercise 3 – Image difference
• Build a new project which performs the following:
• loads 2 images (Image 1, I1 and Image 2, I2)
• computes the pixel-wise difference between the two images:
• computes an output image where each pixel of coordinates (x,y) contains the
absolute difference of the corresponding pixels on I1 and I2:
• Out(x,y) = abs(I1(x,y) – I2(x,y))
• Displays on a window the output image
 Create a chess table using numpy and opencv.

To create a chessboard using numpy and OpenCV, we can follow these steps:
Initialize the board: Create an 8x8 array where each element represents a square on
the chessboard.
Color the squares: Assign alternating colors to the squares to mimic a real chessboard.
Resize and display the image: Use OpenCV to scale the numpy array to a larger size and
display it.
Step 1: We initialize a numpy array of zeros to represent an 8x8 chessboard with 3
color channels (RGB).
Step 2: We use a nested loop to iterate over each element of the array and assign it a
color based on its position. If the sum of the row and column indices is even, the square
is white; otherwise, it is black.
Step 3: We resize the array to make each square larger for better visualization using
cv2.resize.
Step 4: Finally, we display the chessboard using OpenCV's imshow function.
Create a chess table using numpy and opencv.
Create a chess table using numpy and opencv.

import numpy as np
import cv2
# Import the cv2_imshow function
from google.colab.patches import cv2_imshow

# Step 1: Initialize the chessboard size

board_size = 8
square_size = 50 # Size of each square in pixels
board = np.zeros((board_size, board_size, 3),
dtype=np.uint8)
Create a chess table using numpy and opencv.

# Step 2: Color the squares

for i in range(board_size):
for j in range(board_size):
if (i + j) % 2 == 0:
board[i, j] = [255, 255, 255] # White square
else:
board[i, j] = [0, 0, 0] # Black square

# Step 3: Resize the image to a larger size for better

visualization
board_large = cv2.resize(board, (board_size *
square_size, board_size * square_size),
interpolation=cv2.INTER_NEAREST)
Create a chess table using numpy and opencv.

# Step 4: Display the image using OpenCV

cv2.imshow("Chessboard", board_large)
# Display the image using cv2_imshow
cv2_imshow(board_large)

cv2.waitKey(0)
cv2.destroyAllWindows()
Design letter-B using numpy and open-cv.

· Initialize the array: img_arr is a flat array of

values from 0 to 89999. np.reshape converts it
into a 300x300 matrix.
· Set the image to white: img[:,:]=255 sets all
elements to 255 (white).
· Create black regions: Specific slices of the
array are set to 0 (black) to form the desired
pattern.
· Save and display: The image is saved as
result_7.png, and cv2_imshow (specific to
Google Colab) is used to display the image.
Design letter-B using numpy and open-cv.
import cv2
import numpy as np
from google.colab.patches import cv2_imshow

img_arr = np.arange(0, 90000, 1, np.uint8)

img = np.reshape(img_arr, (300, 300))
height, width = img.shape

img[:,:]=255
img[50:250, 50:100]=0

img[50:90, 100:160]=0
img[210:250, 100:160]=0
img[130:170, 100:160]=0

img[70:140, 160:210]=0
img[160:230, 160:210]=0
Design letter-B using numpy and open-cv.

cv2.imwrite('result_7.png', img)
# Import the cv2_imshow function
from google.colab.patches import
cv2_imshow

# Display the image using

cv2_imshow
cv2_imshow(img)
 Rotate Image
· Read the image: The image is read in grayscale mode
(cv2.IMREAD_GRAYSCALE), ensuring a single channel (0-255 values).
· Check for successful image loading: Adding a check to ensure the image
was loaded successfully to avoid errors.
· Initialize and reshape the array: This step is not strictly necessary since we
will overwrite all the values in the next step, but it shows the intent clearly.
· Invert the image: The nested loops iterate through each pixel of the image
and assign it to the corresponding position in the inverted image.
· Save the inverted image: The cv2.imwrite function saves the resulting
image.
· cv2.flip(img, -1) flips the image both vertically and horizontally, which is
equivalent to reversing both rows and columns as in the original code.
· This approach is more concise and leverages OpenCV's optimized functions
for better performance.
Rotate Image
 Rotate Image
import cv2
import numpy as np

# Step 1: Read the image in grayscale mode

img = cv2.imread('img/3.jpg', 0)

# Check if the image was successfully loaded

if img is None:
print("Error loading img/3.jpg")
else:
# Step 2: Invert the image by flipping it vertically and horizontally
rev_img = cv2.flip(img, -1)

# Step 3: Save the inverted image to a file

cv2.imwrite('result_3.png', rev_img)
print("Inverted image saved as result_3.png")
 Corner Line

· Read the image: The image is read in color

mode (BGR).
· Get dimensions: We retrieve the height,
width, and number of color channels (ignored)
of the image.
· Pixel manipulation:
The loops iterate over a range of rows (j) and
columns (k), up to a maximum of 400 and 85
respectively.
The condition if 300 - j + k < width ensures that
the calculated index does not exceed the
image boundaries.
For each valid index, the pixel value is set to
black ([0, 0, 0]).
· Save the modified image: The modified
image is saved to a file named result_5.png.
 Corner Line

import cv2

img = cv2.imread('img/polar_bear.jpg', 1)

height, width, _ = img.shape

for j in range(400): #height

for k in range(85): #width
if not 300-j+k<0:
img[j][300-j+k]= 0

cv2.imwrite('result_5.png', img)