def __init__(self, is_dlib = False, prefix = '.'):
# resolution of input and output image size.
self.resolution_inp = 256
self.resolution_op = 256
#---- load detectors
if is_dlib:
import dlib
detector_path = os.path.join(prefix, 'Data/net-data/mmod_human_face_detector.dat')
self.face_detector = dlib.cnn_face_detection_model_v1(
detector_path)
#---- load PRN
self.pos_predictor = PosPrediction(self.resolution_inp, self.resolution_op)
prn_path = os.path.join(prefix, 'Data/net-data/256_256_resfcn256_weight')
if not os.path.isfile(prn_path + '.data-00000-of-00001'):
print("please download PRN trained model first.")
exit()
self.pos_predictor.restore(prn_path)
# uv file
self.uv_kpt_ind = np.loadtxt(prefix + '/Data/uv-data/uv_kpt_ind.txt').astype(np.int32) # 2 x 68 get kpt
self.face_ind = np.loadtxt(prefix + '/Data/uv-data/face_ind.txt').astype(np.int32) # get valid vertices in the pos map
self.triangles = np.loadtxt(prefix + '/Data/uv-data/triangles.txt').astype(np.int32) # ntri x 3
self.uv_coords = self.generate_uv_coords()
def initialize(detector, scale_to=2048):
global dlib_detectors
global keras_model
global is_initialized
if not is_initialized:
dlib_cnn_face_detector_path = os.path.join(os.path.dirname(__file__), "mmod_human_face_detector.dat")
if not os.path.exists(dlib_cnn_face_detector_path):
raise Exception ("Error: Unable to find %s, reinstall the lib !" % (dlib_cnn_face_detector_path) )
if detector == 'cnn' or detector == "all":
dlib_cnn_face_detector = dlib.cnn_face_detection_model_v1(dlib_cnn_face_detector_path)
#DLIB and TF competiting for VRAM, so dlib must do first allocation to prevent OOM error
dlib_cnn_face_detector ( np.zeros ( (scale_to, scale_to, 3), dtype=np.uint8), 0 )
dlib_detectors.append(dlib_cnn_face_detector)
if detector == "hog" or detector == "all":
dlib_face_detector = dlib.get_frontal_face_detector()
dlib_face_detector ( np.zeros ( (scale_to, scale_to, 3), dtype=np.uint8), 0 )
dlib_detectors.append(dlib_face_detector)
keras_model_path = os.path.join( os.path.dirname(__file__) , "2DFAN-4.h5" )
if not os.path.exists(keras_model_path):
print ("Error: Unable to find %s, reinstall the lib !" % (keras_model_path) )
else:
print ("Info: initializing keras model...")
keras_model = keras.models.load_model (keras_model_path, custom_objects={'TorchBatchNorm2D': TorchBatchNorm2D} )
is_initialized = True
def create_detector(self, verbose, detector):
""" Add the requested detectors """
if self.initialized:
return
self.verbose = verbose
if detector == "dlib-cnn" or detector == "dlib-all":
if self.verbose:
print("Adding DLib - CNN detector")
self.detectors.append(dlib.cnn_face_detection_model_v1(
self.data_path))
if detector == "dlib-hog" or detector == "dlib-all":
if self.verbose:
print("Adding DLib - HOG detector")
self.detectors.append(dlib.get_frontal_face_detector())
self.initialized = True
def demo(isAlignment_5=True):
image_path = "./data/"
image_file = "test_1988.jpg"
im_raw = cv2.imread(image_path + image_file).astype('uint8')
# detector = dlib.get_frontal_face_detector()
model_path = "./models/mmod_human_face_detector.dat" # 基于 Maximum-Margin Object Detector 的深度学习人脸检测方案
detector = dlib.cnn_face_detection_model_v1(model_path)
im_raw = resize(im_raw, width=1200)
gray = cv2.cvtColor(im_raw, cv2.COLOR_BGR2GRAY)
rects = detector(gray, 1)
src_faces = []
for (i, rect) in enumerate(rects):
(x, y, w, h) = rect_to_bb(rect.rect)
detect_face = im_raw[y:y+h,x:x+w]
src_faces.append(detect_face)
cv2.rectangle(im_raw, (x, y), (x + w, y + h), (0, 255, 0), 2)
cv2.putText(im_raw, "Face: {}".format(i + 1), (x - 10, y - 10), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0, 255, 0), 2)
if isAlignment_5:
faces_aligned = face_alignment_5(im_raw, src_faces)
else:
faces_aligned = face_alignment_68(src_faces)
print("{} method, detect spend {}s ".format(("Alignment_5" if isAlignment_5 else "Alignment_68"), time.time()-startTime))
cv2.imshow("src", im_raw)
savePath = "./results/alignment/"
if not os.path.exists(savePath):
os.makedirs(savePath)
if isAlignment_5:
saveName = "_Align5.jpg"
else:
saveName = "_Align68.jpg"
i = 0
for face in faces_aligned:
cv2.imshow("det_{}".format(i), face)
cv2.imwrite(savePath + image_file[:-4] + "_{}".format(i) + saveName, face)
i = i + 1
cv2.waitKey(10)
def test_cnn_face_detector():
"""
You can get the mmod_human_face_detector.dat file from:\n
http://dlib.net/files/mmod_human_face_detector.dat.bz2
:return:
"""
img_path = 'data/running_man.jpg'
cnn_face_detector = dlib.cnn_face_detection_model_v1('mmod_human_face_detector.dat')
img = io.imread(img_path)
# upsample image 1 time, make everything bigger and allow us to detect more faces.
dets = cnn_face_detector(img, 2)
img_cv2 = cv2.imread(img_path)
for i, d in enumerate(dets):
print("Detection {}: Left: {} Top: {} Right: {} Bottom: {} Confidence: {}".format(
i, d.rect.left(), d.rect.top(), d.rect.right(), d.rect.bottom(), d.confidence))
cv2.rectangle(img_cv2, (d.rect.left(), d.rect.top()),
(d.rect.right(), d.rect.bottom()), color=(255, 0, 0), thickness=3)
cv2.imshow('img', img_cv2)
cv2.waitKey(0)
cv2.destroyAllWindows()
def __init__(self, is_dlib=False):
# resolution of input and output image size.
self.resolution_inp = 256
self.resolution_op = 256
#---- load detectors
if is_dlib:
import dlib
detector_path = pkg_resources.resource_filename(
__name__, 'assets/net-data/mmod_human_face_detector.dat')
self.face_detector = dlib.cnn_face_detection_model_v1(
detector_path)
#---- load PRN
self.pos_predictor = PosPrediction(self.resolution_inp,
self.resolution_op)
prn_path = pkg_resources.resource_filename(
__name__, 'assets/net-data/256_256_resfcn256_weight')
if not os.path.isfile(prn_path + '.data-00000-of-00001'):
print("please download PRN trained model first.")
exit()
self.pos_predictor.restore(prn_path)
# uv file
self.uv_kpt_ind = np.loadtxt(
pkg_resources.resource_filename(
__name__, 'assets/uv-data/uv_kpt_ind.txt')).astype(
np.int32) # 2 x 68 get kpt
self.face_ind = np.loadtxt(
pkg_resources.resource_filename(
__name__, 'assets/uv-data/face_ind.txt')).astype(
np.int32) # get valid vertices in the pos map
self.triangles = np.loadtxt(
pkg_resources.resource_filename(
__name__,
'assets/uv-data/triangles.txt')).astype(np.int32) # ntri x 3
self.uv_coords = self.generate_uv_coords()
def face_detector(img, detector='hog'):
'''
Detects faces in images from data
Args:
-----------------------------------------
img: numpy image array
detector: type of detector (Hog or Cnn) to detect faces
Returns:
------------------------------------------
Returns co-ordinates of rectangle bounding face in order (y1,y2,x1,x2)
'''
if detector.lower() == 'hog':
hogFaceDetector = dlib.get_frontal_face_detector()
faceRects = hogFaceDetector(img, 1)
faceRect = faceRects[0]
if faceRect.top() > 0 and faceRect.bottom() > 0 and faceRect.left(
) > 0 and faceRect.right() > 0:
return faceRect.top(), faceRect.bottom(), faceRect.left(
), faceRect.right()
else:
return None
elif detector.lower() == 'cnn':
dnnFaceDetector = dlib.cnn_face_detection_model_v1(
'./database/dlib-models/mmod_human_face_detector.dat')
rects = dnnFaceDetector(img, 1)
faceRect = rects[0]
if faceRect.rect.top() > 0 and faceRect.rect.bottom(
) > 0 and faceRect.rect.left() > 0 and faceRect.rect.right() > 0:
return faceRect.rect.top(), faceRect.rect.bottom(
), faceRect.rect.left(), faceRect.rect.right()
else:
return None
def detect_dog_face(file_path, image):
# 이미지 파일의 Grayscale화
image_gs = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
detector = dlib.cnn_face_detection_model_v1('dogHeadDetector.dat')
predictor = dlib.shape_predictor('landmarkDetector.dat')
# 강아지 얼굴 인식
faces = detector(image_gs, upsample_num_times=1)
if len(faces) == 0:
print("Fail to detecting face")
return
print("Success Face Detection!")
# TO-DO
# [76 31 83 83] -> x_pos, y_pos, width, height
face_count = 1
for (i, d) in enumerate(faces):
x1, y1 = d.rect.left(), d.rect.top()
x2, y2 = d.rect.right(), d.rect.bottom()
face_image = image[y1:y2, x1:x2] # y, x
if face_image.shape[0] > 64:
face_image = cv2.resize(face_image, (64, 64))
print(face_image.shape)
# Save 00_001.jpg -> 00_001_(face_count).jpg
path = pathlib.Path(file_path)
directory = str(path.parent.resolve())
filename = path.stem
extension = path.suffix
output_path = os.path.join(directory,
f"{filename}_{face_count:03}-{extension}")
print(
f"=================================OUTPUT File(절대 경로) : {output_path}"
)
try:
cv2.imwrite(output_path, face_image)
face_count = face_count + 1
except:
print("Exception occured : {}".format(output_path))
return
def __init__(self,
device,
path_to_detector=None,
verbose=False,
models_dir=None):
super().__init__(device, verbose, models_dir)
print(
'Warning: this detector is deprecated. Please use a different one, i.e.: S3FD.'
)
base_path = os.path.join(appdata_dir('face_alignment'), "data")
# Initialise the face detector
if 'cuda' in device:
if path_to_detector is None:
path_to_detector = os.path.join(
base_path, "mmod_human_face_detector.dat")
if not os.path.isfile(path_to_detector):
print("Downloading the face detection CNN. Please wait...")
path_to_temp_detector = os.path.join(
base_path, "mmod_human_face_detector.dat.download")
if os.path.isfile(path_to_temp_detector):
os.remove(os.path.join(path_to_temp_detector))
request_file.urlretrieve(
"https://www.adrianbulat.com/downloads/dlib/mmod_human_face_detector.dat",
os.path.join(path_to_temp_detector))
os.rename(os.path.join(path_to_temp_detector),
os.path.join(path_to_detector))
self.face_detector = dlib.cnn_face_detection_model_v1(
path_to_detector)
else:
self.face_detector = dlib.get_frontal_face_detector()
def main():
args = get_argparser().parse_args()
# load dataset and extract faces
detector = dlib.cnn_face_detection_model_v1(args.detector_model)
train_X, train_y = load_dataset(detector, Path(args.train_dir))
print(train_X.shape, train_y.shape)
val_X, val_y = load_dataset(detector, Path(args.val_dir))
print(val_X.shape, val_y.shape)
# uncomment this section if intermediate faces output are needed
# np.savez_compressed('5-celebrity-faces-dataset.npz', train_X, train_y, val_X, val_y)
# print("Save face embeddings to 5-celebrity-faces-dataset.npz")
model = dlib.face_recognition_model_v1(args.recog_model)
print(f"Loaded model from {args.recog_model}")
# convert faces to embeddings
embed_train_X = list()
for face_pixels in train_X:
embedding = get_embedding(model, face_pixels)
embed_train_X.append(embedding)
embed_train_X = np.asarray(embed_train_X)
print(embed_train_X.shape)
embed_val_X = list()
for face_pixels in val_X:
embedding = get_embedding(model, face_pixels)
embed_val_X.append(embedding)
embed_val_X = np.asarray(embed_val_X)
print(embed_val_X.shape)
np.savez_compressed('5-celebrity-faces-embeddings.npz', embed_train_X,
train_y, embed_val_X, val_y)
print(
f"Saved faces embeddings: {train_X.shape}, {train_y.shape}, {embed_val_X.shape}, {val_y.shape}"
)
def __init__(
self,
face_det_model_path,
predictor_path,
face_rec_model_path,
images_root_dir=os.getcwd(),
debug_level="INFO",
):
basicConfig(level=debug_level)
self.dlib_gpus = dlib.cuda.get_num_devices()
info("dlib BLAS Optimization: {}".format(dlib.DLIB_USE_BLAS))
info("dlib LAPACK Optimization: {}".format(dlib.DLIB_USE_LAPACK))
info("dlib CUDA Optimization: {}".format(dlib.DLIB_USE_CUDA))
info("dlib CUDA Devices: {}".format(self.dlib_gpus))
self.images_root_dir = images_root_dir
self.images_file_list = []
stamp = str(datetime.datetime.now().strftime("%Y_%m_%d_%H_%M_%S"))
self.dest_file_name = os.path.join(self.images_root_dir,
"face_db_" + stamp + ".json")
try:
info(face_det_model_path)
self.detector = dlib.cnn_face_detection_model_v1(
face_det_model_path)
self.mmod = True
info("Using Convolutional Neural Network method.")
except:
self.detector = dlib.get_frontal_face_detector()
self.mmod = False
info("Using Histogram of Oriented Gradients method.")
self.sp = dlib.shape_predictor(predictor_path)
self.shapes = []
self.facerec = dlib.face_recognition_model_v1(face_rec_model_path)
self.descriptors = []
self.images = []
def detectface3(filename=None):
detector = dlib.cnn_face_detection_model_v1(
'cache/mmod_human_face_detector.dat/mmod_human_face_detector.dat')
capture = cv.VideoCapture('cache/test.avi')
fps = capture.get(cv.CAP_PROP_FPS)
waittime = 1.0 / fps
faces = None
frameid = -1
while True:
start = time.time()
ret, frame = capture.read()
key = cv.waitKey(1)
if key == 27:
break
if ret:
frameid += 1
if frameid % 5 == 0:
gray = cv.cvtColor(frame, cv.COLOR_RGB2GRAY)
faces = detector(gray, 1)
elif (frameid - 1) % 5 == 0:
continue
for face in faces:
left = face.rect.left()
top = face.rect.top()
right = face.rect.right()
bottom = face.rect.bottom()
cv.rectangle(frame, (left, top), (right, bottom), (0, 255, 0),
3)
t = waittime - (time.time() - start)
print(t)
if t > 0:
time.sleep(t)
cv.imshow('audio', frame)
else:
break
capture.release()
cv.destroyAllWindows()
def __init__(self, use_cnn_face_detector=False):
# define landmarks numbers for different regions
self.left_eyelid = [0] + list(range(17, 22)) + [27, 28]
self.right_eyelid = [28, 27] + list(range(22, 27)) + [16]
self.eyelids = [self.left_eyelid, self.right_eyelid]
self.left_eye = list(range(36, 42))
self.right_eye = list(range(42, 48))
self.eyes = [self.left_eye, self.right_eye]
self.mouth = list(range(48, 60))
self.teeth = list(range(60, 68))
self.use_cnn = use_cnn_face_detector
if self.use_cnn:
self.detector_weights_path = 'mmod_human_face_detector.dat'
self.face_detector = dlib.cnn_face_detection_model_v1(
self.detector_weights_path)
else:
self.face_detector = dlib.get_frontal_face_detector()
self.predictor_weights_path = 'shape_predictor_68_face_landmarks.dat'
self.landmarks_predictor = dlib.shape_predictor(
self.predictor_weights_path)
def dlib_cnn_extract_faces(image, detector=None):
# Works very slow on cpu (without resizing)
# Quality is better than that of dlib frontal detector
# Foreheads are usually cut
if detector is None:
fd_path = os.path.join('dlib_models', 'mmod_human_face_detector.dat')
dnn_face_detector = dlib.cnn_face_detection_model_v1(fd_path)
detector = dnn_face_detector
faces_results = []
preds = detector(image)
for pred in preds:
w_min = pred.rect.left()
w_max = pred.rect.right()
h_max = pred.rect.bottom()
h_min = pred.rect.top()
faces_results.append(image[h_min:h_max, w_min:w_max, :])
if len(faces_results) == 0:
print('No faces detected')
return faces_results
def face_cut(image_path, category, image_id, save_path):
# print(image_path)
print("save face into ", save_path)
if not os.path.exists(save_path):
os.mkdir(save_path)
# 0表示图片灰度化
img = cv2.imread(image_path, 0)
# Dlib预测器
detector_path = os.path.join('./data/dlib/',
'mmod_human_face_detector.dat')
print("Load modeling!")
detector = dlib.cnn_face_detection_model_v1(detector_path)
# 检测人脸数量
faces = detector(img, 1)
for num, face in enumerate(faces):
cropped = img[face.rect.top() - 50:face.rect.bottom() + 50,
face.rect.left() - 50:face.rect.right() + 50]
cv2.imwrite("%s/%d%d.jpg" % (save_path, image_id, num), cropped)
print("face save %s finished!" % category)
def initialize(detector, scale_to=2048):
global dlib_detectors
global keras_model
global is_initialized
if not is_initialized:
dlib_cnn_face_detector_path = os.path.join(
os.path.dirname(__file__), "mmod_human_face_detector.dat")
if not os.path.exists(dlib_cnn_face_detector_path):
raise Exception("Error: Unable to find %s, reinstall the lib !" %
(dlib_cnn_face_detector_path))
if detector == 'cnn' or detector == "all":
dlib_cnn_face_detector = dlib.cnn_face_detection_model_v1(
dlib_cnn_face_detector_path)
#DLIB and TF competiting for VRAM, so dlib must do first allocation to prevent OOM error
dlib_cnn_face_detector(
np.zeros((scale_to, scale_to, 3), dtype=np.uint8), 0)
dlib_detectors.append(dlib_cnn_face_detector)
if detector == "hog" or detector == "all":
dlib_face_detector = dlib.get_frontal_face_detector()
dlib_face_detector(
np.zeros((scale_to, scale_to, 3), dtype=np.uint8), 0)
dlib_detectors.append(dlib_face_detector)
keras_model_path = os.path.join(os.path.dirname(__file__),
"2DFAN-4.h5")
if not os.path.exists(keras_model_path):
print("Error: Unable to find %s, reinstall the lib !" %
(keras_model_path))
else:
print("Info: initializing keras model...")
keras_model = keras.models.load_model(
keras_model_path,
custom_objects={'TorchBatchNorm2D': TorchBatchNorm2D})
is_initialized = True
def __init__(self, is_dlib=False, is_opencv=False, prefix='.'):
# resolution of input and output image size.
self.resolution_inp = 256
self.resolution_op = 256
#---- load detectors
if is_dlib:
import dlib
detector_path = os.path.join(
prefix, 'Data/net-data/mmod_human_face_detector.dat')
self.face_detector = dlib.cnn_face_detection_model_v1(
detector_path)
if is_opencv:
import cv2
#---- load PRN
self.pos_predictor = PosPrediction(self.resolution_inp,
self.resolution_op)
prn_path = os.path.join(prefix,
'Data/net-data/256_256_resfcn256_weight')
if not os.path.isfile(prn_path + '.data-00000-of-00001'):
print("please download PRN trained model first.")
exit()
self.pos_predictor.restore(prn_path)
# uv file
self.uv_kpt_ind = np.loadtxt(prefix +
'/Data/uv-data/uv_kpt_ind.txt').astype(
np.int32) # 2 x 68 get kpt
self.face_ind = np.loadtxt(
prefix + '/Data/uv-data/face_ind.txt').astype(
np.int32) # get valid vertices in the pos map
self.triangles = np.loadtxt(prefix +
'/Data/uv-data/triangles.txt').astype(
np.int32) # ntri x 3
def detect_face(image_path, default_max_size=800,size = 300, padding = 0.25):
cnn_face_detector = dlib.cnn_face_detection_model_v1('dlib_models/mmod_human_face_detector.dat')
sp = dlib.shape_predictor('dlib_models/shape_predictor_5_face_landmarks.dat')
base = 2000 # largest width and height
img = dlib.load_rgb_image(image_path)
old_height, old_width, _ = img.shape
if old_width > old_height:
new_width, new_height = default_max_size, int(default_max_size * old_height / old_width)
else:
new_width, new_height = int(default_max_size * old_width / old_height), default_max_size
img = dlib.resize_image(img, rows=new_height, cols=new_width)
dets = cnn_face_detector(img, 1)
num_faces = len(dets)
if num_faces == 0:
raise AttributeError("Sorry, there were no faces found.")
# Find the 5 face landmarks we need to do the alignment.
faces = dlib.full_object_detections()
for detection in dets:
rect = detection.rect
faces.append(sp(img, rect))
return dlib.get_face_chips(img, faces, size=size, padding = padding)
def align_and_save_dir(src_dir,
save_dir,
template_path='./pretrain_models/FFHQ_template.npy',
template_scale=2,
use_cnn_detector=True):
if use_cnn_detector:
detector = dlib.cnn_face_detection_model_v1(
'./pretrain_models/mmod_human_face_detector.dat')
else:
detector = dlib.get_frontal_face_detector()
sp = dlib.shape_predictor(
'./pretrain_models/shape_predictor_5_face_landmarks.dat')
for name in os.listdir(src_dir):
img_path = os.path.join(src_dir, name)
img = dlib.load_rgb_image(img_path)
points = get_points(img, detector, sp)
if points is not None:
save_path = os.path.join(save_dir, name)
align_and_save(img, save_path, points, template_path,
template_scale)
else:
print('No face detected in', img_path)
def eval_diff_img_size():
szs = {
"720x1280": (720, 1280, 1),
"360x640": (360, 640, 1),
"180x320": (180, 320, 1),
"90x160": (90, 160, 1)
}
cnn_face_detector = dlib.cnn_face_detection_model_v1(args.face_model)
for sc in [0, 1, 2]:
for s_name in szs:
sz = szs[s_name]
x = np.random.randint(low=0, high=255, size=sz, dtype=np.uint8)
ts = []
for i in range(100):
et = time.time()
_ = cnn_face_detector(x, sc)
ts.append(time.time() - et)
a = str("average for " + s_name + " using scale " + str(sc)).ljust(
40, ' ')
b = str(round(np.average(ts), 7)).ljust(5, ' ')
print a + b
def load_image(image_path, shape_predictor):
# detector = dlib.get_frontal_face_detector()
detector = dlib.cnn_face_detection_model_v1("./mmod_human_face_detector.dat")
predictor = dlib.shape_predictor(shape_predictor)
fa = FaceAligner(predictor, desiredFaceWidth=160)
image = cv2.imread(image_path, cv2.IMREAD_COLOR)
# image = imutils.resize(image, width=256)
gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
start = time.time()
# rects = detector(gray, 2)
rects = detector(image, 1)
# print(time.time() - start)
# print(rects)
rect_nums = len(rects)
XY, aligned_images = [], []
if rect_nums == 0:
aligned_images.append(image)
return aligned_images, image, rect_nums, XY
else:
for i in range(rect_nums):
# print(rects[i])
start = time.time()
# print("================", rects[i])
rec = dlib.rectangle(rects[i].rect.left(),rects[i].rect.top(),rects[i].rect.right(),rects[i].rect.bottom())
aligned_image = fa.align(image, gray, rec)
# print(time.time() - start)
aligned_images.append(aligned_image)
(x, y, w, h) = rect_to_bb(rec)
image = cv2.rectangle(image, (x, y), (x + w, y + h), color=(255, 0, 0), thickness=2)
XY.append((x, y))
shape = predictor(gray, rec)
r = numpy.matrix([[p.x, p.y] for p in shape.parts()])
# print("shape===>", r)
return np.array(aligned_images), image, rect_nums, XY
def get_dst_vectors_from_single_image(file_name):
data = np.zeros((1, 128)) # 定义一个128维的空向量data
label = [] # 定义空的list存放人脸的标签
detector = dlib.cnn_face_detection_model_v1(
'/home/loheagn/boyasite/main/mmod_human_face_detector.dat')
sp = dlib.shape_predictor(
'/home/loheagn/boyasite/main/shape_predictor_68_face_landmarks.dat')
facerec = dlib.face_recognition_model_v1(
'/home/loheagn/boyasite/main/dlib_face_recognition_resnet_model_v1.dat'
)
img = cv2.imread(file_name) # 使用opencv读取图像数据
dets = detector(img, 1) # 使用检测算子检测人脸，返回的是所有的检测到的人脸区域
for k, d in enumerate(dets):
rec = dlib.rectangle(d.rect.left(), d.rect.top(), d.rect.right(),
d.rect.bottom())
shape = sp(img, rec) # 获取landmark
face_descriptor = facerec.compute_face_descriptor(
img, shape) # 使用resNet获取128维的人脸特征向量
faceArray = np.array(face_descriptor).reshape(
(1, 128)) # 转换成numpy中的数据结构
data = np.concatenate((data, faceArray)) # 拼接到事先准备好的data当中去
label.append(label) # 保存标签
return data[1:, :]
def __init__(self):
# OpenCV HAAR
self._faceCascade = cv2.CascadeClassifier(
'Data/Model/haarcascade_frontalface_default.xml')
# OpenCV DNN supports 2 networks.
# 1. FP16 version of the original caffe implementation ( 5.4 MB )
# 2. 8 bit Quantized version using Tensorflow ( 2.7 MB )
DNN = "TF"
if DNN == "CAFFE":
self._modelFile = "Data/Model/res10_300x300_ssd_iter_140000_fp16.caffemodel"
self._configFile = "Data/Model/deploy.prototxt"
self._net = cv2.dnn.readNetFromCaffe(self._configFile,
self._modelFile)
else:
self._modelFile = "Data/Model/opencv_face_detector_uint8.pb"
self._configFile = "Data/Model/opencv_face_detector.pbtxt"
self._net = cv2.dnn.readNetFromTensorflow(self._modelFile,
self._configFile)
self._conf_threshold = 0.8
# DLIB HoG
self._hogFaceDetector = dlib.get_frontal_face_detector()
# DLIB MMOD
self._dnnFaceDetector = dlib.cnn_face_detection_model_v1(
'Data/Model/mmod_human_face_detector.dat')
# TinyFace
self._MAX_INPUT_DIM = 5000.0
self._prob_thresh = float(0.5)
self._nms_tresh = float(0.1)
self._lw = int(3)
self._model = tiny_face_model.Model('Data/Model/hr_res101.weight')
def __init__(self,
image=None,
video=None,
method=None,
capture_image=False,
capture_video=False,
max_width=512,
max_height=512,
show_faces=False):
self.METHODS = {
'cascade': self.cascade,
'hog': self.hog,
'cnn': self.cnn,
'cvlib': self.cvlib,
'mtcnn': self.mtcnn
}
self.max_height = max_height
self.max_width = max_width
self.show_faces = show_faces
self.faces = []
self.confidences = []
if method not in self.METHODS:
raise Exception(f"Method has to be one of {self.METHODS}")
if method == 'cnn':
self.dnnFaceDetector = dlib.cnn_face_detection_model_v1(
CNN_FACE_DETECTION_MODEL)
elif method == 'hog':
self.faceDetect = dlib.get_frontal_face_detector()
elif method == 'cascade':
self.faceCascade = cv2.CascadeClassifier(HAAR_CASC_PATH)
elif method == "mtcnn":
self.mtcnn_detector = MTCNN()
def image(arg1, arg2):
# Load in and convert source image to into grayscale
img = cv2.imread(arg1, 1)
gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
cv2.resize(gray, (0, 0), fx=0.25, fy=0.25)
# Ensure the file is opened
if np.shape(img) == ():
print("Error opening the image file")
exit()
# Detect faces using CNN model
face_detect = dlib.cnn_face_detection_model_v1(
'mmod_human_face_detector.dat')
face = face_detect(gray, 1)
# Blur faces
blur_cnn(img, face)
# Display image with blur
cv2.imshow("Output", img)
cv2.imwrite(arg2, img)
cv2.waitKey(0)
cv2.destroyAllWindows()
import cv2
import dlib
import argparse
import time
import numpy as np
from utils.inference import get_suffix, crop_img, parse_roi_box_from_landmark
import glob
import dlib
import sys
import ntpath
dlib_landmark_model = 'models/shape_predictor_68_face_landmarks.dat'
cnn_face_detector = dlib.cnn_face_detection_model_v1('./models/mmod_human_face_detector.dat')
face_regressor = dlib.shape_predictor(dlib_landmark_model)
def save_img(image, filename, save_path):
image_name = ntpath.basename(filename)
wfp_crop = save_path + '/{}'.format(image_name)
print(wfp_crop)
cv2.imwrite(wfp_crop, image)
def crop_process(image, filename, folder_path, save_path, size=224):
if image is None:
print("Could not read input image")
return False
# Also note that this example requires Numpy which can be installed
# via the command:
# pip install numpy
import sys
import dlib
if len(sys.argv) < 3:
print(
"Call this program like this:\n"
" ./cnn_face_detector.py mmod_human_face_detector.dat ../examples/faces/*.jpg\n"
"You can get the mmod_human_face_detector.dat file from:\n"
" http://dlib.net/files/mmod_human_face_detector.dat.bz2")
exit()
cnn_face_detector = dlib.cnn_face_detection_model_v1(sys.argv[1])
win = dlib.image_window()
for f in sys.argv[2:]:
print("Processing file: {}".format(f))
img = dlib.load_rgb_image(f)
# 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 = cnn_face_detector(img, 1)
'''
This detector returns a mmod_rectangles object. This object contains a list of mmod_rectangle objects.
These objects can be accessed by simply iterating over the mmod_rectangles object
The mmod_rectangle object has two member variables, a dlib.rectangle object, and a confidence score.
It is also possible to pass a list of images to the detector.
def init_dlib(self, detection_path, landmark5_path, landmark68_path):
"""Initialize the dlib detectors and predictors."""
self.face_detector = dlib.cnn_face_detection_model_v1(detection_path)
self.shape_predictor_5 = dlib.shape_predictor(landmark5_path)
self.shape_predictor_68 = dlib.shape_predictor(landmark68_path)
def __init__(self,
landmarks_type,
network_size=NetworkSize.LARGE,
enable_cuda=True,
enable_cudnn=True,
flip_input=False,
use_cnn_face_detector=False):
self.enable_cuda = enable_cuda
self.use_cnn_face_detector = use_cnn_face_detector
self.flip_input = flip_input
self.landmarks_type = landmarks_type
base_path = os.path.join(appdata_dir('face_alignment'), "data")
if not os.path.exists(base_path):
os.makedirs(base_path)
if enable_cudnn and self.enable_cuda:
torch.backends.cudnn.benchmark = True
# Initialise the face detector
if self.use_cnn_face_detector:
path_to_detector = os.path.join(base_path,
"mmod_human_face_detector.dat")
if not os.path.isfile(path_to_detector):
print("Downloading the face detection CNN. Please wait...")
path_to_temp_detector = os.path.join(
base_path, "mmod_human_face_detector.dat.download")
if os.path.isfile(path_to_temp_detector):
os.remove(os.path.join(path_to_temp_detector))
request_file.urlretrieve(
"https://www.adrianbulat.com/downloads/dlib/mmod_human_face_detector.dat",
os.path.join(path_to_temp_detector))
os.rename(os.path.join(path_to_temp_detector),
os.path.join(path_to_detector))
self.face_detector = dlib.cnn_face_detection_model_v1(
path_to_detector)
else:
self.face_detector = dlib.get_frontal_face_detector()
# Initialise the face alignemnt networks
self.face_alignemnt_net = FAN(int(network_size))
if landmarks_type == LandmarksType._2D:
network_name = '2DFAN-' + str(int(network_size)) + '.pth.tar'
else:
network_name = '3DFAN-' + str(int(network_size)) + '.pth.tar'
fan_path = os.path.join(base_path, network_name)
if not os.path.isfile(fan_path):
print(
"Downloading the Face Alignment Network(FAN). Please wait...")
fan_temp_path = os.path.join(base_path, network_name + '.download')
if os.path.isfile(fan_temp_path):
os.remove(os.path.join(fan_temp_path))
request_file.urlretrieve(
"https://www.adrianbulat.com/downloads/python-fan/" +
network_name, os.path.join(fan_temp_path))
os.rename(os.path.join(fan_temp_path), os.path.join(fan_path))
fan_weights = torch.load(fan_path,
map_location=lambda storage, loc: storage)
self.face_alignemnt_net.load_state_dict(fan_weights)
if self.enable_cuda:
self.face_alignemnt_net.cuda()
self.face_alignemnt_net.eval()
# Initialiase the depth prediciton network
if landmarks_type == LandmarksType._3D:
self.depth_prediciton_net = ResNetDepth()
depth_model_path = os.path.join(base_path, 'depth.pth.tar')
if not os.path.isfile(depth_model_path):
print(
"Downloading the Face Alignment depth Network (FAN-D). Please wait..."
)
depth_model_temp_path = os.path.join(base_path,
'depth.pth.tar.download')
if os.path.isfile(depth_model_temp_path):
os.remove(os.path.join(depth_model_temp_path))
request_file.urlretrieve(
"https://www.adrianbulat.com/downloads/python-fan/depth.pth.tar",
os.path.join(depth_model_temp_path))
os.rename(os.path.join(depth_model_temp_path),
os.path.join(depth_model_path))
depth_weights = torch.load(
depth_model_path, map_location=lambda storage, loc: storage)
depth_dict = {
k.replace('module.', ''): v
for k, v in depth_weights['state_dict'].items()
}
self.depth_prediciton_net.load_state_dict(depth_dict)
if self.enable_cuda:
self.depth_prediciton_net.cuda()
self.depth_prediciton_net.eval()
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
:param rect: a dlib 'rect' object
:return: a plain tuple representation of the rect in (top, right, bottom, left) order
"""
return rect.top(), rect.right(), rect.bottom(), rect.left()
def show_detection(image, faces):
"""Draws a rectangle over each detected face"""
# faces contains a list of mmod_rectangle objects
# The mmod_rectangle object has two member variables, a dlib.rectangle object, and a confidence score
# Therefore, we iterate over the detected mmod_rectangle objects accessing dlib.rect to draw the rectangle
for face in faces:
cv2.rectangle(image, (face.rect.left(), face.rect.top()), (face.rect.right(), face.rect.bottom()), (255, 0, 0),
10)
return image
# Load CNN detector from dlib:
cnn_face_detector = dlib.cnn_face_detection_model_v1("mmod_human_face_detector.dat")
# Load image and convert to grayscale:
img = cv2.imread("test_face_detection.jpg")
# Resize the image to attain reasonable speed:
# img = cv2.resize(img, (0, 0), fx=0.5, fy=0.5)
# Detect faces:
rects = cnn_face_detector(img, 0)
# Draw face detections:
img_faces = show_detection(img.copy(), rects)
# Create the dimensions of the figure and set title:
fig = plt.figure(figsize=(10, 5))
print("\tsudo ./install.sh\n")
sys.exit(1)
# Read config from disk
config = configparser.ConfigParser()
config.read(path + "/../config.ini")
if not os.path.exists(config.get("video", "device_path")):
print(
"Camera path is not configured correctly, please edit the 'device_path' config value."
)
sys.exit(1)
use_cnn = config.getboolean("core", "use_cnn", fallback=False)
if use_cnn:
face_detector = dlib.cnn_face_detection_model_v1(
path + "/../dlib-data/mmod_human_face_detector.dat")
else:
face_detector = dlib.get_frontal_face_detector()
pose_predictor = dlib.shape_predictor(
path + "/../dlib-data/shape_predictor_5_face_landmarks.dat")
face_encoder = dlib.face_recognition_model_v1(
path + "/../dlib-data/dlib_face_recognition_resnet_model_v1.dat")
user = builtins.howdy_user
# The permanent file to store the encoded model in
enc_file = path + "/../models/" + user + ".dat"
# Known encodings
encodings = []
# Make the ./models folder if it doesn't already exist
model = net.net(torchvision.models.resnet.BasicBlock, [3, 4, 6, 3], 66)
elif args.arch == 'ResNet101':
model = net.net(torchvision.models.resnet.Bottleneck, [3, 4, 23, 3],
66)
elif args.arch == 'ResNet152':
model = net.net(torchvision.models.resnet.Bottleneck, [3, 8, 36, 3],
66)
else:
if args.arch != 'ResNet50':
print('Invalid value for architecture is passed! '
'The default value of ResNet50 will be used instead!')
model = net.net(torchvision.models.resnet.Bottleneck, [3, 4, 6, 3], 66)
# Dlib face detection model
cnn_face_detector = dlib.cnn_face_detection_model_v1(args.face_model)
print('Loading snapshot.')
# Load snapshot
saved_state_dict = torch.load(snapshot_path)
model.load_state_dict(saved_state_dict)
print('Loading data.')
transformations = transforms.Compose([
transforms.Scale(224),
transforms.CenterCrop(224),
transforms.ToTensor(),
transforms.Normalize(mean=[0.485, 0.456, 0.406],
std=[0.229, 0.224, 0.225])
]) #crop center part of image and scale image
if DNN=="CAFFE":
modelFile = "res10_300x300_ssd_iter_140000_fp16.caffemodel"
configFile = "deploy.prototxt"
net = cv2.dnn.readNetFromCaffe(configFile, modelFile)
else:
modelFile = "opencv_face_detector_uint8.pb"
configFile = "opencv_face_detector.pbtxt"
net = cv2.dnn.readNetFromTensorflow(modelFile, configFile)
conf_threshold = 0.7
# DLIB HoG
hogFaceDetector = dlib.get_frontal_face_detector()
# DLIB MMOD
dnnFaceDetector = dlib.cnn_face_detection_model_v1("./mmod_human_face_detector.dat")
def detectFaceOpenCVHaar(faceCascade, frame, inHeight=300, inWidth=0):
frameOpenCVHaar = frame.copy()
frameHeight = frameOpenCVHaar.shape[0]
frameWidth = frameOpenCVHaar.shape[1]
if not inWidth:
inWidth = int((frameWidth / frameHeight) * inHeight)
scaleHeight = frameHeight / inHeight
scaleWidth = frameWidth / inWidth
frameOpenCVHaarSmall = cv2.resize(frameOpenCVHaar, (inWidth, inHeight))
frameGray = cv2.cvtColor(frameOpenCVHaarSmall, cv2.COLOR_BGR2GRAY)
def __init__(self, landmarks_type, network_size=NetworkSize.LARGE,
enable_cuda=True, enable_cudnn=True, flip_input=False,
use_cnn_face_detector=False):
self.enable_cuda = enable_cuda
self.use_cnn_face_detector = use_cnn_face_detector
self.flip_input = flip_input
self.landmarks_type = landmarks_type
base_path = os.path.join(appdata_dir('face_alignment'), "data")
if not os.path.exists(base_path):
os.makedirs(base_path)
if enable_cudnn and self.enable_cuda:
torch.backends.cudnn.benchmark = True
# Initialise the face detector
if self.enable_cuda or self.use_cnn_face_detector:
path_to_detector = os.path.join(
base_path, "mmod_human_face_detector.dat")
if not os.path.isfile(path_to_detector):
print("Downloading the face detection CNN. Please wait...")
request_file.urlretrieve(
"https://www.adrianbulat.com/downloads/dlib/mmod_human_face_detector.dat",
os.path.join(path_to_detector))
self.face_detector = dlib.cnn_face_detection_model_v1(
path_to_detector)
else:
self.face_detector = dlib.get_frontal_face_detector()
# Initialise the face alignemnt networks
self.face_alignemnt_net = FAN(int(network_size))
if landmarks_type == LandmarksType._2D:
network_name = '2DFAN-' + str(int(network_size)) + '.pth.tar'
else:
network_name = '3DFAN-' + str(int(network_size)) + '.pth.tar'
fan_path = os.path.join(base_path, network_name)
if not os.path.isfile(fan_path):
print("Downloading the Face Alignment Network(FAN). Please wait...")
request_file.urlretrieve(
"https://www.adrianbulat.com/downloads/python-fan/" +
network_name, os.path.join(fan_path))
fan_weights = torch.load(
fan_path,
map_location=lambda storage,
loc: storage)
self.face_alignemnt_net.load_state_dict(fan_weights)
if self.enable_cuda:
self.face_alignemnt_net.cuda()
self.face_alignemnt_net.eval()
# Initialiase the depth prediciton network
if landmarks_type == LandmarksType._3D:
self.depth_prediciton_net = ResNetDepth()
depth_model_path = os.path.join(base_path, 'depth.pth.tar')
if not os.path.isfile(depth_model_path):
print(
"Downloading the Face Alignment depth Network (FAN-D). Please wait...")
request_file.urlretrieve(
"https://www.adrianbulat.com/downloads/python-fan/depth.pth.tar",
os.path.join(depth_model_path))
depth_weights = torch.load(
depth_model_path,
map_location=lambda storage,
loc: storage)
depth_dict = {
k.replace('module.', ''): v for k,
v in depth_weights['state_dict'].items()}
self.depth_prediciton_net.load_state_dict(depth_dict)
if self.enable_cuda:
self.depth_prediciton_net.cuda()
self.depth_prediciton_net.eval()
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
"""
return rect.top(), rect.right(), rect.bottom(), rect.left()
# pip install scikit-image
# Or downloaded from http://scikit-image.org/download.html.
import sys
import dlib
from skimage import io
if len(sys.argv) < 3:
print(
"Call this program like this:\n"
" ./cnn_face_detector.py mmod_human_face_detector.dat ../examples/faces/*.jpg\n"
"You can get the mmod_human_face_detector.dat file from:\n"
" http://dlib.net/files/mmod_human_face_detector.dat.bz2")
exit()
cnn_face_detector = dlib.cnn_face_detection_model_v1(sys.argv[1])
win = dlib.image_window()
for f in sys.argv[2:]:
print("Processing file: {}".format(f))
img = io.imread(f)
# 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 = cnn_face_detector(img, 1)
'''
This detector returns a mmod_rectangles object. This object contains a list of mmod_rectangle objects.
These objects can be accessed by simply iterating over the mmod_rectangles object
The mmod_rectangle object has two member variables, a dlib.rectangle object, and a confidence score.
It is also possible to pass a list of images to the detector.
