def test_partial_face_locations(self): img = api.load_image_file(os.path.join(os.path.dirname(__file__), 'test_images', 'obama_partial_face.jpg')) detected_faces = api.face_locations(img) self.assertEqual(len(detected_faces), 1) self.assertEqual(detected_faces[0], (142, 191, 365, 0)) img = api.load_image_file(os.path.join(os.path.dirname(__file__), 'test_images', 'obama_partial_face2.jpg')) detected_faces = api.face_locations(img) self.assertEqual(len(detected_faces), 1) self.assertEqual(detected_faces[0], (142, 551, 409, 349))
def main(file, model): im = PIL.Image.open(file) im = im.convert("RGB") image = np.array(im) locations = fr.face_locations(image, number_of_times_to_upsample=1, model=model) encodings = fr.face_encodings(image, known_face_locations=locations, model="default") faces = [] for i, encoding in enumerate(encodings): width = locations[i][1] - locations[i][3] height = locations[i][2] - locations[i][0] x = round((locations[i][3] + (width / 2)) / im.width, percision) y = round((locations[i][0] + (height / 2)) / im.height, percision) w = round((width * scaling) / im.width, percision) h = round((height * scaling) / im.height, percision) id = str(uuid.uuid4()) faces.append({ "id": id, "x": x, "y": y, "w": w, "h": h, "detector": "face_recognition@" + face_recognition.__version__, "confidence": 1, "encoding": list(encoding) }) print(json.dumps(faces))
def video_detect_and_blur(img, input_path, output_path, model): if (os.stat(input_path + img).st_size != 0): name = img[:img.rfind('.')] unknown_image = face_recognition.load_image_file(input_path + img) face_locations = face_recognition.face_locations( unknown_image, number_of_times_to_upsample=0, model=model) image = cv2.imread(input_path + img) for face_location in face_locations: top, right, bottom, left = face_location sub_face = image[top:bottom, left:right] # apply a gaussian blur on this new recangle image sub_face = cv2.GaussianBlur(sub_face, (51, 51), 75) # merge this blurry rectangle to our final image image[top:top + sub_face.shape[0], left:left + sub_face.shape[1]] = sub_face # cv2.rectangle(image, (left, top), (right, bottom), (0, 255, 0), 2) # print(output_path + BLURRED_DIR + img) cv2.imwrite(output_path + BLURRED_DIR + img, image) with open(output_path + INFO_DIR + name + '.csv', 'w', newline='', encoding="utf-8") as csvfile: fieldnames = ['location_id', 'top', 'left', 'bottom', 'right'] writer = csv.writer(csvfile) writer.writerow(fieldnames) for (idx, loc) in enumerate(face_locations): top, right, bottom, left = loc writer.writerow([ 'id_' + str(idx), str(top), str(left), str(bottom), str(right) ])
def test_face_loc(self): img = api.load_img_file( os.path.join(os.path.dirname(__file__), 'test_img', 'obama.jpg')) detected_faces = api.face_locations(img) self.assertEqual(len(detected_faces), 1) self.assertEqual(detected_faces[0], (142, 617, 409, 349))
def test_image(image_to_check, model): unknown_image = face_recognition.load_image_file(image_to_check) face_locations = face_recognition.face_locations( unknown_image, number_of_times_to_upsample=0, model=model) for face_location in face_locations: print_result(image_to_check, face_location)
def main(image_to_check, cpus, model): for img_file in image_files_in_folder(image_to_check): unknown_image = face_recognition.load_image_file(img_file) face_locations = face_recognition.face_locations( unknown_image, number_of_times_to_upsample=0, model=model) for faceLocation in face_locations: # print_result(img_file, faceLocation) try: with Image.open(img_file) as im: print("Processing {}...".format(img_file)) top, right, bottom, left = faceLocation myuuid = uuid.uuid1() print("Face Location: {}".format(faceLocation)) print("Format: {0}\tSize: {1}\tMode: {2}".format( im.format, im.size, im.mode)) im1 = im.crop((left, top, right, bottom)) print("Format: {0}\tSize: {1}\tMode: {2}".format( im1.format, im1.size, im1.mode)) im1.save("./" + str(myuuid) + "." + str(im.format).lower(), im.format) except IOError as err: print("Unable to load image: {} ({})".format( img_file, err.errno)) sys.exit(1)
def identityRecognition(testimg, known_face_encodings, known_face_IDs, Threshold): #testimg:当前截图,待匹配人脸 #known_face_encodings: 人脸编码集合 #known_face_IDs: 人脸标号集合 face_locations = face_recognition.face_locations(testimg)#检测出图像中所有面部 #针对多人脸的操作, 核心思想是只取最大的 max_face_id = 0 face_locations_select = [] if len(face_locations)>1: for face_idx in range(len(face_locations)): if (face_locations[face_idx][2]>face_locations[max_face_id][2]) and (face_locations[face_idx][3]>face_locations[max_face_id][3]): max_face_id = face_idx face_locations_select.append(face_locations[face_idx]) else: face_locations_select = face_locations face_encodings = face_recognition.face_encodings(testimg, face_locations_select) #获取图像中所有面部的编码 retname, retscore = np.array(0), np.array(0) top_k_idx = [] for face_encoding in face_encodings: matches, score, top_k_idx = compare_faces(known_face_encodings, face_encoding, Threshold, top_k_num = 3) retname, retscore = np.array(0), np.array(0) # if True in matches: # first_match_index = matches.index(True) # name = known_face_IDs[first_match_index] known_face_IDs_np = np.array(known_face_IDs) name = known_face_IDs_np[top_k_idx] if score > retscore: retname = name retscore = score return retname, top_k_idx
def anonymize_faces(img, min_faces=1, strokes=3): faces = face_recognition.face_locations(img) im = Image.fromarray(img) draw = ImageDraw.Draw(im) if len(faces) <= min_faces: show = -1 else: show = int(random.uniform(0, len(faces))) for i, f in enumerate(faces): if i == show: continue fx = (f[3], f[1] + 1) fy = (f[0], f[2] + 1) fy = fy[0] - (fy[1] - fy[0]) // 4, fy[1] strike_sz = (fy[1] - fy[0]) // strokes irx, iry = int(random.uniform(-10, 10)), int(random.uniform(-4, 4)) for oy in range(0, strokes * strike_sz, strike_sz): rx, ry = irx + int(random.uniform(-5, 5)), iry + int( random.uniform(-3, 3)) draw.polygon([(fx[0] + rx, fy[0] + oy), (fx[0], fy[0] + oy + strike_sz), (fx[1], fy[0] + oy + strike_sz + ry), (fx[1] + rx, fy[0] + oy + ry)], fill=0) return np.array(im)
def test_face_locations(self): img = api.load_image_file( os.path.join(os.path.dirname(__file__), "test_images", "obama.jpg")) detected_faces = api.face_locations(img) assert len(detected_faces) == 1 assert detected_faces[0] == (142, 617, 409, 349)
def test_cnn_face_locations(self): img = api.load_image_file(os.path.join(os.path.dirname(__file__), 'test_images', 'obama.jpg')) detected_faces = api.face_locations(img, model="cnn") self.assertEqual(len(detected_faces), 1) self.assertAlmostEqual(detected_faces[0][0], 144, delta=25) self.assertAlmostEqual(detected_faces[0][1], 608, delta=25) self.assertAlmostEqual(detected_faces[0][2], 389, delta=25) self.assertAlmostEqual(detected_faces[0][3], 363, delta=25)
def test_image( unknown_image): with open('./names.txt') as f: known_names = f.read().splitlines() known_face_encodings=np.loadtxt('encodings.txt',dtype='float') unknown_image = cv2.cvtColor( unknown_image, cv2.COLOR_BGR2RGB ) img = cv2.cvtColor( unknown_image, cv2.COLOR_BGR2GRAY ) print("Image location start") #Find locations of faces in image face_locations = face_recognition.face_locations(unknown_image,number_of_times_to_upsample=2, model="hog") print("Face detection--- %s seconds ---" % (time.time() - start_time)) print("locations",face_locations) if not face_locations: print("No face detected") unknown_encodings=[] username = "******" if face_locations: # for i, face_rect in enumerate(face_locations): # top, right, bottom,left = face_rect # d = dlib.rectangle(left,top, right, bottom ) # alignedFace=face_aligner.align(200, unknown_image,d, landmarkIndices=openface.AlignDlib.OUTER_EYES_AND_NOSE) # alignedFace=cv2.cvtColor( alignedFace, cv2.COLOR_BGR2RGB ) # cv2.imwrite("alignedfaces/aligned_face__{}_.jpg".format(i), alignedFace) # unknown_encoding = face_recognition.face_encodings(alignedFace) # unknown_encodings.extend(unknown_encoding) print(unknown_encodings) unknown_encodings = face_recognition.face_encodings(unknown_image,face_locations) pil_image = Image.fromarray(unknown_image) draw = ImageDraw.Draw(pil_image) count=0 for (top, right, bottom, left), face_encoding in zip(face_locations, unknown_encodings): encodingsfile = open('encodings.txt', 'a+') print((face_encoding)) for x in face_encoding: encodingsfile.write("%f " % x) encodingsfile.write("\n") username = raw_input("Enter name of Unknown : ") # making output annotation for face draw.rectangle(((left, top), (right, bottom)), outline=(0, 0, 255)) text_width, text_height = draw.textsize(username) draw.rectangle(((left, bottom - text_height - 10), (right, bottom)), fill=(0, 0, 255), outline=(0, 0, 255)) draw.text((left + 6, bottom - text_height - 5), username, fill=(255, 255, 255, 255)) known_names.append(username) namefile = open('names.txt', 'w') for item in known_names: namefile.write("%s\n" % item) namefile.close() del draw pil_image.show() return username
def unrecognize_names(unidentified_image_dir): unidentified_face_encodings = [] # Loop through each unidentified images for img_path in image_files_in_folder(unidentified_image_dir): image = face_recognition.load_image_file(img_path) # Find all the faces and face encodings in the current frame of video face_locations = face_recognition.face_locations( image, number_of_times_to_upsample=2) face_encodings = face_recognition.face_encodings(image, face_locations, num_jitters=10) unidentified_face_encodings.append(face_encodings) return unidentified_face_encodings
def _trainImage(self, unknown_image, username="******"): with open(RECOGNISED_NAMES) as f: self.knownNames = f.read().splitlines() unknown_image = cv2.cvtColor(unknown_image, cv2.COLOR_BGR2RGB) img = cv2.cvtColor(unknown_image, cv2.COLOR_BGR2GRAY) face_locations = face_recognition.face_locations( unknown_image, number_of_times_to_upsample=2, model="hog") print "Locations : ", face_locations if not face_locations: print "No face detected" unknown_encodings = [] if face_locations: print unknown_encodings unknown_encodings = face_recognition.face_encodings( unknown_image, face_locations) pil_image = Image.fromarray(unknown_image) draw = ImageDraw.Draw(pil_image) for (top, right, bottom, left), face_encoding in zip(face_locations, unknown_encodings): encodingsfile = open(RECOGNISED_ENCODINGS, 'a+') for x in face_encoding: encodingsfile.write("%f " % x) encodingsfile.write("\n") # making output annotation for face draw.rectangle(((left, top), (right, bottom)), outline=(0, 0, 255)) text_width, text_height = draw.textsize(username) draw.rectangle( ((left, bottom - text_height - 10), (right, bottom)), fill=(0, 0, 255), outline=(0, 0, 255)) draw.text((left + 6, bottom - text_height - 5), username, fill=(255, 255, 255, 255)) self.knownNames.append(username) namefile = open(RECOGNISED_NAMES, 'w') for item in self.knownNames: namefile.write("%s\n" % item) namefile.close() del draw # If one wants to see image at runtime # pil_image.show() return (True, pil_image) return (False, None)
def get_coordinates(image_path): img = face_recognition.load_image_file(image_path) locations = face_recognition.face_locations(img) location_json = [] for coordinates in locations: json_dict = { 'ymin': coordinates[0], 'xmin': coordinates[1], 'ymax': coordinates[2], 'xmax': coordinates[3] } location_json.append(json_dict) return locations, location_json
def recognize_faces(face_image_path): # Read image from disk image = api.load_image_file(face_image_path) # Get face locations in image face_locations = api.face_locations(image, model="hog") # Create encodings from image face_encodings = api.face_encodings(image, known_face_locations=face_locations) # Get encodings from DB existing_face_encoding_objects = [list(g) for _, g in groupby(FaceEncoding.query.order_by(FaceEncoding.player_id).all(), attrgetter('player_id'))] outputs = [] for i, face_encoding in enumerate(face_encodings): distances = {} for face_encoding_group in existing_face_encoding_objects: # Calculate distance to every encoding for this group (person) existing_face_encodings = np.array([fe.encoding for fe in face_encoding_group]) face_distances = api.face_distance(existing_face_encodings, face_encoding) distances[face_encoding_group[0].player] = sum(face_distances) / len(face_distances) recognized_player = None if len(distances) > 0: recognized_player = min(distances, key=distances.get) if distances[recognized_player] > THRESHOLD: recognized_player = None # Create a crop of the face top, right, bottom, left = face_locations[i] image_crop = image[top:bottom, left:right] im = Image.fromarray(image_crop) with io.BytesIO() as output: im.save(output, format="JPEG") contents = output.getvalue() outputs.append( { "image": base64.b64encode(contents).decode("utf-8"), "embedding": face_encoding.tolist(), "player": recognized_player.serialize() if recognized_player else None }) return outputs
def test(): # loop over unknown faces print("processing unknown faces") for filename in os.listdir(UNKNOWN_FACES_DIR): # load the image print(f"Filename {filename}", end="") image = FR.load_image_file(f"{UNKNOWN_FACES_DIR}/{filename}") # Find the location of the faces locations = FR.face_locations(image, model=MODEL) # pass locations to face_encodings to cut down on processing time encodings = FR.face_encodings(image, locations) image = cv2.cvtColor(image, cv2.COLOR_RGB2BGR) print(f",found {len(encodings)} face(s)") for face_encoding, face_location in zip(encodings, locations): results = FR.compare_faces(known_faces, face_encoding, TOLERENCE) match = None if True in results: match = known_names[results.index(True)] print(f"Match Found {match}") # dimensions of where the face is top_left = (face_location[3], face_location[0]) bottom_right = (face_location[1], face_location[2]) # draw rectangle on image color = [0, 255, 0] cv2.rectangle(image, top_left, bottom_right, color, FRAME_THICKNESS) top_left = (face_location[3], face_location[0]) bottom_right = (face_location[1], face_location[2] + 22) # cv2.rectangle(image, top_left, bottom_right, color, cv2.FILLED) cv2.putText( image, match, (face_location[3] + 10, face_location[2] + 15), cv2.FONT_HERSHEY_COMPLEX, 0.5, (200, 200, 200), FONT_THICKNESS, ) cv2.imshow(filename, image) cv2.waitKey(0) cv2.destroyAllWindows()
def test_image(image_to_check, model): unknown_image = face_recognition.load_image_file(image_to_check) face_locations = face_recognition.face_locations( unknown_image, number_of_times_to_upsample=0, model=model) i = 0 for face_location in face_locations: print_result(image_to_check, face_location) try: with Image.open(image_to_check) as im: box = face_location region = im.crop(box) fname = "/tmp/test_image_" + str(i) + ".jpeg" print("Printing: {}".format(fname)) im.save(fname, "JPEG") i = i + 1 except IOError: print("IOError")
def detect_faces_in_image(file_stream): # 载入用户上传的图片 img = face_recognition.load_image_file(file_stream) # 为用户上传的图片中的人脸编码 face_encodings = face_recognition.face_encodings(img) encodings = [] for face_encoding in face_encodings: encodings.append(face_encoding.tolist()) face_locations = face_recognition.face_locations( img, number_of_times_to_upsample=0, model="hog") # face_landmarks = face_recognition.face_landmarks(img, face_locations=face_locations, model='large') # 讲识别结果以json键值对的数据结构输出 result = {"encodings": encodings, "locations": face_locations} return jsonify(result)
def save_keypoints_image(image_path, input_folder, output_folder, model): image = face_recognition.load_image_file(image_path) locations = face_recognition.face_locations(image, model=model) landmarks = face_recognition.face_landmarks(image, face_locations=locations, return_dict=False) num_faces = landmarks.shape[0] if num_faces == 0: return out_path = move_path(image_path, input_folder, output_folder) out_path = out_path.with_suffix('') out_path.mkdir(parents=True, exist_ok=True) for face_idx in range(num_faces): file_path = Path(out_path, F"{face_idx}.npy") landmark_array = landmarks[face_idx] np.save(file_path, landmark_array) print(F"finished image {out_path}")
def save_keypoints_video(video_path, input_folder, output_folder, model, tolerance): video = cv2.VideoCapture(str(video_path)) out_path = move_path(video_path, input_folder, output_folder) out_path = out_path.with_suffix('') known_faces = [] frame_count = 0 while video.isOpened(): ret, frame = video.read() if not ret: break frame = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB) locations = face_recognition.face_locations(frame, model=model) encodings, landmarks = face_recognition.face_encodings_and_landmarks( frame, known_face_locations=locations) num_faces = landmarks.shape[0] if num_faces == 0: continue for face_idx, (encoding, landmark_array) in enumerate(zip(encodings, landmarks)): distances = face_recognition.face_distance(known_faces, encoding) if len(distances) == 0 or distances.min() > tolerance: known_idx = len(known_faces) known_faces.append(encoding) else: known_idx = int(np.argmin(distances)) known_faces[known_idx] = np.mean( [known_faces[known_idx], encoding], axis=0) file_path = Path(out_path, F"{known_idx}", F"{frame_count}.npy") file_path.parent.mkdir(parents=True, exist_ok=True) np.save(file_path, landmark_array) frame_count += 1 print(F"finished video {out_path}")
def _predict(self, frame_number, frame, knn_clf, known_names, known_face_encodings): unknown_image = frame[:, :, ::-1] if max(unknown_image.shape) > 1600: pil_image = Image.fromarray(unknown_image) pil_image.thumbnail((1600, 0), PIL.Image.LANCZOS) unknown_image = np.array(pil_img) img = cv2.cvtColor(unknown_image, cv2.COLOR_RGB2GRAY) pil_image = Image.fromarray(unknown_image) self.start_time = time.time() face_locations = face_recognition.face_locations( img, number_of_times_to_upsample=2, model="hog") print "Face detection--- %s seconds ---" % (time.time() - self.start_time) if not face_locations: return False if face_locations: print face_locations unknown_encodings = face_recognition.face_encodings( unknown_image, face_locations) print "amy", type(unknown_encodings[0]) closest_distances = knn_clf.kneighbors(unknown_encodings, n_neighbors=1) matches = [ closest_distances[0][i][0] <= DIST_THRESHOLD for i in range(len(face_locations)) ] return [(pred, loc, encoding, rec) if rec else ("unknown", loc, encoding, rec) for pred, encoding, loc, rec in zip( knn_clf.predict(unknown_encodings), unknown_encodings, face_locations, matches)]
def main(): vs = VideoStream() vs.start() names, known_encodings = load_known_faces('./faces/known_faces') print(len(known_encodings)) while vs.isOpened(): image = vs.read() gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY) face_locations = fr.face_locations(image, model='hog') img_face_encodings = fr.face_encodings(image, face_locations) match_matrix = [ fr.compare_faces(known_encodings, f, tolerance=0.6) for f in img_face_encodings ] print(match_matrix) img_with_faces = draw_bbox_on_img(image, face_locations) cv2.imshow('frame', img_with_faces) if cv2.waitKey(1) & 0xFF == ord('q'): break vs.close() cv2.destroyAllWindows()
unknown_count = 0 while True: # Grab a single frame of video ret, frame = video_capture.read() # Resize frame of video to 1/4 size for faster face recognition processing small_frame = cv2.resize(frame, (0, 0), fx=0.25, fy=0.25) # Convert the image from BGR color (which OpenCV uses) to RGB color (which face_recognition uses) rgb_small_frame = small_frame[:, :, ::-1] # Only process every other frame of video to save time if process_this_frame: # Find all the faces and face encodings in the current frame of video face_locations = face_recognition.face_locations(rgb_small_frame) face_encodings = face_recognition.face_encodings( rgb_small_frame, face_locations) face_names = [] for face_encoding in face_encodings: # See if the face is a match for the known face(s) matches = face_recognition.compare_faces(known_face_encodings, face_encoding, tolerance=0.35) name = "Unknown" # # If a match was found in known_face_encodings, just use the first one. # if True in matches: # first_match_index = matches.index(True) # name = known_face_ids[first_match_index]
def test_image(image_to_check, model): unknown_image = face_recognition.load_image_file(image_to_check) face_locations = face_recognition.face_locations(unknown_image, number_of_times_to_upsample=0, model=model) for face_location in face_locations: print_result(image_to_check, face_location)
model = Face(train=False) #model.load_weights('./face_weights/face_weights.26-val_loss-3.85-val_age_loss-3.08-val_gender_loss-0.22-val_race_loss-0.55.utk.h5') model.load_weights( './face_weights/face_weights.18-val_loss-3.86-val_age_loss-3.05-val_gender_loss-0.22-val_race_loss-0.59.utk.h5' ) gender_labels = ['Male', 'Female'] race_labels = ['Whites', 'Blacks', 'Asian', 'Indian', 'Others'] #https://www.cv-foundation.org/openaccess/content_iccv_2015_workshops/w11/papers/Rothe_DEX_Deep_EXpectation_ICCV_2015_paper.pdf age_labels = np.reshape(np.arange(1, 94), (93, 1)) demo_image = cv2.imread('./demo_images/15_1_0_20170109213421667.jpg.chip.jpg') image_h, image_w = demo_image.shape[0], demo_image.shape[1] margin = 0.01 face_locations = face_recognition.face_locations(demo_image, model='hog') if len(face_locations) > 0: face_batch = np.empty((len(face_locations), 200, 200, 3)) # add face images into batch for i, rect in enumerate(face_locations): # crop with a margin top, bottom, left, right = rect[0], rect[2], rect[3], rect[1] top = max(int(top - image_h * margin), 0) left = max(int(left - image_w * margin), 0) bottom = min(int(bottom + image_h * margin), image_h - 1) right = min(int(right + image_w * margin), image_w - 1) face_img = demo_image[top:bottom, left:right, :] face_img = cv2.resize(face_img, (200, 200))
from __future__ import print_function import shutil import os import face_recognition.api as face_recognition if __name__ == "__main__": path_folder = r'C:\Users\tinnvt\Documents\BasicML\Project\Face Recognition\BML_Face_Recognition\images' path_remove_images = r'C:\Users\tinnvt\Documents\BasicML\Project\Face Recognition\BML_Face_Recognition\removed_images' for sub_folder_name in os.listdir(path_folder): sub_folder_path = os.path.join(path_folder, sub_folder_name) sub_folder_remove = os.path.join(path_remove_images, sub_folder_name) if not os.path.exists(sub_folder_remove): os.mkdir(sub_folder_remove) for img_name in os.listdir(sub_folder_path): try: path_img = os.path.join(sub_folder_path, img_name) unknown_image = face_recognition.load_image_file(path_img) face_locations = face_recognition.face_locations( unknown_image, number_of_times_to_upsample=1, model="hog") if len(face_locations) == 0: print('No faces in this image!', path_img) shutil.move(path_img, os.path.join(sub_folder_remove, img_name)) except Exception as e: print(f'Image {img_name} has error {e}')
def analyseFootage(clipname): CLIP_PATH = FOOTAGES_PATH + "/" + clipname if os.path.isfile(CLIP_PATH) == False: return 0 #Load the known face IDs and encodings for facial recognition try: with open(os.path.join(STORAGE_PATH, "known_face_ids.pickle"), "rb") as fp: known_face_ids = pickle.load(fp) with open(os.path.join(STORAGE_PATH, "known_face_encodings.pickle"), "rb") as fp: known_face_encodings = pickle.load(fp) except: known_face_encodings = [] known_face_ids = [] #Start the Video Stream fvs = FileVideoStream(CLIP_PATH).start() time.sleep(1.0) print("[INFO] Loading the facial detector") detector = dlib.get_frontal_face_detector() #predictor = dlib.shape_predictor(LANDMARK_PATH) #fa = FaceAligner(predictor, desiredFaceWidth = 96) name = "Unknown" face_locations = [] face_encodings = [] face_names = [] process_this_frame = True #sanity_count = 0 unknown_count = 0 marked = True print("[INFO] Initializing CCTV Footage") while fvs.more(): # grab the frame from the threaded video file stream, resize # it, and convert it to grayscale (while still retaining 3 # channels) frame = fvs.read() if frame is None: break frame = imutils.resize(frame, width=600) frame = adjust_gamma(frame, gamma=1.5) gray_frame = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY) #To store the faces #This will detect all the images in the current frame, and it will return the coordinates of the faces #Takes in image and some other parameter for accurate result faces = detector(gray_frame, 0) #In above 'faces' variable there can be multiple faces so we have to get each and every face and draw a rectangle around it. #sampleNum = sampleNum+1 for face in faces: #num_frames = num_frames + 1 #print("inside for loop") if face is None: print("face is none") continue #face_aligned = fa.align(frame,gray_frame,face) #face_aligned = imutils.resize(face_aligned ,width = 600) if process_this_frame: # Find all the faces and face encodings in the current frame of video face_locations = face_recognition.face_locations(frame) face_encodings = face_recognition.face_encodings( frame, face_locations) face_names = [] for face_encoding in face_encodings: # See if the face is a match for the known face(s) matches = face_recognition.compare_faces( known_face_encodings, face_encoding, tolerance=0.35) name = "Unknown" # # If a match was found in known_face_encodings, just use the first one. # if True in matches: # first_match_index = matches.index(True) # name = known_face_ids[first_match_index] # Or instead, use the known face with the smallest distance to the new face face_distances = face_recognition.face_distance( known_face_encodings, face_encoding) # print(face_distances) try: best_match_index = np.argmin(face_distances) if matches[best_match_index]: name = known_face_ids[best_match_index] except: # print("No students have been marked") #video_capture.release() #cv2.destroyAllWindows() marked = False #return marked #if matches[best_match_index]: # name = known_face_ids[best_match_index] face_names.append(name) if name == "Unknown": unknown_count += 1 else: unknown_count = 0 if unknown_count == 600: # video_capture.release() # cv2.destroyAllWindows() # print("You haven't been registered") marked = False unknown_count = 0 break process_this_frame = not process_this_frame for (top, right, bottom, left), name in zip(face_locations, face_names): # Draw a box around the face cv2.rectangle(frame, (left, top), (right, bottom), (0, 0, 255), 1) # Draw a label with a name below the face cv2.rectangle(frame, (left, bottom + 15), (right, bottom), (0, 0, 255), cv2.FILLED) font = cv2.FONT_HERSHEY_DUPLEX cv2.putText(frame, name, (left + 6, bottom + 15), font, 0.4, (255, 255, 255), 1) #Showing the image in another window #Creates a window with window name "Face" and with the image img #cv2.imshow("Video feed (PRESS Q TO QUIT",frame) frame = cv2.imencode('.jpg', frame)[1].tobytes() yield (b'--frame\r\n' b'Content-Type: image/jpeg\r\n\r\n' + frame + b'\r\n') #if cv2.waitKey(1) == ord("q") : # break print("here") # do a bit of cleanup cv2.destroyAllWindows() #fvs.stop() return
def test_face_locations(self): img = api.load_image_file(os.path.join(os.path.dirname(__file__), "test_images", "obama.jpg")) detected_faces = api.face_locations(img) assert len(detected_faces) == 1 assert detected_faces[0] == (142, 617, 409, 349)
def test_face_locations(self): img = api.load_image_file(os.path.join(os.path.dirname(__file__), 'test_images', 'obama.jpg')) detected_faces = api.face_locations(img) self.assertEqual(len(detected_faces), 1) self.assertEqual(detected_faces[0], (142, 617, 409, 349))
pool.starmap(test_image, function_parameters) known_face_names, known_face_encodings = scan_known_people('./knownmans') face_count = 0 while True: # Grab a single frame of video ret, frame = video_capture.read() # Convert the image from BGR color (which OpenCV uses) to RGB color (which face_recognition uses) rgb_frame = frame[:, :, ::-1] # Find all the faces and face enqcodings in the frame of video face_locations = face_recognition.face_locations(rgb_frame, model="cnn") face_encodings = face_recognition.face_encodings(rgb_frame, face_locations) # Loop through each face in this frame of video for (top, right, bottom, left), face_encoding in zip(face_locations, face_encodings): # See if the face is a match for the known face(s) matches = face_recognition.compare_faces(known_face_encodings, face_encoding, tolerance=0.30) name = "Unknown" # If a match was found in known_face_encodings, just use the first one. if True in matches: first_match_index = matches.index(True)
import cv2 import face_recognition.api as face_recognition import PIL.Image import numpy as np import logging as log import datetime as dt from time import sleep import os dir=os.path.dirname(os.path.abspath(__file__)) image_dir=os.path.join(dir,"Images") for root,dirs,files in os.walk(image_dir): for file in files : if file.endswith("png")or file.endswith("jpg")or file.endswith("jpeg"): path = os.path.join(root, file) label=os.path.split(path)[-1] label , var = label.split('.') img = cv2.imread(path) resized_image = cv2.resize(img, (700, 700)) faces = face_recognition.face_locations(resized_image) if len(faces) >= 0: print(len(faces)) print(path)
def mark_your_attendance(location, known_face_encodings, known_face_ids): mpl.rcParams['toolbar'] = 'None' if (os.path.exists(DB_PATH)): #rdbms='sqlite' #conn = psycopg2.connect(DB_PATH) #c=conn.cursor() rdbms = 'postgresql' conn = psycopg2.connect(host="localhost", database="face_rec_db", user="******", password="******") c = conn.cursor() else: #os.mknod(DB_PATH) conn = sqlite3.connect(DB_PATH) c = conn.cursor() c.execute('''CREATE TABLE IF NOT EXISTS ATTENDANCE (ID TEXT NOT NULL, TIMESTAMP TEXT NOT NULL, LOCATION TEXT);''') conn.commit() name = "Unknown" face_locations = [] face_encodings = [] face_names = [] process_this_frame = True sanity_count = 0 unknown_count = 0 marked = True video_capture = cv2.VideoCapture(0, cv2.CAP_DSHOW) #_,frame = video_capture.read() while True: # Grab a single frame of video _, frame = video_capture.read() #Applying face enhancement steps frame = imageEnhancement.adjust_gamma(frame, gamma=1.5) # Resize frame of video to 1/4 size for faster face recognition processing #small_frame = cv2.resize(frame, (0, 0), fx=0.25, fy=0.25) small_frame = frame # Convert the image from BGR color (which OpenCV uses) to RGB color (which face_recognition uses) rgb_small_frame = small_frame[:, :, ::-1] # Only process every other frame of video to save time if process_this_frame: # Find all the faces and face encodings in the current frame of video face_locations = face_recognition.face_locations(rgb_small_frame) face_encodings = face_recognition.face_encodings( rgb_small_frame, face_locations) face_names = [] for face_encoding in face_encodings: # See if the face is a match for the known face(s) matches = face_recognition.compare_faces(known_face_encodings, face_encoding, tolerance=0.35) name = "Unknown" # # If a match was found in known_face_encodings, just use the first one. # if True in matches: # first_match_index = matches.index(True) # name = known_face_ids[first_match_index] # Or instead, use the known face with the smallest distance to the new face face_distances = face_recognition.face_distance( known_face_encodings, face_encoding) # print(face_distances) try: best_match_index = np.argmin(face_distances) except: # print("No students have been marked") video_capture.release() cv2.destroyAllWindows() marked = False return marked if matches[best_match_index]: name = known_face_ids[best_match_index] face_names.append(name) if name == "Unknown": unknown_count += 1 else: unknown_count = 0 if unknown_count == 600: # video_capture.release() # cv2.destroyAllWindows() # print("You haven't been registered") marked = False unknown_count = 0 break process_this_frame = not process_this_frame # Display the results for (top, right, bottom, left), name in zip(face_locations, face_names): # Scale back up face locations since the frame we detected in was scaled to 1/4 size #top *= 4 #right *= 4 #bottom *= 4 #left *= 4 # Draw a box around the face cv2.rectangle(frame, (left, top), (right, bottom), (0, 0, 255), 2) # Draw a label with a name below the face cv2.rectangle(frame, (left, bottom - 35), (right, bottom), (0, 0, 255), cv2.FILLED) font = cv2.FONT_HERSHEY_DUPLEX cv2.putText(frame, name, (left + 6, bottom - 6), font, 0.7, (255, 255, 255), 1) # print("AFTER SHOWING") # Hit 'q' on the keyboard to quit! if (sanity_count == 0): prev_name = name sanity_count += 1 elif sanity_count < 60: if (prev_name == name and name != "Unknown"): sanity_count += 1 prev_name = name else: sanity_count = 0 elif sanity_count == 60: # print("Face registered") # video_capture.release() # cv2.destroyAllWindows() sanity_count = 0 # now = datetime.now() # if(entry_or_exit==0): # c.execute("INSERT INTO ATTENDANCE VALUES (?,datetime('now'),'IN');",(name, )) # else: # c.execute("INSERT INTO ATTENDANCE VALUES (?,datetime('now'),'OUT');",(name, )) if (rdbms == 'sqlite'): c.execute( "INSERT INTO ATTENDANCE VALUES (?,datetime('now'),?);", ( name, location, )) elif (rdbms == 'postgresql'): c.execute("INSERT INTO attendance VALUES (%s,now(),%s);", (name, location)) conn.commit() break #OpenCV's implementation to show an image in window(doesn't work on production server) #cv2.imshow("Marking Attendance (PRESS Q TO QUIT)",frame) #Encoding the frame to be stream into browser frame = cv2.imencode('.jpg', frame)[1].tobytes() yield (b'--frame\r\n' b'Content-Type: image/jpeg\r\n\r\n' + frame + b'\r\n') #if cv2.waitKey(20) == ord("q"): # break # Release handle to the webcam #plt.close() video_capture.release() cv2.destroyAllWindows() conn.close() return marked
video_capture = cv2.VideoCapture(0) process_this_frame = True while True: # Grab a single frame of video ret, frame = video_capture.read() # Resize frame of video to 1/4 size for faster face recognition processing small_frame = cv2.resize(frame, (0, 0), fx=0.25, fy=0.25) # Convert the image from BGR color (which OpenCV uses) to RGB color (which face_recognition uses) rgb_small_frame = small_frame[:, :, ::-1] # Only process every other frame of video to save time if process_this_frame: # Find all the faces and face encodings in the current frame of video face_locations = face_recognition.face_locations( rgb_small_frame, number_of_times_to_upsample=2) face_encodings = face_recognition.face_encodings( rgb_small_frame, face_locations) face_names = [] for face_encoding in face_encodings: # See if the face is a match for the known face(s) matches = face_recognition.compare_faces(x_train, face_encoding, tolerance=0.5) name = "Unknown" # If a match was found in known_face_encodings, just use the first one. if True in matches: first_match_index = matches.index(True) name = y_lables[first_match_index]