github/deepface
1
1
Fork 0
mirror of https://github.com/serengil/deepface.git synced 2025-06-07 12:05:22 +00:00
Code Issues Packages Projects Releases Wiki Activity

detector mechanism

Browse Source
This commit is contained in:
Sefik Ilkin Serengil 2021-04-28 21:42:58 +03:00
parent 1e8733035d
commit b898f97b38
10 changed files with 407 additions and 376 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
.gitignore vendored
View File

@ -14,6 +14,7 @@ deepface/commons/__pycache__/*
deepface/basemodels/__pycache__/* deepface/basemodels/__pycache__/*
deepface/extendedmodels/__pycache__/* deepface/extendedmodels/__pycache__/*
deepface/subsidiarymodels/__pycache__/* deepface/subsidiarymodels/__pycache__/*
deepface/detectors/__pycache__/*
tests/dataset/*.pkl tests/dataset/*.pkl
.DS_Store .DS_Store
deepface/.DS_Store deepface/.DS_Store

5
deepface/DeepFace.py
View File

@ -774,7 +774,7 @@ def stream(db_path = '', model_name ='VGG-Face', distance_metric = 'cosine', ena
realtime.analysis(db_path, model_name, distance_metric, enable_face_analysis realtime.analysis(db_path, model_name, distance_metric, enable_face_analysis
, source = source, time_threshold = time_threshold, frame_threshold = frame_threshold) , source = source, time_threshold = time_threshold, frame_threshold = frame_threshold)
def detectFace(img_path, detector_backend = 'mtcnn'): def detectFace(img_path, detector_backend = 'mtcnn', enforce_detection = True):
""" """
This function applies pre-processing stages of a face recognition pipeline including detection and alignment This function applies pre-processing stages of a face recognition pipeline including detection and alignment
@ -790,7 +790,8 @@ def detectFace(img_path, detector_backend = 'mtcnn'):
functions.initialize_detector(detector_backend = detector_backend) functions.initialize_detector(detector_backend = detector_backend)
img = functions.preprocess_face(img = img_path, detector_backend = detector_backend)[0] #preprocess_face returns (1, 224, 224, 3) img = functions.preprocess_face(img = img_path, detector_backend = detector_backend
, enforce_detection = enforce_detection)[0] #preprocess_face returns (1, 224, 224, 3)
return img[:, :, ::-1] #bgr to rgb return img[:, :, ::-1] #bgr to rgb
#--------------------------- #---------------------------

385
deepface/commons/functions.py
View File

@ -2,18 +2,10 @@ import os
import numpy as np import numpy as np
import pandas as pd import pandas as pd
import cv2 import cv2
from pathlib import Path
import gdown
import hashlib
import math
from PIL import Image
import copy
import base64 import base64
import multiprocessing from pathlib import Path
import subprocess
import bz2 from deepface.detectors import FaceDetector
from deepface.commons import distance
from mtcnn import MTCNN #0.1.0
import tensorflow as tf import tensorflow as tf
tf_version = int(tf.__version__.split(".")[0]) tf_version = int(tf.__version__.split(".")[0])
@ -52,92 +44,7 @@ def initialize_input(img1_path, img2_path = None):
def initialize_detector(detector_backend): def initialize_detector(detector_backend):
global face_detector global face_detector
face_detector = FaceDetector.build_model(detector_backend)
home = str(Path.home())
#eye detector is common for opencv and ssd
if detector_backend == 'opencv' or detector_backend == 'ssd':
opencv_path = get_opencv_path()
eye_detector_path = opencv_path+"haarcascade_eye.xml"
if os.path.isfile(eye_detector_path) != True:
raise ValueError("Confirm that opencv is installed on your environment! Expected path ",eye_detector_path," violated.")
global eye_detector
eye_detector = cv2.CascadeClassifier(eye_detector_path)
#------------------------------
#face detectors
if detector_backend == 'opencv':
opencv_path = get_opencv_path()
face_detector_path = opencv_path+"haarcascade_frontalface_default.xml"
if os.path.isfile(face_detector_path) != True:
raise ValueError("Confirm that opencv is installed on your environment! Expected path ",face_detector_path," violated.")
face_detector = cv2.CascadeClassifier(face_detector_path)
elif detector_backend == 'ssd':
#check required ssd model exists in the home/.deepface/weights folder
#model structure
if os.path.isfile(home+'/.deepface/weights/deploy.prototxt') != True:
print("deploy.prototxt will be downloaded...")
url = "https://github.com/opencv/opencv/raw/3.4.0/samples/dnn/face_detector/deploy.prototxt"
output = home+'/.deepface/weights/deploy.prototxt'
gdown.download(url, output, quiet=False)
#pre-trained weights
if os.path.isfile(home+'/.deepface/weights/res10_300x300_ssd_iter_140000.caffemodel') != True:
print("res10_300x300_ssd_iter_140000.caffemodel will be downloaded...")
url = "https://github.com/opencv/opencv_3rdparty/raw/dnn_samples_face_detector_20170830/res10_300x300_ssd_iter_140000.caffemodel"
output = home+'/.deepface/weights/res10_300x300_ssd_iter_140000.caffemodel'
gdown.download(url, output, quiet=False)
face_detector = cv2.dnn.readNetFromCaffe(
home+"/.deepface/weights/deploy.prototxt",
home+"/.deepface/weights/res10_300x300_ssd_iter_140000.caffemodel"
)
elif detector_backend == 'dlib':
import dlib #this is not a must library within deepface. that's why, I didn't put this import to a global level. version: 19.20.0
global sp
face_detector = dlib.get_frontal_face_detector()
#check required file exists in the home/.deepface/weights folder
if os.path.isfile(home+'/.deepface/weights/shape_predictor_5_face_landmarks.dat') != True:
print("shape_predictor_5_face_landmarks.dat.bz2 is going to be downloaded")
url = "http://dlib.net/files/shape_predictor_5_face_landmarks.dat.bz2"
output = home+'/.deepface/weights/'+url.split("/")[-1]
gdown.download(url, output, quiet=False)
zipfile = bz2.BZ2File(output)
data = zipfile.read()
newfilepath = output[:-4] #discard .bz2 extension
open(newfilepath, 'wb').write(data)
sp = dlib.shape_predictor(home+"/.deepface/weights/shape_predictor_5_face_landmarks.dat")
elif detector_backend == 'mtcnn':
face_detector = MTCNN()
elif detector_backend == 'retinaface':
from retinaface import RetinaFace
face_detector = RetinaFace.build_model()
def initializeFolder(): def initializeFolder():
@ -157,16 +64,6 @@ def loadBase64Img(uri):
img = cv2.imdecode(nparr, cv2.IMREAD_COLOR) img = cv2.imdecode(nparr, cv2.IMREAD_COLOR)
return img return img
def get_opencv_path():
opencv_home = cv2.__file__
folders = opencv_home.split(os.path.sep)[0:-1]
path = folders[0]
for folder in folders[1:]:
path = path + "/" + folder
return path+"/data/"
def load_image(img): def load_image(img):
exact_image = False exact_image = False
@ -192,280 +89,25 @@ def load_image(img):
def detect_face(img, detector_backend = 'opencv', grayscale = False, enforce_detection = True): def detect_face(img, detector_backend = 'opencv', grayscale = False, enforce_detection = True):
home = str(Path.home())
img_region = [0, 0, img.shape[0], img.shape[1]] img_region = [0, 0, img.shape[0], img.shape[1]]
#if functions.preproces_face is called directly, then face_detector global variable might not been initialized. #if functions.preproces_face is called directly, then face_detector global variable might not been initialized.
if not "face_detector" in globals(): if not "face_detector" in globals():
initialize_detector(detector_backend = detector_backend) initialize_detector(detector_backend = detector_backend)
if detector_backend == 'opencv': detected_face, img_region = FaceDetector.detect_face(face_detector, detector_backend, img)
faces = []
try:
faces = face_detector.detectMultiScale(img, 1.3, 5)
except:
pass
if len(faces) > 0:
x,y,w,h = faces[0] #focus on the 1st face found in the image
detected_face = img[int(y):int(y+h), int(x):int(x+w)]
return detected_face, [x, y, w, h]
else: #if no face detected
if enforce_detection != True:
return img, img_region
else:
raise ValueError("Face could not be detected. Please confirm that the picture is a face photo or consider to set enforce_detection param to False.")
elif detector_backend == 'ssd':
ssd_labels = ["img_id", "is_face", "confidence", "left", "top", "right", "bottom"]
target_size = (300, 300)
base_img = img.copy() #we will restore base_img to img later
original_size = img.shape
img = cv2.resize(img, target_size)
aspect_ratio_x = (original_size[1] / target_size[1])
aspect_ratio_y = (original_size[0] / target_size[0])
imageBlob = cv2.dnn.blobFromImage(image = img)
face_detector.setInput(imageBlob)
detections = face_detector.forward()
detections_df = pd.DataFrame(detections[0][0], columns = ssd_labels)
detections_df = detections_df[detections_df['is_face'] == 1] #0: background, 1: face
detections_df = detections_df[detections_df['confidence'] >= 0.90]
detections_df['left'] = (detections_df['left'] * 300).astype(int)
detections_df['bottom'] = (detections_df['bottom'] * 300).astype(int)
detections_df['right'] = (detections_df['right'] * 300).astype(int)
detections_df['top'] = (detections_df['top'] * 300).astype(int)
if detections_df.shape[0] > 0:
#TODO: sort detections_df
#get the first face in the image
instance = detections_df.iloc[0]
left = instance["left"]
right = instance["right"]
bottom = instance["bottom"]
top = instance["top"]
detected_face = base_img[int(top*aspect_ratio_y):int(bottom*aspect_ratio_y), int(left*aspect_ratio_x):int(right*aspect_ratio_x)]
return detected_face, [int(left*aspect_ratio_x), int(top*aspect_ratio_y), int(right*aspect_ratio_x) - int(left*aspect_ratio_x), int(bottom*aspect_ratio_y) - int(top*aspect_ratio_y)]
else: #if no face detected
if enforce_detection != True:
img = base_img.copy()
return img, img_region
else:
raise ValueError("Face could not be detected. Please confirm that the picture is a face photo or consider to set enforce_detection param to False.")
elif detector_backend == 'dlib':
detections = face_detector(img, 1)
if len(detections) > 0:
for idx, d in enumerate(detections):
left = d.left(); right = d.right()
top = d.top(); bottom = d.bottom()
detected_face = img[top:bottom, left:right]
return detected_face, [left, top, right - left, bottom - top]
else: #if no face detected
if enforce_detection != True:
return img, img_region
else:
raise ValueError("Face could not be detected. Please confirm that the picture is a face photo or consider to set enforce_detection param to False.")
elif detector_backend == 'mtcnn':
img_rgb = cv2.cvtColor(img, cv2.COLOR_BGR2RGB) #mtcnn expects RGB but OpenCV read BGR
detections = face_detector.detect_faces(img_rgb)
if len(detections) > 0:
detection = detections[0]
x, y, w, h = detection["box"]
detected_face = img[int(y):int(y+h), int(x):int(x+w)]
return detected_face, [x, y, w, h]
else: #if no face detected
if not enforce_detection:
return img, img_region
else:
raise ValueError("Face could not be detected. Please confirm that the picture is a face photo or consider to set enforce_detection param to False.")
elif detector_backend == 'retinaface':
img_rgb = cv2.cvtColor(img, cv2.COLOR_BGR2RGB) #retinaface expects RGB but OpenCV read BGR
from retinaface import RetinaFace
faces = RetinaFace.extract_faces(img_rgb, align = True)
if len(faces) > 0:
face = faces[0]
return face, img_region
else: #if no face detected
if not enforce_detection:
return img, img_region
else:
raise ValueError("Face could not be detected. Please confirm that the picture is a face photo or consider to set enforce_detection param to False.")
if (isinstance(detected_face, np.ndarray)):
return detected_face, img_region
else: else:
detectors = ['opencv', 'ssd', 'dlib', 'mtcnn'] if detected_face == None:
raise ValueError("Valid backends are ", detectors," but you passed ", detector_backend) if enforce_detection != True:
return img, img_region
def alignment_procedure(img, left_eye, right_eye):
#this function aligns given face in img based on left and right eye coordinates
left_eye_x, left_eye_y = left_eye
right_eye_x, right_eye_y = right_eye
#-----------------------
#find rotation direction
if left_eye_y > right_eye_y:
point_3rd = (right_eye_x, left_eye_y)
direction = -1 #rotate same direction to clock
else:
point_3rd = (left_eye_x, right_eye_y)
direction = 1 #rotate inverse direction of clock
#-----------------------
#find length of triangle edges
a = distance.findEuclideanDistance(np.array(left_eye), np.array(point_3rd))
b = distance.findEuclideanDistance(np.array(right_eye), np.array(point_3rd))
c = distance.findEuclideanDistance(np.array(right_eye), np.array(left_eye))
#-----------------------
#apply cosine rule
if b != 0 and c != 0: #this multiplication causes division by zero in cos_a calculation
cos_a = (b*b + c*c - a*a)/(2*b*c)
angle = np.arccos(cos_a) #angle in radian
angle = (angle * 180) / math.pi #radian to degree
#-----------------------
#rotate base image
if direction == -1:
angle = 90 - angle
img = Image.fromarray(img)
img = np.array(img.rotate(direction * angle))
#-----------------------
return img #return img anyway
def align_face(img, detector_backend = 'opencv'):
home = str(Path.home())
if (detector_backend == 'opencv') or (detector_backend == 'ssd'):
detected_face_gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY) #eye detector expects gray scale image
eyes = eye_detector.detectMultiScale(detected_face_gray)
if len(eyes) >= 2:
#find the largest 2 eye
base_eyes = eyes[:, 2]
items = []
for i in range(0, len(base_eyes)):
item = (base_eyes[i], i)
items.append(item)
df = pd.DataFrame(items, columns = ["length", "idx"]).sort_values(by=['length'], ascending=False)
eyes = eyes[df.idx.values[0:2]] #eyes variable stores the largest 2 eye
#-----------------------
#decide left and right eye
eye_1 = eyes[0]; eye_2 = eyes[1]
if eye_1[0] < eye_2[0]:
left_eye = eye_1; right_eye = eye_2
else: else:
left_eye = eye_2; right_eye = eye_1 raise ValueError("Face could not be detected. Please confirm that the picture is a face photo or consider to set enforce_detection param to False.")
#-----------------------
#find center of eyes
left_eye = (int(left_eye[0] + (left_eye[2] / 2)), int(left_eye[1] + (left_eye[3] / 2)))
right_eye = (int(right_eye[0] + (right_eye[2]/2)), int(right_eye[1] + (right_eye[3]/2)))
img = alignment_procedure(img, left_eye, right_eye)
return img #return img anyway
elif detector_backend == 'dlib':
import dlib #this is not a must dependency in deepface
detections = face_detector(img, 1)
if len(detections) > 0:
detected_face = detections[0]
img_shape = sp(img, detected_face)
img = dlib.get_face_chip(img, img_shape, size = img.shape[0])
return img #return img anyway
elif detector_backend == 'mtcnn':
img_rgb = cv2.cvtColor(img, cv2.COLOR_BGR2RGB) #mtcnn expects RGB but OpenCV read BGR
detections = face_detector.detect_faces(img_rgb)
if len(detections) > 0:
detection = detections[0]
keypoints = detection["keypoints"]
left_eye = keypoints["left_eye"]
right_eye = keypoints["right_eye"]
img = alignment_procedure(img, left_eye, right_eye)
return img #return img anyway
elif detector_backend == 'retinaface':
#we used extract_faces function of retinaface. it applies alignment anyway.
return img #return img anyway
def preprocess_face(img, target_size=(224, 224), grayscale = False, enforce_detection = True, detector_backend = 'opencv', return_region = False): def preprocess_face(img, target_size=(224, 224), grayscale = False, enforce_detection = True, detector_backend = 'opencv', return_region = False):
#img_path = copy.copy(img)
#img might be path, base64 or numpy array. Convert it to numpy whatever it is. #img might be path, base64 or numpy array. Convert it to numpy whatever it is.
img = load_image(img) img = load_image(img)
base_img = img.copy() base_img = img.copy()
@ -474,10 +116,7 @@ def preprocess_face(img, target_size=(224, 224), grayscale = False, enforce_dete
#-------------------------- #--------------------------
if img.shape[0] > 0 and img.shape[1] > 0: if img.shape[0] == 0 or img.shape[1] == 0:
img = align_face(img = img, detector_backend = detector_backend)
else:
if enforce_detection == True: if enforce_detection == True:
raise ValueError("Detected face shape is ", img.shape,". Consider to set enforce_detection argument to False.") raise ValueError("Detected face shape is ", img.shape,". Consider to set enforce_detection argument to False.")
else: #restore base image else: #restore base image

55
deepface/detectors/DlibWrapper.py Normal file
View File

@ -0,0 +1,55 @@
from pathlib import Path
import gdown
import bz2
import os
def build_model():
home = str(Path.home())
import dlib #this requirement is not a must that's why imported here
#check required file exists in the home/.deepface/weights folder
if os.path.isfile(home+'/.deepface/weights/shape_predictor_5_face_landmarks.dat') != True:
print("shape_predictor_5_face_landmarks.dat.bz2 is going to be downloaded")
url = "http://dlib.net/files/shape_predictor_5_face_landmarks.dat.bz2"
output = home+'/.deepface/weights/'+url.split("/")[-1]
gdown.download(url, output, quiet=False)
zipfile = bz2.BZ2File(output)
data = zipfile.read()
newfilepath = output[:-4] #discard .bz2 extension
open(newfilepath, 'wb').write(data)
face_detector = dlib.get_frontal_face_detector()
return face_detector
def detect_face(face_detector, img):
import dlib #this requirement is not a must that's why imported here
home = str(Path.home())
sp = dlib.shape_predictor(home+"/.deepface/weights/shape_predictor_5_face_landmarks.dat")
detected_face = None
img_region = [0, 0, img.shape[0], img.shape[1]]
detections = face_detector(img, 1)
if len(detections) > 0:
for idx, d in enumerate(detections):
left = d.left(); right = d.right()
top = d.top(); bottom = d.bottom()
detected_face = img[top:bottom, left:right]
img_region = [left, top, right - left, bottom - top]
break #get the first one
img_shape = sp(img, detections[0])
detected_face = dlib.get_face_chip(img, img_shape, size = detected_face.shape[0])
return detected_face, img_region

96
deepface/detectors/FaceDetector.py Normal file
View File

@ -0,0 +1,96 @@
from deepface.detectors import OpenCvWrapper, SsdWrapper, DlibWrapper, MtcnnWrapper, RetinaFaceWrapper
from PIL import Image
import math
import numpy as np
from deepface.commons import distance
def build_model(detector_backend):
if detector_backend == 'opencv':
face_detector = OpenCvWrapper.build_model()
elif detector_backend == 'ssd':
face_detector = SsdWrapper.build_model()
elif detector_backend == 'dlib':
face_detector = DlibWrapper.build_model()
elif detector_backend == 'mtcnn':
face_detector = MtcnnWrapper.build_model()
elif detector_backend == 'retinaface':
face_detector = RetinaFaceWrapper.build_model()
else:
raise ValueError("invalid detector_backend passed - " + detector_backend)
return face_detector
def detect_face(face_detector, detector_backend, img):
if detector_backend == 'opencv':
face, region = OpenCvWrapper.detect_face(face_detector, img)
elif detector_backend == 'ssd':
face, region = SsdWrapper.detect_face(face_detector, img)
elif detector_backend == 'dlib':
face, region = DlibWrapper.detect_face(face_detector, img)
elif detector_backend == 'mtcnn':
face, region = MtcnnWrapper.detect_face(face_detector, img)
elif detector_backend == 'retinaface':
face, region = RetinaFaceWrapper.detect_face(face_detector, img)
else:
raise ValueError("invalid detector_backend passed - " + detector_backend)
return face, region
def alignment_procedure(img, left_eye, right_eye):
#this function aligns given face in img based on left and right eye coordinates
left_eye_x, left_eye_y = left_eye
right_eye_x, right_eye_y = right_eye
#-----------------------
#find rotation direction
if left_eye_y > right_eye_y:
point_3rd = (right_eye_x, left_eye_y)
direction = -1 #rotate same direction to clock
else:
point_3rd = (left_eye_x, right_eye_y)
direction = 1 #rotate inverse direction of clock
#-----------------------
#find length of triangle edges
a = distance.findEuclideanDistance(np.array(left_eye), np.array(point_3rd))
b = distance.findEuclideanDistance(np.array(right_eye), np.array(point_3rd))
c = distance.findEuclideanDistance(np.array(right_eye), np.array(left_eye))
#-----------------------
#apply cosine rule
if b != 0 and c != 0: #this multiplication causes division by zero in cos_a calculation
cos_a = (b*b + c*c - a*a)/(2*b*c)
angle = np.arccos(cos_a) #angle in radian
angle = (angle * 180) / math.pi #radian to degree
#-----------------------
#rotate base image
if direction == -1:
angle = 90 - angle
img = Image.fromarray(img)
img = np.array(img.rotate(direction * angle))
#-----------------------
return img #return img anyway

29
deepface/detectors/MtcnnWrapper.py Normal file
View File

@ -0,0 +1,29 @@
from mtcnn import MTCNN
import cv2
from deepface.detectors import FaceDetector
def build_model():
face_detector = MTCNN()
return face_detector
def detect_face(face_detector, img):
detected_face = None
img_region = [0, 0, img.shape[0], img.shape[1]]
img_rgb = cv2.cvtColor(img, cv2.COLOR_BGR2RGB) #mtcnn expects RGB but OpenCV read BGR
detections = face_detector.detect_faces(img_rgb)
if len(detections) > 0:
detection = detections[0]
x, y, w, h = detection["box"]
detected_face = img[int(y):int(y+h), int(x):int(x+w)]
img_region = [x, y, w, h]
keypoints = detection["keypoints"]
left_eye = keypoints["left_eye"]
right_eye = keypoints["right_eye"]
detected_face = FaceDetector.alignment_procedure(detected_face, left_eye, right_eye)
return detected_face, img_region

97
deepface/detectors/OpenCvWrapper.py Normal file
View File

@ -0,0 +1,97 @@
import cv2
import os
import pandas as pd
from deepface.detectors import FaceDetector
def build_model(model_name = 'haarcascade'):
opencv_path = get_opencv_path()
if model_name == 'haarcascade':
face_detector_path = opencv_path+"haarcascade_frontalface_default.xml"
if os.path.isfile(face_detector_path) != True:
raise ValueError("Confirm that opencv is installed on your environment! Expected path ",face_detector_path," violated.")
face_detector = cv2.CascadeClassifier(face_detector_path)
return face_detector
elif model_name == 'haarcascade_eye':
eye_detector_path = opencv_path+"haarcascade_eye.xml"
if os.path.isfile(eye_detector_path) != True:
raise ValueError("Confirm that opencv is installed on your environment! Expected path ",eye_detector_path," violated.")
eye_detector = cv2.CascadeClassifier(eye_detector_path)
return eye_detector
def detect_face(face_detector, img):
detected_face = None
img_region = [0, 0, img.shape[0], img.shape[1]]
faces = []
try:
faces = face_detector.detectMultiScale(img, 1.3, 5)
except:
pass
if len(faces) > 0:
x,y,w,h = faces[0] #focus on the 1st face found in the image
detected_face = img[int(y):int(y+h), int(x):int(x+w)]
detected_face = align_face(detected_face)
img_region = [x, y, w, h]
return detected_face, img_region
def align_face(img):
eye_detector = build_model(model_name = 'haarcascade_eye')
detected_face_gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY) #eye detector expects gray scale image
eyes = eye_detector.detectMultiScale(detected_face_gray)
if len(eyes) >= 2:
#find the largest 2 eye
base_eyes = eyes[:, 2]
items = []
for i in range(0, len(base_eyes)):
item = (base_eyes[i], i)
items.append(item)
df = pd.DataFrame(items, columns = ["length", "idx"]).sort_values(by=['length'], ascending=False)
eyes = eyes[df.idx.values[0:2]] #eyes variable stores the largest 2 eye
#-----------------------
#decide left and right eye
eye_1 = eyes[0]; eye_2 = eyes[1]
if eye_1[0] < eye_2[0]:
left_eye = eye_1; right_eye = eye_2
else:
left_eye = eye_2; right_eye = eye_1
#-----------------------
#find center of eyes
left_eye = (int(left_eye[0] + (left_eye[2] / 2)), int(left_eye[1] + (left_eye[3] / 2)))
right_eye = (int(right_eye[0] + (right_eye[2]/2)), int(right_eye[1] + (right_eye[3]/2)))
img = FaceDetector.alignment_procedure(img, left_eye, right_eye)
return img #return img anyway
def get_opencv_path():
opencv_home = cv2.__file__
folders = opencv_home.split(os.path.sep)[0:-1]
path = folders[0]
for folder in folders[1:]:
path = path + "/" + folder
return path+"/data/"

20
deepface/detectors/RetinaFaceWrapper.py Normal file
View File

@ -0,0 +1,20 @@
from retinaface import RetinaFace
import cv2
def build_model():
face_detector = RetinaFace.build_model()
return face_detector
def detect_face(face_detector, img):
face = None
img_region = [0, 0, img.shape[0], img.shape[1]]
img_rgb = cv2.cvtColor(img, cv2.COLOR_BGR2RGB) #retinaface expects RGB but OpenCV read BGR
faces = RetinaFace.extract_faces(img_rgb, align = True)
if len(faces) > 0:
face = faces[0][:, :, ::-1]
return face, img_region

92
deepface/detectors/SsdWrapper.py Normal file
View File

@ -0,0 +1,92 @@
import gdown
from pathlib import Path
import os
import cv2
import pandas as pd
from deepface.detectors import OpenCvWrapper
def build_model():
home = str(Path.home())
#model structure
if os.path.isfile(home+'/.deepface/weights/deploy.prototxt') != True:
print("deploy.prototxt will be downloaded...")
url = "https://github.com/opencv/opencv/raw/3.4.0/samples/dnn/face_detector/deploy.prototxt"
output = home+'/.deepface/weights/deploy.prototxt'
gdown.download(url, output, quiet=False)
#pre-trained weights
if os.path.isfile(home+'/.deepface/weights/res10_300x300_ssd_iter_140000.caffemodel') != True:
print("res10_300x300_ssd_iter_140000.caffemodel will be downloaded...")
url = "https://github.com/opencv/opencv_3rdparty/raw/dnn_samples_face_detector_20170830/res10_300x300_ssd_iter_140000.caffemodel"
output = home+'/.deepface/weights/res10_300x300_ssd_iter_140000.caffemodel'
gdown.download(url, output, quiet=False)
face_detector = cv2.dnn.readNetFromCaffe(
home+"/.deepface/weights/deploy.prototxt",
home+"/.deepface/weights/res10_300x300_ssd_iter_140000.caffemodel"
)
return face_detector
def detect_face(face_detector, img):
detected_face = None
img_region = [0, 0, img.shape[0], img.shape[1]]
ssd_labels = ["img_id", "is_face", "confidence", "left", "top", "right", "bottom"]
target_size = (300, 300)
base_img = img.copy() #we will restore base_img to img later
original_size = img.shape
img = cv2.resize(img, target_size)
aspect_ratio_x = (original_size[1] / target_size[1])
aspect_ratio_y = (original_size[0] / target_size[0])
imageBlob = cv2.dnn.blobFromImage(image = img)
face_detector.setInput(imageBlob)
detections = face_detector.forward()
detections_df = pd.DataFrame(detections[0][0], columns = ssd_labels)
detections_df = detections_df[detections_df['is_face'] == 1] #0: background, 1: face
detections_df = detections_df[detections_df['confidence'] >= 0.90]
detections_df['left'] = (detections_df['left'] * 300).astype(int)
detections_df['bottom'] = (detections_df['bottom'] * 300).astype(int)
detections_df['right'] = (detections_df['right'] * 300).astype(int)
detections_df['top'] = (detections_df['top'] * 300).astype(int)
if detections_df.shape[0] > 0:
#TODO: sort detections_df
#get the first face in the image
instance = detections_df.iloc[0]
left = instance["left"]
right = instance["right"]
bottom = instance["bottom"]
top = instance["top"]
detected_face = base_img[int(top*aspect_ratio_y):int(bottom*aspect_ratio_y), int(left*aspect_ratio_x):int(right*aspect_ratio_x)]
img_region = [int(left*aspect_ratio_x), int(top*aspect_ratio_y), int(right*aspect_ratio_x) - int(left*aspect_ratio_x), int(bottom*aspect_ratio_y) - int(top*aspect_ratio_y)]
detected_face = OpenCvWrapper.align_face(detected_face)
return detected_face, img_region

3
tests/unit_tests.py
View File

@ -166,7 +166,8 @@ dataset = [
['dataset/img6.jpg', 'dataset/img9.jpg', False], ['dataset/img6.jpg', 'dataset/img9.jpg', False],
] ]
models = ['VGG-Face', 'Facenet', 'OpenFace', 'DeepFace', 'DeepID', 'Dlib', 'ArcFace'] #models = ['VGG-Face', 'Facenet', 'OpenFace', 'DeepFace', 'DeepID', 'Dlib', 'ArcFace']
models = ['VGG-Face', 'Facenet', 'Dlib', 'ArcFace'] #those are robust models
metrics = ['cosine', 'euclidean', 'euclidean_l2'] metrics = ['cosine', 'euclidean', 'euclidean_l2']
passed_tests = 0; test_cases = 0 passed_tests = 0; test_cases = 0