TemplateMatching scripts

Author: Priyanka Verma

TemplateMatching/tm10.py

@@ -0,0 +1,44 @@
+import numpy as np
+import cv2
+
+#  gives an output 
+cap = cv2.VideoCapture('1ph meter video.mp4')
+
+#Set frame_no in range 0.0-1.0
+#In this example we have a video of 30 seconds having 25 frames per seconds, thus we have 750 frames.
+#The examined frame must get a value from 0 to 749.
+#For more info about the video flags see here: https://stackoverflow.com/questions/11420748/setting-camera-parameters-in-opencv-python
+#Here we select the last frame as frame sequence=749. In case you want to select other frame change value 749.
+#BE CAREFUL! Each video has different time length and frame rate. 
+#So make sure that you have the right parameters for the right video!
+# time_length = 164
+# fps=25
+# frame_seq = 749
+# frame_no = (frame_seq /(time_length*fps))
+
+#The first argument of cap.set(), number 2 defines that parameter for setting the frame selection.
+#Number 2 defines flag CV_CAP_PROP_POS_FRAMES which is a 0-based index of the frame to be decoded/captured next.
+#The second argument defines the frame number in range 0.0-1.0
+cap.set(1,2900);
+
+#Read the next frame from the video. If you set frame 749 above then the code will return the last frame.
+ret, frame = cap.read()
+
+#Set grayscale colorspace for the frame. 
+# gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
+
+#Cut the video extension to have the name of the video
+my_video_name = "1ph meter video"
+
+#Display the resulting frame
+cv2.imshow(my_video_name+ 'frame' + str(2900),frame)
+
+#Set waitKey 
+cv2.waitKey()
+
+#Store this frame to an image
+cv2.imwrite(my_video_name+'frame'+str(2900)+'.jpg',frame)
+
+# When everything done, release the capture
+cap.release()
+cv2.destroyAllWindows()

tm11.py renamed to TemplateMatching/tm11.py

@@ -0,0 +1,38 @@
+import cv2
+import numpy as np
+
+
+voltage_temp = cv2.imread('C:/Users/Win10/Documents/4th Semester Summer/GUVNL/v_bin.png')
+ampere_temp = cv2.imread('C:/Users/Win10/Documents/4th Semester Summer/GUVNL/a_bin.png')
+kW_temp = cv2.imread('C:/Users/Win10/Documents/4th Semester Summer/GUVNL/kW_bin.png')
+kWh_temp = cv2.imread('C:/Users/Win10/Documents/4th Semester Summer/GUVNL/kWh_bin.png')
+voltage_temp = cv2.cvtColor(voltage_temp,cv2.COLOR_BGR2GRAY)
+ampere_temp = cv2.cvtColor(ampere_temp,cv2.COLOR_BGR2GRAY)
+kW_temp = cv2.cvtColor(kW_temp,cv2.COLOR_BGR2GRAY)
+kWh_temp = cv2.cvtColor(kWh_temp,cv2.COLOR_BGR2GRAY)
+
+V_max = np.max(cv2.matchTemplate(screen1_gray,voltage_temp,cv2.TM_CCOEFF_NORMED))
+A_max = np.max(cv2.matchTemplate(screen1_gray,ampere_temp,cv2.TM_CCOEFF_NORMED))
+kW_max = np.max(cv2.matchTemplate(screen1_gray,kW_temp,cv2.TM_CCOEFF_NORMED))
+kWh_max = np.max(cv2.matchTemplate(screen1_gray,kWh_temp,cv2.TM_CCOEFF_NORMED))
+print"V = ", V_max
+print"A = ", A_max
+print "kW =", kW_max
+print "kWh=", kWh_max
+
+threshold = 0.9
+maxval = 0
+if(V_max>maxval):
+    symbol = "V"
+    maxval = V_max
+if(A_max>maxval):
+    symbol = "A"
+    maxval = A_max
+if(kW_max>maxval):
+    symbol = "kW"
+    maxval = kW_max
+if(kWh_max>maxval):
+    symbol = "kWh"
+    maxval = kWh_max
+if(maxval<threshold):
+    symbol = ""

TemplateMatching/tm11.py

@@ -0,0 +1,26 @@
+import cv2
+import math
+import numpy as np
+
+videoFile = '1ph meter video.mp4'
+vidcap = cv2.VideoCapture(videoFile)
+success,image = vidcap.read()   
+
+#################### Setting up parameters ################
+
+seconds = 5
+fps = vidcap.get(cv2.cv.CAP_PROP_FPS) # Gets the frames per second
+
+multiplier = fps * seconds
+
+#################### Initiate Process ################
+
+while success:
+    frameId = int(round(vidcap.get(1))) #current frame number, rounded b/c sometimes you get frame intervals which aren't integers...this adds a little imprecision but is likely good enough
+    success, image = vidcap.read()
+
+    if frameId % multiplier == 0:
+        cv2.imwrite("FolderSeconds/frame%d.jpg" % frameId, image)
+
+vidcap.release()
+print "Complete"

TemplateMatching/tm12.py

@@ -0,0 +1,36 @@
+import cv2
+import numpy as np
+import glob
+
+#  multiple templates 
+
+#empty list to store template images
+X_data = []
+#make a list of all template images from a directory
+files1= glob.glob('*.png')
+
+for myfile in files1:
+    image = cv2.imread(myfile,0)
+    X_data.append (image)
+    cv2.imshow('image',image)
+    cv2.waitKey(0)
+
+print('X_data shape:', np.array(X_data).shape)
+
+# test_image=cv2.imread('you\\testimage\\testimage.png')
+# test_image= cv2.cvtColor(test_image, cv2.COLOR_BGR2GRAY)
+
+# #loop for matching
+# for tmp in template_data:
+#     (tH, tW) = tmp.shape[:2]
+#     cv2.imshow("Template", tmp)
+#     cv2.waitKey(1000)
+#     cv2.destroyAllWindows()
+#     result = cv2.matchTemplate(test_image, tmp, cv2.TM_CCOEFF)
+#     min_val, max_val, min_loc, max_loc = cv2.minMaxLoc(result)
+#     top_left = max_loc
+#     bottom_right = (top_left[0] + tW, top_left[1] + tH)
+#     cv2.rectangle(test_image,top_left, bottom_right,255, 2)
+
+# cv2.imshow('Result',test_image)
+# cv2.waitKey(0)

TemplateMatching/tm2.py

@@ -0,0 +1,26 @@
+import cv2
+import numpy as np
+
+
+cap = cv2.VideoCapture('electric meter 2.mp4')
+# template = cv2.imread('kwh temp 3.png',0)
+# w, h = template.shape[::-1]
+while(cap.isOpened()):
+
+    _, frame = cap.read()
+    # hsv = cv2.cvtColor(frame, cv2.COLOR_BGR2HSV)
+    # vid_gray = cv2.cvtColor(frame,cv2.COLOR_BGR2GRAY)
+    
+#   res = cv2.matchTemplate(vid_gray,template,cv2.TM_CCOEFF_NORMED)
+	cv2.imshow('frame',frame)
+    k = cv2.waitKey(5) & 0xFF
+	if k == 27:
+    	break
+# threshold = 0.92
+# loc = np.where( res >= threshold)
+# for pt in zip(*loc[::-1]):
+    # cv2.rectangle(img_rgb, pt, (pt[0] + w, pt[1] + h), (0,255,255), 1) 
+    # cv2.imshow('mask',mask)
+    # cv2.imshow('res',res)
+cv2.destroyAllWindows()
+cap.release()

TemplateMatching/tm3.py

@@ -0,0 +1,32 @@
+import cv2
+import numpy as np 
+import glob  
+import imutils
+
+cap = cv2.VideoCapture('1ph meter video.mp4')
+template = cv2.imread('kw temp2.png',0)
+w, h = template.shape[::-1]
+                            
+while(cap.isOpened()):
+    ret, frame = cap.read()
+
+    gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
+    
+    res = cv2.matchTemplate(gray,template,cv2.TM_CCOEFF_NORMED)
+    threshold = 0.85
+    
+    loc = np.where( res >= threshold)
+    
+    for pt in zip(*loc[::-1]):
+    	cv2.rectangle(frame, pt, (pt[0] + w, pt[1] + h), (0,255,255), 1) 
+    cv2.imshow('frames',frame)
+    cv2.imshow('temp',template)
+	# cv2.waitKey(0)
+    # if cv2.waitKey(5) & 0xFF == ord('q'):       // doesn't exit with escape key
+        # break  // 
+    k = cv2.waitKey(1) & 0xFF       
+    if k == 27:
+        break
+
+cap.release()
+cv2.destroyAllWindows()

TemplateMatching/tm4.py

@@ -0,0 +1,48 @@
+import cv2
+import numpy as np
+import glob  
+import imutils
+# Read the main image
+img_rgb = cv2.imread('kwh i3.jpg')
+  
+# Convert to grayscale
+img_gray = cv2.cvtColor(img_rgb, cv2.COLOR_BGR2GRAY)
+# Read the templatex
+template = cv2.imread('kw temp2.png',0)
+  
+# Store width and heigth of template in w and h
+w, h = template.shape[::-1]
+found = None
+
+for scale in np.linspace(1, .05, 30)[::-1]:
+ 
+    # resize the image according to the scale, and keep track
+    # of the ratio of the resizing
+    resized = imutils.resize(template, width = int(template.shape[1] * scale))
+    r = template.shape[1] / float(resized.shape[1])
+  
+    # if the resized image is smaller than the template, then break
+    # from the loop
+    # detect edges in the resized, grayscale image and apply template 
+    # matching to find the template in the image 
+    edged = cv2.Canny(img_gray, 50, 200) 
+    result = cv2.matchTemplate(template,img_gray, cv2.TM_CCOEFF)
+    threshold = 0.85
+    (_, maxVal, _, maxLoc) = cv2.minMaxLoc(result)
+    # if we have found a new maximum correlation value, then update
+    # the found variable if found is None or maxVal > found[0]:
+    # if resized.shape[0] < h or resized.shape[1] < w:
+        # break
+    found = (maxVal, maxLoc, r)
+ #                                                                    //no threshold value ? ? 
+# unpack the found varaible and compute the (x, y) coordinates
+# of the bounding box based on the resized ratio
+(_, maxLoc, r) = found
+(startX, startY) = (int(maxLoc[0] * r), int(maxLoc[1] * r))
+(endX, endY) = (int((maxLoc[0] + w) * r), int((maxLoc[1] + h) * r))
+ 
+# draw a bounding box around the detected result and display the image
+cv2.rectangle(img_rgb, (startX, startY), (endX, endY), (0, 0, 255), 2)
+cv2.imshow('img_rgb',img_rgb)
+cv2.imshow('template',template)
+cv2.waitKey(0)

TemplateMatching/tm5.py

@@ -0,0 +1,50 @@
+import cv2
+import numpy as np
+import glob  
+import imutils
+
+# Read the main image
+img_rgb = cv2.imread('kwh i3.jpg')
+  
+# Convert to grayscale
+img_gray = cv2.cvtColor(img_rgb, cv2.COLOR_BGR2GRAY)
+
+# Read the templatex
+template = cv2.imread('kw temp2.png',0)
+  
+# Store width and heigth of template in w and h
+w, h = template.shape[::-1]
+found = None
+
+for scale in np.linspace(.3, 1, 5)[::-1]:
+ 
+    # resize the image according to the scale, and keep track
+    # of the ratio of the resizing
+    resized = imutils.resize(template, width = int(template.shape[1] * scale))
+    r = template.shape[1] / float(resized.shape[1])
+    cv2.imshow('resized',resized)
+    # if the resized image is smaller than the template, then break
+    # from the loop
+    # detect edges in the resized, grayscale image and apply template 
+    # matching to find the template in the image 
+    edged = cv2.Canny(img_gray, 50, 200) 
+    result = cv2.matchTemplate(template,img_gray, cv2.TM_CCOEFF)
+    threshold = 0.85
+    (_, maxVal, _, maxLoc) = cv2.minMaxLoc(result)
+    # if we have found a new maximum correlation value, then update
+    # the found variable if found is None or maxVal > found[0]:
+    # if resized.shape[0] < h or resized.shape[1] < w:
+        # break
+    found = (maxVal, maxLoc, r)
+ #                                                                    //no threshold value ? ? 
+# unpack the found varaible and compute the (x, y) coordinates
+# of the bounding box based on the resized ratio
+(_, maxLoc, r) = found
+(startX, startY) = (int(maxLoc[0] * r), int(maxLoc[1] * r))
+(endX, endY) = (int((maxLoc[0] + w) * r), int((maxLoc[1] + h) * r))
+ 
+# draw a bounding box around the detected result and display the image
+cv2.rectangle(img_rgb, (startX, startY), (endX, endY), (0, 0, 255), 2)
+cv2.imshow('img_rgb',img_rgb)
+cv2.imshow('template',template)
+cv2.waitKey(0)

TemplateMatching/tm6.py

@@ -0,0 +1,36 @@
+import cv2
+import numpy as np
+import glob  
+import imutils 
+
+#kwh 
+# detects kW for V template @ .85 and @.9
+#runs slow at .91 onwards , detects only V frame : ask mayur to check 
+cap = cv2.VideoCapture('1phmetervideo.mp4')
+template = cv2.imread("3vtemp2.png",0)
+w, h = template.shape[::-1]
+
+# for scale in np.linspace(.35, 1, 5)[::-1]:
+resized = imutils.resize(template, width = int(template.shape[1] * .35))
+r = template.shape[1] / float(resized.shape[1])
+
+while(cap.isOpened()):
+    ret, frame = cap.read()
+
+    gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
+    res = cv2.matchTemplate(gray,resized,cv2.TM_CCOEFF_NORMED)
+    threshold = 0.85
+
+    loc = np.where( res >= threshold)
+    for pt in zip(*loc[::-1]):
+    	cv2.rectangle(frame, pt, (pt[0] + int(w*0.35), pt[1] + int(h*0.35)), (0,255,255), 1) 
+ 	cv2.imshow('frame',frame)
+	cv2.imshow('resized',resized)
+	cv2.imshow('template',template)
+	
+    k = cv2.waitKey(1) & 0xFF       
+    if k == 27:
+        break
+        
+cap.release()
+cv2.destroyAllWindows()

TemplateMatching/tm7.py

@@ -0,0 +1,44 @@
+import cv2
+import numpy as np
+ 
+
+cap= cap = cv2.VideoCapture('1ph meter video.mp4')
+ 
+while True:
+    ret, frame = cap.read()
+    blurred_frame = cv2.GaussianBlur(frame, (5, 5), 0)
+    hsv = cv2.cvtColor(blurred_frame, cv2.COLOR_BGR2HSV)
+ 
+    lower_green = np.array([50, 155, 155])
+    upper_green = np.array([70, 255, 255])
+    mask = cv2.inRange(hsv, lower_green, upper_green)
+ 
+contours, hierarchy  = cv2.findContours(mask, cv2.RETR_TREE, cv2.CHAIN_APPROX_NONE)
+ 
+    #for contour in contours:
+        #area = cv2.contourArea(contour)
+ 
+       # if area > 5000:
+    #cv2.drawContours(frame, contours, -1, (0, 0, 255), 3)
+    
+    
+    #find the biggest area
+c = max(contours, key = cv2.contourArea)
+
+x,y,w,h = cv2.boundingRect(c)
+    # draw the reading area contour (in blue)
+im=cv2.rectangle(frame,(x,y),(x+w,y+h),(255,0,0),2)
+    
+roi=im[y:y+h,x:x+w]
+    
+    
+cv2.imshow("Frame", frame)
+# cv2.imshow("Mask", mask)
+cv2.imshow("Result",roi)
+
+key = cv2.waitKey(1)
+if key == 27:
+   break
+ 
+cap.release()
+cv2.destroyAllWindows()