CookieSensei

CookieSensei Home Learn Free Workshops Live Guidance About FAQ Contact Launch Lab

Learn/Programming & AI/Teaching Computers to Learn/Additional Tutorials

Teaching Computers to Learn•Interactive notebook lesson•Free

Image manipulation opencv

No account is required. Learn the material, try the examples, and mark it complete locally when you are ready to move on.

Version requirements

python version: 3.11
imageio: 2.33
opencv: 4.8

Codepython

# Please uncomment the below line to install imageio library
# !pip install imageio

Codepython

import urllib.request

from IPython.display import display, Image
import imageio.v2 as imageio
import os
import cv2

import numpy as np
import glob
import PIL
import matplotlib.pyplot as plt

Image as numpy array

Creating a 5 row, 3 column numpy array

Code

arr1 = np.ones((5,3))
arr1

Codepython

os.listdir()

Output

['7 - imdb_eda.ipynb',
 '7.3 - model analysis.py',
 '2 - opencv image on image.ipynb',
 'resources',
 '6 - alexa_improved_nlp_pipeline.ipynb',
 '7.2 - train_imdb_model.py',
 '5 - embedding vectors basics.ipynb',
 '1 - Image manipulation opencv.ipynb',
 '4 - regular_expressions_beautified.ipynb',
 '3 - Image thresholding.ipynb']

Codepython

glob.glob("*/*.jpg")

Output

['resources/bright_nlp_ifidf.jpg',
 'resources/tom.jpg',
 'resources/saved_img2.jpg',
 'resources/italy.jpg',
 'resources/multiple.jpg',
 'resources/adaptiveboost.jpg',
 'resources/saved_image.jpg',
 'resources/cookiesensei.jpg',
 'resources/crossing.jpg',
 'resources/dark_nlp_tfidf.jpg']

Codepython

# This will work as long as this image is there in the github repo
# This is how we can visualize web images using Ipython.display.Image
img_url = "https://github.com/cookieSensei/AI-tutorials/blob/main/tom.jpg?raw=true"
display(Image(url=img_url))

Output

<IPython.core.display.Image object>

Codepython



imageio_img_arr = imageio.imread(tom_cruise_img_path)
display(imageio.imread(tom_cruise_img_path))

Output

array([[[ 96, 135, 147],
        [ 94, 133, 144],
        [ 93, 129, 142],
        ...,
        [182, 185, 195],
        [182, 185, 195],
        [182, 185, 195]],

       [[ 96, 135, 147],
        [ 94, 133, 144],
        [ 93, 129, 142],
        ...,
        [182, 185, 195],
        [182, 185, 195],
        [182, 185, 195]],

       [[ 96, 135, 149],
        [ 94, 132, 146],
        [ 93, 129, 142],
        ...,
        [182, 185, 195],
        [182, 185, 195],
        [182, 185, 195]],

       ...,

       [[ 55,  58,  66],
        [ 54,  57,  65],
        [ 56,  59,  67],
        ...,
        [ 46,  48,  52],
        [ 46,  48,  52],
        [ 46,  48,  52]],

       [[ 56,  59,  67],
        [ 56,  59,  67],
        [ 57,  61,  69],
        ...,
        [ 46,  48,  52],
        [ 46,  48,  52],
        [ 46,  48,  52]],

       [[ 55,  58,  66],
        [ 56,  59,  67],
        [ 57,  61,  69],
        ...,
        [ 46,  48,  52],
        [ 46,  48,  52],
        [ 46,  48,  52]]], dtype=uint8)

Codepython

img_arr = cv2.imread(tom_cruise_img_path)
img_arr

Output

array([[[147, 135,  96],
        [144, 133,  94],
        [142, 129,  93],
        ...,
        [195, 185, 182],
        [195, 185, 182],
        [195, 185, 182]],

       [[147, 135,  96],
        [144, 133,  94],
        [142, 129,  93],
        ...,
        [195, 185, 182],
        [195, 185, 182],
        [195, 185, 182]],

       [[149, 135,  96],
        [146, 132,  94],
        [142, 129,  93],
        ...,
        [195, 185, 182],
        [195, 185, 182],
        [195, 185, 182]],

       ...,

       [[ 66,  58,  55],
        [ 65,  57,  54],
        [ 67,  59,  56],
        ...,
        [ 52,  48,  46],
        [ 52,  48,  46],
        [ 52,  48,  46]],

       [[ 67,  59,  56],
        [ 67,  59,  56],
        [ 69,  61,  57],
        ...,
        [ 52,  48,  46],
        [ 52,  48,  46],
        [ 52,  48,  46]],

       [[ 66,  58,  55],
        [ 67,  59,  56],
        [ 69,  61,  57],
        ...,
        [ 52,  48,  46],
        [ 52,  48,  46],
        [ 52,  48,  46]]], dtype=uint8)

Codepython

def cv2_plt(img_arr):
    """Function to visualize an image loaded using opencv.
    
    Parameters:
        img_arr: image array ing BGR format or say image loaded using opencv
    """
    
    img_arr = img_arr.copy()    
    image_rgb = cv2.cvtColor(img_arr, cv2.COLOR_BGR2RGB) 
    
    fig, axes = plt.subplots(1,2)
    
    axes[0].imshow(img_arr)
    axes[0].set_title("opencv loaded Image")
    
    axes[1].imshow(image_rgb)
    axes[1].set_title("RGB Image")

    # plt.show()

Codepython

img_arr

Output

array([[[147, 135,  96],
        [144, 133,  94],
        [142, 129,  93],
        ...,
        [195, 185, 182],
        [195, 185, 182],
        [195, 185, 182]],

       [[147, 135,  96],
        [144, 133,  94],
        [142, 129,  93],
        ...,
        [195, 185, 182],
        [195, 185, 182],
        [195, 185, 182]],

       [[149, 135,  96],
        [146, 132,  94],
        [142, 129,  93],
        ...,
        [195, 185, 182],
        [195, 185, 182],
        [195, 185, 182]],

       ...,

       [[ 66,  58,  55],
        [ 65,  57,  54],
        [ 67,  59,  56],
        ...,
        [ 52,  48,  46],
        [ 52,  48,  46],
        [ 52,  48,  46]],

       [[ 67,  59,  56],
        [ 67,  59,  56],
        [ 69,  61,  57],
        ...,
        [ 52,  48,  46],
        [ 52,  48,  46],
        [ 52,  48,  46]],

       [[ 66,  58,  55],
        [ 67,  59,  56],
        [ 69,  61,  57],
        ...,
        [ 52,  48,  46],
        [ 52,  48,  46],
        [ 52,  48,  46]]], dtype=uint8)

Codepython

# Creating array of 3 row pixel, 2 column pixel, 3 color channel format
np.zeros((3,2,4), dtype=np.int8)

Output

array([[[0, 0, 0, 0],
        [0, 0, 0, 0]],

       [[0, 0, 0, 0],
        [0, 0, 0, 0]],

       [[0, 0, 0, 0],
        [0, 0, 0, 0]]], dtype=int8)

Codepython

[
    [
        [100, 0, 0],
        [0, 0, 0]],

    [
        [0, 0, 0],
        [0, 0, 0]],
    
    [
        [0, 0, 0],
        [0, 0, 0]]
]

Output

[[[100, 0, 0], [0, 0, 0]], [[0, 0, 0], [0, 0, 0]], [[0, 0, 0], [0, 0, 0]]]

Codepython

sample_aray = np.array(
[
    [
        [0, 0, 0],
        [0, 0, 100]],

    [
        [0, 0, 0],
        [0, 0, 0]],
    
    [
        [0, 0, 0],
        [0, 0, 0]]
])
plt.imshow(sample_aray)

Output

<matplotlib.image.AxesImage at 0x77f714684820>

Codepython

img3c2 = np.array(
    [
        [  #Red, Green, Blue
            [100, 0, 0], # First row, first column pixel
            [255, 0, 0]], # First row, second column pixel
    
        [
            [0, 100, 0], # Second row, first column pixel
            [0, 255, 0]], # Second row, second column pixel
        
        [
            [0, 0, 100], # Third row, first column pixel
            [0, 0, 255]] # Third row, second column pixel
    ]
)

plt.imshow(img3c2)
plt.show()

Output

Codepython

arr4 = np.zeros((5, 8, 3), dtype=np.int8)
arr4

Output

array([[[0, 0, 0],
        [0, 0, 0],
        [0, 0, 0],
        [0, 0, 0],
        [0, 0, 0],
        [0, 0, 0],
        [0, 0, 0],
        [0, 0, 0]],

       [[0, 0, 0],
        [0, 0, 0],
        [0, 0, 0],
        [0, 0, 0],
        [0, 0, 0],
        [0, 0, 0],
        [0, 0, 0],
        [0, 0, 0]],

       [[0, 0, 0],
        [0, 0, 0],
        [0, 0, 0],
        [0, 0, 0],
        [0, 0, 0],
        [0, 0, 0],
        [0, 0, 0],
        [0, 0, 0]],

       [[0, 0, 0],
        [0, 0, 0],
        [0, 0, 0],
        [0, 0, 0],
        [0, 0, 0],
        [0, 0, 0],
        [0, 0, 0],
        [0, 0, 0]],

       [[0, 0, 0],
        [0, 0, 0],
        [0, 0, 0],
        [0, 0, 0],
        [0, 0, 0],
        [0, 0, 0],
        [0, 0, 0],
        [0, 0, 0]]], dtype=int8)

Codepython

arr4_img = np.array([
    # First row
        [[255, 0, 0],
        [0, 255, 0],
        [0, 0, 255],
        [0, 0, 0],
        [0, 0, 0],
        [0, 0, 0],
        [0, 0, 0],
        [0, 0, 0]],
    
    # Second row
       [[0, 0, 0],
        [0, 0, 0],
        [0, 0, 0],
        [255, 0, 0],
        [0, 255, 0],
        [0, 0, 255],
        [0, 0, 0],
        [0, 0, 0]],

    # Third row
       [[0, 0, 0],
        [0, 0, 0],
        [0, 0, 0],
        [0, 0, 0],
        [0, 0, 0],
        [0, 0, 0],
        [0, 0, 0],
        [0, 0, 0]],

    # Fourth row
       [[0, 0, 0],
        [0, 0, 0],
        [0, 0, 0],
        [0, 0, 0],
        [0, 0, 0],
        [0, 0, 0],
        [0, 0, 0],
        [0, 0, 0]],

    # Fifth row
       [[0, 0, 0],
        [0, 0, 0],
        [0, 0, 0],
        [0, 0, 0],
        [0, 0, 0],
        [0, 0, 0],
        [0, 0, 0],
        [0, 0, 0]]], dtype=int)

plt.imshow(arr4_img)
plt.show()

Output

Codepython

arr5_img = np.array([
    # First row
        [[255, 0, 0],
        [0, 255, 0],
        [0, 0, 255],
        [0, 0, 0],
        [0, 0, 0],
        [0, 0, 0],
        [0, 0, 0],
        [0, 0, 0]],
    
    # Second row
       [[0, 0, 0],
        [0, 0, 0],
        [0, 0, 0],
        [255, 0, 0],
        [0, 255, 0],
        [0, 0, 255],
        [0, 0, 0],
        [0, 0, 0]],

    # Third row
       [[0, 0, 255],
        [0, 0, 0],
        [0, 0, 0],
        [0, 0, 0],
        [0, 0, 0],
        [0, 0, 0],
        [0, 0, 0],
        [0, 0, 0]],

    # Fourth row
       [[0, 0, 0],
        [0, 0, 0],
        [0, 0, 0],
        [0, 0, 0],
        [0, 0, 0],
        [0, 0, 0],
        [0, 0, 0],
        [0, 0, 0]],

    # Fifth row
       [[0, 0, 0],
        [0, 0, 0],
        [0, 0, 0],
        [0, 0, 0],
        [0, 0, 0],
        [0, 0, 0],
        [0, 0, 0],
        [0, 0, 0]]], dtype=int)

plt.imshow(arr5_img)
plt.show()

Output

Codepython

if os.path.isfile(save_img_path):
    print(f"file {save_img_path} already exists")
    print(f"Deleting existing copy of {save_img_path}")
    cv2.imwrite(save_img_path, img3c2)
    print(f"Saving the image: {img3c2} \nto path: '{save_img_path}' to disk")
else: 
    cv2.imwrite(save_img_path, img3c2)
    print(f"Saving the image: {img3c2} \nto path: '{save_img_path}' to disk")

Output

file resources/saved_image.jpg already exists
Deleting existing copy of resources/saved_image.jpg
Saving the image: [[[100   0   0]
  [255   0   0]]

 [[  0 100   0]
  [  0 255   0]]

 [[  0   0 100]
  [  0   0 255]]] 
to path: 'resources/saved_image.jpg' to disk

Codepython

def save_image(img_path, image_array):
    
    if os.path.isfile(img_path):
        print(f"file {img_path} already exists")
        print(f"Deleting existing copy of {img_path}")
        cv2.imwrite(img_path, image_array)
        print(f"Saving the image: 'image_array' to path: '{img_path}' to disk")
    else: 
        cv2.imwrite(img_path, image_array)
        print(f"Saving the image: 'image_array' to path: '{img_path}' to disk")

Codepython

save_image(os.path.join("resources", "saved_img2.jpg"), img_arr)

Output

file resources/saved_img2.jpg already exists
Deleting existing copy of resources/saved_img2.jpg
Saving the image: 'image_array' to path: 'resources/saved_img2.jpg' to disk

Codepython

def cv2_plt(img_arr):
    """Function to visualize an image loaded using opencv.
    
    Parameters:
        img_arr: image array ing BGR format or say image loaded using opencv
    """
    
    img_arr = img_arr.copy()    
    image_rgb = cv2.cvtColor(img_arr, cv2.COLOR_BGR2RGB) 
    plt.imshow(image_rgb)

Codepython



start_row, start_col = int(height*0.15), int(width*0.15)
end_row, end_col = int(height*0.65), int(width*0.65)

cropped = img_arr[start_row:end_row, start_col:end_col]
cv2_plt(cropped)

Output

Codepython

def cv2_imshow(img_arr):
    """Function to visualize an image loaded using opencv.
    
    Parameters:
        img_arr: image array ing BGR format or say image loaded using opencv
    """
    
    img_arr = img_arr.copy()    
    image_rgb = cv2.cvtColor(img_arr, cv2.COLOR_BGR2RGB) 

    # plt.figure(figsize=(6,6))
    plt.imshow(image_rgb)
    plt.show()

Codepython

img = cv2.imread(tom_cruise_img_path)

cv2_imshow(img)

height, width = img.shape[0], img.shape[1]

rotate_matrix = cv2.getRotationMatrix2D(
    center=(width/2, height/2), 
    angle=90, 
    scale=1)
 
# rotate the image using cv2.warpAffine  
# 90 degree anticlockwise 
rotated_image = cv2.warpAffine( 
    src=img, M=rotate_matrix, dsize=(width, height)) 

# rotated_image = cv2.warpAffine(img, rotation_matrix, (int(width/2), int(height/2)))

cv2_imshow(rotated_image)

Output

Codepython

img = cv2.imread(tom_cruise_img_path)

cv2_imshow(img)

height, width = img.shape[0], img.shape[1]

rotate_matrix = cv2.getRotationMatrix2D(
    center=(width/2, height/2), 
    angle=90, 
    scale=0.5)
 
# rotate the image using cv2.warpAffine  
# 90 degree anticlockwise 
rotated_image = cv2.warpAffine( 
    src=img, M=rotate_matrix, dsize=(width, height)) 

cv2_imshow(rotated_image)

Output

Codepython

#filter2D(src, dst, ddepth, kernal)

img = cv2.imread(tom_cruise_img_path)

kernal = 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,1]
])

kernal = kernal/25
print(kernal)

blurred = cv2.filter2D(src=img, ddepth=-1, kernel=kernal)
cv2_plt(blurred)
plt.show()
cv2_plt(img)
plt.show()

Output

[[0.04 0.04 0.04 0.04 0.04]
 [0.04 0.04 0.04 0.04 0.04]
 [0.04 0.04 0.04 0.04 0.04]
 [0.04 0.04 0.04 0.04 0.04]
 [0.04 0.04 0.04 0.04 0.04]]

Codepython

img = cv2.imread(tom_cruise_img_path)

# Creating the kernel(2d convolution matrix) 
# This kernel is specifically used for edge detection
kernel2 = np.array([[-1, -1, -1], 
                    [-1, 8, -1], 
                    [-1, -1, -1]]) 

print(kernel2)

edge = cv2.filter2D(src=img, ddepth=-1, kernel=kernel2)
cv2_imshow(edge)

Output

[[-1 -1 -1]
 [-1  8 -1]
 [-1 -1 -1]]

Codepython

def cv2_imshow(image):
    image_rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB) 
    plt.imshow(image_rgb)
    plt.show()

img = cv2.imread(tom_cruise_img_path)

kernel3 = np.array([[0, -1, 0], 
                    [-1, 5, -1], 
                    [0, -1, 0]]) 

print(kernel3)

sharp = cv2.filter2D(src=img, ddepth=-1, kernel=kernel3)
cv2_imshow(sharp)
cv2_imshow(img)

Output

[[ 0 -1  0]
 [-1  5 -1]
 [ 0 -1  0]]

Codepython

img = cv2.imread(tom_cruise_img_path)

kernel4 = np.ones((5,5))/9

print(kernel4)

box_blur = cv2.filter2D(src=img, ddepth=-1, kernel=kernel4)
cv2_imshow(box_blur)
cv2_imshow(img)

Output

[[0.11111111 0.11111111 0.11111111 0.11111111 0.11111111]
 [0.11111111 0.11111111 0.11111111 0.11111111 0.11111111]
 [0.11111111 0.11111111 0.11111111 0.11111111 0.11111111]
 [0.11111111 0.11111111 0.11111111 0.11111111 0.11111111]
 [0.11111111 0.11111111 0.11111111 0.11111111 0.11111111]]

Codepython

img = cv2.imread(tom_cruise_img_path)

layer = img.copy() 

# Scaling down the image

for i in range(4): 
    # using pyrDown() function 
    layer = cv2.pyrDown(layer) 
  
    cv2_imshow(layer)

Output

Codepython

img = cv2.imread(tom_cruise_img_path)

cv2_imshow(img)

layer = img.copy() 

# Scaling down the image

for i in range(2): 
    # using pyrUp() function 
    layer = cv2.pyrUp(layer) 
  
    cv2_imshow(layer)

Output

Codepython


img = cv2.imread(tom_cruise_img_path)

# Setting parameter values 
t_lower = 50  # Lower Threshold 
t_upper = 150  # Upper threshold 


##################### Canny(image, T_lower, T_upper, aperture_size, L2Gradient)

# Applying the Canny Edge filter 
edge = cv2.Canny(img, t_lower, t_upper) 

cv2_imshow(edge)

Output

CookieSensei

Image manipulation opencv

Version requirements

Image as numpy array

Visualizing sample image from directory

Loading image as numpy array

Single channel image of eight

Three channel images

Practice assignment

Solution to practice assignment

Write image to disk

Define a function to save Image

Crop an image

Image Convolutions using opencv

Rotate an image

Blur the Image

Edge detection

Sharpen the Image

Box blur

Image Pyramids

Canny Edge filter in OpenCV

Thank You

Lesson resources

Finished this lesson?