OpenCV3.4 Python update (#40)

YacobBY · arpit1997 · commit e08d04a33b45 · 2018-09-20T13:33:38.000+05:30
Updated python code for OpenCV3.4, and readme file for clearer instructions.
diff --git a/README.md b/README.md
@@ -15,7 +15,7 @@ _In this project we have worked on the problem of human detection,face detection
 		`sudo apt-get install python3`
 * **python libraries:**
 	Here is a list of all the python dependencies 
-	* Python Image Library (PIL)
+	* Python Image Library (PILLOW)
 	* Imutils
 	* numpy
 
@@ -38,6 +38,15 @@ _In this project we have worked on the problem of human detection,face detection
 	* `video/` : This directory contains some of the videos that we used to while testing.
 
 ## Installation 
+
+## Python
+Don't forget to install the necessary libraries described in the install paragraph above.
+
+First you need to run the create_face_model.py file, which uses the images in /data to create a .yaml file
+* In the project folder run 
+```sh 
+python create_face_model.py
+```
 * To run the python version of the code you have to put all the input videos in one folder and then provide the path of that folder as command line argument:
 ```sh
 python3 main.py /path/to/input/videos/  
@@ -46,6 +55,8 @@ Example- for our directory structure it is:
 ```sh
  python3 main.py /video 
 ```
+
+## C++
 * To compile the C++ version of the code with openCV the command is:
 ```sh
  g++ -ggdb `pkg-config --cflags opencv` -o `basename name_of_file.cpp .cpp` name_of_file.cpp `pkg-config --libs opencv` 
diff --git a/create_face_model.py b/create_face_model.py
@@ -9,7 +9,7 @@
 
 cascadePath = "face_cascades/haarcascade_profileface.xml"
 faceCascade = cv2.CascadeClassifier(cascadePath)
-recognizer = cv2.face.createLBPHFaceRecognizer()
+recognizer = cv2.face.LBPHFaceRecognizer_create()
 
 
 def get_images_and_labels(path):
@@ -59,4 +59,4 @@ def get_images_and_labels(path):
 """
 save the trained data to cont.yaml file
 """
-recognizer.save("cont.yaml")
+recognizer.save("model.yaml")
diff --git a/main.py b/main.py
@@ -1,9 +1,10 @@
-import cv2
+import argparse
 import glob
 import os
 import time
+
+import cv2
 import imutils
-import argparse
 from imutils.object_detection import non_max_suppression
 
 subject_label = 1
@@ -13,171 +14,172 @@
 face_cascade = cv2.CascadeClassifier(cascade_path)
 hog = cv2.HOGDescriptor()
 hog.setSVMDetector(cv2.HOGDescriptor_getDefaultPeopleDetector())
-recognizer = cv2.face.createLBPHFaceRecognizer()
-count=0
+recognizer = cv2.face.LBPHFaceRecognizer_create()
+count = 0
 
-def detect_people(frame):
-	"""
-	detect humans using HOG descriptor
-	Args:
-		frame:
-	Returns:
-		processed frame
-	"""
-	(rects, weights) = hog.detectMultiScale(frame, winStride=(8, 8), padding=(16, 16), scale=1.06)
-	rects = non_max_suppression(rects, probs=None, overlapThresh=0.65)
-	for (x, y, w, h) in rects:
-		cv2.rectangle(frame, (x, y), (x + w, y + h), (0, 0, 255), 2)
-	return frame
 
+def detect_people(frame):
+    """
+    detect humans using HOG descriptor
+    Args:
+        frame:
+    Returns:
+        processed frame
+    """
+    (rects, weights) = hog.detectMultiScale(frame, winStride=(8, 8), padding=(16, 16), scale=1.06)
+    rects = non_max_suppression(rects, probs=None, overlapThresh=0.65)
+    for (x, y, w, h) in rects:
+        cv2.rectangle(frame, (x, y), (x + w, y + h), (0, 0, 255), 2)
+    return frame
 
 
 def detect_face(frame):
-	"""
-	detect human faces in image using haar-cascade
-	Args:
-		frame:
-	Returns:
-	coordinates of detected faces
-	"""
-	faces = face_cascade.detectMultiScale(frame, 1.1, 2, 0, (20, 20) )
-	return faces
+    """
+    detect human faces in image using haar-cascade
+    Args:
+        frame:
+    Returns:
+    coordinates of detected faces
+    """
+    faces = face_cascade.detectMultiScale(frame, 1.1, 2, 0, (20, 20))
+    return faces
 
 
 def recognize_face(frame_orginal, faces):
-	"""
-	recognize human faces using LBPH features
-	Args:
-		frame_orginal:
-		faces:
-	Returns:
-		label of predicted person
-	"""
-	predict_label = []
-	predict_conf = []
-	for x, y, w, h in faces:
-		frame_orginal_grayscale = cv2.cvtColor(frame_orginal[y: y + h, x: x + w], cv2.COLOR_BGR2GRAY)
-		cv2.imshow("cropped", frame_orginal_grayscale)
-		predict_tuple = recognizer.predict(frame_orginal_grayscale)
-		a, b = predict_tuple
-		predict_label.append(a)
-		predict_conf.append(b)
-		print("Predition label, confidence: " + str(predict_tuple))
-	return predict_label
+    """
+    recognize human faces using LBPH features
+    Args:
+        frame_orginal:
+        faces:
+    Returns:
+        label of predicted person
+    """
+    predict_label = []
+    predict_conf = []
+    for x, y, w, h in faces:
+        frame_orginal_grayscale = cv2.cvtColor(frame_orginal[y: y + h, x: x + w], cv2.COLOR_BGR2GRAY)
+        cv2.imshow("cropped", frame_orginal_grayscale)
+        predict_tuple = recognizer.predict(frame_orginal_grayscale)
+        a, b = predict_tuple
+        predict_label.append(a)
+        predict_conf.append(b)
+        print("Predition label, confidence: " + str(predict_tuple))
+    return predict_label
 
 
 def draw_faces(frame, faces):
-	"""
-	draw rectangle around detected faces
-	Args:
-		frame:
-		faces:
-	Returns:
-	face drawn processed frame
-	"""
-	for (x, y, w, h) in faces:
-		xA = x
-		yA = y
-		xB = x + w
-		yB = y + h
-		cv2.rectangle(frame, (xA, yA), (xB, yB), (0, 255, 0), 2)
-	return frame
+    """
+    draw rectangle around detected faces
+    Args:
+        frame:
+        faces:
+    Returns:
+    face drawn processed frame
+    """
+    for (x, y, w, h) in faces:
+        xA = x
+        yA = y
+        xB = x + w
+        yB = y + h
+        cv2.rectangle(frame, (xA, yA), (xB, yB), (0, 255, 0), 2)
+    return frame
 
 
 def put_label_on_face(frame, faces, labels):
-	"""
-	draw label on faces
-	Args:
-		frame:
-		faces:
-		labels:
-	Returns:
-		processed frame
-	"""
-	i = 0
-	for x, y, w, h in faces:
-		cv2.putText(frame, str(labels[i]), (x, y), font, 1, (255, 255, 255), 2)
-		i += 1
-	return frame
+    """
+    draw label on faces
+    Args:
+        frame:
+        faces:
+        labels:
+    Returns:
+        processed frame
+    """
+    i = 0
+    for x, y, w, h in faces:
+        cv2.putText(frame, str(labels[i]), (x, y), font, 1, (255, 255, 255), 2)
+        i += 1
+    return frame
+
 
 def background_subtraction(previous_frame, frame_resized_grayscale, min_area):
-	"""
-	This function returns 1 for the frames in which the area 
-	after subtraction with previous frame is greater than minimum area
-	defined. 
-	Thus expensive computation of human detection face detection 
-	and face recognition is not done on all the frames.
-	Only the frames undergoing significant amount of change (which is controlled min_area)
-	are processed for detection and recognition.
-	"""
-	frameDelta = cv2.absdiff(previous_frame, frame_resized_grayscale)
-	thresh = cv2.threshold(frameDelta, 25, 255, cv2.THRESH_BINARY)[1]
-	thresh = cv2.dilate(thresh, None, iterations=2)
-	im2, cnts, hierarchy = cv2.findContours(thresh.copy(), cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
-	temp=0
-	for c in cnts:
-		# if the contour is too small, ignore it
-		if cv2.contourArea(c) > min_area:
-			temp=1
-	return temp		
+    """
+    This function returns 1 for the frames in which the area
+    after subtraction with previous frame is greater than minimum area
+    defined.
+    Thus expensive computation of human detection face detection
+    and face recognition is not done on all the frames.
+    Only the frames undergoing significant amount of change (which is controlled min_area)
+    are processed for detection and recognition.
+    """
+    frameDelta = cv2.absdiff(previous_frame, frame_resized_grayscale)
+    thresh = cv2.threshold(frameDelta, 25, 255, cv2.THRESH_BINARY)[1]
+    thresh = cv2.dilate(thresh, None, iterations=2)
+    im2, cnts, hierarchy = cv2.findContours(thresh.copy(), cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
+    temp = 0
+    for c in cnts:
+        # if the contour is too small, ignore it
+        if cv2.contourArea(c) > min_area:
+            temp = 1
+    return temp
+
 
 if __name__ == '__main__':
-	"""
-	main function
-	"""
-	ap = argparse.ArgumentParser()
-	ap.add_argument("-v", "--videos", required=True, help="path to videos directory")
-	args = vars(ap.parse_args())
-	path = args["videos"]
-	for f in os.listdir(path):
-		list_of_videos = glob.glob(os.path.join(os.path.abspath(path), f))
-		print(os.path.join(os.path.abspath(path), f) + "*.mp4")
-		print(list_of_videos)
-		if os.path.exists("model.yaml"):
-			recognizer.load("model.yaml")
-			for video in list_of_videos:
-				camera = cv2.VideoCapture(os.path.join(path, video))
-				grabbed, frame = camera.read()
-				print(frame.shape)
-				frame_resized = imutils.resize(frame, width=min(800, frame.shape[1]))
-				frame_resized_grayscale = cv2.cvtColor(frame_resized, cv2.COLOR_BGR2GRAY)
-				print(frame_resized.shape)
-
-				# defining min cuoff area
-				min_area=(3000/800)*frame_resized.shape[1] 
-
-				while True:
-					starttime = time.time()
-					previous_frame = frame_resized_grayscale
-					grabbed, frame = camera.read()
-					if not grabbed:
-						break
-					frame_resized = imutils.resize(frame, width=min(800, frame.shape[1]))
-					frame_resized_grayscale = cv2.cvtColor(frame_resized, cv2.COLOR_BGR2GRAY)
-					temp=background_subtraction(previous_frame, frame_resized_grayscale, min_area)
-					if temp==1:		
-						frame_processed = detect_people(frame_resized)
-						faces = detect_face(frame_resized_grayscale)
-						if len(faces) > 0:
-							frame_processed = draw_faces(frame_processed, faces)
-							label = recognize_face(frame_resized, faces)
-							frame_processed = put_label_on_face(frame_processed, faces, label)
-
-						cv2.imshow("Detected Human and face", frame_processed)
-						key = cv2.waitKey(1) & 0xFF
-						if key == ord("q"):
-							break
-						endtime = time.time()
-						print("Time to process a frame: " + str(starttime-endtime))	
-					else:
-						count=count+1
-						print("Number of frame skipped in the video= " + str(count))
-									
-				
-				camera.release()
-				cv2.destroyAllWindows()
-				
-				
-		else:
-			print("model file not found")
-		list_of_videos = []
+    """
+    main function
+    """
+    ap = argparse.ArgumentParser()
+    ap.add_argument("-v", "--videos", required=True, help="path to videos directory")
+    args = vars(ap.parse_args())
+    path = args["videos"]
+    for f in os.listdir(path):
+        list_of_videos = glob.glob(os.path.join(os.path.abspath(path), f))
+        print(os.path.join(os.path.abspath(path), f) + "*.mp4")
+        print(list_of_videos)
+        if os.path.exists("model.yaml"):
+            recognizer.read("model.yaml")
+            for video in list_of_videos:
+                camera = cv2.VideoCapture(os.path.join(path, video))
+                grabbed, frame = camera.read()
+                print(frame.shape)
+                frame_resized = imutils.resize(frame, width=min(800, frame.shape[1]))
+                frame_resized_grayscale = cv2.cvtColor(frame_resized, cv2.COLOR_BGR2GRAY)
+                print(frame_resized.shape)
+
+                # defining min cuoff area
+                min_area = (3000 / 800) * frame_resized.shape[1]
+
+                while True:
+                    starttime = time.time()
+                    previous_frame = frame_resized_grayscale
+                    grabbed, frame = camera.read()
+                    if not grabbed:
+                        break
+                    frame_resized = imutils.resize(frame, width=min(800, frame.shape[1]))
+                    frame_resized_grayscale = cv2.cvtColor(frame_resized, cv2.COLOR_BGR2GRAY)
+                    temp = background_subtraction(previous_frame, frame_resized_grayscale, min_area)
+                    if temp == 1:
+                        frame_processed = detect_people(frame_resized)
+                        faces = detect_face(frame_resized_grayscale)
+                        if len(faces) > 0:
+                            frame_processed = draw_faces(frame_processed, faces)
+                            label = recognize_face(frame_resized, faces)
+                            frame_processed = put_label_on_face(frame_processed, faces, label)
+
+                        cv2.imshow("Detected Human and face", frame_processed)
+                        key = cv2.waitKey(1) & 0xFF
+                        if key == ord("q"):
+                            break
+                        endtime = time.time()
+                        print("Time to process a frame: " + str(starttime - endtime))
+                    else:
+                        count = count + 1
+                        print("Number of frame skipped in the video= " + str(count))
+
+                camera.release()
+                cv2.destroyAllWindows()
+
+
+        else:
+            print("model file not found")
+        list_of_videos = []
