class RunFaceID(object):
    def __init__(self):
        super(RunFaceID, self).__init__()
        self.face_detection = FaceDetection()
        self.face_recognition = FaceRecognition()

    def predict(self, array_embeddings, embeddings_source):
        return "unknown"

    def processing(self, images, embeddings_source):
        frame = copy.deepcopy(images)
        faces = self.face_detection.detect_faces(frame)
        if faces is None or len(faces) < 1:
            return None
        data = {}
        array_img = []
        labels = []
        for x, y, w, h in faces:
            if w > 0 and h > 0:
                img_crop = frame[y:y + h, x:x + w, :]
                array_img.append(img_crop)
                # labels.append("unknown")
        array_img = np.array(array_img)
        # data["labels"] = labels
        if count >= NUMBER_FRAME:
            array_embeddings = self.face_recognition.embedding_image(array_img)
            data["labels"] = self.predict_labels(array_embeddings,
                                                 embeddings_source)
        data["bounding_boxs"] = faces
        return data
Exemple #2
0
class RunFaceID(object):
    def __init__(self):
        super(RunFaceID, self).__init__()
        self.face_detection = FaceDetection()
        self.face_recognition = FaceRecognition()
        self.arr_embeddings = pickle.load(open("data_embeddings", "rb"))
        self.labels = pickle.load(open("labels", "rb"))

    def predict_labels(self, embeddings):
        dis_cs = cs(embeddings, self.arr_embeddings)
        index_list = np.argmax(dis_cs, axis=-1)
        label_pred = []
        for i, index in enumerate(index_list):
            if dis_cs[i][index] > 0.6:
                label_pred.append(self.labels[index])
            else:
                label_pred.append("unknown")
        return label_pred

    def processing(self, images, count):
        frame = copy.deepcopy(images)
        faces = self.face_detection.detect_faces(frame)
        if faces is None or len(faces) < 1:
            return None
        data = {}
        array_img = []
        labels = []
        for x, y, w, h in faces:
            if w > 0 and h > 0:
                img_crop = img_crop = frame[y:y + h, x:x + w, :]
                array_img.append(img_crop)
                labels.append("unknown")
        array_img = np.array(array_img)
        # data["labels"] = labels
        if count >= 5:
            array_embeddings = self.face_recognition.embedding_image(array_img)
            data["labels"] = self.predict_labels(array_embeddings)
        data["bounding_boxs"] = faces
        return data
Exemple #3
0
class RunFaceID(object):
    def __init__(self):
        super(RunFaceID, self).__init__()
        self.face_detection = FaceDetection()
        self.face_recognition = FaceRecognition()
        # self.arr_embeddings = pickle.load(open("data_embeddings", "rb"))
        # self.labels = pickle.load(open("labels", "rb"))

    def predict_labels(self, embeddings, embeddings_source, labels_index,
                       labels_name):
        dis_cs = cs(embeddings, embeddings_source)
        index_list = np.argmax(dis_cs, axis=-1)
        label_pred = []
        for i, index in enumerate(index_list):
            if dis_cs[i][index] > 0.6:
                label_index = labels_index[index]
                for i, (index_tmp, name_tmp) in enumerate(labels_name):
                    if label_index == index_tmp:
                        label_pred.append(labels_name[i])
            else:
                label_pred.append([-1, "unknown"])
        return label_pred

    def processing(self, images, count, embeddings_source, labels_index,
                   labels_name, message_status):
        frame = copy.deepcopy(images)
        faces = self.face_detection.detect_faces(frame)
        if faces is None or len(faces) < 1:
            return None
        data = {}
        array_img = []
        labels = []
        for x, y, w, h in faces:
            if w > 0 and h > 0:
                img_crop = frame[y:y + h, x:x + w, :]
                array_img.append(img_crop)
                # labels.append("unknown")
        array_img = np.array(array_img)
        # data["labels"] = labels
        if count >= NUMBER_FRAME:
            array_embeddings = self.face_recognition.embedding_image(array_img)
            data["labels"] = self.predict_labels(array_embeddings,
                                                 embeddings_source,
                                                 labels_index, labels_name)
        data["bounding_boxs"] = faces
        return data

    def get_faces(self, images):
        faces = self.face_detection.detect_faces(images)
        return list(faces)

    def get_bb_embeddings(self, images):
        faces = self.get_faces(images)
        if len(faces) != 1:
            return None
        array_img = []
        data = {}
        for x, y, w, h in faces:
            if w > 0 and h > 0:
                img_crop = images[y:y + h, x:x + w, :]
                array_img.append(img_crop)
        embeddings = self.face_recognition.embedding_image(array_img)[0]
        data["bounding_box"] = json.dumps(faces[0].tolist())
        data['embeddings'] = json.dumps(embeddings.tolist())
        return data