Ejemplo n.º 1
0
    def onClientInitialize(self, client_dict):
        self.safe_print ('Running on %s.' % (client_dict['device_name']) )
        self.type         = client_dict['type']
        self.image_size   = client_dict['image_size']
        self.face_type    = client_dict['face_type']
        self.device_idx   = client_dict['device_idx']
        self.cpu_only     = client_dict['device_type'] == 'CPU'
        self.output_path  = Path(client_dict['output_dir']) if 'output_dir' in client_dict.keys() else None        
        self.debug        = client_dict['debug']
        self.detector     = client_dict['detector']

        self.e = None

        device_config = nnlib.DeviceConfig ( cpu_only=self.cpu_only, force_best_gpu_idx=self.device_idx, allow_growth=True)
        if self.type == 'rects':
            if self.detector is not None:
                if self.detector == 'mt':
                    nnlib.import_all (device_config)
                    self.e = facelib.MTCExtractor(nnlib.keras, nnlib.tf, nnlib.tf_sess)                            
                elif self.detector == 'dlib':
                    nnlib.import_dlib (device_config)
                    self.e = facelib.DLIBExtractor(nnlib.dlib)
                self.e.__enter__()

        elif self.type == 'landmarks':
            nnlib.import_all (device_config)
            self.e = facelib.LandmarksExtractor(nnlib.keras)
            self.e.__enter__()
            
        elif self.type == 'final':
            pass
        
        return None
Ejemplo n.º 2
0
        def on_initialize(self, client_dict):
            self.type         = client_dict['type']
            self.image_size   = client_dict['image_size']
            self.face_type    = client_dict['face_type']
            self.max_faces_from_image = client_dict['max_faces_from_image']
            self.device_idx   = client_dict['device_idx']
            self.cpu_only     = client_dict['device_type'] == 'CPU'
            self.final_output_path  = Path(client_dict['final_output_dir']) if 'final_output_dir' in client_dict.keys() else None
            self.debug_dir    = client_dict['debug_dir']
            
            #transfer and set stdin in order to work code.interact in debug subprocess
            stdin_fd         = client_dict['stdin_fd']
            if stdin_fd is not None and DEBUG:
                sys.stdin = os.fdopen(stdin_fd)

            self.cached_image = (None, None)

            self.e = None
            device_config = nnlib.DeviceConfig ( cpu_only=self.cpu_only, force_gpu_idx=self.device_idx, allow_growth=True)
            self.device_vram = device_config.gpu_vram_gb[0]

            intro_str = 'Running on %s.' % (client_dict['device_name'])
            if not self.cpu_only and self.device_vram <= 2:
                intro_str += " Recommended to close all programs using this device."

            self.log_info (intro_str)

            if 'rects' in self.type:
                if self.type == 'rects-mt':
                    nnlib.import_all (device_config)
                    self.e = facelib.MTCExtractor()
                elif self.type == 'rects-dlib':
                    nnlib.import_dlib (device_config)
                    self.e = facelib.DLIBExtractor(nnlib.dlib)
                elif self.type == 'rects-s3fd':
                    nnlib.import_all (device_config)
                    self.e = facelib.S3FDExtractor()
                else:
                    raise ValueError ("Wrong type.")

                if self.e is not None:
                    self.e.__enter__()

            elif self.type == 'landmarks':
                nnlib.import_all (device_config)
                self.e = facelib.FANExtractor()
                self.e.__enter__()
                if self.device_vram >= 2:
                    self.second_pass_e = facelib.S3FDExtractor()
                    self.second_pass_e.__enter__()
                else:
                    self.second_pass_e = None
                    
            elif self.type == 'fanseg':
                nnlib.import_all (device_config)
                self.e = TernausNet(256, FaceType.toString(FaceType.FULL) )
                self.e.__enter__()
                    
            elif self.type == 'final':
                pass
Ejemplo n.º 3
0
        def on_initialize(self, client_dict):
            self.type = client_dict['type']
            self.image_size = client_dict['image_size']
            self.face_type = client_dict['face_type']
            self.device_idx = client_dict['device_idx']
            self.cpu_only = client_dict['device_type'] == 'CPU'
            self.final_output_path = Path(
                client_dict['final_output_dir']
            ) if 'final_output_dir' in client_dict.keys() else None
            self.debug_dir = client_dict['debug_dir']

            self.cached_image = (None, None)

            self.e = None

            device_config = nnlib.DeviceConfig(cpu_only=self.cpu_only,
                                               force_gpu_idx=self.device_idx,
                                               allow_growth=True)
            self.device_vram = device_config.gpu_vram_gb[0]

            intro_str = 'Running on %s.' % (client_dict['device_name'])
            if not self.cpu_only and self.device_vram <= 2:
                intro_str += " Recommended to close all programs using this device."

            self.log_info(intro_str)

            if 'rects' in self.type:
                if self.type == 'rects-mt':
                    nnlib.import_all(device_config)
                    self.e = facelib.MTCExtractor()
                elif self.type == 'rects-dlib':
                    nnlib.import_dlib(device_config)
                    self.e = facelib.DLIBExtractor(nnlib.dlib)
                elif self.type == 'rects-s3fd':
                    nnlib.import_all(device_config)
                    self.e = facelib.S3FDExtractor()
                else:
                    raise ValueError("Wrong type.")

                if self.e is not None:
                    self.e.__enter__()

            elif self.type == 'landmarks':
                nnlib.import_all(device_config)
                self.e = facelib.LandmarksExtractor(nnlib.keras)
                self.e.__enter__()
                if self.device_vram >= 2:
                    self.second_pass_e = facelib.S3FDExtractor()
                    self.second_pass_e.__enter__()
                else:
                    self.second_pass_e = None

            elif self.type == 'final':
                pass
Ejemplo n.º 4
0
        def on_initialize(self, client_dict):
            self.log_info('Running on %s.' % (client_dict['device_name']))

            self.type = client_dict['type']
            self.image_size = client_dict['image_size']
            self.face_type = client_dict['face_type']
            self.device_idx = client_dict['device_idx']
            self.cpu_only = client_dict['device_type'] == 'CPU'
            self.output_path = Path(
                client_dict['output_dir']) if 'output_dir' in client_dict.keys(
                ) else None
            self.debug_dir = client_dict['debug_dir']
            self.detector = client_dict['detector']
            self.accurate_landmarks_extractor = client_dict[
                'accurate_landmarks_extractor']

            self.cached_image = (None, None)

            self.e = None
            device_config = nnlib.DeviceConfig(cpu_only=self.cpu_only,
                                               force_gpu_idx=self.device_idx,
                                               allow_growth=True)
            if self.type == 'rects':
                if self.detector is not None:
                    if self.detector == 'mt':
                        nnlib.import_all(device_config)
                        self.e = facelib.MTCExtractor()
                    elif self.detector == 'dlib':
                        nnlib.import_dlib(device_config)
                        self.e = facelib.DLIBExtractor(nnlib.dlib)
                    elif self.detector == 's3fd':
                        nnlib.import_all(device_config)
                        self.e = facelib.S3FDExtractor()
                    else:
                        raise ValueError("Wrong detector type.")

                    if self.e is not None:
                        self.e.__enter__()

            elif self.type == 'landmarks':
                nnlib.import_all(device_config)
                self.e = facelib.LandmarksExtractor(nnlib.keras)
                self.e.__enter__()
                if self.accurate_landmarks_extractor and device_config.gpu_vram_gb[
                        0] >= 2:
                    self.second_pass_e = facelib.S3FDExtractor()
                    self.second_pass_e.__enter__()
                else:
                    self.second_pass_e = None

            elif self.type == 'final':
                pass
Ejemplo n.º 5
0
    def onClientInitialize(self, client_dict):
        self.safe_print('Running on %s.' % (client_dict['device_name']))
        self.type = client_dict['type']
        self.image_size = client_dict['image_size']
        self.face_type = client_dict['face_type']
        self.device_idx = client_dict['device_idx']
        self.output_path = Path(
            client_dict['output_dir']) if 'output_dir' in client_dict.keys(
            ) else None
        self.debug = client_dict['debug']
        self.detector = client_dict['detector']

        self.keras = None
        self.tf = None
        self.tf_session = None

        self.e = None
        if self.type == 'rects':
            if self.detector is not None:
                if self.detector == 'mt':

                    self.gpu_config = gpufmkmgr.GPUConfig(
                        force_best_gpu_idx=self.device_idx, allow_growth=True)
                    self.tf = gpufmkmgr.import_tf(self.gpu_config)
                    self.tf_session = gpufmkmgr.get_tf_session()
                    self.keras = gpufmkmgr.import_keras()
                    self.e = facelib.MTCExtractor(self.keras, self.tf,
                                                  self.tf_session)
                elif self.detector == 'dlib':
                    self.dlib = gpufmkmgr.import_dlib(self.device_idx)
                    self.e = facelib.DLIBExtractor(self.dlib)
                self.e.__enter__()

        elif self.type == 'landmarks':
            self.gpu_config = gpufmkmgr.GPUConfig(
                force_best_gpu_idx=self.device_idx, allow_growth=True)
            self.tf = gpufmkmgr.import_tf(self.gpu_config)
            self.tf_session = gpufmkmgr.get_tf_session()
            self.keras = gpufmkmgr.import_keras()
            self.e = facelib.LandmarksExtractor(self.keras)
            self.e.__enter__()

        elif self.type == 'final':
            pass

        return None
Ejemplo n.º 6
0
def extract_pass_process(sq, cq):
    e = None
    type = None
    device_idx = None
    debug = False
    output_path = None
    detector = None
    image_size = None
    face_type = None
    while True:
        obj = sq.get()
        obj_op = obj['op']

        if obj_op == 'extract':
            data = obj['data']

            filename_path = Path(data[0])

            if not filename_path.exists():
                cq.put({
                    'op':
                    'error',
                    'close':
                    False,
                    'is_file_not_found':
                    True,
                    'data':
                    obj['data'],
                    'message':
                    'Failed to extract %s, reason: file not found.' %
                    (str(filename_path))
                })
            else:
                try:
                    image = cv2.imread(str(filename_path))

                    if type == 'rects':
                        rects = e.extract_from_bgr(image)
                        cq.put({
                            'op': 'extract_success',
                            'data': obj['data'],
                            'result': [str(filename_path), rects]
                        })

                    elif type == 'landmarks':
                        rects = data[1]
                        landmarks = e.extract_from_bgr(image, rects)
                        cq.put({
                            'op': 'extract_success',
                            'data': obj['data'],
                            'result': [str(filename_path), landmarks]
                        })

                    elif type == 'final':
                        result = []
                        faces = data[1]

                        if debug:
                            debug_output_file = '{}_{}'.format(
                                str(
                                    Path(str(output_path) + '_debug') /
                                    filename_path.stem), 'debug.png')
                            debug_image = image.copy()

                        for (face_idx, face) in enumerate(faces):
                            rect = face[0]
                            image_landmarks = np.array(face[1])
                            image_to_face_mat = facelib.LandmarksProcessor.get_transform_mat(
                                image_landmarks, image_size, face_type)
                            output_file = '{}_{}{}'.format(
                                str(output_path / filename_path.stem),
                                str(face_idx), '.png')

                            if debug:
                                facelib.LandmarksProcessor.draw_rect_landmarks(
                                    debug_image, rect, image_landmarks,
                                    image_size, face_type)

                            face_image = cv2.warpAffine(
                                image, image_to_face_mat,
                                (image_size, image_size))
                            face_image_landmarks = facelib.LandmarksProcessor.transform_points(
                                image_landmarks, image_to_face_mat)

                            cv2.imwrite(output_file, face_image)

                            a_png = AlignedPNG.load(output_file)

                            d = {
                                'type':
                                'face',
                                'landmarks':
                                face_image_landmarks.tolist(),
                                'yaw_value':
                                facelib.LandmarksProcessor.calc_face_yaw(
                                    face_image_landmarks),
                                'pitch_value':
                                facelib.LandmarksProcessor.calc_face_pitch(
                                    face_image_landmarks),
                                'source_filename':
                                filename_path.name,
                                'source_rect':
                                rect,
                                'source_landmarks':
                                image_landmarks.tolist()
                            }
                            a_png.setFaceswapDictData(d)
                            a_png.save(output_file)

                            result.append(output_file)

                        if debug:
                            cv2.imwrite(debug_output_file, debug_image)

                        cq.put({
                            'op': 'extract_success',
                            'data': obj['data'],
                            'result': result
                        })

                except Exception as e:
                    cq.put({
                        'op':
                        'error',
                        'close':
                        True,
                        'data':
                        obj['data'],
                        'message':
                        'Failed to extract %s, reason: %s. \r\n%s' %
                        (str(filename_path), str(e), traceback.format_exc())
                    })
                    break

        elif obj_op == 'init':
            try:
                type = obj['type']
                image_size = obj['image_size']
                face_type = obj['face_type']
                device_idx = obj['device_idx']
                output_path = Path(
                    obj['output_dir']) if 'output_dir' in obj.keys() else None
                debug = obj['debug']
                detector = obj['detector']

                if type == 'rects':
                    if detector is not None:
                        if detector == 'mt':
                            tf = gpufmkmgr.import_tf([device_idx],
                                                     allow_growth=True)
                            tf_session = gpufmkmgr.get_tf_session()
                            keras = gpufmkmgr.import_keras()
                            e = facelib.MTCExtractor(keras, tf, tf_session)
                        elif detector == 'dlib':
                            dlib = gpufmkmgr.import_dlib(device_idx)
                            e = facelib.DLIBExtractor(dlib)
                        e.__enter__()

                elif type == 'landmarks':
                    gpufmkmgr.import_tf([device_idx], allow_growth=True)
                    keras = gpufmkmgr.import_keras()
                    e = facelib.LandmarksExtractor(keras)
                    e.__enter__()
                elif type == 'final':
                    pass

                cq.put({'op': 'init_ok'})
            except Exception as e:
                cq.put({
                    'op':
                    'error',
                    'close':
                    True,
                    'message':
                    'Exception while initialization: %s' %
                    (traceback.format_exc())
                })
                break

    if detector is not None and (type == 'rects' or type == 'landmarks'):
        e.__exit__()
Ejemplo n.º 7
0
        def on_initialize(self, client_dict):
            self.type = client_dict["type"]
            self.image_size = client_dict["image_size"]
            self.face_type = client_dict["face_type"]
            self.device_idx = client_dict["device_idx"]
            self.cpu_only = client_dict["device_type"] == "CPU"
            self.final_output_path = (Path(client_dict["final_output_dir"])
                                      if "final_output_dir"
                                      in client_dict.keys() else None)
            self.debug_dir = client_dict["debug_dir"]

            # transfer and set stdin in order to work code.interact in debug subprocess
            stdin_fd = client_dict["stdin_fd"]
            if stdin_fd is not None and DEBUG:
                sys.stdin = os.fdopen(stdin_fd)

            self.cached_image = (None, None)

            self.e = None
            device_config = nnlib.DeviceConfig(cpu_only=self.cpu_only,
                                               force_gpu_idx=self.device_idx,
                                               allow_growth=True)
            self.device_vram = device_config.gpu_vram_gb[0]

            intro_str = "Running on %s." % (client_dict["device_name"])
            if not self.cpu_only and self.device_vram <= 2:
                intro_str += " Recommended to close all programs using this device."

            self.log_info(intro_str)

            if "rects" in self.type:
                if self.type == "rects-mt":
                    nnlib.import_all(device_config)
                    self.e = facelib.MTCExtractor()
                elif self.type == "rects-dlib":
                    nnlib.import_dlib(device_config)
                    self.e = facelib.DLIBExtractor(nnlib.dlib)
                elif self.type == "rects-s3fd":
                    nnlib.import_all(device_config)
                    self.e = facelib.S3FDExtractor()
                else:
                    raise ValueError("Wrong type.")

                if self.e is not None:
                    self.e.__enter__()

            elif self.type == "landmarks":
                nnlib.import_all(device_config)
                self.e = facelib.LandmarksExtractor(nnlib.keras)
                self.e.__enter__()
                if self.device_vram >= 2:
                    self.second_pass_e = facelib.S3FDExtractor()
                    self.second_pass_e.__enter__()
                else:
                    self.second_pass_e = None

            elif self.type == "fanseg":
                nnlib.import_all(device_config)
                self.e = facelib.FANSegmentator(
                    256, FaceType.toString(FaceType.FULL))
                self.e.__enter__()

            elif self.type == "final":
                pass