def __init__(self,landmark_model="large"): """ Load previously encoded faces and their features """ with open('../../data/face_recognize_features.json') as f: faces = json.load(f) face_list = [] face_name_list = [] for face in faces: for encoding in face['encodings']: face_list.append(np.array(encoding)) face_name_list.append(face['name']) self.face_list = np.array(face_list) self.face_name_list = face_name_list if landmark_model == "small": predictor_5_point_model = face_recognition_models.pose_predictor_five_point_model_location() self.pose_predictor = dlib.shape_predictor(predictor_5_point_model) else: predictor_68_point_model = face_recognition_models.pose_predictor_model_location() self.pose_predictor = dlib.shape_predictor(predictor_68_point_model) face_recognition_model = face_recognition_models.face_recognition_model_location() self.face_encoder = dlib.face_recognition_model_v1(face_recognition_model)
def align_face(self, image): faces = dlib.full_object_detections() (h, w) = image.shape[:2] loc = dlib.rectangle(h, w, 0, 0) model = FRM.pose_predictor_five_point_model_location() sp = dlib.shape_predictor(model) faces.append(sp(image, loc)) aligned = dlib.get_face_chip(image, faces[0], size=160) return aligned
def init_engine(mode='image', num_face=10, mask='all'): if mask == 'recognize': predictor_5_point_model = face_recognition_models.pose_predictor_five_point_model_location() pose_predictor_5_point = dlib.shape_predictor(predictor_5_point_model) #predictor_68_point_model = face_recognition_models.pose_predictor_model_location() #pose_predictor_68_point = dlib.shape_predictor(predictor_68_point_model) face_recognition_model = face_recognition_models.face_recognition_model_location() face_encoder = dlib.face_recognition_model_v1(face_recognition_model) return pose_predictor_5_point, face_encoder else: face_detector = dlib.get_frontal_face_detector() return face_detector
def __init__(self, employees, resolution=(320, 240), model_type="small", nb_iters=1): # nb_iters - the higher is more percise but slower # model_type - "small" / "large" large is more accurate but slower self.camera = picamera.PiCamera() self.camera.resolution = resolution self.np_output = np.zeros((resolution[1], resolution[0], 3), dtype=np.uint8) self.model = frm.face_recognition_model_location() self.encoder = dlib.face_recognition_model_v1(self.model) self.face_detector = dlib.get_frontal_face_detector() self.model_type = model_type self.nb_iters = nb_iters self.employees = employees self.predictor = frm.pose_predictor_five_point_model_location() if self.model_type == "large": self.predictor = frm.face_recognition_models.pose_predictor_model_location( ) self.load_faces()
print( "Please install `face_recognition_models` with this command before using `face_recognition`:\n" ) print( "pip install git+https://github.com/ageitgey/face_recognition_models") quit() ImageFile.LOAD_TRUNCATED_IMAGES = True face_detector = dlib.get_frontal_face_detector() predictor_68_point_model = face_recognition_models.pose_predictor_model_location( ) pose_predictor_68_point = dlib.shape_predictor(predictor_68_point_model) predictor_5_point_model = face_recognition_models.pose_predictor_five_point_model_location( ) pose_predictor_5_point = dlib.shape_predictor(predictor_5_point_model) cnn_face_detection_model = face_recognition_models.cnn_face_detector_model_location( ) cnn_face_detector = dlib.cnn_face_detection_model_v1(cnn_face_detection_model) face_recognition_model = face_recognition_models.face_recognition_model_location( ) face_encoder = dlib.face_recognition_model_v1(face_recognition_model) def _rect_to_css(rect): """ Convert a dlib 'rect' object to a plain tuple in (top, right, bottom, left) order
import numpy as np try: import face_recognition_models except: print("Please install `face_recognition_models` with this command before using `face_recognition`:") print() print("pip install git+https://github.com/ageitgey/face_recognition_models") quit() face_detector = dlib.get_frontal_face_detector() predictor_68_point_model = face_recognition_models.pose_predictor_model_location() pose_predictor_68_point = dlib.shape_predictor(predictor_68_point_model) predictor_5_point_model = face_recognition_models.pose_predictor_five_point_model_location() pose_predictor_5_point = dlib.shape_predictor(predictor_5_point_model) cnn_face_detection_model = face_recognition_models.cnn_face_detector_model_location() cnn_face_detector = dlib.cnn_face_detection_model_v1(cnn_face_detection_model) face_recognition_model = face_recognition_models.face_recognition_model_location() face_encoder = dlib.face_recognition_model_v1(face_recognition_model) def _rect_to_css(rect): """ Convert a dlib 'rect' object to a plain tuple in (top, right, bottom, left) order :param rect: a dlib 'rect' object :return: a plain tuple representation of the rect in (top, right, bottom, left) order
import scipy.misc import dlib import numpy as np import face_recognition_models as frm face_detector = dlib.get_frontal_face_detector() predictor_68_point_model = frm.pose_predictor_model_location() pose_predictor_68_point = dlib.shape_predictor(predictor_68_point_model) predictor_5_point_model = frm.pose_predictor_five_point_model_location() pose_predictor_5_point = dlib.shape_predictor(predictor_5_point_model) cnn_face_detection_model = frm.cnn_face_detector_model_location() cnn_face_detector = dlib.cnn_face_detection_model_v1(cnn_face_detection_model) face_recognition_model = frm.face_recognition_model_location() face_encoder = dlib.face_recognition_model_v1(face_recognition_model) def rect_to_css(rect): return rect.top(), rect.right(), rect.bottom(), rect.left() def css_to_rect(css): return dlib.rectangle(css[3], css[0], css[1], css[2]) def trim_css_to_bounds(css, image_shape): return max(css[0], 0), min(css[1],
def saveEncodings(self, verbose=True): # initialize face encoding parameters ImageFile.LOAD_TRUNCATED_IMAGES = True predictor_68_point_model = face_recognition_models.pose_predictor_model_location( ) pose_predictor_68_point = dlib.shape_predictor( predictor_68_point_model) predictor_5_point_model = face_recognition_models.pose_predictor_five_point_model_location( ) pose_predictor_5_point = dlib.shape_predictor(predictor_5_point_model) face_recognition_model = face_recognition_models.face_recognition_model_location( ) face_encoder = dlib.face_recognition_model_v1(face_recognition_model) pose_predictor = pose_predictor_68_point # initialize a text file for saving images where faces are not found with open('waste_files.txt', 'w') as waste: waste.write("Images which are not suitable for training are-\n") try: # load previously saved encodings pickle_in = open(self.base_dir + "known_face_encodings.pickle", "rb") known_face_encodings = pickle.load(pickle_in) pickle_in.close() pickle_in = open(self.base_dir + "known_face_names.pickle", "rb") known_face_names = pickle.load(pickle_in) pickle_in.close() # filter out faces which are already trained temp = [] for name in self.names: if name not in known_face_names: temp.append(name) self.names = temp except: # declare encodings as empty known_face_encodings = [] known_face_names = [] #self.names = ['1231', '1232', '1234', '1238', '1242']#'1237', '1239','1235', print("[INFO] Encoding... ", self.names) if self.names != []: # looping through names to be trained for name in tqdm(self.names): # clear the lists for new user face_images = [] faces_locations = [] face_names = [] # load images of person to be trained base = self.user_images name = name.strip() base = os.path.join(base, name) # looping through images of person to be trained for img_path in glob.glob(os.path.join(base, "*.jpg")): # read image image_data = cv2.imread(img_path) ############### # check face using resnet ############### blob = cv2.dnn.blobFromImage(image_data, 1.0, (300, 300), (104.0, 177.0, 123.0)) self.net2.setInput(blob) detections = self.net2.forward() (h, w) = image_data.shape[:2] confidences = [] boxes = [] for i in range(0, detections.shape[2]): confidence = detections[0, 0, i, 2] if confidence > 0.98: box = detections[0, 0, i, 3:7] * np.array( [w, h, w, h]) box = box.astype("int") # startX, startY, endX, endY confidences.append(float(confidence)) boxes.append([ box[0], box[1], box[2] - box[0], box[3] - box[1] ]) if len(boxes) > 0: pass else: waste.write(img_path + "\n") #print("[INFO] Image {} not suitable for training: Resnet filtered out".format(img_path)) continue ############### # face detection using yolo ############### # load model parameters blob = cv2.dnn.blobFromImage(image_data, 1 / 255, (416, 416), [0, 0, 0], 1, crop=False) self.net.setInput(blob) # fetch predictions from model/network layers_names = self.net.getLayerNames() outs = self.net.forward([ layers_names[i[0] - 1] for i in self.net.getUnconnectedOutLayers() ]) # fetch size of image (frame_height, frame_width) = image_data.shape[:2] # declare overall confidence list confidences = [] # declare bounding boxes list boxes = [] face_locations = [] # looping through model predictions/ predictions for each grid cell for out in outs: # looping through detectors outputs for grid cell for detection in out: # fetch classifier probabilities for different classes scores = detection[5:] # fetch maximum probabilty class class_id = np.argmax(scores) # define confidence as maximum probability confidence = scores[class_id] # filter predictions based on confidence threshold if confidence > self.yolo_conf_threshold: # fetch bounding box dimensions center_x = int(detection[0] * frame_width) center_y = int(detection[1] * frame_height) width = int(detection[2] * frame_width) height = int(detection[3] * frame_height) left = int(center_x - width / 2) top = int(center_y - height / 2) # append confidence in confidences list confidences.append(float(confidence)) # append bounding box in bounding boxes list boxes.append([left, top, width, height]) # perform non maximum suppression of overlapping images indices = cv2.dnn.NMSBoxes(boxes, confidences, self.yolo_conf_threshold, self.nms_threshold) # fetch faces bounding boxes for i in indices: i = i[0] box = boxes[i] left = box[0] top = box[1] width = box[2] height = box[3] face_locations.append( np.array([ top, left + width + (width * self.margin // 100), top + height, left - (width * self.margin // 100) ])) if len(face_locations) != 1: waste.write(img_path + "\n") # If there are no people (or too many people) in a training image, skip the image. if verbose: pass #print("[INFO] Image {} not suitable for training: {}".format(img_path, "Didn't find a face" if len(face_locations) < 1 else "Found more than one face")) else: for face_location in face_locations: if min(face_location) < 0: pass #print("[INFO] Image {} not suitable for training: Face is not in Boundary of Image".format(img_path)) else: ###################################################### # histogram equalization frame1 = image_data[ face_location[0]:face_location[2], face_location[3]:face_location[1], :] img_to_yuv = cv2.cvtColor( frame1, cv2.COLOR_BGR2YUV) img_to_yuv[:, :, 0] = cv2.equalizeHist( img_to_yuv[:, :, 0]) frame1 = cv2.cvtColor( img_to_yuv, cv2.COLOR_YUV2BGR) image_data[ face_location[0]:face_location[2], face_location[3]: face_location[1], :] = frame1 ################################################### # Add face encoding for current image to the training set faces_locations.append(face_locations[0]) face_images.append(image_data) face_names.append(name) faces_locations = [ self._css_to_rect(face_location) for face_location in faces_locations ] raw_landmarks = [] for face_image, face_location in zip( face_images, faces_locations): faces = dlib.full_object_detections() faces.append(pose_predictor(face_image, face_location)) raw_landmarks.append(faces) if len(faces_locations) < 120: print( "[INFO]: %s skipped as total number of proper images are <120." % name) continue # generate encoding for captured faces of user encodings = list(np.array(face_encoder.compute_face_descriptor(batch_img=face_images, batch_faces=raw_landmarks, num_jitters=20))\ .reshape((len(face_images), 128))) # append new data in old data known_face_encodings += encodings known_face_names += face_names # save the encodings after every iteration of distinct class pickle_out = open( self.base_dir + "known_face_names.pickle", "wb") pickle.dump(known_face_names, pickle_out) pickle_out.close() pickle_out = open( self.base_dir + "known_face_encodings.pickle", "wb") pickle.dump(known_face_encodings, pickle_out) pickle_out.close() print("[INFO]: %s saved!" % name) else: print("Encoding Skipped!\n")
# -*- coding: utf-8 -*- import PIL.Image import dlib import numpy as np import face_recognition_models as models # import models # ==================================================================================================================== # models에 있는 모델 변수 적용 face_detector = dlib.get_frontal_face_detector() point_68_predictor = models.pose_predictor_model_location() point_68_pose = dlib.shape_predictor(point_68_predictor) point_5_predictor = models.pose_predictor_five_point_model_location() point_5_pose = dlib.shape_predictor(point_5_predictor) face_detection_model = models.cnn_face_detector_model_location() face_detector_tool = dlib.cnn_face_detection_model_v1(face_detection_model) face_recognition_model = models.face_recognition_model_location() face_encoder = dlib.face_recognition_model_v1(face_recognition_model) # ==================================================================================================================== # dlib 'rect' 객체를 top, right, bottom, left 순서로 변환 # param rect : dlib 'rect' 오브젝트 # return : tuple (top, right, bottom, left) def _rect_to_css(rect): return rect.top(), rect.right(), rect.bottom(), rect.left()
def main(mode='test', img_path='def'): t = time.clock() classes = [ 'MXG', 'Sanaken', 'Zofinka', 'Toalk', 'Zissxzirsziiss', 'kiasummer' ] known_face_encodes = [ np.loadtxt(MAIN_PATH + '/persons/MXG/fv.txt'), np.loadtxt(MAIN_PATH + '/persons/Sanaken/fv.txt'), np.loadtxt(MAIN_PATH + '/persons/Zofinka/fv.txt'), np.loadtxt(MAIN_PATH + '/persons/Toalk/fv.txt'), np.loadtxt(MAIN_PATH + '/persons/Zissxzirsziiss/fv.txt'), np.loadtxt(MAIN_PATH + '/persons/kiasummer/fv.txt') ] known_face_encodes = np.reshape(known_face_encodes, (6, 5, 128)) # get image if img_path == 'def': image = cv2.imread('team.jpg', 1) else: image = cv2.imread(img_path, 1) # output init_align_faces = [] out_arr = [] # get bboxes fd = FaceDetector() conf, faceboxes, mboxes = fd.get_faceboxes(image) color = [255, 255, 255] # border widths; I set them all to 150 top, bottom, left, right = [120] * 4 image = cv2.copyMakeBorder(image, top, bottom, left, right, cv2.BORDER_CONSTANT, value=color) bbox_mark_image = image.copy() # get alignment model predictor_model = MAIN_PATH + "/models/shape_predictor_68_face_landmarks.dat" face_pose_predictor = dlib.shape_predictor(predictor_model) face_aligner = openface.AlignDlib(predictor_model) # init predection model predictor_5_point_model = face_recognition_models.pose_predictor_five_point_model_location( ) pose_predictor_5_point = dlib.shape_predictor(predictor_5_point_model) face_recognition_model = face_recognition_models.face_recognition_model_location( ) face_encoder = dlib.face_recognition_model_v1(face_recognition_model) for i in range(len(faceboxes)): # get dlib rectangle from facebox face_rect = dlib.rectangle(faceboxes[i][0], faceboxes[i][1], faceboxes[i][2], faceboxes[i][3]) # Get the the face's pose pose_landmarks = face_pose_predictor(image, face_rect) # Use openface to calculate and perform the face alignment alignedFace = face_aligner.align( 534, image, face_rect, landmarkIndices=openface.AlignDlib.OUTER_EYES_AND_NOSE) alignedFace_out = cv2.resize(alignedFace, (faceboxes[i][2] - faceboxes[i][0], faceboxes[i][3] - faceboxes[i][1])) initFace_out = image[faceboxes[i][1]:faceboxes[i][3], faceboxes[i][0]:faceboxes[i][2]] init_align_faces.append([initFace_out, alignedFace_out]) # draw marks parts = dlib.full_object_detection.parts(pose_landmarks) FaceDetector.draw_marks(bbox_mark_image, parts) # get face landmarks for feature extraction landmark_set = pose_predictor_5_point( alignedFace, dlib.rectangle(0, 0, alignedFace.shape[0], alignedFace.shape[1])) # get feature vector feature_vector = np.array( face_encoder.compute_face_descriptor(alignedFace, landmark_set, 1)) # known_face_encode = np.loadtxt('persons/MXG/fv.txt') ind = compare_faces(known_face_encodes, feature_vector) if (ind != -1): face_class = classes[ind] colour = (0, 255, 0) else: face_class = "Unknown" colour = (0, 0, 255) sh = max(image.shape[0], image.shape[1]) mult = sh / 500 if mult < 1: mult = 1 cv2.putText(image, face_class, (faceboxes[i][0], faceboxes[i][1] - 10), cv2.FONT_HERSHEY_SIMPLEX, 0.5 * mult, colour, 1) cv2.rectangle(bbox_mark_image, (faceboxes[i][0], faceboxes[i][1]), (faceboxes[i][2], faceboxes[i][3]), (0, 255, 0)) cv2.rectangle(image, (faceboxes[i][0], faceboxes[i][1]), (faceboxes[i][2], faceboxes[i][3]), (0, 255, 0)) #cv2.rectangle(image, (mboxes[i][0], mboxes[i][1]), (mboxes[i][2], mboxes[i][3]), (0, 255, 0)) #out_arr.append({'x1': faceboxes[i][0], 'y1': faceboxes[i][1], 'x2': faceboxes[i][2], 'y2': faceboxes[i][3], 'class': face_class, 'conf': conf[i]}) out_arr.append({ 'x1': mboxes[i][0], 'y1': mboxes[i][1], 'x2': mboxes[i][2], 'y2': mboxes[i][3], 'class': face_class, 'conf': conf[i] }) t = time.clock() - t out_imgs = [image, bbox_mark_image, init_align_faces, t] if mode == 'test': cv2.imshow("Preview", image) cv2.waitKey(0) cv2.destroyAllWindows() if mode == 'metr': #cv2.imshow("Preview", image) #cv2.waitKey(0) #cv2.destroyAllWindows() return out_arr if mode == 'process': return out_imgs if mode == 'def': return out_imgs