Category Archives: Lab Work

Assignment 2 – Where’s Wally

Posted on by

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
# Gavin Morrison - D12124782 - DT211C-4
 
# 1. I inputted the image and converted it to Greyscale and HSV for the
# operations within the program.
 
# 2. I created a Numpy array of the upper and lower red values of our
# HSV image
 
# 3. I created a mask of the red values
 
# 4. Red content of the image is isolated via a Bitwise 'And' operation
 
# 5. The Greyscale image is inverted
 
# 6. A Binary threshold is applied to our inverted Greyscale image.
 
# 7. The thresholded image is then submitted to another bitwise
# inversion which produces the white content of the image.
 
# 8. The isolated red and white content are combined.
 
# 9. The red and white components of the original image are dilated to
# produce a slight overlap allowing the detection of connected regions.
 
# 10. The dilated images are 'Anded' to produce an image of only the
# overlapping regions.
 
# 11. Canny is applied to detect edges within the image of connected regions.
 
# 12. A Hough Line Transform is applied to the results of Canny to try and
# find the horizontal lines within Wally's sweater.
 
# 13. Wally is located. Please see comments throughout the code for further
# step by step details.
 
# I initially tried using Contours to locate Wally but I had very limited
# results owing to the low resolution of Wally within the overall image.
 
import numpy as np
import cv2
from matplotlib import pyplot as plt
from matplotlib import image as image
 
# Original image is imported
originalImage = cv2.imread("Where.jpg")
 
# Original image is converted to greyscale for white segmentation.
originalImageGrey = cv2.cvtColor(originalImage, cv2.COLOR_BGR2GRAY)
 
# Original image is converted to a HSV Image for red segmentation.
HSVImage = cv2.cvtColor(originalImage, cv2.COLOR_BGR2HSV)
 
# A Numpy array is created of upper and lower red values.
lowerRedValue = np.array([139,100,100])
upperRedValue = np.array([189,255,255])
 
# Mask is created of all red values.
redMask = cv2.inRange(HSVImage, lowerRedValue, upperRedValue)
 
# The red content of the image is isolated.
redContent = cv2.bitwise_and(originalImage,originalImage, mask= redMask)
 
# The Greyscale image is inverted via bitwise.
greyInverted = cv2.bitwise_not(originalImageGrey)
 
# A binary threshold is applied to the inverted greyscale image.
T = 20
T, binaryInvertedGreyscale = cv2.threshold(greyInverted, thresh = T, maxval = 255,
type = cv2.THRESH_BINARY)
 
# This bitwise not operation creates the white content image.
whiteContent = cv2.bitwise_not(binaryInvertedGreyscale)
 
# white and red segmented images are written to file and the images inputed.
cv2.imwrite("white.png", whiteContent)
cv2.imwrite("red.png", redContent)
redImage = cv2.imread("red.png")
whiteImage = cv2.imread("white.png")
 
#The red and white images are combined together and written to file.
redWhiteCombined = redImage + whiteImage
cv2.imwrite("combined.png", redWhiteCombined)
 
# Dilation is perfomed on red and white images to create a slight overlap to allow the location of where red and white are connected.
whiteKernel = np.ones((2,1), np.uint8)
redKernel = np.ones((2,1), np.uint8)
whiteDilation = cv2.dilate(whiteContent, whiteKernel, iterations=1)
redDilation = cv2.dilate(redMask, redKernel, iterations=1)
 
# Dilated images are combined in 'And' operation which isolates connecting areas between red and white
connectedRegions = whiteDilation & redDilation
 
# Connected regions written to file and then inputed
cv2.imwrite("connectedregions.png", connectedRegions)
connectedRegionsImage = cv2.imread("connectedregions.png")
 
# The connected regions are converted to greyscale.
connectedGreyscale = cv2.cvtColor(connectedRegionsImage, cv2.COLOR_BGR2GRAY)
 
# The edges are located on the connected regions.
connectedEdges = cv2.Canny(connectedGreyscale, 500, 300)
 
# A Hough Line Transform is applied that scans the image for lines in the hope that
# it will locate the stripes on Wally's sweater.
houghLines = cv2.HoughLinesP(connectedEdges, 1, np.pi/90, 30, maxLineGap=2)
 
#For loop plotting location of lines found in image.
for line in houghLines:
    x1, y1, x2, y2 = line[0]
    cv2.line(connectedRegionsImage, (x1, y1), (x2, y2), (255, 255, 255), 90)
 
# Location written to file and inputed
cv2.imwrite('wallylocation.png',connectedRegionsImage)
wallyLocation = cv2.imread("wallylocation.png")
 
# Location found is combined with original image in 'And' operation and written to file.
wallyFound = wallyLocation & originalImage
cv2.imwrite('wallyfound.png',wallyFound)
 
# Colour space conversions for matPlotLib display.
OImatPlotLib = cv2.cvtColor(originalImage, cv2.COLOR_BGR2RGB)
RCmatPlotLib = cv2.cvtColor(redContent, cv2.COLOR_BGR2RGB)
RWmatPlotLib = cv2.cvtColor(redWhiteCombined, cv2.COLOR_BGR2RGB)
WFmatPlotLib = cv2.cvtColor(wallyFound, cv2.COLOR_BGR2RGB)
 
# A display of the result of our operations
plt.subplot(231), plt.imshow(OImatPlotLib, cmap ='gray'), plt.title( 'Original Image' )
plt.subplot(232), plt.imshow(whiteContent, cmap ='gray'), plt.title( 'White Content' )
plt.subplot(233), plt.imshow(RCmatPlotLib, cmap ='gray'), plt.title( 'Red Content' )
plt.subplot(234), plt.imshow(RWmatPlotLib, cmap ='gray'), plt.title( 'Red & White combined' )
plt.subplot(235), plt.imshow(connectedRegions, cmap ='gray'), plt.title( 'Connected Regions' )
plt.subplot(236), plt.imshow(WFmatPlotLib, cmap ='gray'), plt.title( 'Wally Found' )
plt.show()

 

Week 9 – Lab Work

Posted on by

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
# 1. Open 'Sudoku.jpg';
 
# 2. Create a Harris corner image for this image;
 
# 3. Use Shi-Tomasi to find the location of the strongest corners.
 
import numpy as np
import cv2
from matplotlib import pyplot as plt
from matplotlib import image as image
import easygui
 
I = cv2.imread("sudoku.jpg")
 
gray = cv2.cvtColor(I,cv2.COLOR_BGR2GRAY)
# Harris Corner code
gray = np.float32(gray)
dst = cv2.cornerHarris(gray,2,3,0.04)
 
#result is dilated for marking the corners, not important
dst = cv2.dilate(dst,None)
 
# Threshold for an optimal value, it may vary depending on the image.
I[dst>0.01*dst.max()]=[0,0,255]
 
# Shi-Tomasi code
corners = cv2.goodFeaturesToTrack(gray,25,0.01,10)
corners = np.int0(corners)
 
for i in corners:
    x,y = i.ravel()
    cv2.circle(I,(x,y),3,255,-1)
 
# plt.imshow(I),plt.show()
 
cv2.imshow('dst',I)
# cv2.imshow("Shi-Tomasi", K)
key = cv2.waitKey(0)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
# 1. Open "Micro.jpg";
 
# 2. Use either thresholding or edge detection to create a binary mask;
 
# 3. Extract and draw the boundary of the cell by finding the largest
# contour in the image.
 
import numpy as np
import cv2
from matplotlib import pyplot as plt
from matplotlib import image as image
import easygui
 
im = cv2.imread('Micro.jpg')
imgray = cv2.cvtColor(im,cv2.COLOR_BGR2GRAY)
ret,thresh = cv2.threshold(imgray,127,255,0)
im2, contours, hierarchy = cv2.findContours(thresh,cv2.RETR_TREE,cv2.CHAIN_APPROX_SIMPLE)
 
cv2.drawContours(im, contours, -1, (0,255,0), 3)
 
# create hull array for convex hull points
hull = []
# calculate points for each contour
for i in range(len(contours)):
    # creating convex hull object for each contour
    hull.append(cv2.convexHull(contours[i], False))
 
# draw contours and hull points
for i in range(len(contours)):
    color_contours = (0, 0, 255) # green - color for contours
    color = (255, 0, 0) # blue - color for convex hull
    # draw with contour
    cv2.drawContours(im, contours, i, color_contours, 1, 8, hierarchy)
    # draw with convex hull object
    cv2.drawContours(im, hull, i, color, 1, 8)
 
cv2.imshow('Combined',im)
key = cv2.waitKey(0)

 

Week 8 – Lab Work

Posted on by

This week Features and Corners.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
# 1. Open any image;
 
# 2. Use Sobel to find the horizontal and vertical gradients;
 
# 3. Create an edge mask using Canny (255 for edges 0 for not);
 
# 4. On the edges, show the magnitude of the gradients.
 
# Advanced Task: Devise a way to visualise the direction of the gradients on the edges.
 
import numpy as np
import cv2
from matplotlib import pyplot as plt
from matplotlib import image as image
import easygui
 
I = cv2.imread("ball.jpg")
 
G = cv2.cvtColor(I, cv2.COLOR_BGR2GRAY)
 
Ix = cv2.Sobel(G,ddepth=cv2.CV_64F,dx=1,dy=0)
Iy = cv2.Sobel(G,ddepth=cv2.CV_64F,dx=0,dy=1)
 
M = np.sqrt(Ix*Ix + Iy*Iy)
 
# D = np.arctan(Iy/Ix)
 
E = cv2.Canny(G,threshold1=100,threshold2=200)
 
F = cv2.bitwise_and(Ix,Iy,mask=E)
 
# plt.figure()
# plt.subplot(2,3,2)
# plt.imshow(Ix)
# plt.subplot(2,3,1)
# plt.imshow(Iy)
# plt.subplot(2,3,3)
# plt.imshow(E)
# plt.show()
# cv2.imshow("image", F)
# key = cv2.waitKey(0)
 
plt.subplot(231), plt.imshow(G, cmap ='gray')
plt.subplot(232), plt.imshow(Ix, cmap ='gray')
plt.subplot(233), plt.imshow(Iy, cmap ='gray')
plt.subplot(234), plt.imshow(E, cmap ='gray')
plt.subplot(235), plt.imshow(F, cmap ='gray')
plt.subplot(236), plt.imshow(M, cmap ='gray')
plt.show()

 

Week 6 – Lab Work

Posted on by

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
# 1. Open image Googly.jpg;
 
# 2. Use thresholding to separate Googly and his friend from the background;
 
# 3. Use statistical analysis to choose a threshold for better results;
 
# 4. Try multiple thresholds on different channels.
 
import numpy as np
import cv2
from matplotlib import pyplot as plt
from matplotlib import image as image
import easygui
 
I = cv2.imread("googly.jpg", cv2.IMREAD_GRAYSCALE)
 
# I = cv2.imread("image.jpg")
 
# RGB = cv2.cvtColor(I, cv2.COLOR_BGR2RGB)
 
T = 100
T, B = cv2.threshold(I, thresh = T, maxval = 255,
type = cv2.THRESH_BINARY)
 
cv2.imshow("Googly", B)
key = cv2.waitKey(0)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
# 1. Open image sudoku.jpg
 
# 2. Use adaptive thresholding to create a black & white image;
 
# 3. Modify the region size and constant for better results.
 
import numpy as np
import cv2
from matplotlib import pyplot as plt
from matplotlib import image as image
import easygui
 
I = cv2.imread("sudoku.jpg", cv2.IMREAD_GRAYSCALE)
 
J = cv2.adaptiveThreshold(I, maxValue = 255,
  adaptiveMethod = cv2.ADAPTIVE_THRESH_GAUSSIAN_C,
  thresholdType = cv2.THRESH_BINARY,
  blockSize = 5, C = 15)
  
cv2.imshow("Sudoku", J)
key = cv2.waitKey(0)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
# 1. Open image Orange.png;
 
# 2. Using thresholding, create a mask with the orange as ROI;
 
# 3. Use this mask to extract the orange from the image;
 
# 4. Open Water.jpg;
 
# 5. Use the inverse of the orange mask to cut an orange-shaped hole in
# the water picture;
 
# 6. Combine the orange and water masked images to create a
# composite image.
 
import numpy as np
import cv2
from matplotlib import pyplot as plt
from matplotlib import image as image
import easygui
 
I = cv2.imread("orange.png")
Z = cv2.imread("water.jpg")
G = cv2.cvtColor(I, cv2.COLOR_BGR2GRAY)
 
J = cv2.bitwise_not(G)
 
T = 20
T, B = cv2.threshold(J, thresh = T, maxval = 255,
type = cv2.THRESH_BINARY)
 
K = cv2.bitwise_not(B)
 
ROI = cv2.bitwise_and(I,I,mask=B)
 
ROI2 = cv2.bitwise_and(Z,Z,mask=K)
 
ROI3 = cv2.bitwise_or(ROI,ROI2)
 
cv2.imshow("Composite", ROI3)
key = cv2.waitKey(0)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
# 1. Open Trump.jpg;
 
# 2. Use an appropriate colour space and range to segment out areas of
# flesh (you will need to research this);
 
# 3. Use morphological processes to clean up the ROI.
 
import numpy as np
import cv2
from matplotlib import pyplot as plt
from matplotlib import image as image
import easygui
 
I = cv2.imread("trumpcopy.jpg")
 
HSV = cv2.cvtColor(I, cv2.COLOR_BGR2HSV)
 
# A Numpy array is created of upper and lower fleshtone values.
lowerFleshValue = np.array([3, 48, 80])
upperFleshValue = np.array([20, 255, 255])
# Mask is created of all fleshtone values.
fleshMask = cv2.inRange(HSV, lowerFleshValue, upperFleshValue)
 
# Structuring element
shape = cv2.getStructuringElement(cv2.MORPH_RECT,(6,6))
 
# Closing
# newMask = cv2.dilate(fleshMask,shape)
# newerMask = cv2.erode(newMask,shape)
 
# Opening
# newestMask = cv2.erode(newerMask,shape)
# mostNewestMask = cv2.dilate(newestMask,shape)
 
newMask = cv2.morphologyEx(fleshMask,cv2.MORPH_CLOSE,shape)
newerMask = cv2.morphologyEx(newMask,cv2.MORPH_OPEN,shape)
boundary = cv2.morphologyEx(newerMask,cv2.MORPH_GRADIENT,shape)
 
C = cv2.bitwise_and(I,I,mask=newerMask)
 
cv2.imshow("Original", I)
cv2.imshow("HSV", HSV)
cv2.imshow("Mask", fleshMask)
cv2.imshow("Closing", newMask)
cv2.imshow("Opening", newerMask)
cv2.imshow("Boundary", boundary)
cv2.imshow("Combined", C)
key = cv2.waitKey(0)

 

Assignement 1 – Lighting

Posted on by

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
# To accomplish this task I did the following:
 
# Stage 1. I converted the image to grayscale.
 
# Stage 2. I then applied Contrast Limited Adaptive Histogram  
# Equalization to try and correct the uneven lighting on the page.
 
# Stage 3. I then applied an Adaptive Threshold which turned
# the information on the page black or white and therefore
# getting rid of a lot of detail making the text unreadable.
# So I ended up using the threshold just to assist canny find
# the edges of the ROI.
 
# Stage 4. I used the opencv'canny' function to find the edges of my
# ROI (Region of Interest)
 
# Stage 5. I used the numpy 'argwhere' function to crop the image
# using the edges located by the 'canny' function.
 
# Final stage. I output a copy of the corrected image and display
# the corrected image on screen.
 
# Summary: I was hoping that my result would be a crisp white
# background with clear black text in the foreground, but as the
# priority was to make the text easier to read I had to make a
# call with that in mind, so in terms of contrast, I think my
# program has provided results somewhere in the middle, but
# the text is definitely more readable.
 
import numpy as np
import cv2
from matplotlib import pyplot as plt
from matplotlib import image as image
import easygui
 
stage1 = cv2.imread("text.jpg", cv2.IMREAD_GRAYSCALE)
 
stage2a = cv2.createCLAHE(clipLimit = 2.0, tileGridSize = (8, 8))
stage2b = stage2a.apply(stage1)
 
stage3 = cv2.adaptiveThreshold(stage2b, maxValue = 255,
  adaptiveMethod = cv2.ADAPTIVE_THRESH_GAUSSIAN_C,
  thresholdType = cv2.THRESH_BINARY,
  blockSize = 5, C = 15)
 
height = np.size(stage3, 0)
width = np.size(stage3, 1)
 
stage4 = cv2.Canny(stage3, height, width)
 
stage5a = stage4 > 0
 
stage5b = np.argwhere(stage5a)
 
horiz0, vertic0 = stage5b.min(axis = 0)
horiz1, vertic1 = stage5b.max(axis = 0) + 1
 
stage5d = stage2b[horiz0: horiz1, vertic0: vertic1]
 
cv2.imwrite('Corrected_image.jpg', stage5d)
 
cv2.imshow("Corrected Image", stage5d)
key = cv2.waitKey(0)

 

Week 5 – Lab Work

Posted on by

Today we explored kernels in more depth.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
# 1. Open any image;
 
# 2. Build a kernel for sharpening an image
# (you will need to research this);
 
# 3. Apply this filter to the image.
 
import numpy as np
import cv2
from matplotlib import pyplot as plt
from matplotlib import image as image
import easygui
 
I = cv2.imread("Lenna.png")
 
G = cv2.cvtColor(I, cv2.COLOR_BGR2GRAY)
 
k = np.array([[0,-1,0], [-1,5,-1], [0,-1,0]],
dtype=float)
 
F = cv2.filter2D(G,ddepth=-1,kernel=k)
 
cv2.imshow("image", F)
key = cv2.waitKey(0)

The second part of this lab was used to finish off our first modules .assignment.

Week 4 – Lab Material

Posted on by

Transformation along with more image adjustments such as cropping, rotating, scaling. We also covered image Math such as adding, dividing, subtraction and multiplication. Finally we had in introduction to Kernels, yikes…

Code for the lab tasks:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
# For finding the size of an image
 
import numpy as np
import cv2
from matplotlib import pyplot as plt
from matplotlib import image as image
import easygui
 
# I = cv2.imread("orange.png")
J = cv2.imread("water.jpg")
 
# Getting the size of the image:
size = np.shape(J)
# size = np.shape(J)
 
print size
 
# orange.png 360L, 630L, 3L
# water.jpg 360L, 630L, 3L

 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
1. Open image "Wartime.jpg";
 
2. View its histogram alongside the image;
 
3. Use histogram equalisation to improve its contrast;
 
4. View the new histogram alongside the new image.
 
import numpy as np
import cv2
from matplotlib import pyplot as plt
from matplotlib import image as image
import easygui
 
I = cv2.imread("wartime.jpg")
G = cv2.cvtColor(I, cv2.COLOR_BGR2GRAY)
 
plt.figure()
plt.subplot(2,2,1)
 
plt.imshow(I)
plt.subplot (2,2,3)
H =cv2.equalizeHist(G)
plt.imshow(H)
 
 
Values = G.ravel()
plt.subplot(2,2,2)
plt.hist(Values,bins =256,range=[0,256]);
Values = H.ravel()
plt.subplot(2,2,4)
plt.hist(Values,bins =256,range=[0,256]);
plt.show()

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
# 1. Open any image;
 
# 2. Crop out the fourth quadrant of the image;
 
# 3. Rotate this cropped section by 45 degrees
 
import numpy as np
import cv2
from matplotlib import pyplot as plt
from matplotlib import image as image
import easygui
 
I = cv2.imread("colors.jpg")
 
C = I[90:180,135:270]
 
M = cv2.getRotationMatrix2D(center=(150,5),
angle=45, scale=1)
R = cv2.warpAffine(C, M = M, dsize=(270,180))
 
cv2.imshow("image", R)
 
key = cv2.waitKey(0)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
# 1. Open images Orange and Water;
# 2. Scale each image to 50 % by multiplying each by 0.5;
# 3. Add the two scaled images to get a composite image;
# 4. Adjust the scaling to give a nicer output.
 
import numpy as np
import cv2
from matplotlib import pyplot as plt
from matplotlib import image as image
import easygui
 
I = cv2.imread("orange.png")
J = cv2.imread("water.jpg")
 
# doesn't accept float so couldn't mulitple by 0.5
h, w, d = I.shape
S = cv2.resize(I, dsize=(2*w, 2*h))
 
# doesn't accept float so couldn't mulitple by 0.5
h, w, d = J.shape
T = cv2.resize(J, dsize=(2*w, 2*h))
 
M = cv2.add(S,T)
 
cv2.imshow("M", M)
cv2.imshow("S", S)
cv2.imshow("T", T)
key = cv2.waitKey(0)

 

Week 3 – Drawing on images & Thresholding

Posted on by

This week we performed further image manipulation in the form of adding, circles and lines and borders on images loaded into OpenCV. We also looked into Threholding and were introduced to the Histogram in relation to image Processing.

Code for the lab tasks.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
# 1. Open a user-selected image;
 
# 2. Show this image on the screen;
 
# 3. Capture the user’s click on the image;
 
import numpy as np
import cv2
from matplotlib import pyplot as plt
from matplotlib import image as image
import easygui
 
I = cv2.imread("colors.jpg")
 
Original = I.copy()
 
def draw(event,x,y,flags,param):
if event == cv2.EVENT_LBUTTONDOWN:
cv2.circle(img = I, center = (x,y),radius = 5, color = (255,255,255), thickness = -1)
cv2.imshow("image", I)
cv2.namedWindow("image")
cv2.setMouseCallback("image", draw)
cv2.imshow("image", I)
key = cv2.waitKey(0)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
# 4. Draw a 201 x 201, 5-pixel thick red square around this location;
 
# 5. Convert the pixels within the square to YUV.
 
import numpy as np
import cv2
from matplotlib import pyplot as plt
from matplotlib import image as image
import easygui
 
I = cv2.imread("colors.jpg")
 
YUV = cv2.cvtColor(I, cv2.COLOR_BGR2YUV)
 
cv2.rectangle(img = I, pt1 = (4,4), pt2 = (270,177), color = (0,0,255), thickness = 10)
 
cv2.imshow("image", I)
key = cv2.waitKey(0)

 

Week 2 -Lab Material

Posted on by
Reply

This week we recapped on the theory we we learned last week and got some practical experience with OpenCV.

We got to explore various colour spaces along with some basic manipulation of images that we loaded into and exported from the system, as was reflected within the lab tasks.

Task 1

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
# 1. Read in any image
 
# Also saves read image as "imagecopy"
 
import numpy as np
import cv2
from matplotlib import pyplot as plt
from matplotlib import image as image
import easygui
 
I = cv2.imread("colors.jpg")
 
cv2.imwrite("imagecopy.jpg",I)
 
cv2.imshow("image", I)
key = cv2.waitKey(0)

 

Task 2

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
# 2. Convert the image to YUV
 
import numpy as np
import cv2
from matplotlib import pyplot as plt
from matplotlib import image as image
import easygui
 
I = cv2.imread("colors.jpg")
YUV = cv2.cvtColor(I, cv2.COLOR_BGR2YUV)
 
cv2.imwrite("imageYUV.jpg",I)
 
cv2.imshow("cvtColor", I)
key = cv2.waitKey(0)

 

Task 3

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
# 3. Extract the y Channel (Luminance)
 
import numpy as np
import cv2
from matplotlib import pyplot as plt
from matplotlib import image as image
import easygui
 
I = cv2.imread("colors.jpg")
YUV = cv2.cvtColor(I, cv2.COLOR_BGR2YUV)
 
cv2.imshow("Y", YUV[:, :, 0])
# cv2.imshow("U", YUV[:, :, 1])
# cv2.imshow("V", YUV[:, :, 2])
key = cv2.waitKey(0)
 
# Alternative method
# y,u,v = cv2.split(YUV)
# cv2.imshow("Y", y)
# cv2.imshow("U", u)
# cv2.imshow("V", v)
# key = cv2.waitKey(0)

 

Task 4

1
2
3
4
5
6
7
8
9
10
11
12
13
# 4. Convert the original image to grayscale (intensity)
 
import numpy as np
import cv2
from matplotlib import pyplot as plt
from matplotlib import image as image
import easygui
 
I = cv2.imread("colors.jpg")
J = cv2.cvtColor(I, cv2.COLOR_BGR2GRAY)
 
cv2.imshow("image", J)
key = cv2.waitKey(0)

 

Task 5

1
2
3
4
5
6
7
8
9
10
11
12
13
14
# 5. Show the two on the screen using OpenCV's imshow function
 
import numpy as np
import cv2
from matplotlib import pyplot as plt
from matplotlib import image as image
import easygui
 
I = cv2.imread("colors.jpg")
J = cv2.cvtColor(I, cv2.COLOR_BGR2GRAY)
 
cv2.imshow("image1", J)
cv2.imshow("image2", I)
key = cv2.waitKey(0)