def sort_face_cnn(self):
""" Sort by CNN similarity """
self.launch_aligner()
input_dir = self.args.input_dir
logger.info("Sorting by face-cnn similarity...")
img_list = []
for img in tqdm(self.find_images(input_dir),
desc="Loading",
file=sys.stdout):
landmarks = self.get_landmarks(img)
img_list.append([img, np.array(landmarks)
if landmarks
else np.zeros((68, 2))])
queue_manager.terminate_queues()
img_list_len = len(img_list)
for i in tqdm(range(0, img_list_len - 1),
desc="Sorting",
file=sys.stdout):
min_score = float("inf")
j_min_score = i + 1
for j in range(i + 1, len(img_list)):
fl1 = img_list[i][1]
fl2 = img_list[j][1]
score = np.sum(np.absolute((fl2 - fl1).flatten()))
if score < min_score:
min_score = score
j_min_score = j
(img_list[i + 1],
img_list[j_min_score]) = (img_list[j_min_score],
img_list[i + 1])
return img_list
def safe_shutdown():
""" Close queues, threads and processes in event of crash """
logger.debug("Safely shutting down")
from lib.queue_manager import queue_manager
from lib.multithreading import terminate_processes
queue_manager.terminate_queues()
terminate_processes()
logger.debug("Cleanup complete. Shutting down queue manager and exiting")
queue_manager._log_queue.put(None) # pylint: disable=protected-access
while not queue_manager._log_queue.empty(): # pylint: disable=protected-access
continue
queue_manager.manager.shutdown()
def process(self):
""" Process the conversion """
logger.debug("Starting Conversion")
# queue_manager.debug_monitor(2)
self.convert_images()
self.disk_io.save_thread.join()
queue_manager.terminate_queues()
Utils.finalize(self.images.images_found,
self.predictor.faces_count,
self.predictor.verify_output)
logger.debug("Completed Conversion")
def display_frames(self):
""" Iterate through frames """
# pylint: disable=no-member
logger.debug("Display frames")
is_windows = platform.system() == "Windows"
is_conda = "conda" in sys.version.lower()
logger.debug("is_windows: %s, is_conda: %s", is_windows, is_conda)
cv2.namedWindow("Frame")
cv2.namedWindow("Faces")
cv2.setMouseCallback('Frame', self.mouse_handler.on_event)
frame, faces = self.get_frame()
press = self.get_keys()
while True:
self.help.render()
cv2.imshow("Frame", frame)
cv2.imshow("Faces", faces)
key = cv2.waitKey(1)
if self.window_closed(is_windows, is_conda, key):
queue_manager.terminate_queues()
break
if key:
logger.trace("Keypress received: '%s'", key)
if key in press.keys():
action = press[key]["action"]
logger.debug("Keypress action: key: ('%s', action: '%s')", key, action)
if action == "quit":
break
if press[key].get("key_type") == range:
args = press[key]["args"] + [chr(key)]
else:
args = press[key]["args"]
action(*args)
if not self.interface.redraw():
continue
logger.trace("Redraw requested")
frame, faces = self.get_frame()
self.interface.set_redraw(False)
cv2.destroyAllWindows()
def process_item_count(self):
""" Return the number of items to be processedd """
processed = sum(os.path.basename(frame) in self.alignments.data.keys()
for frame in self.images.input_images)
logger.debug("Items already processed: %s", processed)
if processed != 0 and self.args.skip_existing:
logger.info("Skipping previously extracted frames: %s", processed)
if processed != 0 and self.args.skip_faces:
logger.info("Skipping frames with detected faces: %s", processed)
to_process = (self.images.images_found - processed) // self.skip_num
logger.debug("Items to be Processed: %s", to_process)
if to_process == 0:
logger.error("No frames to process. Exiting")
queue_manager.terminate_queues()
exit(0)
return to_process
def detect_faces(self, extract_pass="******"):
""" Detect faces from in an image """
if self.is_parallel or extract_pass == "align":
out_queue = queue_manager.get_queue("align")
if not self.is_parallel and extract_pass == "detect":
out_queue = queue_manager.get_queue("detect")
while True:
try:
faces = out_queue.get(True, 1)
if faces == "EOF":
break
exception = faces.get("exception", None)
if exception is not None:
queue_manager.terminate_queues()
yield faces
break
except QueueEmpty:
continue
yield faces
def display_frames(self):
""" Iterate through frames """
# pylint: disable=no-member
is_windows = True if platform.system() == "Windows" else False
is_conda = True if "conda" in sys.version.lower() else False
cv2.namedWindow("Frame")
cv2.namedWindow("Faces")
cv2.setMouseCallback('Frame', self.mouse_handler.on_event)
frame, faces = self.get_frame()
press = self.get_keys()
while True:
self.help.render()
cv2.imshow("Frame", frame)
cv2.imshow("Faces", faces)
key = cv2.waitKey(1)
if self.window_closed(is_windows, is_conda, key):
queue_manager.terminate_queues()
break
if key in press.keys():
action = press[key]["action"]
if action == "quit":
break
if press[key].get("key_type") == range:
args = press[key]["args"] + [chr(key)]
else:
args = press[key]["args"]
action(*args)
if not self.interface.redraw():
continue
frame, faces = self.get_frame()
self.interface.set_redraw(False)
cv2.destroyAllWindows()
def process(self):
""" Process the conversion """
logger.debug("Starting Conversion")
# queue_manager.debug_monitor(5)
try:
self.convert_images()
self.disk_io.save_thread.join()
queue_manager.terminate_queues()
Utils.finalize(self.images.images_found,
self.predictor.faces_count,
self.predictor.verify_output)
logger.debug("Completed Conversion")
except MemoryError as err:
msg = (
"Faceswap ran out of RAM running convert. Conversion is very system RAM "
"heavy, so this can happen in certain circumstances when you have a lot of "
"cpus but not enough RAM to support them all."
"\nYou should lower the number of processes in use by either setting the "
"'singleprocess' flag (-sp) or lowering the number of parallel jobs (-j)."
)
raise FaceswapError(msg) from err
def process(self):
""" Original & LowMem models go with Adjust or Masked converter
Note: GAN prediction outputs a mask + an image, while other
predicts only an image. """
Utils.set_verbosity(self.args.loglevel)
if not self.alignments.have_alignments_file:
self.load_extractor()
model = self.load_model()
converter = self.load_converter(model)
batch = BackgroundGenerator(self.prepare_images(), 1)
for item in batch.iterator():
self.convert(converter, item)
if self.extract_faces:
queue_manager.terminate_queues()
Utils.finalize(self.images.images_found, self.faces_count,
self.verify_output)
def process(self):
""" The entry point for triggering the Conversion Process.
Should only be called from :class:`lib.cli.launcher.ScriptExecutor`
"""
logger.debug("Starting Conversion")
# queue_manager.debug_monitor(5)
try:
self._convert_images()
self._disk_io.save_thread.join()
queue_manager.terminate_queues()
finalize(self._images.count,
self._predictor.faces_count,
self._predictor.verify_output)
logger.debug("Completed Conversion")
except MemoryError as err:
msg = ("Faceswap ran out of RAM running convert. Conversion is very system RAM "
"heavy, so this can happen in certain circumstances when you have a lot of "
"cpus but not enough RAM to support them all."
"\nYou should lower the number of processes in use by either setting the "
"'singleprocess' flag (-sp) or lowering the number of parallel jobs (-j).")
raise FaceswapError(msg) from err
def display_frames(self):
""" Iterate through frames """
# pylint: disable=no-member
logger.debug("Display frames")
is_windows = platform.system() == "Windows"
is_conda = "conda" in sys.version.lower()
logger.debug("is_windows: %s, is_conda: %s", is_windows, is_conda)
cv2.namedWindow("Frame")
cv2.setMouseCallback('Frame', self.mouse_handler.on_event)
frame = self.get_frame()
press = self.get_keys()
self.interface.set_redraw(True)
while True:
if self.interface.redraw():
self.help.render()
cv2.imshow("Frame", frame)
hsv = cv2.cvtColor(frame, cv2.COLOR_BGR2HSV)
# define range of red color in HSV
lower_red = np.array([30, 150, 50])
upper_red = np.array([255, 255, 180])
# create a red HSV colour boundary and
# threshold HSV image
mask = cv2.inRange(hsv, lower_red, upper_red)
# Bitwise-AND mask and original image
res = cv2.bitwise_and(frame, frame, mask=mask)
# finds edges in the input image image and
# marks them in the output map edges
edges = cv2.Canny(frame, 100, 200)
# Display edges in a frame
cv2.imshow('Edges', edges)
self.interface.set_redraw(False)
key = cv2.waitKey(1000)
if self.window_closed(is_windows, is_conda, key):
queue_manager.terminate_queues()
break
if key and key != -1:
logger.trace("Keypress received: '%s'", key)
if key in press.keys():
action = press[key]["action"]
logger.debug("Keypress action: key: ('%s', action: '%s')", key,
action)
if action == "quit":
break
if press[key].get("key_type") == range:
args = press[key]["args"] + [chr(key)]
else:
args = press[key]["args"]
action(*args)
if not self.interface.redraw():
continue
logger.trace("Redraw requested")
frame = self.get_frame()
cv2.destroyAllWindows()
