coding utf8 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 convert a tuple in top right bottom left order to a dlib rect object param css plain tuple representation of the rect in top right bottom left order return a dlib rect object make sure a tuple in top right bottom left order is within the bounds of the image param css plain tuple representation of the rect in top right bottom left order param imageshape numpy shape of the image array return a trimmed plain tuple representation of the rect in top right bottom left order given a list of face encodings compare them to a known face encoding and get a euclidean distance for each comparison face the distance tells you how similar the faces are param faceencodings list of face encodings to compare param facetocompare a face encoding to compare against return a numpy ndarray with the distance for each face in the same order as the faces array loads an image file jpg png etc into a numpy array param file image file name or file object to load param mode format to convert the image to only rgb 8bit rgb 3 channels and l black and white are supported return image contents as numpy array returns an array of bounding boxes of human faces in a image param img an image as a numpy array param numberoftimestoupsample how many times to upsample the image looking for faces higher numbers find smaller faces param model which face detection model to use hog is less accurate but faster on cpus cnn is a more accurate deeplearning model which is gpucuda accelerated if available the default is hog return a list of dlib rect objects of found face locations returns an array of bounding boxes of human faces in a image param img an image as a numpy array param numberoftimestoupsample how many times to upsample the image looking for faces higher numbers find smaller faces param model which face detection model to use hog is less accurate but faster on cpus cnn is a more accurate deeplearning model which is gpucuda accelerated if available the default is hog return a list of tuples of found face locations in css top right bottom left order returns an 2d array of dlib rects of human faces in a image using the cnn face detector param images a list of images each as a numpy array param numberoftimestoupsample how many times to upsample the image looking for faces higher numbers find smaller faces return a list of dlib rect objects of found face locations returns an 2d array of bounding boxes of human faces in a image using the cnn face detector if you are using a gpu this can give you much faster results since the gpu can process batches of images at once if you aren t using a gpu you don t need this function param images a list of images each as a numpy array param numberoftimestoupsample how many times to upsample the image looking for faces higher numbers find smaller faces param batchsize how many images to include in each gpu processing batch return a list of tuples of found face locations in css top right bottom left order given an image returns a dict of face feature locations eyes nose etc for each face in the image param faceimage image to search param facelocations optionally provide a list of face locations to check param model optional which model to use large default or small which only returns 5 points but is faster return a list of dicts of face feature locations eyes nose etc for a definition of each point index see https cdnimages1 medium commax16001abeg31egkbxsqehunjblwg png given an image return the 128dimension face encoding for each face in the image param faceimage the image that contains one or more faces param knownfacelocations optional the bounding boxes of each face if you already know them param numjitters how many times to resample the face when calculating encoding higher is more accurate but slower i e 100 is 100x slower param model optional which model to use large or small default which only returns 5 points but is faster return a list of 128dimensional face encodings one for each face in the image compare a list of face encodings against a candidate encoding to see if they match param knownfaceencodings a list of known face encodings param faceencodingtocheck a single face encoding to compare against the list param tolerance how much distance between faces to consider it a match lower is more strict 0 6 is typical best performance return a list of truefalse values indicating which knownfaceencodings match the face encoding to check coding utf 8 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 convert a tuple in top right bottom left order to a dlib rect object param css plain tuple representation of the rect in top right bottom left order return a dlib rect object make sure a tuple in top right bottom left order is within the bounds of the image param css plain tuple representation of the rect in top right bottom left order param image_shape numpy shape of the image array return a trimmed plain tuple representation of the rect in top right bottom left order given a list of face encodings compare them to a known face encoding and get a euclidean distance for each comparison face the distance tells you how similar the faces are param face_encodings list of face encodings to compare param face_to_compare a face encoding to compare against return a numpy ndarray with the distance for each face in the same order as the faces array loads an image file jpg png etc into a numpy array param file image file name or file object to load param mode format to convert the image to only rgb 8 bit rgb 3 channels and l black and white are supported return image contents as numpy array returns an array of bounding boxes of human faces in a image param img an image as a numpy array param number_of_times_to_upsample how many times to upsample the image looking for faces higher numbers find smaller faces param model which face detection model to use hog is less accurate but faster on cpus cnn is a more accurate deep learning model which is gpu cuda accelerated if available the default is hog return a list of dlib rect objects of found face locations returns an array of bounding boxes of human faces in a image param img an image as a numpy array param number_of_times_to_upsample how many times to upsample the image looking for faces higher numbers find smaller faces param model which face detection model to use hog is less accurate but faster on cpus cnn is a more accurate deep learning model which is gpu cuda accelerated if available the default is hog return a list of tuples of found face locations in css top right bottom left order returns an 2d array of dlib rects of human faces in a image using the cnn face detector param images a list of images each as a numpy array param number_of_times_to_upsample how many times to upsample the image looking for faces higher numbers find smaller faces return a list of dlib rect objects of found face locations returns an 2d array of bounding boxes of human faces in a image using the cnn face detector if you are using a gpu this can give you much faster results since the gpu can process batches of images at once if you aren t using a gpu you don t need this function param images a list of images each as a numpy array param number_of_times_to_upsample how many times to upsample the image looking for faces higher numbers find smaller faces param batch_size how many images to include in each gpu processing batch return a list of tuples of found face locations in css top right bottom left order given an image returns a dict of face feature locations eyes nose etc for each face in the image param face_image image to search param face_locations optionally provide a list of face locations to check param model optional which model to use large default or small which only returns 5 points but is faster return a list of dicts of face feature locations eyes nose etc for a definition of each point index see https cdn images 1 medium com max 1600 1 abeg31egkbxsqehunjblwg png given an image return the 128 dimension face encoding for each face in the image param face_image the image that contains one or more faces param known_face_locations optional the bounding boxes of each face if you already know them param num_jitters how many times to re sample the face when calculating encoding higher is more accurate but slower i e 100 is 100x slower param model optional which model to use large or small default which only returns 5 points but is faster return a list of 128 dimensional face encodings one for each face in the image compare a list of face encodings against a candidate encoding to see if they match param known_face_encodings a list of known face encodings param face_encoding_to_check a single face encoding to compare against the list param tolerance how much distance between faces to consider it a match lower is more strict 0 6 is typical best performance return a list of true false values indicating which known_face_encodings match the face encoding to check
import PIL.Image
import dlib
import numpy as np
from PIL import ImageFile

try:
    import face_recognition_models
except Exception:
    print("Please install `face_recognition_models` with this command before using `face_recognition`:\n")
    print("pip install git+https://github.com/ageitgey/face_recognition_models")
    quit()

ImageFile.LOAD_TRUNCATED_IMAGES = True

face_detector = dlib.get_frontal_face_detector()

predictor_68_point_model = face_recognition_models.pose_predictor_model_location()
pose_predictor_68_point = dlib.shape_predictor(predictor_68_point_model)

predictor_5_point_model = face_recognition_models.pose_predictor_five_point_model_location()
pose_predictor_5_point = dlib.shape_predictor(predictor_5_point_model)

cnn_face_detection_model = face_recognition_models.cnn_face_detector_model_location()
cnn_face_detector = dlib.cnn_face_detection_model_v1(cnn_face_detection_model)

face_recognition_model = face_recognition_models.face_recognition_model_location()
face_encoder = dlib.face_recognition_model_v1(face_recognition_model)


def _rect_to_css(rect):
    
    return rect.top(), rect.right(), rect.bottom(), rect.left()


def _css_to_rect(css):
    
    return dlib.rectangle(css[3], css[0], css[1], css[2])


def _trim_css_to_bounds(css, image_shape):
    
    return max(css[0], 0), min(css[1], image_shape[1]), min(css[2], image_shape[0]), max(css[3], 0)


def face_distance(face_encodings, face_to_compare):
    
    if len(face_encodings) == 0:
        return np.empty((0))

    return np.linalg.norm(face_encodings - face_to_compare, axis=1)


def load_image_file(file, mode='RGB'):
    
    im = PIL.Image.open(file)
    if mode:
        im = im.convert(mode)
    return np.array(im)


def _raw_face_locations(img, number_of_times_to_upsample=1, model="hog"):
    
    if model == "cnn":
        return cnn_face_detector(img, number_of_times_to_upsample)
    else:
        return face_detector(img, number_of_times_to_upsample)


def face_locations(img, number_of_times_to_upsample=1, model="hog"):
    
    if model == "cnn":
        return [_trim_css_to_bounds(_rect_to_css(face.rect), img.shape) for face in _raw_face_locations(img, number_of_times_to_upsample, "cnn")]
    else:
        return [_trim_css_to_bounds(_rect_to_css(face), img.shape) for face in _raw_face_locations(img, number_of_times_to_upsample, model)]


def _raw_face_locations_batched(images, number_of_times_to_upsample=1, batch_size=128):
    
    return cnn_face_detector(images, number_of_times_to_upsample, batch_size=batch_size)


def batch_face_locations(images, number_of_times_to_upsample=1, batch_size=128):
    
    def convert_cnn_detections_to_css(detections):
        return [_trim_css_to_bounds(_rect_to_css(face.rect), images[0].shape) for face in detections]

    raw_detections_batched = _raw_face_locations_batched(images, number_of_times_to_upsample, batch_size)

    return list(map(convert_cnn_detections_to_css, raw_detections_batched))


def _raw_face_landmarks(face_image, face_locations=None, model="large"):
    if face_locations is None:
        face_locations = _raw_face_locations(face_image)
    else:
        face_locations = [_css_to_rect(face_location) for face_location in face_locations]

    pose_predictor = pose_predictor_68_point

    if model == "small":
        pose_predictor = pose_predictor_5_point

    return [pose_predictor(face_image, face_location) for face_location in face_locations]


def face_landmarks(face_image, face_locations=None, model="large"):
    
    landmarks = _raw_face_landmarks(face_image, face_locations, model)
    landmarks_as_tuples = [[(p.x, p.y) for p in landmark.parts()] for landmark in landmarks]

    
    if model == 'large':
        return [{
            "chin": points[0:17],
            "left_eyebrow": points[17:22],
            "right_eyebrow": points[22:27],
            "nose_bridge": points[27:31],
            "nose_tip": points[31:36],
            "left_eye": points[36:42],
            "right_eye": points[42:48],
            "top_lip": points[48:55] + [points[64]] + [points[63]] + [points[62]] + [points[61]] + [points[60]],
            "bottom_lip": points[54:60] + [points[48]] + [points[60]] + [points[67]] + [points[66]] + [points[65]] + [points[64]]
        } for points in landmarks_as_tuples]
    elif model == 'small':
        return [{
            "nose_tip": [points[4]],
            "left_eye": points[2:4],
            "right_eye": points[0:2],
        } for points in landmarks_as_tuples]
    else:
        raise ValueError("Invalid landmarks model type. Supported models are ['small', 'large'].")


def face_encodings(face_image, known_face_locations=None, num_jitters=1, model="small"):
    
    raw_landmarks = _raw_face_landmarks(face_image, known_face_locations, model)
    return [np.array(face_encoder.compute_face_descriptor(face_image, raw_landmark_set, num_jitters)) for raw_landmark_set in raw_landmarks]


def compare_faces(known_face_encodings, face_encoding_to_check, tolerance=0.6):
    
    return list(face_distance(known_face_encodings, face_encoding_to_check) <= tolerance)