def update_landmarks(self): """ Update the landmarks """ queue_manager.get_queue("in").put({"image": self.media["image"], "filename": self.media["frame_id"], "face": self.media["bounding_box"]}) landmarks = queue_manager.get_queue("out").get() if isinstance(landmarks, dict) and landmarks.get("exception"): cv2.destroyAllWindows() # pylint: disable=no-member pid = landmarks["exception"][0] t_back = landmarks["exception"][1].getvalue() err = "Error in child process {}. {}".format(pid, t_back) raise Exception(err) if landmarks == "EOF": exit(0) alignment = self.extracted_to_alignment((landmarks["detected_faces"][0], landmarks["landmarks"][0])) frame = self.media["frame_id"] if self.interface.get_selected_face_id() is None: idx = self.alignments.add_face(frame, alignment) self.interface.set_state_value("edit", "selected", idx) else: self.alignments.update_face(frame, self.interface.get_selected_face_id(), alignment) self.interface.set_redraw(True) self.interface.state["edit"]["updated"] = True self.interface.state["edit"]["update_faces"] = True
def get_landmarks(filename): """ Extract the face from a frame (If not alignments file found) """ image = cv2.imread(filename) queue_manager.get_queue("in").put(Sort.alignment_dict(image)) face = queue_manager.get_queue("out").get() landmarks = face["landmarks"][0] return landmarks
def launch_aligner(self): """ Load the aligner plugin to retrieve landmarks """ out_queue = queue_manager.get_queue("out") kwargs = {"in_queue": queue_manager.get_queue("in"), "out_queue": out_queue} for plugin in ("fan", "cv2_dnn"): aligner = PluginLoader.get_aligner(plugin)(loglevel=self.args.loglevel) process = SpawnProcess(aligner.run, **kwargs) event = process.event process.start() # Wait for Aligner to take init # The first ever load of the model for FAN has reportedly taken # up to 3-4 minutes, hence high timeout. event.wait(300) if not event.is_set(): if plugin == "fan": process.join() logger.error("Error initializing FAN. Trying CV2-DNN") continue else: raise ValueError("Error inititalizing Aligner") if plugin == "cv2_dnn": return try: err = None err = out_queue.get(True, 1) except QueueEmpty: pass if not err: break process.join() logger.error("Error initializing FAN. Trying CV2-DNN")
def init_extractor(self, loglevel): """ Initialize FAN """ logger.debug("Initialize Extractor") out_queue = queue_manager.get_queue("out") d_kwargs = {"in_queue": queue_manager.get_queue("in"), "out_queue": queue_manager.get_queue("align")} a_kwargs = {"in_queue": queue_manager.get_queue("align"), "out_queue": out_queue} detector = PluginLoader.get_detector("manual")(loglevel=loglevel) detect_process = SpawnProcess(detector.run, **d_kwargs) d_event = detect_process.event detect_process.start() for plugin in ("fan", "cv2_dnn"): aligner = PluginLoader.get_aligner(plugin)(loglevel=loglevel) align_process = SpawnProcess(aligner.run, **a_kwargs) a_event = align_process.event align_process.start() # Wait for Aligner to initialize # The first ever load of the model for FAN has reportedly taken # up to 3-4 minutes, hence high timeout. a_event.wait(300) if not a_event.is_set(): if plugin == "fan": align_process.join() logger.error("Error initializing FAN. Trying CV2-DNN") continue else: raise ValueError("Error inititalizing Aligner") if plugin == "cv2_dnn": break try: err = None err = out_queue.get(True, 1) except QueueEmpty: pass if not err: break align_process.join() logger.error("Error initializing FAN. Trying CV2-DNN") d_event.wait(10) if not d_event.is_set(): raise ValueError("Error inititalizing Detector") self.extractor["detect"] = detector self.extractor["align"] = aligner logger.debug("Initialized Extractor")
def make_queues(side, is_timelapse): """ Create the buffer token queues for Fixed Producer Dispatcher """ q_name = "timelapse_{}".format(side) if is_timelapse else "train_{}".format(side) q_names = ["{}_{}".format(q_name, direction) for direction in ("in", "out")] logger.debug(q_names) queues = [queue_manager.get_queue(queue) for queue in q_names] return queues
def convert_images(self): """ Convert the images """ logger.debug("Converting images") save_queue = queue_manager.get_queue("convert_out") patch_queue = queue_manager.get_queue("patch") pool = PoolProcess(self.converter.process, patch_queue, save_queue, processes=self.pool_processes) pool.start() while True: self.check_thread_error() if self.disk_io.completion_event.is_set(): break sleep(1) pool.join() save_queue.put("EOF") logger.debug("Converted images")
def add_queue(self, task): """ Add the queue to queue_manager and set queue attribute """ logger.debug("Adding queue for task: '%s'", task) if task == "load": q_name = "convert_in" elif task == "save": q_name = "convert_out" else: q_name = task setattr(self, "{}_queue".format(task), queue_manager.get_queue(q_name)) logger.debug("Added queue for task: '%s'", task)
def add_queues(self): """ Add the required processing queues to Queue Manager """ queues = dict() for task in ("extract_detect_in", "extract_align_in", "extract_align_out"): # Limit queue size to avoid stacking ram size = 32 if task == "extract_detect_in" or (not self.is_parallel and task == "extract_align_in"): size = 64 queue_manager.add_queue(task, maxsize=size) queues[task] = queue_manager.get_queue(task) logger.debug("Queues: %s", queues) return queues
def launch_detector(self): """ Launch the face detector """ logger.debug("Launching Detector") out_queue = queue_manager.get_queue("detect") kwargs = { "in_queue": queue_manager.get_queue("load"), "out_queue": out_queue } if self.converter_args: kwargs["processes"] = 1 mp_func = PoolProcess if self.detector.parent_is_pool else SpawnProcess self.process_detect = mp_func(self.detector.run, **kwargs) event = self.process_detect.event if hasattr(self.process_detect, "event") else None error = self.process_detect.error if hasattr(self.process_detect, "error") else None self.process_detect.start() if event is None: logger.debug("Launched Detector") return for mins in reversed(range(5)): for seconds in range(60): event.wait(seconds) if event.is_set(): break if error and error.is_set(): break if event.is_set(): break if mins == 0 or (error and error.is_set()): raise ValueError("Error initializing Detector") logger.info("Waiting for Detector... Time out in %s minutes", mins) logger.debug("Launched Detector")
def launch_aligner(): """ Load the aligner plugin to retrieve landmarks """ out_queue = queue_manager.get_queue("out") kwargs = { "in_queue": queue_manager.get_queue("in"), "out_queue": out_queue } for plugin in ("fan", "dlib"): aligner = PluginLoader.get_aligner(plugin)() process = SpawnProcess(aligner.run, **kwargs) event = process.event process.start() # Wait for Aligner to take init # The first ever load of the model for FAN has reportedly taken # up to 3-4 minutes, hence high timeout. event.wait(300) if not event.is_set(): if plugin == "fan": process.join() logger.error("Error initializing FAN. Trying Dlib") continue else: raise ValueError("Error inititalizing Aligner") if plugin == "dlib": return try: err = None err = out_queue.get(True, 1) except QueueEmpty: pass if not err: break process.join() logger.error("Error initializing FAN. Trying Dlib")
def load_extractor(self): """ Set on the fly extraction """ print("\nNo Alignments file found. Extracting on the fly.\n" "NB: This will use the inferior dlib-hog for extraction " "and dlib pose predictor for landmarks.\nIt is recommended " "to perfom Extract first for superior results\n") for task in ("load", "detect", "align"): queue_manager.add_queue(task, maxsize=0) detector = PluginLoader.get_detector("dlib_hog")( verbose=self.args.verbose) aligner = PluginLoader.get_aligner("dlib")(verbose=self.args.verbose) d_kwargs = { "in_queue": queue_manager.get_queue("load"), "out_queue": queue_manager.get_queue("detect") } a_kwargs = { "in_queue": queue_manager.get_queue("detect"), "out_queue": queue_manager.get_queue("align") } d_process = SpawnProcess() d_event = d_process.event a_process = SpawnProcess() a_event = a_process.event d_process.in_process(detector.detect_faces, **d_kwargs) a_process.in_process(aligner.align, **a_kwargs) d_event.wait(10) if not d_event.is_set(): raise ValueError("Error inititalizing Detector") a_event.wait(10) if not a_event.is_set(): raise ValueError("Error inititalizing Aligner") self.extract_faces = True
def make_queues(side, is_preview, is_timelapse): """ Create the buffer token queues for Fixed Producer Dispatcher """ q_name = "_{}".format(side) if is_preview: q_name = "{}{}".format("preview", q_name) elif is_timelapse: q_name = "{}{}".format("timelapse", q_name) else: q_name = "{}{}".format("train", q_name) q_names = [ "{}_{}".format(q_name, direction) for direction in ("in", "out") ] logger.debug(q_names) queues = [queue_manager.get_queue(queue) for queue in q_names] return queues
def launch_aligner(self): """ Launch the face aligner """ logger.debug("Launching Aligner") out_queue = queue_manager.get_queue("align") kwargs = {"in_queue": queue_manager.get_queue("detect"), "out_queue": out_queue} self.process_align = SpawnProcess(self.aligner.run, **kwargs) event = self.process_align.event self.process_align.start() # Wait for Aligner to take it's VRAM # The first ever load of the model for FAN has reportedly taken # up to 3-4 minutes, hence high timeout. # TODO investigate why this is and fix if possible for mins in reversed(range(5)): event.wait(60) if event.is_set(): break if mins == 0: raise ValueError("Error initializing Aligner") logger.info("Waiting for Aligner... Time out in %s minutes", mins) logger.debug("Launched Aligner")
def launch_detector(self): """ Launch the face detector """ logger.debug("Launching Detector") out_queue = queue_manager.get_queue("detect") kwargs = { "in_queue": queue_manager.get_queue("load"), "out_queue": out_queue } if self.args.detector == "mtcnn": mtcnn_kwargs = self.detector.validate_kwargs( self.get_mtcnn_kwargs()) kwargs["mtcnn_kwargs"] = mtcnn_kwargs mp_func = PoolProcess if self.detector.parent_is_pool else SpawnProcess self.process_detect = mp_func(self.detector.run, **kwargs) event = None if hasattr(self.process_detect, "event"): event = self.process_detect.event self.process_detect.start() if event is None: logger.debug("Launched Detector") return for mins in reversed(range(5)): event.wait(60) if event.is_set(): break if mins == 0: raise ValueError("Error initializing Detector") logger.info("Waiting for Detector... Time out in %s minutes", mins) logger.debug("Launched Detector")
def update_landmarks(self): """ Update the landmarks """ queue_manager.get_queue("in").put({ "image": self.media["image"], "face": self.media["bounding_box"] }) landmarks = queue_manager.get_queue("out").get() if landmarks == "EOF": exit(0) alignment = self.extracted_to_alignment( (landmarks["detected_faces"][0], landmarks["landmarks"][0])) frame = self.media["frame_id"] if self.interface.get_selected_face_id() is None: idx = self.alignments.add_face(frame, alignment) self.interface.set_state_value("edit", "selected", idx) else: self.alignments.update_face(frame, self.interface.get_selected_face_id(), alignment) self.interface.set_redraw(True) self.interface.state["edit"]["updated"] = True self.interface.state["edit"]["update_faces"] = True
def save_faces(self): """ Save the generated faces """ if not self.export_face: return save_queue = queue_manager.get_queue("save") while True: item = save_queue.get() if item == "EOF": break filename, output_file, resized_face, idx = item out_filename = "{}_{}{}".format(str(output_file), str(idx), Path(filename).suffix) # pylint: disable=no-member cv2.imwrite(out_filename, resized_face)
def _add_queues(self): """ Add the required processing queues to Queue Manager """ queues = dict() tasks = [ "extract{}_{}_in".format(self._instance, phase) for phase in self._flow ] tasks.append("extract{}_{}_out".format(self._instance, self._final_phase)) for task in tasks: # Limit queue size to avoid stacking ram queue_manager.add_queue(task, maxsize=self._queue_size) queues[task] = queue_manager.get_queue(task) logger.debug("Queues: %s", queues) return queues
def _convert_images(self): """ Start the multi-threaded patching process, monitor all threads for errors and join on completion. """ logger.debug("Converting images") save_queue = queue_manager.get_queue("convert_out") patch_queue = queue_manager.get_queue("patch") self._patch_threads = MultiThread(self._converter.process, patch_queue, save_queue, thread_count=self._pool_processes, name="patch") self._patch_threads.start() while True: self._check_thread_error() if self._disk_io.completion_event.is_set(): logger.debug("DiskIO completion event set. Joining Pool") break if self._patch_threads.completed(): logger.debug("All patch threads completed") break sleep(1) self._patch_threads.join() logger.debug("Putting EOF") save_queue.put("EOF") logger.debug("Converted images")
def _add_queues(self): """ Add the required processing queues to Queue Manager """ queues = dict() tasks = ["extract_{}_in".format(phase) for phase in self._flow] tasks.append("extract_{}_out".format(self._final_phase)) for task in tasks: # Limit queue size to avoid stacking ram self._queue_size = 32 if task == "extract_{}_in".format( self._flow[0]) or (not self._is_parallel and not task.endswith("_out")): self._queue_size = 64 queue_manager.add_queue(task, maxsize=self._queue_size) queues[task] = queue_manager.get_queue(task) logger.debug("Queues: %s", queues) return queues
def load_images(self): """ Load the images """ logger.debug("Load Images: Start") load_queue = queue_manager.get_queue("load") for filename, image in self.images.load(): if load_queue.shutdown.is_set(): logger.debug("Load Queue: Stop signal received. Terminating") break imagename = os.path.basename(filename) if imagename in self.alignments.data.keys(): logger.trace("Skipping image: '%s'", filename) continue item = {"filename": filename, "image": image} load_queue.put(item) load_queue.put("EOF") logger.debug("Load Images: Complete")
def process_faces(self, filename, faces): """ Perform processing on found faces """ final_faces = list() save_queue = queue_manager.get_queue("save") filename = faces["filename"] output_file = faces["output_file"] for idx, face in enumerate(faces["detected_faces"]): if self.export_face: save_queue.put((filename, output_file, face.aligned_face, idx)) final_faces.append(face.to_alignment()) self.alignments.data[os.path.basename(filename)] = final_faces
def _add_queue(self, task): """ Add the queue to queue_manager and to :attr:`self._queues` for the given task. Parameters ---------- task: {"load", "save"} The task that the queue is to be added for """ logger.debug("Adding queue for task: '%s'", task) if task == "load": q_name = "convert_in" elif task == "save": q_name = "convert_out" else: q_name = task self._queues[task] = queue_manager.get_queue(q_name) logger.debug("Added queue for task: '%s'", task)
def run_extraction(self, save_thread): """ Run Face Detection """ save_queue = queue_manager.get_queue("save") to_process = self.process_item_count() frame_no = 0 size = self.args.size if hasattr(self.args, "size") else 256 align_eyes = self.args.align_eyes if hasattr(self.args, "align_eyes") else False if self.plugins.is_parallel: logger.debug("Using parallel processing") self.plugins.launch_aligner() self.plugins.launch_detector() if not self.plugins.is_parallel: logger.debug("Using serial processing") self.run_detection(to_process) self.plugins.launch_aligner() for faces in tqdm(self.plugins.detect_faces(extract_pass="******"), total=to_process, file=sys.stdout, desc="Extracting faces"): filename = faces["filename"] self.align_face(faces, align_eyes, size, filename) self.post_process.do_actions(faces) faces_count = len(faces["detected_faces"]) if faces_count == 0: logger.verbose("No faces were detected in image: %s", os.path.basename(filename)) if not self.verify_output and faces_count > 1: self.verify_output = True self.process_faces(filename, faces, save_queue) frame_no += 1 if frame_no == self.save_interval: self.alignments.save() frame_no = 0 if self.export_face: save_queue.put("EOF") save_thread.join()
def __init__(self, in_queue, queue_size, arguments): logger.debug("Initializing %s: (args: %s, queue_size: %s, in_queue: %s)", self.__class__.__name__, arguments, queue_size, in_queue) self.batchsize = self.get_batchsize(queue_size) self.args = arguments self.in_queue = in_queue self.out_queue = queue_manager.get_queue("patch") self.serializer = Serializer.get_serializer("json") self.faces_count = 0 self.verify_output = False self.model = self.load_model() self.predictor = self.model.converter(self.args.swap_model) self.queues = dict() self.thread = MultiThread(self.predict_faces, thread_count=1) self.thread.start() logger.debug("Initialized %s: (out_queue: %s)", self.__class__.__name__, self.out_queue)
def reload_images(self, detected_faces): """ Reload the images and pair to detected face """ logger.debug("Reload Images: Start. Detected Faces Count: %s", len(detected_faces)) load_queue = queue_manager.get_queue("detect") for filename, image in self.images.load(): if load_queue.shutdown.is_set(): logger.debug("Reload Queue: Stop signal received. Terminating") break logger.trace("Reloading image: '%s'", filename) detect_item = detected_faces.pop(filename, None) if not detect_item: logger.warning("Couldn't find faces for: %s", filename) continue detect_item["image"] = image load_queue.put(detect_item) load_queue.put("EOF") logger.debug("Reload Images: Complete")
def __init__(self, path, task, load_with_hash=False, queue_size=16): logger.debug( "Initializing %s: (path: %s, task: %s, load_with_hash: %s, queue_size: %s)", self.__class__.__name__, path, task, load_with_hash, queue_size) self._location = path self._task = task.lower() self._is_video = self._check_input() self._input = self.location if self._is_video else get_image_paths( self.location) self._count = count_frames_and_secs( self._input)[0] if self._is_video else len(self._input) self._queue = queue_manager.get_queue(name="{}_{}".format( self.__class__.__name__, self._task), maxsize=queue_size) self._thread = self._set_thread(io_args=(load_with_hash, )) self._thread.start()
def __init__(self, in_queue, queue_size, arguments): logger.debug("Initializing %s: (args: %s, queue_size: %s, in_queue: %s)", self.__class__.__name__, arguments, queue_size, in_queue) self.batchsize = min(queue_size, 16) self.args = arguments self.in_queue = in_queue self.out_queue = queue_manager.get_queue("patch") self.serializer = Serializer.get_serializer("json") self.faces_count = 0 self.verify_output = False self.model = self.load_model() self.predictor = self.model.converter(self.args.swap_model) self.queues = dict() self.thread = MultiThread(self.predict_faces, thread_count=1) self.thread.start() logger.debug("Initialized %s: (out_queue: %s)", self.__class__.__name__, self.out_queue)
def __init__(self, in_queue, queue_size, arguments): logger.debug( "Initializing %s: (args: %s, queue_size: %s, in_queue: %s)", self.__class__.__name__, arguments, queue_size, in_queue) self._batchsize = self._get_batchsize(queue_size) self._args = arguments self._in_queue = in_queue self._out_queue = queue_manager.get_queue("patch") self._serializer = get_serializer("json") self._faces_count = 0 self._verify_output = False self._model = self._load_model() self._sizes = self._get_io_sizes() self._coverage_ratio = self._model.coverage_ratio self._thread = self._launch_predictor() logger.debug("Initialized %s: (out_queue: %s)", self.__class__.__name__, self._out_queue)
def __init__(self, arguments): logger.debug("Initializing %s: (args: %s", self.__class__.__name__, arguments) self.args = arguments Utils.set_verbosity(self.args.loglevel) self.output_dir = get_folder(self.args.output_dir) logger.info("Output Directory: %s", self.args.output_dir) self.images = Images(self.args) self.alignments = Alignments(self.args, True, self.images.is_video) self.post_process = PostProcess(arguments) self.extractor = Extractor(self.args.detector, self.args.aligner, self.args.loglevel, self.args.multiprocess, self.args.rotate_images, self.args.min_size) self.save_queue = queue_manager.get_queue("extract_save") self.verify_output = False self.save_interval = None if hasattr(self.args, "save_interval"): self.save_interval = self.args.save_interval logger.debug("Initialized %s", self.__class__.__name__)
def save_faces(): """ Save the generated faces """ logger.debug("Save Faces: Start") save_queue = queue_manager.get_queue("save") while True: if save_queue.shutdown.is_set(): logger.debug("Save Queue: Stop signal received. Terminating") break item = save_queue.get() if item == "EOF": break filename, face = item logger.trace("Saving face: '%s'", filename) try: with open(filename, "wb") as out_file: out_file.write(face) except Exception as err: # pylint: disable=broad-except logger.error("Failed to save image '%s'. Original Error: %s", filename, err) continue logger.debug("Save Faces: Complete")
def __init__(self, arguments): logger.debug("Initializing %s: (args: %s", self.__class__.__name__, arguments) self.args = arguments Utils.set_verbosity(self.args.loglevel) self.output_dir = get_folder(self.args.output_dir) logger.info("Output Directory: %s", self.args.output_dir) self.images = Images(self.args) self.alignments = Alignments(self.args, True, self.images.is_video) self.post_process = PostProcess(arguments) self.extractor = Extractor(self.args.detector, self.args.aligner, self.args.loglevel, self.args.multiprocess, self.args.rotate_images, self.args.min_size) self.save_queue = queue_manager.get_queue("extract_save") self.verify_output = False self.save_interval = None if hasattr(self.args, "save_interval"): self.save_interval = self.args.save_interval logger.debug("Initialized %s", self.__class__.__name__)
def minibatch(self, q_name, load_thread): """ A generator function that yields epoch, batchsize of warped_img and batchsize of target_img from the load queue """ logger.debug("Launching minibatch generator for queue: '%s'", q_name) queue = queue_manager.get_queue(q_name) while True: if load_thread.has_error: logger.debug("Thread error detected") break batch = list() for _ in range(self.batchsize): images = queue.get() for idx, image in enumerate(images): if len(batch) < idx + 1: batch.append(list()) batch[idx].append(image) batch = [np.float32(image) for image in batch] logger.trace( "Yielding batch: (size: %s, item shapes: %s, queue: '%s'", len(batch), [item.shape for item in batch], q_name) yield batch logger.debug("Finished minibatch generator for queue: '%s'", q_name) load_thread.join()
def process(self, trigger_event, shutdown_event, patch_queue_in, samples, tk_vars): """ Wait for event trigger and run when process when set """ patch_queue_out = queue_manager.get_queue("preview_patch_out") while True: trigger = trigger_event.wait(1) if shutdown_event.is_set(): logger.debug("Shutdown received") break if not trigger: continue # Clear trigger so calling process can set it during this run trigger_event.clear() tk_vars["busy"].set(True) queue_manager.flush_queue("preview_patch_in") self.feed_swapped_faces(patch_queue_in, samples) with self.lock: self.update_converter_arguments() self.converter.reinitialize(config=self.current_config) swapped = self.patch_faces(patch_queue_in, patch_queue_out, samples.sample_size) with self.lock: self.display.destination = swapped tk_vars["refresh"].set(True) tk_vars["busy"].set(False)
def __init__(self, arguments, samples, display, lock, trigger, config_tools, tk_vars): logger.debug( "Initializing %s: (arguments: '%s', samples: %s: display: %s, lock: %s," " trigger: %s, config_tools: %s, tk_vars %s)", self.__class__.__name__, arguments, samples, display, lock, trigger, config_tools, tk_vars) self.samples = samples self.queue_patch_in = queue_manager.get_queue("preview_patch_in") self.display = display self.lock = lock self.trigger = trigger self.current_config = config_tools.config self.converter_arguments = None # Updated converter arguments dict configfile = arguments.configfile if hasattr(arguments, "configfile") else None self.converter = Converter( output_dir=None, output_size=self.samples.predictor.output_size, output_has_mask=self.samples.predictor.has_predicted_mask, draw_transparent=False, pre_encode=None, configfile=configfile, arguments=self.generate_converter_arguments(arguments)) self.shutdown = Event() self.thread = MultiThread(self.process, self.trigger, self.shutdown, self.queue_patch_in, self.samples, tk_vars, thread_count=1, name="patch_thread") self.thread.start()
def __init__(self, arguments, sample_size, display, lock, trigger_patch): logger.debug("Initializing %s: (arguments: '%s', sample_size: %s, display: %s, lock: %s, " "trigger_patch: %s)", self.__class__.__name__, arguments, sample_size, display, lock, trigger_patch) self.sample_size = sample_size self.display = display self.lock = lock self.trigger_patch = trigger_patch self.input_images = list() self.predicted_images = list() self.images = Images(arguments) self.alignments = Alignments(arguments, is_extract=False, input_is_video=self.images.is_video) self.filelist = self.get_filelist() self.indices = self.get_indices() self.predictor = Predict(queue_manager.get_queue("preview_predict_in"), sample_size, arguments) self.generate() logger.debug("Initialized %s", self.__class__.__name__)
def patch_iterator(self, processes): """ Prepare the images for conversion """ out_queue = queue_manager.get_queue("out") completed = 0 while True: try: item = out_queue.get(True, 1) except QueueEmpty: self.check_thread_error() continue self.check_thread_error() if item == "EOF": completed += 1 logger.debug("Got EOF %s of %s", completed, processes) if completed == processes: break continue logger.trace("Yielding: '%s'", item[0]) yield item logger.debug("iterator exhausted") return "EOF"
def patch_iterator(self, processes): """ Prepare the images for conversion """ out_queue = queue_manager.get_queue("out") completed = 0 while True: try: item = out_queue.get(True, 1) except QueueEmpty: self.check_thread_error() continue self.check_thread_error() if item == "EOF": completed += 1 logger.debug("Got EOF %s of %s", completed, processes) if completed == processes: break continue logger.trace("Yielding: '%s'", item[0]) yield item logger.debug("iterator exhausted") return "EOF"
def __init__(self, in_queue, queue_size, arguments): logger.debug( "Initializing %s: (args: %s, queue_size: %s, in_queue: %s)", self.__class__.__name__, arguments, queue_size, in_queue) self._batchsize = self._get_batchsize(queue_size) self._args = arguments self._in_queue = in_queue self._out_queue = queue_manager.get_queue("patch") self._serializer = get_serializer("json") self._faces_count = 0 self._verify_output = False if arguments.allow_growth: self._set_tf_allow_growth() self._model = self._load_model() self._output_indices = { "face": self._model.largest_face_index, "mask": self._model.largest_mask_index } self._predictor = self._model.converter(self._args.swap_model) self._thread = self._launch_predictor() logger.debug("Initialized %s: (out_queue: %s)", self.__class__.__name__, self._out_queue)
def launch_aligner(self): """ Load the aligner plugin to retrieve landmarks """ out_queue = queue_manager.get_queue("out") kwargs = {"in_queue": queue_manager.get_queue("in"), "out_queue": out_queue}
face = face.to_dlib_rect() ======= face = face.to_bounding_box_dict() >>>>>>> upstream/master return {"image": image, "detected_faces": [face]} @staticmethod def get_landmarks(filename): """ Extract the face from a frame (If not alignments file found) """ <<<<<<< HEAD image = cv2.imread(filename) ======= image = cv2_read_img(filename, raise_error=True) >>>>>>> upstream/master queue_manager.get_queue("in").put(Sort.alignment_dict(image)) face = queue_manager.get_queue("out").get() landmarks = face["landmarks"][0] return landmarks def sort_process(self): """ This method dynamically assigns the functions that will be used to run the core process of sorting, optionally grouping, renaming/moving into folders. After the functions are assigned they are executed. """ sort_method = self.args.sort_method.lower() group_method = self.args.group_method.lower() final_method = self.args.final_process.lower() img_list = getattr(self, sort_method)()
def get_landmarks(self, filename): """ Get landmarks for current image """ image = cv2.imread(filename) queue_manager.get_queue("in").put(self.alignment_dict(image)) face = queue_manager.get_queue("out").get() return face["detected_faces"][0].landmarksXY