10 directories, 11 files

1# import the necessary packages
2from imutils import paths
3import face_recognition
4import argparse
5import pickle
6import cv2
7import os

1 # construct the argument parser and parse the arguments
2 ap = argparse.ArgumentParser()
3 ap.add_argument("-i", "--dataset", required=True,
4 help="path to input directory of faces + images")
5 ap.add_argument("-e", "--encodings", required=True,
6 help="path to serialized db of facial encodings")
7 ap.add_argument("-d", "--detection-method", type=str, default="cnn",
8 help="face detection model to use: either `hog` or `cnn`")
9 args = vars(ap.parse_args())

1 # grab the paths to the input images in our dataset
2 print("[INFO] quantifying faces...")
3 imagePaths = list(paths.list_images(args["dataset"]))
4
5 # initialize the list of known encodings and known names
6 knownEncodings = []
7 knownNames = []

1 # loop over the image paths
2 for (i, imagePath) in enumerate(imagePaths):
3 # extract the person name from the image path
4 print("[INFO] processing image {}/{}".format(i + 1,
5 len(imagePaths)))
6 name = imagePath.split(os.path.sep)[-2]
7
8 # load the input image and convert it from BGR (OpenCV ordering)
9 # to dlib ordering (RGB)
10 image = cv2.imread (imagePath)
11 rgb = cv2.cvtColor (image, cv2.COLOR_BGR2RGB)

1 # detect the (x, y)-coordinates of the bounding boxes
2 # corresponding to each face in the input image
3 boxes = face_recognition.face_locations(rgb,
4 model=args[" detection_method"])
5
6 # compute the facial embedding for the face
7 encodings = face_recognition.face_encodings(rgb, boxes)
8
9 # loop over the encodings
10 for encoding in encodings:
11 # add each encoding + name to our set of known names and
12 # encodings
13 knownEncodings.append (encoding)
14 knownNames.append (name)

1 # dump the facial encodings + names to disk
2 print("[INFO] serializing encodings...")
3 data = {"encodings": knownEncodings, "names": knownNames}
4 f = open(args[" encodings"], "wb")
5 f.write(pickle.dumps(data))
6 f.close()

1 $ python encode_faces.py --dataset dataset --encodings encodings.pickle
2 [INFO] quantifying faces...
3 [INFO] processing image 1/218
4 [INFO] processing image 2/218
5 [INFO] processing image 3/218
6 ...
7 [INFO] processing image 216/218
8 [INFO] processing image 217/218
9 [INFO] processing image 218/218
10 [INFO] serializing encodings...
11 $ ls -lh encodings*
12 -rw-r--r--@ 1 adrian staff 234K May 29 13:03 encodings.pickle

1 # import the necessary packages
2 import face_recognition
3 import argparse
4 import pickle
5 import cv2
6
7 # construct the argument parser and parse the arguments
8 ap = argparse.ArgumentParser()
9 ap.add_argument ("-e", "--encodings", required=True,
10 help="path to serialized db of facial encodings")
11 ap.add_argument ("-i", "--image", required=True,
12 help="path to input image")
13 ap.add_argument ("-d", " --detection-method", type=str, default="cnn",
14 help="face detection model to use: either `hog` or `cnn`")
15 args = vars(ap.parse_args())

1 # load the known faces and embeddings
2 print("[INFO] loading encodings...")
3 data = pickle.loads (open(args["encodings"], "rb").read())
4
5 # load the input image and convert it from BGR to RGB
6 image = cv2.imread (args["image"])
7 rgb = cv2.cvtColor (image, cv2.COLOR_BGR2RGB)
8
9 # detect the (x, y) -coordinates of the bounding boxes corresponding
10 # to each face in the input image, then compute the facial embeddings
11 # for each face
12 print("[INFO] recognizing faces...")
13 boxes = face_recognition.face_locations(rgb,
14 model=args[" detection_method"])
15 encodings = face_recognition.face_encodings(rgb, boxes)
16
17 # initialize the list of names for each face detected
18 names = []

1 # loop over the facial embeddings
2 for encoding in encodings:
3 # attempt to match each face in the input image to our known
4 # encodings
5 matches = face_recognition.compare_faces(data["encodings"],
6 encoding)
7 name = "Unknown"

1 # check to see if we have found a match
2 if True in matches:
3 # find the indexes of all matched faces then initialize a
4 # dictionary to count the total number of times each face
5 # was matched
6 matchedIdxs = [i for (i, b) in enumerate(matches) if b]
7 counts = {}
8
9 # loop over the matched indexes and maintain a count for
10 # each recognized face face
11 for i in matchedIdxs:
12 name = data["names"][i]
13 counts[name] = counts.get(name, 0) + 1
14
15 # determine the recognized face with the largest number of
16 # votes (note: in the event of an unlikely tie Python will
17 # select first entry in the dictionary)
18 name = max(counts, key=counts.get)
19
20 # update the list of names
21 names.append(name)

1 (Pdb) matchedIdxs
2 [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, 71, 72, 73, 74, 75]

1 (Pdb) counts
2 {'ian_malcolm': 40}

1 (Pdb) counts
2 {'alan_grant': 5}

1 # loop over the recognized faces
2 for ((top, right, bottom, left) , name) in zip(boxes, names):
3 # draw the predicted face name on the image
4 cv2.rectangle(image, (left, top), (right, bottom), (0, 255, 0), 2)
5 y = top - 15 if top - 15 > 15 else top + 15
6 cv2.putText(image, name, (left, y), cv2.FONT_HERSHEY_SIMPLEX,
7 0.75, (0, 255, 0), 2)
8
9 # show the output image
10 cv2.imshow("Image", image)
11 cv2.waitKey(0)

1 $ python recognize_faces_image.py --encodings encodings.pickle \
2 --image examples/example_01.png
3 [INFO] loading encodings...
4 [INFO] recognizing faces...

1 $ python recognize_faces_image.py --encodings encodings.pickle \
2 --image examples/example_02.png
3 [INFO] loading encodings...
4 [INFO] recognizing faces...

1 # import the necessary packages
2 from imutils.video import VideoStream
3 import face_recognition
4 import argparse
5 import imutils
6 import pickle
7 import time
8 import cv2
9
10 # construct the argument parser and parse the arguments
11 ap = argparse.ArgumentParser()
12 ap.add_argument("-e", "--encodings", required=True,
13 help="path to serialized db of facial encodings")
14 ap.add_argument("-o", "--output", type=str,
15 help="path to output video")
16 ap.add_argument("-y", "--display", type=int, default=1,
17 help="whether or not to display output frame to screen")
18 ap.add_argument("-d", "--detection-method", type=str, default="cnn",
19 help="face detection model to use: either `hog` or `cnn`")
20 args = vars(ap.parse_args())

1 # load the known faces and embeddings
2 print("[INFO] loading encodings...")
3 data = pickle.loads(open (args["encodings"], "rb").read())
4
5 # initialize the video stream and pointer to output video file, then
6 # allow the camera sensor to warm up
7 print("[INFO] starting video stream...")
8 vs = VideoStream(src=0).start()
9 writer = None
10 time.sleep(2.0)

1 # loop over frames from the video file stream
2 while True:
3 # grab the frame from the threaded video stream
4 frame = vs.read()
5
6 # convert the input frame from BGR to RGB then resize it to have
7 # a width of 750px (to speedup processing)
8 rgb = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
9 rgb = imutils.resize(frame, width=750)
10 r = frame.shape[1] / float(rgb.shape[1])
11
12 # detect the (x, y)-coordinates of the bounding boxes
13 # corresponding to each face in the input frame, then compute
14 # the facial embeddings for each face
15 boxes = face_recognition.face_locations(rgb,
16 model=args["detection_method"])
17 encodings = face_recognition.face_encodings(rgb, boxes)
18 names = []

1 # loop over the facial embeddings
2 for encoding in encodings:
3 # attempt to match each face in the input image to our known
4 # encodings
5 matches = face_recognition.compare_faces(data["encodings"],
6 encoding)
7 name = "Unknown"
8
9 # check to see if we have found a match
10 if True in matches:
11 # find the indexes of all matched faces then initialize a
12 # dictionary to count the total number of times each face
13 # was matched
14 matchedIdxs = [i for (i, b) in enumerate(matches) if b]
15 counts = {}
16
17 # loop over the matched indexes and maintain a count for
18 # each recognized face face
19 for i in matchedIdxs:
20 name = data["names"][i]
21 counts[name] = counts.get(name, 0) + 1
22
23 # determine the recognized face with the largest number
24 # of votes (note: in the event of an unlikely tie Python
25 # will select first entry in the dictionary)
26 name = max(counts, key=counts.get)
27
28 # update the list of names
29 names.append(name)

1 # loop over the recognized faces
2 for ((top, right, bottom, left), name) in zip(boxes, names):
3 # rescale the face coordinates
4 top = int(top * r)
5 right = int(right * r)
6 bottom = int(bottom * r)
7 left = int(left * r)
8
9 # draw the predicted face name on the image
10 cv2.rectangle(frame, (left, top), (right, bottom),
11 (0, 255, 0), 2)
12 y = top - 15 if top - 15 > 15 else top + 15
13 cv2.putText(frame, name, (left, y), cv2.FONT_HERSHEY_SIMPLEX,
14 0.75, (0, 255, 0), 2)

1 # if the video writer is None *AND* we are supposed to write
2 # the output video to disk initialize the writer
3 if writer is None and args["output"] is not None:
4 fourcc = cv2.VideoWriter_fourcc(*"MJPG")
5 writer = cv2.VideoWriter(args["output"], fourcc, 20,
6 (frame.shape[1], frame.shape[0]), True)
7
8 # if the writer is not None, write the frame with recognized
9 # faces t odisk
10 if writer is not None:
11 writer.write(frame)

1 # check to see if we are supposed to display the output frame to
2 # the screen
3 if args["display"] > 0:
4 cv2.imshow("Frame", frame)
5 key = cv2.waitKey(1) & 0xFF
6
7 # if the `q` key was pressed, break from the loop
8 if key == ord("q"):
9 break

1 # do a bit of cleanup
2 cv2.destroyAllWindows()
3 vs.stop()
4
5 # check to see if the video writer point needs to be released
6 if writer is not None:
7 writer.release()

1 $ python recognize_faces_video.py --encodings encodings.pickle \
2 --output output/webcam_face_recognition_output.avi --display 1
3 [INFO] loading encodings...
4 [INFO] starting video stream...

1 $ python recognize_faces_video_file.py --encodings encodings.pickle \
2 --input videos/lunch_scene.mp4 --output output/lunch_scene_output.avi \
3 --display 0