def process(input, output, frame_skip): detector = dlib.get_frontal_face_detector() sp = dlib.shape_predictor("shape_predictor_68_face_landmarks.dat") vidcap = cv.VideoCapture(input) success, image = vidcap.read() image = rotate_image(image, -90) image = cv.cvtColor(image, cv.COLOR_BGR2RGB) count = 0 while success: image_path = "%s/%04d" % (output, count) if count % frame_skip == 0: dets = detector(image) if (len(dets) > 0): d = dets[0] shape = sp(image, d) else: print("face not found") dlib.save_face_chip(image, shape, image_path, size=FACE_SIZE, padding=0.25) success, image = vidcap.read() if success: image = rotate_image(image, -90) image = cv.cvtColor(image, cv.COLOR_BGR2RGB) count += 1
def get_face_descriptor(self, file): img = io.imread(str(file)) detections = self.detector(img, 1) if len(detections) > 0: d = detections[0] shape = self.sp(img, d) dlib.save_face_chip(img, shape, str(file)[:-4] + const.file_with_face_suffix) return self.facerec.compute_face_descriptor(img, shape)
def face_align(src, dest): for label in os.listdir(src): label_src = os.path.join(src, label) label_dest = os.path.join(dest, label) if not os.path.isdir(label_dest): os.makedirs(label_dest) for file in os.listdir(label_src): in_abspath = os.path.join(label_src, file) img = dlib.load_rgb_image(in_abspath) faces = detector(img, 1) for i, face in enumerate(faces): shape = sp(img, face) out_abspath = os.path.join(label_dest, str(i)) dlib.save_face_chip(img, shape, out_abspath, size=96)
def process(left, right): detector = dlib.get_frontal_face_detector() sp = dlib.shape_predictor("shape_predictor_68_face_landmarks.dat") left_img = cv.imread(left) left_img = cv.cvtColor(left_img, cv.COLOR_BGR2RGB) left_dets = detector(left_img) if(len(left_dets) > 0): d = left_dets[0] shape = sp(left_img, d) dlib.save_face_chip(left_img, shape, "left_dlib_chip", size=im_w, padding=0.25) else: print("left face not found") right_img = cv.imread(right) right_img = cv.cvtColor(right_img, cv.COLOR_BGR2RGB) right_dets = detector(right_img) if(len(right_dets) > 0): d = right_dets[0] shape = sp(right_img, d) dlib.save_face_chip(right_img, shape, "right_dlib_chip", size=im_w, padding=0.25) else: print("right face not found") hsv = get_flow("left_dlib_chip.jpg", "right_dlib_chip.jpg") img = cv.cvtColor(hsv, cv.COLOR_HSV2BGR) filename = "optical_flow.png" cv.imwrite(filename, img) # load YAML and create model yaml_file = open('model.yaml', 'r') loaded_model_yaml = yaml_file.read() yaml_file.close() loaded_model = model_from_yaml(loaded_model_yaml) # load weights into new model loaded_model.load_weights("model.h5") print("Loaded model from disk") X = np.array([img], dtype=float) X /= 255 sample = X.reshape((-1, im_h, im_w, 3)) classes = loaded_model.predict(sample) if np.argmax(classes) == 1: print("live") else: print("fraud")
def save_cluster_chips(self, root_dir=None, size=224, padding=0.25): if not root_dir: root_dir = self.images_root_dir cluster_root_dir = os.path.join(root_dir, "face_chip_clusters") self.maybe_make_dir(cluster_root_dir) for label_idx in list(set(self.labels)): label_dir = os.path.join(cluster_root_dir, str(label_idx)) self.maybe_make_dir(label_dir) for i, index in enumerate(self.indices): image_file, shape = self.images[index] img = self.load_image_file(image_file) l = self.labels[index] output_folder_path = os.path.join(cluster_root_dir, str(l)) file_path = os.path.join(output_folder_path, "face_" + str(i)) dlib.save_face_chip(img, shape, file_path, size=224, padding=0.25)
def landmark(filepath): filepath = filepath.replace("\\", "/") predictor_path = "samples/models/shape_predictor_5_face_landmarks.dat" face_rec_model_path = "samples/models/dlib_face_recognition_resnet_model_v1.dat" files_dir = file_dir(filepath) + '/' detector = dlib.get_frontal_face_detector() predictor = dlib.shape_predictor(predictor_path) facerec = dlib.face_recognition_model_v1(face_rec_model_path) print("Processing file: {}".format(filepath)) img = io.imread(filepath) # Ask the detector to find the bounding boxes of each face. The 1 in the # second argument indicates that we should upsample the image 1 time. This # will make everything bigger and allow us to detect more faces. dets = detector(img, 1) print("Number of faces detected: {}".format(len(dets))) locations = [] for l in dets: locations.append([l.left(), l.right(), l.top(), l.bottom()]) SaveImage(filepath, locations) ##faces = dlib.full_object_detections() for k, d in enumerate(dets): # Get the landmarks/parts for the face in box d. shape = predictor(img, d) ##faces.append(shape) face_descriptor = facerec.compute_face_descriptor(img, shape) filenames = nsfile(1) dlib.save_face_chip(img, shape, files_dir + filenames[0], 150, 0.25) fps = [] for p in face_descriptor: fps.append(p) SaveFace(filenames[0] + '.jpg', fps, filepath)
def do_alignment(img, bbox): fh, temp_file = tempfile.mkstemp('.jpg') os.close(fh) temp_file_no_ext = ".".join(temp_file.rsplit('.')[:-1]) d = dlib.rectangle(bbox.x, bbox.y, bbox.x + bbox.w, bbox.y + bbox.h) # num_pts = len(source_pts) num_pts = 5 try: landmark_predictor = landmark_predictors[str(num_pts)] except KeyError: raise Exception("Incorrect number of landmarks") detection_object = landmark_predictor(img, d) chip_size = 150 border = 0.2 dlib.save_face_chip(img, detection_object, temp_file_no_ext, chip_size, border) # Playing with OpenCVs geometric transforms - they don't work out of the box # due to faces not being a plane. # sample_idx = np.random.choice(source_pts.shape[0], 4, replace=False) # sample_source_pts = source_pts[sample_idx, :] # sample_target_pts = target_pts[sample_idx, :] # M = cv2.getPerspectiveTransform(sample_source_pts, sample_target_pts) # dst_img = cv2.warpPerspective(img, M, (300, 300)) # H = cv2.findHomography(source_pts, target_pts, cv2.CV_RANSAC) # dst_img = cv2.warpPerspective(img, H, (300, 300)) aligned_img = cv2.cvtColor(ioimg.imread(temp_file), cv2.COLOR_RGB2BGR) os.remove(temp_file) ret, buf = cv2.imencode('.jpg', aligned_img) return buf.tobytes()
import sys import os import dlib from glob import glob import shutil as st predictor_path = 'shape_predictor_68_face_landmarks.dat' face_rec_model_path = 'dlib_face_recognition_resnet_model_v1.dat' faces_folder_path = '../UTKface_inthewild_frontalization2/' save_folder_path = '../UTKface_inthewild_frontalization3/' detector = dlib.get_frontal_face_detector() sp = dlib.shape_predictor(predictor_path) facerec = dlib.face_recognition_model_v1(face_rec_model_path) file_names = glob(faces_folder_path + '/*jpg') for i in range(len(file_names)): file_name = file_names[i] print(file_name) img = dlib.load_rgb_image(file_name) dets = detector(img, 1) if len(dets) is 1: for k, d in enumerate(dets): shape = sp(img, d) dlib.save_face_chip(img, shape, "thumbnail", size=260, padding=0.1) st.copy2("thumbnail.jpg", save_folder_path + file_name.split('\\')[1])
def clustering(self, image_list=None, output_folder_path=configs_clustering_output_folder, shape_predictor_path=config_shape_predictor_path, recognition_model_path=config_recognition_model_path): """ 人脸聚类函数:使用聚类分析方式进行人脸识别,可以在某一群人中认出特定的人 首先假设最大的群集将包含照片集中的普通人照片 然后提取人脸图像保存150x150格式的最大聚类中 TODO: 可以保存所有大于2的聚类到文件夹中 这里图片不能使用黑白的,否则报错: RuntimeError: Unsupported image type, must be RGB image. """ if not os.path.isdir(output_folder_path): os.makedirs(output_folder_path) detector = dlib.get_frontal_face_detector() shape_predictor = dlib.shape_predictor(shape_predictor_path) recognition_model = dlib.face_recognition_model_v1( recognition_model_path) descriptors = [] images = [] # 找到所有人脸并为每个人脸计算出128维人脸描述器 for i in image_list: print('正在处理图片: {}'.format(i)) img = io.imread(i) dets = detector(img, 1) num_faces = len(dets) if num_faces == 0: print("没有找到人脸,文件路径{}".format(i)) continue print('检测到的人脸数: {}'.format(num_faces)) for k, d in enumerate(dets): # 得到的人脸特征点/部分在矩形框d中 shape = shape_predictor(img, d) # 计算128维向量描述的人脸形状 face_descriptor = recognition_model.compute_face_descriptor( img, shape) descriptors.append(face_descriptor) images.append((img, shape)) # 对人脸进行聚类 labels = dlib.chinese_whispers_clustering(descriptors, 0.5) num_classes = len(set(labels)) print("聚类的数量: {}".format(num_classes)) # 找到人脸聚类最多的那个类 biggest_class = None biggest_class_length = 0 for i in range(0, num_classes): class_length = len([label for label in labels if label == i]) if class_length > biggest_class_length: biggest_class_length = class_length biggest_class = i print("最大聚类的索引号: {}".format(biggest_class)) print("最大聚类中存储的人脸数: {}".format(biggest_class_length)) # 生成最大聚类生成索引 indices = [] for i, label in enumerate(labels): if label == biggest_class: indices.append(i) print("最大聚类中的图片索引:{}".format(str(indices))) # 确认输出字典的存在 if not os.path.isdir(output_folder_path): os.makedirs(output_folder_path) # 保存提取出来的脸部 print('正在保存最大s聚类到脸部文件夹{}'.format(output_folder_path)) for i, index in enumerate(indices): img, shape = images[index] file_path = os.path.join(output_folder_path, 'face_' + str(i)) # 大小(size)和填充(padding)参数默认设置为150x150, 0.25 dlib.save_face_chip(img, shape, file_path, size=150, padding=0.25)
def custom_test(self, testing_samples_dir, age, gender): if not self.load_checkpoint(): print("\tFAILED >_<!") exit(0) else: print("\tSUCCESS ^_^") predictor_path = 'shape_predictor_68_face_landmarks.dat' detector = dlib.get_frontal_face_detector() sp = dlib.shape_predictor(predictor_path) num_samples = int(np.sqrt(self.size_batch)) file_names = glob(testing_samples_dir) for i in range(len(file_names)): file_name = file_names[i] img = dlib.load_rgb_image(file_name) dets = detector(img, 1) if len(dets) is 1: for k, d in enumerate(dets): shape = sp(img, d) dlib.save_face_chip(img, shape, "test/result/thumbnail", size=256, padding=0.1) sample_files = [] for j in range(num_samples): sample_files.append("test/result/thumbnail.jpg") sample = [ load_image( image_path=sample_file, image_size=self.size_image, image_value_range=self.image_value_range, is_gray=(self.num_input_channels == 1), ) for sample_file in sample_files ] if self.num_input_channels == 1: images = np.array(sample).astype(np.float32)[:, :, :, None] else: images = np.array(sample).astype(np.float32) gender_male = np.ones( shape=(num_samples, 2), dtype=np.float32) * self.image_value_range[0] gender_female = np.ones( shape=(num_samples, 2), dtype=np.float32) * self.image_value_range[0] for i in range(gender_male.shape[0]): gender_male[i, 0] = self.image_value_range[-1] gender_female[i, 1] = self.image_value_range[-1] if 0 <= age <= 5: label = 0 elif 6 <= age <= 10: label = 1 elif 11 <= age <= 15: label = 2 elif 16 <= age <= 20: label = 3 elif 21 <= age <= 30: label = 4 elif 31 <= age <= 40: label = 5 elif 41 <= age <= 50: label = 6 elif 51 <= age <= 60: label = 7 elif 61 <= age <= 70: label = 8 else: label = 9 if gender is 0: self.test(images, gender_male, 'test.png') else: self.test(images, gender_female, 'test.png') img = cv2.imread(self.save_dir + '/test/test.png') a = 128 * label b = 128 * (label + 1) img0 = img[a:b, a:b] cv2.imwrite('test/result/thumbnail.png', img0) try: output = faceSwap('test/result/thumbnail.png', file_name) cv2.imwrite( 'test/result/' + str(age) + '_' + str(gender) + '_' + file_name.split('\\')[1], output) input = cv2.imread(file_name) cv2.imshow('input', input) cv2.imshow('output', output) cv2.waitKey(0) print('\n\tDone! Results are saved as %s' % 'test/result/' + str(age) + '_' + str(gender) + '_' + file_name.split('\\')[1]) except IndexError as e: print( 'Result The face is not normal. Please put good quality pictures in your input.' ) os.remove('test/result/thumbnail.png') os.remove('test/result/thumbnail.jpg')
if class_length > biggest_class_length: biggest_class_length = class_length biggest_class = i print("Biggest cluster id number: {}".format(biggest_class)) print("Number of faces in biggest cluster: {}".format(biggest_class_length)) # Find the indices for the biggest class indices = [] for i, label in enumerate(labels): if label == biggest_class: indices.append(i) print("Indices of images in the biggest cluster: {}".format(str(indices))) # Ensure output directory exists if not os.path.isdir(output_folder_path): os.makedirs(output_folder_path) # Save the extracted faces print("Saving faces in largest cluster to output folder...") for i, index in enumerate(indices): img, shape = images[index] file_path = os.path.join(output_folder_path, "face_" + str(i)) # The size and padding arguments are optional with default size=150x150 and padding=0.25 dlib.save_face_chip(img, shape, file_path, size=150, padding=0.25)
class_length = len([label for label in labels if label == i]) if class_length > biggest_class_length: biggest_class_length = class_length biggest_class = i print("Biggest cluster id number: {}".format(biggest_class)) print("Number of faces in biggest cluster: {}".format(biggest_class_length)) # Find the indices for the biggest class indices = [] for i, label in enumerate(labels): if label == biggest_class: indices.append(i) print("Indices of images in the biggest cluster: {}".format(str(indices))) # Ensure output directory exists if not os.path.isdir(output_folder_path): os.makedirs(output_folder_path) # Save the extracted faces print("Saving faces in largest cluster to output folder...") for i, index in enumerate(indices): img, shape = images[index] file_path = os.path.join(output_folder_path, "face_" + str(i)) dlib.save_face_chip(img, shape, file_path)
suc, frame = v_cap.read() #reading frames frame_id = v_cap.get(1) #getting frame number frames.append(frame) ts.append(count) count += 1 dets = detector( frame, 1 ) # Ask the detector to find the bounding boxes of each face. The 1 in the second argument indicates that we should upsample the image 1 time. This will make everything bigger and allow us to detect more faces. print("Number of faces detected: {}".format(len(dets))) # Now process each face we found. for k, d in enumerate(dets): # Get the landmarks/parts for the face in box d. # Compute the 128D vector that describes the face in img identified by shape. shape = sp(frame, d) face_descriptor = facerec.compute_face_descriptor(frame, shape) ff = np.array(face_descriptor).tolist() ptf.insert(ff) #print(type(frame)) #print(shape) #print(type(shape)) now = datetime.datetime.now() name = str(now.strftime("%d_%m_%Y")) + ' ' + str( now.strftime("%H_%M_%S")) #print(name) dlib.save_face_chip(frame, shape, './face/face{0}.jpg'.format(name), size=150, padding=0.25) v_cap.release()
def dlib_face_cluster(pic_path,tmp_path,files_path): global detector,sp,facerec predictor_path = files_path + '/shape_predictor_5_face_landmarks.dat' face_rec_model_path = files_path + '/dlib_face_recognition_resnet_model_v1.dat' faces_folder_path = pic_path output_folder_path = tmp_path # Load all the models we need: a detector to find the faces, a shape predictor # to find face landmarks so we can precisely localize the face, and finally the # face recognition model. if not 'detector' in globals(): detector = dlib.get_frontal_face_detector() if not 'sp' in globals(): sp = dlib.shape_predictor(predictor_path) if not 'facerec' in globals(): facerec = dlib.face_recognition_model_v1(face_rec_model_path) raw_image_list = glob.glob(os.path.join(faces_folder_path, "*.jpg")) raw_image_list.append(raw_image_list[0]) counter = 1 batch_index = 1 # Now find all the faces and compute 128D face descriptors for each face. while(True): descriptors = [] images = [] while(True): # print("Processing file: {}".format(f)) try: f = raw_image_list.pop(0) counter += 1 except: break try: img = io.imread(f) except: print('[Debug] : something wrong at io.imread, {0}'.format(f)) continue # Ask the detector to find the bounding boxes of each face. The 1 in the # second argument indicates that we should upsample the image 1 time. This # will make everything bigger and allow us to detect more faces. try: dets = detector(img, 1) except: print('[Debug] : something wrong at detector, {0}'.format(f)) continue # print("Number of faces detected: {}".format(len(dets))) # Now process each face we found. for k, d in enumerate(dets): # Get the landmarks/parts for the face in box d. shape = sp(img, d) # Compute the 128D vector that describes the face in img identified by # shape. try: face_descriptor = facerec.compute_face_descriptor(img, shape) descriptors.append(face_descriptor) images.append((img, shape)) except: print('[Debug] : something wrong at facerec.compute_face_descriptor, {0}'.format(f)) continue # Now let's cluster the faces. labels = dlib.chinese_whispers_clustering(descriptors, 0.5) num_classes = len(set(labels)) # print("Number of clusters: {}".format(num_classes)) # Find biggest class biggest_class = None biggest_class_length = 0 for i in range(0, num_classes): class_length = len([label for label in labels if label == i]) if class_length > biggest_class_length: biggest_class_length = class_length biggest_class = i # print("Biggest cluster id number: {}".format(biggest_class)) # print("Number of faces in biggest cluster: {}".format(biggest_class_length)) # Find the indices for the biggest class indices = [] for i, label in enumerate(labels): if label == biggest_class: indices.append(i) # print("Indices of images in the biggest cluster: {}".format(str(indices))) # Ensure output directory exists if not os.path.isdir(output_folder_path): os.makedirs(output_folder_path) # Save the extracted faces # print("Saving faces in largest cluster to output folder...") for i, index in enumerate(indices): img, shape = images[index] file_path = os.path.join(output_folder_path,'batch{0}_{1}'.format(batch_index,i)) dlib.save_face_chip(img, shape, file_path) break batch_index += 1 if len(raw_image_list) == 0: break
#labels = labels+1 #images_number = len(descriptors) #print("Number of images : {}".format(images_number)) labels = dlib.chinese_whispers_clustering(descriptors, 0.4) print("labels: {}".format(labels)) num_classes = len(set(labels)) print("Number of clusters: {}".format(num_classes)) noise = [i == 0 for i in list(labels)].count(True) print("Number of noise : {}".format(noise)) num_classes = len(set(labels)) print("Number of clusters : {}".format(num_classes)) print("labels: {}".format(labels)) face_dict = {} for i in range(num_classes): face_dict[i] = [] for i in range(len(labels)): face_dict[labels[i]].append(images[i]) for key in face_dict.keys(): file_dir = os.path.join(output_folder, str(key)) if not os.path.isdir(file_dir): os.makedirs(file_dir) for index, (image, shape) in enumerate(face_dict[key]): file_path = os.path.join(file_dir, 'face_' + str(index)) dlib.save_face_chip(image, shape, file_path, size=150, padding=0.25)
# It is possible to pass a list of images to the detector. # - like this: dets = cnn_face_detector([image list], upsample_num, batch_size = 128) # In this case it will return a mmod_rectangless object. # This object behaves just like a list of lists and can be iterated over. # ''' predictor_path = "shape_predictor_68_face_landmarks.dat" sp = dlib.shape_predictor(predictor_path) print("Number of faces detected: {}".format(len(dets))) counter = 0 for faces, prefix in zip(dets, f_prefix): img = io.imread(counter) for i, d in enumerate(faces): f_name = prefix + str(i) df.loc[counter] = [ fids[counter], pids[counter], i, f_name, d.rect.left(), d.rect.top(), d.rect.right(), d.rect.bottom(), d.confidence ] print( "Detection {}: Left: {} Top: {} Right: {} Bottom: {} Confidence: {}" .format(i, d.rect.left(), d.rect.top(), d.rect.right(), d.rect.bottom(), d.confidence)) shape = sp(img, d) dlib.save_face_chip(img, shape, dir_det_out + f_name + ".jpg") counter += 1 df.to_csv("dnn_face_detections_bb_2.csv")
def process(): mylogger = loger.getLoger("Whisper", Constants.boltpath + "logs") try: timenow = Blocker.current_milli_time() # Generic models video = DatabaseSession.session.query(Videos).first() # Some paths detector = dlib.get_frontal_face_detector() sp = dlib.shape_predictor( Constants.predictor_path) # 128D face descriptor predictor facerec = dlib.face_recognition_model_v1(Constants.face_rec_model_path) descriptors = [] images = [] # Now find all the faces and compute 128D face descriptors for each face. for f in glob.glob(os.path.join(Constants.faces_folder_path, "*.png")): mylogger.info("Processing file: {}".format(f)) img = dlib.load_rgb_image(f) # Ask the detector to find the bounding boxes of each face. The 1 in the # second argument indicates that we should upsample the image 1 time. This # will make everything bigger and allow us to detect more faces. dets = detector(img, 1) mylogger.info("Number of faces detected: {}".format(len(dets))) # Now process each face we found. for k, d in enumerate(dets): # Get the landmarks/parts for the face in box d. shape = sp(img, d) # Compute the 128D vector that describes the face in img identified by # shape. face_descriptor = facerec.compute_face_descriptor(img, shape) descriptors.append(face_descriptor) images.append((img, shape)) # Now let's cluster the faces. labels = dlib.chinese_whispers_clustering(descriptors, Constants.TOLERANCE_WHISPER) num_classes = len(set(labels)) mylogger.info("Number of clusters: {}".format(num_classes)) if num_classes > 0: # Find the indices for the biggest class indices = [] counts = 0 DatabaseSession.session.query(Wishper).filter( Wishper.video == video).delete() DatabaseSession.session.commit() for i, label in enumerate(labels): # Ensure output directory exists output_folder_path_real = Constants.output_folder_path + str( label) if not os.path.isdir(output_folder_path_real): os.makedirs(output_folder_path_real) # Save the extracted faces mylogger.info("Saving faces cluster to output folder...") img, shape = images[i] file_path = os.path.join(output_folder_path_real, "face_" + str(counts)) # The size and padding arguments are optional size=300x300 and padding=0.25 dlib.save_face_chip(img, shape, file_path, size=300, padding=0.25) counts = counts + 1 whisper = Wishper(alias=file_path, original_image=file_path, video=video, group=str(label), path=file_path + ".jpg") DatabaseSession.session.add(whisper) DatabaseSession.session.commit() except Exception as inst: mylogger.error("Python error.") mylogger.error(type(inst)) mylogger.error(inst)
for path in paths: img = imread(path) dets = detector(img, 1) for i, d in enumerate(dets): shape = predictor(img, d) face_vector = facerec.compute_face_descriptor(img, shape) vectors.append(face_vector) images.append((img, shape)) # 聚类函数 labels = dlib.chinese_whispers_clustering(vectors, 0.5) num_classes = len(set(labels)) print('共聚为 %d 类' % num_classes) biggest_class = Counter(labels).most_common(1) print(biggest_class) output_dir = 'most_common' if not os.path.exists(output_dir): os.mkdir(output_dir) face_id = 1 for i in range(len(images)): if labels[i] == biggest_class[0][0]: img, shape = images[i] # 把人脸切出来 dlib.save_face_chip(img, shape, output_dir + '/face_%d' % face_id, size=150, padding=0.25) face_id += 1
def save_face_chip(option): dlib.save_face_chip(option['img'], option['shape'], option['file_path'], size=150, padding=0.25)
def detect_from_webcam(save_video): cap = cv2.VideoCapture(0) width, height = query_capture(cap) do_loop = True # face detection/localization face_detector_dlib_hog = dlib.get_frontal_face_detector() face_detector_dlib_cnn = dlib.cnn_face_detection_model_v1( cnn_face_detector_path) face_detector_opencv_haarcascade = cv2.CascadeClassifier(cascade_path) # landmark prediction landmark68_predictor = dlib.shape_predictor(landmark68_predictor_path) landmark5_predictor = dlib.shape_predictor(landmark5_predictor_path) # face recognition facerec = dlib.face_recognition_model_v1(recognition_model_path) landmark_predictors = [landmark5_predictor, landmark68_predictor] landmark_idx = 0 num_face_detectors = 3 face_idx = 0 last_identity = np.zeros((128, )) chip_size = 150 border = 0.2 if save_video: videowriter = cv2.VideoWriter("test.avi", cv2.VideoWriter_fourcc(*'DIV4'), 20, (width, height)) chip_size = 300 border = 1.0 videowriter_aligned = cv2.VideoWriter("test_align.avi", cv2.VideoWriter_fourcc(*'DIV4'), 20, (chip_size, chip_size)) fh, temp_file = tempfile.mkstemp('.jpg') os.close(fh) temp_file_no_ext = ".".join(temp_file.rsplit('.')[:-1]) while (do_loop): # Capture frame-by-frame ret, frame = cap.read() img = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB) dets = [] # face detection if face_idx == 0: gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY) faces = face_detector_opencv_haarcascade.detectMultiScale( gray, scaleFactor=1.05, minNeighbors=5, minSize=(100, 100), flags=cv2.CASCADE_SCALE_IMAGE) # Convert to array of dlib rectangles for (x, y, w, h) in faces: dets.append(dlib.rectangle(x, y, x + w, y + h)) elif face_idx == 1: dets = face_detector_dlib_hog(img, 1) else: cnn_dets = face_detector_dlib_cnn(img, 1) for cnn_d in cnn_dets: # different return type because it includes confidence, get the rect d = cnn_d.rect h = d.top() - d.bottom() # cnn max margin detector seems to cut off the chin and this confuses landmark predictor, # expand height by 10% dets.append( dlib.rectangle(d.left(), d.top(), d.right(), d.bottom() - int(h / 10.0))) print("Number of faces detected: {}".format(len(dets))) landmarks = [None] * len(dets) for i, d in enumerate(dets): #print("Detection {}, score: {}, face_type:{}".format( # d, scores[i], idx[i])) #print("Detection {}: Left: {} Top: {} Right: {} Bottom: {}".format( # i, d.left(), d.top(), d.right(), d.bottom())) landmark_predictor = landmark_predictors[landmark_idx] detection_object = landmark_predictor(img, d) # This is a hack to get the aligned face image via the dlib API # It writes to a file that we have to read back # `compute_face_descriptor` recomputes the alignment and won't accept a differently aligned face dlib.save_face_chip(img, detection_object, temp_file_no_ext, chip_size, border) aligned_img = cv2.cvtColor(io.imread(temp_file), cv2.COLOR_RGB2BGR) if save_video: videowriter_aligned.write(aligned_img) cv2.imshow("aligned", aligned_img) landmarks[i] = detection_object.parts() face_descriptor = facerec.compute_face_descriptor( img, detection_object, 10) # TODO: this currently is just comparing to the last frame. Won't handle multiple faces. # To handle multiple faces we need to compare distance to all previous identities, or # track the bbox movement new_identity = np.matrix(face_descriptor) print("Distance to last identity %.4f" % np.linalg.norm(last_identity - new_identity)) last_identity = new_identity render_bounding_boxes(frame, dets) render_landmarks(frame, landmarks) cv2.imshow("Faces found", frame) if save_video: videowriter.write(frame) key = cv2.waitKey(1) & 0xFF if key != -1: if key == ord('q'): do_loop = False elif key == ord('l'): landmark_idx += 1 landmark_idx %= len(landmark_predictors) elif key == ord('d'): face_idx += 1 face_idx %= num_face_detectors os.remove(temp_file) cv2.destroyAllWindows() cap.release()
cap.release() # Cluster the faces. labels = dlib.chinese_whispers_clustering(descriptors, 0.5) num_classes = len(set(labels)) # Total number of clusters print("Number of clusters: {}".format(num_classes)) for i in range(0, num_classes): indices = [] class_length = len([label for label in labels if label == i]) for j, label in enumerate(labels): if label == i: indices.append(j) print("Indices of images in the cluster {0} : {1}".format(str(i),str(indices))) print("Size of cluster {0} : {1}".format(str(i),str(class_length))) output_folder_path = output_folder +'./'+ str(i) # Output folder for each cluster os.path.normpath(output_folder_path) os.makedirs(output_folder_path) # Save each face to the respective cluster folder print("Saving faces to output folder...") for k, index in enumerate(indices): img, shape = images[index] file_path = os.path.join(output_folder_path,"face_"+str(k)+"_"+str(i)) dlib.save_face_chip(img, shape, file_path) print("--- %s seconds ---" % (time.time() - start))
def cluster_images(faces_folder_path,output_folder_path,output_folder_path1,predictor_path,face_rec_model_path,output_folder_path2,json_name): # Load all the models we need: a detector to find the faces, a shape predictor # to find face landmarks so we can precisely localize the face, and finally the # face recognition model. from_date = (datetime.datetime.now()) detector = dlib.get_frontal_face_detector() sp = dlib.shape_predictor(predictor_path) facerec = dlib.face_recognition_model_v1(face_rec_model_path) if os.path.exists(json_name): img_dict = json.loads(open(json_name, "r").read()) else: img_dict={} descriptors = [] images = [] image_names=[] # Now find all the faces and compute 128D face descriptors for each face. for l,f in enumerate(glob.glob(os.path.join(faces_folder_path, "*"))): print("Processing file: {}".format(f)) print("[INFO] processing image {}/{}".format(l + 1, len(os.listdir(faces_folder_path)))) img = dlib.load_rgb_image(f) img_name=f.split(os.path.sep)[-1] #print('img_name',img_name) # Ask the detector to find the bounding boxes of each face. The 1 in the # second argument indicates that we should upsample the image 1 time. This # will make everything bigger and allow us to detect more faces. dets = detector(img) print("Number of faces detected: {}".format(len(dets))) # Now process each face we found. for k, d in enumerate(dets): #d= dlib.rectangle(d.left()-500, d.top()-500,d.right()+50, d.bottom()+50) # Get the landmarks/parts for the face in box d. shape = sp(img, d) # Compute the 128D vector that describes the face in img identified by # shape. face_descriptor = facerec.compute_face_descriptor(img, shape) descriptors.append(face_descriptor) images.append((img, shape)) image_names.append(img_name) # Now let's cluster the faces. labels = dlib.chinese_whispers_clustering(descriptors, 0.4) num_classes = len(set(labels)) for j in range(0, num_classes): indices = [] for i, label in enumerate(labels): if label == j: indices.append(i) if len(indices) >1 : # Ensure output directory exists if not os.path.isdir(output_folder_path+'/####'+str(j)): os.makedirs(output_folder_path+'/####'+str(j)) if not os.path.isdir(output_folder_path1+'/####'+str(j)): os.makedirs(output_folder_path1+'/####'+str(j)) if not os.path.isdir(output_folder_path2): os.makedirs(output_folder_path2) name_of_images=[] # Save the extracted faces for i, index in enumerate(indices): name_image=currentDT.strftime("%Y-%m-%d %H:%M:%S") img, shape = images[index] name_of_images.append(image_names[index]) file_path = os.path.join(output_folder_path+'/####'+str(j),str(name_image)+str(j)+'-'+str(i)) # The size and padding arguments are optional with default size=150x150 and padding=0.25 dlib.save_face_chip(img, shape, file_path, size=150, padding=0.25) file_path1 = os.path.join(output_folder_path1+'/####'+str(j), str(name_image)+str(j)+'-'+str(i)+'.jpg') #image path must end with one of [.bmp, .png, .dng, .jpg, .jpeg] for dlib.save_image dlib.save_image(img,file_path1) f1 = open(output_folder_path2+'/####'+str(j)+'.txt', "a") f1.write(str(name_image)+str(j)+'-'+str(i)+'.jpg'+'\n') f1.close() #img_dict.update({'####'+str(j): name_of_images} ) img_dict['####'+str(j)] = name_of_images f = open(json_name, "w") f.write(json.dumps(img_dict)) f.close() to_date = (datetime.datetime.now()) print('clustering inages time',to_date-from_date)