mirror of
https://github.com/facefusion/facefusion.git
synced 2026-07-28 12:59:03 +02:00
Compare commits
| Author | SHA1 | Date | |
|---|---|---|---|
 Henry RuhsandGitHub
|
666c15f9da | ||
|
|
420d738a6b | ||
|
henryruhs
|
81c5e85dea | ||
|
|
8bf9170577 | ||
|
|
189d750621 | ||
|
Henry RuhsandGitHub
|
f3be23d19b | ||
|
henryruhs
|
16e84b43ce | ||
|
|
da0da3a4b4 |
@@ -0,0 +1,2 @@
|
||||
[run]
|
||||
patch = subprocess
|
||||
Executable → Regular
BIN
Binary file not shown.
|
Before Width: | Height: | Size: 1.3 MiB After Width: | Height: | Size: 1.3 MiB |
+2
-1
@@ -1,6 +1,7 @@
|
||||
__pycache__
|
||||
.assets
|
||||
.claude
|
||||
.caches
|
||||
.jobs
|
||||
.idea
|
||||
.jobs
|
||||
.vscode
|
||||
|
||||
+12
-4
@@ -13,6 +13,7 @@ output_pattern =
|
||||
[face_detector]
|
||||
face_detector_model =
|
||||
face_detector_size =
|
||||
face_detector_margin =
|
||||
face_detector_angles =
|
||||
face_detector_score =
|
||||
|
||||
@@ -40,6 +41,9 @@ face_mask_regions =
|
||||
face_mask_blur =
|
||||
face_mask_padding =
|
||||
|
||||
[voice_extractor]
|
||||
voice_extractor_model =
|
||||
|
||||
[frame_extraction]
|
||||
trim_frame_start =
|
||||
trim_frame_end =
|
||||
@@ -48,24 +52,27 @@ keep_temp =
|
||||
|
||||
[output_creation]
|
||||
output_image_quality =
|
||||
output_image_resolution =
|
||||
output_image_scale =
|
||||
output_audio_encoder =
|
||||
output_audio_quality =
|
||||
output_audio_volume =
|
||||
output_video_encoder =
|
||||
output_video_preset =
|
||||
output_video_quality =
|
||||
output_video_resolution =
|
||||
output_video_scale =
|
||||
output_video_fps =
|
||||
|
||||
[processors]
|
||||
processors =
|
||||
age_modifier_model =
|
||||
age_modifier_direction =
|
||||
background_remover_model =
|
||||
background_remover_color =
|
||||
deep_swapper_model =
|
||||
deep_swapper_morph =
|
||||
expression_restorer_model =
|
||||
expression_restorer_factor =
|
||||
expression_restorer_areas =
|
||||
face_debugger_items =
|
||||
face_editor_model =
|
||||
face_editor_eyebrow_direction =
|
||||
@@ -87,6 +94,7 @@ face_enhancer_blend =
|
||||
face_enhancer_weight =
|
||||
face_swapper_model =
|
||||
face_swapper_pixel_boost =
|
||||
face_swapper_weight =
|
||||
frame_colorizer_model =
|
||||
frame_colorizer_size =
|
||||
frame_colorizer_blend =
|
||||
@@ -105,14 +113,14 @@ download_providers =
|
||||
download_scope =
|
||||
|
||||
[benchmark]
|
||||
benchmark_mode =
|
||||
benchmark_resolutions =
|
||||
benchmark_cycle_count =
|
||||
|
||||
[execution]
|
||||
execution_device_id =
|
||||
execution_device_ids =
|
||||
execution_providers =
|
||||
execution_thread_count =
|
||||
execution_queue_count =
|
||||
|
||||
[memory]
|
||||
video_memory_strategy =
|
||||
|
||||
+11
-20
@@ -1,10 +1,10 @@
|
||||
from facefusion import state_manager
|
||||
from facefusion.filesystem import get_file_name, is_image, is_video, resolve_file_paths
|
||||
from facefusion.filesystem import get_file_name, is_video, resolve_file_paths
|
||||
from facefusion.jobs import job_store
|
||||
from facefusion.normalizer import normalize_fps, normalize_padding
|
||||
from facefusion.normalizer import normalize_fps, normalize_space
|
||||
from facefusion.processors.core import get_processors_modules
|
||||
from facefusion.types import ApplyStateItem, Args
|
||||
from facefusion.vision import create_image_resolutions, create_video_resolutions, detect_image_resolution, detect_video_fps, detect_video_resolution, pack_resolution
|
||||
from facefusion.vision import detect_video_fps
|
||||
|
||||
|
||||
def reduce_step_args(args : Args) -> Args:
|
||||
@@ -55,6 +55,7 @@ def apply_args(args : Args, apply_state_item : ApplyStateItem) -> None:
|
||||
# face detector
|
||||
apply_state_item('face_detector_model', args.get('face_detector_model'))
|
||||
apply_state_item('face_detector_size', args.get('face_detector_size'))
|
||||
apply_state_item('face_detector_margin', normalize_space(args.get('face_detector_margin')))
|
||||
apply_state_item('face_detector_angles', args.get('face_detector_angles'))
|
||||
apply_state_item('face_detector_score', args.get('face_detector_score'))
|
||||
# face landmarker
|
||||
@@ -77,7 +78,9 @@ def apply_args(args : Args, apply_state_item : ApplyStateItem) -> None:
|
||||
apply_state_item('face_mask_areas', args.get('face_mask_areas'))
|
||||
apply_state_item('face_mask_regions', args.get('face_mask_regions'))
|
||||
apply_state_item('face_mask_blur', args.get('face_mask_blur'))
|
||||
apply_state_item('face_mask_padding', normalize_padding(args.get('face_mask_padding')))
|
||||
apply_state_item('face_mask_padding', normalize_space(args.get('face_mask_padding')))
|
||||
# voice extractor
|
||||
apply_state_item('voice_extractor_model', args.get('voice_extractor_model'))
|
||||
# frame extraction
|
||||
apply_state_item('trim_frame_start', args.get('trim_frame_start'))
|
||||
apply_state_item('trim_frame_end', args.get('trim_frame_end'))
|
||||
@@ -85,26 +88,14 @@ def apply_args(args : Args, apply_state_item : ApplyStateItem) -> None:
|
||||
apply_state_item('keep_temp', args.get('keep_temp'))
|
||||
# output creation
|
||||
apply_state_item('output_image_quality', args.get('output_image_quality'))
|
||||
if is_image(args.get('target_path')):
|
||||
output_image_resolution = detect_image_resolution(args.get('target_path'))
|
||||
output_image_resolutions = create_image_resolutions(output_image_resolution)
|
||||
if args.get('output_image_resolution') in output_image_resolutions:
|
||||
apply_state_item('output_image_resolution', args.get('output_image_resolution'))
|
||||
else:
|
||||
apply_state_item('output_image_resolution', pack_resolution(output_image_resolution))
|
||||
apply_state_item('output_image_scale', args.get('output_image_scale'))
|
||||
apply_state_item('output_audio_encoder', args.get('output_audio_encoder'))
|
||||
apply_state_item('output_audio_quality', args.get('output_audio_quality'))
|
||||
apply_state_item('output_audio_volume', args.get('output_audio_volume'))
|
||||
apply_state_item('output_video_encoder', args.get('output_video_encoder'))
|
||||
apply_state_item('output_video_preset', args.get('output_video_preset'))
|
||||
apply_state_item('output_video_quality', args.get('output_video_quality'))
|
||||
if is_video(args.get('target_path')):
|
||||
output_video_resolution = detect_video_resolution(args.get('target_path'))
|
||||
output_video_resolutions = create_video_resolutions(output_video_resolution)
|
||||
if args.get('output_video_resolution') in output_video_resolutions:
|
||||
apply_state_item('output_video_resolution', args.get('output_video_resolution'))
|
||||
else:
|
||||
apply_state_item('output_video_resolution', pack_resolution(output_video_resolution))
|
||||
apply_state_item('output_video_scale', args.get('output_video_scale'))
|
||||
if args.get('output_video_fps') or is_video(args.get('target_path')):
|
||||
output_video_fps = normalize_fps(args.get('output_video_fps')) or detect_video_fps(args.get('target_path'))
|
||||
apply_state_item('output_video_fps', output_video_fps)
|
||||
@@ -118,14 +109,14 @@ def apply_args(args : Args, apply_state_item : ApplyStateItem) -> None:
|
||||
apply_state_item('ui_layouts', args.get('ui_layouts'))
|
||||
apply_state_item('ui_workflow', args.get('ui_workflow'))
|
||||
# execution
|
||||
apply_state_item('execution_device_id', args.get('execution_device_id'))
|
||||
apply_state_item('execution_device_ids', args.get('execution_device_ids'))
|
||||
apply_state_item('execution_providers', args.get('execution_providers'))
|
||||
apply_state_item('execution_thread_count', args.get('execution_thread_count'))
|
||||
apply_state_item('execution_queue_count', args.get('execution_queue_count'))
|
||||
# download
|
||||
apply_state_item('download_providers', args.get('download_providers'))
|
||||
apply_state_item('download_scope', args.get('download_scope'))
|
||||
# benchmark
|
||||
apply_state_item('benchmark_mode', args.get('benchmark_mode'))
|
||||
apply_state_item('benchmark_resolutions', args.get('benchmark_resolutions'))
|
||||
apply_state_item('benchmark_cycle_count', args.get('benchmark_cycle_count'))
|
||||
# memory
|
||||
|
||||
+5
-5
@@ -11,7 +11,7 @@ from facefusion.types import Audio, AudioFrame, Fps, Mel, MelFilterBank, Spectro
|
||||
from facefusion.voice_extractor import batch_extract_voice
|
||||
|
||||
|
||||
@lru_cache()
|
||||
@lru_cache(maxsize = 64)
|
||||
def read_static_audio(audio_path : str, fps : Fps) -> Optional[List[AudioFrame]]:
|
||||
return read_audio(audio_path, fps)
|
||||
|
||||
@@ -31,7 +31,7 @@ def read_audio(audio_path : str, fps : Fps) -> Optional[List[AudioFrame]]:
|
||||
return None
|
||||
|
||||
|
||||
@lru_cache()
|
||||
@lru_cache(maxsize = 64)
|
||||
def read_static_voice(audio_path : str, fps : Fps) -> Optional[List[AudioFrame]]:
|
||||
return read_voice(audio_path, fps)
|
||||
|
||||
@@ -118,12 +118,12 @@ def convert_mel_to_hertz(mel : Mel) -> NDArray[Any]:
|
||||
|
||||
def create_mel_filter_bank() -> MelFilterBank:
|
||||
audio_sample_rate = 16000
|
||||
audio_min_frequency = 55.0
|
||||
audio_max_frequency = 7600.0
|
||||
audio_frequency_min = 55.0
|
||||
audio_frequency_max = 7600.0
|
||||
mel_filter_total = 80
|
||||
mel_bin_total = 800
|
||||
mel_filter_bank = numpy.zeros((mel_filter_total, mel_bin_total // 2 + 1))
|
||||
mel_frequency_range = numpy.linspace(convert_hertz_to_mel(audio_min_frequency), convert_hertz_to_mel(audio_max_frequency), mel_filter_total + 2)
|
||||
mel_frequency_range = numpy.linspace(convert_hertz_to_mel(audio_frequency_min), convert_hertz_to_mel(audio_frequency_max), mel_filter_total + 2)
|
||||
indices = numpy.floor((mel_bin_total + 1) * convert_mel_to_hertz(mel_frequency_range) / audio_sample_rate).astype(numpy.int16)
|
||||
|
||||
for index in range(mel_filter_total):
|
||||
|
||||
+16
-11
@@ -3,15 +3,16 @@ import os
|
||||
import statistics
|
||||
import tempfile
|
||||
from time import perf_counter
|
||||
from typing import Generator, List
|
||||
from typing import Iterator, List
|
||||
|
||||
import facefusion.choices
|
||||
from facefusion import core, state_manager
|
||||
from facefusion import content_analyser, core, state_manager
|
||||
from facefusion.cli_helper import render_table
|
||||
from facefusion.download import conditional_download, resolve_download_url
|
||||
from facefusion.face_store import clear_static_faces
|
||||
from facefusion.filesystem import get_file_extension
|
||||
from facefusion.types import BenchmarkCycleSet
|
||||
from facefusion.vision import count_video_frame_total, detect_video_fps, detect_video_resolution, pack_resolution
|
||||
from facefusion.vision import count_video_frame_total, detect_video_fps
|
||||
|
||||
|
||||
def pre_check() -> bool:
|
||||
@@ -30,7 +31,7 @@ def pre_check() -> bool:
|
||||
return True
|
||||
|
||||
|
||||
def run() -> Generator[List[BenchmarkCycleSet], None, None]:
|
||||
def run() -> Iterator[List[BenchmarkCycleSet]]:
|
||||
benchmark_resolutions = state_manager.get_item('benchmark_resolutions')
|
||||
benchmark_cycle_count = state_manager.get_item('benchmark_cycle_count')
|
||||
|
||||
@@ -42,11 +43,11 @@ def run() -> Generator[List[BenchmarkCycleSet], None, None]:
|
||||
state_manager.init_item('video_memory_strategy', 'tolerant')
|
||||
|
||||
benchmarks = []
|
||||
target_paths = [facefusion.choices.benchmark_set.get(benchmark_resolution) for benchmark_resolution in benchmark_resolutions if benchmark_resolution in facefusion.choices.benchmark_set]
|
||||
target_paths = [ facefusion.choices.benchmark_set.get(benchmark_resolution) for benchmark_resolution in benchmark_resolutions if benchmark_resolution in facefusion.choices.benchmark_set ]
|
||||
|
||||
for target_path in target_paths:
|
||||
state_manager.set_item('target_path', target_path)
|
||||
state_manager.set_item('output_path', suggest_output_path(state_manager.get_item('target_path')))
|
||||
state_manager.init_item('target_path', target_path)
|
||||
state_manager.init_item('output_path', suggest_output_path(state_manager.get_item('target_path')))
|
||||
benchmarks.append(cycle(benchmark_cycle_count))
|
||||
yield benchmarks
|
||||
|
||||
@@ -54,13 +55,17 @@ def run() -> Generator[List[BenchmarkCycleSet], None, None]:
|
||||
def cycle(cycle_count : int) -> BenchmarkCycleSet:
|
||||
process_times = []
|
||||
video_frame_total = count_video_frame_total(state_manager.get_item('target_path'))
|
||||
output_video_resolution = detect_video_resolution(state_manager.get_item('target_path'))
|
||||
state_manager.set_item('output_video_resolution', pack_resolution(output_video_resolution))
|
||||
state_manager.set_item('output_video_fps', detect_video_fps(state_manager.get_item('target_path')))
|
||||
state_manager.init_item('output_video_fps', detect_video_fps(state_manager.get_item('target_path')))
|
||||
|
||||
core.conditional_process()
|
||||
if state_manager.get_item('benchmark_mode') == 'warm':
|
||||
core.conditional_process()
|
||||
|
||||
for index in range(cycle_count):
|
||||
if state_manager.get_item('benchmark_mode') == 'cold':
|
||||
content_analyser.analyse_image.cache_clear()
|
||||
content_analyser.analyse_video.cache_clear()
|
||||
clear_static_faces()
|
||||
|
||||
start_time = perf_counter()
|
||||
core.conditional_process()
|
||||
end_time = perf_counter()
|
||||
|
||||
@@ -0,0 +1,53 @@
|
||||
from typing import List
|
||||
|
||||
import cv2
|
||||
|
||||
from facefusion.types import CameraPoolSet
|
||||
|
||||
CAMERA_POOL_SET : CameraPoolSet =\
|
||||
{
|
||||
'capture': {}
|
||||
}
|
||||
|
||||
|
||||
def get_local_camera_capture(camera_id : int) -> cv2.VideoCapture:
|
||||
camera_key = str(camera_id)
|
||||
|
||||
if camera_key not in CAMERA_POOL_SET.get('capture'):
|
||||
camera_capture = cv2.VideoCapture(camera_id)
|
||||
|
||||
if camera_capture.isOpened():
|
||||
CAMERA_POOL_SET['capture'][camera_key] = camera_capture
|
||||
|
||||
return CAMERA_POOL_SET.get('capture').get(camera_key)
|
||||
|
||||
|
||||
def get_remote_camera_capture(camera_url : str) -> cv2.VideoCapture:
|
||||
if camera_url not in CAMERA_POOL_SET.get('capture'):
|
||||
camera_capture = cv2.VideoCapture(camera_url)
|
||||
|
||||
if camera_capture.isOpened():
|
||||
CAMERA_POOL_SET['capture'][camera_url] = camera_capture
|
||||
|
||||
return CAMERA_POOL_SET.get('capture').get(camera_url)
|
||||
|
||||
|
||||
def clear_camera_pool() -> None:
|
||||
for camera_capture in CAMERA_POOL_SET.get('capture').values():
|
||||
camera_capture.release()
|
||||
|
||||
CAMERA_POOL_SET['capture'].clear()
|
||||
|
||||
|
||||
def detect_local_camera_ids(id_start : int, id_end : int) -> List[int]:
|
||||
local_camera_ids = []
|
||||
|
||||
for camera_id in range(id_start, id_end):
|
||||
cv2.setLogLevel(0)
|
||||
camera_capture = get_local_camera_capture(camera_id)
|
||||
cv2.setLogLevel(3)
|
||||
|
||||
if camera_capture and camera_capture.isOpened():
|
||||
local_camera_ids.append(camera_id)
|
||||
|
||||
return local_camera_ids
|
||||
+16
-12
@@ -2,14 +2,15 @@ import logging
|
||||
from typing import List, Sequence
|
||||
|
||||
from facefusion.common_helper import create_float_range, create_int_range
|
||||
from facefusion.types import Angle, AudioEncoder, AudioFormat, AudioTypeSet, BenchmarkResolution, BenchmarkSet, DownloadProvider, DownloadProviderSet, DownloadScope, EncoderSet, ExecutionProvider, ExecutionProviderSet, FaceDetectorModel, FaceDetectorSet, FaceLandmarkerModel, FaceMaskArea, FaceMaskAreaSet, FaceMaskRegion, FaceMaskRegionSet, FaceMaskType, FaceOccluderModel, FaceParserModel, FaceSelectorMode, FaceSelectorOrder, Gender, ImageFormat, ImageTypeSet, JobStatus, LogLevel, LogLevelSet, Race, Score, TempFrameFormat, UiWorkflow, VideoEncoder, VideoFormat, VideoMemoryStrategy, VideoPreset, VideoTypeSet, WebcamMode
|
||||
from facefusion.types import Angle, AudioEncoder, AudioFormat, AudioTypeSet, BenchmarkMode, BenchmarkResolution, BenchmarkSet, DownloadProvider, DownloadProviderSet, DownloadScope, EncoderSet, ExecutionProvider, ExecutionProviderSet, FaceDetectorModel, FaceDetectorSet, FaceLandmarkerModel, FaceMaskArea, FaceMaskAreaSet, FaceMaskRegion, FaceMaskRegionSet, FaceMaskType, FaceOccluderModel, FaceParserModel, FaceSelectorMode, FaceSelectorOrder, Gender, ImageFormat, ImageTypeSet, JobStatus, LogLevel, LogLevelSet, Race, Score, TempFrameFormat, UiWorkflow, VideoEncoder, VideoFormat, VideoMemoryStrategy, VideoPreset, VideoTypeSet, VoiceExtractorModel
|
||||
|
||||
face_detector_set : FaceDetectorSet =\
|
||||
{
|
||||
'many': [ '640x640' ],
|
||||
'retinaface': [ '160x160', '320x320', '480x480', '512x512', '640x640' ],
|
||||
'scrfd': [ '160x160', '320x320', '480x480', '512x512', '640x640' ],
|
||||
'yolo_face': [ '640x640' ]
|
||||
'yolo_face': [ '640x640' ],
|
||||
'yunet': [ '640x640' ]
|
||||
}
|
||||
face_detector_models : List[FaceDetectorModel] = list(face_detector_set.keys())
|
||||
face_landmarker_models : List[FaceLandmarkerModel] = [ 'many', '2dfan4', 'peppa_wutz' ]
|
||||
@@ -17,7 +18,7 @@ face_selector_modes : List[FaceSelectorMode] = [ 'many', 'one', 'reference' ]
|
||||
face_selector_orders : List[FaceSelectorOrder] = [ 'left-right', 'right-left', 'top-bottom', 'bottom-top', 'small-large', 'large-small', 'best-worst', 'worst-best' ]
|
||||
face_selector_genders : List[Gender] = [ 'female', 'male' ]
|
||||
face_selector_races : List[Race] = [ 'white', 'black', 'latino', 'asian', 'indian', 'arabic' ]
|
||||
face_occluder_models : List[FaceOccluderModel] = [ 'xseg_1', 'xseg_2', 'xseg_3' ]
|
||||
face_occluder_models : List[FaceOccluderModel] = [ 'many', 'xseg_1', 'xseg_2', 'xseg_3' ]
|
||||
face_parser_models : List[FaceParserModel] = [ 'bisenet_resnet_18', 'bisenet_resnet_34' ]
|
||||
face_mask_types : List[FaceMaskType] = [ 'box', 'occlusion', 'area', 'region' ]
|
||||
face_mask_area_set : FaceMaskAreaSet =\
|
||||
@@ -42,6 +43,8 @@ face_mask_region_set : FaceMaskRegionSet =\
|
||||
face_mask_areas : List[FaceMaskArea] = list(face_mask_area_set.keys())
|
||||
face_mask_regions : List[FaceMaskRegion] = list(face_mask_region_set.keys())
|
||||
|
||||
voice_extractor_models : List[VoiceExtractorModel] = [ 'kim_vocal_1', 'kim_vocal_2', 'uvr_mdxnet' ]
|
||||
|
||||
audio_type_set : AudioTypeSet =\
|
||||
{
|
||||
'flac': 'audio/flac',
|
||||
@@ -65,8 +68,11 @@ video_type_set : VideoTypeSet =\
|
||||
'm4v': 'video/mp4',
|
||||
'mkv': 'video/x-matroska',
|
||||
'mp4': 'video/mp4',
|
||||
'mpeg': 'video/mpeg',
|
||||
'mov': 'video/quicktime',
|
||||
'webm': 'video/webm'
|
||||
'mxf': 'application/mxf',
|
||||
'webm': 'video/webm',
|
||||
'wmv': 'video/x-ms-wmv'
|
||||
}
|
||||
audio_formats : List[AudioFormat] = list(audio_type_set.keys())
|
||||
image_formats : List[ImageFormat] = list(image_type_set.keys())
|
||||
@@ -76,15 +82,13 @@ temp_frame_formats : List[TempFrameFormat] = [ 'bmp', 'jpeg', 'png', 'tiff' ]
|
||||
output_encoder_set : EncoderSet =\
|
||||
{
|
||||
'audio': [ 'flac', 'aac', 'libmp3lame', 'libopus', 'libvorbis', 'pcm_s16le', 'pcm_s32le' ],
|
||||
'video': [ 'libx264', 'libx265', 'libvpx-vp9', 'h264_nvenc', 'hevc_nvenc', 'h264_amf', 'hevc_amf', 'h264_qsv', 'hevc_qsv', 'h264_videotoolbox', 'hevc_videotoolbox', 'rawvideo' ]
|
||||
'video': [ 'libx264', 'libx264rgb', 'libx265', 'libvpx-vp9', 'h264_nvenc', 'hevc_nvenc', 'h264_amf', 'hevc_amf', 'h264_qsv', 'hevc_qsv', 'h264_videotoolbox', 'hevc_videotoolbox', 'rawvideo' ]
|
||||
}
|
||||
output_audio_encoders : List[AudioEncoder] = output_encoder_set.get('audio')
|
||||
output_video_encoders : List[VideoEncoder] = output_encoder_set.get('video')
|
||||
output_video_presets : List[VideoPreset] = [ 'ultrafast', 'superfast', 'veryfast', 'faster', 'fast', 'medium', 'slow', 'slower', 'veryslow' ]
|
||||
|
||||
image_template_sizes : List[float] = [ 0.25, 0.5, 0.75, 1, 1.5, 2, 2.5, 3, 3.5, 4 ]
|
||||
video_template_sizes : List[int] = [ 240, 360, 480, 540, 720, 1080, 1440, 2160, 4320 ]
|
||||
|
||||
benchmark_modes : List[BenchmarkMode] = [ 'warm', 'cold' ]
|
||||
benchmark_set : BenchmarkSet =\
|
||||
{
|
||||
'240p': '.assets/examples/target-240p.mp4',
|
||||
@@ -97,15 +101,13 @@ benchmark_set : BenchmarkSet =\
|
||||
}
|
||||
benchmark_resolutions : List[BenchmarkResolution] = list(benchmark_set.keys())
|
||||
|
||||
webcam_modes : List[WebcamMode] = [ 'inline', 'udp', 'v4l2' ]
|
||||
webcam_resolutions : List[str] = [ '320x240', '640x480', '800x600', '1024x768', '1280x720', '1280x960', '1920x1080', '2560x1440', '3840x2160' ]
|
||||
|
||||
execution_provider_set : ExecutionProviderSet =\
|
||||
{
|
||||
'cuda': 'CUDAExecutionProvider',
|
||||
'tensorrt': 'TensorrtExecutionProvider',
|
||||
'directml': 'DmlExecutionProvider',
|
||||
'rocm': 'ROCMExecutionProvider',
|
||||
'migraphx': 'MIGraphXExecutionProvider',
|
||||
'openvino': 'OpenVINOExecutionProvider',
|
||||
'coreml': 'CoreMLExecutionProvider',
|
||||
'cpu': 'CPUExecutionProvider'
|
||||
@@ -150,8 +152,8 @@ job_statuses : List[JobStatus] = [ 'drafted', 'queued', 'completed', 'failed' ]
|
||||
|
||||
benchmark_cycle_count_range : Sequence[int] = create_int_range(1, 10, 1)
|
||||
execution_thread_count_range : Sequence[int] = create_int_range(1, 32, 1)
|
||||
execution_queue_count_range : Sequence[int] = create_int_range(1, 4, 1)
|
||||
system_memory_limit_range : Sequence[int] = create_int_range(0, 128, 4)
|
||||
face_detector_margin_range : Sequence[int] = create_int_range(0, 100, 1)
|
||||
face_detector_angles : Sequence[Angle] = create_int_range(0, 270, 90)
|
||||
face_detector_score_range : Sequence[Score] = create_float_range(0.0, 1.0, 0.05)
|
||||
face_landmarker_score_range : Sequence[Score] = create_float_range(0.0, 1.0, 0.05)
|
||||
@@ -160,6 +162,8 @@ face_mask_padding_range : Sequence[int] = create_int_range(0, 100, 1)
|
||||
face_selector_age_range : Sequence[int] = create_int_range(0, 100, 1)
|
||||
reference_face_distance_range : Sequence[float] = create_float_range(0.0, 1.0, 0.05)
|
||||
output_image_quality_range : Sequence[int] = create_int_range(0, 100, 1)
|
||||
output_image_scale_range : Sequence[float] = create_float_range(0.25, 8.0, 0.25)
|
||||
output_audio_quality_range : Sequence[int] = create_int_range(0, 100, 1)
|
||||
output_audio_volume_range : Sequence[int] = create_int_range(0, 100, 1)
|
||||
output_video_quality_range : Sequence[int] = create_int_range(0, 100, 1)
|
||||
output_video_scale_range : Sequence[float] = create_float_range(0.25, 8.0, 0.25)
|
||||
|
||||
@@ -1,10 +1,10 @@
|
||||
from typing import Tuple
|
||||
from typing import List, Tuple
|
||||
|
||||
from facefusion.logger import get_package_logger
|
||||
from facefusion.types import TableContents, TableHeaders
|
||||
from facefusion.types import TableContent, TableHeader
|
||||
|
||||
|
||||
def render_table(headers : TableHeaders, contents : TableContents) -> None:
|
||||
def render_table(headers : List[TableHeader], contents : List[List[TableContent]]) -> None:
|
||||
package_logger = get_package_logger()
|
||||
table_column, table_separator = create_table_parts(headers, contents)
|
||||
|
||||
@@ -19,7 +19,7 @@ def render_table(headers : TableHeaders, contents : TableContents) -> None:
|
||||
package_logger.critical(table_separator)
|
||||
|
||||
|
||||
def create_table_parts(headers : TableHeaders, contents : TableContents) -> Tuple[str, str]:
|
||||
def create_table_parts(headers : List[TableHeader], contents : List[List[TableContent]]) -> Tuple[str, str]:
|
||||
column_parts = []
|
||||
separator_parts = []
|
||||
widths = [ len(header) for header in headers ]
|
||||
|
||||
@@ -15,11 +15,11 @@ def is_windows() -> bool:
|
||||
|
||||
|
||||
def create_int_metavar(int_range : Sequence[int]) -> str:
|
||||
return '[' + str(int_range[0]) + '..' + str(int_range[-1]) + ':' + str(calc_int_step(int_range)) + ']'
|
||||
return '[' + str(int_range[0]) + '..' + str(int_range[-1]) + ':' + str(calculate_int_step(int_range)) + ']'
|
||||
|
||||
|
||||
def create_float_metavar(float_range : Sequence[float]) -> str:
|
||||
return '[' + str(float_range[0]) + '..' + str(float_range[-1]) + ':' + str(calc_float_step(float_range)) + ']'
|
||||
return '[' + str(float_range[0]) + '..' + str(float_range[-1]) + ':' + str(calculate_float_step(float_range)) + ']'
|
||||
|
||||
|
||||
def create_int_range(start : int, end : int, step : int) -> Sequence[int]:
|
||||
@@ -42,11 +42,11 @@ def create_float_range(start : float, end : float, step : float) -> Sequence[flo
|
||||
return float_range
|
||||
|
||||
|
||||
def calc_int_step(int_range : Sequence[int]) -> int:
|
||||
def calculate_int_step(int_range : Sequence[int]) -> int:
|
||||
return int_range[1] - int_range[0]
|
||||
|
||||
|
||||
def calc_float_step(float_range : Sequence[float]) -> float:
|
||||
def calculate_float_step(float_range : Sequence[float]) -> float:
|
||||
return round(float_range[1] - float_range[0], 2)
|
||||
|
||||
|
||||
|
||||
@@ -4,23 +4,30 @@ from typing import List, Tuple
|
||||
import numpy
|
||||
from tqdm import tqdm
|
||||
|
||||
from facefusion import inference_manager, state_manager, wording
|
||||
from facefusion import inference_manager, state_manager, translator
|
||||
from facefusion.common_helper import is_macos
|
||||
from facefusion.download import conditional_download_hashes, conditional_download_sources, resolve_download_url
|
||||
from facefusion.execution import has_execution_provider
|
||||
from facefusion.filesystem import resolve_relative_path
|
||||
from facefusion.thread_helper import conditional_thread_semaphore
|
||||
from facefusion.types import Detection, DownloadScope, DownloadSet, ExecutionProvider, Fps, InferencePool, ModelSet, VisionFrame
|
||||
from facefusion.vision import detect_video_fps, fit_frame, read_image, read_video_frame
|
||||
from facefusion.vision import detect_video_fps, fit_contain_frame, read_image, read_video_frame
|
||||
|
||||
STREAM_COUNTER = 0
|
||||
|
||||
|
||||
@lru_cache(maxsize = None)
|
||||
@lru_cache()
|
||||
def create_static_model_set(download_scope : DownloadScope) -> ModelSet:
|
||||
return\
|
||||
{
|
||||
'nsfw_1':
|
||||
{
|
||||
'__metadata__':
|
||||
{
|
||||
'vendor': 'EraX',
|
||||
'license': 'Apache-2.0',
|
||||
'year': 2024
|
||||
},
|
||||
'hashes':
|
||||
{
|
||||
'content_analyser':
|
||||
@@ -43,6 +50,12 @@ def create_static_model_set(download_scope : DownloadScope) -> ModelSet:
|
||||
},
|
||||
'nsfw_2':
|
||||
{
|
||||
'__metadata__':
|
||||
{
|
||||
'vendor': 'Marqo',
|
||||
'license': 'Apache-2.0',
|
||||
'year': 2024
|
||||
},
|
||||
'hashes':
|
||||
{
|
||||
'content_analyser':
|
||||
@@ -65,6 +78,12 @@ def create_static_model_set(download_scope : DownloadScope) -> ModelSet:
|
||||
},
|
||||
'nsfw_3':
|
||||
{
|
||||
'__metadata__':
|
||||
{
|
||||
'vendor': 'Freepik',
|
||||
'license': 'MIT',
|
||||
'year': 2025
|
||||
},
|
||||
'hashes':
|
||||
{
|
||||
'content_analyser':
|
||||
@@ -101,7 +120,7 @@ def clear_inference_pool() -> None:
|
||||
|
||||
|
||||
def resolve_execution_providers() -> List[ExecutionProvider]:
|
||||
if has_execution_provider('coreml'):
|
||||
if is_macos() and has_execution_provider('coreml'):
|
||||
return [ 'cpu' ]
|
||||
return state_manager.get_item('execution_providers')
|
||||
|
||||
@@ -137,13 +156,13 @@ def analyse_frame(vision_frame : VisionFrame) -> bool:
|
||||
return detect_nsfw(vision_frame)
|
||||
|
||||
|
||||
@lru_cache(maxsize = None)
|
||||
@lru_cache()
|
||||
def analyse_image(image_path : str) -> bool:
|
||||
vision_frame = read_image(image_path)
|
||||
return analyse_frame(vision_frame)
|
||||
|
||||
|
||||
@lru_cache(maxsize = None)
|
||||
@lru_cache()
|
||||
def analyse_video(video_path : str, trim_frame_start : int, trim_frame_end : int) -> bool:
|
||||
video_fps = detect_video_fps(video_path)
|
||||
frame_range = range(trim_frame_start, trim_frame_end)
|
||||
@@ -151,16 +170,19 @@ def analyse_video(video_path : str, trim_frame_start : int, trim_frame_end : int
|
||||
total = 0
|
||||
counter = 0
|
||||
|
||||
with tqdm(total = len(frame_range), desc = wording.get('analysing'), unit = 'frame', ascii = ' =', disable = state_manager.get_item('log_level') in [ 'warn', 'error' ]) as progress:
|
||||
with tqdm(total = len(frame_range), desc = translator.get('analysing'), unit = 'frame', ascii = ' =', disable = state_manager.get_item('log_level') in [ 'warn', 'error' ]) as progress:
|
||||
|
||||
for frame_number in frame_range:
|
||||
if frame_number % int(video_fps) == 0:
|
||||
vision_frame = read_video_frame(video_path, frame_number)
|
||||
total += 1
|
||||
|
||||
if analyse_frame(vision_frame):
|
||||
counter += 1
|
||||
|
||||
if counter > 0 and total > 0:
|
||||
rate = counter / total * 100
|
||||
|
||||
progress.set_postfix(rate = rate)
|
||||
progress.update()
|
||||
|
||||
@@ -196,8 +218,8 @@ def detect_with_nsfw_3(vision_frame : VisionFrame) -> bool:
|
||||
return bool(detection_score > 10.5)
|
||||
|
||||
|
||||
def forward_nsfw(vision_frame : VisionFrame, nsfw_model : str) -> Detection:
|
||||
content_analyser = get_inference_pool().get(nsfw_model)
|
||||
def forward_nsfw(vision_frame : VisionFrame, model_name : str) -> Detection:
|
||||
content_analyser = get_inference_pool().get(model_name)
|
||||
|
||||
with conditional_thread_semaphore():
|
||||
detection = content_analyser.run(None,
|
||||
@@ -205,7 +227,7 @@ def forward_nsfw(vision_frame : VisionFrame, nsfw_model : str) -> Detection:
|
||||
'input': vision_frame
|
||||
})[0]
|
||||
|
||||
if nsfw_model in [ 'nsfw_2', 'nsfw_3' ]:
|
||||
if model_name in [ 'nsfw_2', 'nsfw_3' ]:
|
||||
return detection[0]
|
||||
|
||||
return detection
|
||||
@@ -217,7 +239,7 @@ def prepare_detect_frame(temp_vision_frame : VisionFrame, model_name : str) -> V
|
||||
model_mean = model_set.get('mean')
|
||||
model_standard_deviation = model_set.get('standard_deviation')
|
||||
|
||||
detect_vision_frame = fit_frame(temp_vision_frame, model_size)
|
||||
detect_vision_frame = fit_contain_frame(temp_vision_frame, model_size)
|
||||
detect_vision_frame = detect_vision_frame[:, :, ::-1] / 255.0
|
||||
detect_vision_frame -= model_mean
|
||||
detect_vision_frame /= model_standard_deviation
|
||||
|
||||
+61
-228
@@ -5,28 +5,19 @@ import signal
|
||||
import sys
|
||||
from time import time
|
||||
|
||||
import numpy
|
||||
|
||||
from facefusion import benchmarker, cli_helper, content_analyser, face_classifier, face_detector, face_landmarker, face_masker, face_recognizer, hash_helper, logger, process_manager, state_manager, video_manager, voice_extractor, wording
|
||||
from facefusion import benchmarker, cli_helper, content_analyser, face_classifier, face_detector, face_landmarker, face_masker, face_recognizer, hash_helper, logger, state_manager, translator, voice_extractor
|
||||
from facefusion.args import apply_args, collect_job_args, reduce_job_args, reduce_step_args
|
||||
from facefusion.common_helper import get_first
|
||||
from facefusion.content_analyser import analyse_image, analyse_video
|
||||
from facefusion.download import conditional_download_hashes, conditional_download_sources
|
||||
from facefusion.exit_helper import hard_exit, signal_exit
|
||||
from facefusion.face_analyser import get_average_face, get_many_faces, get_one_face
|
||||
from facefusion.face_selector import sort_and_filter_faces
|
||||
from facefusion.face_store import append_reference_face, clear_reference_faces, get_reference_faces
|
||||
from facefusion.ffmpeg import copy_image, extract_frames, finalize_image, merge_video, replace_audio, restore_audio
|
||||
from facefusion.filesystem import filter_audio_paths, get_file_name, is_image, is_video, resolve_file_paths, resolve_file_pattern
|
||||
from facefusion.filesystem import get_file_extension, get_file_name, is_image, is_video, resolve_file_paths, resolve_file_pattern
|
||||
from facefusion.jobs import job_helper, job_manager, job_runner
|
||||
from facefusion.jobs.job_list import compose_job_list
|
||||
from facefusion.memory import limit_system_memory
|
||||
from facefusion.processors.core import get_processors_modules
|
||||
from facefusion.program import create_program
|
||||
from facefusion.program_helper import validate_args
|
||||
from facefusion.temp_helper import clear_temp_directory, create_temp_directory, get_temp_file_path, move_temp_file, resolve_temp_frame_paths
|
||||
from facefusion.types import Args, ErrorCode
|
||||
from facefusion.vision import pack_resolution, read_image, read_static_images, read_video_frame, restrict_image_resolution, restrict_trim_frame, restrict_video_fps, restrict_video_resolution, unpack_resolution
|
||||
from facefusion.workflows import image_to_image, image_to_video
|
||||
|
||||
|
||||
def cli() -> None:
|
||||
@@ -57,11 +48,11 @@ def route(args : Args) -> None:
|
||||
|
||||
if state_manager.get_item('command') == 'force-download':
|
||||
error_code = force_download()
|
||||
return hard_exit(error_code)
|
||||
hard_exit(error_code)
|
||||
|
||||
if state_manager.get_item('command') == 'benchmark':
|
||||
if not common_pre_check() or not processors_pre_check() or not benchmarker.pre_check():
|
||||
return hard_exit(2)
|
||||
hard_exit(2)
|
||||
benchmarker.render()
|
||||
|
||||
if state_manager.get_item('command') in [ 'job-list', 'job-create', 'job-submit', 'job-submit-all', 'job-delete', 'job-delete-all', 'job-add-step', 'job-remix-step', 'job-insert-step', 'job-remove-step' ]:
|
||||
@@ -74,24 +65,24 @@ def route(args : Args) -> None:
|
||||
import facefusion.uis.core as ui
|
||||
|
||||
if not common_pre_check() or not processors_pre_check():
|
||||
return hard_exit(2)
|
||||
hard_exit(2)
|
||||
for ui_layout in ui.get_ui_layouts_modules(state_manager.get_item('ui_layouts')):
|
||||
if not ui_layout.pre_check():
|
||||
return hard_exit(2)
|
||||
hard_exit(2)
|
||||
ui.init()
|
||||
ui.launch()
|
||||
|
||||
if state_manager.get_item('command') == 'headless-run':
|
||||
if not job_manager.init_jobs(state_manager.get_item('jobs_path')):
|
||||
hard_exit(1)
|
||||
error_core = process_headless(args)
|
||||
hard_exit(error_core)
|
||||
error_code = process_headless(args)
|
||||
hard_exit(error_code)
|
||||
|
||||
if state_manager.get_item('command') == 'batch-run':
|
||||
if not job_manager.init_jobs(state_manager.get_item('jobs_path')):
|
||||
hard_exit(1)
|
||||
error_core = process_batch(args)
|
||||
hard_exit(error_core)
|
||||
error_code = process_batch(args)
|
||||
hard_exit(error_code)
|
||||
|
||||
if state_manager.get_item('command') in [ 'job-run', 'job-run-all', 'job-retry', 'job-retry-all' ]:
|
||||
if not job_manager.init_jobs(state_manager.get_item('jobs_path')):
|
||||
@@ -102,15 +93,15 @@ def route(args : Args) -> None:
|
||||
|
||||
def pre_check() -> bool:
|
||||
if sys.version_info < (3, 10):
|
||||
logger.error(wording.get('python_not_supported').format(version = '3.10'), __name__)
|
||||
logger.error(translator.get('python_not_supported').format(version = '3.10'), __name__)
|
||||
return False
|
||||
|
||||
if not shutil.which('curl'):
|
||||
logger.error(wording.get('curl_not_installed'), __name__)
|
||||
logger.error(translator.get('curl_not_installed'), __name__)
|
||||
return False
|
||||
|
||||
if not shutil.which('ffmpeg'):
|
||||
logger.error(wording.get('ffmpeg_not_installed'), __name__)
|
||||
logger.error(translator.get('ffmpeg_not_installed'), __name__)
|
||||
return False
|
||||
return True
|
||||
|
||||
@@ -128,9 +119,9 @@ def common_pre_check() -> bool:
|
||||
]
|
||||
|
||||
content_analyser_content = inspect.getsource(content_analyser).encode()
|
||||
is_valid = hash_helper.create_hash(content_analyser_content) == 'b159fd9d'
|
||||
content_analyser_hash = hash_helper.create_hash(content_analyser_content)
|
||||
|
||||
return all(module.pre_check() for module in common_modules) and is_valid
|
||||
return all(module.pre_check() for module in common_modules) and content_analyser_hash == 'b14e7b92'
|
||||
|
||||
|
||||
def processors_pre_check() -> bool:
|
||||
@@ -178,106 +169,106 @@ def route_job_manager(args : Args) -> ErrorCode:
|
||||
|
||||
if state_manager.get_item('command') == 'job-create':
|
||||
if job_manager.create_job(state_manager.get_item('job_id')):
|
||||
logger.info(wording.get('job_created').format(job_id = state_manager.get_item('job_id')), __name__)
|
||||
logger.info(translator.get('job_created').format(job_id = state_manager.get_item('job_id')), __name__)
|
||||
return 0
|
||||
logger.error(wording.get('job_not_created').format(job_id = state_manager.get_item('job_id')), __name__)
|
||||
logger.error(translator.get('job_not_created').format(job_id = state_manager.get_item('job_id')), __name__)
|
||||
return 1
|
||||
|
||||
if state_manager.get_item('command') == 'job-submit':
|
||||
if job_manager.submit_job(state_manager.get_item('job_id')):
|
||||
logger.info(wording.get('job_submitted').format(job_id = state_manager.get_item('job_id')), __name__)
|
||||
logger.info(translator.get('job_submitted').format(job_id = state_manager.get_item('job_id')), __name__)
|
||||
return 0
|
||||
logger.error(wording.get('job_not_submitted').format(job_id = state_manager.get_item('job_id')), __name__)
|
||||
logger.error(translator.get('job_not_submitted').format(job_id = state_manager.get_item('job_id')), __name__)
|
||||
return 1
|
||||
|
||||
if state_manager.get_item('command') == 'job-submit-all':
|
||||
if job_manager.submit_jobs(state_manager.get_item('halt_on_error')):
|
||||
logger.info(wording.get('job_all_submitted'), __name__)
|
||||
logger.info(translator.get('job_all_submitted'), __name__)
|
||||
return 0
|
||||
logger.error(wording.get('job_all_not_submitted'), __name__)
|
||||
logger.error(translator.get('job_all_not_submitted'), __name__)
|
||||
return 1
|
||||
|
||||
if state_manager.get_item('command') == 'job-delete':
|
||||
if job_manager.delete_job(state_manager.get_item('job_id')):
|
||||
logger.info(wording.get('job_deleted').format(job_id = state_manager.get_item('job_id')), __name__)
|
||||
logger.info(translator.get('job_deleted').format(job_id = state_manager.get_item('job_id')), __name__)
|
||||
return 0
|
||||
logger.error(wording.get('job_not_deleted').format(job_id = state_manager.get_item('job_id')), __name__)
|
||||
logger.error(translator.get('job_not_deleted').format(job_id = state_manager.get_item('job_id')), __name__)
|
||||
return 1
|
||||
|
||||
if state_manager.get_item('command') == 'job-delete-all':
|
||||
if job_manager.delete_jobs(state_manager.get_item('halt_on_error')):
|
||||
logger.info(wording.get('job_all_deleted'), __name__)
|
||||
logger.info(translator.get('job_all_deleted'), __name__)
|
||||
return 0
|
||||
logger.error(wording.get('job_all_not_deleted'), __name__)
|
||||
logger.error(translator.get('job_all_not_deleted'), __name__)
|
||||
return 1
|
||||
|
||||
if state_manager.get_item('command') == 'job-add-step':
|
||||
step_args = reduce_step_args(args)
|
||||
|
||||
if job_manager.add_step(state_manager.get_item('job_id'), step_args):
|
||||
logger.info(wording.get('job_step_added').format(job_id = state_manager.get_item('job_id')), __name__)
|
||||
logger.info(translator.get('job_step_added').format(job_id = state_manager.get_item('job_id')), __name__)
|
||||
return 0
|
||||
logger.error(wording.get('job_step_not_added').format(job_id = state_manager.get_item('job_id')), __name__)
|
||||
logger.error(translator.get('job_step_not_added').format(job_id = state_manager.get_item('job_id')), __name__)
|
||||
return 1
|
||||
|
||||
if state_manager.get_item('command') == 'job-remix-step':
|
||||
step_args = reduce_step_args(args)
|
||||
|
||||
if job_manager.remix_step(state_manager.get_item('job_id'), state_manager.get_item('step_index'), step_args):
|
||||
logger.info(wording.get('job_remix_step_added').format(job_id = state_manager.get_item('job_id'), step_index = state_manager.get_item('step_index')), __name__)
|
||||
logger.info(translator.get('job_remix_step_added').format(job_id = state_manager.get_item('job_id'), step_index = state_manager.get_item('step_index')), __name__)
|
||||
return 0
|
||||
logger.error(wording.get('job_remix_step_not_added').format(job_id = state_manager.get_item('job_id'), step_index = state_manager.get_item('step_index')), __name__)
|
||||
logger.error(translator.get('job_remix_step_not_added').format(job_id = state_manager.get_item('job_id'), step_index = state_manager.get_item('step_index')), __name__)
|
||||
return 1
|
||||
|
||||
if state_manager.get_item('command') == 'job-insert-step':
|
||||
step_args = reduce_step_args(args)
|
||||
|
||||
if job_manager.insert_step(state_manager.get_item('job_id'), state_manager.get_item('step_index'), step_args):
|
||||
logger.info(wording.get('job_step_inserted').format(job_id = state_manager.get_item('job_id'), step_index = state_manager.get_item('step_index')), __name__)
|
||||
logger.info(translator.get('job_step_inserted').format(job_id = state_manager.get_item('job_id'), step_index = state_manager.get_item('step_index')), __name__)
|
||||
return 0
|
||||
logger.error(wording.get('job_step_not_inserted').format(job_id = state_manager.get_item('job_id'), step_index = state_manager.get_item('step_index')), __name__)
|
||||
logger.error(translator.get('job_step_not_inserted').format(job_id = state_manager.get_item('job_id'), step_index = state_manager.get_item('step_index')), __name__)
|
||||
return 1
|
||||
|
||||
if state_manager.get_item('command') == 'job-remove-step':
|
||||
if job_manager.remove_step(state_manager.get_item('job_id'), state_manager.get_item('step_index')):
|
||||
logger.info(wording.get('job_step_removed').format(job_id = state_manager.get_item('job_id'), step_index = state_manager.get_item('step_index')), __name__)
|
||||
logger.info(translator.get('job_step_removed').format(job_id = state_manager.get_item('job_id'), step_index = state_manager.get_item('step_index')), __name__)
|
||||
return 0
|
||||
logger.error(wording.get('job_step_not_removed').format(job_id = state_manager.get_item('job_id'), step_index = state_manager.get_item('step_index')), __name__)
|
||||
logger.error(translator.get('job_step_not_removed').format(job_id = state_manager.get_item('job_id'), step_index = state_manager.get_item('step_index')), __name__)
|
||||
return 1
|
||||
return 1
|
||||
|
||||
|
||||
def route_job_runner() -> ErrorCode:
|
||||
if state_manager.get_item('command') == 'job-run':
|
||||
logger.info(wording.get('running_job').format(job_id = state_manager.get_item('job_id')), __name__)
|
||||
logger.info(translator.get('running_job').format(job_id = state_manager.get_item('job_id')), __name__)
|
||||
if job_runner.run_job(state_manager.get_item('job_id'), process_step):
|
||||
logger.info(wording.get('processing_job_succeed').format(job_id = state_manager.get_item('job_id')), __name__)
|
||||
logger.info(translator.get('processing_job_succeeded').format(job_id = state_manager.get_item('job_id')), __name__)
|
||||
return 0
|
||||
logger.info(wording.get('processing_job_failed').format(job_id = state_manager.get_item('job_id')), __name__)
|
||||
logger.info(translator.get('processing_job_failed').format(job_id = state_manager.get_item('job_id')), __name__)
|
||||
return 1
|
||||
|
||||
if state_manager.get_item('command') == 'job-run-all':
|
||||
logger.info(wording.get('running_jobs'), __name__)
|
||||
logger.info(translator.get('running_jobs'), __name__)
|
||||
if job_runner.run_jobs(process_step, state_manager.get_item('halt_on_error')):
|
||||
logger.info(wording.get('processing_jobs_succeed'), __name__)
|
||||
logger.info(translator.get('processing_jobs_succeeded'), __name__)
|
||||
return 0
|
||||
logger.info(wording.get('processing_jobs_failed'), __name__)
|
||||
logger.info(translator.get('processing_jobs_failed'), __name__)
|
||||
return 1
|
||||
|
||||
if state_manager.get_item('command') == 'job-retry':
|
||||
logger.info(wording.get('retrying_job').format(job_id = state_manager.get_item('job_id')), __name__)
|
||||
logger.info(translator.get('retrying_job').format(job_id = state_manager.get_item('job_id')), __name__)
|
||||
if job_runner.retry_job(state_manager.get_item('job_id'), process_step):
|
||||
logger.info(wording.get('processing_job_succeed').format(job_id = state_manager.get_item('job_id')), __name__)
|
||||
logger.info(translator.get('processing_job_succeeded').format(job_id = state_manager.get_item('job_id')), __name__)
|
||||
return 0
|
||||
logger.info(wording.get('processing_job_failed').format(job_id = state_manager.get_item('job_id')), __name__)
|
||||
logger.info(translator.get('processing_job_failed').format(job_id = state_manager.get_item('job_id')), __name__)
|
||||
return 1
|
||||
|
||||
if state_manager.get_item('command') == 'job-retry-all':
|
||||
logger.info(wording.get('retrying_jobs'), __name__)
|
||||
logger.info(translator.get('retrying_jobs'), __name__)
|
||||
if job_runner.retry_jobs(process_step, state_manager.get_item('halt_on_error')):
|
||||
logger.info(wording.get('processing_jobs_succeed'), __name__)
|
||||
logger.info(translator.get('processing_jobs_succeeded'), __name__)
|
||||
return 0
|
||||
logger.info(wording.get('processing_jobs_failed'), __name__)
|
||||
logger.info(translator.get('processing_jobs_failed'), __name__)
|
||||
return 1
|
||||
return 2
|
||||
|
||||
@@ -303,7 +294,12 @@ def process_batch(args : Args) -> ErrorCode:
|
||||
for index, (source_path, target_path) in enumerate(itertools.product(source_paths, target_paths)):
|
||||
step_args['source_paths'] = [ source_path ]
|
||||
step_args['target_path'] = target_path
|
||||
step_args['output_path'] = job_args.get('output_pattern').format(index = index)
|
||||
|
||||
try:
|
||||
step_args['output_path'] = job_args.get('output_pattern').format(index = index, source_name = get_file_name(source_path), target_name = get_file_name(target_path), target_extension = get_file_extension(target_path))
|
||||
except KeyError:
|
||||
return 1
|
||||
|
||||
if not job_manager.add_step(job_id, step_args):
|
||||
return 1
|
||||
if job_manager.submit_job(job_id) and job_runner.run_job(job_id, process_step):
|
||||
@@ -312,7 +308,12 @@ def process_batch(args : Args) -> ErrorCode:
|
||||
if not source_paths and target_paths:
|
||||
for index, target_path in enumerate(target_paths):
|
||||
step_args['target_path'] = target_path
|
||||
step_args['output_path'] = job_args.get('output_pattern').format(index = index)
|
||||
|
||||
try:
|
||||
step_args['output_path'] = job_args.get('output_pattern').format(index = index, target_name = get_file_name(target_path), target_extension = get_file_extension(target_path))
|
||||
except KeyError:
|
||||
return 1
|
||||
|
||||
if not job_manager.add_step(job_id, step_args):
|
||||
return 1
|
||||
if job_manager.submit_job(job_id) and job_runner.run_job(job_id, process_step):
|
||||
@@ -321,12 +322,11 @@ def process_batch(args : Args) -> ErrorCode:
|
||||
|
||||
|
||||
def process_step(job_id : str, step_index : int, step_args : Args) -> bool:
|
||||
clear_reference_faces()
|
||||
step_total = job_manager.count_step_total(job_id)
|
||||
step_args.update(collect_job_args())
|
||||
apply_args(step_args, state_manager.set_item)
|
||||
|
||||
logger.info(wording.get('processing_step').format(step_current = step_index + 1, step_total = step_total), __name__)
|
||||
logger.info(translator.get('processing_step').format(step_current = step_index + 1, step_total = step_total), __name__)
|
||||
if common_pre_check() and processors_pre_check():
|
||||
error_code = conditional_process()
|
||||
return error_code == 0
|
||||
@@ -340,178 +340,11 @@ def conditional_process() -> ErrorCode:
|
||||
if not processor_module.pre_process('output'):
|
||||
return 2
|
||||
|
||||
conditional_append_reference_faces()
|
||||
|
||||
if is_image(state_manager.get_item('target_path')):
|
||||
return process_image(start_time)
|
||||
return image_to_image.process(start_time)
|
||||
if is_video(state_manager.get_item('target_path')):
|
||||
return process_video(start_time)
|
||||
return image_to_video.process(start_time)
|
||||
|
||||
return 0
|
||||
|
||||
|
||||
def conditional_append_reference_faces() -> None:
|
||||
if 'reference' in state_manager.get_item('face_selector_mode') and not get_reference_faces():
|
||||
source_frames = read_static_images(state_manager.get_item('source_paths'))
|
||||
source_faces = get_many_faces(source_frames)
|
||||
source_face = get_average_face(source_faces)
|
||||
if is_video(state_manager.get_item('target_path')):
|
||||
reference_frame = read_video_frame(state_manager.get_item('target_path'), state_manager.get_item('reference_frame_number'))
|
||||
else:
|
||||
reference_frame = read_image(state_manager.get_item('target_path'))
|
||||
reference_faces = sort_and_filter_faces(get_many_faces([ reference_frame ]))
|
||||
reference_face = get_one_face(reference_faces, state_manager.get_item('reference_face_position'))
|
||||
append_reference_face('origin', reference_face)
|
||||
|
||||
if source_face and reference_face:
|
||||
for processor_module in get_processors_modules(state_manager.get_item('processors')):
|
||||
abstract_reference_frame = processor_module.get_reference_frame(source_face, reference_face, reference_frame)
|
||||
if numpy.any(abstract_reference_frame):
|
||||
abstract_reference_faces = sort_and_filter_faces(get_many_faces([ abstract_reference_frame ]))
|
||||
abstract_reference_face = get_one_face(abstract_reference_faces, state_manager.get_item('reference_face_position'))
|
||||
append_reference_face(processor_module.__name__, abstract_reference_face)
|
||||
|
||||
|
||||
def process_image(start_time : float) -> ErrorCode:
|
||||
if analyse_image(state_manager.get_item('target_path')):
|
||||
return 3
|
||||
|
||||
logger.debug(wording.get('clearing_temp'), __name__)
|
||||
clear_temp_directory(state_manager.get_item('target_path'))
|
||||
logger.debug(wording.get('creating_temp'), __name__)
|
||||
create_temp_directory(state_manager.get_item('target_path'))
|
||||
|
||||
process_manager.start()
|
||||
temp_image_resolution = pack_resolution(restrict_image_resolution(state_manager.get_item('target_path'), unpack_resolution(state_manager.get_item('output_image_resolution'))))
|
||||
logger.info(wording.get('copying_image').format(resolution = temp_image_resolution), __name__)
|
||||
if copy_image(state_manager.get_item('target_path'), temp_image_resolution):
|
||||
logger.debug(wording.get('copying_image_succeed'), __name__)
|
||||
else:
|
||||
logger.error(wording.get('copying_image_failed'), __name__)
|
||||
process_manager.end()
|
||||
return 1
|
||||
|
||||
temp_image_path = get_temp_file_path(state_manager.get_item('target_path'))
|
||||
for processor_module in get_processors_modules(state_manager.get_item('processors')):
|
||||
logger.info(wording.get('processing'), processor_module.__name__)
|
||||
processor_module.process_image(state_manager.get_item('source_paths'), temp_image_path, temp_image_path)
|
||||
processor_module.post_process()
|
||||
if is_process_stopping():
|
||||
process_manager.end()
|
||||
return 4
|
||||
|
||||
logger.info(wording.get('finalizing_image').format(resolution = state_manager.get_item('output_image_resolution')), __name__)
|
||||
if finalize_image(state_manager.get_item('target_path'), state_manager.get_item('output_path'), state_manager.get_item('output_image_resolution')):
|
||||
logger.debug(wording.get('finalizing_image_succeed'), __name__)
|
||||
else:
|
||||
logger.warn(wording.get('finalizing_image_skipped'), __name__)
|
||||
|
||||
logger.debug(wording.get('clearing_temp'), __name__)
|
||||
clear_temp_directory(state_manager.get_item('target_path'))
|
||||
|
||||
if is_image(state_manager.get_item('output_path')):
|
||||
seconds = '{:.2f}'.format((time() - start_time) % 60)
|
||||
logger.info(wording.get('processing_image_succeed').format(seconds = seconds), __name__)
|
||||
else:
|
||||
logger.error(wording.get('processing_image_failed'), __name__)
|
||||
process_manager.end()
|
||||
return 1
|
||||
process_manager.end()
|
||||
return 0
|
||||
|
||||
|
||||
def process_video(start_time : float) -> ErrorCode:
|
||||
trim_frame_start, trim_frame_end = restrict_trim_frame(state_manager.get_item('target_path'), state_manager.get_item('trim_frame_start'), state_manager.get_item('trim_frame_end'))
|
||||
if analyse_video(state_manager.get_item('target_path'), trim_frame_start, trim_frame_end):
|
||||
return 3
|
||||
|
||||
logger.debug(wording.get('clearing_temp'), __name__)
|
||||
clear_temp_directory(state_manager.get_item('target_path'))
|
||||
logger.debug(wording.get('creating_temp'), __name__)
|
||||
create_temp_directory(state_manager.get_item('target_path'))
|
||||
|
||||
process_manager.start()
|
||||
temp_video_resolution = pack_resolution(restrict_video_resolution(state_manager.get_item('target_path'), unpack_resolution(state_manager.get_item('output_video_resolution'))))
|
||||
temp_video_fps = restrict_video_fps(state_manager.get_item('target_path'), state_manager.get_item('output_video_fps'))
|
||||
logger.info(wording.get('extracting_frames').format(resolution = temp_video_resolution, fps = temp_video_fps), __name__)
|
||||
if extract_frames(state_manager.get_item('target_path'), temp_video_resolution, temp_video_fps, trim_frame_start, trim_frame_end):
|
||||
logger.debug(wording.get('extracting_frames_succeed'), __name__)
|
||||
else:
|
||||
if is_process_stopping():
|
||||
process_manager.end()
|
||||
return 4
|
||||
logger.error(wording.get('extracting_frames_failed'), __name__)
|
||||
process_manager.end()
|
||||
return 1
|
||||
|
||||
temp_frame_paths = resolve_temp_frame_paths(state_manager.get_item('target_path'))
|
||||
if temp_frame_paths:
|
||||
for processor_module in get_processors_modules(state_manager.get_item('processors')):
|
||||
logger.info(wording.get('processing'), processor_module.__name__)
|
||||
processor_module.process_video(state_manager.get_item('source_paths'), temp_frame_paths)
|
||||
processor_module.post_process()
|
||||
if is_process_stopping():
|
||||
return 4
|
||||
else:
|
||||
logger.error(wording.get('temp_frames_not_found'), __name__)
|
||||
process_manager.end()
|
||||
return 1
|
||||
|
||||
logger.info(wording.get('merging_video').format(resolution = state_manager.get_item('output_video_resolution'), fps = state_manager.get_item('output_video_fps')), __name__)
|
||||
if merge_video(state_manager.get_item('target_path'), temp_video_fps, state_manager.get_item('output_video_resolution'), state_manager.get_item('output_video_fps'), trim_frame_start, trim_frame_end):
|
||||
logger.debug(wording.get('merging_video_succeed'), __name__)
|
||||
else:
|
||||
if is_process_stopping():
|
||||
process_manager.end()
|
||||
return 4
|
||||
logger.error(wording.get('merging_video_failed'), __name__)
|
||||
process_manager.end()
|
||||
return 1
|
||||
|
||||
if state_manager.get_item('output_audio_volume') == 0:
|
||||
logger.info(wording.get('skipping_audio'), __name__)
|
||||
move_temp_file(state_manager.get_item('target_path'), state_manager.get_item('output_path'))
|
||||
else:
|
||||
source_audio_path = get_first(filter_audio_paths(state_manager.get_item('source_paths')))
|
||||
if source_audio_path:
|
||||
if replace_audio(state_manager.get_item('target_path'), source_audio_path, state_manager.get_item('output_path')):
|
||||
video_manager.clear_video_pool()
|
||||
logger.debug(wording.get('replacing_audio_succeed'), __name__)
|
||||
else:
|
||||
video_manager.clear_video_pool()
|
||||
if is_process_stopping():
|
||||
process_manager.end()
|
||||
return 4
|
||||
logger.warn(wording.get('replacing_audio_skipped'), __name__)
|
||||
move_temp_file(state_manager.get_item('target_path'), state_manager.get_item('output_path'))
|
||||
else:
|
||||
if restore_audio(state_manager.get_item('target_path'), state_manager.get_item('output_path'), trim_frame_start, trim_frame_end):
|
||||
video_manager.clear_video_pool()
|
||||
logger.debug(wording.get('restoring_audio_succeed'), __name__)
|
||||
else:
|
||||
video_manager.clear_video_pool()
|
||||
if is_process_stopping():
|
||||
process_manager.end()
|
||||
return 4
|
||||
logger.warn(wording.get('restoring_audio_skipped'), __name__)
|
||||
move_temp_file(state_manager.get_item('target_path'), state_manager.get_item('output_path'))
|
||||
|
||||
logger.debug(wording.get('clearing_temp'), __name__)
|
||||
clear_temp_directory(state_manager.get_item('target_path'))
|
||||
|
||||
if is_video(state_manager.get_item('output_path')):
|
||||
seconds = '{:.2f}'.format((time() - start_time))
|
||||
logger.info(wording.get('processing_video_succeed').format(seconds = seconds), __name__)
|
||||
else:
|
||||
logger.error(wording.get('processing_video_failed'), __name__)
|
||||
process_manager.end()
|
||||
return 1
|
||||
process_manager.end()
|
||||
return 0
|
||||
|
||||
|
||||
def is_process_stopping() -> bool:
|
||||
if process_manager.is_stopping():
|
||||
process_manager.end()
|
||||
logger.info(wording.get('processing_stopped'), __name__)
|
||||
return process_manager.is_pending()
|
||||
|
||||
@@ -1,27 +1,32 @@
|
||||
import itertools
|
||||
import shutil
|
||||
from typing import List
|
||||
|
||||
from facefusion import metadata
|
||||
from facefusion.types import Commands
|
||||
from facefusion.types import Command
|
||||
|
||||
|
||||
def run(commands : Commands) -> Commands:
|
||||
def run(commands : List[Command]) -> List[Command]:
|
||||
user_agent = metadata.get('name') + '/' + metadata.get('version')
|
||||
|
||||
return [ shutil.which('curl'), '--user-agent', user_agent, '--insecure', '--location', '--silent' ] + commands
|
||||
|
||||
|
||||
def chain(*commands : Commands) -> Commands:
|
||||
def chain(*commands : List[Command]) -> List[Command]:
|
||||
return list(itertools.chain(*commands))
|
||||
|
||||
|
||||
def head(url : str) -> Commands:
|
||||
def ping(url : str) -> List[Command]:
|
||||
return [ '-I', url ]
|
||||
|
||||
|
||||
def download(url : str, download_file_path : str) -> Commands:
|
||||
def download(url : str, download_file_path : str) -> List[Command]:
|
||||
return [ '--create-dirs', '--continue-at', '-', '--output', download_file_path, url ]
|
||||
|
||||
|
||||
def set_timeout(timeout : int) -> Commands:
|
||||
def set_timeout(timeout : int) -> List[Command]:
|
||||
return [ '--connect-timeout', str(timeout) ]
|
||||
|
||||
|
||||
def set_retry(retry : int) -> List[Command]:
|
||||
return [ '--retry', str(retry) ]
|
||||
|
||||
+15
-14
@@ -7,13 +7,13 @@ from urllib.parse import urlparse
|
||||
from tqdm import tqdm
|
||||
|
||||
import facefusion.choices
|
||||
from facefusion import curl_builder, logger, process_manager, state_manager, wording
|
||||
from facefusion import curl_builder, logger, process_manager, state_manager, translator
|
||||
from facefusion.filesystem import get_file_name, get_file_size, is_file, remove_file
|
||||
from facefusion.hash_helper import validate_hash
|
||||
from facefusion.types import Commands, DownloadProvider, DownloadSet
|
||||
from facefusion.types import Command, DownloadProvider, DownloadSet
|
||||
|
||||
|
||||
def open_curl(commands : Commands) -> subprocess.Popen[bytes]:
|
||||
def open_curl(commands : List[Command]) -> subprocess.Popen[bytes]:
|
||||
commands = curl_builder.run(commands)
|
||||
return subprocess.Popen(commands, stdin = subprocess.PIPE, stdout = subprocess.PIPE)
|
||||
|
||||
@@ -26,10 +26,11 @@ def conditional_download(download_directory_path : str, urls : List[str]) -> Non
|
||||
download_size = get_static_download_size(url)
|
||||
|
||||
if initial_size < download_size:
|
||||
with tqdm(total = download_size, initial = initial_size, desc = wording.get('downloading'), unit = 'B', unit_scale = True, unit_divisor = 1024, ascii = ' =', disable = state_manager.get_item('log_level') in [ 'warn', 'error' ]) as progress:
|
||||
with tqdm(total = download_size, initial = initial_size, desc = translator.get('downloading'), unit = 'B', unit_scale = True, unit_divisor = 1024, ascii = ' =', disable = state_manager.get_item('log_level') in [ 'warn', 'error' ]) as progress:
|
||||
commands = curl_builder.chain(
|
||||
curl_builder.download(url, download_file_path),
|
||||
curl_builder.set_timeout(10)
|
||||
curl_builder.set_timeout(5),
|
||||
curl_builder.set_retry(5)
|
||||
)
|
||||
open_curl(commands)
|
||||
current_size = initial_size
|
||||
@@ -41,10 +42,10 @@ def conditional_download(download_directory_path : str, urls : List[str]) -> Non
|
||||
progress.update(current_size - progress.n)
|
||||
|
||||
|
||||
@lru_cache(maxsize = None)
|
||||
@lru_cache(maxsize = 64)
|
||||
def get_static_download_size(url : str) -> int:
|
||||
commands = curl_builder.chain(
|
||||
curl_builder.head(url),
|
||||
curl_builder.ping(url),
|
||||
curl_builder.set_timeout(5)
|
||||
)
|
||||
process = open_curl(commands)
|
||||
@@ -59,10 +60,10 @@ def get_static_download_size(url : str) -> int:
|
||||
return 0
|
||||
|
||||
|
||||
@lru_cache(maxsize = None)
|
||||
@lru_cache(maxsize = 64)
|
||||
def ping_static_url(url : str) -> bool:
|
||||
commands = curl_builder.chain(
|
||||
curl_builder.head(url),
|
||||
curl_builder.ping(url),
|
||||
curl_builder.set_timeout(5)
|
||||
)
|
||||
process = open_curl(commands)
|
||||
@@ -87,10 +88,10 @@ def conditional_download_hashes(hash_set : DownloadSet) -> bool:
|
||||
|
||||
for valid_hash_path in valid_hash_paths:
|
||||
valid_hash_file_name = get_file_name(valid_hash_path)
|
||||
logger.debug(wording.get('validating_hash_succeed').format(hash_file_name = valid_hash_file_name), __name__)
|
||||
logger.debug(translator.get('validating_hash_succeeded').format(hash_file_name = valid_hash_file_name), __name__)
|
||||
for invalid_hash_path in invalid_hash_paths:
|
||||
invalid_hash_file_name = get_file_name(invalid_hash_path)
|
||||
logger.error(wording.get('validating_hash_failed').format(hash_file_name = invalid_hash_file_name), __name__)
|
||||
logger.error(translator.get('validating_hash_failed').format(hash_file_name = invalid_hash_file_name), __name__)
|
||||
|
||||
if not invalid_hash_paths:
|
||||
process_manager.end()
|
||||
@@ -114,13 +115,13 @@ def conditional_download_sources(source_set : DownloadSet) -> bool:
|
||||
|
||||
for valid_source_path in valid_source_paths:
|
||||
valid_source_file_name = get_file_name(valid_source_path)
|
||||
logger.debug(wording.get('validating_source_succeed').format(source_file_name = valid_source_file_name), __name__)
|
||||
logger.debug(translator.get('validating_source_succeeded').format(source_file_name = valid_source_file_name), __name__)
|
||||
for invalid_source_path in invalid_source_paths:
|
||||
invalid_source_file_name = get_file_name(invalid_source_path)
|
||||
logger.error(wording.get('validating_source_failed').format(source_file_name = invalid_source_file_name), __name__)
|
||||
logger.error(translator.get('validating_source_failed').format(source_file_name = invalid_source_file_name), __name__)
|
||||
|
||||
if remove_file(invalid_source_path):
|
||||
logger.error(wording.get('deleting_corrupt_source').format(source_file_name = invalid_source_file_name), __name__)
|
||||
logger.error(translator.get('deleting_corrupt_source').format(source_file_name = invalid_source_file_name), __name__)
|
||||
|
||||
if not invalid_source_paths:
|
||||
process_manager.end()
|
||||
|
||||
+11
-7
@@ -28,7 +28,7 @@ def get_available_execution_providers() -> List[ExecutionProvider]:
|
||||
return available_execution_providers
|
||||
|
||||
|
||||
def create_inference_session_providers(execution_device_id : str, execution_providers : List[ExecutionProvider]) -> List[InferenceSessionProvider]:
|
||||
def create_inference_session_providers(execution_device_id : int, execution_providers : List[ExecutionProvider]) -> List[InferenceSessionProvider]:
|
||||
inference_session_providers : List[InferenceSessionProvider] = []
|
||||
|
||||
for execution_provider in execution_providers:
|
||||
@@ -53,6 +53,12 @@ def create_inference_session_providers(execution_device_id : str, execution_prov
|
||||
{
|
||||
'device_id': execution_device_id
|
||||
}))
|
||||
if execution_provider == 'migraphx':
|
||||
inference_session_providers.append((facefusion.choices.execution_provider_set.get(execution_provider),
|
||||
{
|
||||
'device_id': execution_device_id,
|
||||
'migraphx_model_cache_dir': '.caches'
|
||||
}))
|
||||
if execution_provider == 'openvino':
|
||||
inference_session_providers.append((facefusion.choices.execution_provider_set.get(execution_provider),
|
||||
{
|
||||
@@ -83,12 +89,10 @@ def resolve_cudnn_conv_algo_search() -> str:
|
||||
return 'EXHAUSTIVE'
|
||||
|
||||
|
||||
def resolve_openvino_device_type(execution_device_id : str) -> str:
|
||||
if execution_device_id == '0':
|
||||
def resolve_openvino_device_type(execution_device_id : int) -> str:
|
||||
if execution_device_id == 0:
|
||||
return 'GPU'
|
||||
if execution_device_id == '∞':
|
||||
return 'MULTI:GPU'
|
||||
return 'GPU.' + execution_device_id
|
||||
return 'GPU.' + str(execution_device_id)
|
||||
|
||||
|
||||
def run_nvidia_smi() -> subprocess.Popen[bytes]:
|
||||
@@ -96,7 +100,7 @@ def run_nvidia_smi() -> subprocess.Popen[bytes]:
|
||||
return subprocess.Popen(commands, stdout = subprocess.PIPE)
|
||||
|
||||
|
||||
@lru_cache(maxsize = None)
|
||||
@lru_cache()
|
||||
def detect_static_execution_devices() -> List[ExecutionDevice]:
|
||||
return detect_execution_devices()
|
||||
|
||||
|
||||
@@ -1,3 +1,4 @@
|
||||
import os
|
||||
import signal
|
||||
import sys
|
||||
from time import sleep
|
||||
@@ -8,8 +9,11 @@ from facefusion.temp_helper import clear_temp_directory
|
||||
from facefusion.types import ErrorCode
|
||||
|
||||
|
||||
def fatal_exit(error_code : ErrorCode) -> None:
|
||||
os._exit(error_code)
|
||||
|
||||
|
||||
def hard_exit(error_code : ErrorCode) -> None:
|
||||
signal.signal(signal.SIGINT, signal.SIG_IGN)
|
||||
sys.exit(error_code)
|
||||
|
||||
|
||||
@@ -18,9 +22,13 @@ def signal_exit(signum : int, frame : FrameType) -> None:
|
||||
|
||||
|
||||
def graceful_exit(error_code : ErrorCode) -> None:
|
||||
signal.signal(signal.SIGINT, signal.SIG_IGN)
|
||||
process_manager.stop()
|
||||
|
||||
while process_manager.is_processing():
|
||||
sleep(0.5)
|
||||
|
||||
if state_manager.get_item('target_path'):
|
||||
clear_temp_directory(state_manager.get_item('target_path'))
|
||||
|
||||
hard_exit(error_code)
|
||||
|
||||
+31
-12
@@ -5,10 +5,10 @@ import numpy
|
||||
from facefusion import state_manager
|
||||
from facefusion.common_helper import get_first
|
||||
from facefusion.face_classifier import classify_face
|
||||
from facefusion.face_detector import detect_faces, detect_rotated_faces
|
||||
from facefusion.face_detector import detect_faces, detect_faces_by_angle
|
||||
from facefusion.face_helper import apply_nms, convert_to_face_landmark_5, estimate_face_angle, get_nms_threshold
|
||||
from facefusion.face_landmarker import detect_face_landmark, estimate_face_landmark_68_5
|
||||
from facefusion.face_recognizer import calc_embedding
|
||||
from facefusion.face_recognizer import calculate_face_embedding
|
||||
from facefusion.face_store import get_static_faces, set_static_faces
|
||||
from facefusion.types import BoundingBox, Face, FaceLandmark5, FaceLandmarkSet, FaceScoreSet, Score, VisionFrame
|
||||
|
||||
@@ -45,15 +45,15 @@ def create_faces(vision_frame : VisionFrame, bounding_boxes : List[BoundingBox],
|
||||
'detector': face_score,
|
||||
'landmarker': face_landmark_score_68
|
||||
}
|
||||
embedding, normed_embedding = calc_embedding(vision_frame, face_landmark_set.get('5/68'))
|
||||
face_embedding, face_embedding_norm = calculate_face_embedding(vision_frame, face_landmark_set.get('5/68'))
|
||||
gender, age, race = classify_face(vision_frame, face_landmark_set.get('5/68'))
|
||||
faces.append(Face(
|
||||
bounding_box = bounding_box,
|
||||
score_set = face_score_set,
|
||||
landmark_set = face_landmark_set,
|
||||
angle = face_angle,
|
||||
embedding = embedding,
|
||||
normed_embedding = normed_embedding,
|
||||
embedding = face_embedding,
|
||||
embedding_norm = face_embedding_norm,
|
||||
gender = gender,
|
||||
age = age,
|
||||
race = race
|
||||
@@ -69,23 +69,23 @@ def get_one_face(faces : List[Face], position : int = 0) -> Optional[Face]:
|
||||
|
||||
|
||||
def get_average_face(faces : List[Face]) -> Optional[Face]:
|
||||
embeddings = []
|
||||
normed_embeddings = []
|
||||
face_embeddings = []
|
||||
face_embeddings_norm = []
|
||||
|
||||
if faces:
|
||||
first_face = get_first(faces)
|
||||
|
||||
for face in faces:
|
||||
embeddings.append(face.embedding)
|
||||
normed_embeddings.append(face.normed_embedding)
|
||||
face_embeddings.append(face.embedding)
|
||||
face_embeddings_norm.append(face.embedding_norm)
|
||||
|
||||
return Face(
|
||||
bounding_box = first_face.bounding_box,
|
||||
score_set = first_face.score_set,
|
||||
landmark_set = first_face.landmark_set,
|
||||
angle = first_face.angle,
|
||||
embedding = numpy.mean(embeddings, axis = 0),
|
||||
normed_embedding = numpy.mean(normed_embeddings, axis = 0),
|
||||
embedding = numpy.mean(face_embeddings, axis = 0),
|
||||
embedding_norm = numpy.mean(face_embeddings_norm, axis = 0),
|
||||
gender = first_face.gender,
|
||||
age = first_face.age,
|
||||
race = first_face.race
|
||||
@@ -110,7 +110,7 @@ def get_many_faces(vision_frames : List[VisionFrame]) -> List[Face]:
|
||||
if face_detector_angle == 0:
|
||||
bounding_boxes, face_scores, face_landmarks_5 = detect_faces(vision_frame)
|
||||
else:
|
||||
bounding_boxes, face_scores, face_landmarks_5 = detect_rotated_faces(vision_frame, face_detector_angle)
|
||||
bounding_boxes, face_scores, face_landmarks_5 = detect_faces_by_angle(vision_frame, face_detector_angle)
|
||||
all_bounding_boxes.extend(bounding_boxes)
|
||||
all_face_scores.extend(face_scores)
|
||||
all_face_landmarks_5.extend(face_landmarks_5)
|
||||
@@ -122,3 +122,22 @@ def get_many_faces(vision_frames : List[VisionFrame]) -> List[Face]:
|
||||
many_faces.extend(faces)
|
||||
set_static_faces(vision_frame, faces)
|
||||
return many_faces
|
||||
|
||||
|
||||
def scale_face(target_face : Face, target_vision_frame : VisionFrame, temp_vision_frame : VisionFrame) -> Face:
|
||||
scale_x = temp_vision_frame.shape[1] / target_vision_frame.shape[1]
|
||||
scale_y = temp_vision_frame.shape[0] / target_vision_frame.shape[0]
|
||||
|
||||
bounding_box = target_face.bounding_box * [ scale_x, scale_y, scale_x, scale_y ]
|
||||
landmark_set =\
|
||||
{
|
||||
'5': target_face.landmark_set.get('5') * numpy.array([ scale_x, scale_y ]),
|
||||
'5/68': target_face.landmark_set.get('5/68') * numpy.array([ scale_x, scale_y ]),
|
||||
'68': target_face.landmark_set.get('68') * numpy.array([ scale_x, scale_y ]),
|
||||
'68/5': target_face.landmark_set.get('68/5') * numpy.array([ scale_x, scale_y ])
|
||||
}
|
||||
|
||||
return target_face._replace(
|
||||
bounding_box = bounding_box,
|
||||
landmark_set = landmark_set
|
||||
)
|
||||
|
||||
@@ -11,12 +11,18 @@ from facefusion.thread_helper import conditional_thread_semaphore
|
||||
from facefusion.types import Age, DownloadScope, FaceLandmark5, Gender, InferencePool, ModelOptions, ModelSet, Race, VisionFrame
|
||||
|
||||
|
||||
@lru_cache(maxsize = None)
|
||||
@lru_cache()
|
||||
def create_static_model_set(download_scope : DownloadScope) -> ModelSet:
|
||||
return\
|
||||
{
|
||||
'fairface':
|
||||
{
|
||||
'__metadata__':
|
||||
{
|
||||
'vendor': 'dchen236',
|
||||
'license': 'Non-Commercial',
|
||||
'year': 2021
|
||||
},
|
||||
'hashes':
|
||||
{
|
||||
'face_classifier':
|
||||
|
||||
+154
-19
@@ -6,19 +6,25 @@ import numpy
|
||||
|
||||
from facefusion import inference_manager, state_manager
|
||||
from facefusion.download import conditional_download_hashes, conditional_download_sources, resolve_download_url
|
||||
from facefusion.face_helper import create_rotated_matrix_and_size, create_static_anchors, distance_to_bounding_box, distance_to_face_landmark_5, normalize_bounding_box, transform_bounding_box, transform_points
|
||||
from facefusion.face_helper import create_rotation_matrix_and_size, create_static_anchors, distance_to_bounding_box, distance_to_face_landmark_5, normalize_bounding_box, transform_bounding_box, transform_points
|
||||
from facefusion.filesystem import resolve_relative_path
|
||||
from facefusion.thread_helper import thread_semaphore
|
||||
from facefusion.types import Angle, BoundingBox, Detection, DownloadScope, DownloadSet, FaceLandmark5, InferencePool, ModelSet, Score, VisionFrame
|
||||
from facefusion.types import Angle, BoundingBox, Detection, DownloadScope, DownloadSet, FaceLandmark5, InferencePool, Margin, ModelSet, Score, VisionFrame
|
||||
from facefusion.vision import restrict_frame, unpack_resolution
|
||||
|
||||
|
||||
@lru_cache(maxsize = None)
|
||||
@lru_cache()
|
||||
def create_static_model_set(download_scope : DownloadScope) -> ModelSet:
|
||||
return\
|
||||
{
|
||||
'retinaface':
|
||||
{
|
||||
'__metadata__':
|
||||
{
|
||||
'vendor': 'InsightFace',
|
||||
'license': 'Non-Commercial',
|
||||
'year': 2020
|
||||
},
|
||||
'hashes':
|
||||
{
|
||||
'retinaface':
|
||||
@@ -38,6 +44,12 @@ def create_static_model_set(download_scope : DownloadScope) -> ModelSet:
|
||||
},
|
||||
'scrfd':
|
||||
{
|
||||
'__metadata__':
|
||||
{
|
||||
'vendor': 'InsightFace',
|
||||
'license': 'Non-Commercial',
|
||||
'year': 2021
|
||||
},
|
||||
'hashes':
|
||||
{
|
||||
'scrfd':
|
||||
@@ -57,6 +69,12 @@ def create_static_model_set(download_scope : DownloadScope) -> ModelSet:
|
||||
},
|
||||
'yolo_face':
|
||||
{
|
||||
'__metadata__':
|
||||
{
|
||||
'vendor': 'derronqi',
|
||||
'license': 'GPL-3.0',
|
||||
'year': 2022
|
||||
},
|
||||
'hashes':
|
||||
{
|
||||
'yolo_face':
|
||||
@@ -73,6 +91,31 @@ def create_static_model_set(download_scope : DownloadScope) -> ModelSet:
|
||||
'path': resolve_relative_path('../.assets/models/yoloface_8n.onnx')
|
||||
}
|
||||
}
|
||||
},
|
||||
'yunet':
|
||||
{
|
||||
'__metadata__':
|
||||
{
|
||||
'vendor': 'OpenCV',
|
||||
'license': 'MIT',
|
||||
'year': 2023
|
||||
},
|
||||
'hashes':
|
||||
{
|
||||
'yunet':
|
||||
{
|
||||
'url': resolve_download_url('models-3.4.0', 'yunet_2023_mar.hash'),
|
||||
'path': resolve_relative_path('../.assets/models/yunet_2023_mar.hash')
|
||||
}
|
||||
},
|
||||
'sources':
|
||||
{
|
||||
'yunet':
|
||||
{
|
||||
'url': resolve_download_url('models-3.4.0', 'yunet_2023_mar.onnx'),
|
||||
'path': resolve_relative_path('../.assets/models/yunet_2023_mar.onnx')
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -94,7 +137,7 @@ def collect_model_downloads() -> Tuple[DownloadSet, DownloadSet]:
|
||||
model_hash_set = {}
|
||||
model_source_set = {}
|
||||
|
||||
for face_detector_model in [ 'retinaface', 'scrfd', 'yolo_face' ]:
|
||||
for face_detector_model in [ 'retinaface', 'scrfd', 'yolo_face', 'yunet' ]:
|
||||
if state_manager.get_item('face_detector_model') in [ 'many', face_detector_model ]:
|
||||
model_hash_set[face_detector_model] = model_set.get(face_detector_model).get('hashes').get(face_detector_model)
|
||||
model_source_set[face_detector_model] = model_set.get(face_detector_model).get('sources').get(face_detector_model)
|
||||
@@ -109,39 +152,56 @@ def pre_check() -> bool:
|
||||
|
||||
|
||||
def detect_faces(vision_frame : VisionFrame) -> Tuple[List[BoundingBox], List[Score], List[FaceLandmark5]]:
|
||||
margin_top, margin_right, margin_bottom, margin_left = prepare_margin(vision_frame)
|
||||
margin_vision_frame = numpy.pad(vision_frame, ((margin_top, margin_bottom), (margin_left, margin_right), (0, 0)))
|
||||
all_bounding_boxes : List[BoundingBox] = []
|
||||
all_face_scores : List[Score] = []
|
||||
all_face_landmarks_5 : List[FaceLandmark5] = []
|
||||
|
||||
if state_manager.get_item('face_detector_model') in [ 'many', 'retinaface' ]:
|
||||
bounding_boxes, face_scores, face_landmarks_5 = detect_with_retinaface(vision_frame, state_manager.get_item('face_detector_size'))
|
||||
bounding_boxes, face_scores, face_landmarks_5 = detect_with_retinaface(margin_vision_frame, state_manager.get_item('face_detector_size'))
|
||||
all_bounding_boxes.extend(bounding_boxes)
|
||||
all_face_scores.extend(face_scores)
|
||||
all_face_landmarks_5.extend(face_landmarks_5)
|
||||
|
||||
if state_manager.get_item('face_detector_model') in [ 'many', 'scrfd' ]:
|
||||
bounding_boxes, face_scores, face_landmarks_5 = detect_with_scrfd(vision_frame, state_manager.get_item('face_detector_size'))
|
||||
bounding_boxes, face_scores, face_landmarks_5 = detect_with_scrfd(margin_vision_frame, state_manager.get_item('face_detector_size'))
|
||||
all_bounding_boxes.extend(bounding_boxes)
|
||||
all_face_scores.extend(face_scores)
|
||||
all_face_landmarks_5.extend(face_landmarks_5)
|
||||
|
||||
if state_manager.get_item('face_detector_model') in [ 'many', 'yolo_face' ]:
|
||||
bounding_boxes, face_scores, face_landmarks_5 = detect_with_yolo_face(vision_frame, state_manager.get_item('face_detector_size'))
|
||||
bounding_boxes, face_scores, face_landmarks_5 = detect_with_yolo_face(margin_vision_frame, state_manager.get_item('face_detector_size'))
|
||||
all_bounding_boxes.extend(bounding_boxes)
|
||||
all_face_scores.extend(face_scores)
|
||||
all_face_landmarks_5.extend(face_landmarks_5)
|
||||
|
||||
all_bounding_boxes = [ normalize_bounding_box(all_bounding_box) for all_bounding_box in all_bounding_boxes ]
|
||||
if state_manager.get_item('face_detector_model') == 'yunet':
|
||||
bounding_boxes, face_scores, face_landmarks_5 = detect_with_yunet(margin_vision_frame, state_manager.get_item('face_detector_size'))
|
||||
all_bounding_boxes.extend(bounding_boxes)
|
||||
all_face_scores.extend(face_scores)
|
||||
all_face_landmarks_5.extend(face_landmarks_5)
|
||||
|
||||
all_bounding_boxes = [ normalize_bounding_box(all_bounding_box) - numpy.array([ margin_left, margin_top, margin_left, margin_top ]) for all_bounding_box in all_bounding_boxes ]
|
||||
all_face_landmarks_5 = [ all_face_landmark_5 - numpy.array([ margin_left, margin_top ]) for all_face_landmark_5 in all_face_landmarks_5 ]
|
||||
return all_bounding_boxes, all_face_scores, all_face_landmarks_5
|
||||
|
||||
|
||||
def detect_rotated_faces(vision_frame : VisionFrame, angle : Angle) -> Tuple[List[BoundingBox], List[Score], List[FaceLandmark5]]:
|
||||
rotated_matrix, rotated_size = create_rotated_matrix_and_size(angle, vision_frame.shape[:2][::-1])
|
||||
rotated_vision_frame = cv2.warpAffine(vision_frame, rotated_matrix, rotated_size)
|
||||
rotated_inverse_matrix = cv2.invertAffineTransform(rotated_matrix)
|
||||
bounding_boxes, face_scores, face_landmarks_5 = detect_faces(rotated_vision_frame)
|
||||
bounding_boxes = [ transform_bounding_box(bounding_box, rotated_inverse_matrix) for bounding_box in bounding_boxes ]
|
||||
face_landmarks_5 = [ transform_points(face_landmark_5, rotated_inverse_matrix) for face_landmark_5 in face_landmarks_5 ]
|
||||
def prepare_margin(vision_frame : VisionFrame) -> Margin:
|
||||
margin_top = int(vision_frame.shape[0] * numpy.interp(state_manager.get_item('face_detector_margin')[0], [ 0, 100 ], [ 0, 0.5 ]))
|
||||
margin_right = int(vision_frame.shape[1] * numpy.interp(state_manager.get_item('face_detector_margin')[1], [ 0, 100 ], [ 0, 0.5 ]))
|
||||
margin_bottom = int(vision_frame.shape[0] * numpy.interp(state_manager.get_item('face_detector_margin')[2], [ 0, 100 ], [ 0, 0.5 ]))
|
||||
margin_left = int(vision_frame.shape[1] * numpy.interp(state_manager.get_item('face_detector_margin')[3], [ 0, 100 ], [ 0, 0.5 ]))
|
||||
return margin_top, margin_right, margin_bottom, margin_left
|
||||
|
||||
|
||||
def detect_faces_by_angle(vision_frame : VisionFrame, face_angle : Angle) -> Tuple[List[BoundingBox], List[Score], List[FaceLandmark5]]:
|
||||
rotation_matrix, rotation_size = create_rotation_matrix_and_size(face_angle, vision_frame.shape[:2][::-1])
|
||||
rotation_vision_frame = cv2.warpAffine(vision_frame, rotation_matrix, rotation_size)
|
||||
rotation_inverse_matrix = cv2.invertAffineTransform(rotation_matrix)
|
||||
bounding_boxes, face_scores, face_landmarks_5 = detect_faces(rotation_vision_frame)
|
||||
bounding_boxes = [ transform_bounding_box(bounding_box, rotation_inverse_matrix) for bounding_box in bounding_boxes ]
|
||||
face_landmarks_5 = [ transform_points(face_landmark_5, rotation_inverse_matrix) for face_landmark_5 in face_landmarks_5 ]
|
||||
return bounding_boxes, face_scores, face_landmarks_5
|
||||
|
||||
|
||||
@@ -162,7 +222,8 @@ def detect_with_retinaface(vision_frame : VisionFrame, face_detector_size : str)
|
||||
detection = forward_with_retinaface(detect_vision_frame)
|
||||
|
||||
for index, feature_stride in enumerate(feature_strides):
|
||||
keep_indices = numpy.where(detection[index] >= face_detector_score)[0]
|
||||
face_scores_raw = detection[index]
|
||||
keep_indices = numpy.where(face_scores_raw >= face_detector_score)[0]
|
||||
|
||||
if numpy.any(keep_indices):
|
||||
stride_height = face_detector_height // feature_stride
|
||||
@@ -180,7 +241,7 @@ def detect_with_retinaface(vision_frame : VisionFrame, face_detector_size : str)
|
||||
bounding_box_raw[3] * ratio_height
|
||||
]))
|
||||
|
||||
for face_score_raw in detection[index][keep_indices]:
|
||||
for face_score_raw in face_scores_raw[keep_indices]:
|
||||
face_scores.append(face_score_raw[0])
|
||||
|
||||
for face_landmark_raw_5 in distance_to_face_landmark_5(anchors, face_landmarks_5_raw)[keep_indices]:
|
||||
@@ -206,7 +267,8 @@ def detect_with_scrfd(vision_frame : VisionFrame, face_detector_size : str) -> T
|
||||
detection = forward_with_scrfd(detect_vision_frame)
|
||||
|
||||
for index, feature_stride in enumerate(feature_strides):
|
||||
keep_indices = numpy.where(detection[index] >= face_detector_score)[0]
|
||||
face_scores_raw = detection[index]
|
||||
keep_indices = numpy.where(face_scores_raw >= face_detector_score)[0]
|
||||
|
||||
if numpy.any(keep_indices):
|
||||
stride_height = face_detector_height // feature_stride
|
||||
@@ -224,7 +286,7 @@ def detect_with_scrfd(vision_frame : VisionFrame, face_detector_size : str) -> T
|
||||
bounding_box_raw[3] * ratio_height
|
||||
]))
|
||||
|
||||
for face_score_raw in detection[index][keep_indices]:
|
||||
for face_score_raw in face_scores_raw[keep_indices]:
|
||||
face_scores.append(face_score_raw[0])
|
||||
|
||||
for face_landmark_raw_5 in distance_to_face_landmark_5(anchors, face_landmarks_5_raw)[keep_indices]:
|
||||
@@ -271,6 +333,67 @@ def detect_with_yolo_face(vision_frame : VisionFrame, face_detector_size : str)
|
||||
return bounding_boxes, face_scores, face_landmarks_5
|
||||
|
||||
|
||||
def detect_with_yunet(vision_frame : VisionFrame, face_detector_size : str) -> Tuple[List[BoundingBox], List[Score], List[FaceLandmark5]]:
|
||||
bounding_boxes = []
|
||||
face_scores = []
|
||||
face_landmarks_5 = []
|
||||
feature_strides = [ 8, 16, 32 ]
|
||||
feature_map_channel = 3
|
||||
anchor_total = 1
|
||||
face_detector_score = state_manager.get_item('face_detector_score')
|
||||
face_detector_width, face_detector_height = unpack_resolution(face_detector_size)
|
||||
temp_vision_frame = restrict_frame(vision_frame, (face_detector_width, face_detector_height))
|
||||
ratio_height = vision_frame.shape[0] / temp_vision_frame.shape[0]
|
||||
ratio_width = vision_frame.shape[1] / temp_vision_frame.shape[1]
|
||||
detect_vision_frame = prepare_detect_frame(temp_vision_frame, face_detector_size)
|
||||
detect_vision_frame = normalize_detect_frame(detect_vision_frame, [ 0, 255 ])
|
||||
detection = forward_with_yunet(detect_vision_frame)
|
||||
|
||||
for index, feature_stride in enumerate(feature_strides):
|
||||
face_scores_raw = (detection[index] * detection[index + feature_map_channel]).reshape(-1)
|
||||
keep_indices = numpy.where(face_scores_raw >= face_detector_score)[0]
|
||||
|
||||
if numpy.any(keep_indices):
|
||||
stride_height = face_detector_height // feature_stride
|
||||
stride_width = face_detector_width // feature_stride
|
||||
anchors = create_static_anchors(feature_stride, anchor_total, stride_height, stride_width)
|
||||
bounding_boxes_center = detection[index + feature_map_channel * 2].squeeze(0)[:, :2] * feature_stride + anchors
|
||||
bounding_boxes_size = numpy.exp(detection[index + feature_map_channel * 2].squeeze(0)[:, 2:4]) * feature_stride
|
||||
face_landmarks_5_raw = detection[index + feature_map_channel * 3].squeeze(0)
|
||||
|
||||
bounding_boxes_raw = numpy.stack(
|
||||
[
|
||||
bounding_boxes_center[:, 0] - bounding_boxes_size[:, 0] / 2,
|
||||
bounding_boxes_center[:, 1] - bounding_boxes_size[:, 1] / 2,
|
||||
bounding_boxes_center[:, 0] + bounding_boxes_size[:, 0] / 2,
|
||||
bounding_boxes_center[:, 1] + bounding_boxes_size[:, 1] / 2
|
||||
], axis = -1)
|
||||
|
||||
for bounding_box_raw in bounding_boxes_raw[keep_indices]:
|
||||
bounding_boxes.append(numpy.array(
|
||||
[
|
||||
bounding_box_raw[0] * ratio_width,
|
||||
bounding_box_raw[1] * ratio_height,
|
||||
bounding_box_raw[2] * ratio_width,
|
||||
bounding_box_raw[3] * ratio_height
|
||||
]))
|
||||
|
||||
face_scores.extend(face_scores_raw[keep_indices])
|
||||
face_landmarks_5_raw = numpy.concatenate(
|
||||
[
|
||||
face_landmarks_5_raw[:, [0, 1]] * feature_stride + anchors,
|
||||
face_landmarks_5_raw[:, [2, 3]] * feature_stride + anchors,
|
||||
face_landmarks_5_raw[:, [4, 5]] * feature_stride + anchors,
|
||||
face_landmarks_5_raw[:, [6, 7]] * feature_stride + anchors,
|
||||
face_landmarks_5_raw[:, [8, 9]] * feature_stride + anchors
|
||||
], axis = -1).reshape(-1, 5, 2)
|
||||
|
||||
for face_landmark_raw_5 in face_landmarks_5_raw[keep_indices]:
|
||||
face_landmarks_5.append(face_landmark_raw_5 * [ ratio_width, ratio_height ])
|
||||
|
||||
return bounding_boxes, face_scores, face_landmarks_5
|
||||
|
||||
|
||||
def forward_with_retinaface(detect_vision_frame : VisionFrame) -> Detection:
|
||||
face_detector = get_inference_pool().get('retinaface')
|
||||
|
||||
@@ -307,6 +430,18 @@ def forward_with_yolo_face(detect_vision_frame : VisionFrame) -> Detection:
|
||||
return detection
|
||||
|
||||
|
||||
def forward_with_yunet(detect_vision_frame : VisionFrame) -> Detection:
|
||||
face_detector = get_inference_pool().get('yunet')
|
||||
|
||||
with thread_semaphore():
|
||||
detection = face_detector.run(None,
|
||||
{
|
||||
'input': detect_vision_frame
|
||||
})
|
||||
|
||||
return detection
|
||||
|
||||
|
||||
def prepare_detect_frame(temp_vision_frame : VisionFrame, face_detector_size : str) -> VisionFrame:
|
||||
face_detector_width, face_detector_height = unpack_resolution(face_detector_size)
|
||||
detect_vision_frame = numpy.zeros((face_detector_height, face_detector_width, 3))
|
||||
|
||||
+41
-39
@@ -69,8 +69,8 @@ WARP_TEMPLATE_SET : WarpTemplateSet =\
|
||||
|
||||
|
||||
def estimate_matrix_by_face_landmark_5(face_landmark_5 : FaceLandmark5, warp_template : WarpTemplate, crop_size : Size) -> Matrix:
|
||||
normed_warp_template = WARP_TEMPLATE_SET.get(warp_template) * crop_size
|
||||
affine_matrix = cv2.estimateAffinePartial2D(face_landmark_5, normed_warp_template, method = cv2.RANSAC, ransacReprojThreshold = 100)[0]
|
||||
warp_template_norm = WARP_TEMPLATE_SET.get(warp_template) * crop_size
|
||||
affine_matrix = cv2.estimateAffinePartial2D(face_landmark_5, warp_template_norm, method = cv2.RANSAC, ransacReprojThreshold = 100)[0]
|
||||
return affine_matrix
|
||||
|
||||
|
||||
@@ -98,59 +98,59 @@ def warp_face_by_translation(temp_vision_frame : VisionFrame, translation : Tran
|
||||
return crop_vision_frame, affine_matrix
|
||||
|
||||
|
||||
def paste_back(temp_vision_frame : VisionFrame, crop_vision_frame : VisionFrame, crop_mask : Mask, affine_matrix : Matrix) -> VisionFrame:
|
||||
paste_bounding_box, paste_matrix = calc_paste_area(temp_vision_frame, crop_vision_frame, affine_matrix)
|
||||
x_min, y_min, x_max, y_max = paste_bounding_box
|
||||
paste_width = x_max - x_min
|
||||
paste_height = y_max - y_min
|
||||
inverse_mask = cv2.warpAffine(crop_mask, paste_matrix, (paste_width, paste_height)).clip(0, 1)
|
||||
inverse_mask = numpy.expand_dims(inverse_mask, axis = -1)
|
||||
def paste_back(temp_vision_frame : VisionFrame, crop_vision_frame : VisionFrame, crop_vision_mask : Mask, affine_matrix : Matrix) -> VisionFrame:
|
||||
paste_bounding_box, paste_matrix = calculate_paste_area(temp_vision_frame, crop_vision_frame, affine_matrix)
|
||||
x1, y1, x2, y2 = paste_bounding_box
|
||||
paste_width = x2 - x1
|
||||
paste_height = y2 - y1
|
||||
inverse_vision_mask = cv2.warpAffine(crop_vision_mask, paste_matrix, (paste_width, paste_height)).clip(0, 1)
|
||||
inverse_vision_mask = numpy.expand_dims(inverse_vision_mask, axis = -1)
|
||||
inverse_vision_frame = cv2.warpAffine(crop_vision_frame, paste_matrix, (paste_width, paste_height), borderMode = cv2.BORDER_REPLICATE)
|
||||
temp_vision_frame = temp_vision_frame.copy()
|
||||
paste_vision_frame = temp_vision_frame[y_min:y_max, x_min:x_max]
|
||||
paste_vision_frame = paste_vision_frame * (1 - inverse_mask) + inverse_vision_frame * inverse_mask
|
||||
temp_vision_frame[y_min:y_max, x_min:x_max] = paste_vision_frame.astype(temp_vision_frame.dtype)
|
||||
paste_vision_frame = temp_vision_frame[y1:y2, x1:x2]
|
||||
paste_vision_frame = paste_vision_frame * (1 - inverse_vision_mask) + inverse_vision_frame * inverse_vision_mask
|
||||
temp_vision_frame[y1:y2, x1:x2] = paste_vision_frame.astype(temp_vision_frame.dtype)
|
||||
return temp_vision_frame
|
||||
|
||||
|
||||
def calc_paste_area(temp_vision_frame : VisionFrame, crop_vision_frame : VisionFrame, affine_matrix : Matrix) -> Tuple[BoundingBox, Matrix]:
|
||||
def calculate_paste_area(temp_vision_frame : VisionFrame, crop_vision_frame : VisionFrame, affine_matrix : Matrix) -> Tuple[BoundingBox, Matrix]:
|
||||
temp_height, temp_width = temp_vision_frame.shape[:2]
|
||||
crop_height, crop_width = crop_vision_frame.shape[:2]
|
||||
inverse_matrix = cv2.invertAffineTransform(affine_matrix)
|
||||
crop_points = numpy.array([ [ 0, 0 ], [ crop_width, 0 ], [ crop_width, crop_height ], [ 0, crop_height ] ])
|
||||
paste_region_points = transform_points(crop_points, inverse_matrix)
|
||||
min_point = numpy.floor(paste_region_points.min(axis = 0)).astype(int)
|
||||
max_point = numpy.ceil(paste_region_points.max(axis = 0)).astype(int)
|
||||
x_min, y_min = numpy.clip(min_point, 0, [ temp_width, temp_height ])
|
||||
x_max, y_max = numpy.clip(max_point, 0, [ temp_width, temp_height ])
|
||||
paste_bounding_box = numpy.array([ x_min, y_min, x_max, y_max ])
|
||||
paste_region_point_min = numpy.floor(paste_region_points.min(axis = 0)).astype(int)
|
||||
paste_region_point_max = numpy.ceil(paste_region_points.max(axis = 0)).astype(int)
|
||||
x1, y1 = numpy.clip(paste_region_point_min, 0, [ temp_width, temp_height ])
|
||||
x2, y2 = numpy.clip(paste_region_point_max, 0, [ temp_width, temp_height ])
|
||||
paste_bounding_box = numpy.array([ x1, y1, x2, y2 ])
|
||||
paste_matrix = inverse_matrix.copy()
|
||||
paste_matrix[0, 2] -= x_min
|
||||
paste_matrix[1, 2] -= y_min
|
||||
paste_matrix[0, 2] -= x1
|
||||
paste_matrix[1, 2] -= y1
|
||||
return paste_bounding_box, paste_matrix
|
||||
|
||||
|
||||
@lru_cache(maxsize = None)
|
||||
@lru_cache()
|
||||
def create_static_anchors(feature_stride : int, anchor_total : int, stride_height : int, stride_width : int) -> Anchors:
|
||||
y, x = numpy.mgrid[:stride_height, :stride_width][::-1]
|
||||
x, y = numpy.mgrid[:stride_width, :stride_height]
|
||||
anchors = numpy.stack((y, x), axis = -1)
|
||||
anchors = (anchors * feature_stride).reshape((-1, 2))
|
||||
anchors = numpy.stack([ anchors ] * anchor_total, axis = 1).reshape((-1, 2))
|
||||
return anchors
|
||||
|
||||
|
||||
def create_rotated_matrix_and_size(angle : Angle, size : Size) -> Tuple[Matrix, Size]:
|
||||
rotated_matrix = cv2.getRotationMatrix2D((size[0] / 2, size[1] / 2), angle, 1)
|
||||
rotated_size = numpy.dot(numpy.abs(rotated_matrix[:, :2]), size)
|
||||
rotated_matrix[:, -1] += (rotated_size - size) * 0.5 #type:ignore[misc]
|
||||
rotated_size = int(rotated_size[0]), int(rotated_size[1])
|
||||
return rotated_matrix, rotated_size
|
||||
def create_rotation_matrix_and_size(angle : Angle, size : Size) -> Tuple[Matrix, Size]:
|
||||
rotation_matrix = cv2.getRotationMatrix2D((size[0] / 2, size[1] / 2), angle, 1)
|
||||
rotation_size = numpy.dot(numpy.abs(rotation_matrix[:, :2]), size)
|
||||
rotation_matrix[:, -1] += (rotation_size - size) * 0.5 #type:ignore[misc]
|
||||
rotation_size = int(rotation_size[0]), int(rotation_size[1])
|
||||
return rotation_matrix, rotation_size
|
||||
|
||||
|
||||
def create_bounding_box(face_landmark_68 : FaceLandmark68) -> BoundingBox:
|
||||
min_x, min_y = numpy.min(face_landmark_68, axis = 0)
|
||||
max_x, max_y = numpy.max(face_landmark_68, axis = 0)
|
||||
bounding_box = normalize_bounding_box(numpy.array([ min_x, min_y, max_x, max_y ]))
|
||||
x1, y1 = numpy.min(face_landmark_68, axis = 0)
|
||||
x2, y2 = numpy.max(face_landmark_68, axis = 0)
|
||||
bounding_box = normalize_bounding_box(numpy.array([ x1, y1, x2, y2 ]))
|
||||
return bounding_box
|
||||
|
||||
|
||||
@@ -229,8 +229,8 @@ def estimate_face_angle(face_landmark_68 : FaceLandmark68) -> Angle:
|
||||
|
||||
|
||||
def apply_nms(bounding_boxes : List[BoundingBox], scores : List[Score], score_threshold : float, nms_threshold : float) -> Sequence[int]:
|
||||
normed_bounding_boxes = [ (x1, y1, x2 - x1, y2 - y1) for (x1, y1, x2, y2) in bounding_boxes ]
|
||||
keep_indices = cv2.dnn.NMSBoxes(normed_bounding_boxes, scores, score_threshold = score_threshold, nms_threshold = nms_threshold)
|
||||
bounding_boxes_norm = [ (x1, y1, x2 - x1, y2 - y1) for (x1, y1, x2, y2) in bounding_boxes ]
|
||||
keep_indices = cv2.dnn.NMSBoxes(bounding_boxes_norm, scores, score_threshold = score_threshold, nms_threshold = nms_threshold)
|
||||
return keep_indices
|
||||
|
||||
|
||||
@@ -246,9 +246,11 @@ def get_nms_threshold(face_detector_model : FaceDetectorModel, face_detector_ang
|
||||
return 0.4
|
||||
|
||||
|
||||
def merge_matrix(matrices : List[Matrix]) -> Matrix:
|
||||
merged_matrix = numpy.vstack([ matrices[0], [ 0, 0, 1 ] ])
|
||||
for matrix in matrices[1:]:
|
||||
matrix = numpy.vstack([ matrix, [ 0, 0, 1 ] ])
|
||||
merged_matrix = numpy.dot(merged_matrix, matrix)
|
||||
return merged_matrix[:2, :]
|
||||
def merge_matrix(temp_matrices : List[Matrix]) -> Matrix:
|
||||
matrix = numpy.vstack([temp_matrices[0], [0, 0, 1]])
|
||||
|
||||
for temp_matrix in temp_matrices[1:]:
|
||||
temp_matrix = numpy.vstack([ temp_matrix, [ 0, 0, 1 ] ])
|
||||
matrix = numpy.dot(temp_matrix, matrix)
|
||||
|
||||
return matrix[:2, :]
|
||||
|
||||
@@ -6,18 +6,24 @@ import numpy
|
||||
|
||||
from facefusion import inference_manager, state_manager
|
||||
from facefusion.download import conditional_download_hashes, conditional_download_sources, resolve_download_url
|
||||
from facefusion.face_helper import create_rotated_matrix_and_size, estimate_matrix_by_face_landmark_5, transform_points, warp_face_by_translation
|
||||
from facefusion.face_helper import create_rotation_matrix_and_size, estimate_matrix_by_face_landmark_5, transform_points, warp_face_by_translation
|
||||
from facefusion.filesystem import resolve_relative_path
|
||||
from facefusion.thread_helper import conditional_thread_semaphore
|
||||
from facefusion.types import Angle, BoundingBox, DownloadScope, DownloadSet, FaceLandmark5, FaceLandmark68, InferencePool, ModelSet, Prediction, Score, VisionFrame
|
||||
|
||||
|
||||
@lru_cache(maxsize = None)
|
||||
@lru_cache()
|
||||
def create_static_model_set(download_scope : DownloadScope) -> ModelSet:
|
||||
return\
|
||||
{
|
||||
'2dfan4':
|
||||
{
|
||||
'__metadata__':
|
||||
{
|
||||
'vendor': 'breadbread1984',
|
||||
'license': 'MIT',
|
||||
'year': 2018
|
||||
},
|
||||
'hashes':
|
||||
{
|
||||
'2dfan4':
|
||||
@@ -38,6 +44,12 @@ def create_static_model_set(download_scope : DownloadScope) -> ModelSet:
|
||||
},
|
||||
'peppa_wutz':
|
||||
{
|
||||
'__metadata__':
|
||||
{
|
||||
'vendor': 'Unknown',
|
||||
'license': 'Apache-2.0',
|
||||
'year': 2023
|
||||
},
|
||||
'hashes':
|
||||
{
|
||||
'peppa_wutz':
|
||||
@@ -58,6 +70,12 @@ def create_static_model_set(download_scope : DownloadScope) -> ModelSet:
|
||||
},
|
||||
'fan_68_5':
|
||||
{
|
||||
'__metadata__':
|
||||
{
|
||||
'vendor': 'FaceFusion',
|
||||
'license': 'OpenRAIL-M',
|
||||
'year': 2024
|
||||
},
|
||||
'hashes':
|
||||
{
|
||||
'fan_68_5':
|
||||
@@ -136,14 +154,14 @@ def detect_with_2dfan4(temp_vision_frame: VisionFrame, bounding_box: BoundingBox
|
||||
model_size = create_static_model_set('full').get('2dfan4').get('size')
|
||||
scale = 195 / numpy.subtract(bounding_box[2:], bounding_box[:2]).max().clip(1, None)
|
||||
translation = (model_size[0] - numpy.add(bounding_box[2:], bounding_box[:2]) * scale) * 0.5
|
||||
rotated_matrix, rotated_size = create_rotated_matrix_and_size(face_angle, model_size)
|
||||
rotation_matrix, rotation_size = create_rotation_matrix_and_size(face_angle, model_size)
|
||||
crop_vision_frame, affine_matrix = warp_face_by_translation(temp_vision_frame, translation, scale, model_size)
|
||||
crop_vision_frame = cv2.warpAffine(crop_vision_frame, rotated_matrix, rotated_size)
|
||||
crop_vision_frame = cv2.warpAffine(crop_vision_frame, rotation_matrix, rotation_size)
|
||||
crop_vision_frame = conditional_optimize_contrast(crop_vision_frame)
|
||||
crop_vision_frame = crop_vision_frame.transpose(2, 0, 1).astype(numpy.float32) / 255.0
|
||||
face_landmark_68, face_heatmap = forward_with_2dfan4(crop_vision_frame)
|
||||
face_landmark_68 = face_landmark_68[:, :, :2][0] / 64 * 256
|
||||
face_landmark_68 = transform_points(face_landmark_68, cv2.invertAffineTransform(rotated_matrix))
|
||||
face_landmark_68 = transform_points(face_landmark_68, cv2.invertAffineTransform(rotation_matrix))
|
||||
face_landmark_68 = transform_points(face_landmark_68, cv2.invertAffineTransform(affine_matrix))
|
||||
face_landmark_score_68 = numpy.amax(face_heatmap, axis = (2, 3))
|
||||
face_landmark_score_68 = numpy.mean(face_landmark_score_68)
|
||||
@@ -155,15 +173,15 @@ def detect_with_peppa_wutz(temp_vision_frame : VisionFrame, bounding_box : Bound
|
||||
model_size = create_static_model_set('full').get('peppa_wutz').get('size')
|
||||
scale = 195 / numpy.subtract(bounding_box[2:], bounding_box[:2]).max().clip(1, None)
|
||||
translation = (model_size[0] - numpy.add(bounding_box[2:], bounding_box[:2]) * scale) * 0.5
|
||||
rotated_matrix, rotated_size = create_rotated_matrix_and_size(face_angle, model_size)
|
||||
rotation_matrix, rotation_size = create_rotation_matrix_and_size(face_angle, model_size)
|
||||
crop_vision_frame, affine_matrix = warp_face_by_translation(temp_vision_frame, translation, scale, model_size)
|
||||
crop_vision_frame = cv2.warpAffine(crop_vision_frame, rotated_matrix, rotated_size)
|
||||
crop_vision_frame = cv2.warpAffine(crop_vision_frame, rotation_matrix, rotation_size)
|
||||
crop_vision_frame = conditional_optimize_contrast(crop_vision_frame)
|
||||
crop_vision_frame = crop_vision_frame.transpose(2, 0, 1).astype(numpy.float32) / 255.0
|
||||
crop_vision_frame = numpy.expand_dims(crop_vision_frame, axis = 0)
|
||||
prediction = forward_with_peppa_wutz(crop_vision_frame)
|
||||
face_landmark_68 = prediction.reshape(-1, 3)[:, :2] / 64 * model_size[0]
|
||||
face_landmark_68 = transform_points(face_landmark_68, cv2.invertAffineTransform(rotated_matrix))
|
||||
face_landmark_68 = transform_points(face_landmark_68, cv2.invertAffineTransform(rotation_matrix))
|
||||
face_landmark_68 = transform_points(face_landmark_68, cv2.invertAffineTransform(affine_matrix))
|
||||
face_landmark_score_68 = prediction.reshape(-1, 3)[:, 2].mean()
|
||||
face_landmark_score_68 = numpy.interp(face_landmark_score_68, [ 0, 0.95 ], [ 0, 1 ])
|
||||
|
||||
+51
-12
@@ -12,12 +12,18 @@ from facefusion.thread_helper import conditional_thread_semaphore
|
||||
from facefusion.types import DownloadScope, DownloadSet, FaceLandmark68, FaceMaskArea, FaceMaskRegion, InferencePool, Mask, ModelSet, Padding, VisionFrame
|
||||
|
||||
|
||||
@lru_cache(maxsize = None)
|
||||
@lru_cache()
|
||||
def create_static_model_set(download_scope : DownloadScope) -> ModelSet:
|
||||
return\
|
||||
{
|
||||
'xseg_1':
|
||||
{
|
||||
'__metadata__':
|
||||
{
|
||||
'vendor': 'DeepFaceLab',
|
||||
'license': 'GPL-3.0',
|
||||
'year': 2021
|
||||
},
|
||||
'hashes':
|
||||
{
|
||||
'face_occluder':
|
||||
@@ -38,6 +44,12 @@ def create_static_model_set(download_scope : DownloadScope) -> ModelSet:
|
||||
},
|
||||
'xseg_2':
|
||||
{
|
||||
'__metadata__':
|
||||
{
|
||||
'vendor': 'DeepFaceLab',
|
||||
'license': 'GPL-3.0',
|
||||
'year': 2021
|
||||
},
|
||||
'hashes':
|
||||
{
|
||||
'face_occluder':
|
||||
@@ -58,6 +70,12 @@ def create_static_model_set(download_scope : DownloadScope) -> ModelSet:
|
||||
},
|
||||
'xseg_3':
|
||||
{
|
||||
'__metadata__':
|
||||
{
|
||||
'vendor': 'DeepFaceLab',
|
||||
'license': 'GPL-3.0',
|
||||
'year': 2021
|
||||
},
|
||||
'hashes':
|
||||
{
|
||||
'face_occluder':
|
||||
@@ -78,6 +96,12 @@ def create_static_model_set(download_scope : DownloadScope) -> ModelSet:
|
||||
},
|
||||
'bisenet_resnet_18':
|
||||
{
|
||||
'__metadata__':
|
||||
{
|
||||
'vendor': 'yakhyo',
|
||||
'license': 'MIT',
|
||||
'year': 2024
|
||||
},
|
||||
'hashes':
|
||||
{
|
||||
'face_parser':
|
||||
@@ -98,6 +122,12 @@ def create_static_model_set(download_scope : DownloadScope) -> ModelSet:
|
||||
},
|
||||
'bisenet_resnet_34':
|
||||
{
|
||||
'__metadata__':
|
||||
{
|
||||
'vendor': 'yakhyo',
|
||||
'license': 'MIT',
|
||||
'year': 2024
|
||||
},
|
||||
'hashes':
|
||||
{
|
||||
'face_parser':
|
||||
@@ -137,7 +167,7 @@ def collect_model_downloads() -> Tuple[DownloadSet, DownloadSet]:
|
||||
model_source_set = {}
|
||||
|
||||
for face_occluder_model in [ 'xseg_1', 'xseg_2', 'xseg_3' ]:
|
||||
if state_manager.get_item('face_occluder_model') == face_occluder_model:
|
||||
if state_manager.get_item('face_occluder_model') in [ 'many', face_occluder_model ]:
|
||||
model_hash_set[face_occluder_model] = model_set.get(face_occluder_model).get('hashes').get('face_occluder')
|
||||
model_source_set[face_occluder_model] = model_set.get(face_occluder_model).get('sources').get('face_occluder')
|
||||
|
||||
@@ -171,14 +201,24 @@ def create_box_mask(crop_vision_frame : VisionFrame, face_mask_blur : float, fac
|
||||
|
||||
|
||||
def create_occlusion_mask(crop_vision_frame : VisionFrame) -> Mask:
|
||||
model_name = state_manager.get_item('face_occluder_model')
|
||||
model_size = create_static_model_set('full').get(model_name).get('size')
|
||||
prepare_vision_frame = cv2.resize(crop_vision_frame, model_size)
|
||||
prepare_vision_frame = numpy.expand_dims(prepare_vision_frame, axis = 0).astype(numpy.float32) / 255.0
|
||||
prepare_vision_frame = prepare_vision_frame.transpose(0, 1, 2, 3)
|
||||
occlusion_mask = forward_occlude_face(prepare_vision_frame)
|
||||
occlusion_mask = occlusion_mask.transpose(0, 1, 2).clip(0, 1).astype(numpy.float32)
|
||||
occlusion_mask = cv2.resize(occlusion_mask, crop_vision_frame.shape[:2][::-1])
|
||||
temp_masks = []
|
||||
|
||||
if state_manager.get_item('face_occluder_model') == 'many':
|
||||
model_names = [ 'xseg_1', 'xseg_2', 'xseg_3' ]
|
||||
else:
|
||||
model_names = [ state_manager.get_item('face_occluder_model') ]
|
||||
|
||||
for model_name in model_names:
|
||||
model_size = create_static_model_set('full').get(model_name).get('size')
|
||||
prepare_vision_frame = cv2.resize(crop_vision_frame, model_size)
|
||||
prepare_vision_frame = numpy.expand_dims(prepare_vision_frame, axis = 0).astype(numpy.float32) / 255.0
|
||||
prepare_vision_frame = prepare_vision_frame.transpose(0, 1, 2, 3)
|
||||
temp_mask = forward_occlude_face(prepare_vision_frame, model_name)
|
||||
temp_mask = temp_mask.transpose(0, 1, 2).clip(0, 1).astype(numpy.float32)
|
||||
temp_mask = cv2.resize(temp_mask, crop_vision_frame.shape[:2][::-1])
|
||||
temp_masks.append(temp_mask)
|
||||
|
||||
occlusion_mask = numpy.minimum.reduce(temp_masks)
|
||||
occlusion_mask = (cv2.GaussianBlur(occlusion_mask.clip(0, 1), (0, 0), 5).clip(0.5, 1) - 0.5) * 2
|
||||
return occlusion_mask
|
||||
|
||||
@@ -214,8 +254,7 @@ def create_region_mask(crop_vision_frame : VisionFrame, face_mask_regions : List
|
||||
return region_mask
|
||||
|
||||
|
||||
def forward_occlude_face(prepare_vision_frame : VisionFrame) -> Mask:
|
||||
model_name = state_manager.get_item('face_occluder_model')
|
||||
def forward_occlude_face(prepare_vision_frame : VisionFrame, model_name : str) -> Mask:
|
||||
face_occluder = get_inference_pool().get(model_name)
|
||||
|
||||
with conditional_thread_semaphore():
|
||||
|
||||
@@ -11,12 +11,18 @@ from facefusion.thread_helper import conditional_thread_semaphore
|
||||
from facefusion.types import DownloadScope, Embedding, FaceLandmark5, InferencePool, ModelOptions, ModelSet, VisionFrame
|
||||
|
||||
|
||||
@lru_cache(maxsize = None)
|
||||
@lru_cache()
|
||||
def create_static_model_set(download_scope : DownloadScope) -> ModelSet:
|
||||
return\
|
||||
{
|
||||
'arcface':
|
||||
{
|
||||
'__metadata__':
|
||||
{
|
||||
'vendor': 'InsightFace',
|
||||
'license': 'Non-Commercial',
|
||||
'year': 2018
|
||||
},
|
||||
'hashes':
|
||||
{
|
||||
'face_recognizer':
|
||||
@@ -62,26 +68,26 @@ def pre_check() -> bool:
|
||||
return conditional_download_hashes(model_hash_set) and conditional_download_sources(model_source_set)
|
||||
|
||||
|
||||
def calc_embedding(temp_vision_frame : VisionFrame, face_landmark_5 : FaceLandmark5) -> Tuple[Embedding, Embedding]:
|
||||
def calculate_face_embedding(temp_vision_frame : VisionFrame, face_landmark_5 : FaceLandmark5) -> Tuple[Embedding, Embedding]:
|
||||
model_template = get_model_options().get('template')
|
||||
model_size = get_model_options().get('size')
|
||||
crop_vision_frame, matrix = warp_face_by_face_landmark_5(temp_vision_frame, face_landmark_5, model_template, model_size)
|
||||
crop_vision_frame = crop_vision_frame / 127.5 - 1
|
||||
crop_vision_frame = crop_vision_frame[:, :, ::-1].transpose(2, 0, 1).astype(numpy.float32)
|
||||
crop_vision_frame = numpy.expand_dims(crop_vision_frame, axis = 0)
|
||||
embedding = forward(crop_vision_frame)
|
||||
embedding = embedding.ravel()
|
||||
normed_embedding = embedding / numpy.linalg.norm(embedding)
|
||||
return embedding, normed_embedding
|
||||
face_embedding = forward(crop_vision_frame)
|
||||
face_embedding = face_embedding.ravel()
|
||||
face_embedding_norm = face_embedding / numpy.linalg.norm(face_embedding)
|
||||
return face_embedding, face_embedding_norm
|
||||
|
||||
|
||||
def forward(crop_vision_frame : VisionFrame) -> Embedding:
|
||||
face_recognizer = get_inference_pool().get('face_recognizer')
|
||||
|
||||
with conditional_thread_semaphore():
|
||||
embedding = face_recognizer.run(None,
|
||||
face_embedding = face_recognizer.run(None,
|
||||
{
|
||||
'input': crop_vision_frame
|
||||
})[0]
|
||||
|
||||
return embedding
|
||||
return face_embedding
|
||||
|
||||
+37
-15
@@ -3,31 +3,53 @@ from typing import List
|
||||
import numpy
|
||||
|
||||
from facefusion import state_manager
|
||||
from facefusion.types import Face, FaceSelectorOrder, FaceSet, Gender, Race, Score
|
||||
from facefusion.face_analyser import get_many_faces, get_one_face
|
||||
from facefusion.types import Face, FaceSelectorOrder, Gender, Race, Score, VisionFrame
|
||||
|
||||
|
||||
def find_similar_faces(faces : List[Face], reference_faces : FaceSet, face_distance : float) -> List[Face]:
|
||||
similar_faces : List[Face] = []
|
||||
def select_faces(reference_vision_frame : VisionFrame, target_vision_frame : VisionFrame) -> List[Face]:
|
||||
target_faces = get_many_faces([ target_vision_frame ])
|
||||
|
||||
if faces and reference_faces:
|
||||
for reference_set in reference_faces:
|
||||
if not similar_faces:
|
||||
for reference_face in reference_faces[reference_set]:
|
||||
for face in faces:
|
||||
if compare_faces(face, reference_face, face_distance):
|
||||
similar_faces.append(face)
|
||||
return similar_faces
|
||||
if state_manager.get_item('face_selector_mode') == 'many':
|
||||
return sort_and_filter_faces(target_faces)
|
||||
|
||||
if state_manager.get_item('face_selector_mode') == 'one':
|
||||
target_face = get_one_face(sort_and_filter_faces(target_faces))
|
||||
if target_face:
|
||||
return [ target_face ]
|
||||
|
||||
if state_manager.get_item('face_selector_mode') == 'reference':
|
||||
reference_faces = get_many_faces([ reference_vision_frame ])
|
||||
reference_faces = sort_and_filter_faces(reference_faces)
|
||||
reference_face = get_one_face(reference_faces, state_manager.get_item('reference_face_position'))
|
||||
if reference_face:
|
||||
match_faces = find_match_faces([ reference_face ], target_faces, state_manager.get_item('reference_face_distance'))
|
||||
return match_faces
|
||||
|
||||
return []
|
||||
|
||||
|
||||
def find_match_faces(reference_faces : List[Face], target_faces : List[Face], face_distance : float) -> List[Face]:
|
||||
match_faces : List[Face] = []
|
||||
|
||||
for reference_face in reference_faces:
|
||||
if reference_face:
|
||||
for index, target_face in enumerate(target_faces):
|
||||
if compare_faces(target_face, reference_face, face_distance):
|
||||
match_faces.append(target_faces[index])
|
||||
|
||||
return match_faces
|
||||
|
||||
|
||||
def compare_faces(face : Face, reference_face : Face, face_distance : float) -> bool:
|
||||
current_face_distance = calc_face_distance(face, reference_face)
|
||||
current_face_distance = calculate_face_distance(face, reference_face)
|
||||
current_face_distance = float(numpy.interp(current_face_distance, [ 0, 2 ], [ 0, 1 ]))
|
||||
return current_face_distance < face_distance
|
||||
|
||||
|
||||
def calc_face_distance(face : Face, reference_face : Face) -> float:
|
||||
if hasattr(face, 'normed_embedding') and hasattr(reference_face, 'normed_embedding'):
|
||||
return 1 - numpy.dot(face.normed_embedding, reference_face.normed_embedding)
|
||||
def calculate_face_distance(face : Face, reference_face : Face) -> float:
|
||||
if hasattr(face, 'embedding_norm') and hasattr(reference_face, 'embedding_norm'):
|
||||
return 1 - numpy.dot(face.embedding_norm, reference_face.embedding_norm)
|
||||
return 0
|
||||
|
||||
|
||||
|
||||
@@ -1,12 +1,11 @@
|
||||
from typing import List, Optional
|
||||
|
||||
from facefusion.hash_helper import create_hash
|
||||
from facefusion.types import Face, FaceSet, FaceStore, VisionFrame
|
||||
from facefusion.types import Face, FaceStore, VisionFrame
|
||||
|
||||
FACE_STORE : FaceStore =\
|
||||
{
|
||||
'static_faces': {},
|
||||
'reference_faces': {}
|
||||
'static_faces': {}
|
||||
}
|
||||
|
||||
|
||||
@@ -27,17 +26,3 @@ def set_static_faces(vision_frame : VisionFrame, faces : List[Face]) -> None:
|
||||
|
||||
def clear_static_faces() -> None:
|
||||
FACE_STORE['static_faces'].clear()
|
||||
|
||||
|
||||
def get_reference_faces() -> Optional[FaceSet]:
|
||||
return FACE_STORE.get('reference_faces')
|
||||
|
||||
|
||||
def append_reference_face(name : str, face : Face) -> None:
|
||||
if name not in FACE_STORE.get('reference_faces'):
|
||||
FACE_STORE['reference_faces'][name] = []
|
||||
FACE_STORE['reference_faces'][name].append(face)
|
||||
|
||||
|
||||
def clear_reference_faces() -> None:
|
||||
FACE_STORE['reference_faces'].clear()
|
||||
|
||||
+28
-23
@@ -7,14 +7,14 @@ from typing import List, Optional, cast
|
||||
from tqdm import tqdm
|
||||
|
||||
import facefusion.choices
|
||||
from facefusion import ffmpeg_builder, logger, process_manager, state_manager, wording
|
||||
from facefusion import ffmpeg_builder, logger, process_manager, state_manager, translator
|
||||
from facefusion.filesystem import get_file_format, remove_file
|
||||
from facefusion.temp_helper import get_temp_file_path, get_temp_frames_pattern
|
||||
from facefusion.types import AudioBuffer, AudioEncoder, Commands, EncoderSet, Fps, UpdateProgress, VideoEncoder, VideoFormat
|
||||
from facefusion.vision import detect_video_duration, detect_video_fps, predict_video_frame_total
|
||||
from facefusion.types import AudioBuffer, AudioEncoder, Command, EncoderSet, Fps, Resolution, UpdateProgress, VideoEncoder, VideoFormat
|
||||
from facefusion.vision import detect_video_duration, detect_video_fps, pack_resolution, predict_video_frame_total
|
||||
|
||||
|
||||
def run_ffmpeg_with_progress(commands : Commands, update_progress : UpdateProgress) -> subprocess.Popen[bytes]:
|
||||
def run_ffmpeg_with_progress(commands : List[Command], update_progress : UpdateProgress) -> subprocess.Popen[bytes]:
|
||||
log_level = state_manager.get_item('log_level')
|
||||
commands.extend(ffmpeg_builder.set_progress())
|
||||
commands.extend(ffmpeg_builder.cast_stream())
|
||||
@@ -23,8 +23,10 @@ def run_ffmpeg_with_progress(commands : Commands, update_progress : UpdateProgre
|
||||
|
||||
while process_manager.is_processing():
|
||||
try:
|
||||
|
||||
while __line__ := process.stdout.readline().decode().lower():
|
||||
if process_manager.is_stopping():
|
||||
process.terminate()
|
||||
|
||||
if 'frame=' in __line__:
|
||||
_, frame_number = __line__.split('frame=')
|
||||
update_progress(int(frame_number))
|
||||
@@ -36,8 +38,6 @@ def run_ffmpeg_with_progress(commands : Commands, update_progress : UpdateProgre
|
||||
continue
|
||||
return process
|
||||
|
||||
if process_manager.is_stopping():
|
||||
process.terminate()
|
||||
return process
|
||||
|
||||
|
||||
@@ -45,7 +45,7 @@ def update_progress(progress : tqdm, frame_number : int) -> None:
|
||||
progress.update(frame_number - progress.n)
|
||||
|
||||
|
||||
def run_ffmpeg(commands : Commands) -> subprocess.Popen[bytes]:
|
||||
def run_ffmpeg(commands : List[Command]) -> subprocess.Popen[bytes]:
|
||||
log_level = state_manager.get_item('log_level')
|
||||
commands = ffmpeg_builder.run(commands)
|
||||
process = subprocess.Popen(commands, stderr = subprocess.PIPE, stdout = subprocess.PIPE)
|
||||
@@ -61,10 +61,11 @@ def run_ffmpeg(commands : Commands) -> subprocess.Popen[bytes]:
|
||||
|
||||
if process_manager.is_stopping():
|
||||
process.terminate()
|
||||
|
||||
return process
|
||||
|
||||
|
||||
def open_ffmpeg(commands : Commands) -> subprocess.Popen[bytes]:
|
||||
def open_ffmpeg(commands : List[Command]) -> subprocess.Popen[bytes]:
|
||||
commands = ffmpeg_builder.run(commands)
|
||||
return subprocess.Popen(commands, stdin = subprocess.PIPE, stdout = subprocess.PIPE)
|
||||
|
||||
@@ -106,40 +107,40 @@ def get_available_encoder_set() -> EncoderSet:
|
||||
return available_encoder_set
|
||||
|
||||
|
||||
def extract_frames(target_path : str, temp_video_resolution : str, temp_video_fps : Fps, trim_frame_start : int, trim_frame_end : int) -> bool:
|
||||
def extract_frames(target_path : str, temp_video_resolution : Resolution, temp_video_fps : Fps, trim_frame_start : int, trim_frame_end : int) -> bool:
|
||||
extract_frame_total = predict_video_frame_total(target_path, temp_video_fps, trim_frame_start, trim_frame_end)
|
||||
temp_frames_pattern = get_temp_frames_pattern(target_path, '%08d')
|
||||
commands = ffmpeg_builder.chain(
|
||||
ffmpeg_builder.set_input(target_path),
|
||||
ffmpeg_builder.set_media_resolution(temp_video_resolution),
|
||||
ffmpeg_builder.set_media_resolution(pack_resolution(temp_video_resolution)),
|
||||
ffmpeg_builder.set_frame_quality(0),
|
||||
ffmpeg_builder.select_frame_range(trim_frame_start, trim_frame_end, temp_video_fps),
|
||||
ffmpeg_builder.prevent_frame_drop(),
|
||||
ffmpeg_builder.set_output(temp_frames_pattern)
|
||||
)
|
||||
|
||||
with tqdm(total = extract_frame_total, desc = wording.get('extracting'), unit = 'frame', ascii = ' =', disable = state_manager.get_item('log_level') in [ 'warn', 'error' ]) as progress:
|
||||
with tqdm(total = extract_frame_total, desc = translator.get('extracting'), unit = 'frame', ascii = ' =', disable = state_manager.get_item('log_level') in [ 'warn', 'error' ]) as progress:
|
||||
process = run_ffmpeg_with_progress(commands, partial(update_progress, progress))
|
||||
return process.returncode == 0
|
||||
|
||||
|
||||
def copy_image(target_path : str, temp_image_resolution : str) -> bool:
|
||||
def copy_image(target_path : str, temp_image_resolution : Resolution) -> bool:
|
||||
temp_image_path = get_temp_file_path(target_path)
|
||||
commands = ffmpeg_builder.chain(
|
||||
ffmpeg_builder.set_input(target_path),
|
||||
ffmpeg_builder.set_media_resolution(temp_image_resolution),
|
||||
ffmpeg_builder.set_media_resolution(pack_resolution(temp_image_resolution)),
|
||||
ffmpeg_builder.set_image_quality(target_path, 100),
|
||||
ffmpeg_builder.force_output(temp_image_path)
|
||||
)
|
||||
return run_ffmpeg(commands).returncode == 0
|
||||
|
||||
|
||||
def finalize_image(target_path : str, output_path : str, output_image_resolution : str) -> bool:
|
||||
def finalize_image(target_path : str, output_path : str, output_image_resolution : Resolution) -> bool:
|
||||
output_image_quality = state_manager.get_item('output_image_quality')
|
||||
temp_image_path = get_temp_file_path(target_path)
|
||||
commands = ffmpeg_builder.chain(
|
||||
ffmpeg_builder.set_input(temp_image_path),
|
||||
ffmpeg_builder.set_media_resolution(output_image_resolution),
|
||||
ffmpeg_builder.set_media_resolution(pack_resolution(output_image_resolution)),
|
||||
ffmpeg_builder.set_image_quality(target_path, output_image_quality),
|
||||
ffmpeg_builder.force_output(output_path)
|
||||
)
|
||||
@@ -211,7 +212,7 @@ def replace_audio(target_path : str, audio_path : str, output_path : str) -> boo
|
||||
return run_ffmpeg(commands).returncode == 0
|
||||
|
||||
|
||||
def merge_video(target_path : str, temp_video_fps : Fps, output_video_resolution : str, output_video_fps : Fps, trim_frame_start : int, trim_frame_end : int) -> bool:
|
||||
def merge_video(target_path : str, temp_video_fps : Fps, output_video_resolution : Resolution, output_video_fps : Fps, trim_frame_start : int, trim_frame_end : int) -> bool:
|
||||
output_video_encoder = state_manager.get_item('output_video_encoder')
|
||||
output_video_quality = state_manager.get_item('output_video_quality')
|
||||
output_video_preset = state_manager.get_item('output_video_preset')
|
||||
@@ -224,17 +225,19 @@ def merge_video(target_path : str, temp_video_fps : Fps, output_video_resolution
|
||||
commands = ffmpeg_builder.chain(
|
||||
ffmpeg_builder.set_input_fps(temp_video_fps),
|
||||
ffmpeg_builder.set_input(temp_frames_pattern),
|
||||
ffmpeg_builder.set_media_resolution(output_video_resolution),
|
||||
ffmpeg_builder.set_media_resolution(pack_resolution(output_video_resolution)),
|
||||
ffmpeg_builder.set_video_encoder(output_video_encoder),
|
||||
ffmpeg_builder.set_video_quality(output_video_encoder, output_video_quality),
|
||||
ffmpeg_builder.set_video_preset(output_video_encoder, output_video_preset),
|
||||
ffmpeg_builder.set_video_fps(output_video_fps),
|
||||
ffmpeg_builder.concat(
|
||||
ffmpeg_builder.set_video_fps(output_video_fps),
|
||||
ffmpeg_builder.keep_video_alpha(output_video_encoder)
|
||||
),
|
||||
ffmpeg_builder.set_pixel_format(output_video_encoder),
|
||||
ffmpeg_builder.set_video_colorspace('bt709'),
|
||||
ffmpeg_builder.force_output(temp_video_path)
|
||||
)
|
||||
|
||||
with tqdm(total = merge_frame_total, desc = wording.get('merging'), unit = 'frame', ascii = ' =', disable = state_manager.get_item('log_level') in [ 'warn', 'error' ]) as progress:
|
||||
with tqdm(total = merge_frame_total, desc = translator.get('merging'), unit = 'frame', ascii = ' =', disable = state_manager.get_item('log_level') in [ 'warn', 'error' ]) as progress:
|
||||
process = run_ffmpeg_with_progress(commands, partial(update_progress, progress))
|
||||
return process.returncode == 0
|
||||
|
||||
@@ -265,17 +268,19 @@ def concat_video(output_path : str, temp_output_paths : List[str]) -> bool:
|
||||
def fix_audio_encoder(video_format : VideoFormat, audio_encoder : AudioEncoder) -> AudioEncoder:
|
||||
if video_format == 'avi' and audio_encoder == 'libopus':
|
||||
return 'aac'
|
||||
if video_format == 'm4v':
|
||||
if video_format in [ 'm4v', 'mpeg', 'wmv' ]:
|
||||
return 'aac'
|
||||
if video_format == 'mov' and audio_encoder in [ 'flac', 'libopus' ]:
|
||||
return 'aac'
|
||||
if video_format == 'mxf':
|
||||
return 'pcm_s16le'
|
||||
if video_format == 'webm':
|
||||
return 'libopus'
|
||||
return audio_encoder
|
||||
|
||||
|
||||
def fix_video_encoder(video_format : VideoFormat, video_encoder : VideoEncoder) -> VideoEncoder:
|
||||
if video_format == 'm4v':
|
||||
if video_format in [ 'm4v', 'mpeg', 'mxf', 'wmv' ]:
|
||||
return 'libx264'
|
||||
if video_format in [ 'mkv', 'mp4' ] and video_encoder == 'rawvideo':
|
||||
return 'libx264'
|
||||
|
||||
@@ -1,54 +1,69 @@
|
||||
import itertools
|
||||
import shutil
|
||||
from typing import Optional
|
||||
from typing import List, Optional
|
||||
|
||||
import numpy
|
||||
|
||||
from facefusion.filesystem import get_file_format
|
||||
from facefusion.types import AudioEncoder, Commands, Duration, Fps, StreamMode, VideoEncoder, VideoPreset
|
||||
from facefusion.types import AudioEncoder, Command, CommandSet, Duration, Fps, StreamMode, VideoEncoder, VideoPreset
|
||||
|
||||
|
||||
def run(commands : Commands) -> Commands:
|
||||
def run(commands : List[Command]) -> List[Command]:
|
||||
return [ shutil.which('ffmpeg'), '-loglevel', 'error' ] + commands
|
||||
|
||||
|
||||
def chain(*commands : Commands) -> Commands:
|
||||
def chain(*commands : List[Command]) -> List[Command]:
|
||||
return list(itertools.chain(*commands))
|
||||
|
||||
|
||||
def get_encoders() -> Commands:
|
||||
def concat(*__commands__ : List[Command]) -> List[Command]:
|
||||
commands = []
|
||||
command_set : CommandSet = {}
|
||||
|
||||
for command in __commands__:
|
||||
for argument, value in zip(command[::2], command[1::2]):
|
||||
command_set.setdefault(argument, []).append(value)
|
||||
|
||||
for argument, values in command_set.items():
|
||||
commands.append(argument)
|
||||
commands.append(','.join(values))
|
||||
|
||||
return commands
|
||||
|
||||
|
||||
def get_encoders() -> List[Command]:
|
||||
return [ '-encoders' ]
|
||||
|
||||
|
||||
def set_hardware_accelerator(value : str) -> Commands:
|
||||
def set_hardware_accelerator(value : str) -> List[Command]:
|
||||
return [ '-hwaccel', value ]
|
||||
|
||||
|
||||
def set_progress() -> Commands:
|
||||
def set_progress() -> List[Command]:
|
||||
return [ '-progress' ]
|
||||
|
||||
|
||||
def set_input(input_path : str) -> Commands:
|
||||
def set_input(input_path : str) -> List[Command]:
|
||||
return [ '-i', input_path ]
|
||||
|
||||
|
||||
def set_input_fps(input_fps : Fps) -> Commands:
|
||||
def set_input_fps(input_fps : Fps) -> List[Command]:
|
||||
return [ '-r', str(input_fps)]
|
||||
|
||||
|
||||
def set_output(output_path : str) -> Commands:
|
||||
def set_output(output_path : str) -> List[Command]:
|
||||
return [ output_path ]
|
||||
|
||||
|
||||
def force_output(output_path : str) -> Commands:
|
||||
def force_output(output_path : str) -> List[Command]:
|
||||
return [ '-y', output_path ]
|
||||
|
||||
|
||||
def cast_stream() -> Commands:
|
||||
def cast_stream() -> List[Command]:
|
||||
return [ '-' ]
|
||||
|
||||
|
||||
def set_stream_mode(stream_mode : StreamMode) -> Commands:
|
||||
def set_stream_mode(stream_mode : StreamMode) -> List[Command]:
|
||||
if stream_mode == 'udp':
|
||||
return [ '-f', 'mpegts' ]
|
||||
if stream_mode == 'v4l2':
|
||||
@@ -56,25 +71,27 @@ def set_stream_mode(stream_mode : StreamMode) -> Commands:
|
||||
return []
|
||||
|
||||
|
||||
def set_stream_quality(stream_quality : int) -> Commands:
|
||||
def set_stream_quality(stream_quality : int) -> List[Command]:
|
||||
return [ '-b:v', str(stream_quality) + 'k' ]
|
||||
|
||||
|
||||
def unsafe_concat() -> Commands:
|
||||
def unsafe_concat() -> List[Command]:
|
||||
return [ '-f', 'concat', '-safe', '0' ]
|
||||
|
||||
|
||||
def set_pixel_format(video_encoder : VideoEncoder) -> Commands:
|
||||
def set_pixel_format(video_encoder : VideoEncoder) -> List[Command]:
|
||||
if video_encoder == 'rawvideo':
|
||||
return [ '-pix_fmt', 'rgb24' ]
|
||||
if video_encoder == 'libvpx-vp9':
|
||||
return [ '-pix_fmt', 'yuva420p' ]
|
||||
return [ '-pix_fmt', 'yuv420p' ]
|
||||
|
||||
|
||||
def set_frame_quality(frame_quality : int) -> Commands:
|
||||
def set_frame_quality(frame_quality : int) -> List[Command]:
|
||||
return [ '-q:v', str(frame_quality) ]
|
||||
|
||||
|
||||
def select_frame_range(frame_start : int, frame_end : int, video_fps : Fps) -> Commands:
|
||||
def select_frame_range(frame_start : int, frame_end : int, video_fps : Fps) -> List[Command]:
|
||||
if isinstance(frame_start, int) and isinstance(frame_end, int):
|
||||
return [ '-vf', 'trim=start_frame=' + str(frame_start) + ':end_frame=' + str(frame_end) + ',fps=' + str(video_fps) ]
|
||||
if isinstance(frame_start, int):
|
||||
@@ -84,11 +101,11 @@ def select_frame_range(frame_start : int, frame_end : int, video_fps : Fps) -> C
|
||||
return [ '-vf', 'fps=' + str(video_fps) ]
|
||||
|
||||
|
||||
def prevent_frame_drop() -> Commands:
|
||||
def prevent_frame_drop() -> List[Command]:
|
||||
return [ '-vsync', '0' ]
|
||||
|
||||
|
||||
def select_media_range(frame_start : int, frame_end : int, media_fps : Fps) -> Commands:
|
||||
def select_media_range(frame_start : int, frame_end : int, media_fps : Fps) -> List[Command]:
|
||||
commands = []
|
||||
|
||||
if isinstance(frame_start, int):
|
||||
@@ -98,35 +115,35 @@ def select_media_range(frame_start : int, frame_end : int, media_fps : Fps) -> C
|
||||
return commands
|
||||
|
||||
|
||||
def select_media_stream(media_stream : str) -> Commands:
|
||||
def select_media_stream(media_stream : str) -> List[Command]:
|
||||
return [ '-map', media_stream ]
|
||||
|
||||
|
||||
def set_media_resolution(video_resolution : str) -> Commands:
|
||||
def set_media_resolution(video_resolution : str) -> List[Command]:
|
||||
return [ '-s', video_resolution ]
|
||||
|
||||
|
||||
def set_image_quality(image_path : str, image_quality : int) -> Commands:
|
||||
def set_image_quality(image_path : str, image_quality : int) -> List[Command]:
|
||||
if get_file_format(image_path) == 'webp':
|
||||
image_compression = image_quality
|
||||
else:
|
||||
image_compression = round(31 - (image_quality * 0.31))
|
||||
return [ '-q:v', str(image_quality) ]
|
||||
|
||||
image_compression = round(31 - (image_quality * 0.31))
|
||||
return [ '-q:v', str(image_compression) ]
|
||||
|
||||
|
||||
def set_audio_encoder(audio_codec : str) -> Commands:
|
||||
def set_audio_encoder(audio_codec : str) -> List[Command]:
|
||||
return [ '-c:a', audio_codec ]
|
||||
|
||||
|
||||
def copy_audio_encoder() -> Commands:
|
||||
def copy_audio_encoder() -> List[Command]:
|
||||
return set_audio_encoder('copy')
|
||||
|
||||
|
||||
def set_audio_sample_rate(audio_sample_rate : int) -> Commands:
|
||||
def set_audio_sample_rate(audio_sample_rate : int) -> List[Command]:
|
||||
return [ '-ar', str(audio_sample_rate) ]
|
||||
|
||||
|
||||
def set_audio_sample_size(audio_sample_size : int) -> Commands:
|
||||
def set_audio_sample_size(audio_sample_size : int) -> List[Command]:
|
||||
if audio_sample_size == 16:
|
||||
return [ '-f', 's16le' ]
|
||||
if audio_sample_size == 32:
|
||||
@@ -134,62 +151,62 @@ def set_audio_sample_size(audio_sample_size : int) -> Commands:
|
||||
return []
|
||||
|
||||
|
||||
def set_audio_channel_total(audio_channel_total : int) -> Commands:
|
||||
def set_audio_channel_total(audio_channel_total : int) -> List[Command]:
|
||||
return [ '-ac', str(audio_channel_total) ]
|
||||
|
||||
|
||||
def set_audio_quality(audio_encoder : AudioEncoder, audio_quality : int) -> Commands:
|
||||
def set_audio_quality(audio_encoder : AudioEncoder, audio_quality : int) -> List[Command]:
|
||||
if audio_encoder == 'aac':
|
||||
audio_compression = round(numpy.interp(audio_quality, [ 0, 100 ], [ 0.1, 2.0 ]), 1)
|
||||
audio_compression = numpy.round(numpy.interp(audio_quality, [ 0, 100 ], [ 0.1, 2.0 ]), 1).astype(float).item()
|
||||
return [ '-q:a', str(audio_compression) ]
|
||||
if audio_encoder == 'libmp3lame':
|
||||
audio_compression = round(numpy.interp(audio_quality, [ 0, 100 ], [ 9, 0 ]))
|
||||
audio_compression = numpy.round(numpy.interp(audio_quality, [ 0, 100 ], [ 9, 0 ])).astype(int).item()
|
||||
return [ '-q:a', str(audio_compression) ]
|
||||
if audio_encoder == 'libopus':
|
||||
audio_bit_rate = round(numpy.interp(audio_quality, [ 0, 100 ], [ 64, 256 ]))
|
||||
audio_bit_rate = numpy.round(numpy.interp(audio_quality, [ 0, 100 ], [ 64, 256 ])).astype(int).item()
|
||||
return [ '-b:a', str(audio_bit_rate) + 'k' ]
|
||||
if audio_encoder == 'libvorbis':
|
||||
audio_compression = round(numpy.interp(audio_quality, [ 0, 100 ], [ -1, 10 ]), 1)
|
||||
audio_compression = numpy.round(numpy.interp(audio_quality, [ 0, 100 ], [ -1, 10 ]), 1).astype(float).item()
|
||||
return [ '-q:a', str(audio_compression) ]
|
||||
return []
|
||||
|
||||
|
||||
def set_audio_volume(audio_volume : int) -> Commands:
|
||||
def set_audio_volume(audio_volume : int) -> List[Command]:
|
||||
return [ '-filter:a', 'volume=' + str(audio_volume / 100) ]
|
||||
|
||||
|
||||
def set_video_encoder(video_encoder : str) -> Commands:
|
||||
def set_video_encoder(video_encoder : str) -> List[Command]:
|
||||
return [ '-c:v', video_encoder ]
|
||||
|
||||
|
||||
def copy_video_encoder() -> Commands:
|
||||
def copy_video_encoder() -> List[Command]:
|
||||
return set_video_encoder('copy')
|
||||
|
||||
|
||||
def set_video_quality(video_encoder : VideoEncoder, video_quality : int) -> Commands:
|
||||
if video_encoder in [ 'libx264', 'libx265' ]:
|
||||
video_compression = round(numpy.interp(video_quality, [ 0, 100 ], [ 51, 0 ]))
|
||||
def set_video_quality(video_encoder : VideoEncoder, video_quality : int) -> List[Command]:
|
||||
if video_encoder in [ 'libx264', 'libx264rgb', 'libx265' ]:
|
||||
video_compression = numpy.round(numpy.interp(video_quality, [ 0, 100 ], [ 51, 0 ])).astype(int).item()
|
||||
return [ '-crf', str(video_compression) ]
|
||||
if video_encoder == 'libvpx-vp9':
|
||||
video_compression = round(numpy.interp(video_quality, [ 0, 100 ], [ 63, 0 ]))
|
||||
video_compression = numpy.round(numpy.interp(video_quality, [ 0, 100 ], [ 63, 0 ])).astype(int).item()
|
||||
return [ '-crf', str(video_compression) ]
|
||||
if video_encoder in [ 'h264_nvenc', 'hevc_nvenc' ]:
|
||||
video_compression = round(numpy.interp(video_quality, [ 0, 100 ], [ 51, 0 ]))
|
||||
video_compression = numpy.round(numpy.interp(video_quality, [ 0, 100 ], [ 51, 0 ])).astype(int).item()
|
||||
return [ '-cq', str(video_compression) ]
|
||||
if video_encoder in [ 'h264_amf', 'hevc_amf' ]:
|
||||
video_compression = round(numpy.interp(video_quality, [ 0, 100 ], [ 51, 0 ]))
|
||||
video_compression = numpy.round(numpy.interp(video_quality, [ 0, 100 ], [ 51, 0 ])).astype(int).item()
|
||||
return [ '-qp_i', str(video_compression), '-qp_p', str(video_compression), '-qp_b', str(video_compression) ]
|
||||
if video_encoder in [ 'h264_qsv', 'hevc_qsv' ]:
|
||||
video_compression = round(numpy.interp(video_quality, [ 0, 100 ], [ 51, 0 ]))
|
||||
video_compression = numpy.round(numpy.interp(video_quality, [ 0, 100 ], [ 51, 0 ])).astype(int).item()
|
||||
return [ '-qp', str(video_compression) ]
|
||||
if video_encoder in [ 'h264_videotoolbox', 'hevc_videotoolbox' ]:
|
||||
video_bit_rate = round(numpy.interp(video_quality, [ 0, 100 ], [ 1024, 50512 ]))
|
||||
video_bit_rate = numpy.round(numpy.interp(video_quality, [ 0, 100 ], [ 1024, 50512 ])).astype(int).item()
|
||||
return [ '-b:v', str(video_bit_rate) + 'k' ]
|
||||
return []
|
||||
|
||||
|
||||
def set_video_preset(video_encoder : VideoEncoder, video_preset : VideoPreset) -> Commands:
|
||||
if video_encoder in [ 'libx264', 'libx265' ]:
|
||||
def set_video_preset(video_encoder : VideoEncoder, video_preset : VideoPreset) -> List[Command]:
|
||||
if video_encoder in [ 'libx264', 'libx264rgb', 'libx265' ]:
|
||||
return [ '-preset', video_preset ]
|
||||
if video_encoder in [ 'h264_nvenc', 'hevc_nvenc' ]:
|
||||
return [ '-preset', map_nvenc_preset(video_preset) ]
|
||||
@@ -200,23 +217,25 @@ def set_video_preset(video_encoder : VideoEncoder, video_preset : VideoPreset) -
|
||||
return []
|
||||
|
||||
|
||||
def set_video_colorspace(video_colorspace : str) -> Commands:
|
||||
return [ '-colorspace', video_colorspace ]
|
||||
def set_video_fps(video_fps : Fps) -> List[Command]:
|
||||
return [ '-vf', 'fps=' + str(video_fps) ]
|
||||
|
||||
|
||||
def set_video_fps(video_fps : Fps) -> Commands:
|
||||
return [ '-vf', 'framerate=fps=' + str(video_fps) ]
|
||||
|
||||
|
||||
def set_video_duration(video_duration : Duration) -> Commands:
|
||||
def set_video_duration(video_duration : Duration) -> List[Command]:
|
||||
return [ '-t', str(video_duration) ]
|
||||
|
||||
|
||||
def capture_video() -> Commands:
|
||||
def keep_video_alpha(video_encoder : VideoEncoder) -> List[Command]:
|
||||
if video_encoder == 'libvpx-vp9':
|
||||
return [ '-vf', 'format=yuva420p' ]
|
||||
return []
|
||||
|
||||
|
||||
def capture_video() -> List[Command]:
|
||||
return [ '-f', 'rawvideo', '-pix_fmt', 'rgb24' ]
|
||||
|
||||
|
||||
def ignore_video_stream() -> Commands:
|
||||
def ignore_video_stream() -> List[Command]:
|
||||
return [ '-vn' ]
|
||||
|
||||
|
||||
|
||||
@@ -36,6 +36,8 @@ def get_file_format(file_path : str) -> Optional[str]:
|
||||
return 'jpeg'
|
||||
if file_extension == '.tif':
|
||||
return 'tiff'
|
||||
if file_extension == '.mpg':
|
||||
return 'mpeg'
|
||||
return file_extension.lstrip('.')
|
||||
return None
|
||||
|
||||
@@ -99,7 +101,7 @@ def has_video(video_paths : List[str]) -> bool:
|
||||
|
||||
def are_videos(video_paths : List[str]) -> bool:
|
||||
if video_paths:
|
||||
return any(map(is_video, video_paths))
|
||||
return all(map(is_video, video_paths))
|
||||
return False
|
||||
|
||||
|
||||
|
||||
@@ -1,13 +1,17 @@
|
||||
import importlib
|
||||
from time import sleep
|
||||
import random
|
||||
from time import sleep, time
|
||||
from typing import List
|
||||
|
||||
from onnxruntime import InferenceSession
|
||||
|
||||
from facefusion import process_manager, state_manager
|
||||
from facefusion import logger, process_manager, state_manager, translator
|
||||
from facefusion.app_context import detect_app_context
|
||||
from facefusion.execution import create_inference_session_providers
|
||||
from facefusion.filesystem import is_file
|
||||
from facefusion.common_helper import is_windows
|
||||
from facefusion.execution import create_inference_session_providers, has_execution_provider
|
||||
from facefusion.exit_helper import fatal_exit
|
||||
from facefusion.filesystem import get_file_name, is_file
|
||||
from facefusion.time_helper import calculate_end_time
|
||||
from facefusion.types import DownloadSet, ExecutionProvider, InferencePool, InferencePoolSet
|
||||
|
||||
INFERENCE_POOL_SET : InferencePoolSet =\
|
||||
@@ -20,22 +24,25 @@ INFERENCE_POOL_SET : InferencePoolSet =\
|
||||
def get_inference_pool(module_name : str, model_names : List[str], model_source_set : DownloadSet) -> InferencePool:
|
||||
while process_manager.is_checking():
|
||||
sleep(0.5)
|
||||
execution_device_id = state_manager.get_item('execution_device_id')
|
||||
execution_device_ids = state_manager.get_item('execution_device_ids')
|
||||
execution_providers = resolve_execution_providers(module_name)
|
||||
app_context = detect_app_context()
|
||||
inference_context = get_inference_context(module_name, model_names, execution_device_id, execution_providers)
|
||||
|
||||
if app_context == 'cli' and INFERENCE_POOL_SET.get('ui').get(inference_context):
|
||||
INFERENCE_POOL_SET['cli'][inference_context] = INFERENCE_POOL_SET.get('ui').get(inference_context)
|
||||
if app_context == 'ui' and INFERENCE_POOL_SET.get('cli').get(inference_context):
|
||||
INFERENCE_POOL_SET['ui'][inference_context] = INFERENCE_POOL_SET.get('cli').get(inference_context)
|
||||
if not INFERENCE_POOL_SET.get(app_context).get(inference_context):
|
||||
INFERENCE_POOL_SET[app_context][inference_context] = create_inference_pool(model_source_set, execution_device_id, execution_providers)
|
||||
for execution_device_id in execution_device_ids:
|
||||
inference_context = get_inference_context(module_name, model_names, execution_device_id, execution_providers)
|
||||
|
||||
return INFERENCE_POOL_SET.get(app_context).get(inference_context)
|
||||
if app_context == 'cli' and INFERENCE_POOL_SET.get('ui').get(inference_context):
|
||||
INFERENCE_POOL_SET['cli'][inference_context] = INFERENCE_POOL_SET.get('ui').get(inference_context)
|
||||
if app_context == 'ui' and INFERENCE_POOL_SET.get('cli').get(inference_context):
|
||||
INFERENCE_POOL_SET['ui'][inference_context] = INFERENCE_POOL_SET.get('cli').get(inference_context)
|
||||
if not INFERENCE_POOL_SET.get(app_context).get(inference_context):
|
||||
INFERENCE_POOL_SET[app_context][inference_context] = create_inference_pool(model_source_set, execution_device_id, execution_providers)
|
||||
|
||||
current_inference_context = get_inference_context(module_name, model_names, random.choice(execution_device_ids), execution_providers)
|
||||
return INFERENCE_POOL_SET.get(app_context).get(current_inference_context)
|
||||
|
||||
|
||||
def create_inference_pool(model_source_set : DownloadSet, execution_device_id : str, execution_providers : List[ExecutionProvider]) -> InferencePool:
|
||||
def create_inference_pool(model_source_set : DownloadSet, execution_device_id : int, execution_providers : List[ExecutionProvider]) -> InferencePool:
|
||||
inference_pool : InferencePool = {}
|
||||
|
||||
for model_name in model_source_set.keys():
|
||||
@@ -47,22 +54,36 @@ def create_inference_pool(model_source_set : DownloadSet, execution_device_id :
|
||||
|
||||
|
||||
def clear_inference_pool(module_name : str, model_names : List[str]) -> None:
|
||||
execution_device_id = state_manager.get_item('execution_device_id')
|
||||
execution_device_ids = state_manager.get_item('execution_device_ids')
|
||||
execution_providers = resolve_execution_providers(module_name)
|
||||
app_context = detect_app_context()
|
||||
inference_context = get_inference_context(module_name, model_names, execution_device_id, execution_providers)
|
||||
|
||||
if INFERENCE_POOL_SET.get(app_context).get(inference_context):
|
||||
del INFERENCE_POOL_SET[app_context][inference_context]
|
||||
if is_windows() and has_execution_provider('directml'):
|
||||
INFERENCE_POOL_SET[app_context].clear()
|
||||
|
||||
for execution_device_id in execution_device_ids:
|
||||
inference_context = get_inference_context(module_name, model_names, execution_device_id, execution_providers)
|
||||
if INFERENCE_POOL_SET.get(app_context).get(inference_context):
|
||||
del INFERENCE_POOL_SET[app_context][inference_context]
|
||||
|
||||
|
||||
def create_inference_session(model_path : str, execution_device_id : str, execution_providers : List[ExecutionProvider]) -> InferenceSession:
|
||||
inference_session_providers = create_inference_session_providers(execution_device_id, execution_providers)
|
||||
return InferenceSession(model_path, providers = inference_session_providers)
|
||||
def create_inference_session(model_path : str, execution_device_id : int, execution_providers : List[ExecutionProvider]) -> InferenceSession:
|
||||
model_file_name = get_file_name(model_path)
|
||||
start_time = time()
|
||||
|
||||
try:
|
||||
inference_session_providers = create_inference_session_providers(execution_device_id, execution_providers)
|
||||
inference_session = InferenceSession(model_path, providers = inference_session_providers)
|
||||
logger.debug(translator.get('loading_model_succeeded').format(model_name = model_file_name, seconds = calculate_end_time(start_time)), __name__)
|
||||
return inference_session
|
||||
|
||||
except Exception:
|
||||
logger.error(translator.get('loading_model_failed').format(model_name = model_file_name), __name__)
|
||||
fatal_exit(1)
|
||||
|
||||
|
||||
def get_inference_context(module_name : str, model_names : List[str], execution_device_id : str, execution_providers : List[ExecutionProvider]) -> str:
|
||||
inference_context = '.'.join([ module_name ] + model_names + [ execution_device_id ] + list(execution_providers))
|
||||
def get_inference_context(module_name : str, model_names : List[str], execution_device_id : int, execution_providers : List[ExecutionProvider]) -> str:
|
||||
inference_context = '.'.join([ module_name ] + model_names + [ str(execution_device_id) ] + list(execution_providers))
|
||||
return inference_context
|
||||
|
||||
|
||||
|
||||
+31
-18
@@ -7,27 +7,36 @@ from argparse import ArgumentParser, HelpFormatter
|
||||
from functools import partial
|
||||
from types import FrameType
|
||||
|
||||
from facefusion import metadata, wording
|
||||
from facefusion import metadata
|
||||
from facefusion.common_helper import is_linux, is_windows
|
||||
|
||||
LOCALS =\
|
||||
{
|
||||
'install_dependency': 'install the {dependency} package',
|
||||
'force_reinstall': 'force reinstall of packages',
|
||||
'skip_conda': 'skip the conda environment check',
|
||||
'conda_not_activated': 'conda is not activated'
|
||||
}
|
||||
ONNXRUNTIME_SET =\
|
||||
{
|
||||
'default': ('onnxruntime', '1.22.0')
|
||||
'default': ('onnxruntime', '1.23.2')
|
||||
}
|
||||
if is_windows() or is_linux():
|
||||
ONNXRUNTIME_SET['cuda'] = ('onnxruntime-gpu', '1.22.0')
|
||||
ONNXRUNTIME_SET['openvino'] = ('onnxruntime-openvino', '1.22.0')
|
||||
ONNXRUNTIME_SET['cuda'] = ('onnxruntime-gpu', '1.23.2')
|
||||
ONNXRUNTIME_SET['openvino'] = ('onnxruntime-openvino', '1.23.0')
|
||||
if is_windows():
|
||||
ONNXRUNTIME_SET['directml'] = ('onnxruntime-directml', '1.17.3')
|
||||
ONNXRUNTIME_SET['directml'] = ('onnxruntime-directml', '1.23.0')
|
||||
if is_linux():
|
||||
ONNXRUNTIME_SET['rocm'] = ('onnxruntime-rocm', '1.21.0')
|
||||
ONNXRUNTIME_SET['migraphx'] = ('onnxruntime-migraphx', '1.23.0')
|
||||
ONNXRUNTIME_SET['rocm'] = ('onnxruntime_rocm', '1.22.1', '7.0.2') #type:ignore[assignment]
|
||||
|
||||
|
||||
def cli() -> None:
|
||||
signal.signal(signal.SIGINT, signal_exit)
|
||||
program = ArgumentParser(formatter_class = partial(HelpFormatter, max_help_position = 50))
|
||||
program.add_argument('--onnxruntime', help = wording.get('help.install_dependency').format(dependency = 'onnxruntime'), choices = ONNXRUNTIME_SET.keys(), required = True)
|
||||
program.add_argument('--skip-conda', help = wording.get('help.skip_conda'), action = 'store_true')
|
||||
program.add_argument('--onnxruntime', help = LOCALS.get('install_dependency').format(dependency = 'onnxruntime'), choices = ONNXRUNTIME_SET.keys(), required = True)
|
||||
program.add_argument('--force-reinstall', help = LOCALS.get('force_reinstall'), action = 'store_true')
|
||||
program.add_argument('--skip-conda', help = LOCALS.get('skip_conda'), action = 'store_true')
|
||||
program.add_argument('-v', '--version', version = metadata.get('name') + ' ' + metadata.get('version'), action = 'version')
|
||||
run(program)
|
||||
|
||||
@@ -39,10 +48,13 @@ def signal_exit(signum : int, frame : FrameType) -> None:
|
||||
def run(program : ArgumentParser) -> None:
|
||||
args = program.parse_args()
|
||||
has_conda = 'CONDA_PREFIX' in os.environ
|
||||
onnxruntime_name, onnxruntime_version = ONNXRUNTIME_SET.get(args.onnxruntime)
|
||||
commands = [ shutil.which('pip'), 'install' ]
|
||||
|
||||
if args.force_reinstall:
|
||||
commands.append('--force-reinstall')
|
||||
|
||||
if not args.skip_conda and not has_conda:
|
||||
sys.stdout.write(wording.get('conda_not_activated') + os.linesep)
|
||||
sys.stdout.write(LOCALS.get('conda_not_activated') + os.linesep)
|
||||
sys.exit(1)
|
||||
|
||||
with open('requirements.txt') as file:
|
||||
@@ -50,17 +62,21 @@ def run(program : ArgumentParser) -> None:
|
||||
for line in file.readlines():
|
||||
__line__ = line.strip()
|
||||
if not __line__.startswith('onnxruntime'):
|
||||
subprocess.call([ shutil.which('pip'), 'install', line, '--force-reinstall' ])
|
||||
commands.append(__line__)
|
||||
|
||||
if args.onnxruntime == 'rocm':
|
||||
onnxruntime_name, onnxruntime_version, rocm_version = ONNXRUNTIME_SET.get(args.onnxruntime) #type:ignore[misc]
|
||||
python_id = 'cp' + str(sys.version_info.major) + str(sys.version_info.minor)
|
||||
|
||||
if python_id in [ 'cp310', 'cp312' ]:
|
||||
wheel_name = 'onnxruntime_rocm-' + onnxruntime_version + '-' + python_id + '-' + python_id + '-linux_x86_64.whl'
|
||||
wheel_url = 'https://repo.radeon.com/rocm/manylinux/rocm-rel-6.4/' + wheel_name
|
||||
subprocess.call([ shutil.which('pip'), 'install', wheel_url, '--force-reinstall' ])
|
||||
wheel_name = onnxruntime_name + '-' + onnxruntime_version + '-' + python_id + '-' + python_id + '-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl'
|
||||
wheel_url = 'https://repo.radeon.com/rocm/manylinux/rocm-rel-' + rocm_version + '/' + wheel_name
|
||||
commands.append(wheel_url)
|
||||
else:
|
||||
subprocess.call([ shutil.which('pip'), 'install', onnxruntime_name + '==' + onnxruntime_version, '--force-reinstall' ])
|
||||
onnxruntime_name, onnxruntime_version = ONNXRUNTIME_SET.get(args.onnxruntime)
|
||||
commands.append(onnxruntime_name + '==' + onnxruntime_version)
|
||||
|
||||
subprocess.call(commands)
|
||||
|
||||
if args.onnxruntime == 'cuda' and has_conda:
|
||||
library_paths = []
|
||||
@@ -91,6 +107,3 @@ def run(program : ArgumentParser) -> None:
|
||||
library_paths = list(dict.fromkeys([ library_path for library_path in library_paths if os.path.exists(library_path) ]))
|
||||
|
||||
subprocess.call([ shutil.which('conda'), 'env', 'config', 'vars', 'set', 'PATH=' + os.pathsep.join(library_paths) ])
|
||||
|
||||
if args.onnxruntime == 'directml':
|
||||
subprocess.call([ shutil.which('pip'), 'install', 'numpy==1.26.4', '--force-reinstall' ])
|
||||
|
||||
@@ -7,10 +7,12 @@ from facefusion.filesystem import get_file_extension, get_file_name
|
||||
|
||||
def get_step_output_path(job_id : str, step_index : int, output_path : str) -> Optional[str]:
|
||||
if output_path:
|
||||
output_directory_path, _ = os.path.split(output_path)
|
||||
output_file_name = get_file_name(_)
|
||||
output_file_extension = get_file_extension(_)
|
||||
return os.path.join(output_directory_path, output_file_name + '-' + job_id + '-' + str(step_index) + output_file_extension)
|
||||
output_directory_path, output_file_path = os.path.split(output_path)
|
||||
output_file_name = get_file_name(output_file_path)
|
||||
output_file_extension = get_file_extension(output_file_path)
|
||||
|
||||
if output_file_name and output_file_extension:
|
||||
return os.path.join(output_directory_path, output_file_name + '-' + job_id + '-' + str(step_index) + output_file_extension)
|
||||
return None
|
||||
|
||||
|
||||
|
||||
@@ -1,15 +1,15 @@
|
||||
from datetime import datetime
|
||||
from typing import Optional, Tuple
|
||||
from typing import List, Optional, Tuple
|
||||
|
||||
from facefusion.date_helper import describe_time_ago
|
||||
from facefusion.jobs import job_manager
|
||||
from facefusion.types import JobStatus, TableContents, TableHeaders
|
||||
from facefusion.time_helper import describe_time_ago
|
||||
from facefusion.types import JobStatus, TableContent, TableHeader
|
||||
|
||||
|
||||
def compose_job_list(job_status : JobStatus) -> Tuple[TableHeaders, TableContents]:
|
||||
def compose_job_list(job_status : JobStatus) -> Tuple[List[TableHeader], List[List[TableContent]]]:
|
||||
jobs = job_manager.find_jobs(job_status)
|
||||
job_headers : TableHeaders = [ 'job id', 'steps', 'date created', 'date updated', 'job status' ]
|
||||
job_contents : TableContents = []
|
||||
job_headers : List[TableHeader] = [ 'job id', 'steps', 'date created', 'date updated', 'job status' ]
|
||||
job_contents : List[List[TableContent]] = []
|
||||
|
||||
for index, job_id in enumerate(jobs):
|
||||
if job_manager.validate_job(job_id):
|
||||
|
||||
@@ -3,10 +3,10 @@ from copy import copy
|
||||
from typing import List, Optional
|
||||
|
||||
import facefusion.choices
|
||||
from facefusion.date_helper import get_current_date_time
|
||||
from facefusion.filesystem import create_directory, get_file_name, is_directory, is_file, move_file, remove_directory, remove_file, resolve_file_pattern
|
||||
from facefusion.jobs.job_helper import get_step_output_path
|
||||
from facefusion.json import read_json, write_json
|
||||
from facefusion.time_helper import get_current_date_time
|
||||
from facefusion.types import Args, Job, JobSet, JobStatus, JobStep, JobStepStatus
|
||||
|
||||
JOBS_PATH : Optional[str] = None
|
||||
|
||||
@@ -17,11 +17,11 @@ def get_step_keys() -> List[str]:
|
||||
return JOB_STORE.get('step_keys')
|
||||
|
||||
|
||||
def register_job_keys(step_keys : List[str]) -> None:
|
||||
for step_key in step_keys:
|
||||
JOB_STORE['job_keys'].append(step_key)
|
||||
|
||||
|
||||
def register_step_keys(job_keys : List[str]) -> None:
|
||||
def register_job_keys(job_keys : List[str]) -> None:
|
||||
for job_key in job_keys:
|
||||
JOB_STORE['step_keys'].append(job_key)
|
||||
JOB_STORE['job_keys'].append(job_key)
|
||||
|
||||
|
||||
def register_step_keys(step_keys : List[str]) -> None:
|
||||
for step_key in step_keys:
|
||||
JOB_STORE['step_keys'].append(step_key)
|
||||
|
||||
@@ -0,0 +1,274 @@
|
||||
from facefusion.types import Locals
|
||||
|
||||
LOCALS : Locals =\
|
||||
{
|
||||
'en':
|
||||
{
|
||||
'conda_not_activated': 'conda is not activated',
|
||||
'python_not_supported': 'python version is not supported, upgrade to {version} or higher',
|
||||
'curl_not_installed': 'curl is not installed',
|
||||
'ffmpeg_not_installed': 'ffmpeg is not installed',
|
||||
'creating_temp': 'creating temporary resources',
|
||||
'extracting_frames': 'extracting frames with a resolution of {resolution} and {fps} frames per second',
|
||||
'extracting_frames_succeeded': 'extracting frames succeeded',
|
||||
'extracting_frames_failed': 'extracting frames failed',
|
||||
'analysing': 'analysing',
|
||||
'extracting': 'extracting',
|
||||
'streaming': 'streaming',
|
||||
'processing': 'processing',
|
||||
'merging': 'merging',
|
||||
'downloading': 'downloading',
|
||||
'temp_frames_not_found': 'temporary frames not found',
|
||||
'copying_image': 'copying image with a resolution of {resolution}',
|
||||
'copying_image_succeeded': 'copying image succeeded',
|
||||
'copying_image_failed': 'copying image failed',
|
||||
'finalizing_image': 'finalizing image with a resolution of {resolution}',
|
||||
'finalizing_image_succeeded': 'finalizing image succeeded',
|
||||
'finalizing_image_skipped': 'finalizing image skipped',
|
||||
'merging_video': 'merging video with a resolution of {resolution} and {fps} frames per second',
|
||||
'merging_video_succeeded': 'merging video succeeded',
|
||||
'merging_video_failed': 'merging video failed',
|
||||
'skipping_audio': 'skipping audio',
|
||||
'replacing_audio_succeeded': 'replacing audio succeeded',
|
||||
'replacing_audio_skipped': 'replacing audio skipped',
|
||||
'restoring_audio_succeeded': 'restoring audio succeeded',
|
||||
'restoring_audio_skipped': 'restoring audio skipped',
|
||||
'clearing_temp': 'clearing temporary resources',
|
||||
'processing_stopped': 'processing stopped',
|
||||
'processing_image_succeeded': 'processing to image succeeded in {seconds} seconds',
|
||||
'processing_image_failed': 'processing to image failed',
|
||||
'processing_video_succeeded': 'processing to video succeeded in {seconds} seconds',
|
||||
'processing_video_failed': 'processing to video failed',
|
||||
'choose_image_source': 'choose an image for the source',
|
||||
'choose_audio_source': 'choose an audio for the source',
|
||||
'choose_video_target': 'choose a video for the target',
|
||||
'choose_image_or_video_target': 'choose an image or video for the target',
|
||||
'specify_image_or_video_output': 'specify the output image or video within a directory',
|
||||
'match_target_and_output_extension': 'match the target and output extension',
|
||||
'no_source_face_detected': 'no source face detected',
|
||||
'processor_not_loaded': 'processor {processor} could not be loaded',
|
||||
'processor_not_implemented': 'processor {processor} not implemented correctly',
|
||||
'ui_layout_not_loaded': 'ui layout {ui_layout} could not be loaded',
|
||||
'ui_layout_not_implemented': 'ui layout {ui_layout} not implemented correctly',
|
||||
'stream_not_loaded': 'stream {stream_mode} could not be loaded',
|
||||
'stream_not_supported': 'stream not supported',
|
||||
'job_created': 'job {job_id} created',
|
||||
'job_not_created': 'job {job_id} not created',
|
||||
'job_submitted': 'job {job_id} submitted',
|
||||
'job_not_submitted': 'job {job_id} not submitted',
|
||||
'job_all_submitted': 'jobs submitted',
|
||||
'job_all_not_submitted': 'jobs not submitted',
|
||||
'job_deleted': 'job {job_id} deleted',
|
||||
'job_not_deleted': 'job {job_id} not deleted',
|
||||
'job_all_deleted': 'jobs deleted',
|
||||
'job_all_not_deleted': 'jobs not deleted',
|
||||
'job_step_added': 'step added to job {job_id}',
|
||||
'job_step_not_added': 'step not added to job {job_id}',
|
||||
'job_remix_step_added': 'step {step_index} remixed from job {job_id}',
|
||||
'job_remix_step_not_added': 'step {step_index} not remixed from job {job_id}',
|
||||
'job_step_inserted': 'step {step_index} inserted to job {job_id}',
|
||||
'job_step_not_inserted': 'step {step_index} not inserted to job {job_id}',
|
||||
'job_step_removed': 'step {step_index} removed from job {job_id}',
|
||||
'job_step_not_removed': 'step {step_index} not removed from job {job_id}',
|
||||
'running_job': 'running queued job {job_id}',
|
||||
'running_jobs': 'running all queued jobs',
|
||||
'retrying_job': 'retrying failed job {job_id}',
|
||||
'retrying_jobs': 'retrying all failed jobs',
|
||||
'processing_job_succeeded': 'processing of job {job_id} succeeded',
|
||||
'processing_jobs_succeeded': 'processing of all jobs succeeded',
|
||||
'processing_job_failed': 'processing of job {job_id} failed',
|
||||
'processing_jobs_failed': 'processing of all jobs failed',
|
||||
'processing_step': 'processing step {step_current} of {step_total}',
|
||||
'validating_hash_succeeded': 'validating hash for {hash_file_name} succeeded',
|
||||
'validating_hash_failed': 'validating hash for {hash_file_name} failed',
|
||||
'validating_source_succeeded': 'validating source for {source_file_name} succeeded',
|
||||
'validating_source_failed': 'validating source for {source_file_name} failed',
|
||||
'deleting_corrupt_source': 'deleting corrupt source for {source_file_name}',
|
||||
'loading_model_succeeded': 'loading model {model_name} succeeded in {seconds} seconds',
|
||||
'loading_model_failed': 'loading model {model_name} failed',
|
||||
'time_ago_now': 'just now',
|
||||
'time_ago_minutes': '{minutes} minutes ago',
|
||||
'time_ago_hours': '{hours} hours and {minutes} minutes ago',
|
||||
'time_ago_days': '{days} days, {hours} hours and {minutes} minutes ago',
|
||||
'point': '.',
|
||||
'comma': ',',
|
||||
'colon': ':',
|
||||
'question_mark': '?',
|
||||
'exclamation_mark': '!',
|
||||
'help':
|
||||
{
|
||||
'install_dependency': 'choose the variant of {dependency} to install',
|
||||
'skip_conda': 'skip the conda environment check',
|
||||
'config_path': 'choose the config file to override defaults',
|
||||
'temp_path': 'specify the directory for the temporary resources',
|
||||
'jobs_path': 'specify the directory to store jobs',
|
||||
'source_paths': 'choose the image or audio paths',
|
||||
'target_path': 'choose the image or video path',
|
||||
'output_path': 'specify the image or video within a directory',
|
||||
'source_pattern': 'choose the image or audio pattern',
|
||||
'target_pattern': 'choose the image or video pattern',
|
||||
'output_pattern': 'specify the image or video pattern',
|
||||
'face_detector_model': 'choose the model responsible for detecting the faces',
|
||||
'face_detector_size': 'specify the frame size provided to the face detector',
|
||||
'face_detector_margin': 'apply top, right, bottom and left margin to the frame',
|
||||
'face_detector_angles': 'specify the angles to rotate the frame before detecting faces',
|
||||
'face_detector_score': 'filter the detected faces based on the confidence score',
|
||||
'face_landmarker_model': 'choose the model responsible for detecting the face landmarks',
|
||||
'face_landmarker_score': 'filter the detected face landmarks based on the confidence score',
|
||||
'face_selector_mode': 'use reference based tracking or simple matching',
|
||||
'face_selector_order': 'specify the order of the detected faces',
|
||||
'face_selector_age_start': 'filter the detected faces based on the starting age',
|
||||
'face_selector_age_end': 'filter the detected faces based on the ending age',
|
||||
'face_selector_gender': 'filter the detected faces based on their gender',
|
||||
'face_selector_race': 'filter the detected faces based on their race',
|
||||
'reference_face_position': 'specify the position used to create the reference face',
|
||||
'reference_face_distance': 'specify the similarity between the reference face and target face',
|
||||
'reference_frame_number': 'specify the frame used to create the reference face',
|
||||
'face_occluder_model': 'choose the model responsible for the occlusion mask',
|
||||
'face_parser_model': 'choose the model responsible for the region mask',
|
||||
'face_mask_types': 'mix and match different face mask types (choices: {choices})',
|
||||
'face_mask_areas': 'choose the items used for the area mask (choices: {choices})',
|
||||
'face_mask_regions': 'choose the items used for the region mask (choices: {choices})',
|
||||
'face_mask_blur': 'specify the degree of blur applied to the box mask',
|
||||
'face_mask_padding': 'apply top, right, bottom and left padding to the box mask',
|
||||
'voice_extractor_model': 'choose the model responsible for extracting the voices',
|
||||
'trim_frame_start': 'specify the starting frame of the target video',
|
||||
'trim_frame_end': 'specify the ending frame of the target video',
|
||||
'temp_frame_format': 'specify the temporary resources format',
|
||||
'keep_temp': 'keep the temporary resources after processing',
|
||||
'output_image_quality': 'specify the image quality which translates to the image compression',
|
||||
'output_image_scale': 'specify the image scale based on the target image',
|
||||
'output_audio_encoder': 'specify the encoder used for the audio',
|
||||
'output_audio_quality': 'specify the audio quality which translates to the audio compression',
|
||||
'output_audio_volume': 'specify the audio volume based on the target video',
|
||||
'output_video_encoder': 'specify the encoder used for the video',
|
||||
'output_video_preset': 'balance fast video processing and video file size',
|
||||
'output_video_quality': 'specify the video quality which translates to the video compression',
|
||||
'output_video_scale': 'specify the video scale based on the target video',
|
||||
'output_video_fps': 'specify the video fps based on the target video',
|
||||
'processors': 'load a single or multiple processors (choices: {choices}, ...)',
|
||||
'background-remover-model': 'choose the model responsible for removing the background',
|
||||
'background-remover-color': 'apply red, green blue and alpha values of the background',
|
||||
'open_browser': 'open the browser once the program is ready',
|
||||
'ui_layouts': 'launch a single or multiple UI layouts (choices: {choices}, ...)',
|
||||
'ui_workflow': 'choose the ui workflow',
|
||||
'download_providers': 'download using different providers (choices: {choices}, ...)',
|
||||
'download_scope': 'specify the download scope',
|
||||
'benchmark_mode': 'choose the benchmark mode',
|
||||
'benchmark_resolutions': 'choose the resolutions for the benchmarks (choices: {choices}, ...)',
|
||||
'benchmark_cycle_count': 'specify the amount of cycles per benchmark',
|
||||
'execution_device_ids': 'specify the devices used for processing',
|
||||
'execution_providers': 'inference using different providers (choices: {choices}, ...)',
|
||||
'execution_thread_count': 'specify the amount of parallel threads while processing',
|
||||
'video_memory_strategy': 'balance fast processing and low VRAM usage',
|
||||
'system_memory_limit': 'limit the available RAM that can be used while processing',
|
||||
'log_level': 'adjust the message severity displayed in the terminal',
|
||||
'halt_on_error': 'halt the program once an error occurred',
|
||||
'run': 'run the program',
|
||||
'headless_run': 'run the program in headless mode',
|
||||
'batch_run': 'run the program in batch mode',
|
||||
'force_download': 'force automate downloads and exit',
|
||||
'benchmark': 'benchmark the program',
|
||||
'job_id': 'specify the job id',
|
||||
'job_status': 'specify the job status',
|
||||
'step_index': 'specify the step index',
|
||||
'job_list': 'list jobs by status',
|
||||
'job_create': 'create a drafted job',
|
||||
'job_submit': 'submit a drafted job to become a queued job',
|
||||
'job_submit_all': 'submit all drafted jobs to become a queued jobs',
|
||||
'job_delete': 'delete a drafted, queued, failed or completed job',
|
||||
'job_delete_all': 'delete all drafted, queued, failed and completed jobs',
|
||||
'job_add_step': 'add a step to a drafted job',
|
||||
'job_remix_step': 'remix a previous step from a drafted job',
|
||||
'job_insert_step': 'insert a step to a drafted job',
|
||||
'job_remove_step': 'remove a step from a drafted job',
|
||||
'job_run': 'run a queued job',
|
||||
'job_run_all': 'run all queued jobs',
|
||||
'job_retry': 'retry a failed job',
|
||||
'job_retry_all': 'retry all failed jobs'
|
||||
},
|
||||
'about':
|
||||
{
|
||||
'fund': 'fund training server',
|
||||
'subscribe': 'become a member',
|
||||
'join': 'join our community'
|
||||
},
|
||||
'uis':
|
||||
{
|
||||
'apply_button': 'APPLY',
|
||||
'benchmark_mode_dropdown': 'BENCHMARK MODE',
|
||||
'benchmark_cycle_count_slider': 'BENCHMARK CYCLE COUNT',
|
||||
'benchmark_resolutions_checkbox_group': 'BENCHMARK RESOLUTIONS',
|
||||
'clear_button': 'CLEAR',
|
||||
'common_options_checkbox_group': 'OPTIONS',
|
||||
'download_providers_checkbox_group': 'DOWNLOAD PROVIDERS',
|
||||
'execution_providers_checkbox_group': 'EXECUTION PROVIDERS',
|
||||
'execution_thread_count_slider': 'EXECUTION THREAD COUNT',
|
||||
'face_detector_angles_checkbox_group': 'FACE DETECTOR ANGLES',
|
||||
'face_detector_model_dropdown': 'FACE DETECTOR MODEL',
|
||||
'face_detector_margin_slider': 'FACE DETECTOR MARGIN',
|
||||
'face_detector_score_slider': 'FACE DETECTOR SCORE',
|
||||
'face_detector_size_dropdown': 'FACE DETECTOR SIZE',
|
||||
'face_landmarker_model_dropdown': 'FACE LANDMARKER MODEL',
|
||||
'face_landmarker_score_slider': 'FACE LANDMARKER SCORE',
|
||||
'face_mask_blur_slider': 'FACE MASK BLUR',
|
||||
'face_mask_padding_bottom_slider': 'FACE MASK PADDING BOTTOM',
|
||||
'face_mask_padding_left_slider': 'FACE MASK PADDING LEFT',
|
||||
'face_mask_padding_right_slider': 'FACE MASK PADDING RIGHT',
|
||||
'face_mask_padding_top_slider': 'FACE MASK PADDING TOP',
|
||||
'face_mask_areas_checkbox_group': 'FACE MASK AREAS',
|
||||
'face_mask_regions_checkbox_group': 'FACE MASK REGIONS',
|
||||
'face_mask_types_checkbox_group': 'FACE MASK TYPES',
|
||||
'face_selector_age_range_slider': 'FACE SELECTOR AGE',
|
||||
'face_selector_gender_dropdown': 'FACE SELECTOR GENDER',
|
||||
'face_selector_mode_dropdown': 'FACE SELECTOR MODE',
|
||||
'face_selector_order_dropdown': 'FACE SELECTOR ORDER',
|
||||
'face_selector_race_dropdown': 'FACE SELECTOR RACE',
|
||||
'face_occluder_model_dropdown': 'FACE OCCLUDER MODEL',
|
||||
'face_parser_model_dropdown': 'FACE PARSER MODEL',
|
||||
'voice_extractor_model_dropdown': 'VOICE EXTRACTOR MODEL',
|
||||
'job_list_status_checkbox_group': 'JOB STATUS',
|
||||
'job_manager_job_action_dropdown': 'JOB_ACTION',
|
||||
'job_manager_job_id_dropdown': 'JOB ID',
|
||||
'job_manager_step_index_dropdown': 'STEP INDEX',
|
||||
'job_runner_job_action_dropdown': 'JOB ACTION',
|
||||
'job_runner_job_id_dropdown': 'JOB ID',
|
||||
'log_level_dropdown': 'LOG LEVEL',
|
||||
'output_audio_encoder_dropdown': 'OUTPUT AUDIO ENCODER',
|
||||
'output_audio_quality_slider': 'OUTPUT AUDIO QUALITY',
|
||||
'output_audio_volume_slider': 'OUTPUT AUDIO VOLUME',
|
||||
'output_image_or_video': 'OUTPUT',
|
||||
'output_image_quality_slider': 'OUTPUT IMAGE QUALITY',
|
||||
'output_image_scale_slider': 'OUTPUT IMAGE SCALE',
|
||||
'output_path_textbox': 'OUTPUT PATH',
|
||||
'output_video_encoder_dropdown': 'OUTPUT VIDEO ENCODER',
|
||||
'output_video_fps_slider': 'OUTPUT VIDEO FPS',
|
||||
'output_video_preset_dropdown': 'OUTPUT VIDEO PRESET',
|
||||
'output_video_quality_slider': 'OUTPUT VIDEO QUALITY',
|
||||
'output_video_scale_slider': 'OUTPUT VIDEO SCALE',
|
||||
'preview_frame_slider': 'PREVIEW FRAME',
|
||||
'preview_image': 'PREVIEW',
|
||||
'preview_mode_dropdown': 'PREVIEW MODE',
|
||||
'preview_resolution_dropdown': 'PREVIEW RESOLUTION',
|
||||
'processors_checkbox_group': 'PROCESSORS',
|
||||
'reference_face_distance_slider': 'REFERENCE FACE DISTANCE',
|
||||
'reference_face_gallery': 'REFERENCE FACE',
|
||||
'refresh_button': 'REFRESH',
|
||||
'source_file': 'SOURCE',
|
||||
'start_button': 'START',
|
||||
'stop_button': 'STOP',
|
||||
'system_memory_limit_slider': 'SYSTEM MEMORY LIMIT',
|
||||
'target_file': 'TARGET',
|
||||
'temp_frame_format_dropdown': 'TEMP FRAME FORMAT',
|
||||
'terminal_textbox': 'TERMINAL',
|
||||
'trim_frame_slider': 'TRIM FRAME',
|
||||
'ui_workflow': 'UI WORKFLOW',
|
||||
'video_memory_strategy_dropdown': 'VIDEO MEMORY STRATEGY',
|
||||
'webcam_fps_slider': 'WEBCAM FPS',
|
||||
'webcam_image': 'WEBCAM',
|
||||
'webcam_device_id_dropdown': 'WEBCAM DEVICE ID',
|
||||
'webcam_mode_radio': 'WEBCAM MODE',
|
||||
'webcam_resolution_dropdown': 'WEBCAM RESOLUTION'
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -4,7 +4,7 @@ METADATA =\
|
||||
{
|
||||
'name': 'FaceFusion',
|
||||
'description': 'Industry leading face manipulation platform',
|
||||
'version': '3.3.2',
|
||||
'version': '3.5.2',
|
||||
'license': 'OpenRAIL-AS',
|
||||
'author': 'Henry Ruhs',
|
||||
'url': 'https://facefusion.io'
|
||||
@@ -12,6 +12,4 @@ METADATA =\
|
||||
|
||||
|
||||
def get(key : str) -> Optional[str]:
|
||||
if key in METADATA:
|
||||
return METADATA.get(key)
|
||||
return None
|
||||
return METADATA.get(key)
|
||||
|
||||
@@ -5,7 +5,7 @@ import onnx
|
||||
from facefusion.types import ModelInitializer
|
||||
|
||||
|
||||
@lru_cache(maxsize = None)
|
||||
@lru_cache()
|
||||
def get_static_model_initializer(model_path : str) -> ModelInitializer:
|
||||
model = onnx.load(model_path)
|
||||
return onnx.numpy_helper.to_array(model.graph.initializer[-1])
|
||||
|
||||
+22
-10
@@ -1,17 +1,29 @@
|
||||
from typing import List, Optional
|
||||
|
||||
from facefusion.types import Fps, Padding
|
||||
from facefusion.types import Color, Fps, Padding
|
||||
|
||||
|
||||
def normalize_padding(padding : Optional[List[int]]) -> Optional[Padding]:
|
||||
if padding and len(padding) == 1:
|
||||
return tuple([ padding[0] ] * 4) #type:ignore[return-value]
|
||||
if padding and len(padding) == 2:
|
||||
return tuple([ padding[0], padding[1], padding[0], padding[1] ]) #type:ignore[return-value]
|
||||
if padding and len(padding) == 3:
|
||||
return tuple([ padding[0], padding[1], padding[2], padding[1] ]) #type:ignore[return-value]
|
||||
if padding and len(padding) == 4:
|
||||
return tuple(padding) #type:ignore[return-value]
|
||||
def normalize_color(channels : Optional[List[int]]) -> Optional[Color]:
|
||||
if channels and len(channels) == 1:
|
||||
return tuple([ channels[0], channels[0], channels[0], 255 ]) #type:ignore[return-value]
|
||||
if channels and len(channels) == 2:
|
||||
return tuple([ channels[0], channels[1], channels[0], 255 ]) #type:ignore[return-value]
|
||||
if channels and len(channels) == 3:
|
||||
return tuple([ channels[0], channels[1], channels[2], 255 ]) #type:ignore[return-value]
|
||||
if channels and len(channels) == 4:
|
||||
return tuple(channels) #type:ignore[return-value]
|
||||
return None
|
||||
|
||||
|
||||
def normalize_space(spaces : Optional[List[int]]) -> Optional[Padding]:
|
||||
if spaces and len(spaces) == 1:
|
||||
return tuple([spaces[0]] * 4) #type:ignore[return-value]
|
||||
if spaces and len(spaces) == 2:
|
||||
return tuple([spaces[0], spaces[1], spaces[0], spaces[1]]) #type:ignore[return-value]
|
||||
if spaces and len(spaces) == 3:
|
||||
return tuple([spaces[0], spaces[1], spaces[2], spaces[1]]) #type:ignore[return-value]
|
||||
if spaces and len(spaces) == 4:
|
||||
return tuple(spaces) #type:ignore[return-value]
|
||||
return None
|
||||
|
||||
|
||||
|
||||
@@ -1,6 +1,4 @@
|
||||
from typing import Generator, List
|
||||
|
||||
from facefusion.types import ProcessState, QueuePayload
|
||||
from facefusion.types import ProcessState
|
||||
|
||||
PROCESS_STATE : ProcessState = 'pending'
|
||||
|
||||
@@ -45,9 +43,3 @@ def stop() -> None:
|
||||
|
||||
def end() -> None:
|
||||
set_process_state('pending')
|
||||
|
||||
|
||||
def manage(queue_payloads : List[QueuePayload]) -> Generator[QueuePayload, None, None]:
|
||||
for query_payload in queue_payloads:
|
||||
if is_processing():
|
||||
yield query_payload
|
||||
|
||||
@@ -1,15 +1,10 @@
|
||||
import importlib
|
||||
import os
|
||||
from concurrent.futures import ThreadPoolExecutor, as_completed
|
||||
from queue import Queue
|
||||
from types import ModuleType
|
||||
from typing import Any, List
|
||||
|
||||
from tqdm import tqdm
|
||||
|
||||
from facefusion import logger, state_manager, wording
|
||||
from facefusion import logger, translator
|
||||
from facefusion.exit_helper import hard_exit
|
||||
from facefusion.types import ProcessFrames, QueuePayload
|
||||
|
||||
|
||||
PROCESSORS_METHODS =\
|
||||
[
|
||||
@@ -20,26 +15,22 @@ PROCESSORS_METHODS =\
|
||||
'pre_check',
|
||||
'pre_process',
|
||||
'post_process',
|
||||
'get_reference_frame',
|
||||
'process_frame',
|
||||
'process_frames',
|
||||
'process_image',
|
||||
'process_video'
|
||||
'process_frame'
|
||||
]
|
||||
|
||||
|
||||
def load_processor_module(processor : str) -> Any:
|
||||
try:
|
||||
processor_module = importlib.import_module('facefusion.processors.modules.' + processor)
|
||||
processor_module = importlib.import_module('facefusion.processors.modules.' + processor + '.core')
|
||||
for method_name in PROCESSORS_METHODS:
|
||||
if not hasattr(processor_module, method_name):
|
||||
raise NotImplementedError
|
||||
except ModuleNotFoundError as exception:
|
||||
logger.error(wording.get('processor_not_loaded').format(processor = processor), __name__)
|
||||
logger.error(translator.get('processor_not_loaded').format(processor = processor), __name__)
|
||||
logger.debug(exception.msg, __name__)
|
||||
hard_exit(1)
|
||||
except NotImplementedError:
|
||||
logger.error(wording.get('processor_not_implemented').format(processor = processor), __name__)
|
||||
logger.error(translator.get('processor_not_implemented').format(processor = processor), __name__)
|
||||
hard_exit(1)
|
||||
return processor_module
|
||||
|
||||
@@ -51,49 +42,3 @@ def get_processors_modules(processors : List[str]) -> List[ModuleType]:
|
||||
processor_module = load_processor_module(processor)
|
||||
processor_modules.append(processor_module)
|
||||
return processor_modules
|
||||
|
||||
|
||||
def multi_process_frames(source_paths : List[str], temp_frame_paths : List[str], process_frames : ProcessFrames) -> None:
|
||||
queue_payloads = create_queue_payloads(temp_frame_paths)
|
||||
with tqdm(total = len(queue_payloads), desc = wording.get('processing'), unit = 'frame', ascii = ' =', disable = state_manager.get_item('log_level') in [ 'warn', 'error' ]) as progress:
|
||||
progress.set_postfix(execution_providers = state_manager.get_item('execution_providers'))
|
||||
with ThreadPoolExecutor(max_workers = state_manager.get_item('execution_thread_count')) as executor:
|
||||
futures = []
|
||||
queue : Queue[QueuePayload] = create_queue(queue_payloads)
|
||||
queue_per_future = max(len(queue_payloads) // state_manager.get_item('execution_thread_count') * state_manager.get_item('execution_queue_count'), 1)
|
||||
|
||||
while not queue.empty():
|
||||
future = executor.submit(process_frames, source_paths, pick_queue(queue, queue_per_future), progress.update)
|
||||
futures.append(future)
|
||||
|
||||
for future_done in as_completed(futures):
|
||||
future_done.result()
|
||||
|
||||
|
||||
def create_queue(queue_payloads : List[QueuePayload]) -> Queue[QueuePayload]:
|
||||
queue : Queue[QueuePayload] = Queue()
|
||||
for queue_payload in queue_payloads:
|
||||
queue.put(queue_payload)
|
||||
return queue
|
||||
|
||||
|
||||
def pick_queue(queue : Queue[QueuePayload], queue_per_future : int) -> List[QueuePayload]:
|
||||
queues = []
|
||||
for _ in range(queue_per_future):
|
||||
if not queue.empty():
|
||||
queues.append(queue.get())
|
||||
return queues
|
||||
|
||||
|
||||
def create_queue_payloads(temp_frame_paths : List[str]) -> List[QueuePayload]:
|
||||
queue_payloads = []
|
||||
temp_frame_paths = sorted(temp_frame_paths, key = os.path.basename)
|
||||
|
||||
for frame_number, frame_path in enumerate(temp_frame_paths):
|
||||
frame_payload : QueuePayload =\
|
||||
{
|
||||
'frame_number': frame_number,
|
||||
'frame_path': frame_path
|
||||
}
|
||||
queue_payloads.append(frame_payload)
|
||||
return queue_payloads
|
||||
|
||||
@@ -63,15 +63,15 @@ def limit_expression(expression : LivePortraitExpression) -> LivePortraitExpress
|
||||
return numpy.clip(expression, EXPRESSION_MIN, EXPRESSION_MAX)
|
||||
|
||||
|
||||
def limit_euler_angles(target_pitch : LivePortraitPitch, target_yaw : LivePortraitYaw, target_roll : LivePortraitRoll, output_pitch : LivePortraitPitch, output_yaw : LivePortraitYaw, output_roll : LivePortraitRoll) -> Tuple[LivePortraitPitch, LivePortraitYaw, LivePortraitRoll]:
|
||||
pitch_min, pitch_max, yaw_min, yaw_max, roll_min, roll_max = calc_euler_limits(target_pitch, target_yaw, target_roll)
|
||||
def limit_angle(target_pitch : LivePortraitPitch, target_yaw : LivePortraitYaw, target_roll : LivePortraitRoll, output_pitch : LivePortraitPitch, output_yaw : LivePortraitYaw, output_roll : LivePortraitRoll) -> Tuple[LivePortraitPitch, LivePortraitYaw, LivePortraitRoll]:
|
||||
pitch_min, pitch_max, yaw_min, yaw_max, roll_min, roll_max = calculate_euler_limits(target_pitch, target_yaw, target_roll)
|
||||
output_pitch = numpy.clip(output_pitch, pitch_min, pitch_max)
|
||||
output_yaw = numpy.clip(output_yaw, yaw_min, yaw_max)
|
||||
output_roll = numpy.clip(output_roll, roll_min, roll_max)
|
||||
return output_pitch, output_yaw, output_roll
|
||||
|
||||
|
||||
def calc_euler_limits(pitch : LivePortraitPitch, yaw : LivePortraitYaw, roll : LivePortraitRoll) -> Tuple[float, float, float, float, float, float]:
|
||||
def calculate_euler_limits(pitch : LivePortraitPitch, yaw : LivePortraitYaw, roll : LivePortraitRoll) -> Tuple[float, float, float, float, float, float]:
|
||||
pitch_min = -30.0
|
||||
pitch_max = 30.0
|
||||
yaw_min = -60.0
|
||||
|
||||
@@ -0,0 +1,8 @@
|
||||
from typing import List, Sequence
|
||||
|
||||
from facefusion.common_helper import create_int_range
|
||||
from facefusion.processors.modules.age_modifier.types import AgeModifierModel
|
||||
|
||||
age_modifier_models : List[AgeModifierModel] = [ 'styleganex_age' ]
|
||||
|
||||
age_modifier_direction_range : Sequence[int] = create_int_range(-100, 100, 1)
|
||||
+35
-70
@@ -1,6 +1,5 @@
|
||||
from argparse import ArgumentParser
|
||||
from functools import lru_cache
|
||||
from typing import List
|
||||
|
||||
import cv2
|
||||
import numpy
|
||||
@@ -8,31 +7,36 @@ import numpy
|
||||
import facefusion.choices
|
||||
import facefusion.jobs.job_manager
|
||||
import facefusion.jobs.job_store
|
||||
import facefusion.processors.core as processors
|
||||
from facefusion import config, content_analyser, face_classifier, face_detector, face_landmarker, face_masker, face_recognizer, inference_manager, logger, process_manager, state_manager, video_manager, wording
|
||||
from facefusion.common_helper import create_int_metavar
|
||||
from facefusion import config, content_analyser, face_classifier, face_detector, face_landmarker, face_masker, face_recognizer, inference_manager, logger, state_manager, translator, video_manager
|
||||
from facefusion.common_helper import create_int_metavar, is_macos
|
||||
from facefusion.download import conditional_download_hashes, conditional_download_sources, resolve_download_url
|
||||
from facefusion.execution import has_execution_provider
|
||||
from facefusion.face_analyser import get_many_faces, get_one_face
|
||||
from facefusion.face_analyser import scale_face
|
||||
from facefusion.face_helper import merge_matrix, paste_back, scale_face_landmark_5, warp_face_by_face_landmark_5
|
||||
from facefusion.face_masker import create_box_mask, create_occlusion_mask
|
||||
from facefusion.face_selector import find_similar_faces, sort_and_filter_faces
|
||||
from facefusion.face_store import get_reference_faces
|
||||
from facefusion.face_selector import select_faces
|
||||
from facefusion.filesystem import in_directory, is_image, is_video, resolve_relative_path, same_file_extension
|
||||
from facefusion.processors import choices as processors_choices
|
||||
from facefusion.processors.types import AgeModifierDirection, AgeModifierInputs
|
||||
from facefusion.processors.modules.age_modifier import choices as age_modifier_choices
|
||||
from facefusion.processors.modules.age_modifier.types import AgeModifierDirection, AgeModifierInputs
|
||||
from facefusion.processors.types import ProcessorOutputs
|
||||
from facefusion.program_helper import find_argument_group
|
||||
from facefusion.thread_helper import thread_semaphore
|
||||
from facefusion.types import ApplyStateItem, Args, DownloadScope, Face, InferencePool, ModelOptions, ModelSet, ProcessMode, QueuePayload, UpdateProgress, VisionFrame
|
||||
from facefusion.vision import match_frame_color, read_image, read_static_image, write_image
|
||||
from facefusion.types import ApplyStateItem, Args, DownloadScope, Face, InferencePool, ModelOptions, ModelSet, ProcessMode, VisionFrame
|
||||
from facefusion.vision import match_frame_color, read_static_image, read_static_video_frame
|
||||
|
||||
|
||||
@lru_cache(maxsize = None)
|
||||
@lru_cache()
|
||||
def create_static_model_set(download_scope : DownloadScope) -> ModelSet:
|
||||
return\
|
||||
{
|
||||
'styleganex_age':
|
||||
{
|
||||
'__metadata__':
|
||||
{
|
||||
'vendor': 'williamyang1991',
|
||||
'license': 'S-Lab-1.0',
|
||||
'year': 2023
|
||||
},
|
||||
'hashes':
|
||||
{
|
||||
'age_modifier':
|
||||
@@ -83,8 +87,8 @@ def get_model_options() -> ModelOptions:
|
||||
def register_args(program : ArgumentParser) -> None:
|
||||
group_processors = find_argument_group(program, 'processors')
|
||||
if group_processors:
|
||||
group_processors.add_argument('--age-modifier-model', help = wording.get('help.age_modifier_model'), default = config.get_str_value('processors', 'age_modifier_model', 'styleganex_age'), choices = processors_choices.age_modifier_models)
|
||||
group_processors.add_argument('--age-modifier-direction', help = wording.get('help.age_modifier_direction'), type = int, default = config.get_int_value('processors', 'age_modifier_direction', '0'), choices = processors_choices.age_modifier_direction_range, metavar = create_int_metavar(processors_choices.age_modifier_direction_range))
|
||||
group_processors.add_argument('--age-modifier-model', help = translator.get('help.model', __package__), default = config.get_str_value('processors', 'age_modifier_model', 'styleganex_age'), choices = age_modifier_choices.age_modifier_models)
|
||||
group_processors.add_argument('--age-modifier-direction', help = translator.get('help.direction', __package__), type = int, default = config.get_int_value('processors', 'age_modifier_direction', '0'), choices = age_modifier_choices.age_modifier_direction_range, metavar = create_int_metavar(age_modifier_choices.age_modifier_direction_range))
|
||||
facefusion.jobs.job_store.register_step_keys([ 'age_modifier_model', 'age_modifier_direction' ])
|
||||
|
||||
|
||||
@@ -102,19 +106,20 @@ def pre_check() -> bool:
|
||||
|
||||
def pre_process(mode : ProcessMode) -> bool:
|
||||
if mode in [ 'output', 'preview' ] and not is_image(state_manager.get_item('target_path')) and not is_video(state_manager.get_item('target_path')):
|
||||
logger.error(wording.get('choose_image_or_video_target') + wording.get('exclamation_mark'), __name__)
|
||||
logger.error(translator.get('choose_image_or_video_target') + translator.get('exclamation_mark'), __name__)
|
||||
return False
|
||||
if mode == 'output' and not in_directory(state_manager.get_item('output_path')):
|
||||
logger.error(wording.get('specify_image_or_video_output') + wording.get('exclamation_mark'), __name__)
|
||||
logger.error(translator.get('specify_image_or_video_output') + translator.get('exclamation_mark'), __name__)
|
||||
return False
|
||||
if mode == 'output' and not same_file_extension(state_manager.get_item('target_path'), state_manager.get_item('output_path')):
|
||||
logger.error(wording.get('match_target_and_output_extension') + wording.get('exclamation_mark'), __name__)
|
||||
logger.error(translator.get('match_target_and_output_extension') + translator.get('exclamation_mark'), __name__)
|
||||
return False
|
||||
return True
|
||||
|
||||
|
||||
def post_process() -> None:
|
||||
read_static_image.cache_clear()
|
||||
read_static_video_frame.cache_clear()
|
||||
video_manager.clear_video_pool()
|
||||
if state_manager.get_item('video_memory_strategy') in [ 'strict', 'moderate' ]:
|
||||
clear_inference_pool()
|
||||
@@ -143,8 +148,8 @@ def modify_age(target_face : Face, temp_vision_frame : VisionFrame) -> VisionFra
|
||||
|
||||
if 'occlusion' in state_manager.get_item('face_mask_types'):
|
||||
occlusion_mask = create_occlusion_mask(crop_vision_frame)
|
||||
combined_matrix = merge_matrix([ extend_affine_matrix, cv2.invertAffineTransform(affine_matrix) ])
|
||||
occlusion_mask = cv2.warpAffine(occlusion_mask, combined_matrix, model_sizes.get('target_with_background'))
|
||||
temp_matrix = merge_matrix([ extend_affine_matrix, cv2.invertAffineTransform(affine_matrix) ])
|
||||
occlusion_mask = cv2.warpAffine(occlusion_mask, temp_matrix, model_sizes.get('target_with_background'))
|
||||
crop_masks.append(occlusion_mask)
|
||||
|
||||
crop_vision_frame = prepare_vision_frame(crop_vision_frame)
|
||||
@@ -164,7 +169,7 @@ def forward(crop_vision_frame : VisionFrame, extend_vision_frame : VisionFrame,
|
||||
age_modifier = get_inference_pool().get('age_modifier')
|
||||
age_modifier_inputs = {}
|
||||
|
||||
if has_execution_provider('coreml'):
|
||||
if is_macos() and has_execution_provider('coreml'):
|
||||
age_modifier.set_providers([ facefusion.choices.execution_provider_set.get('cpu') ])
|
||||
|
||||
for age_modifier_input in age_modifier.get_inputs():
|
||||
@@ -199,56 +204,16 @@ def normalize_extend_frame(extend_vision_frame : VisionFrame) -> VisionFrame:
|
||||
return extend_vision_frame
|
||||
|
||||
|
||||
def get_reference_frame(source_face : Face, target_face : Face, temp_vision_frame : VisionFrame) -> VisionFrame:
|
||||
return modify_age(target_face, temp_vision_frame)
|
||||
|
||||
|
||||
def process_frame(inputs : AgeModifierInputs) -> VisionFrame:
|
||||
reference_faces = inputs.get('reference_faces')
|
||||
def process_frame(inputs : AgeModifierInputs) -> ProcessorOutputs:
|
||||
reference_vision_frame = inputs.get('reference_vision_frame')
|
||||
target_vision_frame = inputs.get('target_vision_frame')
|
||||
many_faces = sort_and_filter_faces(get_many_faces([ target_vision_frame ]))
|
||||
temp_vision_frame = inputs.get('temp_vision_frame')
|
||||
temp_vision_mask = inputs.get('temp_vision_mask')
|
||||
target_faces = select_faces(reference_vision_frame, target_vision_frame)
|
||||
|
||||
if state_manager.get_item('face_selector_mode') == 'many':
|
||||
if many_faces:
|
||||
for target_face in many_faces:
|
||||
target_vision_frame = modify_age(target_face, target_vision_frame)
|
||||
if state_manager.get_item('face_selector_mode') == 'one':
|
||||
target_face = get_one_face(many_faces)
|
||||
if target_face:
|
||||
target_vision_frame = modify_age(target_face, target_vision_frame)
|
||||
if state_manager.get_item('face_selector_mode') == 'reference':
|
||||
similar_faces = find_similar_faces(many_faces, reference_faces, state_manager.get_item('reference_face_distance'))
|
||||
if similar_faces:
|
||||
for similar_face in similar_faces:
|
||||
target_vision_frame = modify_age(similar_face, target_vision_frame)
|
||||
return target_vision_frame
|
||||
if target_faces:
|
||||
for target_face in target_faces:
|
||||
target_face = scale_face(target_face, target_vision_frame, temp_vision_frame)
|
||||
temp_vision_frame = modify_age(target_face, temp_vision_frame)
|
||||
|
||||
|
||||
def process_frames(source_path : List[str], queue_payloads : List[QueuePayload], update_progress : UpdateProgress) -> None:
|
||||
reference_faces = get_reference_faces() if 'reference' in state_manager.get_item('face_selector_mode') else None
|
||||
|
||||
for queue_payload in process_manager.manage(queue_payloads):
|
||||
target_vision_path = queue_payload['frame_path']
|
||||
target_vision_frame = read_image(target_vision_path)
|
||||
output_vision_frame = process_frame(
|
||||
{
|
||||
'reference_faces': reference_faces,
|
||||
'target_vision_frame': target_vision_frame
|
||||
})
|
||||
write_image(target_vision_path, output_vision_frame)
|
||||
update_progress(1)
|
||||
|
||||
|
||||
def process_image(source_path : str, target_path : str, output_path : str) -> None:
|
||||
reference_faces = get_reference_faces() if 'reference' in state_manager.get_item('face_selector_mode') else None
|
||||
target_vision_frame = read_static_image(target_path)
|
||||
output_vision_frame = process_frame(
|
||||
{
|
||||
'reference_faces': reference_faces,
|
||||
'target_vision_frame': target_vision_frame
|
||||
})
|
||||
write_image(output_path, output_vision_frame)
|
||||
|
||||
|
||||
def process_video(source_paths : List[str], temp_frame_paths : List[str]) -> None:
|
||||
processors.multi_process_frames(None, temp_frame_paths, process_frames)
|
||||
return temp_vision_frame, temp_vision_mask
|
||||
@@ -0,0 +1,18 @@
|
||||
from facefusion.types import Locals
|
||||
|
||||
LOCALS : Locals =\
|
||||
{
|
||||
'en':
|
||||
{
|
||||
'help':
|
||||
{
|
||||
'model': 'choose the model responsible for aging the face',
|
||||
'direction': 'specify the direction in which the age should be modified'
|
||||
},
|
||||
'uis':
|
||||
{
|
||||
'direction_slider': 'AGE MODIFIER DIRECTION',
|
||||
'model_dropdown': 'AGE MODIFIER MODEL'
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,17 @@
|
||||
from typing import Any, Literal, TypeAlias, TypedDict
|
||||
|
||||
from numpy.typing import NDArray
|
||||
|
||||
from facefusion.types import Mask, VisionFrame
|
||||
|
||||
AgeModifierInputs = TypedDict('AgeModifierInputs',
|
||||
{
|
||||
'reference_vision_frame' : VisionFrame,
|
||||
'target_vision_frame' : VisionFrame,
|
||||
'temp_vision_frame' : VisionFrame,
|
||||
'temp_vision_mask' : Mask
|
||||
})
|
||||
|
||||
AgeModifierModel = Literal['styleganex_age']
|
||||
|
||||
AgeModifierDirection : TypeAlias = NDArray[Any]
|
||||
@@ -0,0 +1,8 @@
|
||||
from typing import List, Sequence
|
||||
|
||||
from facefusion.common_helper import create_int_range
|
||||
from facefusion.processors.modules.background_remover.types import BackgroundRemoverModel
|
||||
|
||||
background_remover_models : List[BackgroundRemoverModel] = [ 'ben_2', 'birefnet_general', 'birefnet_portrait', 'isnet_general', 'modnet', 'ormbg', 'rmbg_1.4', 'rmbg_2.0', 'silueta', 'u2net_cloth', 'u2net_general', 'u2net_human', 'u2netp' ]
|
||||
|
||||
background_remover_color_range : Sequence[int] = create_int_range(0, 255, 1)
|
||||
@@ -0,0 +1,524 @@
|
||||
from argparse import ArgumentParser
|
||||
from functools import lru_cache, partial
|
||||
from typing import List, Tuple
|
||||
|
||||
import cv2
|
||||
import numpy
|
||||
|
||||
import facefusion.jobs.job_manager
|
||||
import facefusion.jobs.job_store
|
||||
from facefusion import config, content_analyser, inference_manager, logger, state_manager, translator, video_manager
|
||||
from facefusion.common_helper import is_macos
|
||||
from facefusion.download import conditional_download_hashes, conditional_download_sources, resolve_download_url
|
||||
from facefusion.execution import has_execution_provider
|
||||
from facefusion.filesystem import in_directory, is_image, is_video, resolve_relative_path, same_file_extension
|
||||
from facefusion.normalizer import normalize_color
|
||||
from facefusion.processors.modules.background_remover import choices as background_remover_choices
|
||||
from facefusion.processors.modules.background_remover.types import BackgroundRemoverInputs
|
||||
from facefusion.processors.types import ProcessorOutputs
|
||||
from facefusion.program_helper import find_argument_group
|
||||
from facefusion.sanitizer import sanitize_int_range
|
||||
from facefusion.thread_helper import thread_semaphore
|
||||
from facefusion.types import ApplyStateItem, Args, DownloadScope, ExecutionProvider, InferencePool, Mask, ModelOptions, ModelSet, ProcessMode, VisionFrame
|
||||
from facefusion.vision import read_static_image, read_static_video_frame
|
||||
|
||||
|
||||
@lru_cache()
|
||||
def create_static_model_set(download_scope : DownloadScope) -> ModelSet:
|
||||
return\
|
||||
{
|
||||
'ben_2':
|
||||
{
|
||||
'__metadata__':
|
||||
{
|
||||
'vendor': 'PramaLLC',
|
||||
'license': 'MIT',
|
||||
'year': 2025
|
||||
},
|
||||
'hashes':
|
||||
{
|
||||
'background_remover':
|
||||
{
|
||||
'url': resolve_download_url('models-3.5.0', 'ben_2.hash'),
|
||||
'path': resolve_relative_path('../.assets/models/ben_2.hash')
|
||||
}
|
||||
},
|
||||
'sources':
|
||||
{
|
||||
'background_remover':
|
||||
{
|
||||
'url': resolve_download_url('models-3.5.0', 'ben_2.onnx'),
|
||||
'path': resolve_relative_path('../.assets/models/ben_2.onnx')
|
||||
}
|
||||
},
|
||||
'size': (1024, 1024),
|
||||
'mean': [ 0.0, 0.0, 0.0 ],
|
||||
'standard_deviation': [ 1.0, 1.0, 1.0 ]
|
||||
},
|
||||
'birefnet_general':
|
||||
{
|
||||
'__metadata__':
|
||||
{
|
||||
'vendor': 'ZhengPeng7',
|
||||
'license': 'MIT',
|
||||
'year': 2024
|
||||
},
|
||||
'hashes':
|
||||
{
|
||||
'background_remover':
|
||||
{
|
||||
'url': resolve_download_url('models-3.5.0', 'birefnet_general.hash'),
|
||||
'path': resolve_relative_path('../.assets/models/birefnet_general.hash')
|
||||
}
|
||||
},
|
||||
'sources':
|
||||
{
|
||||
'background_remover':
|
||||
{
|
||||
'url': resolve_download_url('models-3.5.0', 'birefnet_general.onnx'),
|
||||
'path': resolve_relative_path('../.assets/models/birefnet_general.onnx')
|
||||
}
|
||||
},
|
||||
'size': (1024, 1024),
|
||||
'mean': [ 0.0, 0.0, 0.0 ],
|
||||
'standard_deviation': [ 1.0, 1.0, 1.0 ]
|
||||
},
|
||||
'birefnet_portrait':
|
||||
{
|
||||
'__metadata__':
|
||||
{
|
||||
'vendor': 'ZhengPeng7',
|
||||
'license': 'MIT',
|
||||
'year': 2024
|
||||
},
|
||||
'hashes':
|
||||
{
|
||||
'background_remover':
|
||||
{
|
||||
'url': resolve_download_url('models-3.5.0', 'birefnet_portrait.hash'),
|
||||
'path': resolve_relative_path('../.assets/models/birefnet_portrait.hash')
|
||||
}
|
||||
},
|
||||
'sources':
|
||||
{
|
||||
'background_remover':
|
||||
{
|
||||
'url': resolve_download_url('models-3.5.0', 'birefnet_portrait.onnx'),
|
||||
'path': resolve_relative_path('../.assets/models/birefnet_portrait.onnx')
|
||||
}
|
||||
},
|
||||
'size': (1024, 1024),
|
||||
'mean': [ 0.0, 0.0, 0.0 ],
|
||||
'standard_deviation': [ 1.0, 1.0, 1.0 ]
|
||||
},
|
||||
'isnet_general':
|
||||
{
|
||||
'__metadata__':
|
||||
{
|
||||
'vendor': 'xuebinqin',
|
||||
'license': 'Apache-2.0',
|
||||
'year': 2022
|
||||
},
|
||||
'hashes':
|
||||
{
|
||||
'background_remover':
|
||||
{
|
||||
'url': resolve_download_url('models-3.5.0', 'isnet_general.hash'),
|
||||
'path': resolve_relative_path('../.assets/models/isnet_general.hash')
|
||||
}
|
||||
},
|
||||
'sources':
|
||||
{
|
||||
'background_remover':
|
||||
{
|
||||
'url': resolve_download_url('models-3.5.0', 'isnet_general.onnx'),
|
||||
'path': resolve_relative_path('../.assets/models/isnet_general.onnx')
|
||||
}
|
||||
},
|
||||
'size': (1024, 1024),
|
||||
'mean': [ 0.5, 0.5, 0.5 ],
|
||||
'standard_deviation': [ 1.0, 1.0, 1.0 ]
|
||||
},
|
||||
'modnet':
|
||||
{
|
||||
'__metadata__':
|
||||
{
|
||||
'vendor': 'ZHKKKe',
|
||||
'license': 'Apache-2.0',
|
||||
'year': 2020
|
||||
},
|
||||
'hashes':
|
||||
{
|
||||
'background_remover':
|
||||
{
|
||||
'url': resolve_download_url('models-3.5.0', 'modnet.hash'),
|
||||
'path': resolve_relative_path('../.assets/models/modnet.hash')
|
||||
}
|
||||
},
|
||||
'sources':
|
||||
{
|
||||
'background_remover':
|
||||
{
|
||||
'url': resolve_download_url('models-3.5.0', 'modnet.onnx'),
|
||||
'path': resolve_relative_path('../.assets/models/modnet.onnx')
|
||||
}
|
||||
},
|
||||
'size': (512, 512),
|
||||
'mean': [ 0.5, 0.5, 0.5 ],
|
||||
'standard_deviation': [ 0.5, 0.5, 0.5 ]
|
||||
},
|
||||
'ormbg':
|
||||
{
|
||||
'__metadata__':
|
||||
{
|
||||
'vendor': 'schirrmacher',
|
||||
'license': 'Apache-2.0',
|
||||
'year': 2024
|
||||
},
|
||||
'hashes':
|
||||
{
|
||||
'background_remover':
|
||||
{
|
||||
'url': resolve_download_url('models-3.5.0', 'ormbg.hash'),
|
||||
'path': resolve_relative_path('../.assets/models/ormbg.hash')
|
||||
}
|
||||
},
|
||||
'sources':
|
||||
{
|
||||
'background_remover':
|
||||
{
|
||||
'url': resolve_download_url('models-3.5.0', 'ormbg.onnx'),
|
||||
'path': resolve_relative_path('../.assets/models/ormbg.onnx')
|
||||
}
|
||||
},
|
||||
'size': (1024, 1024),
|
||||
'mean': [ 0.0, 0.0, 0.0 ],
|
||||
'standard_deviation': [ 1.0, 1.0, 1.0 ]
|
||||
},
|
||||
'rmbg_1.4':
|
||||
{
|
||||
'__metadata__':
|
||||
{
|
||||
'vendor': 'Bria',
|
||||
'license': 'Non-Commercial',
|
||||
'year': 2023
|
||||
},
|
||||
'hashes':
|
||||
{
|
||||
'background_remover':
|
||||
{
|
||||
'url': resolve_download_url('models-3.5.0', 'rmbg_1.4.hash'),
|
||||
'path': resolve_relative_path('../.assets/models/rmbg_1.4.hash')
|
||||
}
|
||||
},
|
||||
'sources':
|
||||
{
|
||||
'background_remover':
|
||||
{
|
||||
'url': resolve_download_url('models-3.5.0', 'rmbg_1.4.onnx'),
|
||||
'path': resolve_relative_path('../.assets/models/rmbg_1.4.onnx')
|
||||
}
|
||||
},
|
||||
'size': (1024, 1024),
|
||||
'mean': [ 0.5, 0.5, 0.5 ],
|
||||
'standard_deviation': [ 1.0, 1.0, 1.0 ]
|
||||
},
|
||||
'rmbg_2.0':
|
||||
{
|
||||
'__metadata__':
|
||||
{
|
||||
'vendor': 'Bria',
|
||||
'license': 'Non-Commercial',
|
||||
'year': 2024
|
||||
},
|
||||
'hashes':
|
||||
{
|
||||
'background_remover':
|
||||
{
|
||||
'url': resolve_download_url('models-3.5.0', 'rmbg_2.0.hash'),
|
||||
'path': resolve_relative_path('../.assets/models/rmbg_2.0.hash')
|
||||
}
|
||||
},
|
||||
'sources':
|
||||
{
|
||||
'background_remover':
|
||||
{
|
||||
'url': resolve_download_url('models-3.5.0', 'rmbg_2.0.onnx'),
|
||||
'path': resolve_relative_path('../.assets/models/rmbg_2.0.onnx')
|
||||
}
|
||||
},
|
||||
'size': (1024, 1024),
|
||||
'mean': [ 0.485, 0.456, 0.406 ],
|
||||
'standard_deviation': [ 0.229, 0.224, 0.225 ]
|
||||
},
|
||||
'silueta':
|
||||
{
|
||||
'__metadata__':
|
||||
{
|
||||
'vendor': 'Kikedao',
|
||||
'license': 'Apache-2.0',
|
||||
'year': 2022
|
||||
},
|
||||
'hashes':
|
||||
{
|
||||
'background_remover':
|
||||
{
|
||||
'url': resolve_download_url('models-3.5.0', 'silueta.hash'),
|
||||
'path': resolve_relative_path('../.assets/models/silueta.hash')
|
||||
}
|
||||
},
|
||||
'sources':
|
||||
{
|
||||
'background_remover':
|
||||
{
|
||||
'url': resolve_download_url('models-3.5.0', 'silueta.onnx'),
|
||||
'path': resolve_relative_path('../.assets/models/silueta.onnx')
|
||||
}
|
||||
},
|
||||
'size': (320, 320),
|
||||
'mean': [ 0.485, 0.456, 0.406 ],
|
||||
'standard_deviation': [ 0.229, 0.224, 0.225 ]
|
||||
},
|
||||
'u2net_cloth':
|
||||
{
|
||||
'__metadata__':
|
||||
{
|
||||
'vendor': 'levindabhi',
|
||||
'license': 'MIT',
|
||||
'year': 2021
|
||||
},
|
||||
'hashes':
|
||||
{
|
||||
'background_remover':
|
||||
{
|
||||
'url': resolve_download_url('models-3.5.0', 'u2net_cloth.hash'),
|
||||
'path': resolve_relative_path('../.assets/models/u2net_cloth.hash')
|
||||
}
|
||||
},
|
||||
'sources':
|
||||
{
|
||||
'background_remover':
|
||||
{
|
||||
'url': resolve_download_url('models-3.5.0', 'u2net_cloth.onnx'),
|
||||
'path': resolve_relative_path('../.assets/models/u2net_cloth.onnx')
|
||||
}
|
||||
},
|
||||
'size': (768, 768),
|
||||
'mean': [ 0.485, 0.456, 0.406 ],
|
||||
'standard_deviation': [ 0.229, 0.224, 0.225 ]
|
||||
},
|
||||
'u2net_general':
|
||||
{
|
||||
'__metadata__':
|
||||
{
|
||||
'vendor': 'xuebinqin',
|
||||
'license': 'Apache-2.0',
|
||||
'year': 2020
|
||||
},
|
||||
'hashes':
|
||||
{
|
||||
'background_remover':
|
||||
{
|
||||
'url': resolve_download_url('models-3.5.0', 'u2net_general.hash'),
|
||||
'path': resolve_relative_path('../.assets/models/u2net_general.hash')
|
||||
}
|
||||
},
|
||||
'sources':
|
||||
{
|
||||
'background_remover':
|
||||
{
|
||||
'url': resolve_download_url('models-3.5.0', 'u2net_general.onnx'),
|
||||
'path': resolve_relative_path('../.assets/models/u2net_general.onnx')
|
||||
}
|
||||
},
|
||||
'size': (320, 320),
|
||||
'mean': [ 0.485, 0.456, 0.406 ],
|
||||
'standard_deviation': [ 0.229, 0.224, 0.225 ]
|
||||
},
|
||||
'u2net_human':
|
||||
{
|
||||
'__metadata__':
|
||||
{
|
||||
'vendor': 'xuebinqin',
|
||||
'license': 'Apache-2.0',
|
||||
'year': 2021
|
||||
},
|
||||
'hashes':
|
||||
{
|
||||
'background_remover':
|
||||
{
|
||||
'url': resolve_download_url('models-3.5.0', 'u2net_human.hash'),
|
||||
'path': resolve_relative_path('../.assets/models/u2net_human.hash')
|
||||
}
|
||||
},
|
||||
'sources':
|
||||
{
|
||||
'background_remover':
|
||||
{
|
||||
'url': resolve_download_url('models-3.5.0', 'u2net_human.onnx'),
|
||||
'path': resolve_relative_path('../.assets/models/u2net_human.onnx')
|
||||
}
|
||||
},
|
||||
'size': (320, 320),
|
||||
'mean': [ 0.485, 0.456, 0.406 ],
|
||||
'standard_deviation': [ 0.229, 0.224, 0.225 ]
|
||||
},
|
||||
'u2netp':
|
||||
{
|
||||
'__metadata__':
|
||||
{
|
||||
'vendor': 'xuebinqin',
|
||||
'license': 'Apache-2.0',
|
||||
'year': 2021
|
||||
},
|
||||
'hashes':
|
||||
{
|
||||
'background_remover':
|
||||
{
|
||||
'url': resolve_download_url('models-3.5.0', 'u2netp.hash'),
|
||||
'path': resolve_relative_path('../.assets/models/u2netp.hash')
|
||||
}
|
||||
},
|
||||
'sources':
|
||||
{
|
||||
'background_remover':
|
||||
{
|
||||
'url': resolve_download_url('models-3.5.0', 'u2netp.onnx'),
|
||||
'path': resolve_relative_path('../.assets/models/u2netp.onnx')
|
||||
}
|
||||
},
|
||||
'size': (320, 320),
|
||||
'mean': [ 0.485, 0.456, 0.406 ],
|
||||
'standard_deviation': [ 0.229, 0.224, 0.225 ]
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
def get_inference_pool() -> InferencePool:
|
||||
model_names = [ state_manager.get_item('background_remover_model') ]
|
||||
model_source_set = get_model_options().get('sources')
|
||||
|
||||
return inference_manager.get_inference_pool(__name__, model_names, model_source_set)
|
||||
|
||||
|
||||
def clear_inference_pool() -> None:
|
||||
model_names = [ state_manager.get_item('background_remover_model') ]
|
||||
inference_manager.clear_inference_pool(__name__, model_names)
|
||||
|
||||
|
||||
def resolve_execution_providers() -> List[ExecutionProvider]:
|
||||
if is_macos() and has_execution_provider('coreml'):
|
||||
return [ 'cpu' ]
|
||||
return state_manager.get_item('execution_providers')
|
||||
|
||||
|
||||
def get_model_options() -> ModelOptions:
|
||||
model_name = state_manager.get_item('background_remover_model')
|
||||
return create_static_model_set('full').get(model_name)
|
||||
|
||||
|
||||
def register_args(program : ArgumentParser) -> None:
|
||||
group_processors = find_argument_group(program, 'processors')
|
||||
if group_processors:
|
||||
group_processors.add_argument('--background-remover-model', help = translator.get('help.model', __package__), default = config.get_str_value('processors', 'background_remover_model', 'rmbg_2.0'), choices = background_remover_choices.background_remover_models)
|
||||
group_processors.add_argument('--background-remover-color', help = translator.get('help.color', __package__), type = partial(sanitize_int_range, int_range = background_remover_choices.background_remover_color_range), default = config.get_int_list('processors', 'background_remover_color', '0 0 0 0'), nargs = '+')
|
||||
facefusion.jobs.job_store.register_step_keys([ 'background_remover_model', 'background_remover_color' ])
|
||||
|
||||
|
||||
def apply_args(args : Args, apply_state_item : ApplyStateItem) -> None:
|
||||
apply_state_item('background_remover_model', args.get('background_remover_model'))
|
||||
apply_state_item('background_remover_color', normalize_color(args.get('background_remover_color')))
|
||||
|
||||
|
||||
def pre_check() -> bool:
|
||||
model_hash_set = get_model_options().get('hashes')
|
||||
model_source_set = get_model_options().get('sources')
|
||||
|
||||
return conditional_download_hashes(model_hash_set) and conditional_download_sources(model_source_set)
|
||||
|
||||
|
||||
def pre_process(mode : ProcessMode) -> bool:
|
||||
if mode in [ 'output', 'preview' ] and not is_image(state_manager.get_item('target_path')) and not is_video(state_manager.get_item('target_path')):
|
||||
logger.error(translator.get('choose_image_or_video_target') + translator.get('exclamation_mark'), __name__)
|
||||
return False
|
||||
if mode == 'output' and not in_directory(state_manager.get_item('output_path')):
|
||||
logger.error(translator.get('specify_image_or_video_output') + translator.get('exclamation_mark'), __name__)
|
||||
return False
|
||||
if mode == 'output' and not same_file_extension(state_manager.get_item('target_path'), state_manager.get_item('output_path')):
|
||||
logger.error(translator.get('match_target_and_output_extension') + translator.get('exclamation_mark'), __name__)
|
||||
return False
|
||||
return True
|
||||
|
||||
|
||||
def post_process() -> None:
|
||||
read_static_image.cache_clear()
|
||||
read_static_video_frame.cache_clear()
|
||||
video_manager.clear_video_pool()
|
||||
if state_manager.get_item('video_memory_strategy') in [ 'strict', 'moderate' ]:
|
||||
clear_inference_pool()
|
||||
if state_manager.get_item('video_memory_strategy') == 'strict':
|
||||
content_analyser.clear_inference_pool()
|
||||
|
||||
|
||||
def remove_background(temp_vision_frame : VisionFrame) -> Tuple[VisionFrame, Mask]:
|
||||
temp_vision_mask = forward(prepare_temp_frame(temp_vision_frame))
|
||||
temp_vision_mask = normalize_vision_mask(temp_vision_mask)
|
||||
temp_vision_mask = cv2.resize(temp_vision_mask, temp_vision_frame.shape[:2][::-1])
|
||||
temp_vision_frame = apply_background_color(temp_vision_frame, temp_vision_mask)
|
||||
return temp_vision_frame, temp_vision_mask
|
||||
|
||||
|
||||
def forward(temp_vision_frame : VisionFrame) -> VisionFrame:
|
||||
background_remover = get_inference_pool().get('background_remover')
|
||||
model_name = state_manager.get_item('background_remover_model')
|
||||
|
||||
with thread_semaphore():
|
||||
remove_vision_frame = background_remover.run(None,
|
||||
{
|
||||
'input': temp_vision_frame
|
||||
})[0]
|
||||
|
||||
if model_name == 'u2net_cloth':
|
||||
remove_vision_frame = numpy.argmax(remove_vision_frame, axis = 1)
|
||||
|
||||
return remove_vision_frame
|
||||
|
||||
|
||||
def prepare_temp_frame(temp_vision_frame : VisionFrame) -> VisionFrame:
|
||||
model_size = get_model_options().get('size')
|
||||
model_mean = get_model_options().get('mean')
|
||||
model_standard_deviation = get_model_options().get('standard_deviation')
|
||||
|
||||
temp_vision_frame = cv2.resize(temp_vision_frame, model_size)
|
||||
temp_vision_frame = temp_vision_frame[:, :, ::-1] / 255.0
|
||||
temp_vision_frame = (temp_vision_frame - model_mean) / model_standard_deviation
|
||||
temp_vision_frame = temp_vision_frame.transpose(2, 0, 1)
|
||||
temp_vision_frame = numpy.expand_dims(temp_vision_frame, axis = 0).astype(numpy.float32)
|
||||
return temp_vision_frame
|
||||
|
||||
|
||||
def normalize_vision_mask(temp_vision_mask : Mask) -> Mask:
|
||||
temp_vision_mask = numpy.squeeze(temp_vision_mask).clip(0, 1) * 255
|
||||
temp_vision_mask = numpy.clip(temp_vision_mask, 0, 255).astype(numpy.uint8)
|
||||
return temp_vision_mask
|
||||
|
||||
|
||||
def apply_background_color(temp_vision_frame : VisionFrame, temp_vision_mask : Mask) -> VisionFrame:
|
||||
background_remover_color = state_manager.get_item('background_remover_color')
|
||||
temp_vision_mask = temp_vision_mask.astype(numpy.float32) / 255
|
||||
temp_vision_mask = numpy.expand_dims(temp_vision_mask, axis = 2)
|
||||
temp_vision_mask = (1 - temp_vision_mask) * background_remover_color[-1] / 255
|
||||
color_frame = numpy.zeros_like(temp_vision_frame)
|
||||
color_frame[:, :, 0] = background_remover_color[2]
|
||||
color_frame[:, :, 1] = background_remover_color[1]
|
||||
color_frame[:, :, 2] = background_remover_color[0]
|
||||
temp_vision_frame = temp_vision_frame * (1 - temp_vision_mask) + color_frame * temp_vision_mask
|
||||
temp_vision_frame = temp_vision_frame.astype(numpy.uint8)
|
||||
return temp_vision_frame
|
||||
|
||||
|
||||
def process_frame(inputs : BackgroundRemoverInputs) -> ProcessorOutputs:
|
||||
temp_vision_frame = inputs.get('temp_vision_frame')
|
||||
temp_vision_frame, temp_vision_mask = remove_background(temp_vision_frame)
|
||||
temp_vision_mask = numpy.minimum.reduce([ temp_vision_mask, inputs.get('temp_vision_mask') ])
|
||||
return temp_vision_frame, temp_vision_mask
|
||||
@@ -0,0 +1,21 @@
|
||||
from facefusion.types import Locals
|
||||
|
||||
LOCALS : Locals =\
|
||||
{
|
||||
'en':
|
||||
{
|
||||
'help':
|
||||
{
|
||||
'model': 'choose the model responsible for removing the background',
|
||||
'color': 'apply red, green blue and alpha values to the background'
|
||||
},
|
||||
'uis':
|
||||
{
|
||||
'model_dropdown': 'BACKGROUND REMOVER MODEL',
|
||||
'color_red_number': 'BACKGROUND COLOR RED',
|
||||
'color_green_number': 'BACKGROUND COLOR GREEN',
|
||||
'color_blue_number': 'BACKGROUND COLOR BLUE',
|
||||
'color_alpha_number': 'BACKGROUND COLOR ALPHA'
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,12 @@
|
||||
from typing import Literal, TypedDict
|
||||
|
||||
from facefusion.types import Mask, VisionFrame
|
||||
|
||||
BackgroundRemoverInputs = TypedDict('BackgroundRemoverInputs',
|
||||
{
|
||||
'target_vision_frame' : VisionFrame,
|
||||
'temp_vision_frame' : VisionFrame,
|
||||
'temp_vision_mask' : Mask
|
||||
})
|
||||
|
||||
BackgroundRemoverModel = Literal['ben_2', 'birefnet_general', 'birefnet_portrait', 'isnet_general', 'modnet', 'ormbg', 'rmbg_1.4', 'rmbg_2.0', 'silueta', 'u2net_cloth', 'u2net_general', 'u2net_human', 'u2netp']
|
||||
Executable → Regular
+2
-50
@@ -1,10 +1,9 @@
|
||||
from typing import List, Sequence
|
||||
|
||||
from facefusion.common_helper import create_float_range, create_int_range
|
||||
from facefusion.common_helper import create_int_range
|
||||
from facefusion.filesystem import get_file_name, resolve_file_paths, resolve_relative_path
|
||||
from facefusion.processors.types import AgeModifierModel, DeepSwapperModel, ExpressionRestorerModel, FaceDebuggerItem, FaceEditorModel, FaceEnhancerModel, FaceSwapperModel, FaceSwapperSet, FrameColorizerModel, FrameEnhancerModel, LipSyncerModel
|
||||
from facefusion.processors.modules.deep_swapper.types import DeepSwapperModel
|
||||
|
||||
age_modifier_models : List[AgeModifierModel] = [ 'styleganex_age' ]
|
||||
deep_swapper_models : List[DeepSwapperModel] =\
|
||||
[
|
||||
'druuzil/adam_levine_320',
|
||||
@@ -174,51 +173,4 @@ if custom_model_file_paths:
|
||||
model_id = '/'.join([ 'custom', get_file_name(model_file_path) ])
|
||||
deep_swapper_models.append(model_id)
|
||||
|
||||
expression_restorer_models : List[ExpressionRestorerModel] = [ 'live_portrait' ]
|
||||
face_debugger_items : List[FaceDebuggerItem] = [ 'bounding-box', 'face-landmark-5', 'face-landmark-5/68', 'face-landmark-68', 'face-landmark-68/5', 'face-mask', 'face-detector-score', 'face-landmarker-score', 'age', 'gender', 'race' ]
|
||||
face_editor_models : List[FaceEditorModel] = [ 'live_portrait' ]
|
||||
face_enhancer_models : List[FaceEnhancerModel] = [ 'codeformer', 'gfpgan_1.2', 'gfpgan_1.3', 'gfpgan_1.4', 'gpen_bfr_256', 'gpen_bfr_512', 'gpen_bfr_1024', 'gpen_bfr_2048', 'restoreformer_plus_plus' ]
|
||||
face_swapper_set : FaceSwapperSet =\
|
||||
{
|
||||
'blendswap_256': [ '256x256', '384x384', '512x512', '768x768', '1024x1024' ],
|
||||
'ghost_1_256': [ '256x256', '512x512', '768x768', '1024x1024' ],
|
||||
'ghost_2_256': [ '256x256', '512x512', '768x768', '1024x1024' ],
|
||||
'ghost_3_256': [ '256x256', '512x512', '768x768', '1024x1024' ],
|
||||
'hififace_unofficial_256': [ '256x256', '512x512', '768x768', '1024x1024' ],
|
||||
'hyperswap_1a_256': [ '256x256', '512x512', '768x768', '1024x1024' ],
|
||||
'hyperswap_1b_256': [ '256x256', '512x512', '768x768', '1024x1024' ],
|
||||
'hyperswap_1c_256': [ '256x256', '512x512', '768x768', '1024x1024' ],
|
||||
'inswapper_128': [ '128x128', '256x256', '384x384', '512x512', '768x768', '1024x1024' ],
|
||||
'inswapper_128_fp16': [ '128x128', '256x256', '384x384', '512x512', '768x768', '1024x1024' ],
|
||||
'simswap_256': [ '256x256', '512x512', '768x768', '1024x1024' ],
|
||||
'simswap_unofficial_512': [ '512x512', '768x768', '1024x1024' ],
|
||||
'uniface_256': [ '256x256', '512x512', '768x768', '1024x1024' ]
|
||||
}
|
||||
face_swapper_models : List[FaceSwapperModel] = list(face_swapper_set.keys())
|
||||
frame_colorizer_models : List[FrameColorizerModel] = [ 'ddcolor', 'ddcolor_artistic', 'deoldify', 'deoldify_artistic', 'deoldify_stable' ]
|
||||
frame_colorizer_sizes : List[str] = [ '192x192', '256x256', '384x384', '512x512' ]
|
||||
frame_enhancer_models : List[FrameEnhancerModel] = [ 'clear_reality_x4', 'lsdir_x4', 'nomos8k_sc_x4', 'real_esrgan_x2', 'real_esrgan_x2_fp16', 'real_esrgan_x4', 'real_esrgan_x4_fp16', 'real_esrgan_x8', 'real_esrgan_x8_fp16', 'real_hatgan_x4', 'real_web_photo_x4', 'realistic_rescaler_x4', 'remacri_x4', 'siax_x4', 'span_kendata_x4', 'swin2_sr_x4', 'ultra_sharp_x4', 'ultra_sharp_2_x4' ]
|
||||
lip_syncer_models : List[LipSyncerModel] = [ 'edtalk_256', 'wav2lip_96', 'wav2lip_gan_96' ]
|
||||
|
||||
age_modifier_direction_range : Sequence[int] = create_int_range(-100, 100, 1)
|
||||
deep_swapper_morph_range : Sequence[int] = create_int_range(0, 100, 1)
|
||||
expression_restorer_factor_range : Sequence[int] = create_int_range(0, 100, 1)
|
||||
face_editor_eyebrow_direction_range : Sequence[float] = create_float_range(-1.0, 1.0, 0.05)
|
||||
face_editor_eye_gaze_horizontal_range : Sequence[float] = create_float_range(-1.0, 1.0, 0.05)
|
||||
face_editor_eye_gaze_vertical_range : Sequence[float] = create_float_range(-1.0, 1.0, 0.05)
|
||||
face_editor_eye_open_ratio_range : Sequence[float] = create_float_range(-1.0, 1.0, 0.05)
|
||||
face_editor_lip_open_ratio_range : Sequence[float] = create_float_range(-1.0, 1.0, 0.05)
|
||||
face_editor_mouth_grim_range : Sequence[float] = create_float_range(-1.0, 1.0, 0.05)
|
||||
face_editor_mouth_pout_range : Sequence[float] = create_float_range(-1.0, 1.0, 0.05)
|
||||
face_editor_mouth_purse_range : Sequence[float] = create_float_range(-1.0, 1.0, 0.05)
|
||||
face_editor_mouth_smile_range : Sequence[float] = create_float_range(-1.0, 1.0, 0.05)
|
||||
face_editor_mouth_position_horizontal_range : Sequence[float] = create_float_range(-1.0, 1.0, 0.05)
|
||||
face_editor_mouth_position_vertical_range : Sequence[float] = create_float_range(-1.0, 1.0, 0.05)
|
||||
face_editor_head_pitch_range : Sequence[float] = create_float_range(-1.0, 1.0, 0.05)
|
||||
face_editor_head_yaw_range : Sequence[float] = create_float_range(-1.0, 1.0, 0.05)
|
||||
face_editor_head_roll_range : Sequence[float] = create_float_range(-1.0, 1.0, 0.05)
|
||||
face_enhancer_blend_range : Sequence[int] = create_int_range(0, 100, 1)
|
||||
face_enhancer_weight_range : Sequence[float] = create_float_range(0.0, 1.0, 0.05)
|
||||
frame_colorizer_blend_range : Sequence[int] = create_int_range(0, 100, 1)
|
||||
frame_enhancer_blend_range : Sequence[int] = create_int_range(0, 100, 1)
|
||||
lip_syncer_weight_range : Sequence[float] = create_float_range(0.0, 1.0, 0.05)
|
||||
+26
-66
@@ -1,6 +1,6 @@
|
||||
from argparse import ArgumentParser
|
||||
from functools import lru_cache
|
||||
from typing import List, Tuple
|
||||
from typing import Tuple
|
||||
|
||||
import cv2
|
||||
import numpy
|
||||
@@ -8,25 +8,24 @@ from cv2.typing import Size
|
||||
|
||||
import facefusion.jobs.job_manager
|
||||
import facefusion.jobs.job_store
|
||||
import facefusion.processors.core as processors
|
||||
from facefusion import config, content_analyser, face_classifier, face_detector, face_landmarker, face_masker, face_recognizer, inference_manager, logger, process_manager, state_manager, video_manager, wording
|
||||
from facefusion import config, content_analyser, face_classifier, face_detector, face_landmarker, face_masker, face_recognizer, inference_manager, logger, state_manager, translator, video_manager
|
||||
from facefusion.common_helper import create_int_metavar
|
||||
from facefusion.download import conditional_download_hashes, conditional_download_sources, resolve_download_url_by_provider
|
||||
from facefusion.face_analyser import get_many_faces, get_one_face
|
||||
from facefusion.face_analyser import scale_face
|
||||
from facefusion.face_helper import paste_back, warp_face_by_face_landmark_5
|
||||
from facefusion.face_masker import create_area_mask, create_box_mask, create_occlusion_mask, create_region_mask
|
||||
from facefusion.face_selector import find_similar_faces, sort_and_filter_faces
|
||||
from facefusion.face_store import get_reference_faces
|
||||
from facefusion.face_selector import select_faces
|
||||
from facefusion.filesystem import get_file_name, in_directory, is_image, is_video, resolve_file_paths, resolve_relative_path, same_file_extension
|
||||
from facefusion.processors import choices as processors_choices
|
||||
from facefusion.processors.types import DeepSwapperInputs, DeepSwapperMorph
|
||||
from facefusion.processors.modules.deep_swapper import choices as deep_swapper_choices
|
||||
from facefusion.processors.modules.deep_swapper.types import DeepSwapperInputs, DeepSwapperMorph
|
||||
from facefusion.processors.types import ProcessorOutputs
|
||||
from facefusion.program_helper import find_argument_group
|
||||
from facefusion.thread_helper import thread_semaphore
|
||||
from facefusion.types import ApplyStateItem, Args, DownloadScope, Face, InferencePool, Mask, ModelOptions, ModelSet, ProcessMode, QueuePayload, UpdateProgress, VisionFrame
|
||||
from facefusion.vision import conditional_match_frame_color, read_image, read_static_image, write_image
|
||||
from facefusion.types import ApplyStateItem, Args, DownloadScope, Face, InferencePool, Mask, ModelOptions, ModelSet, ProcessMode, VisionFrame
|
||||
from facefusion.vision import conditional_match_frame_color, read_static_image, read_static_video_frame
|
||||
|
||||
|
||||
@lru_cache(maxsize = None)
|
||||
@lru_cache()
|
||||
def create_static_model_set(download_scope : DownloadScope) -> ModelSet:
|
||||
model_config = []
|
||||
|
||||
@@ -277,8 +276,8 @@ def get_model_size() -> Size:
|
||||
def register_args(program : ArgumentParser) -> None:
|
||||
group_processors = find_argument_group(program, 'processors')
|
||||
if group_processors:
|
||||
group_processors.add_argument('--deep-swapper-model', help = wording.get('help.deep_swapper_model'), default = config.get_str_value('processors', 'deep_swapper_model', 'iperov/elon_musk_224'), choices = processors_choices.deep_swapper_models)
|
||||
group_processors.add_argument('--deep-swapper-morph', help = wording.get('help.deep_swapper_morph'), type = int, default = config.get_int_value('processors', 'deep_swapper_morph', '100'), choices = processors_choices.deep_swapper_morph_range, metavar = create_int_metavar(processors_choices.deep_swapper_morph_range))
|
||||
group_processors.add_argument('--deep-swapper-model', help = translator.get('help.model', __package__), default = config.get_str_value('processors', 'deep_swapper_model', 'iperov/elon_musk_224'), choices = deep_swapper_choices.deep_swapper_models)
|
||||
group_processors.add_argument('--deep-swapper-morph', help = translator.get('help.morph', __package__), type = int, default = config.get_int_value('processors', 'deep_swapper_morph', '100'), choices = deep_swapper_choices.deep_swapper_morph_range, metavar = create_int_metavar(deep_swapper_choices.deep_swapper_morph_range))
|
||||
facefusion.jobs.job_store.register_step_keys([ 'deep_swapper_model', 'deep_swapper_morph' ])
|
||||
|
||||
|
||||
@@ -298,19 +297,20 @@ def pre_check() -> bool:
|
||||
|
||||
def pre_process(mode : ProcessMode) -> bool:
|
||||
if mode in [ 'output', 'preview' ] and not is_image(state_manager.get_item('target_path')) and not is_video(state_manager.get_item('target_path')):
|
||||
logger.error(wording.get('choose_image_or_video_target') + wording.get('exclamation_mark'), __name__)
|
||||
logger.error(translator.get('choose_image_or_video_target') + translator.get('exclamation_mark'), __name__)
|
||||
return False
|
||||
if mode == 'output' and not in_directory(state_manager.get_item('output_path')):
|
||||
logger.error(wording.get('specify_image_or_video_output') + wording.get('exclamation_mark'), __name__)
|
||||
logger.error(translator.get('specify_image_or_video_output') + translator.get('exclamation_mark'), __name__)
|
||||
return False
|
||||
if mode == 'output' and not same_file_extension(state_manager.get_item('target_path'), state_manager.get_item('output_path')):
|
||||
logger.error(wording.get('match_target_and_output_extension') + wording.get('exclamation_mark'), __name__)
|
||||
logger.error(translator.get('match_target_and_output_extension') + translator.get('exclamation_mark'), __name__)
|
||||
return False
|
||||
return True
|
||||
|
||||
|
||||
def post_process() -> None:
|
||||
read_static_image.cache_clear()
|
||||
read_static_video_frame.cache_clear()
|
||||
video_manager.clear_video_pool()
|
||||
if state_manager.get_item('video_memory_strategy') in [ 'strict', 'moderate' ]:
|
||||
clear_inference_pool()
|
||||
@@ -409,56 +409,16 @@ def prepare_crop_mask(crop_source_mask : Mask, crop_target_mask : Mask) -> Mask:
|
||||
return crop_mask
|
||||
|
||||
|
||||
def get_reference_frame(source_face : Face, target_face : Face, temp_vision_frame : VisionFrame) -> VisionFrame:
|
||||
return swap_face(target_face, temp_vision_frame)
|
||||
|
||||
|
||||
def process_frame(inputs : DeepSwapperInputs) -> VisionFrame:
|
||||
reference_faces = inputs.get('reference_faces')
|
||||
def process_frame(inputs : DeepSwapperInputs) -> ProcessorOutputs:
|
||||
reference_vision_frame = inputs.get('reference_vision_frame')
|
||||
target_vision_frame = inputs.get('target_vision_frame')
|
||||
many_faces = sort_and_filter_faces(get_many_faces([ target_vision_frame ]))
|
||||
temp_vision_frame = inputs.get('temp_vision_frame')
|
||||
temp_vision_mask = inputs.get('temp_vision_mask')
|
||||
target_faces = select_faces(reference_vision_frame, target_vision_frame)
|
||||
|
||||
if state_manager.get_item('face_selector_mode') == 'many':
|
||||
if many_faces:
|
||||
for target_face in many_faces:
|
||||
target_vision_frame = swap_face(target_face, target_vision_frame)
|
||||
if state_manager.get_item('face_selector_mode') == 'one':
|
||||
target_face = get_one_face(many_faces)
|
||||
if target_face:
|
||||
target_vision_frame = swap_face(target_face, target_vision_frame)
|
||||
if state_manager.get_item('face_selector_mode') == 'reference':
|
||||
similar_faces = find_similar_faces(many_faces, reference_faces, state_manager.get_item('reference_face_distance'))
|
||||
if similar_faces:
|
||||
for similar_face in similar_faces:
|
||||
target_vision_frame = swap_face(similar_face, target_vision_frame)
|
||||
return target_vision_frame
|
||||
if target_faces:
|
||||
for target_face in target_faces:
|
||||
target_face = scale_face(target_face, target_vision_frame, temp_vision_frame)
|
||||
temp_vision_frame = swap_face(target_face, temp_vision_frame)
|
||||
|
||||
|
||||
def process_frames(source_path : List[str], queue_payloads : List[QueuePayload], update_progress : UpdateProgress) -> None:
|
||||
reference_faces = get_reference_faces() if 'reference' in state_manager.get_item('face_selector_mode') else None
|
||||
|
||||
for queue_payload in process_manager.manage(queue_payloads):
|
||||
target_vision_path = queue_payload['frame_path']
|
||||
target_vision_frame = read_image(target_vision_path)
|
||||
output_vision_frame = process_frame(
|
||||
{
|
||||
'reference_faces': reference_faces,
|
||||
'target_vision_frame': target_vision_frame
|
||||
})
|
||||
write_image(target_vision_path, output_vision_frame)
|
||||
update_progress(1)
|
||||
|
||||
|
||||
def process_image(source_path : str, target_path : str, output_path : str) -> None:
|
||||
reference_faces = get_reference_faces() if 'reference' in state_manager.get_item('face_selector_mode') else None
|
||||
target_vision_frame = read_static_image(target_path)
|
||||
output_vision_frame = process_frame(
|
||||
{
|
||||
'reference_faces': reference_faces,
|
||||
'target_vision_frame': target_vision_frame
|
||||
})
|
||||
write_image(output_path, output_vision_frame)
|
||||
|
||||
|
||||
def process_video(source_paths : List[str], temp_frame_paths : List[str]) -> None:
|
||||
processors.multi_process_frames(None, temp_frame_paths, process_frames)
|
||||
return temp_vision_frame, temp_vision_mask
|
||||
@@ -0,0 +1,18 @@
|
||||
from facefusion.types import Locals
|
||||
|
||||
LOCALS : Locals =\
|
||||
{
|
||||
'en':
|
||||
{
|
||||
'help':
|
||||
{
|
||||
'model': 'choose the model responsible for swapping the face',
|
||||
'morph': 'morph between source face and target faces'
|
||||
},
|
||||
'uis':
|
||||
{
|
||||
'model_dropdown': 'DEEP SWAPPER MODEL',
|
||||
'morph_slider': 'DEEP SWAPPER MORPH'
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,17 @@
|
||||
from typing import Any, TypeAlias, TypedDict
|
||||
|
||||
from numpy.typing import NDArray
|
||||
|
||||
from facefusion.types import Mask, VisionFrame
|
||||
|
||||
DeepSwapperInputs = TypedDict('DeepSwapperInputs',
|
||||
{
|
||||
'reference_vision_frame' : VisionFrame,
|
||||
'target_vision_frame' : VisionFrame,
|
||||
'temp_vision_frame' : VisionFrame,
|
||||
'temp_vision_mask' : Mask
|
||||
})
|
||||
|
||||
DeepSwapperModel : TypeAlias = str
|
||||
|
||||
DeepSwapperMorph : TypeAlias = NDArray[Any]
|
||||
@@ -0,0 +1,10 @@
|
||||
from typing import List, Sequence
|
||||
|
||||
from facefusion.common_helper import create_int_range
|
||||
from facefusion.processors.modules.expression_restorer.types import ExpressionRestorerArea, ExpressionRestorerModel
|
||||
|
||||
expression_restorer_models : List[ExpressionRestorerModel] = [ 'live_portrait' ]
|
||||
|
||||
expression_restorer_areas : List[ExpressionRestorerArea] = [ 'upper-face', 'lower-face' ]
|
||||
|
||||
expression_restorer_factor_range : Sequence[int] = create_int_range(0, 100, 1)
|
||||
+71
-99
@@ -1,37 +1,42 @@
|
||||
from argparse import ArgumentParser
|
||||
from functools import lru_cache
|
||||
from typing import List, Tuple
|
||||
from typing import Tuple
|
||||
|
||||
import cv2
|
||||
import numpy
|
||||
|
||||
import facefusion.jobs.job_manager
|
||||
import facefusion.jobs.job_store
|
||||
import facefusion.processors.core as processors
|
||||
from facefusion import config, content_analyser, face_classifier, face_detector, face_landmarker, face_masker, face_recognizer, inference_manager, logger, process_manager, state_manager, video_manager, wording
|
||||
from facefusion import config, content_analyser, face_classifier, face_detector, face_landmarker, face_masker, face_recognizer, inference_manager, logger, state_manager, translator, video_manager
|
||||
from facefusion.common_helper import create_int_metavar
|
||||
from facefusion.download import conditional_download_hashes, conditional_download_sources, resolve_download_url
|
||||
from facefusion.face_analyser import get_many_faces, get_one_face
|
||||
from facefusion.face_analyser import scale_face
|
||||
from facefusion.face_helper import paste_back, warp_face_by_face_landmark_5
|
||||
from facefusion.face_masker import create_box_mask, create_occlusion_mask
|
||||
from facefusion.face_selector import find_similar_faces, sort_and_filter_faces
|
||||
from facefusion.face_store import get_reference_faces
|
||||
from facefusion.face_selector import select_faces
|
||||
from facefusion.filesystem import in_directory, is_image, is_video, resolve_relative_path, same_file_extension
|
||||
from facefusion.processors import choices as processors_choices
|
||||
from facefusion.processors.live_portrait import create_rotation, limit_expression
|
||||
from facefusion.processors.types import ExpressionRestorerInputs, LivePortraitExpression, LivePortraitFeatureVolume, LivePortraitMotionPoints, LivePortraitPitch, LivePortraitRoll, LivePortraitScale, LivePortraitTranslation, LivePortraitYaw
|
||||
from facefusion.processors.modules.expression_restorer import choices as expression_restorer_choices
|
||||
from facefusion.processors.modules.expression_restorer.types import ExpressionRestorerInputs
|
||||
from facefusion.processors.types import LivePortraitExpression, LivePortraitFeatureVolume, LivePortraitMotionPoints, LivePortraitPitch, LivePortraitRoll, LivePortraitScale, LivePortraitTranslation, LivePortraitYaw, ProcessorOutputs
|
||||
from facefusion.program_helper import find_argument_group
|
||||
from facefusion.thread_helper import conditional_thread_semaphore, thread_semaphore
|
||||
from facefusion.types import ApplyStateItem, Args, DownloadScope, Face, InferencePool, ModelOptions, ModelSet, ProcessMode, QueuePayload, UpdateProgress, VisionFrame
|
||||
from facefusion.vision import read_image, read_static_image, read_video_frame, write_image
|
||||
from facefusion.types import ApplyStateItem, Args, DownloadScope, Face, InferencePool, ModelOptions, ModelSet, ProcessMode, VisionFrame
|
||||
from facefusion.vision import read_static_image, read_static_video_frame
|
||||
|
||||
|
||||
@lru_cache(maxsize = None)
|
||||
@lru_cache()
|
||||
def create_static_model_set(download_scope : DownloadScope) -> ModelSet:
|
||||
return\
|
||||
{
|
||||
'live_portrait':
|
||||
{
|
||||
'__metadata__':
|
||||
{
|
||||
'vendor': 'KwaiVGI',
|
||||
'license': 'MIT',
|
||||
'year': 2024
|
||||
},
|
||||
'hashes':
|
||||
{
|
||||
'feature_extractor':
|
||||
@@ -94,14 +99,16 @@ def get_model_options() -> ModelOptions:
|
||||
def register_args(program : ArgumentParser) -> None:
|
||||
group_processors = find_argument_group(program, 'processors')
|
||||
if group_processors:
|
||||
group_processors.add_argument('--expression-restorer-model', help = wording.get('help.expression_restorer_model'), default = config.get_str_value('processors', 'expression_restorer_model', 'live_portrait'), choices = processors_choices.expression_restorer_models)
|
||||
group_processors.add_argument('--expression-restorer-factor', help = wording.get('help.expression_restorer_factor'), type = int, default = config.get_int_value('processors', 'expression_restorer_factor', '80'), choices = processors_choices.expression_restorer_factor_range, metavar = create_int_metavar(processors_choices.expression_restorer_factor_range))
|
||||
facefusion.jobs.job_store.register_step_keys([ 'expression_restorer_model', 'expression_restorer_factor' ])
|
||||
group_processors.add_argument('--expression-restorer-model', help = translator.get('help.model', __package__), default = config.get_str_value('processors', 'expression_restorer_model', 'live_portrait'), choices = expression_restorer_choices.expression_restorer_models)
|
||||
group_processors.add_argument('--expression-restorer-factor', help = translator.get('help.factor', __package__), type = int, default = config.get_int_value('processors', 'expression_restorer_factor', '80'), choices = expression_restorer_choices.expression_restorer_factor_range, metavar = create_int_metavar(expression_restorer_choices.expression_restorer_factor_range))
|
||||
group_processors.add_argument('--expression-restorer-areas', help = translator.get('help.areas', __package__).format(choices = ', '.join(expression_restorer_choices.expression_restorer_areas)), default = config.get_str_list('processors', 'expression_restorer_areas', ' '.join(expression_restorer_choices.expression_restorer_areas)), choices = expression_restorer_choices.expression_restorer_areas, nargs = '+', metavar = 'EXPRESSION_RESTORER_AREAS')
|
||||
facefusion.jobs.job_store.register_step_keys([ 'expression_restorer_model', 'expression_restorer_factor', 'expression_restorer_areas' ])
|
||||
|
||||
|
||||
def apply_args(args : Args, apply_state_item : ApplyStateItem) -> None:
|
||||
apply_state_item('expression_restorer_model', args.get('expression_restorer_model'))
|
||||
apply_state_item('expression_restorer_factor', args.get('expression_restorer_factor'))
|
||||
apply_state_item('expression_restorer_areas', args.get('expression_restorer_areas'))
|
||||
|
||||
|
||||
def pre_check() -> bool:
|
||||
@@ -113,22 +120,23 @@ def pre_check() -> bool:
|
||||
|
||||
def pre_process(mode : ProcessMode) -> bool:
|
||||
if mode == 'stream':
|
||||
logger.error(wording.get('stream_not_supported') + wording.get('exclamation_mark'), __name__)
|
||||
logger.error(translator.get('stream_not_supported') + translator.get('exclamation_mark'), __name__)
|
||||
return False
|
||||
if mode in [ 'output', 'preview' ] and not is_image(state_manager.get_item('target_path')) and not is_video(state_manager.get_item('target_path')):
|
||||
logger.error(wording.get('choose_image_or_video_target') + wording.get('exclamation_mark'), __name__)
|
||||
logger.error(translator.get('choose_image_or_video_target') + translator.get('exclamation_mark'), __name__)
|
||||
return False
|
||||
if mode == 'output' and not in_directory(state_manager.get_item('output_path')):
|
||||
logger.error(wording.get('specify_image_or_video_output') + wording.get('exclamation_mark'), __name__)
|
||||
logger.error(translator.get('specify_image_or_video_output') + translator.get('exclamation_mark'), __name__)
|
||||
return False
|
||||
if mode == 'output' and not same_file_extension(state_manager.get_item('target_path'), state_manager.get_item('output_path')):
|
||||
logger.error(wording.get('match_target_and_output_extension') + wording.get('exclamation_mark'), __name__)
|
||||
logger.error(translator.get('match_target_and_output_extension') + translator.get('exclamation_mark'), __name__)
|
||||
return False
|
||||
return True
|
||||
|
||||
|
||||
def post_process() -> None:
|
||||
read_static_image.cache_clear()
|
||||
read_static_video_frame.cache_clear()
|
||||
video_manager.clear_video_pool()
|
||||
if state_manager.get_item('video_memory_strategy') in [ 'strict', 'moderate' ]:
|
||||
clear_inference_pool()
|
||||
@@ -141,46 +149,58 @@ def post_process() -> None:
|
||||
face_recognizer.clear_inference_pool()
|
||||
|
||||
|
||||
def restore_expression(source_vision_frame : VisionFrame, target_face : Face, temp_vision_frame : VisionFrame) -> VisionFrame:
|
||||
def restore_expression(target_face : Face, target_vision_frame : VisionFrame, temp_vision_frame : VisionFrame) -> VisionFrame:
|
||||
model_template = get_model_options().get('template')
|
||||
model_size = get_model_options().get('size')
|
||||
expression_restorer_factor = float(numpy.interp(float(state_manager.get_item('expression_restorer_factor')), [ 0, 100 ], [ 0, 1.2 ]))
|
||||
source_vision_frame = cv2.resize(source_vision_frame, temp_vision_frame.shape[:2][::-1])
|
||||
source_crop_vision_frame, _ = warp_face_by_face_landmark_5(source_vision_frame, target_face.landmark_set.get('5/68'), model_template, model_size)
|
||||
target_crop_vision_frame, affine_matrix = warp_face_by_face_landmark_5(temp_vision_frame, target_face.landmark_set.get('5/68'), model_template, model_size)
|
||||
box_mask = create_box_mask(target_crop_vision_frame, state_manager.get_item('face_mask_blur'), (0, 0, 0, 0))
|
||||
target_crop_vision_frame, _ = warp_face_by_face_landmark_5(target_vision_frame, target_face.landmark_set.get('5/68'), model_template, model_size)
|
||||
temp_crop_vision_frame, affine_matrix = warp_face_by_face_landmark_5(temp_vision_frame, target_face.landmark_set.get('5/68'), model_template, model_size)
|
||||
box_mask = create_box_mask(temp_crop_vision_frame, state_manager.get_item('face_mask_blur'), (0, 0, 0, 0))
|
||||
crop_masks =\
|
||||
[
|
||||
box_mask
|
||||
]
|
||||
|
||||
if 'occlusion' in state_manager.get_item('face_mask_types'):
|
||||
occlusion_mask = create_occlusion_mask(target_crop_vision_frame)
|
||||
occlusion_mask = create_occlusion_mask(temp_crop_vision_frame)
|
||||
crop_masks.append(occlusion_mask)
|
||||
|
||||
source_crop_vision_frame = prepare_crop_frame(source_crop_vision_frame)
|
||||
target_crop_vision_frame = prepare_crop_frame(target_crop_vision_frame)
|
||||
target_crop_vision_frame = apply_restore(source_crop_vision_frame, target_crop_vision_frame, expression_restorer_factor)
|
||||
target_crop_vision_frame = normalize_crop_frame(target_crop_vision_frame)
|
||||
temp_crop_vision_frame = prepare_crop_frame(temp_crop_vision_frame)
|
||||
temp_crop_vision_frame = apply_restore(target_crop_vision_frame, temp_crop_vision_frame, expression_restorer_factor)
|
||||
temp_crop_vision_frame = normalize_crop_frame(temp_crop_vision_frame)
|
||||
crop_mask = numpy.minimum.reduce(crop_masks).clip(0, 1)
|
||||
temp_vision_frame = paste_back(temp_vision_frame, target_crop_vision_frame, crop_mask, affine_matrix)
|
||||
return temp_vision_frame
|
||||
paste_vision_frame = paste_back(temp_vision_frame, temp_crop_vision_frame, crop_mask, affine_matrix)
|
||||
return paste_vision_frame
|
||||
|
||||
|
||||
def apply_restore(source_crop_vision_frame : VisionFrame, target_crop_vision_frame : VisionFrame, expression_restorer_factor : float) -> VisionFrame:
|
||||
feature_volume = forward_extract_feature(target_crop_vision_frame)
|
||||
source_expression = forward_extract_motion(source_crop_vision_frame)[5]
|
||||
pitch, yaw, roll, scale, translation, target_expression, motion_points = forward_extract_motion(target_crop_vision_frame)
|
||||
def apply_restore(target_crop_vision_frame : VisionFrame, temp_crop_vision_frame : VisionFrame, expression_restorer_factor : float) -> VisionFrame:
|
||||
feature_volume = forward_extract_feature(temp_crop_vision_frame)
|
||||
target_expression = forward_extract_motion(target_crop_vision_frame)[5]
|
||||
pitch, yaw, roll, scale, translation, temp_expression, motion_points = forward_extract_motion(temp_crop_vision_frame)
|
||||
rotation = create_rotation(pitch, yaw, roll)
|
||||
source_expression[:, [ 0, 4, 5, 8, 9 ]] = target_expression[:, [ 0, 4, 5, 8, 9 ]]
|
||||
source_expression = source_expression * expression_restorer_factor + target_expression * (1 - expression_restorer_factor)
|
||||
source_expression = limit_expression(source_expression)
|
||||
source_motion_points = scale * (motion_points @ rotation.T + source_expression) + translation
|
||||
target_expression = restrict_expression_areas(temp_expression, target_expression)
|
||||
target_expression = target_expression * expression_restorer_factor + temp_expression * (1 - expression_restorer_factor)
|
||||
target_expression = limit_expression(target_expression)
|
||||
target_motion_points = scale * (motion_points @ rotation.T + target_expression) + translation
|
||||
crop_vision_frame = forward_generate_frame(feature_volume, source_motion_points, target_motion_points)
|
||||
temp_motion_points = scale * (motion_points @ rotation.T + temp_expression) + translation
|
||||
crop_vision_frame = forward_generate_frame(feature_volume, target_motion_points, temp_motion_points)
|
||||
return crop_vision_frame
|
||||
|
||||
|
||||
def restrict_expression_areas(temp_expression : LivePortraitExpression, target_expression : LivePortraitExpression) -> LivePortraitExpression:
|
||||
expression_restorer_areas = state_manager.get_item('expression_restorer_areas')
|
||||
|
||||
if 'upper-face' not in expression_restorer_areas:
|
||||
target_expression[:, [1, 2, 6, 10, 11, 12, 13, 15, 16]] = temp_expression[:, [1, 2, 6, 10, 11, 12, 13, 15, 16]]
|
||||
|
||||
if 'lower-face' not in expression_restorer_areas:
|
||||
target_expression[:, [3, 7, 14, 17, 18, 19, 20]] = temp_expression[:, [3, 7, 14, 17, 18, 19, 20]]
|
||||
|
||||
target_expression[:, [0, 4, 5, 8, 9]] = temp_expression[:, [0, 4, 5, 8, 9]]
|
||||
return target_expression
|
||||
|
||||
|
||||
def forward_extract_feature(crop_vision_frame : VisionFrame) -> LivePortraitFeatureVolume:
|
||||
feature_extractor = get_inference_pool().get('feature_extractor')
|
||||
|
||||
@@ -205,15 +225,15 @@ def forward_extract_motion(crop_vision_frame : VisionFrame) -> Tuple[LivePortrai
|
||||
return pitch, yaw, roll, scale, translation, expression, motion_points
|
||||
|
||||
|
||||
def forward_generate_frame(feature_volume : LivePortraitFeatureVolume, source_motion_points : LivePortraitMotionPoints, target_motion_points : LivePortraitMotionPoints) -> VisionFrame:
|
||||
def forward_generate_frame(feature_volume : LivePortraitFeatureVolume, target_motion_points : LivePortraitMotionPoints, temp_motion_points : LivePortraitMotionPoints) -> VisionFrame:
|
||||
generator = get_inference_pool().get('generator')
|
||||
|
||||
with thread_semaphore():
|
||||
crop_vision_frame = generator.run(None,
|
||||
{
|
||||
'feature_volume': feature_volume,
|
||||
'source': source_motion_points,
|
||||
'target': target_motion_points
|
||||
'source': target_motion_points,
|
||||
'target': temp_motion_points
|
||||
})[0][0]
|
||||
|
||||
return crop_vision_frame
|
||||
@@ -235,64 +255,16 @@ def normalize_crop_frame(crop_vision_frame : VisionFrame) -> VisionFrame:
|
||||
return crop_vision_frame
|
||||
|
||||
|
||||
def get_reference_frame(source_face : Face, target_face : Face, temp_vision_frame : VisionFrame) -> VisionFrame:
|
||||
pass
|
||||
|
||||
|
||||
def process_frame(inputs : ExpressionRestorerInputs) -> VisionFrame:
|
||||
reference_faces = inputs.get('reference_faces')
|
||||
source_vision_frame = inputs.get('source_vision_frame')
|
||||
def process_frame(inputs : ExpressionRestorerInputs) -> ProcessorOutputs:
|
||||
reference_vision_frame = inputs.get('reference_vision_frame')
|
||||
target_vision_frame = inputs.get('target_vision_frame')
|
||||
many_faces = sort_and_filter_faces(get_many_faces([ target_vision_frame ]))
|
||||
temp_vision_frame = inputs.get('temp_vision_frame')
|
||||
temp_vision_mask = inputs.get('temp_vision_mask')
|
||||
target_faces = select_faces(reference_vision_frame, target_vision_frame)
|
||||
|
||||
if state_manager.get_item('face_selector_mode') == 'many':
|
||||
if many_faces:
|
||||
for target_face in many_faces:
|
||||
target_vision_frame = restore_expression(source_vision_frame, target_face, target_vision_frame)
|
||||
if state_manager.get_item('face_selector_mode') == 'one':
|
||||
target_face = get_one_face(many_faces)
|
||||
if target_face:
|
||||
target_vision_frame = restore_expression(source_vision_frame, target_face, target_vision_frame)
|
||||
if state_manager.get_item('face_selector_mode') == 'reference':
|
||||
similar_faces = find_similar_faces(many_faces, reference_faces, state_manager.get_item('reference_face_distance'))
|
||||
if similar_faces:
|
||||
for similar_face in similar_faces:
|
||||
target_vision_frame = restore_expression(source_vision_frame, similar_face, target_vision_frame)
|
||||
return target_vision_frame
|
||||
if target_faces:
|
||||
for target_face in target_faces:
|
||||
target_face = scale_face(target_face, target_vision_frame, temp_vision_frame)
|
||||
temp_vision_frame = restore_expression(target_face, target_vision_frame, temp_vision_frame)
|
||||
|
||||
|
||||
def process_frames(source_path : List[str], queue_payloads : List[QueuePayload], update_progress : UpdateProgress) -> None:
|
||||
reference_faces = get_reference_faces() if 'reference' in state_manager.get_item('face_selector_mode') else None
|
||||
|
||||
for queue_payload in process_manager.manage(queue_payloads):
|
||||
frame_number = queue_payload.get('frame_number')
|
||||
if state_manager.get_item('trim_frame_start'):
|
||||
frame_number += state_manager.get_item('trim_frame_start')
|
||||
source_vision_frame = read_video_frame(state_manager.get_item('target_path'), frame_number)
|
||||
target_vision_path = queue_payload.get('frame_path')
|
||||
target_vision_frame = read_image(target_vision_path)
|
||||
output_vision_frame = process_frame(
|
||||
{
|
||||
'reference_faces': reference_faces,
|
||||
'source_vision_frame': source_vision_frame,
|
||||
'target_vision_frame': target_vision_frame
|
||||
})
|
||||
write_image(target_vision_path, output_vision_frame)
|
||||
update_progress(1)
|
||||
|
||||
|
||||
def process_image(source_path : str, target_path : str, output_path : str) -> None:
|
||||
reference_faces = get_reference_faces() if 'reference' in state_manager.get_item('face_selector_mode') else None
|
||||
source_vision_frame = read_static_image(state_manager.get_item('target_path'))
|
||||
target_vision_frame = read_static_image(target_path)
|
||||
output_vision_frame = process_frame(
|
||||
{
|
||||
'reference_faces': reference_faces,
|
||||
'source_vision_frame': source_vision_frame,
|
||||
'target_vision_frame': target_vision_frame
|
||||
})
|
||||
write_image(output_path, output_vision_frame)
|
||||
|
||||
|
||||
def process_video(source_paths : List[str], temp_frame_paths : List[str]) -> None:
|
||||
processors.multi_process_frames(None, temp_frame_paths, process_frames)
|
||||
return temp_vision_frame, temp_vision_mask
|
||||
@@ -0,0 +1,20 @@
|
||||
from facefusion.types import Locals
|
||||
|
||||
LOCALS : Locals =\
|
||||
{
|
||||
'en':
|
||||
{
|
||||
'help':
|
||||
{
|
||||
'model': 'choose the model responsible for restoring the expression',
|
||||
'factor': 'restore factor of expression from the target face',
|
||||
'areas': 'choose the items used for the expression areas (choices: {choices})'
|
||||
},
|
||||
'uis':
|
||||
{
|
||||
'model_dropdown': 'EXPRESSION RESTORER MODEL',
|
||||
'factor_slider': 'EXPRESSION RESTORER FACTOR',
|
||||
'areas_checkbox_group': 'EXPRESSION RESTORER AREAS'
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,16 @@
|
||||
from typing import List, Literal, TypedDict
|
||||
|
||||
from facefusion.types import Mask, VisionFrame
|
||||
|
||||
ExpressionRestorerInputs = TypedDict('ExpressionRestorerInputs',
|
||||
{
|
||||
'reference_vision_frame' : VisionFrame,
|
||||
'source_vision_frames' : List[VisionFrame],
|
||||
'target_vision_frame' : VisionFrame,
|
||||
'temp_vision_frame' : VisionFrame,
|
||||
'temp_vision_mask' : Mask
|
||||
})
|
||||
|
||||
ExpressionRestorerModel = Literal['live_portrait']
|
||||
|
||||
ExpressionRestorerArea = Literal['upper-face', 'lower-face']
|
||||
@@ -1,228 +0,0 @@
|
||||
from argparse import ArgumentParser
|
||||
from typing import List
|
||||
|
||||
import cv2
|
||||
import numpy
|
||||
|
||||
import facefusion.jobs.job_manager
|
||||
import facefusion.jobs.job_store
|
||||
import facefusion.processors.core as processors
|
||||
from facefusion import config, content_analyser, face_classifier, face_detector, face_landmarker, face_masker, face_recognizer, logger, process_manager, state_manager, video_manager, wording
|
||||
from facefusion.face_analyser import get_many_faces, get_one_face
|
||||
from facefusion.face_helper import warp_face_by_face_landmark_5
|
||||
from facefusion.face_masker import create_area_mask, create_box_mask, create_occlusion_mask, create_region_mask
|
||||
from facefusion.face_selector import find_similar_faces, sort_and_filter_faces
|
||||
from facefusion.face_store import get_reference_faces
|
||||
from facefusion.filesystem import in_directory, same_file_extension
|
||||
from facefusion.processors import choices as processors_choices
|
||||
from facefusion.processors.types import FaceDebuggerInputs
|
||||
from facefusion.program_helper import find_argument_group
|
||||
from facefusion.types import ApplyStateItem, Args, Face, InferencePool, ProcessMode, QueuePayload, UpdateProgress, VisionFrame
|
||||
from facefusion.vision import read_image, read_static_image, write_image
|
||||
|
||||
|
||||
def get_inference_pool() -> InferencePool:
|
||||
pass
|
||||
|
||||
|
||||
def clear_inference_pool() -> None:
|
||||
pass
|
||||
|
||||
|
||||
def register_args(program : ArgumentParser) -> None:
|
||||
group_processors = find_argument_group(program, 'processors')
|
||||
if group_processors:
|
||||
group_processors.add_argument('--face-debugger-items', help = wording.get('help.face_debugger_items').format(choices = ', '.join(processors_choices.face_debugger_items)), default = config.get_str_list('processors', 'face_debugger_items', 'face-landmark-5/68 face-mask'), choices = processors_choices.face_debugger_items, nargs = '+', metavar = 'FACE_DEBUGGER_ITEMS')
|
||||
facefusion.jobs.job_store.register_step_keys([ 'face_debugger_items' ])
|
||||
|
||||
|
||||
def apply_args(args : Args, apply_state_item : ApplyStateItem) -> None:
|
||||
apply_state_item('face_debugger_items', args.get('face_debugger_items'))
|
||||
|
||||
|
||||
def pre_check() -> bool:
|
||||
return True
|
||||
|
||||
|
||||
def pre_process(mode : ProcessMode) -> bool:
|
||||
if mode == 'output' and not in_directory(state_manager.get_item('output_path')):
|
||||
logger.error(wording.get('specify_image_or_video_output') + wording.get('exclamation_mark'), __name__)
|
||||
return False
|
||||
if mode == 'output' and not same_file_extension(state_manager.get_item('target_path'), state_manager.get_item('output_path')):
|
||||
logger.error(wording.get('match_target_and_output_extension') + wording.get('exclamation_mark'), __name__)
|
||||
return False
|
||||
return True
|
||||
|
||||
|
||||
def post_process() -> None:
|
||||
read_static_image.cache_clear()
|
||||
video_manager.clear_video_pool()
|
||||
if state_manager.get_item('video_memory_strategy') == 'strict':
|
||||
content_analyser.clear_inference_pool()
|
||||
face_classifier.clear_inference_pool()
|
||||
face_detector.clear_inference_pool()
|
||||
face_landmarker.clear_inference_pool()
|
||||
face_masker.clear_inference_pool()
|
||||
face_recognizer.clear_inference_pool()
|
||||
|
||||
|
||||
def debug_face(target_face : Face, temp_vision_frame : VisionFrame) -> VisionFrame:
|
||||
primary_color = (0, 0, 255)
|
||||
primary_light_color = (100, 100, 255)
|
||||
secondary_color = (0, 255, 0)
|
||||
tertiary_color = (255, 255, 0)
|
||||
bounding_box = target_face.bounding_box.astype(numpy.int32)
|
||||
temp_vision_frame = temp_vision_frame.copy()
|
||||
has_face_landmark_5_fallback = numpy.array_equal(target_face.landmark_set.get('5'), target_face.landmark_set.get('5/68'))
|
||||
has_face_landmark_68_fallback = numpy.array_equal(target_face.landmark_set.get('68'), target_face.landmark_set.get('68/5'))
|
||||
face_debugger_items = state_manager.get_item('face_debugger_items')
|
||||
|
||||
if 'bounding-box' in face_debugger_items:
|
||||
x1, y1, x2, y2 = bounding_box
|
||||
cv2.rectangle(temp_vision_frame, (x1, y1), (x2, y2), primary_color, 2)
|
||||
|
||||
if target_face.angle == 0:
|
||||
cv2.line(temp_vision_frame, (x1, y1), (x2, y1), primary_light_color, 3)
|
||||
if target_face.angle == 180:
|
||||
cv2.line(temp_vision_frame, (x1, y2), (x2, y2), primary_light_color, 3)
|
||||
if target_face.angle == 90:
|
||||
cv2.line(temp_vision_frame, (x2, y1), (x2, y2), primary_light_color, 3)
|
||||
if target_face.angle == 270:
|
||||
cv2.line(temp_vision_frame, (x1, y1), (x1, y2), primary_light_color, 3)
|
||||
|
||||
if 'face-mask' in face_debugger_items:
|
||||
crop_vision_frame, affine_matrix = warp_face_by_face_landmark_5(temp_vision_frame, target_face.landmark_set.get('5/68'), 'arcface_128', (512, 512))
|
||||
inverse_matrix = cv2.invertAffineTransform(affine_matrix)
|
||||
temp_size = temp_vision_frame.shape[:2][::-1]
|
||||
crop_masks = []
|
||||
|
||||
if 'box' in state_manager.get_item('face_mask_types'):
|
||||
box_mask = create_box_mask(crop_vision_frame, 0, state_manager.get_item('face_mask_padding'))
|
||||
crop_masks.append(box_mask)
|
||||
|
||||
if 'occlusion' in state_manager.get_item('face_mask_types'):
|
||||
occlusion_mask = create_occlusion_mask(crop_vision_frame)
|
||||
crop_masks.append(occlusion_mask)
|
||||
|
||||
if 'area' in state_manager.get_item('face_mask_types'):
|
||||
face_landmark_68 = cv2.transform(target_face.landmark_set.get('68').reshape(1, -1, 2), affine_matrix).reshape(-1, 2)
|
||||
area_mask = create_area_mask(crop_vision_frame, face_landmark_68, state_manager.get_item('face_mask_areas'))
|
||||
crop_masks.append(area_mask)
|
||||
|
||||
if 'region' in state_manager.get_item('face_mask_types'):
|
||||
region_mask = create_region_mask(crop_vision_frame, state_manager.get_item('face_mask_regions'))
|
||||
crop_masks.append(region_mask)
|
||||
|
||||
crop_mask = numpy.minimum.reduce(crop_masks).clip(0, 1)
|
||||
crop_mask = (crop_mask * 255).astype(numpy.uint8)
|
||||
inverse_vision_frame = cv2.warpAffine(crop_mask, inverse_matrix, temp_size)
|
||||
inverse_vision_frame = cv2.threshold(inverse_vision_frame, 100, 255, cv2.THRESH_BINARY)[1]
|
||||
inverse_vision_frame[inverse_vision_frame > 0] = 255 #type:ignore[operator]
|
||||
inverse_contours = cv2.findContours(inverse_vision_frame, cv2.RETR_LIST, cv2.CHAIN_APPROX_NONE)[0]
|
||||
cv2.drawContours(temp_vision_frame, inverse_contours, -1, tertiary_color if has_face_landmark_5_fallback else secondary_color, 2)
|
||||
|
||||
if 'face-landmark-5' in face_debugger_items and numpy.any(target_face.landmark_set.get('5')):
|
||||
face_landmark_5 = target_face.landmark_set.get('5').astype(numpy.int32)
|
||||
for index in range(face_landmark_5.shape[0]):
|
||||
cv2.circle(temp_vision_frame, (face_landmark_5[index][0], face_landmark_5[index][1]), 3, primary_color, -1)
|
||||
|
||||
if 'face-landmark-5/68' in face_debugger_items and numpy.any(target_face.landmark_set.get('5/68')):
|
||||
face_landmark_5_68 = target_face.landmark_set.get('5/68').astype(numpy.int32)
|
||||
for index in range(face_landmark_5_68.shape[0]):
|
||||
cv2.circle(temp_vision_frame, (face_landmark_5_68[index][0], face_landmark_5_68[index][1]), 3, tertiary_color if has_face_landmark_5_fallback else secondary_color, -1)
|
||||
|
||||
if 'face-landmark-68' in face_debugger_items and numpy.any(target_face.landmark_set.get('68')):
|
||||
face_landmark_68 = target_face.landmark_set.get('68').astype(numpy.int32)
|
||||
for index in range(face_landmark_68.shape[0]):
|
||||
cv2.circle(temp_vision_frame, (face_landmark_68[index][0], face_landmark_68[index][1]), 3, tertiary_color if has_face_landmark_68_fallback else secondary_color, -1)
|
||||
|
||||
if 'face-landmark-68/5' in face_debugger_items and numpy.any(target_face.landmark_set.get('68')):
|
||||
face_landmark_68 = target_face.landmark_set.get('68/5').astype(numpy.int32)
|
||||
for index in range(face_landmark_68.shape[0]):
|
||||
cv2.circle(temp_vision_frame, (face_landmark_68[index][0], face_landmark_68[index][1]), 3, tertiary_color, -1)
|
||||
|
||||
if bounding_box[3] - bounding_box[1] > 50 and bounding_box[2] - bounding_box[0] > 50:
|
||||
top = bounding_box[1]
|
||||
left = bounding_box[0] - 20
|
||||
|
||||
if 'face-detector-score' in face_debugger_items:
|
||||
face_score_text = str(round(target_face.score_set.get('detector'), 2))
|
||||
top = top + 20
|
||||
cv2.putText(temp_vision_frame, face_score_text, (left, top), cv2.FONT_HERSHEY_SIMPLEX, 0.5, primary_color, 2)
|
||||
|
||||
if 'face-landmarker-score' in face_debugger_items:
|
||||
face_score_text = str(round(target_face.score_set.get('landmarker'), 2))
|
||||
top = top + 20
|
||||
cv2.putText(temp_vision_frame, face_score_text, (left, top), cv2.FONT_HERSHEY_SIMPLEX, 0.5, tertiary_color if has_face_landmark_5_fallback else secondary_color, 2)
|
||||
|
||||
if 'age' in face_debugger_items:
|
||||
face_age_text = str(target_face.age.start) + '-' + str(target_face.age.stop)
|
||||
top = top + 20
|
||||
cv2.putText(temp_vision_frame, face_age_text, (left, top), cv2.FONT_HERSHEY_SIMPLEX, 0.5, primary_color, 2)
|
||||
|
||||
if 'gender' in face_debugger_items:
|
||||
face_gender_text = target_face.gender
|
||||
top = top + 20
|
||||
cv2.putText(temp_vision_frame, face_gender_text, (left, top), cv2.FONT_HERSHEY_SIMPLEX, 0.5, primary_color, 2)
|
||||
|
||||
if 'race' in face_debugger_items:
|
||||
face_race_text = target_face.race
|
||||
top = top + 20
|
||||
cv2.putText(temp_vision_frame, face_race_text, (left, top), cv2.FONT_HERSHEY_SIMPLEX, 0.5, primary_color, 2)
|
||||
|
||||
return temp_vision_frame
|
||||
|
||||
|
||||
def get_reference_frame(source_face : Face, target_face : Face, temp_vision_frame : VisionFrame) -> VisionFrame:
|
||||
pass
|
||||
|
||||
|
||||
def process_frame(inputs : FaceDebuggerInputs) -> VisionFrame:
|
||||
reference_faces = inputs.get('reference_faces')
|
||||
target_vision_frame = inputs.get('target_vision_frame')
|
||||
many_faces = sort_and_filter_faces(get_many_faces([ target_vision_frame ]))
|
||||
|
||||
if state_manager.get_item('face_selector_mode') == 'many':
|
||||
if many_faces:
|
||||
for target_face in many_faces:
|
||||
target_vision_frame = debug_face(target_face, target_vision_frame)
|
||||
if state_manager.get_item('face_selector_mode') == 'one':
|
||||
target_face = get_one_face(many_faces)
|
||||
if target_face:
|
||||
target_vision_frame = debug_face(target_face, target_vision_frame)
|
||||
if state_manager.get_item('face_selector_mode') == 'reference':
|
||||
similar_faces = find_similar_faces(many_faces, reference_faces, state_manager.get_item('reference_face_distance'))
|
||||
if similar_faces:
|
||||
for similar_face in similar_faces:
|
||||
target_vision_frame = debug_face(similar_face, target_vision_frame)
|
||||
return target_vision_frame
|
||||
|
||||
|
||||
def process_frames(source_paths : List[str], queue_payloads : List[QueuePayload], update_progress : UpdateProgress) -> None:
|
||||
reference_faces = get_reference_faces() if 'reference' in state_manager.get_item('face_selector_mode') else None
|
||||
|
||||
for queue_payload in process_manager.manage(queue_payloads):
|
||||
target_vision_path = queue_payload['frame_path']
|
||||
target_vision_frame = read_image(target_vision_path)
|
||||
output_vision_frame = process_frame(
|
||||
{
|
||||
'reference_faces': reference_faces,
|
||||
'target_vision_frame': target_vision_frame
|
||||
})
|
||||
write_image(target_vision_path, output_vision_frame)
|
||||
update_progress(1)
|
||||
|
||||
|
||||
def process_image(source_paths : List[str], target_path : str, output_path : str) -> None:
|
||||
reference_faces = get_reference_faces() if 'reference' in state_manager.get_item('face_selector_mode') else None
|
||||
target_vision_frame = read_static_image(target_path)
|
||||
output_vision_frame = process_frame(
|
||||
{
|
||||
'reference_faces': reference_faces,
|
||||
'target_vision_frame': target_vision_frame
|
||||
})
|
||||
write_image(output_path, output_vision_frame)
|
||||
|
||||
|
||||
def process_video(source_paths : List[str], temp_frame_paths : List[str]) -> None:
|
||||
processors.multi_process_frames(source_paths, temp_frame_paths, process_frames)
|
||||
@@ -0,0 +1,5 @@
|
||||
from typing import List
|
||||
|
||||
from facefusion.processors.modules.face_debugger.types import FaceDebuggerItem
|
||||
|
||||
face_debugger_items : List[FaceDebuggerItem] = [ 'bounding-box', 'face-landmark-5', 'face-landmark-5/68', 'face-landmark-68', 'face-landmark-68/5', 'face-mask' ]
|
||||
+235
@@ -0,0 +1,235 @@
|
||||
from argparse import ArgumentParser
|
||||
|
||||
import cv2
|
||||
import numpy
|
||||
|
||||
import facefusion.jobs.job_manager
|
||||
import facefusion.jobs.job_store
|
||||
from facefusion import config, content_analyser, face_classifier, face_detector, face_landmarker, face_masker, face_recognizer, logger, state_manager, translator, video_manager
|
||||
from facefusion.face_analyser import scale_face
|
||||
from facefusion.face_helper import warp_face_by_face_landmark_5
|
||||
from facefusion.face_masker import create_area_mask, create_box_mask, create_occlusion_mask, create_region_mask
|
||||
from facefusion.face_selector import select_faces
|
||||
from facefusion.filesystem import in_directory, is_image, is_video, same_file_extension
|
||||
from facefusion.processors.modules.face_debugger import choices as face_debugger_choices
|
||||
from facefusion.processors.modules.face_debugger.types import FaceDebuggerInputs
|
||||
from facefusion.processors.types import ProcessorOutputs
|
||||
from facefusion.program_helper import find_argument_group
|
||||
from facefusion.types import ApplyStateItem, Args, Face, InferencePool, ProcessMode, VisionFrame
|
||||
from facefusion.vision import read_static_image, read_static_video_frame
|
||||
|
||||
|
||||
def get_inference_pool() -> InferencePool:
|
||||
pass
|
||||
|
||||
|
||||
def clear_inference_pool() -> None:
|
||||
pass
|
||||
|
||||
|
||||
def register_args(program : ArgumentParser) -> None:
|
||||
group_processors = find_argument_group(program, 'processors')
|
||||
if group_processors:
|
||||
group_processors.add_argument('--face-debugger-items', help = translator.get('help.items', __package__).format(choices = ', '.join(face_debugger_choices.face_debugger_items)), default = config.get_str_list('processors', 'face_debugger_items', 'face-landmark-5/68 face-mask'), choices = face_debugger_choices.face_debugger_items, nargs = '+', metavar = 'FACE_DEBUGGER_ITEMS')
|
||||
facefusion.jobs.job_store.register_step_keys([ 'face_debugger_items' ])
|
||||
|
||||
|
||||
def apply_args(args : Args, apply_state_item : ApplyStateItem) -> None:
|
||||
apply_state_item('face_debugger_items', args.get('face_debugger_items'))
|
||||
|
||||
|
||||
def pre_check() -> bool:
|
||||
return True
|
||||
|
||||
|
||||
def pre_process(mode : ProcessMode) -> bool:
|
||||
if mode in [ 'output', 'preview' ] and not is_image(state_manager.get_item('target_path')) and not is_video(state_manager.get_item('target_path')):
|
||||
logger.error(translator.get('choose_image_or_video_target') + translator.get('exclamation_mark'), __name__)
|
||||
return False
|
||||
if mode == 'output' and not in_directory(state_manager.get_item('output_path')):
|
||||
logger.error(translator.get('specify_image_or_video_output') + translator.get('exclamation_mark'), __name__)
|
||||
return False
|
||||
if mode == 'output' and not same_file_extension(state_manager.get_item('target_path'), state_manager.get_item('output_path')):
|
||||
logger.error(translator.get('match_target_and_output_extension') + translator.get('exclamation_mark'), __name__)
|
||||
return False
|
||||
return True
|
||||
|
||||
|
||||
def post_process() -> None:
|
||||
read_static_image.cache_clear()
|
||||
read_static_video_frame.cache_clear()
|
||||
video_manager.clear_video_pool()
|
||||
if state_manager.get_item('video_memory_strategy') == 'strict':
|
||||
content_analyser.clear_inference_pool()
|
||||
face_classifier.clear_inference_pool()
|
||||
face_detector.clear_inference_pool()
|
||||
face_landmarker.clear_inference_pool()
|
||||
face_masker.clear_inference_pool()
|
||||
face_recognizer.clear_inference_pool()
|
||||
|
||||
|
||||
def debug_face(target_face : Face, temp_vision_frame : VisionFrame) -> VisionFrame:
|
||||
face_debugger_items = state_manager.get_item('face_debugger_items')
|
||||
|
||||
if 'bounding-box' in face_debugger_items:
|
||||
temp_vision_frame = draw_bounding_box(target_face, temp_vision_frame)
|
||||
|
||||
if 'face-mask' in face_debugger_items:
|
||||
temp_vision_frame = draw_face_mask(target_face, temp_vision_frame)
|
||||
|
||||
if 'face-landmark-5' in face_debugger_items:
|
||||
temp_vision_frame = draw_face_landmark_5(target_face, temp_vision_frame)
|
||||
|
||||
if 'face-landmark-5/68' in face_debugger_items:
|
||||
temp_vision_frame = draw_face_landmark_5_68(target_face, temp_vision_frame)
|
||||
|
||||
if 'face-landmark-68' in face_debugger_items:
|
||||
temp_vision_frame = draw_face_landmark_68(target_face, temp_vision_frame)
|
||||
|
||||
if 'face-landmark-68/5' in face_debugger_items:
|
||||
temp_vision_frame = draw_face_landmark_68_5(target_face, temp_vision_frame)
|
||||
|
||||
return temp_vision_frame
|
||||
|
||||
|
||||
def draw_bounding_box(target_face : Face, temp_vision_frame : VisionFrame) -> VisionFrame:
|
||||
temp_vision_frame = numpy.ascontiguousarray(temp_vision_frame)
|
||||
box_color = 0, 0, 255
|
||||
border_color = 100, 100, 255
|
||||
bounding_box = target_face.bounding_box.astype(numpy.int32)
|
||||
x1, y1, x2, y2 = bounding_box
|
||||
|
||||
cv2.rectangle(temp_vision_frame, (x1, y1), (x2, y2), box_color, 2)
|
||||
|
||||
if target_face.angle == 0:
|
||||
cv2.line(temp_vision_frame, (x1, y1), (x2, y1), border_color, 3)
|
||||
if target_face.angle == 180:
|
||||
cv2.line(temp_vision_frame, (x1, y2), (x2, y2), border_color, 3)
|
||||
if target_face.angle == 90:
|
||||
cv2.line(temp_vision_frame, (x2, y1), (x2, y2), border_color, 3)
|
||||
if target_face.angle == 270:
|
||||
cv2.line(temp_vision_frame, (x1, y1), (x1, y2), border_color, 3)
|
||||
|
||||
return temp_vision_frame
|
||||
|
||||
|
||||
def draw_face_mask(target_face : Face, temp_vision_frame : VisionFrame) -> VisionFrame:
|
||||
crop_masks = []
|
||||
temp_vision_frame = numpy.ascontiguousarray(temp_vision_frame)
|
||||
face_landmark_5 = target_face.landmark_set.get('5')
|
||||
face_landmark_68 = target_face.landmark_set.get('68')
|
||||
face_landmark_5_68 = target_face.landmark_set.get('5/68')
|
||||
crop_vision_frame, affine_matrix = warp_face_by_face_landmark_5(temp_vision_frame, face_landmark_5_68, 'arcface_128', (512, 512))
|
||||
inverse_matrix = cv2.invertAffineTransform(affine_matrix)
|
||||
temp_size = temp_vision_frame.shape[:2][::-1]
|
||||
mask_color = 0, 255, 0
|
||||
|
||||
if numpy.array_equal(face_landmark_5, face_landmark_5_68):
|
||||
mask_color = 255, 255, 0
|
||||
|
||||
if 'box' in state_manager.get_item('face_mask_types'):
|
||||
box_mask = create_box_mask(crop_vision_frame, 0, state_manager.get_item('face_mask_padding'))
|
||||
crop_masks.append(box_mask)
|
||||
|
||||
if 'occlusion' in state_manager.get_item('face_mask_types'):
|
||||
occlusion_mask = create_occlusion_mask(crop_vision_frame)
|
||||
crop_masks.append(occlusion_mask)
|
||||
|
||||
if 'area' in state_manager.get_item('face_mask_types'):
|
||||
face_landmark_68 = cv2.transform(face_landmark_68.reshape(1, -1, 2), affine_matrix).reshape(-1, 2)
|
||||
area_mask = create_area_mask(crop_vision_frame, face_landmark_68, state_manager.get_item('face_mask_areas'))
|
||||
crop_masks.append(area_mask)
|
||||
|
||||
if 'region' in state_manager.get_item('face_mask_types'):
|
||||
region_mask = create_region_mask(crop_vision_frame, state_manager.get_item('face_mask_regions'))
|
||||
crop_masks.append(region_mask)
|
||||
|
||||
crop_mask = numpy.minimum.reduce(crop_masks).clip(0, 1)
|
||||
crop_mask = (crop_mask * 255).astype(numpy.uint8)
|
||||
inverse_vision_frame = cv2.warpAffine(crop_mask, inverse_matrix, temp_size)
|
||||
inverse_vision_frame = cv2.threshold(inverse_vision_frame, 100, 255, cv2.THRESH_BINARY)[1]
|
||||
inverse_contours, _ = cv2.findContours(inverse_vision_frame, cv2.RETR_LIST, cv2.CHAIN_APPROX_NONE)
|
||||
cv2.drawContours(temp_vision_frame, inverse_contours, -1, mask_color, 2)
|
||||
|
||||
return temp_vision_frame
|
||||
|
||||
|
||||
def draw_face_landmark_5(target_face : Face, temp_vision_frame : VisionFrame) -> VisionFrame:
|
||||
temp_vision_frame = numpy.ascontiguousarray(temp_vision_frame)
|
||||
face_landmark_5 = target_face.landmark_set.get('5')
|
||||
point_color = 0, 0, 255
|
||||
|
||||
if numpy.any(face_landmark_5):
|
||||
face_landmark_5 = face_landmark_5.astype(numpy.int32)
|
||||
|
||||
for point in face_landmark_5:
|
||||
cv2.circle(temp_vision_frame, tuple(point), 3, point_color, -1)
|
||||
|
||||
return temp_vision_frame
|
||||
|
||||
|
||||
def draw_face_landmark_5_68(target_face : Face, temp_vision_frame : VisionFrame) -> VisionFrame:
|
||||
temp_vision_frame = numpy.ascontiguousarray(temp_vision_frame)
|
||||
face_landmark_5 = target_face.landmark_set.get('5')
|
||||
face_landmark_5_68 = target_face.landmark_set.get('5/68')
|
||||
point_color = 0, 255, 0
|
||||
|
||||
if numpy.array_equal(face_landmark_5, face_landmark_5_68):
|
||||
point_color = 255, 255, 0
|
||||
|
||||
if numpy.any(face_landmark_5_68):
|
||||
face_landmark_5_68 = face_landmark_5_68.astype(numpy.int32)
|
||||
|
||||
for point in face_landmark_5_68:
|
||||
cv2.circle(temp_vision_frame, tuple(point), 3, point_color, -1)
|
||||
|
||||
return temp_vision_frame
|
||||
|
||||
|
||||
def draw_face_landmark_68(target_face : Face, temp_vision_frame : VisionFrame) -> VisionFrame:
|
||||
temp_vision_frame = numpy.ascontiguousarray(temp_vision_frame)
|
||||
face_landmark_68 = target_face.landmark_set.get('68')
|
||||
face_landmark_68_5 = target_face.landmark_set.get('68/5')
|
||||
point_color = 0, 255, 0
|
||||
|
||||
if numpy.array_equal(face_landmark_68, face_landmark_68_5):
|
||||
point_color = 255, 255, 0
|
||||
|
||||
if numpy.any(face_landmark_68):
|
||||
face_landmark_68 = face_landmark_68.astype(numpy.int32)
|
||||
|
||||
for point in face_landmark_68:
|
||||
cv2.circle(temp_vision_frame, tuple(point), 3, point_color, -1)
|
||||
|
||||
return temp_vision_frame
|
||||
|
||||
|
||||
def draw_face_landmark_68_5(target_face : Face, temp_vision_frame : VisionFrame) -> VisionFrame:
|
||||
temp_vision_frame = numpy.ascontiguousarray(temp_vision_frame)
|
||||
face_landmark_68_5 = target_face.landmark_set.get('68/5')
|
||||
point_color = 255, 255, 0
|
||||
|
||||
if numpy.any(face_landmark_68_5):
|
||||
face_landmark_68_5 = face_landmark_68_5.astype(numpy.int32)
|
||||
|
||||
for point in face_landmark_68_5:
|
||||
cv2.circle(temp_vision_frame, tuple(point), 3, point_color, -1)
|
||||
|
||||
return temp_vision_frame
|
||||
|
||||
|
||||
def process_frame(inputs : FaceDebuggerInputs) -> ProcessorOutputs:
|
||||
reference_vision_frame = inputs.get('reference_vision_frame')
|
||||
target_vision_frame = inputs.get('target_vision_frame')
|
||||
temp_vision_frame = inputs.get('temp_vision_frame')
|
||||
temp_vision_mask = inputs.get('temp_vision_mask')
|
||||
target_faces = select_faces(reference_vision_frame, target_vision_frame)
|
||||
|
||||
if target_faces:
|
||||
for target_face in target_faces:
|
||||
target_face = scale_face(target_face, target_vision_frame, temp_vision_frame)
|
||||
temp_vision_frame = debug_face(target_face, temp_vision_frame)
|
||||
|
||||
return temp_vision_frame, temp_vision_mask
|
||||
|
||||
|
||||
@@ -0,0 +1,16 @@
|
||||
from facefusion.types import Locals
|
||||
|
||||
LOCALS : Locals =\
|
||||
{
|
||||
'en':
|
||||
{
|
||||
'help':
|
||||
{
|
||||
'items': 'load a single or multiple processors (choices: {choices})'
|
||||
},
|
||||
'uis':
|
||||
{
|
||||
'items_checkbox_group': 'FACE DEBUGGER ITEMS'
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,13 @@
|
||||
from typing import Literal, TypedDict
|
||||
|
||||
from facefusion.types import Mask, VisionFrame
|
||||
|
||||
FaceDebuggerInputs = TypedDict('FaceDebuggerInputs',
|
||||
{
|
||||
'reference_vision_frame' : VisionFrame,
|
||||
'target_vision_frame' : VisionFrame,
|
||||
'temp_vision_frame' : VisionFrame,
|
||||
'temp_vision_mask' : Mask
|
||||
})
|
||||
|
||||
FaceDebuggerItem = Literal['bounding-box', 'face-landmark-5', 'face-landmark-5/68', 'face-landmark-68', 'face-landmark-68/5', 'face-mask']
|
||||
@@ -0,0 +1,21 @@
|
||||
from typing import List, Sequence
|
||||
|
||||
from facefusion.common_helper import create_float_range
|
||||
from facefusion.processors.modules.face_editor.types import FaceEditorModel
|
||||
|
||||
face_editor_models : List[FaceEditorModel] = [ 'live_portrait' ]
|
||||
|
||||
face_editor_eyebrow_direction_range : Sequence[float] = create_float_range(-1.0, 1.0, 0.05)
|
||||
face_editor_eye_gaze_horizontal_range : Sequence[float] = create_float_range(-1.0, 1.0, 0.05)
|
||||
face_editor_eye_gaze_vertical_range : Sequence[float] = create_float_range(-1.0, 1.0, 0.05)
|
||||
face_editor_eye_open_ratio_range : Sequence[float] = create_float_range(-1.0, 1.0, 0.05)
|
||||
face_editor_lip_open_ratio_range : Sequence[float] = create_float_range(-1.0, 1.0, 0.05)
|
||||
face_editor_mouth_grim_range : Sequence[float] = create_float_range(-1.0, 1.0, 0.05)
|
||||
face_editor_mouth_pout_range : Sequence[float] = create_float_range(-1.0, 1.0, 0.05)
|
||||
face_editor_mouth_purse_range : Sequence[float] = create_float_range(-1.0, 1.0, 0.05)
|
||||
face_editor_mouth_smile_range : Sequence[float] = create_float_range(-1.0, 1.0, 0.05)
|
||||
face_editor_mouth_position_horizontal_range : Sequence[float] = create_float_range(-1.0, 1.0, 0.05)
|
||||
face_editor_mouth_position_vertical_range : Sequence[float] = create_float_range(-1.0, 1.0, 0.05)
|
||||
face_editor_head_pitch_range : Sequence[float] = create_float_range(-1.0, 1.0, 0.05)
|
||||
face_editor_head_yaw_range : Sequence[float] = create_float_range(-1.0, 1.0, 0.05)
|
||||
face_editor_head_roll_range : Sequence[float] = create_float_range(-1.0, 1.0, 0.05)
|
||||
+53
-87
@@ -1,37 +1,42 @@
|
||||
from argparse import ArgumentParser
|
||||
from functools import lru_cache
|
||||
from typing import List, Tuple
|
||||
from typing import Tuple
|
||||
|
||||
import cv2
|
||||
import numpy
|
||||
|
||||
import facefusion.jobs.job_manager
|
||||
import facefusion.jobs.job_store
|
||||
import facefusion.processors.core as processors
|
||||
from facefusion import config, content_analyser, face_classifier, face_detector, face_landmarker, face_masker, face_recognizer, inference_manager, logger, process_manager, state_manager, video_manager, wording
|
||||
from facefusion import config, content_analyser, face_classifier, face_detector, face_landmarker, face_masker, face_recognizer, inference_manager, logger, state_manager, translator, video_manager
|
||||
from facefusion.common_helper import create_float_metavar
|
||||
from facefusion.download import conditional_download_hashes, conditional_download_sources, resolve_download_url
|
||||
from facefusion.face_analyser import get_many_faces, get_one_face
|
||||
from facefusion.face_analyser import scale_face
|
||||
from facefusion.face_helper import paste_back, scale_face_landmark_5, warp_face_by_face_landmark_5
|
||||
from facefusion.face_masker import create_box_mask
|
||||
from facefusion.face_selector import find_similar_faces, sort_and_filter_faces
|
||||
from facefusion.face_store import get_reference_faces
|
||||
from facefusion.face_selector import select_faces
|
||||
from facefusion.filesystem import in_directory, is_image, is_video, resolve_relative_path, same_file_extension
|
||||
from facefusion.processors import choices as processors_choices
|
||||
from facefusion.processors.live_portrait import create_rotation, limit_euler_angles, limit_expression
|
||||
from facefusion.processors.types import FaceEditorInputs, LivePortraitExpression, LivePortraitFeatureVolume, LivePortraitMotionPoints, LivePortraitPitch, LivePortraitRoll, LivePortraitRotation, LivePortraitScale, LivePortraitTranslation, LivePortraitYaw
|
||||
from facefusion.processors.live_portrait import create_rotation, limit_angle, limit_expression
|
||||
from facefusion.processors.modules.face_editor import choices as face_editor_choices
|
||||
from facefusion.processors.modules.face_editor.types import FaceEditorInputs
|
||||
from facefusion.processors.types import LivePortraitExpression, LivePortraitFeatureVolume, LivePortraitMotionPoints, LivePortraitPitch, LivePortraitRoll, LivePortraitRotation, LivePortraitScale, LivePortraitTranslation, LivePortraitYaw, ProcessorOutputs
|
||||
from facefusion.program_helper import find_argument_group
|
||||
from facefusion.thread_helper import conditional_thread_semaphore, thread_semaphore
|
||||
from facefusion.types import ApplyStateItem, Args, DownloadScope, Face, FaceLandmark68, InferencePool, ModelOptions, ModelSet, ProcessMode, QueuePayload, UpdateProgress, VisionFrame
|
||||
from facefusion.vision import read_image, read_static_image, write_image
|
||||
from facefusion.types import ApplyStateItem, Args, DownloadScope, Face, FaceLandmark68, InferencePool, ModelOptions, ModelSet, ProcessMode, VisionFrame
|
||||
from facefusion.vision import read_static_image, read_static_video_frame
|
||||
|
||||
|
||||
@lru_cache(maxsize = None)
|
||||
@lru_cache()
|
||||
def create_static_model_set(download_scope : DownloadScope) -> ModelSet:
|
||||
return\
|
||||
{
|
||||
'live_portrait':
|
||||
{
|
||||
'__metadata__':
|
||||
{
|
||||
'vendor': 'KwaiVGI',
|
||||
'license': 'MIT',
|
||||
'year': 2024
|
||||
},
|
||||
'hashes':
|
||||
{
|
||||
'feature_extractor':
|
||||
@@ -124,21 +129,21 @@ def get_model_options() -> ModelOptions:
|
||||
def register_args(program : ArgumentParser) -> None:
|
||||
group_processors = find_argument_group(program, 'processors')
|
||||
if group_processors:
|
||||
group_processors.add_argument('--face-editor-model', help = wording.get('help.face_editor_model'), default = config.get_str_value('processors', 'face_editor_model', 'live_portrait'), choices = processors_choices.face_editor_models)
|
||||
group_processors.add_argument('--face-editor-eyebrow-direction', help = wording.get('help.face_editor_eyebrow_direction'), type = float, default = config.get_float_value('processors', 'face_editor_eyebrow_direction', '0'), choices = processors_choices.face_editor_eyebrow_direction_range, metavar = create_float_metavar(processors_choices.face_editor_eyebrow_direction_range))
|
||||
group_processors.add_argument('--face-editor-eye-gaze-horizontal', help = wording.get('help.face_editor_eye_gaze_horizontal'), type = float, default = config.get_float_value('processors', 'face_editor_eye_gaze_horizontal', '0'), choices = processors_choices.face_editor_eye_gaze_horizontal_range, metavar = create_float_metavar(processors_choices.face_editor_eye_gaze_horizontal_range))
|
||||
group_processors.add_argument('--face-editor-eye-gaze-vertical', help = wording.get('help.face_editor_eye_gaze_vertical'), type = float, default = config.get_float_value('processors', 'face_editor_eye_gaze_vertical', '0'), choices = processors_choices.face_editor_eye_gaze_vertical_range, metavar = create_float_metavar(processors_choices.face_editor_eye_gaze_vertical_range))
|
||||
group_processors.add_argument('--face-editor-eye-open-ratio', help = wording.get('help.face_editor_eye_open_ratio'), type = float, default = config.get_float_value('processors', 'face_editor_eye_open_ratio', '0'), choices = processors_choices.face_editor_eye_open_ratio_range, metavar = create_float_metavar(processors_choices.face_editor_eye_open_ratio_range))
|
||||
group_processors.add_argument('--face-editor-lip-open-ratio', help = wording.get('help.face_editor_lip_open_ratio'), type = float, default = config.get_float_value('processors', 'face_editor_lip_open_ratio', '0'), choices = processors_choices.face_editor_lip_open_ratio_range, metavar = create_float_metavar(processors_choices.face_editor_lip_open_ratio_range))
|
||||
group_processors.add_argument('--face-editor-mouth-grim', help = wording.get('help.face_editor_mouth_grim'), type = float, default = config.get_float_value('processors', 'face_editor_mouth_grim', '0'), choices = processors_choices.face_editor_mouth_grim_range, metavar = create_float_metavar(processors_choices.face_editor_mouth_grim_range))
|
||||
group_processors.add_argument('--face-editor-mouth-pout', help = wording.get('help.face_editor_mouth_pout'), type = float, default = config.get_float_value('processors', 'face_editor_mouth_pout', '0'), choices = processors_choices.face_editor_mouth_pout_range, metavar = create_float_metavar(processors_choices.face_editor_mouth_pout_range))
|
||||
group_processors.add_argument('--face-editor-mouth-purse', help = wording.get('help.face_editor_mouth_purse'), type = float, default = config.get_float_value('processors', 'face_editor_mouth_purse', '0'), choices = processors_choices.face_editor_mouth_purse_range, metavar = create_float_metavar(processors_choices.face_editor_mouth_purse_range))
|
||||
group_processors.add_argument('--face-editor-mouth-smile', help = wording.get('help.face_editor_mouth_smile'), type = float, default = config.get_float_value('processors', 'face_editor_mouth_smile', '0'), choices = processors_choices.face_editor_mouth_smile_range, metavar = create_float_metavar(processors_choices.face_editor_mouth_smile_range))
|
||||
group_processors.add_argument('--face-editor-mouth-position-horizontal', help = wording.get('help.face_editor_mouth_position_horizontal'), type = float, default = config.get_float_value('processors', 'face_editor_mouth_position_horizontal', '0'), choices = processors_choices.face_editor_mouth_position_horizontal_range, metavar = create_float_metavar(processors_choices.face_editor_mouth_position_horizontal_range))
|
||||
group_processors.add_argument('--face-editor-mouth-position-vertical', help = wording.get('help.face_editor_mouth_position_vertical'), type = float, default = config.get_float_value('processors', 'face_editor_mouth_position_vertical', '0'), choices = processors_choices.face_editor_mouth_position_vertical_range, metavar = create_float_metavar(processors_choices.face_editor_mouth_position_vertical_range))
|
||||
group_processors.add_argument('--face-editor-head-pitch', help = wording.get('help.face_editor_head_pitch'), type = float, default = config.get_float_value('processors', 'face_editor_head_pitch', '0'), choices = processors_choices.face_editor_head_pitch_range, metavar = create_float_metavar(processors_choices.face_editor_head_pitch_range))
|
||||
group_processors.add_argument('--face-editor-head-yaw', help = wording.get('help.face_editor_head_yaw'), type = float, default = config.get_float_value('processors', 'face_editor_head_yaw', '0'), choices = processors_choices.face_editor_head_yaw_range, metavar = create_float_metavar(processors_choices.face_editor_head_yaw_range))
|
||||
group_processors.add_argument('--face-editor-head-roll', help = wording.get('help.face_editor_head_roll'), type = float, default = config.get_float_value('processors', 'face_editor_head_roll', '0'), choices = processors_choices.face_editor_head_roll_range, metavar = create_float_metavar(processors_choices.face_editor_head_roll_range))
|
||||
group_processors.add_argument('--face-editor-model', help = translator.get('help.model', __package__), default = config.get_str_value('processors', 'face_editor_model', 'live_portrait'), choices = face_editor_choices.face_editor_models)
|
||||
group_processors.add_argument('--face-editor-eyebrow-direction', help = translator.get('help.eyebrow_direction', __package__), type = float, default = config.get_float_value('processors', 'face_editor_eyebrow_direction', '0'), choices = face_editor_choices.face_editor_eyebrow_direction_range, metavar = create_float_metavar(face_editor_choices.face_editor_eyebrow_direction_range))
|
||||
group_processors.add_argument('--face-editor-eye-gaze-horizontal', help = translator.get('help.eye_gaze_horizontal', __package__), type = float, default = config.get_float_value('processors', 'face_editor_eye_gaze_horizontal', '0'), choices = face_editor_choices.face_editor_eye_gaze_horizontal_range, metavar = create_float_metavar(face_editor_choices.face_editor_eye_gaze_horizontal_range))
|
||||
group_processors.add_argument('--face-editor-eye-gaze-vertical', help = translator.get('help.eye_gaze_vertical', __package__), type = float, default = config.get_float_value('processors', 'face_editor_eye_gaze_vertical', '0'), choices = face_editor_choices.face_editor_eye_gaze_vertical_range, metavar = create_float_metavar(face_editor_choices.face_editor_eye_gaze_vertical_range))
|
||||
group_processors.add_argument('--face-editor-eye-open-ratio', help = translator.get('help.eye_open_ratio', __package__), type = float, default = config.get_float_value('processors', 'face_editor_eye_open_ratio', '0'), choices = face_editor_choices.face_editor_eye_open_ratio_range, metavar = create_float_metavar(face_editor_choices.face_editor_eye_open_ratio_range))
|
||||
group_processors.add_argument('--face-editor-lip-open-ratio', help = translator.get('help.lip_open_ratio', __package__), type = float, default = config.get_float_value('processors', 'face_editor_lip_open_ratio', '0'), choices = face_editor_choices.face_editor_lip_open_ratio_range, metavar = create_float_metavar(face_editor_choices.face_editor_lip_open_ratio_range))
|
||||
group_processors.add_argument('--face-editor-mouth-grim', help = translator.get('help.mouth_grim', __package__), type = float, default = config.get_float_value('processors', 'face_editor_mouth_grim', '0'), choices = face_editor_choices.face_editor_mouth_grim_range, metavar = create_float_metavar(face_editor_choices.face_editor_mouth_grim_range))
|
||||
group_processors.add_argument('--face-editor-mouth-pout', help = translator.get('help.mouth_pout', __package__), type = float, default = config.get_float_value('processors', 'face_editor_mouth_pout', '0'), choices = face_editor_choices.face_editor_mouth_pout_range, metavar = create_float_metavar(face_editor_choices.face_editor_mouth_pout_range))
|
||||
group_processors.add_argument('--face-editor-mouth-purse', help = translator.get('help.mouth_purse', __package__), type = float, default = config.get_float_value('processors', 'face_editor_mouth_purse', '0'), choices = face_editor_choices.face_editor_mouth_purse_range, metavar = create_float_metavar(face_editor_choices.face_editor_mouth_purse_range))
|
||||
group_processors.add_argument('--face-editor-mouth-smile', help = translator.get('help.mouth_smile', __package__), type = float, default = config.get_float_value('processors', 'face_editor_mouth_smile', '0'), choices = face_editor_choices.face_editor_mouth_smile_range, metavar = create_float_metavar(face_editor_choices.face_editor_mouth_smile_range))
|
||||
group_processors.add_argument('--face-editor-mouth-position-horizontal', help = translator.get('help.mouth_position_horizontal', __package__), type = float, default = config.get_float_value('processors', 'face_editor_mouth_position_horizontal', '0'), choices = face_editor_choices.face_editor_mouth_position_horizontal_range, metavar = create_float_metavar(face_editor_choices.face_editor_mouth_position_horizontal_range))
|
||||
group_processors.add_argument('--face-editor-mouth-position-vertical', help = translator.get('help.mouth_position_vertical', __package__), type = float, default = config.get_float_value('processors', 'face_editor_mouth_position_vertical', '0'), choices = face_editor_choices.face_editor_mouth_position_vertical_range, metavar = create_float_metavar(face_editor_choices.face_editor_mouth_position_vertical_range))
|
||||
group_processors.add_argument('--face-editor-head-pitch', help = translator.get('help.head_pitch', __package__), type = float, default = config.get_float_value('processors', 'face_editor_head_pitch', '0'), choices = face_editor_choices.face_editor_head_pitch_range, metavar = create_float_metavar(face_editor_choices.face_editor_head_pitch_range))
|
||||
group_processors.add_argument('--face-editor-head-yaw', help = translator.get('help.head_yaw', __package__), type = float, default = config.get_float_value('processors', 'face_editor_head_yaw', '0'), choices = face_editor_choices.face_editor_head_yaw_range, metavar = create_float_metavar(face_editor_choices.face_editor_head_yaw_range))
|
||||
group_processors.add_argument('--face-editor-head-roll', help = translator.get('help.head_roll', __package__), type = float, default = config.get_float_value('processors', 'face_editor_head_roll', '0'), choices = face_editor_choices.face_editor_head_roll_range, metavar = create_float_metavar(face_editor_choices.face_editor_head_roll_range))
|
||||
facefusion.jobs.job_store.register_step_keys([ 'face_editor_model', 'face_editor_eyebrow_direction', 'face_editor_eye_gaze_horizontal', 'face_editor_eye_gaze_vertical', 'face_editor_eye_open_ratio', 'face_editor_lip_open_ratio', 'face_editor_mouth_grim', 'face_editor_mouth_pout', 'face_editor_mouth_purse', 'face_editor_mouth_smile', 'face_editor_mouth_position_horizontal', 'face_editor_mouth_position_vertical', 'face_editor_head_pitch', 'face_editor_head_yaw', 'face_editor_head_roll' ])
|
||||
|
||||
|
||||
@@ -169,19 +174,20 @@ def pre_check() -> bool:
|
||||
|
||||
def pre_process(mode : ProcessMode) -> bool:
|
||||
if mode in [ 'output', 'preview' ] and not is_image(state_manager.get_item('target_path')) and not is_video(state_manager.get_item('target_path')):
|
||||
logger.error(wording.get('choose_image_or_video_target') + wording.get('exclamation_mark'), __name__)
|
||||
logger.error(translator.get('choose_image_or_video_target') + translator.get('exclamation_mark'), __name__)
|
||||
return False
|
||||
if mode == 'output' and not in_directory(state_manager.get_item('output_path')):
|
||||
logger.error(wording.get('specify_image_or_video_output') + wording.get('exclamation_mark'), __name__)
|
||||
logger.error(translator.get('specify_image_or_video_output') + translator.get('exclamation_mark'), __name__)
|
||||
return False
|
||||
if mode == 'output' and not same_file_extension(state_manager.get_item('target_path'), state_manager.get_item('output_path')):
|
||||
logger.error(wording.get('match_target_and_output_extension') + wording.get('exclamation_mark'), __name__)
|
||||
logger.error(translator.get('match_target_and_output_extension') + translator.get('exclamation_mark'), __name__)
|
||||
return False
|
||||
return True
|
||||
|
||||
|
||||
def post_process() -> None:
|
||||
read_static_image.cache_clear()
|
||||
read_static_video_frame.cache_clear()
|
||||
video_manager.clear_video_pool()
|
||||
if state_manager.get_item('video_memory_strategy') in [ 'strict', 'moderate' ]:
|
||||
clear_inference_pool()
|
||||
@@ -203,8 +209,8 @@ def edit_face(target_face : Face, temp_vision_frame : VisionFrame) -> VisionFram
|
||||
crop_vision_frame = prepare_crop_frame(crop_vision_frame)
|
||||
crop_vision_frame = apply_edit(crop_vision_frame, target_face.landmark_set.get('68'))
|
||||
crop_vision_frame = normalize_crop_frame(crop_vision_frame)
|
||||
temp_vision_frame = paste_back(temp_vision_frame, crop_vision_frame, box_mask, affine_matrix)
|
||||
return temp_vision_frame
|
||||
paste_vision_frame = paste_back(temp_vision_frame, crop_vision_frame, box_mask, affine_matrix)
|
||||
return paste_vision_frame
|
||||
|
||||
|
||||
def apply_edit(crop_vision_frame : VisionFrame, face_landmark_68 : FaceLandmark68) -> VisionFrame:
|
||||
@@ -342,8 +348,8 @@ def edit_eye_gaze(expression : LivePortraitExpression) -> LivePortraitExpression
|
||||
|
||||
def edit_eye_open(motion_points : LivePortraitMotionPoints, face_landmark_68 : FaceLandmark68) -> LivePortraitMotionPoints:
|
||||
face_editor_eye_open_ratio = state_manager.get_item('face_editor_eye_open_ratio')
|
||||
left_eye_ratio = calc_distance_ratio(face_landmark_68, 37, 40, 39, 36)
|
||||
right_eye_ratio = calc_distance_ratio(face_landmark_68, 43, 46, 45, 42)
|
||||
left_eye_ratio = calculate_distance_ratio(face_landmark_68, 37, 40, 39, 36)
|
||||
right_eye_ratio = calculate_distance_ratio(face_landmark_68, 43, 46, 45, 42)
|
||||
|
||||
if face_editor_eye_open_ratio < 0:
|
||||
eye_motion_points = numpy.concatenate([ motion_points.ravel(), [ left_eye_ratio, right_eye_ratio, 0.0 ] ])
|
||||
@@ -357,7 +363,7 @@ def edit_eye_open(motion_points : LivePortraitMotionPoints, face_landmark_68 : F
|
||||
|
||||
def edit_lip_open(motion_points : LivePortraitMotionPoints, face_landmark_68 : FaceLandmark68) -> LivePortraitMotionPoints:
|
||||
face_editor_lip_open_ratio = state_manager.get_item('face_editor_lip_open_ratio')
|
||||
lip_ratio = calc_distance_ratio(face_landmark_68, 62, 66, 54, 48)
|
||||
lip_ratio = calculate_distance_ratio(face_landmark_68, 62, 66, 54, 48)
|
||||
|
||||
if face_editor_lip_open_ratio < 0:
|
||||
lip_motion_points = numpy.concatenate([ motion_points.ravel(), [ lip_ratio, 0.0 ] ])
|
||||
@@ -450,12 +456,12 @@ def edit_head_rotation(pitch : LivePortraitPitch, yaw : LivePortraitYaw, roll :
|
||||
edit_pitch = pitch + float(numpy.interp(face_editor_head_pitch, [ -1, 1 ], [ 20, -20 ]))
|
||||
edit_yaw = yaw + float(numpy.interp(face_editor_head_yaw, [ -1, 1 ], [ 60, -60 ]))
|
||||
edit_roll = roll + float(numpy.interp(face_editor_head_roll, [ -1, 1 ], [ -15, 15 ]))
|
||||
edit_pitch, edit_yaw, edit_roll = limit_euler_angles(pitch, yaw, roll, edit_pitch, edit_yaw, edit_roll)
|
||||
edit_pitch, edit_yaw, edit_roll = limit_angle(pitch, yaw, roll, edit_pitch, edit_yaw, edit_roll)
|
||||
rotation = create_rotation(edit_pitch, edit_yaw, edit_roll)
|
||||
return rotation
|
||||
|
||||
|
||||
def calc_distance_ratio(face_landmark_68 : FaceLandmark68, top_index : int, bottom_index : int, left_index : int, right_index : int) -> float:
|
||||
def calculate_distance_ratio(face_landmark_68 : FaceLandmark68, top_index : int, bottom_index : int, left_index : int, right_index : int) -> float:
|
||||
vertical_direction = face_landmark_68[top_index] - face_landmark_68[bottom_index]
|
||||
horizontal_direction = face_landmark_68[left_index] - face_landmark_68[right_index]
|
||||
distance_ratio = float(numpy.linalg.norm(vertical_direction) / (numpy.linalg.norm(horizontal_direction) + 1e-6))
|
||||
@@ -478,56 +484,16 @@ def normalize_crop_frame(crop_vision_frame : VisionFrame) -> VisionFrame:
|
||||
return crop_vision_frame
|
||||
|
||||
|
||||
def get_reference_frame(source_face : Face, target_face : Face, temp_vision_frame : VisionFrame) -> VisionFrame:
|
||||
pass
|
||||
|
||||
|
||||
def process_frame(inputs : FaceEditorInputs) -> VisionFrame:
|
||||
reference_faces = inputs.get('reference_faces')
|
||||
def process_frame(inputs : FaceEditorInputs) -> ProcessorOutputs:
|
||||
reference_vision_frame = inputs.get('reference_vision_frame')
|
||||
target_vision_frame = inputs.get('target_vision_frame')
|
||||
many_faces = sort_and_filter_faces(get_many_faces([ target_vision_frame ]))
|
||||
temp_vision_frame = inputs.get('temp_vision_frame')
|
||||
temp_vision_mask = inputs.get('temp_vision_mask')
|
||||
target_faces = select_faces(reference_vision_frame, target_vision_frame)
|
||||
|
||||
if state_manager.get_item('face_selector_mode') == 'many':
|
||||
if many_faces:
|
||||
for target_face in many_faces:
|
||||
target_vision_frame = edit_face(target_face, target_vision_frame)
|
||||
if state_manager.get_item('face_selector_mode') == 'one':
|
||||
target_face = get_one_face(many_faces)
|
||||
if target_face:
|
||||
target_vision_frame = edit_face(target_face, target_vision_frame)
|
||||
if state_manager.get_item('face_selector_mode') == 'reference':
|
||||
similar_faces = find_similar_faces(many_faces, reference_faces, state_manager.get_item('reference_face_distance'))
|
||||
if similar_faces:
|
||||
for similar_face in similar_faces:
|
||||
target_vision_frame = edit_face(similar_face, target_vision_frame)
|
||||
return target_vision_frame
|
||||
if target_faces:
|
||||
for target_face in target_faces:
|
||||
target_face = scale_face(target_face, target_vision_frame, temp_vision_frame)
|
||||
temp_vision_frame = edit_face(target_face, temp_vision_frame)
|
||||
|
||||
|
||||
def process_frames(source_path : List[str], queue_payloads : List[QueuePayload], update_progress : UpdateProgress) -> None:
|
||||
reference_faces = get_reference_faces() if 'reference' in state_manager.get_item('face_selector_mode') else None
|
||||
|
||||
for queue_payload in process_manager.manage(queue_payloads):
|
||||
target_vision_path = queue_payload['frame_path']
|
||||
target_vision_frame = read_image(target_vision_path)
|
||||
output_vision_frame = process_frame(
|
||||
{
|
||||
'reference_faces': reference_faces,
|
||||
'target_vision_frame': target_vision_frame
|
||||
})
|
||||
write_image(target_vision_path, output_vision_frame)
|
||||
update_progress(1)
|
||||
|
||||
|
||||
def process_image(source_path : str, target_path : str, output_path : str) -> None:
|
||||
reference_faces = get_reference_faces() if 'reference' in state_manager.get_item('face_selector_mode') else None
|
||||
target_vision_frame = read_static_image(target_path)
|
||||
output_vision_frame = process_frame(
|
||||
{
|
||||
'reference_faces': reference_faces,
|
||||
'target_vision_frame': target_vision_frame
|
||||
})
|
||||
write_image(output_path, output_vision_frame)
|
||||
|
||||
|
||||
def process_video(source_paths : List[str], temp_frame_paths : List[str]) -> None:
|
||||
processors.multi_process_frames(None, temp_frame_paths, process_frames)
|
||||
return temp_vision_frame, temp_vision_mask
|
||||
@@ -0,0 +1,44 @@
|
||||
from facefusion.types import Locals
|
||||
|
||||
LOCALS : Locals =\
|
||||
{
|
||||
'en':
|
||||
{
|
||||
'help':
|
||||
{
|
||||
'model': 'choose the model responsible for editing the face',
|
||||
'eyebrow_direction': 'specify the eyebrow direction',
|
||||
'eye_gaze_horizontal': 'specify the horizontal eye gaze',
|
||||
'eye_gaze_vertical': 'specify the vertical eye gaze',
|
||||
'eye_open_ratio': 'specify the ratio of eye opening',
|
||||
'lip_open_ratio': 'specify the ratio of lip opening',
|
||||
'mouth_grim': 'specify the mouth grim',
|
||||
'mouth_pout': 'specify the mouth pout',
|
||||
'mouth_purse': 'specify the mouth purse',
|
||||
'mouth_smile': 'specify the mouth smile',
|
||||
'mouth_position_horizontal': 'specify the horizontal mouth position',
|
||||
'mouth_position_vertical': 'specify the vertical mouth position',
|
||||
'head_pitch': 'specify the head pitch',
|
||||
'head_yaw': 'specify the head yaw',
|
||||
'head_roll': 'specify the head roll'
|
||||
},
|
||||
'uis':
|
||||
{
|
||||
'eyebrow_direction_slider': 'FACE EDITOR EYEBROW DIRECTION',
|
||||
'eye_gaze_horizontal_slider': 'FACE EDITOR EYE GAZE HORIZONTAL',
|
||||
'eye_gaze_vertical_slider': 'FACE EDITOR EYE GAZE VERTICAL',
|
||||
'eye_open_ratio_slider': 'FACE EDITOR EYE OPEN RATIO',
|
||||
'head_pitch_slider': 'FACE EDITOR HEAD PITCH',
|
||||
'head_roll_slider': 'FACE EDITOR HEAD ROLL',
|
||||
'head_yaw_slider': 'FACE EDITOR HEAD YAW',
|
||||
'lip_open_ratio_slider': 'FACE EDITOR LIP OPEN RATIO',
|
||||
'model_dropdown': 'FACE EDITOR MODEL',
|
||||
'mouth_grim_slider': 'FACE EDITOR MOUTH GRIM',
|
||||
'mouth_position_horizontal_slider': 'FACE EDITOR MOUTH POSITION HORIZONTAL',
|
||||
'mouth_position_vertical_slider': 'FACE EDITOR MOUTH POSITION VERTICAL',
|
||||
'mouth_pout_slider': 'FACE EDITOR MOUTH POUT',
|
||||
'mouth_purse_slider': 'FACE EDITOR MOUTH PURSE',
|
||||
'mouth_smile_slider': 'FACE EDITOR MOUTH SMILE'
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,13 @@
|
||||
from typing import Literal, TypedDict
|
||||
|
||||
from facefusion.types import Mask, VisionFrame
|
||||
|
||||
FaceEditorInputs = TypedDict('FaceEditorInputs',
|
||||
{
|
||||
'reference_vision_frame' : VisionFrame,
|
||||
'target_vision_frame' : VisionFrame,
|
||||
'temp_vision_frame' : VisionFrame,
|
||||
'temp_vision_mask' : Mask
|
||||
})
|
||||
|
||||
FaceEditorModel = Literal['live_portrait']
|
||||
@@ -0,0 +1,10 @@
|
||||
from typing import List, Sequence
|
||||
|
||||
from facefusion.common_helper import create_float_range, create_int_range
|
||||
from facefusion.processors.modules.face_enhancer.types import FaceEnhancerModel
|
||||
|
||||
face_enhancer_models : List[FaceEnhancerModel] = [ 'codeformer', 'gfpgan_1.2', 'gfpgan_1.3', 'gfpgan_1.4', 'gpen_bfr_256', 'gpen_bfr_512', 'gpen_bfr_1024', 'gpen_bfr_2048', 'restoreformer_plus_plus' ]
|
||||
|
||||
face_enhancer_blend_range : Sequence[int] = create_int_range(0, 100, 1)
|
||||
|
||||
face_enhancer_weight_range : Sequence[float] = create_float_range(0.0, 1.0, 0.05)
|
||||
+83
-71
@@ -1,36 +1,39 @@
|
||||
from argparse import ArgumentParser
|
||||
from functools import lru_cache
|
||||
from typing import List
|
||||
|
||||
import cv2
|
||||
import numpy
|
||||
|
||||
import facefusion.jobs.job_manager
|
||||
import facefusion.jobs.job_store
|
||||
import facefusion.processors.core as processors
|
||||
from facefusion import config, content_analyser, face_classifier, face_detector, face_landmarker, face_masker, face_recognizer, inference_manager, logger, process_manager, state_manager, video_manager, wording
|
||||
from facefusion import config, content_analyser, face_classifier, face_detector, face_landmarker, face_masker, face_recognizer, inference_manager, logger, state_manager, translator, video_manager
|
||||
from facefusion.common_helper import create_float_metavar, create_int_metavar
|
||||
from facefusion.download import conditional_download_hashes, conditional_download_sources, resolve_download_url
|
||||
from facefusion.face_analyser import get_many_faces, get_one_face
|
||||
from facefusion.face_analyser import scale_face
|
||||
from facefusion.face_helper import paste_back, warp_face_by_face_landmark_5
|
||||
from facefusion.face_masker import create_box_mask, create_occlusion_mask
|
||||
from facefusion.face_selector import find_similar_faces, sort_and_filter_faces
|
||||
from facefusion.face_store import get_reference_faces
|
||||
from facefusion.face_selector import select_faces
|
||||
from facefusion.filesystem import in_directory, is_image, is_video, resolve_relative_path, same_file_extension
|
||||
from facefusion.processors import choices as processors_choices
|
||||
from facefusion.processors.types import FaceEnhancerInputs, FaceEnhancerWeight
|
||||
from facefusion.processors.modules.face_enhancer import choices as face_enhancer_choices
|
||||
from facefusion.processors.modules.face_enhancer.types import FaceEnhancerInputs, FaceEnhancerWeight
|
||||
from facefusion.processors.types import ProcessorOutputs
|
||||
from facefusion.program_helper import find_argument_group
|
||||
from facefusion.thread_helper import thread_semaphore
|
||||
from facefusion.types import ApplyStateItem, Args, DownloadScope, Face, InferencePool, ModelOptions, ModelSet, ProcessMode, QueuePayload, UpdateProgress, VisionFrame
|
||||
from facefusion.vision import read_image, read_static_image, write_image
|
||||
from facefusion.types import ApplyStateItem, Args, DownloadScope, Face, InferencePool, ModelOptions, ModelSet, ProcessMode, VisionFrame
|
||||
from facefusion.vision import blend_frame, read_static_image, read_static_video_frame
|
||||
|
||||
|
||||
@lru_cache(maxsize = None)
|
||||
@lru_cache()
|
||||
def create_static_model_set(download_scope : DownloadScope) -> ModelSet:
|
||||
return\
|
||||
{
|
||||
'codeformer':
|
||||
{
|
||||
'__metadata__':
|
||||
{
|
||||
'vendor': 'sczhou',
|
||||
'license': 'S-Lab-1.0',
|
||||
'year': 2022
|
||||
},
|
||||
'hashes':
|
||||
{
|
||||
'face_enhancer':
|
||||
@@ -52,6 +55,12 @@ def create_static_model_set(download_scope : DownloadScope) -> ModelSet:
|
||||
},
|
||||
'gfpgan_1.2':
|
||||
{
|
||||
'__metadata__':
|
||||
{
|
||||
'vendor': 'TencentARC',
|
||||
'license': 'Apache-2.0',
|
||||
'year': 2022
|
||||
},
|
||||
'hashes':
|
||||
{
|
||||
'face_enhancer':
|
||||
@@ -73,6 +82,12 @@ def create_static_model_set(download_scope : DownloadScope) -> ModelSet:
|
||||
},
|
||||
'gfpgan_1.3':
|
||||
{
|
||||
'__metadata__':
|
||||
{
|
||||
'vendor': 'TencentARC',
|
||||
'license': 'Apache-2.0',
|
||||
'year': 2022
|
||||
},
|
||||
'hashes':
|
||||
{
|
||||
'face_enhancer':
|
||||
@@ -94,6 +109,12 @@ def create_static_model_set(download_scope : DownloadScope) -> ModelSet:
|
||||
},
|
||||
'gfpgan_1.4':
|
||||
{
|
||||
'__metadata__':
|
||||
{
|
||||
'vendor': 'TencentARC',
|
||||
'license': 'Apache-2.0',
|
||||
'year': 2022
|
||||
},
|
||||
'hashes':
|
||||
{
|
||||
'face_enhancer':
|
||||
@@ -115,6 +136,12 @@ def create_static_model_set(download_scope : DownloadScope) -> ModelSet:
|
||||
},
|
||||
'gpen_bfr_256':
|
||||
{
|
||||
'__metadata__':
|
||||
{
|
||||
'vendor': 'yangxy',
|
||||
'license': 'Non-Commercial',
|
||||
'year': 2021
|
||||
},
|
||||
'hashes':
|
||||
{
|
||||
'face_enhancer':
|
||||
@@ -136,6 +163,12 @@ def create_static_model_set(download_scope : DownloadScope) -> ModelSet:
|
||||
},
|
||||
'gpen_bfr_512':
|
||||
{
|
||||
'__metadata__':
|
||||
{
|
||||
'vendor': 'yangxy',
|
||||
'license': 'Non-Commercial',
|
||||
'year': 2021
|
||||
},
|
||||
'hashes':
|
||||
{
|
||||
'face_enhancer':
|
||||
@@ -157,6 +190,12 @@ def create_static_model_set(download_scope : DownloadScope) -> ModelSet:
|
||||
},
|
||||
'gpen_bfr_1024':
|
||||
{
|
||||
'__metadata__':
|
||||
{
|
||||
'vendor': 'yangxy',
|
||||
'license': 'Non-Commercial',
|
||||
'year': 2021
|
||||
},
|
||||
'hashes':
|
||||
{
|
||||
'face_enhancer':
|
||||
@@ -178,6 +217,12 @@ def create_static_model_set(download_scope : DownloadScope) -> ModelSet:
|
||||
},
|
||||
'gpen_bfr_2048':
|
||||
{
|
||||
'__metadata__':
|
||||
{
|
||||
'vendor': 'yangxy',
|
||||
'license': 'Non-Commercial',
|
||||
'year': 2021
|
||||
},
|
||||
'hashes':
|
||||
{
|
||||
'face_enhancer':
|
||||
@@ -199,6 +244,12 @@ def create_static_model_set(download_scope : DownloadScope) -> ModelSet:
|
||||
},
|
||||
'restoreformer_plus_plus':
|
||||
{
|
||||
'__metadata__':
|
||||
{
|
||||
'vendor': 'wzhouxiff',
|
||||
'license': 'Apache-2.0',
|
||||
'year': 2022
|
||||
},
|
||||
'hashes':
|
||||
{
|
||||
'face_enhancer':
|
||||
@@ -241,9 +292,9 @@ def get_model_options() -> ModelOptions:
|
||||
def register_args(program : ArgumentParser) -> None:
|
||||
group_processors = find_argument_group(program, 'processors')
|
||||
if group_processors:
|
||||
group_processors.add_argument('--face-enhancer-model', help = wording.get('help.face_enhancer_model'), default = config.get_str_value('processors', 'face_enhancer_model', 'gfpgan_1.4'), choices = processors_choices.face_enhancer_models)
|
||||
group_processors.add_argument('--face-enhancer-blend', help = wording.get('help.face_enhancer_blend'), type = int, default = config.get_int_value('processors', 'face_enhancer_blend', '80'), choices = processors_choices.face_enhancer_blend_range, metavar = create_int_metavar(processors_choices.face_enhancer_blend_range))
|
||||
group_processors.add_argument('--face-enhancer-weight', help = wording.get('help.face_enhancer_weight'), type = float, default = config.get_float_value('processors', 'face_enhancer_weight', '1.0'), choices = processors_choices.face_enhancer_weight_range, metavar = create_float_metavar(processors_choices.face_enhancer_weight_range))
|
||||
group_processors.add_argument('--face-enhancer-model', help = translator.get('help.model', __package__), default = config.get_str_value('processors', 'face_enhancer_model', 'gfpgan_1.4'), choices = face_enhancer_choices.face_enhancer_models)
|
||||
group_processors.add_argument('--face-enhancer-blend', help = translator.get('help.blend', __package__), type = int, default = config.get_int_value('processors', 'face_enhancer_blend', '80'), choices = face_enhancer_choices.face_enhancer_blend_range, metavar = create_int_metavar(face_enhancer_choices.face_enhancer_blend_range))
|
||||
group_processors.add_argument('--face-enhancer-weight', help = translator.get('help.weight', __package__), type = float, default = config.get_float_value('processors', 'face_enhancer_weight', '0.5'), choices = face_enhancer_choices.face_enhancer_weight_range, metavar = create_float_metavar(face_enhancer_choices.face_enhancer_weight_range))
|
||||
facefusion.jobs.job_store.register_step_keys([ 'face_enhancer_model', 'face_enhancer_blend', 'face_enhancer_weight' ])
|
||||
|
||||
|
||||
@@ -262,19 +313,20 @@ def pre_check() -> bool:
|
||||
|
||||
def pre_process(mode : ProcessMode) -> bool:
|
||||
if mode in [ 'output', 'preview' ] and not is_image(state_manager.get_item('target_path')) and not is_video(state_manager.get_item('target_path')):
|
||||
logger.error(wording.get('choose_image_or_video_target') + wording.get('exclamation_mark'), __name__)
|
||||
logger.error(translator.get('choose_image_or_video_target') + translator.get('exclamation_mark'), __name__)
|
||||
return False
|
||||
if mode == 'output' and not in_directory(state_manager.get_item('output_path')):
|
||||
logger.error(wording.get('specify_image_or_video_output') + wording.get('exclamation_mark'), __name__)
|
||||
logger.error(translator.get('specify_image_or_video_output') + translator.get('exclamation_mark'), __name__)
|
||||
return False
|
||||
if mode == 'output' and not same_file_extension(state_manager.get_item('target_path'), state_manager.get_item('output_path')):
|
||||
logger.error(wording.get('match_target_and_output_extension') + wording.get('exclamation_mark'), __name__)
|
||||
logger.error(translator.get('match_target_and_output_extension') + translator.get('exclamation_mark'), __name__)
|
||||
return False
|
||||
return True
|
||||
|
||||
|
||||
def post_process() -> None:
|
||||
read_static_image.cache_clear()
|
||||
read_static_video_frame.cache_clear()
|
||||
video_manager.clear_video_pool()
|
||||
if state_manager.get_item('video_memory_strategy') in [ 'strict', 'moderate' ]:
|
||||
clear_inference_pool()
|
||||
@@ -307,7 +359,7 @@ def enhance_face(target_face : Face, temp_vision_frame : VisionFrame) -> VisionF
|
||||
crop_vision_frame = normalize_crop_frame(crop_vision_frame)
|
||||
crop_mask = numpy.minimum.reduce(crop_masks).clip(0, 1)
|
||||
paste_vision_frame = paste_back(temp_vision_frame, crop_vision_frame, crop_mask, affine_matrix)
|
||||
temp_vision_frame = blend_frame(temp_vision_frame, paste_vision_frame)
|
||||
temp_vision_frame = blend_paste_frame(temp_vision_frame, paste_vision_frame)
|
||||
return temp_vision_frame
|
||||
|
||||
|
||||
@@ -353,62 +405,22 @@ def normalize_crop_frame(crop_vision_frame : VisionFrame) -> VisionFrame:
|
||||
return crop_vision_frame
|
||||
|
||||
|
||||
def blend_frame(temp_vision_frame : VisionFrame, paste_vision_frame : VisionFrame) -> VisionFrame:
|
||||
def blend_paste_frame(temp_vision_frame : VisionFrame, paste_vision_frame : VisionFrame) -> VisionFrame:
|
||||
face_enhancer_blend = 1 - (state_manager.get_item('face_enhancer_blend') / 100)
|
||||
temp_vision_frame = cv2.addWeighted(temp_vision_frame, face_enhancer_blend, paste_vision_frame, 1 - face_enhancer_blend, 0)
|
||||
temp_vision_frame = blend_frame(temp_vision_frame, paste_vision_frame, 1 - face_enhancer_blend)
|
||||
return temp_vision_frame
|
||||
|
||||
|
||||
def get_reference_frame(source_face : Face, target_face : Face, temp_vision_frame : VisionFrame) -> VisionFrame:
|
||||
return enhance_face(target_face, temp_vision_frame)
|
||||
|
||||
|
||||
def process_frame(inputs : FaceEnhancerInputs) -> VisionFrame:
|
||||
reference_faces = inputs.get('reference_faces')
|
||||
def process_frame(inputs : FaceEnhancerInputs) -> ProcessorOutputs:
|
||||
reference_vision_frame = inputs.get('reference_vision_frame')
|
||||
target_vision_frame = inputs.get('target_vision_frame')
|
||||
many_faces = sort_and_filter_faces(get_many_faces([ target_vision_frame ]))
|
||||
temp_vision_frame = inputs.get('temp_vision_frame')
|
||||
temp_vision_mask = inputs.get('temp_vision_mask')
|
||||
target_faces = select_faces(reference_vision_frame, target_vision_frame)
|
||||
|
||||
if state_manager.get_item('face_selector_mode') == 'many':
|
||||
if many_faces:
|
||||
for target_face in many_faces:
|
||||
target_vision_frame = enhance_face(target_face, target_vision_frame)
|
||||
if state_manager.get_item('face_selector_mode') == 'one':
|
||||
target_face = get_one_face(many_faces)
|
||||
if target_face:
|
||||
target_vision_frame = enhance_face(target_face, target_vision_frame)
|
||||
if state_manager.get_item('face_selector_mode') == 'reference':
|
||||
similar_faces = find_similar_faces(many_faces, reference_faces, state_manager.get_item('reference_face_distance'))
|
||||
if similar_faces:
|
||||
for similar_face in similar_faces:
|
||||
target_vision_frame = enhance_face(similar_face, target_vision_frame)
|
||||
return target_vision_frame
|
||||
if target_faces:
|
||||
for target_face in target_faces:
|
||||
target_face = scale_face(target_face, target_vision_frame, temp_vision_frame)
|
||||
temp_vision_frame = enhance_face(target_face, temp_vision_frame)
|
||||
|
||||
|
||||
def process_frames(source_path : List[str], queue_payloads : List[QueuePayload], update_progress : UpdateProgress) -> None:
|
||||
reference_faces = get_reference_faces() if 'reference' in state_manager.get_item('face_selector_mode') else None
|
||||
|
||||
for queue_payload in process_manager.manage(queue_payloads):
|
||||
target_vision_path = queue_payload['frame_path']
|
||||
target_vision_frame = read_image(target_vision_path)
|
||||
output_vision_frame = process_frame(
|
||||
{
|
||||
'reference_faces': reference_faces,
|
||||
'target_vision_frame': target_vision_frame
|
||||
})
|
||||
write_image(target_vision_path, output_vision_frame)
|
||||
update_progress(1)
|
||||
|
||||
|
||||
def process_image(source_path : str, target_path : str, output_path : str) -> None:
|
||||
reference_faces = get_reference_faces() if 'reference' in state_manager.get_item('face_selector_mode') else None
|
||||
target_vision_frame = read_static_image(target_path)
|
||||
output_vision_frame = process_frame(
|
||||
{
|
||||
'reference_faces': reference_faces,
|
||||
'target_vision_frame': target_vision_frame
|
||||
})
|
||||
write_image(output_path, output_vision_frame)
|
||||
|
||||
|
||||
def process_video(source_paths : List[str], temp_frame_paths : List[str]) -> None:
|
||||
processors.multi_process_frames(None, temp_frame_paths, process_frames)
|
||||
return temp_vision_frame, temp_vision_mask
|
||||
@@ -0,0 +1,20 @@
|
||||
from facefusion.types import Locals
|
||||
|
||||
LOCALS : Locals =\
|
||||
{
|
||||
'en':
|
||||
{
|
||||
'help':
|
||||
{
|
||||
'model': 'choose the model responsible for enhancing the face',
|
||||
'blend': 'blend the enhanced into the previous face',
|
||||
'weight': 'specify the degree of weight applied to the face'
|
||||
},
|
||||
'uis':
|
||||
{
|
||||
'blend_slider': 'FACE ENHANCER BLEND',
|
||||
'model_dropdown': 'FACE ENHANCER MODEL',
|
||||
'weight_slider': 'FACE ENHANCER WEIGHT'
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,17 @@
|
||||
from typing import Any, Literal, TypeAlias, TypedDict
|
||||
|
||||
from numpy.typing import NDArray
|
||||
|
||||
from facefusion.types import Mask, VisionFrame
|
||||
|
||||
FaceEnhancerInputs = TypedDict('FaceEnhancerInputs',
|
||||
{
|
||||
'reference_vision_frame' : VisionFrame,
|
||||
'target_vision_frame' : VisionFrame,
|
||||
'temp_vision_frame' : VisionFrame,
|
||||
'temp_vision_mask' : Mask
|
||||
})
|
||||
|
||||
FaceEnhancerModel = Literal['codeformer', 'gfpgan_1.2', 'gfpgan_1.3', 'gfpgan_1.4', 'gpen_bfr_256', 'gpen_bfr_512', 'gpen_bfr_1024', 'gpen_bfr_2048', 'restoreformer_plus_plus']
|
||||
|
||||
FaceEnhancerWeight : TypeAlias = NDArray[Any]
|
||||
@@ -0,0 +1,25 @@
|
||||
from typing import List, Sequence
|
||||
|
||||
from facefusion.common_helper import create_float_range
|
||||
from facefusion.processors.modules.face_swapper.types import FaceSwapperModel, FaceSwapperSet, FaceSwapperWeight
|
||||
|
||||
face_swapper_set : FaceSwapperSet =\
|
||||
{
|
||||
'blendswap_256': [ '256x256', '384x384', '512x512', '768x768', '1024x1024' ],
|
||||
'ghost_1_256': [ '256x256', '512x512', '768x768', '1024x1024' ],
|
||||
'ghost_2_256': [ '256x256', '512x512', '768x768', '1024x1024' ],
|
||||
'ghost_3_256': [ '256x256', '512x512', '768x768', '1024x1024' ],
|
||||
'hififace_unofficial_256': [ '256x256', '512x512', '768x768', '1024x1024' ],
|
||||
'hyperswap_1a_256': [ '256x256', '512x512', '768x768', '1024x1024' ],
|
||||
'hyperswap_1b_256': [ '256x256', '512x512', '768x768', '1024x1024' ],
|
||||
'hyperswap_1c_256': [ '256x256', '512x512', '768x768', '1024x1024' ],
|
||||
'inswapper_128': [ '128x128', '256x256', '384x384', '512x512', '768x768', '1024x1024' ],
|
||||
'inswapper_128_fp16': [ '128x128', '256x256', '384x384', '512x512', '768x768', '1024x1024' ],
|
||||
'simswap_256': [ '256x256', '512x512', '768x768', '1024x1024' ],
|
||||
'simswap_unofficial_512': [ '512x512', '768x768', '1024x1024' ],
|
||||
'uniface_256': [ '256x256', '512x512', '768x768', '1024x1024' ]
|
||||
}
|
||||
|
||||
face_swapper_models : List[FaceSwapperModel] = list(face_swapper_set.keys())
|
||||
|
||||
face_swapper_weight_range : Sequence[FaceSwapperWeight] = create_float_range(0.0, 1.0, 0.05)
|
||||
+197
-135
@@ -1,6 +1,6 @@
|
||||
from argparse import ArgumentParser
|
||||
from functools import lru_cache
|
||||
from typing import List, Tuple
|
||||
from typing import List, Optional, Tuple
|
||||
|
||||
import cv2
|
||||
import numpy
|
||||
@@ -8,33 +8,38 @@ import numpy
|
||||
import facefusion.choices
|
||||
import facefusion.jobs.job_manager
|
||||
import facefusion.jobs.job_store
|
||||
import facefusion.processors.core as processors
|
||||
from facefusion import config, content_analyser, face_classifier, face_detector, face_landmarker, face_masker, face_recognizer, inference_manager, logger, process_manager, state_manager, video_manager, wording
|
||||
from facefusion.common_helper import get_first
|
||||
from facefusion import config, content_analyser, face_classifier, face_detector, face_landmarker, face_masker, face_recognizer, inference_manager, logger, state_manager, translator, video_manager
|
||||
from facefusion.common_helper import get_first, is_macos
|
||||
from facefusion.download import conditional_download_hashes, conditional_download_sources, resolve_download_url
|
||||
from facefusion.execution import has_execution_provider
|
||||
from facefusion.face_analyser import get_average_face, get_many_faces, get_one_face
|
||||
from facefusion.face_analyser import get_average_face, get_many_faces, get_one_face, scale_face
|
||||
from facefusion.face_helper import paste_back, warp_face_by_face_landmark_5
|
||||
from facefusion.face_masker import create_area_mask, create_box_mask, create_occlusion_mask, create_region_mask
|
||||
from facefusion.face_selector import find_similar_faces, sort_and_filter_faces, sort_faces_by_order
|
||||
from facefusion.face_store import get_reference_faces
|
||||
from facefusion.face_selector import select_faces, sort_faces_by_order
|
||||
from facefusion.filesystem import filter_image_paths, has_image, in_directory, is_image, is_video, resolve_relative_path, same_file_extension
|
||||
from facefusion.model_helper import get_static_model_initializer
|
||||
from facefusion.processors import choices as processors_choices
|
||||
from facefusion.processors.modules.face_swapper import choices as face_swapper_choices
|
||||
from facefusion.processors.modules.face_swapper.types import FaceSwapperInputs
|
||||
from facefusion.processors.pixel_boost import explode_pixel_boost, implode_pixel_boost
|
||||
from facefusion.processors.types import FaceSwapperInputs
|
||||
from facefusion.processors.types import ProcessorOutputs
|
||||
from facefusion.program_helper import find_argument_group
|
||||
from facefusion.thread_helper import conditional_thread_semaphore
|
||||
from facefusion.types import ApplyStateItem, Args, DownloadScope, Embedding, Face, InferencePool, ModelOptions, ModelSet, ProcessMode, QueuePayload, UpdateProgress, VisionFrame
|
||||
from facefusion.vision import read_image, read_static_image, read_static_images, unpack_resolution, write_image
|
||||
from facefusion.types import ApplyStateItem, Args, DownloadScope, Embedding, Face, InferencePool, ModelOptions, ModelSet, ProcessMode, VisionFrame
|
||||
from facefusion.vision import read_static_image, read_static_images, read_static_video_frame, unpack_resolution
|
||||
|
||||
|
||||
@lru_cache(maxsize = None)
|
||||
@lru_cache()
|
||||
def create_static_model_set(download_scope : DownloadScope) -> ModelSet:
|
||||
return\
|
||||
{
|
||||
'blendswap_256':
|
||||
{
|
||||
'__metadata__':
|
||||
{
|
||||
'vendor': 'mapooon',
|
||||
'license': 'Non-Commercial',
|
||||
'year': 2023
|
||||
},
|
||||
'hashes':
|
||||
{
|
||||
'face_swapper':
|
||||
@@ -59,6 +64,12 @@ def create_static_model_set(download_scope : DownloadScope) -> ModelSet:
|
||||
},
|
||||
'ghost_1_256':
|
||||
{
|
||||
'__metadata__':
|
||||
{
|
||||
'vendor': 'ai-forever',
|
||||
'license': 'Apache-2.0',
|
||||
'year': 2022
|
||||
},
|
||||
'hashes':
|
||||
{
|
||||
'face_swapper':
|
||||
@@ -68,8 +79,8 @@ def create_static_model_set(download_scope : DownloadScope) -> ModelSet:
|
||||
},
|
||||
'embedding_converter':
|
||||
{
|
||||
'url': resolve_download_url('models-3.0.0', 'arcface_converter_ghost.hash'),
|
||||
'path': resolve_relative_path('../.assets/models/arcface_converter_ghost.hash')
|
||||
'url': resolve_download_url('models-3.4.0', 'crossface_ghost.hash'),
|
||||
'path': resolve_relative_path('../.assets/models/crossface_ghost.hash')
|
||||
}
|
||||
},
|
||||
'sources':
|
||||
@@ -81,8 +92,8 @@ def create_static_model_set(download_scope : DownloadScope) -> ModelSet:
|
||||
},
|
||||
'embedding_converter':
|
||||
{
|
||||
'url': resolve_download_url('models-3.0.0', 'arcface_converter_ghost.onnx'),
|
||||
'path': resolve_relative_path('../.assets/models/arcface_converter_ghost.onnx')
|
||||
'url': resolve_download_url('models-3.4.0', 'crossface_ghost.onnx'),
|
||||
'path': resolve_relative_path('../.assets/models/crossface_ghost.onnx')
|
||||
}
|
||||
},
|
||||
'type': 'ghost',
|
||||
@@ -93,6 +104,12 @@ def create_static_model_set(download_scope : DownloadScope) -> ModelSet:
|
||||
},
|
||||
'ghost_2_256':
|
||||
{
|
||||
'__metadata__':
|
||||
{
|
||||
'vendor': 'ai-forever',
|
||||
'license': 'Apache-2.0',
|
||||
'year': 2022
|
||||
},
|
||||
'hashes':
|
||||
{
|
||||
'face_swapper':
|
||||
@@ -102,8 +119,8 @@ def create_static_model_set(download_scope : DownloadScope) -> ModelSet:
|
||||
},
|
||||
'embedding_converter':
|
||||
{
|
||||
'url': resolve_download_url('models-3.0.0', 'arcface_converter_ghost.hash'),
|
||||
'path': resolve_relative_path('../.assets/models/arcface_converter_ghost.hash')
|
||||
'url': resolve_download_url('models-3.4.0', 'crossface_ghost.hash'),
|
||||
'path': resolve_relative_path('../.assets/models/crossface_ghost.hash')
|
||||
}
|
||||
},
|
||||
'sources':
|
||||
@@ -115,8 +132,8 @@ def create_static_model_set(download_scope : DownloadScope) -> ModelSet:
|
||||
},
|
||||
'embedding_converter':
|
||||
{
|
||||
'url': resolve_download_url('models-3.0.0', 'arcface_converter_ghost.onnx'),
|
||||
'path': resolve_relative_path('../.assets/models/arcface_converter_ghost.onnx')
|
||||
'url': resolve_download_url('models-3.4.0', 'crossface_ghost.onnx'),
|
||||
'path': resolve_relative_path('../.assets/models/crossface_ghost.onnx')
|
||||
}
|
||||
},
|
||||
'type': 'ghost',
|
||||
@@ -127,6 +144,12 @@ def create_static_model_set(download_scope : DownloadScope) -> ModelSet:
|
||||
},
|
||||
'ghost_3_256':
|
||||
{
|
||||
'__metadata__':
|
||||
{
|
||||
'vendor': 'ai-forever',
|
||||
'license': 'Apache-2.0',
|
||||
'year': 2022
|
||||
},
|
||||
'hashes':
|
||||
{
|
||||
'face_swapper':
|
||||
@@ -136,8 +159,8 @@ def create_static_model_set(download_scope : DownloadScope) -> ModelSet:
|
||||
},
|
||||
'embedding_converter':
|
||||
{
|
||||
'url': resolve_download_url('models-3.0.0', 'arcface_converter_ghost.hash'),
|
||||
'path': resolve_relative_path('../.assets/models/arcface_converter_ghost.hash')
|
||||
'url': resolve_download_url('models-3.4.0', 'crossface_ghost.hash'),
|
||||
'path': resolve_relative_path('../.assets/models/crossface_ghost.hash')
|
||||
}
|
||||
},
|
||||
'sources':
|
||||
@@ -149,8 +172,8 @@ def create_static_model_set(download_scope : DownloadScope) -> ModelSet:
|
||||
},
|
||||
'embedding_converter':
|
||||
{
|
||||
'url': resolve_download_url('models-3.0.0', 'arcface_converter_ghost.onnx'),
|
||||
'path': resolve_relative_path('../.assets/models/arcface_converter_ghost.onnx')
|
||||
'url': resolve_download_url('models-3.4.0', 'crossface_ghost.onnx'),
|
||||
'path': resolve_relative_path('../.assets/models/crossface_ghost.onnx')
|
||||
}
|
||||
},
|
||||
'type': 'ghost',
|
||||
@@ -161,6 +184,12 @@ def create_static_model_set(download_scope : DownloadScope) -> ModelSet:
|
||||
},
|
||||
'hififace_unofficial_256':
|
||||
{
|
||||
'__metadata__':
|
||||
{
|
||||
'vendor': 'GuijiAI',
|
||||
'license': 'Unknown',
|
||||
'year': 2021
|
||||
},
|
||||
'hashes':
|
||||
{
|
||||
'face_swapper':
|
||||
@@ -170,8 +199,8 @@ def create_static_model_set(download_scope : DownloadScope) -> ModelSet:
|
||||
},
|
||||
'embedding_converter':
|
||||
{
|
||||
'url': resolve_download_url('models-3.1.0', 'arcface_converter_hififace.hash'),
|
||||
'path': resolve_relative_path('../.assets/models/arcface_converter_hififace.hash')
|
||||
'url': resolve_download_url('models-3.4.0', 'crossface_hififace.hash'),
|
||||
'path': resolve_relative_path('../.assets/models/crossface_hififace.hash')
|
||||
}
|
||||
},
|
||||
'sources':
|
||||
@@ -183,8 +212,8 @@ def create_static_model_set(download_scope : DownloadScope) -> ModelSet:
|
||||
},
|
||||
'embedding_converter':
|
||||
{
|
||||
'url': resolve_download_url('models-3.1.0', 'arcface_converter_hififace.onnx'),
|
||||
'path': resolve_relative_path('../.assets/models/arcface_converter_hififace.onnx')
|
||||
'url': resolve_download_url('models-3.4.0', 'crossface_hififace.onnx'),
|
||||
'path': resolve_relative_path('../.assets/models/crossface_hififace.onnx')
|
||||
}
|
||||
},
|
||||
'type': 'hififace',
|
||||
@@ -195,6 +224,12 @@ def create_static_model_set(download_scope : DownloadScope) -> ModelSet:
|
||||
},
|
||||
'hyperswap_1a_256':
|
||||
{
|
||||
'__metadata__':
|
||||
{
|
||||
'vendor': 'FaceFusion',
|
||||
'license': 'ResearchRAIL',
|
||||
'year': 2025
|
||||
},
|
||||
'hashes':
|
||||
{
|
||||
'face_swapper':
|
||||
@@ -219,6 +254,12 @@ def create_static_model_set(download_scope : DownloadScope) -> ModelSet:
|
||||
},
|
||||
'hyperswap_1b_256':
|
||||
{
|
||||
'__metadata__':
|
||||
{
|
||||
'vendor': 'FaceFusion',
|
||||
'license': 'ResearchRAIL',
|
||||
'year': 2025
|
||||
},
|
||||
'hashes':
|
||||
{
|
||||
'face_swapper':
|
||||
@@ -243,6 +284,12 @@ def create_static_model_set(download_scope : DownloadScope) -> ModelSet:
|
||||
},
|
||||
'hyperswap_1c_256':
|
||||
{
|
||||
'__metadata__':
|
||||
{
|
||||
'vendor': 'FaceFusion',
|
||||
'license': 'ResearchRAIL',
|
||||
'year': 2025
|
||||
},
|
||||
'hashes':
|
||||
{
|
||||
'face_swapper':
|
||||
@@ -267,6 +314,12 @@ def create_static_model_set(download_scope : DownloadScope) -> ModelSet:
|
||||
},
|
||||
'inswapper_128':
|
||||
{
|
||||
'__metadata__':
|
||||
{
|
||||
'vendor': 'InsightFace',
|
||||
'license': 'Non-Commercial',
|
||||
'year': 2023
|
||||
},
|
||||
'hashes':
|
||||
{
|
||||
'face_swapper':
|
||||
@@ -291,6 +344,12 @@ def create_static_model_set(download_scope : DownloadScope) -> ModelSet:
|
||||
},
|
||||
'inswapper_128_fp16':
|
||||
{
|
||||
'__metadata__':
|
||||
{
|
||||
'vendor': 'InsightFace',
|
||||
'license': 'Non-Commercial',
|
||||
'year': 2023
|
||||
},
|
||||
'hashes':
|
||||
{
|
||||
'face_swapper':
|
||||
@@ -315,6 +374,12 @@ def create_static_model_set(download_scope : DownloadScope) -> ModelSet:
|
||||
},
|
||||
'simswap_256':
|
||||
{
|
||||
'__metadata__':
|
||||
{
|
||||
'vendor': 'neuralchen',
|
||||
'license': 'Non-Commercial',
|
||||
'year': 2020
|
||||
},
|
||||
'hashes':
|
||||
{
|
||||
'face_swapper':
|
||||
@@ -324,8 +389,8 @@ def create_static_model_set(download_scope : DownloadScope) -> ModelSet:
|
||||
},
|
||||
'embedding_converter':
|
||||
{
|
||||
'url': resolve_download_url('models-3.0.0', 'arcface_converter_simswap.hash'),
|
||||
'path': resolve_relative_path('../.assets/models/arcface_converter_simswap.hash')
|
||||
'url': resolve_download_url('models-3.4.0', 'crossface_simswap.hash'),
|
||||
'path': resolve_relative_path('../.assets/models/crossface_simswap.hash')
|
||||
}
|
||||
},
|
||||
'sources':
|
||||
@@ -337,8 +402,8 @@ def create_static_model_set(download_scope : DownloadScope) -> ModelSet:
|
||||
},
|
||||
'embedding_converter':
|
||||
{
|
||||
'url': resolve_download_url('models-3.0.0', 'arcface_converter_simswap.onnx'),
|
||||
'path': resolve_relative_path('../.assets/models/arcface_converter_simswap.onnx')
|
||||
'url': resolve_download_url('models-3.4.0', 'crossface_simswap.onnx'),
|
||||
'path': resolve_relative_path('../.assets/models/crossface_simswap.onnx')
|
||||
}
|
||||
},
|
||||
'type': 'simswap',
|
||||
@@ -349,6 +414,12 @@ def create_static_model_set(download_scope : DownloadScope) -> ModelSet:
|
||||
},
|
||||
'simswap_unofficial_512':
|
||||
{
|
||||
'__metadata__':
|
||||
{
|
||||
'vendor': 'neuralchen',
|
||||
'license': 'Non-Commercial',
|
||||
'year': 2020
|
||||
},
|
||||
'hashes':
|
||||
{
|
||||
'face_swapper':
|
||||
@@ -358,8 +429,8 @@ def create_static_model_set(download_scope : DownloadScope) -> ModelSet:
|
||||
},
|
||||
'embedding_converter':
|
||||
{
|
||||
'url': resolve_download_url('models-3.0.0', 'arcface_converter_simswap.hash'),
|
||||
'path': resolve_relative_path('../.assets/models/arcface_converter_simswap.hash')
|
||||
'url': resolve_download_url('models-3.4.0', 'crossface_simswap.hash'),
|
||||
'path': resolve_relative_path('../.assets/models/crossface_simswap.hash')
|
||||
}
|
||||
},
|
||||
'sources':
|
||||
@@ -371,8 +442,8 @@ def create_static_model_set(download_scope : DownloadScope) -> ModelSet:
|
||||
},
|
||||
'embedding_converter':
|
||||
{
|
||||
'url': resolve_download_url('models-3.0.0', 'arcface_converter_simswap.onnx'),
|
||||
'path': resolve_relative_path('../.assets/models/arcface_converter_simswap.onnx')
|
||||
'url': resolve_download_url('models-3.4.0', 'crossface_simswap.onnx'),
|
||||
'path': resolve_relative_path('../.assets/models/crossface_simswap.onnx')
|
||||
}
|
||||
},
|
||||
'type': 'simswap',
|
||||
@@ -383,6 +454,12 @@ def create_static_model_set(download_scope : DownloadScope) -> ModelSet:
|
||||
},
|
||||
'uniface_256':
|
||||
{
|
||||
'__metadata__':
|
||||
{
|
||||
'vendor': 'xc-csc101',
|
||||
'license': 'Unknown',
|
||||
'year': 2022
|
||||
},
|
||||
'hashes':
|
||||
{
|
||||
'face_swapper':
|
||||
@@ -428,7 +505,7 @@ def get_model_options() -> ModelOptions:
|
||||
def get_model_name() -> str:
|
||||
model_name = state_manager.get_item('face_swapper_model')
|
||||
|
||||
if has_execution_provider('coreml') and model_name == 'inswapper_128_fp16':
|
||||
if is_macos() and has_execution_provider('coreml') and model_name == 'inswapper_128_fp16':
|
||||
return 'inswapper_128'
|
||||
return model_name
|
||||
|
||||
@@ -436,16 +513,18 @@ def get_model_name() -> str:
|
||||
def register_args(program : ArgumentParser) -> None:
|
||||
group_processors = find_argument_group(program, 'processors')
|
||||
if group_processors:
|
||||
group_processors.add_argument('--face-swapper-model', help = wording.get('help.face_swapper_model'), default = config.get_str_value('processors', 'face_swapper_model', 'hyperswap_1a_256'), choices = processors_choices.face_swapper_models)
|
||||
group_processors.add_argument('--face-swapper-model', help = translator.get('help.model', __package__), default = config.get_str_value('processors', 'face_swapper_model', 'hyperswap_1a_256'), choices = face_swapper_choices.face_swapper_models)
|
||||
known_args, _ = program.parse_known_args()
|
||||
face_swapper_pixel_boost_choices = processors_choices.face_swapper_set.get(known_args.face_swapper_model)
|
||||
group_processors.add_argument('--face-swapper-pixel-boost', help = wording.get('help.face_swapper_pixel_boost'), default = config.get_str_value('processors', 'face_swapper_pixel_boost', get_first(face_swapper_pixel_boost_choices)), choices = face_swapper_pixel_boost_choices)
|
||||
facefusion.jobs.job_store.register_step_keys([ 'face_swapper_model', 'face_swapper_pixel_boost' ])
|
||||
face_swapper_pixel_boost_choices = face_swapper_choices.face_swapper_set.get(known_args.face_swapper_model)
|
||||
group_processors.add_argument('--face-swapper-pixel-boost', help = translator.get('help.pixel_boost', __package__), default = config.get_str_value('processors', 'face_swapper_pixel_boost', get_first(face_swapper_pixel_boost_choices)), choices = face_swapper_pixel_boost_choices)
|
||||
group_processors.add_argument('--face-swapper-weight', help = translator.get('help.weight', __package__), type = float, default = config.get_float_value('processors', 'face_swapper_weight', '0.5'), choices = face_swapper_choices.face_swapper_weight_range)
|
||||
facefusion.jobs.job_store.register_step_keys([ 'face_swapper_model', 'face_swapper_pixel_boost', 'face_swapper_weight' ])
|
||||
|
||||
|
||||
def apply_args(args : Args, apply_state_item : ApplyStateItem) -> None:
|
||||
apply_state_item('face_swapper_model', args.get('face_swapper_model'))
|
||||
apply_state_item('face_swapper_pixel_boost', args.get('face_swapper_pixel_boost'))
|
||||
apply_state_item('face_swapper_weight', args.get('face_swapper_weight'))
|
||||
|
||||
|
||||
def pre_check() -> bool:
|
||||
@@ -457,28 +536,35 @@ def pre_check() -> bool:
|
||||
|
||||
def pre_process(mode : ProcessMode) -> bool:
|
||||
if not has_image(state_manager.get_item('source_paths')):
|
||||
logger.error(wording.get('choose_image_source') + wording.get('exclamation_mark'), __name__)
|
||||
logger.error(translator.get('choose_image_source') + translator.get('exclamation_mark'), __name__)
|
||||
return False
|
||||
|
||||
source_image_paths = filter_image_paths(state_manager.get_item('source_paths'))
|
||||
source_frames = read_static_images(source_image_paths)
|
||||
source_faces = get_many_faces(source_frames)
|
||||
|
||||
if not get_one_face(source_faces):
|
||||
logger.error(wording.get('no_source_face_detected') + wording.get('exclamation_mark'), __name__)
|
||||
logger.error(translator.get('no_source_face_detected') + translator.get('exclamation_mark'), __name__)
|
||||
return False
|
||||
|
||||
if mode in [ 'output', 'preview' ] and not is_image(state_manager.get_item('target_path')) and not is_video(state_manager.get_item('target_path')):
|
||||
logger.error(wording.get('choose_image_or_video_target') + wording.get('exclamation_mark'), __name__)
|
||||
logger.error(translator.get('choose_image_or_video_target') + translator.get('exclamation_mark'), __name__)
|
||||
return False
|
||||
|
||||
if mode == 'output' and not in_directory(state_manager.get_item('output_path')):
|
||||
logger.error(wording.get('specify_image_or_video_output') + wording.get('exclamation_mark'), __name__)
|
||||
logger.error(translator.get('specify_image_or_video_output') + translator.get('exclamation_mark'), __name__)
|
||||
return False
|
||||
|
||||
if mode == 'output' and not same_file_extension(state_manager.get_item('target_path'), state_manager.get_item('output_path')):
|
||||
logger.error(wording.get('match_target_and_output_extension') + wording.get('exclamation_mark'), __name__)
|
||||
logger.error(translator.get('match_target_and_output_extension') + translator.get('exclamation_mark'), __name__)
|
||||
return False
|
||||
|
||||
return True
|
||||
|
||||
|
||||
def post_process() -> None:
|
||||
read_static_image.cache_clear()
|
||||
read_static_video_frame.cache_clear()
|
||||
video_manager.clear_video_pool()
|
||||
if state_manager.get_item('video_memory_strategy') in [ 'strict', 'moderate' ]:
|
||||
get_static_model_initializer.cache_clear()
|
||||
@@ -512,7 +598,7 @@ def swap_face(source_face : Face, target_face : Face, temp_vision_frame : Vision
|
||||
pixel_boost_vision_frames = implode_pixel_boost(crop_vision_frame, pixel_boost_total, model_size)
|
||||
for pixel_boost_vision_frame in pixel_boost_vision_frames:
|
||||
pixel_boost_vision_frame = prepare_crop_frame(pixel_boost_vision_frame)
|
||||
pixel_boost_vision_frame = forward_swap_face(source_face, pixel_boost_vision_frame)
|
||||
pixel_boost_vision_frame = forward_swap_face(source_face, target_face, pixel_boost_vision_frame)
|
||||
pixel_boost_vision_frame = normalize_crop_frame(pixel_boost_vision_frame)
|
||||
temp_vision_frames.append(pixel_boost_vision_frame)
|
||||
crop_vision_frame = explode_pixel_boost(temp_vision_frames, pixel_boost_total, model_size, pixel_boost_size)
|
||||
@@ -527,16 +613,16 @@ def swap_face(source_face : Face, target_face : Face, temp_vision_frame : Vision
|
||||
crop_masks.append(region_mask)
|
||||
|
||||
crop_mask = numpy.minimum.reduce(crop_masks).clip(0, 1)
|
||||
temp_vision_frame = paste_back(temp_vision_frame, crop_vision_frame, crop_mask, affine_matrix)
|
||||
return temp_vision_frame
|
||||
paste_vision_frame = paste_back(temp_vision_frame, crop_vision_frame, crop_mask, affine_matrix)
|
||||
return paste_vision_frame
|
||||
|
||||
|
||||
def forward_swap_face(source_face : Face, crop_vision_frame : VisionFrame) -> VisionFrame:
|
||||
def forward_swap_face(source_face : Face, target_face : Face, crop_vision_frame : VisionFrame) -> VisionFrame:
|
||||
face_swapper = get_inference_pool().get('face_swapper')
|
||||
model_type = get_model_options().get('type')
|
||||
face_swapper_inputs = {}
|
||||
|
||||
if has_execution_provider('coreml') and model_type in [ 'ghost', 'uniface' ]:
|
||||
if is_macos() and has_execution_provider('coreml') and model_type in [ 'ghost', 'uniface' ]:
|
||||
face_swapper.set_providers([ facefusion.choices.execution_provider_set.get('cpu') ])
|
||||
|
||||
for face_swapper_input in face_swapper.get_inputs():
|
||||
@@ -544,7 +630,9 @@ def forward_swap_face(source_face : Face, crop_vision_frame : VisionFrame) -> Vi
|
||||
if model_type in [ 'blendswap', 'uniface' ]:
|
||||
face_swapper_inputs[face_swapper_input.name] = prepare_source_frame(source_face)
|
||||
else:
|
||||
face_swapper_inputs[face_swapper_input.name] = prepare_source_embedding(source_face)
|
||||
source_embedding = prepare_source_embedding(source_face)
|
||||
source_embedding = balance_source_embedding(source_embedding, target_face.embedding)
|
||||
face_swapper_inputs[face_swapper_input.name] = source_embedding
|
||||
if face_swapper_input.name == 'target':
|
||||
face_swapper_inputs[face_swapper_input.name] = crop_vision_frame
|
||||
|
||||
@@ -554,16 +642,16 @@ def forward_swap_face(source_face : Face, crop_vision_frame : VisionFrame) -> Vi
|
||||
return crop_vision_frame
|
||||
|
||||
|
||||
def forward_convert_embedding(embedding : Embedding) -> Embedding:
|
||||
def forward_convert_embedding(face_embedding : Embedding) -> Embedding:
|
||||
embedding_converter = get_inference_pool().get('embedding_converter')
|
||||
|
||||
with conditional_thread_semaphore():
|
||||
embedding = embedding_converter.run(None,
|
||||
face_embedding = embedding_converter.run(None,
|
||||
{
|
||||
'input': embedding
|
||||
'input': face_embedding
|
||||
})[0]
|
||||
|
||||
return embedding
|
||||
return face_embedding
|
||||
|
||||
|
||||
def prepare_source_frame(source_face : Face) -> VisionFrame:
|
||||
@@ -572,8 +660,10 @@ def prepare_source_frame(source_face : Face) -> VisionFrame:
|
||||
|
||||
if model_type == 'blendswap':
|
||||
source_vision_frame, _ = warp_face_by_face_landmark_5(source_vision_frame, source_face.landmark_set.get('5/68'), 'arcface_112_v2', (112, 112))
|
||||
|
||||
if model_type == 'uniface':
|
||||
source_vision_frame, _ = warp_face_by_face_landmark_5(source_vision_frame, source_face.landmark_set.get('5/68'), 'ffhq_512', (256, 256))
|
||||
|
||||
source_vision_frame = source_vision_frame[:, :, ::-1] / 255.0
|
||||
source_vision_frame = source_vision_frame.transpose(2, 0, 1)
|
||||
source_vision_frame = numpy.expand_dims(source_vision_frame, axis = 0).astype(numpy.float32)
|
||||
@@ -584,12 +674,13 @@ def prepare_source_embedding(source_face : Face) -> Embedding:
|
||||
model_type = get_model_options().get('type')
|
||||
|
||||
if model_type == 'ghost':
|
||||
source_embedding, _ = convert_embedding(source_face)
|
||||
source_embedding = source_face.embedding.reshape(-1, 512)
|
||||
source_embedding, _ = convert_source_embedding(source_embedding)
|
||||
source_embedding = source_embedding.reshape(1, -1)
|
||||
return source_embedding
|
||||
|
||||
if model_type == 'hyperswap':
|
||||
source_embedding = source_face.normed_embedding.reshape((1, -1))
|
||||
source_embedding = source_face.embedding_norm.reshape((1, -1))
|
||||
return source_embedding
|
||||
|
||||
if model_type == 'inswapper':
|
||||
@@ -599,17 +690,31 @@ def prepare_source_embedding(source_face : Face) -> Embedding:
|
||||
source_embedding = numpy.dot(source_embedding, model_initializer) / numpy.linalg.norm(source_embedding)
|
||||
return source_embedding
|
||||
|
||||
_, source_normed_embedding = convert_embedding(source_face)
|
||||
source_embedding = source_normed_embedding.reshape(1, -1)
|
||||
source_embedding = source_face.embedding.reshape(-1, 512)
|
||||
_, source_embedding_norm = convert_source_embedding(source_embedding)
|
||||
source_embedding = source_embedding_norm.reshape(1, -1)
|
||||
return source_embedding
|
||||
|
||||
|
||||
def convert_embedding(source_face : Face) -> Tuple[Embedding, Embedding]:
|
||||
embedding = source_face.embedding.reshape(-1, 512)
|
||||
embedding = forward_convert_embedding(embedding)
|
||||
embedding = embedding.ravel()
|
||||
normed_embedding = embedding / numpy.linalg.norm(embedding)
|
||||
return embedding, normed_embedding
|
||||
def balance_source_embedding(source_embedding : Embedding, target_embedding : Embedding) -> Embedding:
|
||||
model_type = get_model_options().get('type')
|
||||
face_swapper_weight = state_manager.get_item('face_swapper_weight')
|
||||
face_swapper_weight = numpy.interp(face_swapper_weight, [ 0, 1 ], [ 0.35, -0.35 ]).astype(numpy.float32)
|
||||
|
||||
if model_type in [ 'hififace', 'hyperswap', 'inswapper', 'simswap' ]:
|
||||
target_embedding = target_embedding / numpy.linalg.norm(target_embedding)
|
||||
|
||||
source_embedding = source_embedding.reshape(1, -1)
|
||||
target_embedding = target_embedding.reshape(1, -1)
|
||||
source_embedding = source_embedding * (1 - face_swapper_weight) + target_embedding * face_swapper_weight
|
||||
return source_embedding
|
||||
|
||||
|
||||
def convert_source_embedding(source_embedding : Embedding) -> Tuple[Embedding, Embedding]:
|
||||
source_embedding = forward_convert_embedding(source_embedding)
|
||||
source_embedding = source_embedding.ravel()
|
||||
source_embedding_norm = source_embedding / numpy.linalg.norm(source_embedding)
|
||||
return source_embedding, source_embedding_norm
|
||||
|
||||
|
||||
def prepare_crop_frame(crop_vision_frame : VisionFrame) -> VisionFrame:
|
||||
@@ -629,84 +734,41 @@ def normalize_crop_frame(crop_vision_frame : VisionFrame) -> VisionFrame:
|
||||
model_standard_deviation = get_model_options().get('standard_deviation')
|
||||
|
||||
crop_vision_frame = crop_vision_frame.transpose(1, 2, 0)
|
||||
|
||||
if model_type in [ 'ghost', 'hififace', 'hyperswap', 'uniface' ]:
|
||||
crop_vision_frame = crop_vision_frame * model_standard_deviation + model_mean
|
||||
|
||||
crop_vision_frame = crop_vision_frame.clip(0, 1)
|
||||
crop_vision_frame = crop_vision_frame[:, :, ::-1] * 255
|
||||
return crop_vision_frame
|
||||
|
||||
|
||||
def get_reference_frame(source_face : Face, target_face : Face, temp_vision_frame : VisionFrame) -> VisionFrame:
|
||||
return swap_face(source_face, target_face, temp_vision_frame)
|
||||
def extract_source_face(source_vision_frames : List[VisionFrame]) -> Optional[Face]:
|
||||
source_faces = []
|
||||
|
||||
if source_vision_frames:
|
||||
for source_vision_frame in source_vision_frames:
|
||||
temp_faces = get_many_faces([source_vision_frame])
|
||||
temp_faces = sort_faces_by_order(temp_faces, 'large-small')
|
||||
|
||||
if temp_faces:
|
||||
source_faces.append(get_first(temp_faces))
|
||||
|
||||
return get_average_face(source_faces)
|
||||
|
||||
|
||||
def process_frame(inputs : FaceSwapperInputs) -> VisionFrame:
|
||||
reference_faces = inputs.get('reference_faces')
|
||||
source_face = inputs.get('source_face')
|
||||
def process_frame(inputs : FaceSwapperInputs) -> ProcessorOutputs:
|
||||
reference_vision_frame = inputs.get('reference_vision_frame')
|
||||
source_vision_frames = inputs.get('source_vision_frames')
|
||||
target_vision_frame = inputs.get('target_vision_frame')
|
||||
many_faces = sort_and_filter_faces(get_many_faces([ target_vision_frame ]))
|
||||
temp_vision_frame = inputs.get('temp_vision_frame')
|
||||
temp_vision_mask = inputs.get('temp_vision_mask')
|
||||
source_face = extract_source_face(source_vision_frames)
|
||||
target_faces = select_faces(reference_vision_frame, target_vision_frame)
|
||||
|
||||
if state_manager.get_item('face_selector_mode') == 'many':
|
||||
if many_faces:
|
||||
for target_face in many_faces:
|
||||
target_vision_frame = swap_face(source_face, target_face, target_vision_frame)
|
||||
if state_manager.get_item('face_selector_mode') == 'one':
|
||||
target_face = get_one_face(many_faces)
|
||||
if target_face:
|
||||
target_vision_frame = swap_face(source_face, target_face, target_vision_frame)
|
||||
if state_manager.get_item('face_selector_mode') == 'reference':
|
||||
similar_faces = find_similar_faces(many_faces, reference_faces, state_manager.get_item('reference_face_distance'))
|
||||
if similar_faces:
|
||||
for similar_face in similar_faces:
|
||||
target_vision_frame = swap_face(source_face, similar_face, target_vision_frame)
|
||||
return target_vision_frame
|
||||
if source_face and target_faces:
|
||||
for target_face in target_faces:
|
||||
target_face = scale_face(target_face, target_vision_frame, temp_vision_frame)
|
||||
temp_vision_frame = swap_face(source_face, target_face, temp_vision_frame)
|
||||
|
||||
|
||||
def process_frames(source_paths : List[str], queue_payloads : List[QueuePayload], update_progress : UpdateProgress) -> None:
|
||||
reference_faces = get_reference_faces() if 'reference' in state_manager.get_item('face_selector_mode') else None
|
||||
source_frames = read_static_images(source_paths)
|
||||
source_faces = []
|
||||
|
||||
for source_frame in source_frames:
|
||||
temp_faces = get_many_faces([ source_frame ])
|
||||
temp_faces = sort_faces_by_order(temp_faces, 'large-small')
|
||||
if temp_faces:
|
||||
source_faces.append(get_first(temp_faces))
|
||||
source_face = get_average_face(source_faces)
|
||||
|
||||
for queue_payload in process_manager.manage(queue_payloads):
|
||||
target_vision_path = queue_payload['frame_path']
|
||||
target_vision_frame = read_image(target_vision_path)
|
||||
output_vision_frame = process_frame(
|
||||
{
|
||||
'reference_faces': reference_faces,
|
||||
'source_face': source_face,
|
||||
'target_vision_frame': target_vision_frame
|
||||
})
|
||||
write_image(target_vision_path, output_vision_frame)
|
||||
update_progress(1)
|
||||
|
||||
|
||||
def process_image(source_paths : List[str], target_path : str, output_path : str) -> None:
|
||||
reference_faces = get_reference_faces() if 'reference' in state_manager.get_item('face_selector_mode') else None
|
||||
source_frames = read_static_images(source_paths)
|
||||
source_faces = []
|
||||
|
||||
for source_frame in source_frames:
|
||||
temp_faces = get_many_faces([ source_frame ])
|
||||
temp_faces = sort_faces_by_order(temp_faces, 'large-small')
|
||||
if temp_faces:
|
||||
source_faces.append(get_first(temp_faces))
|
||||
source_face = get_average_face(source_faces)
|
||||
target_vision_frame = read_static_image(target_path)
|
||||
output_vision_frame = process_frame(
|
||||
{
|
||||
'reference_faces': reference_faces,
|
||||
'source_face': source_face,
|
||||
'target_vision_frame': target_vision_frame
|
||||
})
|
||||
write_image(output_path, output_vision_frame)
|
||||
|
||||
|
||||
def process_video(source_paths : List[str], temp_frame_paths : List[str]) -> None:
|
||||
processors.multi_process_frames(source_paths, temp_frame_paths, process_frames)
|
||||
return temp_vision_frame, temp_vision_mask
|
||||
@@ -0,0 +1,20 @@
|
||||
from facefusion.types import Locals
|
||||
|
||||
LOCALS : Locals =\
|
||||
{
|
||||
'en':
|
||||
{
|
||||
'help':
|
||||
{
|
||||
'model': 'choose the model responsible for swapping the face',
|
||||
'pixel_boost': 'choose the pixel boost resolution for the face swapper',
|
||||
'weight': 'specify the degree of weight applied to the face'
|
||||
},
|
||||
'uis':
|
||||
{
|
||||
'model_dropdown': 'FACE SWAPPER MODEL',
|
||||
'pixel_boost_dropdown': 'FACE SWAPPER PIXEL BOOST',
|
||||
'weight_slider': 'FACE SWAPPER WEIGHT'
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,18 @@
|
||||
from typing import Dict, List, Literal, TypeAlias, TypedDict
|
||||
|
||||
from facefusion.types import Mask, VisionFrame
|
||||
|
||||
FaceSwapperInputs = TypedDict('FaceSwapperInputs',
|
||||
{
|
||||
'reference_vision_frame' : VisionFrame,
|
||||
'source_vision_frames' : List[VisionFrame],
|
||||
'target_vision_frame' : VisionFrame,
|
||||
'temp_vision_frame' : VisionFrame,
|
||||
'temp_vision_mask' : Mask
|
||||
})
|
||||
|
||||
FaceSwapperModel = Literal['blendswap_256', 'ghost_1_256', 'ghost_2_256', 'ghost_3_256', 'hififace_unofficial_256', 'hyperswap_1a_256', 'hyperswap_1b_256', 'hyperswap_1c_256', 'inswapper_128', 'inswapper_128_fp16', 'simswap_256', 'simswap_unofficial_512', 'uniface_256']
|
||||
|
||||
FaceSwapperWeight : TypeAlias = float
|
||||
|
||||
FaceSwapperSet : TypeAlias = Dict[FaceSwapperModel, List[str]]
|
||||
@@ -0,0 +1,10 @@
|
||||
from typing import List, Sequence
|
||||
|
||||
from facefusion.common_helper import create_int_range
|
||||
from facefusion.processors.modules.frame_colorizer.types import FrameColorizerModel
|
||||
|
||||
frame_colorizer_models : List[FrameColorizerModel] = [ 'ddcolor', 'ddcolor_artistic', 'deoldify', 'deoldify_artistic', 'deoldify_stable' ]
|
||||
|
||||
frame_colorizer_sizes : List[str] = [ '192x192', '256x256', '384x384', '512x512' ]
|
||||
|
||||
frame_colorizer_blend_range : Sequence[int] = create_int_range(0, 100, 1)
|
||||
+54
-50
@@ -7,26 +7,32 @@ import numpy
|
||||
|
||||
import facefusion.jobs.job_manager
|
||||
import facefusion.jobs.job_store
|
||||
import facefusion.processors.core as processors
|
||||
from facefusion import config, content_analyser, inference_manager, logger, process_manager, state_manager, video_manager, wording
|
||||
from facefusion.common_helper import create_int_metavar
|
||||
from facefusion import config, content_analyser, inference_manager, logger, state_manager, translator, video_manager
|
||||
from facefusion.common_helper import create_int_metavar, is_macos
|
||||
from facefusion.download import conditional_download_hashes, conditional_download_sources, resolve_download_url
|
||||
from facefusion.execution import has_execution_provider
|
||||
from facefusion.filesystem import in_directory, is_image, is_video, resolve_relative_path, same_file_extension
|
||||
from facefusion.processors import choices as processors_choices
|
||||
from facefusion.processors.types import FrameColorizerInputs
|
||||
from facefusion.processors.modules.frame_colorizer import choices as frame_colorizer_choices
|
||||
from facefusion.processors.modules.frame_colorizer.types import FrameColorizerInputs
|
||||
from facefusion.processors.types import ProcessorOutputs
|
||||
from facefusion.program_helper import find_argument_group
|
||||
from facefusion.thread_helper import thread_semaphore
|
||||
from facefusion.types import ApplyStateItem, Args, DownloadScope, ExecutionProvider, Face, InferencePool, ModelOptions, ModelSet, ProcessMode, QueuePayload, UpdateProgress, VisionFrame
|
||||
from facefusion.vision import read_image, read_static_image, unpack_resolution, write_image
|
||||
from facefusion.types import ApplyStateItem, Args, DownloadScope, ExecutionProvider, InferencePool, ModelOptions, ModelSet, ProcessMode, VisionFrame
|
||||
from facefusion.vision import blend_frame, read_static_image, read_static_video_frame, unpack_resolution
|
||||
|
||||
|
||||
@lru_cache(maxsize = None)
|
||||
@lru_cache()
|
||||
def create_static_model_set(download_scope : DownloadScope) -> ModelSet:
|
||||
return\
|
||||
{
|
||||
'ddcolor':
|
||||
{
|
||||
'__metadata__':
|
||||
{
|
||||
'vendor': 'piddnad',
|
||||
'license': 'Apache-2.0',
|
||||
'year': 2023
|
||||
},
|
||||
'hashes':
|
||||
{
|
||||
'frame_colorizer':
|
||||
@@ -47,6 +53,12 @@ def create_static_model_set(download_scope : DownloadScope) -> ModelSet:
|
||||
},
|
||||
'ddcolor_artistic':
|
||||
{
|
||||
'__metadata__':
|
||||
{
|
||||
'vendor': 'piddnad',
|
||||
'license': 'Apache-2.0',
|
||||
'year': 2023
|
||||
},
|
||||
'hashes':
|
||||
{
|
||||
'frame_colorizer':
|
||||
@@ -67,6 +79,12 @@ def create_static_model_set(download_scope : DownloadScope) -> ModelSet:
|
||||
},
|
||||
'deoldify':
|
||||
{
|
||||
'__metadata__':
|
||||
{
|
||||
'vendor': 'jantic',
|
||||
'license': 'MIT',
|
||||
'year': 2022
|
||||
},
|
||||
'hashes':
|
||||
{
|
||||
'frame_colorizer':
|
||||
@@ -87,6 +105,12 @@ def create_static_model_set(download_scope : DownloadScope) -> ModelSet:
|
||||
},
|
||||
'deoldify_artistic':
|
||||
{
|
||||
'__metadata__':
|
||||
{
|
||||
'vendor': 'jantic',
|
||||
'license': 'MIT',
|
||||
'year': 2022
|
||||
},
|
||||
'hashes':
|
||||
{
|
||||
'frame_colorizer':
|
||||
@@ -107,6 +131,12 @@ def create_static_model_set(download_scope : DownloadScope) -> ModelSet:
|
||||
},
|
||||
'deoldify_stable':
|
||||
{
|
||||
'__metadata__':
|
||||
{
|
||||
'vendor': 'jantic',
|
||||
'license': 'MIT',
|
||||
'year': 2022
|
||||
},
|
||||
'hashes':
|
||||
{
|
||||
'frame_colorizer':
|
||||
@@ -141,7 +171,7 @@ def clear_inference_pool() -> None:
|
||||
|
||||
|
||||
def resolve_execution_providers() -> List[ExecutionProvider]:
|
||||
if has_execution_provider('coreml'):
|
||||
if is_macos() and has_execution_provider('coreml'):
|
||||
return [ 'cpu' ]
|
||||
return state_manager.get_item('execution_providers')
|
||||
|
||||
@@ -154,9 +184,9 @@ def get_model_options() -> ModelOptions:
|
||||
def register_args(program : ArgumentParser) -> None:
|
||||
group_processors = find_argument_group(program, 'processors')
|
||||
if group_processors:
|
||||
group_processors.add_argument('--frame-colorizer-model', help = wording.get('help.frame_colorizer_model'), default = config.get_str_value('processors', 'frame_colorizer_model', 'ddcolor'), choices = processors_choices.frame_colorizer_models)
|
||||
group_processors.add_argument('--frame-colorizer-size', help = wording.get('help.frame_colorizer_size'), type = str, default = config.get_str_value('processors', 'frame_colorizer_size', '256x256'), choices = processors_choices.frame_colorizer_sizes)
|
||||
group_processors.add_argument('--frame-colorizer-blend', help = wording.get('help.frame_colorizer_blend'), type = int, default = config.get_int_value('processors', 'frame_colorizer_blend', '100'), choices = processors_choices.frame_colorizer_blend_range, metavar = create_int_metavar(processors_choices.frame_colorizer_blend_range))
|
||||
group_processors.add_argument('--frame-colorizer-model', help = translator.get('help.model', __package__), default = config.get_str_value('processors', 'frame_colorizer_model', 'ddcolor'), choices = frame_colorizer_choices.frame_colorizer_models)
|
||||
group_processors.add_argument('--frame-colorizer-size', help = translator.get('help.size', __package__), type = str, default = config.get_str_value('processors', 'frame_colorizer_size', '256x256'), choices = frame_colorizer_choices.frame_colorizer_sizes)
|
||||
group_processors.add_argument('--frame-colorizer-blend', help = translator.get('help.blend', __package__), type = int, default = config.get_int_value('processors', 'frame_colorizer_blend', '100'), choices = frame_colorizer_choices.frame_colorizer_blend_range, metavar = create_int_metavar(frame_colorizer_choices.frame_colorizer_blend_range))
|
||||
facefusion.jobs.job_store.register_step_keys([ 'frame_colorizer_model', 'frame_colorizer_blend', 'frame_colorizer_size' ])
|
||||
|
||||
|
||||
@@ -175,19 +205,20 @@ def pre_check() -> bool:
|
||||
|
||||
def pre_process(mode : ProcessMode) -> bool:
|
||||
if mode in [ 'output', 'preview' ] and not is_image(state_manager.get_item('target_path')) and not is_video(state_manager.get_item('target_path')):
|
||||
logger.error(wording.get('choose_image_or_video_target') + wording.get('exclamation_mark'), __name__)
|
||||
logger.error(translator.get('choose_image_or_video_target') + translator.get('exclamation_mark'), __name__)
|
||||
return False
|
||||
if mode == 'output' and not in_directory(state_manager.get_item('output_path')):
|
||||
logger.error(wording.get('specify_image_or_video_output') + wording.get('exclamation_mark'), __name__)
|
||||
logger.error(translator.get('specify_image_or_video_output') + translator.get('exclamation_mark'), __name__)
|
||||
return False
|
||||
if mode == 'output' and not same_file_extension(state_manager.get_item('target_path'), state_manager.get_item('output_path')):
|
||||
logger.error(wording.get('match_target_and_output_extension') + wording.get('exclamation_mark'), __name__)
|
||||
logger.error(translator.get('match_target_and_output_extension') + translator.get('exclamation_mark'), __name__)
|
||||
return False
|
||||
return True
|
||||
|
||||
|
||||
def post_process() -> None:
|
||||
read_static_image.cache_clear()
|
||||
read_static_video_frame.cache_clear()
|
||||
video_manager.clear_video_pool()
|
||||
if state_manager.get_item('video_memory_strategy') in [ 'strict', 'moderate' ]:
|
||||
clear_inference_pool()
|
||||
@@ -199,7 +230,7 @@ def colorize_frame(temp_vision_frame : VisionFrame) -> VisionFrame:
|
||||
color_vision_frame = prepare_temp_frame(temp_vision_frame)
|
||||
color_vision_frame = forward(color_vision_frame)
|
||||
color_vision_frame = merge_color_frame(temp_vision_frame, color_vision_frame)
|
||||
color_vision_frame = blend_frame(temp_vision_frame, color_vision_frame)
|
||||
color_vision_frame = blend_color_frame(temp_vision_frame, color_vision_frame)
|
||||
return color_vision_frame
|
||||
|
||||
|
||||
@@ -255,41 +286,14 @@ def merge_color_frame(temp_vision_frame : VisionFrame, color_vision_frame : Visi
|
||||
return color_vision_frame
|
||||
|
||||
|
||||
def blend_frame(temp_vision_frame : VisionFrame, paste_vision_frame : VisionFrame) -> VisionFrame:
|
||||
def blend_color_frame(temp_vision_frame : VisionFrame, color_vision_frame : VisionFrame) -> VisionFrame:
|
||||
frame_colorizer_blend = 1 - (state_manager.get_item('frame_colorizer_blend') / 100)
|
||||
temp_vision_frame = cv2.addWeighted(temp_vision_frame, frame_colorizer_blend, paste_vision_frame, 1 - frame_colorizer_blend, 0)
|
||||
temp_vision_frame = blend_frame(temp_vision_frame, color_vision_frame, 1 - frame_colorizer_blend)
|
||||
return temp_vision_frame
|
||||
|
||||
|
||||
def get_reference_frame(source_face : Face, target_face : Face, temp_vision_frame : VisionFrame) -> VisionFrame:
|
||||
pass
|
||||
|
||||
|
||||
def process_frame(inputs : FrameColorizerInputs) -> VisionFrame:
|
||||
target_vision_frame = inputs.get('target_vision_frame')
|
||||
return colorize_frame(target_vision_frame)
|
||||
|
||||
|
||||
def process_frames(source_paths : List[str], queue_payloads : List[QueuePayload], update_progress : UpdateProgress) -> None:
|
||||
for queue_payload in process_manager.manage(queue_payloads):
|
||||
target_vision_path = queue_payload['frame_path']
|
||||
target_vision_frame = read_image(target_vision_path)
|
||||
output_vision_frame = process_frame(
|
||||
{
|
||||
'target_vision_frame': target_vision_frame
|
||||
})
|
||||
write_image(target_vision_path, output_vision_frame)
|
||||
update_progress(1)
|
||||
|
||||
|
||||
def process_image(source_paths : List[str], target_path : str, output_path : str) -> None:
|
||||
target_vision_frame = read_static_image(target_path)
|
||||
output_vision_frame = process_frame(
|
||||
{
|
||||
'target_vision_frame': target_vision_frame
|
||||
})
|
||||
write_image(output_path, output_vision_frame)
|
||||
|
||||
|
||||
def process_video(source_paths : List[str], temp_frame_paths : List[str]) -> None:
|
||||
processors.multi_process_frames(None, temp_frame_paths, process_frames)
|
||||
def process_frame(inputs : FrameColorizerInputs) -> ProcessorOutputs:
|
||||
temp_vision_frame = inputs.get('temp_vision_frame')
|
||||
temp_vision_mask = inputs.get('temp_vision_mask')
|
||||
temp_vision_frame = colorize_frame(temp_vision_frame)
|
||||
return temp_vision_frame, temp_vision_mask
|
||||
@@ -0,0 +1,20 @@
|
||||
from facefusion.types import Locals
|
||||
|
||||
LOCALS : Locals =\
|
||||
{
|
||||
'en':
|
||||
{
|
||||
'help':
|
||||
{
|
||||
'model': 'choose the model responsible for colorizing the frame',
|
||||
'size': 'specify the frame size provided to the frame colorizer',
|
||||
'blend': 'blend the colorized into the previous frame'
|
||||
},
|
||||
'uis':
|
||||
{
|
||||
'blend_slider': 'FRAME COLORIZER BLEND',
|
||||
'model_dropdown': 'FRAME COLORIZER MODEL',
|
||||
'size_dropdown': 'FRAME COLORIZER SIZE'
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,12 @@
|
||||
from typing import Literal, TypedDict
|
||||
|
||||
from facefusion.types import Mask, VisionFrame
|
||||
|
||||
FrameColorizerInputs = TypedDict('FrameColorizerInputs',
|
||||
{
|
||||
'target_vision_frame' : VisionFrame,
|
||||
'temp_vision_frame' : VisionFrame,
|
||||
'temp_vision_mask' : Mask
|
||||
})
|
||||
|
||||
FrameColorizerModel = Literal['ddcolor', 'ddcolor_artistic', 'deoldify', 'deoldify_artistic', 'deoldify_stable']
|
||||
@@ -0,0 +1,8 @@
|
||||
from typing import List, Sequence
|
||||
|
||||
from facefusion.common_helper import create_int_range
|
||||
from facefusion.processors.modules.frame_enhancer.types import FrameEnhancerModel
|
||||
|
||||
frame_enhancer_models : List[FrameEnhancerModel] = [ 'clear_reality_x4', 'face_dat_x4', 'lsdir_x4', 'nomos8k_sc_x4', 'real_esrgan_x2', 'real_esrgan_x2_fp16', 'real_esrgan_x4', 'real_esrgan_x4_fp16', 'real_esrgan_x8', 'real_esrgan_x8_fp16', 'real_hatgan_x4', 'real_web_photo_x4', 'realistic_rescaler_x4', 'remacri_x4', 'siax_x4', 'span_kendata_x4', 'swin2_sr_x4', 'tghq_face_x8', 'ultra_sharp_x4', 'ultra_sharp_2_x4' ]
|
||||
|
||||
frame_enhancer_blend_range : Sequence[int] = create_int_range(0, 100, 1)
|
||||
+173
-64
@@ -1,32 +1,37 @@
|
||||
from argparse import ArgumentParser
|
||||
from functools import lru_cache
|
||||
from typing import List
|
||||
|
||||
import cv2
|
||||
import numpy
|
||||
|
||||
import facefusion.jobs.job_manager
|
||||
import facefusion.jobs.job_store
|
||||
import facefusion.processors.core as processors
|
||||
from facefusion import config, content_analyser, inference_manager, logger, process_manager, state_manager, video_manager, wording
|
||||
from facefusion.common_helper import create_int_metavar
|
||||
from facefusion import config, content_analyser, inference_manager, logger, state_manager, translator, video_manager
|
||||
from facefusion.common_helper import create_int_metavar, is_macos
|
||||
from facefusion.download import conditional_download_hashes, conditional_download_sources, resolve_download_url
|
||||
from facefusion.execution import has_execution_provider
|
||||
from facefusion.filesystem import in_directory, is_image, is_video, resolve_relative_path, same_file_extension
|
||||
from facefusion.processors import choices as processors_choices
|
||||
from facefusion.processors.types import FrameEnhancerInputs
|
||||
from facefusion.processors.modules.frame_enhancer import choices as frame_enhancer_choices
|
||||
from facefusion.processors.modules.frame_enhancer.types import FrameEnhancerInputs
|
||||
from facefusion.processors.types import ProcessorOutputs
|
||||
from facefusion.program_helper import find_argument_group
|
||||
from facefusion.thread_helper import conditional_thread_semaphore
|
||||
from facefusion.types import ApplyStateItem, Args, DownloadScope, Face, InferencePool, ModelOptions, ModelSet, ProcessMode, QueuePayload, UpdateProgress, VisionFrame
|
||||
from facefusion.vision import create_tile_frames, merge_tile_frames, read_image, read_static_image, write_image
|
||||
from facefusion.types import ApplyStateItem, Args, DownloadScope, InferencePool, ModelOptions, ModelSet, ProcessMode, VisionFrame
|
||||
from facefusion.vision import blend_frame, create_tile_frames, merge_tile_frames, read_static_image, read_static_video_frame
|
||||
|
||||
|
||||
@lru_cache(maxsize = None)
|
||||
@lru_cache()
|
||||
def create_static_model_set(download_scope : DownloadScope) -> ModelSet:
|
||||
return\
|
||||
{
|
||||
'clear_reality_x4':
|
||||
{
|
||||
'__metadata__':
|
||||
{
|
||||
'vendor': 'Kim2091',
|
||||
'license': 'Non-Commercial',
|
||||
'year': 2023
|
||||
},
|
||||
'hashes':
|
||||
{
|
||||
'frame_enhancer':
|
||||
@@ -46,22 +51,28 @@ def create_static_model_set(download_scope : DownloadScope) -> ModelSet:
|
||||
'size': (128, 8, 4),
|
||||
'scale': 4
|
||||
},
|
||||
'lsdir_x4':
|
||||
'face_dat_x4':
|
||||
{
|
||||
'__metadata__':
|
||||
{
|
||||
'vendor': 'Helaman',
|
||||
'license': 'Non-Commercial',
|
||||
'year': 2023
|
||||
},
|
||||
'hashes':
|
||||
{
|
||||
'frame_enhancer':
|
||||
{
|
||||
'url': resolve_download_url('models-3.0.0', 'lsdir_x4.hash'),
|
||||
'path': resolve_relative_path('../.assets/models/lsdir_x4.hash')
|
||||
'url': resolve_download_url('models-3.5.0', 'face_dat_x4.hash'),
|
||||
'path': resolve_relative_path('../.assets/models/face_dat_x4.hash')
|
||||
}
|
||||
},
|
||||
'sources':
|
||||
{
|
||||
'frame_enhancer':
|
||||
{
|
||||
'url': resolve_download_url('models-3.0.0', 'lsdir_x4.onnx'),
|
||||
'path': resolve_relative_path('../.assets/models/lsdir_x4.onnx')
|
||||
'url': resolve_download_url('models-3.5.0', 'face_dat_x4.onnx'),
|
||||
'path': resolve_relative_path('../.assets/models/face_dat_x4.onnx')
|
||||
}
|
||||
},
|
||||
'size': (128, 8, 4),
|
||||
@@ -69,6 +80,12 @@ def create_static_model_set(download_scope : DownloadScope) -> ModelSet:
|
||||
},
|
||||
'nomos8k_sc_x4':
|
||||
{
|
||||
'__metadata__':
|
||||
{
|
||||
'vendor': 'Phhofm',
|
||||
'license': 'Non-Commercial',
|
||||
'year': 2023
|
||||
},
|
||||
'hashes':
|
||||
{
|
||||
'frame_enhancer':
|
||||
@@ -90,6 +107,12 @@ def create_static_model_set(download_scope : DownloadScope) -> ModelSet:
|
||||
},
|
||||
'real_esrgan_x2':
|
||||
{
|
||||
'__metadata__':
|
||||
{
|
||||
'vendor': 'xinntao',
|
||||
'license': 'BSD-3-Clause',
|
||||
'year': 2021
|
||||
},
|
||||
'hashes':
|
||||
{
|
||||
'frame_enhancer':
|
||||
@@ -111,6 +134,12 @@ def create_static_model_set(download_scope : DownloadScope) -> ModelSet:
|
||||
},
|
||||
'real_esrgan_x2_fp16':
|
||||
{
|
||||
'__metadata__':
|
||||
{
|
||||
'vendor': 'xinntao',
|
||||
'license': 'BSD-3-Clause',
|
||||
'year': 2021
|
||||
},
|
||||
'hashes':
|
||||
{
|
||||
'frame_enhancer':
|
||||
@@ -132,6 +161,12 @@ def create_static_model_set(download_scope : DownloadScope) -> ModelSet:
|
||||
},
|
||||
'real_esrgan_x4':
|
||||
{
|
||||
'__metadata__':
|
||||
{
|
||||
'vendor': 'xinntao',
|
||||
'license': 'BSD-3-Clause',
|
||||
'year': 2021
|
||||
},
|
||||
'hashes':
|
||||
{
|
||||
'frame_enhancer':
|
||||
@@ -153,6 +188,12 @@ def create_static_model_set(download_scope : DownloadScope) -> ModelSet:
|
||||
},
|
||||
'real_esrgan_x4_fp16':
|
||||
{
|
||||
'__metadata__':
|
||||
{
|
||||
'vendor': 'xinntao',
|
||||
'license': 'BSD-3-Clause',
|
||||
'year': 2021
|
||||
},
|
||||
'hashes':
|
||||
{
|
||||
'frame_enhancer':
|
||||
@@ -174,6 +215,12 @@ def create_static_model_set(download_scope : DownloadScope) -> ModelSet:
|
||||
},
|
||||
'real_esrgan_x8':
|
||||
{
|
||||
'__metadata__':
|
||||
{
|
||||
'vendor': 'xinntao',
|
||||
'license': 'BSD-3-Clause',
|
||||
'year': 2021
|
||||
},
|
||||
'hashes':
|
||||
{
|
||||
'frame_enhancer':
|
||||
@@ -195,6 +242,12 @@ def create_static_model_set(download_scope : DownloadScope) -> ModelSet:
|
||||
},
|
||||
'real_esrgan_x8_fp16':
|
||||
{
|
||||
'__metadata__':
|
||||
{
|
||||
'vendor': 'xinntao',
|
||||
'license': 'BSD-3-Clause',
|
||||
'year': 2021
|
||||
},
|
||||
'hashes':
|
||||
{
|
||||
'frame_enhancer':
|
||||
@@ -216,6 +269,12 @@ def create_static_model_set(download_scope : DownloadScope) -> ModelSet:
|
||||
},
|
||||
'real_hatgan_x4':
|
||||
{
|
||||
'__metadata__':
|
||||
{
|
||||
'vendor': 'XPixelGroup',
|
||||
'license': 'Apache-2.0',
|
||||
'year': 2023
|
||||
},
|
||||
'hashes':
|
||||
{
|
||||
'frame_enhancer':
|
||||
@@ -237,6 +296,12 @@ def create_static_model_set(download_scope : DownloadScope) -> ModelSet:
|
||||
},
|
||||
'real_web_photo_x4':
|
||||
{
|
||||
'__metadata__':
|
||||
{
|
||||
'vendor': 'Helaman',
|
||||
'license': 'Non-Commercial',
|
||||
'year': 2024
|
||||
},
|
||||
'hashes':
|
||||
{
|
||||
'frame_enhancer':
|
||||
@@ -258,6 +323,12 @@ def create_static_model_set(download_scope : DownloadScope) -> ModelSet:
|
||||
},
|
||||
'realistic_rescaler_x4':
|
||||
{
|
||||
'__metadata__':
|
||||
{
|
||||
'vendor': 'Mutin Choler',
|
||||
'license': 'WTFPL',
|
||||
'year': 2023
|
||||
},
|
||||
'hashes':
|
||||
{
|
||||
'frame_enhancer':
|
||||
@@ -279,6 +350,12 @@ def create_static_model_set(download_scope : DownloadScope) -> ModelSet:
|
||||
},
|
||||
'remacri_x4':
|
||||
{
|
||||
'__metadata__':
|
||||
{
|
||||
'vendor': 'FoolhardyVEVO',
|
||||
'license': 'Non-Commercial',
|
||||
'year': 2021
|
||||
},
|
||||
'hashes':
|
||||
{
|
||||
'frame_enhancer':
|
||||
@@ -300,6 +377,12 @@ def create_static_model_set(download_scope : DownloadScope) -> ModelSet:
|
||||
},
|
||||
'siax_x4':
|
||||
{
|
||||
'__metadata__':
|
||||
{
|
||||
'vendor': 'NMKD',
|
||||
'license': 'WTFPL',
|
||||
'year': 2021
|
||||
},
|
||||
'hashes':
|
||||
{
|
||||
'frame_enhancer':
|
||||
@@ -321,6 +404,12 @@ def create_static_model_set(download_scope : DownloadScope) -> ModelSet:
|
||||
},
|
||||
'span_kendata_x4':
|
||||
{
|
||||
'__metadata__':
|
||||
{
|
||||
'vendor': 'terrainer',
|
||||
'license': 'Non-Commercial',
|
||||
'year': 2024
|
||||
},
|
||||
'hashes':
|
||||
{
|
||||
'frame_enhancer':
|
||||
@@ -342,6 +431,12 @@ def create_static_model_set(download_scope : DownloadScope) -> ModelSet:
|
||||
},
|
||||
'swin2_sr_x4':
|
||||
{
|
||||
'__metadata__':
|
||||
{
|
||||
'vendor': 'mv-lab',
|
||||
'license': 'Apache-2.0',
|
||||
'year': 2022
|
||||
},
|
||||
'hashes':
|
||||
{
|
||||
'frame_enhancer':
|
||||
@@ -361,8 +456,41 @@ def create_static_model_set(download_scope : DownloadScope) -> ModelSet:
|
||||
'size': (128, 8, 4),
|
||||
'scale': 4
|
||||
},
|
||||
'tghq_face_x8':
|
||||
{
|
||||
'__metadata__':
|
||||
{
|
||||
'vendor': 'TorrentGuy',
|
||||
'license': 'GPL-3.0',
|
||||
'year': 2019
|
||||
},
|
||||
'hashes':
|
||||
{
|
||||
'frame_enhancer':
|
||||
{
|
||||
'url': resolve_download_url('models-3.5.0', 'tghq_face_x8.hash'),
|
||||
'path': resolve_relative_path('../.assets/models/tghq_face_x8.hash')
|
||||
}
|
||||
},
|
||||
'sources':
|
||||
{
|
||||
'frame_enhancer':
|
||||
{
|
||||
'url': resolve_download_url('models-3.5.0', 'tghq_face_x8.onnx'),
|
||||
'path': resolve_relative_path('../.assets/models/tghq_face_x8.onnx')
|
||||
}
|
||||
},
|
||||
'size': (128, 8, 4),
|
||||
'scale': 8
|
||||
},
|
||||
'ultra_sharp_x4':
|
||||
{
|
||||
'__metadata__':
|
||||
{
|
||||
'vendor': 'Kim2091',
|
||||
'license': 'Non-Commercial',
|
||||
'year': 2021
|
||||
},
|
||||
'hashes':
|
||||
{
|
||||
'frame_enhancer':
|
||||
@@ -384,6 +512,12 @@ def create_static_model_set(download_scope : DownloadScope) -> ModelSet:
|
||||
},
|
||||
'ultra_sharp_2_x4':
|
||||
{
|
||||
'__metadata__':
|
||||
{
|
||||
'vendor': 'Kim2091',
|
||||
'license': 'Non-Commercial',
|
||||
'year': 2025
|
||||
},
|
||||
'hashes':
|
||||
{
|
||||
'frame_enhancer':
|
||||
@@ -426,7 +560,7 @@ def get_model_options() -> ModelOptions:
|
||||
def get_frame_enhancer_model() -> str:
|
||||
frame_enhancer_model = state_manager.get_item('frame_enhancer_model')
|
||||
|
||||
if has_execution_provider('coreml'):
|
||||
if is_macos() and has_execution_provider('coreml'):
|
||||
if frame_enhancer_model == 'real_esrgan_x2_fp16':
|
||||
return 'real_esrgan_x2'
|
||||
if frame_enhancer_model == 'real_esrgan_x4_fp16':
|
||||
@@ -439,8 +573,8 @@ def get_frame_enhancer_model() -> str:
|
||||
def register_args(program : ArgumentParser) -> None:
|
||||
group_processors = find_argument_group(program, 'processors')
|
||||
if group_processors:
|
||||
group_processors.add_argument('--frame-enhancer-model', help = wording.get('help.frame_enhancer_model'), default = config.get_str_value('processors', 'frame_enhancer_model', 'span_kendata_x4'), choices = processors_choices.frame_enhancer_models)
|
||||
group_processors.add_argument('--frame-enhancer-blend', help = wording.get('help.frame_enhancer_blend'), type = int, default = config.get_int_value('processors', 'frame_enhancer_blend', '80'), choices = processors_choices.frame_enhancer_blend_range, metavar = create_int_metavar(processors_choices.frame_enhancer_blend_range))
|
||||
group_processors.add_argument('--frame-enhancer-model', help = translator.get('help.model', __package__), default = config.get_str_value('processors', 'frame_enhancer_model', 'span_kendata_x4'), choices = frame_enhancer_choices.frame_enhancer_models)
|
||||
group_processors.add_argument('--frame-enhancer-blend', help = translator.get('help.blend', __package__), type = int, default = config.get_int_value('processors', 'frame_enhancer_blend', '80'), choices = frame_enhancer_choices.frame_enhancer_blend_range, metavar = create_int_metavar(frame_enhancer_choices.frame_enhancer_blend_range))
|
||||
facefusion.jobs.job_store.register_step_keys([ 'frame_enhancer_model', 'frame_enhancer_blend' ])
|
||||
|
||||
|
||||
@@ -458,19 +592,20 @@ def pre_check() -> bool:
|
||||
|
||||
def pre_process(mode : ProcessMode) -> bool:
|
||||
if mode in [ 'output', 'preview' ] and not is_image(state_manager.get_item('target_path')) and not is_video(state_manager.get_item('target_path')):
|
||||
logger.error(wording.get('choose_image_or_video_target') + wording.get('exclamation_mark'), __name__)
|
||||
logger.error(translator.get('choose_image_or_video_target') + translator.get('exclamation_mark'), __name__)
|
||||
return False
|
||||
if mode == 'output' and not in_directory(state_manager.get_item('output_path')):
|
||||
logger.error(wording.get('specify_image_or_video_output') + wording.get('exclamation_mark'), __name__)
|
||||
logger.error(translator.get('specify_image_or_video_output') + translator.get('exclamation_mark'), __name__)
|
||||
return False
|
||||
if mode == 'output' and not same_file_extension(state_manager.get_item('target_path'), state_manager.get_item('output_path')):
|
||||
logger.error(wording.get('match_target_and_output_extension') + wording.get('exclamation_mark'), __name__)
|
||||
logger.error(translator.get('match_target_and_output_extension') + translator.get('exclamation_mark'), __name__)
|
||||
return False
|
||||
return True
|
||||
|
||||
|
||||
def post_process() -> None:
|
||||
read_static_image.cache_clear()
|
||||
read_static_video_frame.cache_clear()
|
||||
video_manager.clear_video_pool()
|
||||
if state_manager.get_item('video_memory_strategy') in [ 'strict', 'moderate' ]:
|
||||
clear_inference_pool()
|
||||
@@ -490,7 +625,7 @@ def enhance_frame(temp_vision_frame : VisionFrame) -> VisionFrame:
|
||||
tile_vision_frames[index] = normalize_tile_frame(tile_vision_frame)
|
||||
|
||||
merge_vision_frame = merge_tile_frames(tile_vision_frames, temp_width * model_scale, temp_height * model_scale, pad_width * model_scale, pad_height * model_scale, (model_size[0] * model_scale, model_size[1] * model_scale, model_size[2] * model_scale))
|
||||
temp_vision_frame = blend_frame(temp_vision_frame, merge_vision_frame)
|
||||
temp_vision_frame = blend_merge_frame(temp_vision_frame, merge_vision_frame)
|
||||
return temp_vision_frame
|
||||
|
||||
|
||||
@@ -506,55 +641,29 @@ def forward(tile_vision_frame : VisionFrame) -> VisionFrame:
|
||||
return tile_vision_frame
|
||||
|
||||
|
||||
def prepare_tile_frame(vision_tile_frame : VisionFrame) -> VisionFrame:
|
||||
vision_tile_frame = numpy.expand_dims(vision_tile_frame[:, :, ::-1], axis = 0)
|
||||
vision_tile_frame = vision_tile_frame.transpose(0, 3, 1, 2)
|
||||
vision_tile_frame = vision_tile_frame.astype(numpy.float32) / 255.0
|
||||
return vision_tile_frame
|
||||
def prepare_tile_frame(tile_vision_frame : VisionFrame) -> VisionFrame:
|
||||
tile_vision_frame = numpy.expand_dims(tile_vision_frame[:, :, ::-1], axis = 0)
|
||||
tile_vision_frame = tile_vision_frame.transpose(0, 3, 1, 2)
|
||||
tile_vision_frame = tile_vision_frame.astype(numpy.float32) / 255.0
|
||||
return tile_vision_frame
|
||||
|
||||
|
||||
def normalize_tile_frame(vision_tile_frame : VisionFrame) -> VisionFrame:
|
||||
vision_tile_frame = vision_tile_frame.transpose(0, 2, 3, 1).squeeze(0) * 255
|
||||
vision_tile_frame = vision_tile_frame.clip(0, 255).astype(numpy.uint8)[:, :, ::-1]
|
||||
return vision_tile_frame
|
||||
def normalize_tile_frame(tile_vision_frame : VisionFrame) -> VisionFrame:
|
||||
tile_vision_frame = tile_vision_frame.transpose(0, 2, 3, 1).squeeze(0) * 255
|
||||
tile_vision_frame = tile_vision_frame.clip(0, 255).astype(numpy.uint8)[:, :, ::-1]
|
||||
return tile_vision_frame
|
||||
|
||||
|
||||
def blend_frame(temp_vision_frame : VisionFrame, merge_vision_frame : VisionFrame) -> VisionFrame:
|
||||
def blend_merge_frame(temp_vision_frame : VisionFrame, merge_vision_frame : VisionFrame) -> VisionFrame:
|
||||
frame_enhancer_blend = 1 - (state_manager.get_item('frame_enhancer_blend') / 100)
|
||||
temp_vision_frame = cv2.resize(temp_vision_frame, (merge_vision_frame.shape[1], merge_vision_frame.shape[0]))
|
||||
temp_vision_frame = cv2.addWeighted(temp_vision_frame, frame_enhancer_blend, merge_vision_frame, 1 - frame_enhancer_blend, 0)
|
||||
temp_vision_frame = blend_frame(temp_vision_frame, merge_vision_frame, 1 - frame_enhancer_blend)
|
||||
return temp_vision_frame
|
||||
|
||||
|
||||
def get_reference_frame(source_face : Face, target_face : Face, temp_vision_frame : VisionFrame) -> VisionFrame:
|
||||
pass
|
||||
|
||||
|
||||
def process_frame(inputs : FrameEnhancerInputs) -> VisionFrame:
|
||||
target_vision_frame = inputs.get('target_vision_frame')
|
||||
return enhance_frame(target_vision_frame)
|
||||
|
||||
|
||||
def process_frames(source_paths : List[str], queue_payloads : List[QueuePayload], update_progress : UpdateProgress) -> None:
|
||||
for queue_payload in process_manager.manage(queue_payloads):
|
||||
target_vision_path = queue_payload['frame_path']
|
||||
target_vision_frame = read_image(target_vision_path)
|
||||
output_vision_frame = process_frame(
|
||||
{
|
||||
'target_vision_frame': target_vision_frame
|
||||
})
|
||||
write_image(target_vision_path, output_vision_frame)
|
||||
update_progress(1)
|
||||
|
||||
|
||||
def process_image(source_paths : List[str], target_path : str, output_path : str) -> None:
|
||||
target_vision_frame = read_static_image(target_path)
|
||||
output_vision_frame = process_frame(
|
||||
{
|
||||
'target_vision_frame': target_vision_frame
|
||||
})
|
||||
write_image(output_path, output_vision_frame)
|
||||
|
||||
|
||||
def process_video(source_paths : List[str], temp_frame_paths : List[str]) -> None:
|
||||
processors.multi_process_frames(None, temp_frame_paths, process_frames)
|
||||
def process_frame(inputs : FrameEnhancerInputs) -> ProcessorOutputs:
|
||||
temp_vision_frame = inputs.get('temp_vision_frame')
|
||||
temp_vision_mask = inputs.get('temp_vision_mask')
|
||||
temp_vision_frame = enhance_frame(temp_vision_frame)
|
||||
temp_vision_mask = cv2.resize(temp_vision_mask, temp_vision_frame.shape[:2][::-1])
|
||||
return temp_vision_frame, temp_vision_mask
|
||||
@@ -0,0 +1,18 @@
|
||||
from facefusion.types import Locals
|
||||
|
||||
LOCALS : Locals =\
|
||||
{
|
||||
'en':
|
||||
{
|
||||
'help':
|
||||
{
|
||||
'model': 'choose the model responsible for enhancing the frame',
|
||||
'blend': 'blend the enhanced into the previous frame'
|
||||
},
|
||||
'uis':
|
||||
{
|
||||
'blend_slider': 'FRAME ENHANCER BLEND',
|
||||
'model_dropdown': 'FRAME ENHANCER MODEL'
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,12 @@
|
||||
from typing import Literal, TypedDict
|
||||
|
||||
from facefusion.types import Mask, VisionFrame
|
||||
|
||||
FrameEnhancerInputs = TypedDict('FrameEnhancerInputs',
|
||||
{
|
||||
'target_vision_frame' : VisionFrame,
|
||||
'temp_vision_frame' : VisionFrame,
|
||||
'temp_vision_mask' : Mask
|
||||
})
|
||||
|
||||
FrameEnhancerModel = Literal['clear_reality_x4', 'face_dat_x4', 'lsdir_x4', 'nomos8k_sc_x4', 'real_esrgan_x2', 'real_esrgan_x2_fp16', 'real_esrgan_x4', 'real_esrgan_x4_fp16', 'real_esrgan_x8', 'real_esrgan_x8_fp16', 'real_hatgan_x4', 'real_web_photo_x4', 'realistic_rescaler_x4', 'remacri_x4', 'siax_x4', 'span_kendata_x4', 'swin2_sr_x4', 'tghq_face_x8', 'ultra_sharp_x4', 'ultra_sharp_2_x4']
|
||||
@@ -0,0 +1,8 @@
|
||||
from typing import List, Sequence
|
||||
|
||||
from facefusion.common_helper import create_float_range
|
||||
from facefusion.processors.modules.lip_syncer.types import LipSyncerModel
|
||||
|
||||
lip_syncer_models : List[LipSyncerModel] = [ 'edtalk_256', 'wav2lip_96', 'wav2lip_gan_96' ]
|
||||
|
||||
lip_syncer_weight_range : Sequence[float] = create_float_range(0.0, 1.0, 0.05)
|
||||
+51
-103
@@ -1,38 +1,41 @@
|
||||
from argparse import ArgumentParser
|
||||
from functools import lru_cache
|
||||
from typing import List
|
||||
|
||||
import cv2
|
||||
import numpy
|
||||
|
||||
import facefusion.jobs.job_manager
|
||||
import facefusion.jobs.job_store
|
||||
import facefusion.processors.core as processors
|
||||
from facefusion import config, content_analyser, face_classifier, face_detector, face_landmarker, face_masker, face_recognizer, inference_manager, logger, process_manager, state_manager, video_manager, voice_extractor, wording
|
||||
from facefusion.audio import create_empty_audio_frame, get_voice_frame, read_static_voice
|
||||
from facefusion import config, content_analyser, face_classifier, face_detector, face_landmarker, face_masker, face_recognizer, inference_manager, logger, state_manager, translator, video_manager, voice_extractor
|
||||
from facefusion.audio import read_static_voice
|
||||
from facefusion.common_helper import create_float_metavar
|
||||
from facefusion.common_helper import get_first
|
||||
from facefusion.download import conditional_download_hashes, conditional_download_sources, resolve_download_url
|
||||
from facefusion.face_analyser import get_many_faces, get_one_face
|
||||
from facefusion.face_analyser import scale_face
|
||||
from facefusion.face_helper import create_bounding_box, paste_back, warp_face_by_bounding_box, warp_face_by_face_landmark_5
|
||||
from facefusion.face_masker import create_area_mask, create_box_mask, create_occlusion_mask
|
||||
from facefusion.face_selector import find_similar_faces, sort_and_filter_faces
|
||||
from facefusion.face_store import get_reference_faces
|
||||
from facefusion.filesystem import filter_audio_paths, has_audio, in_directory, is_image, is_video, resolve_relative_path, same_file_extension
|
||||
from facefusion.processors import choices as processors_choices
|
||||
from facefusion.processors.types import LipSyncerInputs, LipSyncerWeight
|
||||
from facefusion.face_selector import select_faces
|
||||
from facefusion.filesystem import has_audio, resolve_relative_path
|
||||
from facefusion.processors.modules.lip_syncer import choices as lip_syncer_choices
|
||||
from facefusion.processors.modules.lip_syncer.types import LipSyncerInputs, LipSyncerWeight
|
||||
from facefusion.processors.types import ProcessorOutputs
|
||||
from facefusion.program_helper import find_argument_group
|
||||
from facefusion.thread_helper import conditional_thread_semaphore
|
||||
from facefusion.types import ApplyStateItem, Args, AudioFrame, BoundingBox, DownloadScope, Face, InferencePool, ModelOptions, ModelSet, ProcessMode, QueuePayload, UpdateProgress, VisionFrame
|
||||
from facefusion.vision import read_image, read_static_image, restrict_video_fps, write_image
|
||||
from facefusion.types import ApplyStateItem, Args, AudioFrame, DownloadScope, Face, InferencePool, ModelOptions, ModelSet, ProcessMode, VisionFrame
|
||||
from facefusion.vision import read_static_image, read_static_video_frame
|
||||
|
||||
|
||||
@lru_cache(maxsize = None)
|
||||
@lru_cache()
|
||||
def create_static_model_set(download_scope : DownloadScope) -> ModelSet:
|
||||
return\
|
||||
{
|
||||
'edtalk_256':
|
||||
{
|
||||
'__metadata__':
|
||||
{
|
||||
'vendor': 'tanshuai0219',
|
||||
'license': 'Apache-2.0',
|
||||
'year': 2024
|
||||
},
|
||||
'hashes':
|
||||
{
|
||||
'lip_syncer':
|
||||
@@ -54,6 +57,12 @@ def create_static_model_set(download_scope : DownloadScope) -> ModelSet:
|
||||
},
|
||||
'wav2lip_96':
|
||||
{
|
||||
'__metadata__':
|
||||
{
|
||||
'vendor': 'Rudrabha',
|
||||
'license': 'Non-Commercial',
|
||||
'year': 2020
|
||||
},
|
||||
'hashes':
|
||||
{
|
||||
'lip_syncer':
|
||||
@@ -75,6 +84,12 @@ def create_static_model_set(download_scope : DownloadScope) -> ModelSet:
|
||||
},
|
||||
'wav2lip_gan_96':
|
||||
{
|
||||
'__metadata__':
|
||||
{
|
||||
'vendor': 'Rudrabha',
|
||||
'license': 'Non-Commercial',
|
||||
'year': 2020
|
||||
},
|
||||
'hashes':
|
||||
{
|
||||
'lip_syncer':
|
||||
@@ -117,8 +132,8 @@ def get_model_options() -> ModelOptions:
|
||||
def register_args(program : ArgumentParser) -> None:
|
||||
group_processors = find_argument_group(program, 'processors')
|
||||
if group_processors:
|
||||
group_processors.add_argument('--lip-syncer-model', help = wording.get('help.lip_syncer_model'), default = config.get_str_value('processors', 'lip_syncer_model', 'wav2lip_gan_96'), choices = processors_choices.lip_syncer_models)
|
||||
group_processors.add_argument('--lip-syncer-weight', help = wording.get('help.lip_syncer_weight'), type = float, default = config.get_float_value('processors', 'lip_syncer_weight', '0.5'), choices = processors_choices.lip_syncer_weight_range, metavar = create_float_metavar(processors_choices.lip_syncer_weight_range))
|
||||
group_processors.add_argument('--lip-syncer-model', help = translator.get('help.model', __package__), default = config.get_str_value('processors', 'lip_syncer_model', 'wav2lip_gan_96'), choices = lip_syncer_choices.lip_syncer_models)
|
||||
group_processors.add_argument('--lip-syncer-weight', help = translator.get('help.weight', __package__), type = float, default = config.get_float_value('processors', 'lip_syncer_weight', '0.5'), choices = lip_syncer_choices.lip_syncer_weight_range, metavar = create_float_metavar(lip_syncer_choices.lip_syncer_weight_range))
|
||||
facefusion.jobs.job_store.register_step_keys([ 'lip_syncer_model', 'lip_syncer_weight' ])
|
||||
|
||||
|
||||
@@ -136,22 +151,14 @@ def pre_check() -> bool:
|
||||
|
||||
def pre_process(mode : ProcessMode) -> bool:
|
||||
if not has_audio(state_manager.get_item('source_paths')):
|
||||
logger.error(wording.get('choose_audio_source') + wording.get('exclamation_mark'), __name__)
|
||||
return False
|
||||
if mode in [ 'output', 'preview' ] and not is_image(state_manager.get_item('target_path')) and not is_video(state_manager.get_item('target_path')):
|
||||
logger.error(wording.get('choose_image_or_video_target') + wording.get('exclamation_mark'), __name__)
|
||||
return False
|
||||
if mode == 'output' and not in_directory(state_manager.get_item('output_path')):
|
||||
logger.error(wording.get('specify_image_or_video_output') + wording.get('exclamation_mark'), __name__)
|
||||
return False
|
||||
if mode == 'output' and not same_file_extension(state_manager.get_item('target_path'), state_manager.get_item('output_path')):
|
||||
logger.error(wording.get('match_target_and_output_extension') + wording.get('exclamation_mark'), __name__)
|
||||
logger.error(translator.get('choose_audio_source') + translator.get('exclamation_mark'), __name__)
|
||||
return False
|
||||
return True
|
||||
|
||||
|
||||
def post_process() -> None:
|
||||
read_static_image.cache_clear()
|
||||
read_static_video_frame.cache_clear()
|
||||
read_static_voice.cache_clear()
|
||||
video_manager.clear_video_pool()
|
||||
if state_manager.get_item('video_memory_strategy') in [ 'strict', 'moderate' ]:
|
||||
@@ -166,10 +173,10 @@ def post_process() -> None:
|
||||
voice_extractor.clear_inference_pool()
|
||||
|
||||
|
||||
def sync_lip(target_face : Face, temp_audio_frame : AudioFrame, temp_vision_frame : VisionFrame) -> VisionFrame:
|
||||
def sync_lip(target_face : Face, source_voice_frame : AudioFrame, temp_vision_frame : VisionFrame) -> VisionFrame:
|
||||
model_type = get_model_options().get('type')
|
||||
model_size = get_model_options().get('size')
|
||||
temp_audio_frame = prepare_audio_frame(temp_audio_frame)
|
||||
source_voice_frame = prepare_audio_frame(source_voice_frame)
|
||||
crop_vision_frame, affine_matrix = warp_face_by_face_landmark_5(temp_vision_frame, target_face.landmark_set.get('5/68'), 'ffhq_512', (512, 512))
|
||||
crop_masks = []
|
||||
|
||||
@@ -182,17 +189,17 @@ def sync_lip(target_face : Face, temp_audio_frame : AudioFrame, temp_vision_fram
|
||||
box_mask = create_box_mask(crop_vision_frame, state_manager.get_item('face_mask_blur'), state_manager.get_item('face_mask_padding'))
|
||||
crop_masks.append(box_mask)
|
||||
crop_vision_frame = prepare_crop_frame(crop_vision_frame)
|
||||
crop_vision_frame = forward_edtalk(temp_audio_frame, crop_vision_frame, lip_syncer_weight)
|
||||
crop_vision_frame = forward_edtalk(source_voice_frame, crop_vision_frame, lip_syncer_weight)
|
||||
crop_vision_frame = normalize_crop_frame(crop_vision_frame)
|
||||
|
||||
if model_type == 'wav2lip':
|
||||
face_landmark_68 = cv2.transform(target_face.landmark_set.get('68').reshape(1, -1, 2), affine_matrix).reshape(-1, 2)
|
||||
area_mask = create_area_mask(crop_vision_frame, face_landmark_68, [ 'lower-face' ])
|
||||
crop_masks.append(area_mask)
|
||||
bounding_box = create_bounding_box(face_landmark_68)
|
||||
bounding_box = resize_bounding_box(bounding_box, 1 / 8)
|
||||
area_vision_frame, area_matrix = warp_face_by_bounding_box(crop_vision_frame, bounding_box, model_size)
|
||||
area_vision_frame = prepare_crop_frame(area_vision_frame)
|
||||
area_vision_frame = forward_wav2lip(temp_audio_frame, area_vision_frame)
|
||||
area_vision_frame = forward_wav2lip(source_voice_frame, area_vision_frame)
|
||||
area_vision_frame = normalize_crop_frame(area_vision_frame)
|
||||
crop_vision_frame = cv2.warpAffine(area_vision_frame, cv2.invertAffineTransform(area_matrix), (512, 512), borderMode = cv2.BORDER_REPLICATE)
|
||||
|
||||
@@ -249,23 +256,17 @@ def prepare_crop_frame(crop_vision_frame : VisionFrame) -> VisionFrame:
|
||||
crop_vision_frame = cv2.resize(crop_vision_frame, model_size, interpolation = cv2.INTER_AREA)
|
||||
crop_vision_frame = crop_vision_frame[:, :, ::-1] / 255.0
|
||||
crop_vision_frame = numpy.expand_dims(crop_vision_frame.transpose(2, 0, 1), axis = 0).astype(numpy.float32)
|
||||
|
||||
if model_type == 'wav2lip':
|
||||
crop_vision_frame = numpy.expand_dims(crop_vision_frame, axis = 0)
|
||||
prepare_vision_frame = crop_vision_frame.copy()
|
||||
prepare_vision_frame[:, model_size[0] // 2:] = 0
|
||||
crop_vision_frame = numpy.concatenate((prepare_vision_frame, crop_vision_frame), axis = 3)
|
||||
crop_vision_frame = crop_vision_frame.transpose(0, 3, 1, 2).astype('float32') / 255.0
|
||||
crop_vision_frame = crop_vision_frame.transpose(0, 3, 1, 2).astype(numpy.float32) / 255.0
|
||||
|
||||
return crop_vision_frame
|
||||
|
||||
|
||||
def resize_bounding_box(bounding_box : BoundingBox, aspect_ratio : float) -> BoundingBox:
|
||||
x1, y1, x2, y2 = bounding_box
|
||||
y1 -= numpy.abs(y2 - y1) * aspect_ratio
|
||||
bounding_box[1] = max(y1, 0)
|
||||
return bounding_box
|
||||
|
||||
|
||||
def normalize_crop_frame(crop_vision_frame : VisionFrame) -> VisionFrame:
|
||||
model_type = get_model_options().get('type')
|
||||
crop_vision_frame = crop_vision_frame[0].transpose(1, 2, 0)
|
||||
@@ -279,70 +280,17 @@ def normalize_crop_frame(crop_vision_frame : VisionFrame) -> VisionFrame:
|
||||
return crop_vision_frame
|
||||
|
||||
|
||||
def get_reference_frame(source_face : Face, target_face : Face, temp_vision_frame : VisionFrame) -> VisionFrame:
|
||||
pass
|
||||
|
||||
|
||||
def process_frame(inputs : LipSyncerInputs) -> VisionFrame:
|
||||
reference_faces = inputs.get('reference_faces')
|
||||
source_audio_frame = inputs.get('source_audio_frame')
|
||||
def process_frame(inputs : LipSyncerInputs) -> ProcessorOutputs:
|
||||
reference_vision_frame = inputs.get('reference_vision_frame')
|
||||
source_voice_frame = inputs.get('source_voice_frame')
|
||||
target_vision_frame = inputs.get('target_vision_frame')
|
||||
many_faces = sort_and_filter_faces(get_many_faces([ target_vision_frame ]))
|
||||
temp_vision_frame = inputs.get('temp_vision_frame')
|
||||
temp_vision_mask = inputs.get('temp_vision_mask')
|
||||
target_faces = select_faces(reference_vision_frame, target_vision_frame)
|
||||
|
||||
if state_manager.get_item('face_selector_mode') == 'many':
|
||||
if many_faces:
|
||||
for target_face in many_faces:
|
||||
target_vision_frame = sync_lip(target_face, source_audio_frame, target_vision_frame)
|
||||
if state_manager.get_item('face_selector_mode') == 'one':
|
||||
target_face = get_one_face(many_faces)
|
||||
if target_face:
|
||||
target_vision_frame = sync_lip(target_face, source_audio_frame, target_vision_frame)
|
||||
if state_manager.get_item('face_selector_mode') == 'reference':
|
||||
similar_faces = find_similar_faces(many_faces, reference_faces, state_manager.get_item('reference_face_distance'))
|
||||
if similar_faces:
|
||||
for similar_face in similar_faces:
|
||||
target_vision_frame = sync_lip(similar_face, source_audio_frame, target_vision_frame)
|
||||
return target_vision_frame
|
||||
if target_faces:
|
||||
for target_face in target_faces:
|
||||
target_face = scale_face(target_face, target_vision_frame, temp_vision_frame)
|
||||
temp_vision_frame = sync_lip(target_face, source_voice_frame, temp_vision_frame)
|
||||
|
||||
|
||||
def process_frames(source_paths : List[str], queue_payloads : List[QueuePayload], update_progress : UpdateProgress) -> None:
|
||||
reference_faces = get_reference_faces() if 'reference' in state_manager.get_item('face_selector_mode') else None
|
||||
source_audio_path = get_first(filter_audio_paths(source_paths))
|
||||
temp_video_fps = restrict_video_fps(state_manager.get_item('target_path'), state_manager.get_item('output_video_fps'))
|
||||
|
||||
for queue_payload in process_manager.manage(queue_payloads):
|
||||
frame_number = queue_payload.get('frame_number')
|
||||
target_vision_path = queue_payload.get('frame_path')
|
||||
source_audio_frame = get_voice_frame(source_audio_path, temp_video_fps, frame_number)
|
||||
if not numpy.any(source_audio_frame):
|
||||
source_audio_frame = create_empty_audio_frame()
|
||||
target_vision_frame = read_image(target_vision_path)
|
||||
output_vision_frame = process_frame(
|
||||
{
|
||||
'reference_faces': reference_faces,
|
||||
'source_audio_frame': source_audio_frame,
|
||||
'target_vision_frame': target_vision_frame
|
||||
})
|
||||
write_image(target_vision_path, output_vision_frame)
|
||||
update_progress(1)
|
||||
|
||||
|
||||
def process_image(source_paths : List[str], target_path : str, output_path : str) -> None:
|
||||
reference_faces = get_reference_faces() if 'reference' in state_manager.get_item('face_selector_mode') else None
|
||||
source_audio_frame = create_empty_audio_frame()
|
||||
target_vision_frame = read_static_image(target_path)
|
||||
output_vision_frame = process_frame(
|
||||
{
|
||||
'reference_faces': reference_faces,
|
||||
'source_audio_frame': source_audio_frame,
|
||||
'target_vision_frame': target_vision_frame
|
||||
})
|
||||
write_image(output_path, output_vision_frame)
|
||||
|
||||
|
||||
def process_video(source_paths : List[str], temp_frame_paths : List[str]) -> None:
|
||||
source_audio_paths = filter_audio_paths(state_manager.get_item('source_paths'))
|
||||
temp_video_fps = restrict_video_fps(state_manager.get_item('target_path'), state_manager.get_item('output_video_fps'))
|
||||
for source_audio_path in source_audio_paths:
|
||||
read_static_voice(source_audio_path, temp_video_fps)
|
||||
processors.multi_process_frames(source_paths, temp_frame_paths, process_frames)
|
||||
return temp_vision_frame, temp_vision_mask
|
||||
@@ -0,0 +1,18 @@
|
||||
from facefusion.types import Locals
|
||||
|
||||
LOCALS : Locals =\
|
||||
{
|
||||
'en':
|
||||
{
|
||||
'help':
|
||||
{
|
||||
'model': 'choose the model responsible for syncing the lips',
|
||||
'weight': 'specify the degree of weight applied to the lips'
|
||||
},
|
||||
'uis':
|
||||
{
|
||||
'model_dropdown': 'LIP SYNCER MODEL',
|
||||
'weight_slider': 'LIP SYNCER WEIGHT'
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,18 @@
|
||||
from typing import Any, Literal, TypeAlias, TypedDict
|
||||
|
||||
from numpy.typing import NDArray
|
||||
|
||||
from facefusion.types import AudioFrame, Mask, VisionFrame
|
||||
|
||||
LipSyncerInputs = TypedDict('LipSyncerInputs',
|
||||
{
|
||||
'reference_vision_frame' : VisionFrame,
|
||||
'source_voice_frame' : AudioFrame,
|
||||
'target_vision_frame' : VisionFrame,
|
||||
'temp_vision_frame' : VisionFrame,
|
||||
'temp_vision_mask' : Mask
|
||||
})
|
||||
|
||||
LipSyncerModel = Literal['edtalk_256', 'wav2lip_96', 'wav2lip_gan_96']
|
||||
|
||||
LipSyncerWeight : TypeAlias = NDArray[Any]
|
||||
@@ -1,153 +1,9 @@
|
||||
from typing import Any, Dict, List, Literal, TypeAlias, TypedDict
|
||||
from typing import Any, Dict, Tuple, TypeAlias
|
||||
|
||||
from numpy.typing import NDArray
|
||||
|
||||
from facefusion.types import AppContext, AudioFrame, Face, FaceSet, VisionFrame
|
||||
from facefusion.types import AppContext, Mask, VisionFrame
|
||||
|
||||
AgeModifierModel = Literal['styleganex_age']
|
||||
DeepSwapperModel : TypeAlias = str
|
||||
ExpressionRestorerModel = Literal['live_portrait']
|
||||
FaceDebuggerItem = Literal['bounding-box', 'face-landmark-5', 'face-landmark-5/68', 'face-landmark-68', 'face-landmark-68/5', 'face-mask', 'face-detector-score', 'face-landmarker-score', 'age', 'gender', 'race']
|
||||
FaceEditorModel = Literal['live_portrait']
|
||||
FaceEnhancerModel = Literal['codeformer', 'gfpgan_1.2', 'gfpgan_1.3', 'gfpgan_1.4', 'gpen_bfr_256', 'gpen_bfr_512', 'gpen_bfr_1024', 'gpen_bfr_2048', 'restoreformer_plus_plus']
|
||||
FaceSwapperModel = Literal['blendswap_256', 'ghost_1_256', 'ghost_2_256', 'ghost_3_256', 'hififace_unofficial_256', 'hyperswap_1a_256', 'hyperswap_1b_256', 'hyperswap_1c_256', 'inswapper_128', 'inswapper_128_fp16', 'simswap_256', 'simswap_unofficial_512', 'uniface_256']
|
||||
FrameColorizerModel = Literal['ddcolor', 'ddcolor_artistic', 'deoldify', 'deoldify_artistic', 'deoldify_stable']
|
||||
FrameEnhancerModel = Literal['clear_reality_x4', 'lsdir_x4', 'nomos8k_sc_x4', 'real_esrgan_x2', 'real_esrgan_x2_fp16', 'real_esrgan_x4', 'real_esrgan_x4_fp16', 'real_esrgan_x8', 'real_esrgan_x8_fp16', 'real_hatgan_x4', 'real_web_photo_x4', 'realistic_rescaler_x4', 'remacri_x4', 'siax_x4', 'span_kendata_x4', 'swin2_sr_x4', 'ultra_sharp_x4', 'ultra_sharp_2_x4']
|
||||
LipSyncerModel = Literal['edtalk_256', 'wav2lip_96', 'wav2lip_gan_96']
|
||||
|
||||
FaceSwapperSet : TypeAlias = Dict[FaceSwapperModel, List[str]]
|
||||
|
||||
AgeModifierInputs = TypedDict('AgeModifierInputs',
|
||||
{
|
||||
'reference_faces' : FaceSet,
|
||||
'target_vision_frame' : VisionFrame
|
||||
})
|
||||
DeepSwapperInputs = TypedDict('DeepSwapperInputs',
|
||||
{
|
||||
'reference_faces' : FaceSet,
|
||||
'target_vision_frame' : VisionFrame
|
||||
})
|
||||
ExpressionRestorerInputs = TypedDict('ExpressionRestorerInputs',
|
||||
{
|
||||
'reference_faces' : FaceSet,
|
||||
'source_vision_frame' : VisionFrame,
|
||||
'target_vision_frame' : VisionFrame
|
||||
})
|
||||
FaceDebuggerInputs = TypedDict('FaceDebuggerInputs',
|
||||
{
|
||||
'reference_faces' : FaceSet,
|
||||
'target_vision_frame' : VisionFrame
|
||||
})
|
||||
FaceEditorInputs = TypedDict('FaceEditorInputs',
|
||||
{
|
||||
'reference_faces' : FaceSet,
|
||||
'target_vision_frame' : VisionFrame
|
||||
})
|
||||
FaceEnhancerInputs = TypedDict('FaceEnhancerInputs',
|
||||
{
|
||||
'reference_faces' : FaceSet,
|
||||
'target_vision_frame' : VisionFrame
|
||||
})
|
||||
FaceSwapperInputs = TypedDict('FaceSwapperInputs',
|
||||
{
|
||||
'reference_faces' : FaceSet,
|
||||
'source_face' : Face,
|
||||
'target_vision_frame' : VisionFrame
|
||||
})
|
||||
FrameColorizerInputs = TypedDict('FrameColorizerInputs',
|
||||
{
|
||||
'target_vision_frame' : VisionFrame
|
||||
})
|
||||
FrameEnhancerInputs = TypedDict('FrameEnhancerInputs',
|
||||
{
|
||||
'target_vision_frame' : VisionFrame
|
||||
})
|
||||
LipSyncerInputs = TypedDict('LipSyncerInputs',
|
||||
{
|
||||
'reference_faces' : FaceSet,
|
||||
'source_audio_frame' : AudioFrame,
|
||||
'target_vision_frame' : VisionFrame
|
||||
})
|
||||
|
||||
ProcessorStateKey = Literal\
|
||||
[
|
||||
'age_modifier_model',
|
||||
'age_modifier_direction',
|
||||
'deep_swapper_model',
|
||||
'deep_swapper_morph',
|
||||
'expression_restorer_model',
|
||||
'expression_restorer_factor',
|
||||
'face_debugger_items',
|
||||
'face_editor_model',
|
||||
'face_editor_eyebrow_direction',
|
||||
'face_editor_eye_gaze_horizontal',
|
||||
'face_editor_eye_gaze_vertical',
|
||||
'face_editor_eye_open_ratio',
|
||||
'face_editor_lip_open_ratio',
|
||||
'face_editor_mouth_grim',
|
||||
'face_editor_mouth_pout',
|
||||
'face_editor_mouth_purse',
|
||||
'face_editor_mouth_smile',
|
||||
'face_editor_mouth_position_horizontal',
|
||||
'face_editor_mouth_position_vertical',
|
||||
'face_editor_head_pitch',
|
||||
'face_editor_head_yaw',
|
||||
'face_editor_head_roll',
|
||||
'face_enhancer_model',
|
||||
'face_enhancer_blend',
|
||||
'face_enhancer_weight',
|
||||
'face_swapper_model',
|
||||
'face_swapper_pixel_boost',
|
||||
'frame_colorizer_model',
|
||||
'frame_colorizer_size',
|
||||
'frame_colorizer_blend',
|
||||
'frame_enhancer_model',
|
||||
'frame_enhancer_blend',
|
||||
'lip_syncer_model',
|
||||
'lip_syncer_weight'
|
||||
]
|
||||
ProcessorState = TypedDict('ProcessorState',
|
||||
{
|
||||
'age_modifier_model' : AgeModifierModel,
|
||||
'age_modifier_direction' : int,
|
||||
'deep_swapper_model' : DeepSwapperModel,
|
||||
'deep_swapper_morph' : int,
|
||||
'expression_restorer_model' : ExpressionRestorerModel,
|
||||
'expression_restorer_factor' : int,
|
||||
'face_debugger_items' : List[FaceDebuggerItem],
|
||||
'face_editor_model' : FaceEditorModel,
|
||||
'face_editor_eyebrow_direction' : float,
|
||||
'face_editor_eye_gaze_horizontal' : float,
|
||||
'face_editor_eye_gaze_vertical' : float,
|
||||
'face_editor_eye_open_ratio' : float,
|
||||
'face_editor_lip_open_ratio' : float,
|
||||
'face_editor_mouth_grim' : float,
|
||||
'face_editor_mouth_pout' : float,
|
||||
'face_editor_mouth_purse' : float,
|
||||
'face_editor_mouth_smile' : float,
|
||||
'face_editor_mouth_position_horizontal' : float,
|
||||
'face_editor_mouth_position_vertical' : float,
|
||||
'face_editor_head_pitch' : float,
|
||||
'face_editor_head_yaw' : float,
|
||||
'face_editor_head_roll' : float,
|
||||
'face_enhancer_model' : FaceEnhancerModel,
|
||||
'face_enhancer_blend' : int,
|
||||
'face_enhancer_weight' : float,
|
||||
'face_swapper_model' : FaceSwapperModel,
|
||||
'face_swapper_pixel_boost' : str,
|
||||
'frame_colorizer_model' : FrameColorizerModel,
|
||||
'frame_colorizer_size' : str,
|
||||
'frame_colorizer_blend' : int,
|
||||
'frame_enhancer_model' : FrameEnhancerModel,
|
||||
'frame_enhancer_blend' : int,
|
||||
'lip_syncer_model' : LipSyncerModel
|
||||
})
|
||||
ProcessorStateSet : TypeAlias = Dict[AppContext, ProcessorState]
|
||||
|
||||
AgeModifierDirection : TypeAlias = NDArray[Any]
|
||||
DeepSwapperMorph : TypeAlias = NDArray[Any]
|
||||
FaceEnhancerWeight : TypeAlias = NDArray[Any]
|
||||
LipSyncerWeight : TypeAlias = NDArray[Any]
|
||||
LivePortraitPitch : TypeAlias = float
|
||||
LivePortraitYaw : TypeAlias = float
|
||||
LivePortraitRoll : TypeAlias = float
|
||||
@@ -157,3 +13,8 @@ LivePortraitMotionPoints : TypeAlias = NDArray[Any]
|
||||
LivePortraitRotation : TypeAlias = NDArray[Any]
|
||||
LivePortraitScale : TypeAlias = NDArray[Any]
|
||||
LivePortraitTranslation : TypeAlias = NDArray[Any]
|
||||
|
||||
ProcessorStateKey = str
|
||||
ProcessorState : TypeAlias = Dict[ProcessorStateKey, Any]
|
||||
ProcessorStateSet : TypeAlias = Dict[AppContext, ProcessorState]
|
||||
ProcessorOutputs : TypeAlias = Tuple[VisionFrame, Mask]
|
||||
|
||||
+99
-89
@@ -1,14 +1,16 @@
|
||||
import tempfile
|
||||
from argparse import ArgumentParser, HelpFormatter
|
||||
from functools import partial
|
||||
|
||||
import facefusion.choices
|
||||
from facefusion import config, metadata, state_manager, wording
|
||||
from facefusion import config, metadata, state_manager, translator
|
||||
from facefusion.common_helper import create_float_metavar, create_int_metavar, get_first, get_last
|
||||
from facefusion.execution import get_available_execution_providers
|
||||
from facefusion.ffmpeg import get_available_encoder_set
|
||||
from facefusion.filesystem import get_file_name, resolve_file_paths
|
||||
from facefusion.jobs import job_store
|
||||
from facefusion.processors.core import get_processors_modules
|
||||
from facefusion.sanitizer import sanitize_int_range
|
||||
|
||||
|
||||
def create_help_formatter_small(prog : str) -> HelpFormatter:
|
||||
@@ -22,7 +24,7 @@ def create_help_formatter_large(prog : str) -> HelpFormatter:
|
||||
def create_config_path_program() -> ArgumentParser:
|
||||
program = ArgumentParser(add_help = False)
|
||||
group_paths = program.add_argument_group('paths')
|
||||
group_paths.add_argument('--config-path', help = wording.get('help.config_path'), default = 'facefusion.ini')
|
||||
group_paths.add_argument('--config-path', help = translator.get('help.config_path'), default = 'facefusion.ini')
|
||||
job_store.register_job_keys([ 'config_path' ])
|
||||
apply_config_path(program)
|
||||
return program
|
||||
@@ -31,7 +33,7 @@ def create_config_path_program() -> ArgumentParser:
|
||||
def create_temp_path_program() -> ArgumentParser:
|
||||
program = ArgumentParser(add_help = False)
|
||||
group_paths = program.add_argument_group('paths')
|
||||
group_paths.add_argument('--temp-path', help = wording.get('help.temp_path'), default = config.get_str_value('paths', 'temp_path', tempfile.gettempdir()))
|
||||
group_paths.add_argument('--temp-path', help = translator.get('help.temp_path'), default = config.get_str_value('paths', 'temp_path', tempfile.gettempdir()))
|
||||
job_store.register_job_keys([ 'temp_path' ])
|
||||
return program
|
||||
|
||||
@@ -39,7 +41,7 @@ def create_temp_path_program() -> ArgumentParser:
|
||||
def create_jobs_path_program() -> ArgumentParser:
|
||||
program = ArgumentParser(add_help = False)
|
||||
group_paths = program.add_argument_group('paths')
|
||||
group_paths.add_argument('--jobs-path', help = wording.get('help.jobs_path'), default = config.get_str_value('paths', 'jobs_path', '.jobs'))
|
||||
group_paths.add_argument('--jobs-path', help = translator.get('help.jobs_path'), default = config.get_str_value('paths', 'jobs_path', '.jobs'))
|
||||
job_store.register_job_keys([ 'jobs_path' ])
|
||||
return program
|
||||
|
||||
@@ -47,7 +49,7 @@ def create_jobs_path_program() -> ArgumentParser:
|
||||
def create_source_paths_program() -> ArgumentParser:
|
||||
program = ArgumentParser(add_help = False)
|
||||
group_paths = program.add_argument_group('paths')
|
||||
group_paths.add_argument('-s', '--source-paths', help = wording.get('help.source_paths'), default = config.get_str_list('paths', 'source_paths'), nargs = '+')
|
||||
group_paths.add_argument('-s', '--source-paths', help = translator.get('help.source_paths'), default = config.get_str_list('paths', 'source_paths'), nargs = '+')
|
||||
job_store.register_step_keys([ 'source_paths' ])
|
||||
return program
|
||||
|
||||
@@ -55,7 +57,7 @@ def create_source_paths_program() -> ArgumentParser:
|
||||
def create_target_path_program() -> ArgumentParser:
|
||||
program = ArgumentParser(add_help = False)
|
||||
group_paths = program.add_argument_group('paths')
|
||||
group_paths.add_argument('-t', '--target-path', help = wording.get('help.target_path'), default = config.get_str_value('paths', 'target_path'))
|
||||
group_paths.add_argument('-t', '--target-path', help = translator.get('help.target_path'), default = config.get_str_value('paths', 'target_path'))
|
||||
job_store.register_step_keys([ 'target_path' ])
|
||||
return program
|
||||
|
||||
@@ -63,7 +65,7 @@ def create_target_path_program() -> ArgumentParser:
|
||||
def create_output_path_program() -> ArgumentParser:
|
||||
program = ArgumentParser(add_help = False)
|
||||
group_paths = program.add_argument_group('paths')
|
||||
group_paths.add_argument('-o', '--output-path', help = wording.get('help.output_path'), default = config.get_str_value('paths', 'output_path'))
|
||||
group_paths.add_argument('-o', '--output-path', help = translator.get('help.output_path'), default = config.get_str_value('paths', 'output_path'))
|
||||
job_store.register_step_keys([ 'output_path' ])
|
||||
return program
|
||||
|
||||
@@ -71,7 +73,7 @@ def create_output_path_program() -> ArgumentParser:
|
||||
def create_source_pattern_program() -> ArgumentParser:
|
||||
program = ArgumentParser(add_help = False)
|
||||
group_patterns = program.add_argument_group('patterns')
|
||||
group_patterns.add_argument('-s', '--source-pattern', help = wording.get('help.source_pattern'), default = config.get_str_value('patterns', 'source_pattern'))
|
||||
group_patterns.add_argument('-s', '--source-pattern', help = translator.get('help.source_pattern'), default = config.get_str_value('patterns', 'source_pattern'))
|
||||
job_store.register_job_keys([ 'source_pattern' ])
|
||||
return program
|
||||
|
||||
@@ -79,7 +81,7 @@ def create_source_pattern_program() -> ArgumentParser:
|
||||
def create_target_pattern_program() -> ArgumentParser:
|
||||
program = ArgumentParser(add_help = False)
|
||||
group_patterns = program.add_argument_group('patterns')
|
||||
group_patterns.add_argument('-t', '--target-pattern', help = wording.get('help.target_pattern'), default = config.get_str_value('patterns', 'target_pattern'))
|
||||
group_patterns.add_argument('-t', '--target-pattern', help = translator.get('help.target_pattern'), default = config.get_str_value('patterns', 'target_pattern'))
|
||||
job_store.register_job_keys([ 'target_pattern' ])
|
||||
return program
|
||||
|
||||
@@ -87,7 +89,7 @@ def create_target_pattern_program() -> ArgumentParser:
|
||||
def create_output_pattern_program() -> ArgumentParser:
|
||||
program = ArgumentParser(add_help = False)
|
||||
group_patterns = program.add_argument_group('patterns')
|
||||
group_patterns.add_argument('-o', '--output-pattern', help = wording.get('help.output_pattern'), default = config.get_str_value('patterns', 'output_pattern'))
|
||||
group_patterns.add_argument('-o', '--output-pattern', help = translator.get('help.output_pattern'), default = config.get_str_value('patterns', 'output_pattern'))
|
||||
job_store.register_job_keys([ 'output_pattern' ])
|
||||
return program
|
||||
|
||||
@@ -95,21 +97,22 @@ def create_output_pattern_program() -> ArgumentParser:
|
||||
def create_face_detector_program() -> ArgumentParser:
|
||||
program = ArgumentParser(add_help = False)
|
||||
group_face_detector = program.add_argument_group('face detector')
|
||||
group_face_detector.add_argument('--face-detector-model', help = wording.get('help.face_detector_model'), default = config.get_str_value('face_detector', 'face_detector_model', 'yolo_face'), choices = facefusion.choices.face_detector_models)
|
||||
group_face_detector.add_argument('--face-detector-model', help = translator.get('help.face_detector_model'), default = config.get_str_value('face_detector', 'face_detector_model', 'yolo_face'), choices = facefusion.choices.face_detector_models)
|
||||
known_args, _ = program.parse_known_args()
|
||||
face_detector_size_choices = facefusion.choices.face_detector_set.get(known_args.face_detector_model)
|
||||
group_face_detector.add_argument('--face-detector-size', help = wording.get('help.face_detector_size'), default = config.get_str_value('face_detector', 'face_detector_size', get_last(face_detector_size_choices)), choices = face_detector_size_choices)
|
||||
group_face_detector.add_argument('--face-detector-angles', help = wording.get('help.face_detector_angles'), type = int, default = config.get_int_list('face_detector', 'face_detector_angles', '0'), choices = facefusion.choices.face_detector_angles, nargs = '+', metavar = 'FACE_DETECTOR_ANGLES')
|
||||
group_face_detector.add_argument('--face-detector-score', help = wording.get('help.face_detector_score'), type = float, default = config.get_float_value('face_detector', 'face_detector_score', '0.5'), choices = facefusion.choices.face_detector_score_range, metavar = create_float_metavar(facefusion.choices.face_detector_score_range))
|
||||
job_store.register_step_keys([ 'face_detector_model', 'face_detector_angles', 'face_detector_size', 'face_detector_score' ])
|
||||
group_face_detector.add_argument('--face-detector-size', help = translator.get('help.face_detector_size'), default = config.get_str_value('face_detector', 'face_detector_size', get_last(face_detector_size_choices)), choices = face_detector_size_choices)
|
||||
group_face_detector.add_argument('--face-detector-margin', help = translator.get('help.face_detector_margin'), type = partial(sanitize_int_range, int_range = facefusion.choices.face_detector_margin_range), default = config.get_int_list('face_detector', 'face_detector_margin', '0 0 0 0'), nargs = '+')
|
||||
group_face_detector.add_argument('--face-detector-angles', help = translator.get('help.face_detector_angles'), type = int, default = config.get_int_list('face_detector', 'face_detector_angles', '0'), choices = facefusion.choices.face_detector_angles, nargs = '+', metavar = 'FACE_DETECTOR_ANGLES')
|
||||
group_face_detector.add_argument('--face-detector-score', help = translator.get('help.face_detector_score'), type = float, default = config.get_float_value('face_detector', 'face_detector_score', '0.5'), choices = facefusion.choices.face_detector_score_range, metavar = create_float_metavar(facefusion.choices.face_detector_score_range))
|
||||
job_store.register_step_keys([ 'face_detector_model', 'face_detector_size', 'face_detector_margin', 'face_detector_angles', 'face_detector_score' ])
|
||||
return program
|
||||
|
||||
|
||||
def create_face_landmarker_program() -> ArgumentParser:
|
||||
program = ArgumentParser(add_help = False)
|
||||
group_face_landmarker = program.add_argument_group('face landmarker')
|
||||
group_face_landmarker.add_argument('--face-landmarker-model', help = wording.get('help.face_landmarker_model'), default = config.get_str_value('face_landmarker', 'face_landmarker_model', '2dfan4'), choices = facefusion.choices.face_landmarker_models)
|
||||
group_face_landmarker.add_argument('--face-landmarker-score', help = wording.get('help.face_landmarker_score'), type = float, default = config.get_float_value('face_landmarker', 'face_landmarker_score', '0.5'), choices = facefusion.choices.face_landmarker_score_range, metavar = create_float_metavar(facefusion.choices.face_landmarker_score_range))
|
||||
group_face_landmarker.add_argument('--face-landmarker-model', help = translator.get('help.face_landmarker_model'), default = config.get_str_value('face_landmarker', 'face_landmarker_model', '2dfan4'), choices = facefusion.choices.face_landmarker_models)
|
||||
group_face_landmarker.add_argument('--face-landmarker-score', help = translator.get('help.face_landmarker_score'), type = float, default = config.get_float_value('face_landmarker', 'face_landmarker_score', '0.5'), choices = facefusion.choices.face_landmarker_score_range, metavar = create_float_metavar(facefusion.choices.face_landmarker_score_range))
|
||||
job_store.register_step_keys([ 'face_landmarker_model', 'face_landmarker_score' ])
|
||||
return program
|
||||
|
||||
@@ -117,15 +120,15 @@ def create_face_landmarker_program() -> ArgumentParser:
|
||||
def create_face_selector_program() -> ArgumentParser:
|
||||
program = ArgumentParser(add_help = False)
|
||||
group_face_selector = program.add_argument_group('face selector')
|
||||
group_face_selector.add_argument('--face-selector-mode', help = wording.get('help.face_selector_mode'), default = config.get_str_value('face_selector', 'face_selector_mode', 'reference'), choices = facefusion.choices.face_selector_modes)
|
||||
group_face_selector.add_argument('--face-selector-order', help = wording.get('help.face_selector_order'), default = config.get_str_value('face_selector', 'face_selector_order', 'large-small'), choices = facefusion.choices.face_selector_orders)
|
||||
group_face_selector.add_argument('--face-selector-age-start', help = wording.get('help.face_selector_age_start'), type = int, default = config.get_int_value('face_selector', 'face_selector_age_start'), choices = facefusion.choices.face_selector_age_range, metavar = create_int_metavar(facefusion.choices.face_selector_age_range))
|
||||
group_face_selector.add_argument('--face-selector-age-end', help = wording.get('help.face_selector_age_end'), type = int, default = config.get_int_value('face_selector', 'face_selector_age_end'), choices = facefusion.choices.face_selector_age_range, metavar = create_int_metavar(facefusion.choices.face_selector_age_range))
|
||||
group_face_selector.add_argument('--face-selector-gender', help = wording.get('help.face_selector_gender'), default = config.get_str_value('face_selector', 'face_selector_gender'), choices = facefusion.choices.face_selector_genders)
|
||||
group_face_selector.add_argument('--face-selector-race', help = wording.get('help.face_selector_race'), default = config.get_str_value('face_selector', 'face_selector_race'), choices = facefusion.choices.face_selector_races)
|
||||
group_face_selector.add_argument('--reference-face-position', help = wording.get('help.reference_face_position'), type = int, default = config.get_int_value('face_selector', 'reference_face_position', '0'))
|
||||
group_face_selector.add_argument('--reference-face-distance', help = wording.get('help.reference_face_distance'), type = float, default = config.get_float_value('face_selector', 'reference_face_distance', '0.3'), choices = facefusion.choices.reference_face_distance_range, metavar = create_float_metavar(facefusion.choices.reference_face_distance_range))
|
||||
group_face_selector.add_argument('--reference-frame-number', help = wording.get('help.reference_frame_number'), type = int, default = config.get_int_value('face_selector', 'reference_frame_number', '0'))
|
||||
group_face_selector.add_argument('--face-selector-mode', help = translator.get('help.face_selector_mode'), default = config.get_str_value('face_selector', 'face_selector_mode', 'reference'), choices = facefusion.choices.face_selector_modes)
|
||||
group_face_selector.add_argument('--face-selector-order', help = translator.get('help.face_selector_order'), default = config.get_str_value('face_selector', 'face_selector_order', 'large-small'), choices = facefusion.choices.face_selector_orders)
|
||||
group_face_selector.add_argument('--face-selector-age-start', help = translator.get('help.face_selector_age_start'), type = int, default = config.get_int_value('face_selector', 'face_selector_age_start'), choices = facefusion.choices.face_selector_age_range, metavar = create_int_metavar(facefusion.choices.face_selector_age_range))
|
||||
group_face_selector.add_argument('--face-selector-age-end', help = translator.get('help.face_selector_age_end'), type = int, default = config.get_int_value('face_selector', 'face_selector_age_end'), choices = facefusion.choices.face_selector_age_range, metavar = create_int_metavar(facefusion.choices.face_selector_age_range))
|
||||
group_face_selector.add_argument('--face-selector-gender', help = translator.get('help.face_selector_gender'), default = config.get_str_value('face_selector', 'face_selector_gender'), choices = facefusion.choices.face_selector_genders)
|
||||
group_face_selector.add_argument('--face-selector-race', help = translator.get('help.face_selector_race'), default = config.get_str_value('face_selector', 'face_selector_race'), choices = facefusion.choices.face_selector_races)
|
||||
group_face_selector.add_argument('--reference-face-position', help = translator.get('help.reference_face_position'), type = int, default = config.get_int_value('face_selector', 'reference_face_position', '0'))
|
||||
group_face_selector.add_argument('--reference-face-distance', help = translator.get('help.reference_face_distance'), type = float, default = config.get_float_value('face_selector', 'reference_face_distance', '0.3'), choices = facefusion.choices.reference_face_distance_range, metavar = create_float_metavar(facefusion.choices.reference_face_distance_range))
|
||||
group_face_selector.add_argument('--reference-frame-number', help = translator.get('help.reference_frame_number'), type = int, default = config.get_int_value('face_selector', 'reference_frame_number', '0'))
|
||||
job_store.register_step_keys([ 'face_selector_mode', 'face_selector_order', 'face_selector_gender', 'face_selector_race', 'face_selector_age_start', 'face_selector_age_end', 'reference_face_position', 'reference_face_distance', 'reference_frame_number' ])
|
||||
return program
|
||||
|
||||
@@ -133,24 +136,32 @@ def create_face_selector_program() -> ArgumentParser:
|
||||
def create_face_masker_program() -> ArgumentParser:
|
||||
program = ArgumentParser(add_help = False)
|
||||
group_face_masker = program.add_argument_group('face masker')
|
||||
group_face_masker.add_argument('--face-occluder-model', help = wording.get('help.face_occluder_model'), default = config.get_str_value('face_masker', 'face_occluder_model', 'xseg_1'), choices = facefusion.choices.face_occluder_models)
|
||||
group_face_masker.add_argument('--face-parser-model', help = wording.get('help.face_parser_model'), default = config.get_str_value('face_masker', 'face_parser_model', 'bisenet_resnet_34'), choices = facefusion.choices.face_parser_models)
|
||||
group_face_masker.add_argument('--face-mask-types', help = wording.get('help.face_mask_types').format(choices = ', '.join(facefusion.choices.face_mask_types)), default = config.get_str_list('face_masker', 'face_mask_types', 'box'), choices = facefusion.choices.face_mask_types, nargs = '+', metavar = 'FACE_MASK_TYPES')
|
||||
group_face_masker.add_argument('--face-mask-areas', help = wording.get('help.face_mask_areas').format(choices = ', '.join(facefusion.choices.face_mask_areas)), default = config.get_str_list('face_masker', 'face_mask_areas', ' '.join(facefusion.choices.face_mask_areas)), choices = facefusion.choices.face_mask_areas, nargs = '+', metavar = 'FACE_MASK_AREAS')
|
||||
group_face_masker.add_argument('--face-mask-regions', help = wording.get('help.face_mask_regions').format(choices = ', '.join(facefusion.choices.face_mask_regions)), default = config.get_str_list('face_masker', 'face_mask_regions', ' '.join(facefusion.choices.face_mask_regions)), choices = facefusion.choices.face_mask_regions, nargs = '+', metavar = 'FACE_MASK_REGIONS')
|
||||
group_face_masker.add_argument('--face-mask-blur', help = wording.get('help.face_mask_blur'), type = float, default = config.get_float_value('face_masker', 'face_mask_blur', '0.3'), choices = facefusion.choices.face_mask_blur_range, metavar = create_float_metavar(facefusion.choices.face_mask_blur_range))
|
||||
group_face_masker.add_argument('--face-mask-padding', help = wording.get('help.face_mask_padding'), type = int, default = config.get_int_list('face_masker', 'face_mask_padding', '0 0 0 0'), nargs = '+')
|
||||
group_face_masker.add_argument('--face-occluder-model', help = translator.get('help.face_occluder_model'), default = config.get_str_value('face_masker', 'face_occluder_model', 'xseg_1'), choices = facefusion.choices.face_occluder_models)
|
||||
group_face_masker.add_argument('--face-parser-model', help = translator.get('help.face_parser_model'), default = config.get_str_value('face_masker', 'face_parser_model', 'bisenet_resnet_34'), choices = facefusion.choices.face_parser_models)
|
||||
group_face_masker.add_argument('--face-mask-types', help = translator.get('help.face_mask_types').format(choices = ', '.join(facefusion.choices.face_mask_types)), default = config.get_str_list('face_masker', 'face_mask_types', 'box'), choices = facefusion.choices.face_mask_types, nargs = '+', metavar = 'FACE_MASK_TYPES')
|
||||
group_face_masker.add_argument('--face-mask-areas', help = translator.get('help.face_mask_areas').format(choices = ', '.join(facefusion.choices.face_mask_areas)), default = config.get_str_list('face_masker', 'face_mask_areas', ' '.join(facefusion.choices.face_mask_areas)), choices = facefusion.choices.face_mask_areas, nargs = '+', metavar = 'FACE_MASK_AREAS')
|
||||
group_face_masker.add_argument('--face-mask-regions', help = translator.get('help.face_mask_regions').format(choices = ', '.join(facefusion.choices.face_mask_regions)), default = config.get_str_list('face_masker', 'face_mask_regions', ' '.join(facefusion.choices.face_mask_regions)), choices = facefusion.choices.face_mask_regions, nargs = '+', metavar = 'FACE_MASK_REGIONS')
|
||||
group_face_masker.add_argument('--face-mask-blur', help = translator.get('help.face_mask_blur'), type = float, default = config.get_float_value('face_masker', 'face_mask_blur', '0.3'), choices = facefusion.choices.face_mask_blur_range, metavar = create_float_metavar(facefusion.choices.face_mask_blur_range))
|
||||
group_face_masker.add_argument('--face-mask-padding', help = translator.get('help.face_mask_padding'), type = partial(sanitize_int_range, int_range = facefusion.choices.face_mask_padding_range), default = config.get_int_list('face_masker', 'face_mask_padding', '0 0 0 0'), nargs = '+')
|
||||
job_store.register_step_keys([ 'face_occluder_model', 'face_parser_model', 'face_mask_types', 'face_mask_areas', 'face_mask_regions', 'face_mask_blur', 'face_mask_padding' ])
|
||||
return program
|
||||
|
||||
|
||||
def create_voice_extractor_program() -> ArgumentParser:
|
||||
program = ArgumentParser(add_help = False)
|
||||
group_voice_extractor = program.add_argument_group('voice extractor')
|
||||
group_voice_extractor.add_argument('--voice-extractor-model', help = translator.get('help.voice_extractor_model'), default = config.get_str_value('voice_extractor', 'voice_extractor_model', 'kim_vocal_2'), choices = facefusion.choices.voice_extractor_models)
|
||||
job_store.register_step_keys([ 'voice_extractor_model' ])
|
||||
return program
|
||||
|
||||
|
||||
def create_frame_extraction_program() -> ArgumentParser:
|
||||
program = ArgumentParser(add_help = False)
|
||||
group_frame_extraction = program.add_argument_group('frame extraction')
|
||||
group_frame_extraction.add_argument('--trim-frame-start', help = wording.get('help.trim_frame_start'), type = int, default = facefusion.config.get_int_value('frame_extraction', 'trim_frame_start'))
|
||||
group_frame_extraction.add_argument('--trim-frame-end', help = wording.get('help.trim_frame_end'), type = int, default = facefusion.config.get_int_value('frame_extraction', 'trim_frame_end'))
|
||||
group_frame_extraction.add_argument('--temp-frame-format', help = wording.get('help.temp_frame_format'), default = config.get_str_value('frame_extraction', 'temp_frame_format', 'png'), choices = facefusion.choices.temp_frame_formats)
|
||||
group_frame_extraction.add_argument('--keep-temp', help = wording.get('help.keep_temp'), action = 'store_true', default = config.get_bool_value('frame_extraction', 'keep_temp'))
|
||||
group_frame_extraction.add_argument('--trim-frame-start', help = translator.get('help.trim_frame_start'), type = int, default = facefusion.config.get_int_value('frame_extraction', 'trim_frame_start'))
|
||||
group_frame_extraction.add_argument('--trim-frame-end', help = translator.get('help.trim_frame_end'), type = int, default = facefusion.config.get_int_value('frame_extraction', 'trim_frame_end'))
|
||||
group_frame_extraction.add_argument('--temp-frame-format', help = translator.get('help.temp_frame_format'), default = config.get_str_value('frame_extraction', 'temp_frame_format', 'png'), choices = facefusion.choices.temp_frame_formats)
|
||||
group_frame_extraction.add_argument('--keep-temp', help = translator.get('help.keep_temp'), action = 'store_true', default = config.get_bool_value('frame_extraction', 'keep_temp'))
|
||||
job_store.register_step_keys([ 'trim_frame_start', 'trim_frame_end', 'temp_frame_format', 'keep_temp' ])
|
||||
return program
|
||||
|
||||
@@ -159,17 +170,17 @@ def create_output_creation_program() -> ArgumentParser:
|
||||
program = ArgumentParser(add_help = False)
|
||||
available_encoder_set = get_available_encoder_set()
|
||||
group_output_creation = program.add_argument_group('output creation')
|
||||
group_output_creation.add_argument('--output-image-quality', help = wording.get('help.output_image_quality'), type = int, default = config.get_int_value('output_creation', 'output_image_quality', '80'), choices = facefusion.choices.output_image_quality_range, metavar = create_int_metavar(facefusion.choices.output_image_quality_range))
|
||||
group_output_creation.add_argument('--output-image-resolution', help = wording.get('help.output_image_resolution'), default = config.get_str_value('output_creation', 'output_image_resolution'))
|
||||
group_output_creation.add_argument('--output-audio-encoder', help = wording.get('help.output_audio_encoder'), default = config.get_str_value('output_creation', 'output_audio_encoder', get_first(available_encoder_set.get('audio'))), choices = available_encoder_set.get('audio'))
|
||||
group_output_creation.add_argument('--output-audio-quality', help = wording.get('help.output_audio_quality'), type = int, default = config.get_int_value('output_creation', 'output_audio_quality', '80'), choices = facefusion.choices.output_audio_quality_range, metavar = create_int_metavar(facefusion.choices.output_audio_quality_range))
|
||||
group_output_creation.add_argument('--output-audio-volume', help = wording.get('help.output_audio_volume'), type = int, default = config.get_int_value('output_creation', 'output_audio_volume', '100'), choices = facefusion.choices.output_audio_volume_range, metavar = create_int_metavar(facefusion.choices.output_audio_volume_range))
|
||||
group_output_creation.add_argument('--output-video-encoder', help = wording.get('help.output_video_encoder'), default = config.get_str_value('output_creation', 'output_video_encoder', get_first(available_encoder_set.get('video'))), choices = available_encoder_set.get('video'))
|
||||
group_output_creation.add_argument('--output-video-preset', help = wording.get('help.output_video_preset'), default = config.get_str_value('output_creation', 'output_video_preset', 'veryfast'), choices = facefusion.choices.output_video_presets)
|
||||
group_output_creation.add_argument('--output-video-quality', help = wording.get('help.output_video_quality'), type = int, default = config.get_int_value('output_creation', 'output_video_quality', '80'), choices = facefusion.choices.output_video_quality_range, metavar = create_int_metavar(facefusion.choices.output_video_quality_range))
|
||||
group_output_creation.add_argument('--output-video-resolution', help = wording.get('help.output_video_resolution'), default = config.get_str_value('output_creation', 'output_video_resolution'))
|
||||
group_output_creation.add_argument('--output-video-fps', help = wording.get('help.output_video_fps'), type = float, default = config.get_str_value('output_creation', 'output_video_fps'))
|
||||
job_store.register_step_keys([ 'output_image_quality', 'output_image_resolution', 'output_audio_encoder', 'output_audio_quality', 'output_audio_volume', 'output_video_encoder', 'output_video_preset', 'output_video_quality', 'output_video_resolution', 'output_video_fps' ])
|
||||
group_output_creation.add_argument('--output-image-quality', help = translator.get('help.output_image_quality'), type = int, default = config.get_int_value('output_creation', 'output_image_quality', '80'), choices = facefusion.choices.output_image_quality_range, metavar = create_int_metavar(facefusion.choices.output_image_quality_range))
|
||||
group_output_creation.add_argument('--output-image-scale', help = translator.get('help.output_image_scale'), type = float, default = config.get_float_value('output_creation', 'output_image_scale', '1.0'), choices = facefusion.choices.output_image_scale_range)
|
||||
group_output_creation.add_argument('--output-audio-encoder', help = translator.get('help.output_audio_encoder'), default = config.get_str_value('output_creation', 'output_audio_encoder', get_first(available_encoder_set.get('audio'))), choices = available_encoder_set.get('audio'))
|
||||
group_output_creation.add_argument('--output-audio-quality', help = translator.get('help.output_audio_quality'), type = int, default = config.get_int_value('output_creation', 'output_audio_quality', '80'), choices = facefusion.choices.output_audio_quality_range, metavar = create_int_metavar(facefusion.choices.output_audio_quality_range))
|
||||
group_output_creation.add_argument('--output-audio-volume', help = translator.get('help.output_audio_volume'), type = int, default = config.get_int_value('output_creation', 'output_audio_volume', '100'), choices = facefusion.choices.output_audio_volume_range, metavar = create_int_metavar(facefusion.choices.output_audio_volume_range))
|
||||
group_output_creation.add_argument('--output-video-encoder', help = translator.get('help.output_video_encoder'), default = config.get_str_value('output_creation', 'output_video_encoder', get_first(available_encoder_set.get('video'))), choices = available_encoder_set.get('video'))
|
||||
group_output_creation.add_argument('--output-video-preset', help = translator.get('help.output_video_preset'), default = config.get_str_value('output_creation', 'output_video_preset', 'veryfast'), choices = facefusion.choices.output_video_presets)
|
||||
group_output_creation.add_argument('--output-video-quality', help = translator.get('help.output_video_quality'), type = int, default = config.get_int_value('output_creation', 'output_video_quality', '80'), choices = facefusion.choices.output_video_quality_range, metavar = create_int_metavar(facefusion.choices.output_video_quality_range))
|
||||
group_output_creation.add_argument('--output-video-scale', help = translator.get('help.output_video_scale'), type = float, default = config.get_float_value('output_creation', 'output_video_scale', '1.0'), choices = facefusion.choices.output_video_scale_range)
|
||||
group_output_creation.add_argument('--output-video-fps', help = translator.get('help.output_video_fps'), type = float, default = config.get_float_value('output_creation', 'output_video_fps'))
|
||||
job_store.register_step_keys([ 'output_image_quality', 'output_image_scale', 'output_audio_encoder', 'output_audio_quality', 'output_audio_volume', 'output_video_encoder', 'output_video_preset', 'output_video_quality', 'output_video_scale', 'output_video_fps' ])
|
||||
return program
|
||||
|
||||
|
||||
@@ -177,7 +188,7 @@ def create_processors_program() -> ArgumentParser:
|
||||
program = ArgumentParser(add_help = False)
|
||||
available_processors = [ get_file_name(file_path) for file_path in resolve_file_paths('facefusion/processors/modules') ]
|
||||
group_processors = program.add_argument_group('processors')
|
||||
group_processors.add_argument('--processors', help = wording.get('help.processors').format(choices = ', '.join(available_processors)), default = config.get_str_list('processors', 'processors', 'face_swapper'), nargs = '+')
|
||||
group_processors.add_argument('--processors', help = translator.get('help.processors').format(choices = ', '.join(available_processors)), default = config.get_str_list('processors', 'processors', 'face_swapper'), nargs = '+')
|
||||
job_store.register_step_keys([ 'processors' ])
|
||||
for processor_module in get_processors_modules(available_processors):
|
||||
processor_module.register_args(program)
|
||||
@@ -188,16 +199,16 @@ def create_uis_program() -> ArgumentParser:
|
||||
program = ArgumentParser(add_help = False)
|
||||
available_ui_layouts = [ get_file_name(file_path) for file_path in resolve_file_paths('facefusion/uis/layouts') ]
|
||||
group_uis = program.add_argument_group('uis')
|
||||
group_uis.add_argument('--open-browser', help = wording.get('help.open_browser'), action = 'store_true', default = config.get_bool_value('uis', 'open_browser'))
|
||||
group_uis.add_argument('--ui-layouts', help = wording.get('help.ui_layouts').format(choices = ', '.join(available_ui_layouts)), default = config.get_str_list('uis', 'ui_layouts', 'default'), nargs = '+')
|
||||
group_uis.add_argument('--ui-workflow', help = wording.get('help.ui_workflow'), default = config.get_str_value('uis', 'ui_workflow', 'instant_runner'), choices = facefusion.choices.ui_workflows)
|
||||
group_uis.add_argument('--open-browser', help = translator.get('help.open_browser'), action = 'store_true', default = config.get_bool_value('uis', 'open_browser'))
|
||||
group_uis.add_argument('--ui-layouts', help = translator.get('help.ui_layouts').format(choices = ', '.join(available_ui_layouts)), default = config.get_str_list('uis', 'ui_layouts', 'default'), nargs = '+')
|
||||
group_uis.add_argument('--ui-workflow', help = translator.get('help.ui_workflow'), default = config.get_str_value('uis', 'ui_workflow', 'instant_runner'), choices = facefusion.choices.ui_workflows)
|
||||
return program
|
||||
|
||||
|
||||
def create_download_providers_program() -> ArgumentParser:
|
||||
program = ArgumentParser(add_help = False)
|
||||
group_download = program.add_argument_group('download')
|
||||
group_download.add_argument('--download-providers', help = wording.get('help.download_providers').format(choices = ', '.join(facefusion.choices.download_providers)), default = config.get_str_list('download', 'download_providers', ' '.join(facefusion.choices.download_providers)), choices = facefusion.choices.download_providers, nargs = '+', metavar = 'DOWNLOAD_PROVIDERS')
|
||||
group_download.add_argument('--download-providers', help = translator.get('help.download_providers').format(choices = ', '.join(facefusion.choices.download_providers)), default = config.get_str_list('download', 'download_providers', ' '.join(facefusion.choices.download_providers)), choices = facefusion.choices.download_providers, nargs = '+', metavar = 'DOWNLOAD_PROVIDERS')
|
||||
job_store.register_job_keys([ 'download_providers' ])
|
||||
return program
|
||||
|
||||
@@ -205,7 +216,7 @@ def create_download_providers_program() -> ArgumentParser:
|
||||
def create_download_scope_program() -> ArgumentParser:
|
||||
program = ArgumentParser(add_help = False)
|
||||
group_download = program.add_argument_group('download')
|
||||
group_download.add_argument('--download-scope', help = wording.get('help.download_scope'), default = config.get_str_value('download', 'download_scope', 'lite'), choices = facefusion.choices.download_scopes)
|
||||
group_download.add_argument('--download-scope', help = translator.get('help.download_scope'), default = config.get_str_value('download', 'download_scope', 'lite'), choices = facefusion.choices.download_scopes)
|
||||
job_store.register_job_keys([ 'download_scope' ])
|
||||
return program
|
||||
|
||||
@@ -213,8 +224,9 @@ def create_download_scope_program() -> ArgumentParser:
|
||||
def create_benchmark_program() -> ArgumentParser:
|
||||
program = ArgumentParser(add_help = False)
|
||||
group_benchmark = program.add_argument_group('benchmark')
|
||||
group_benchmark.add_argument('--benchmark-resolutions', help = wording.get('help.benchmark_resolutions'), default = config.get_str_list('benchmark', 'benchmark_resolutions', get_first(facefusion.choices.benchmark_resolutions)), choices = facefusion.choices.benchmark_resolutions, nargs = '+')
|
||||
group_benchmark.add_argument('--benchmark-cycle-count', help = wording.get('help.benchmark_cycle_count'), type = int, default = config.get_int_value('benchmark', 'benchmark_cycle_count', '5'), choices = facefusion.choices.benchmark_cycle_count_range)
|
||||
group_benchmark.add_argument('--benchmark-mode', help = translator.get('help.benchmark_mode'), default = config.get_str_value('benchmark', 'benchmark_mode', 'warm'), choices = facefusion.choices.benchmark_modes)
|
||||
group_benchmark.add_argument('--benchmark-resolutions', help = translator.get('help.benchmark_resolutions'), default = config.get_str_list('benchmark', 'benchmark_resolutions', get_first(facefusion.choices.benchmark_resolutions)), choices = facefusion.choices.benchmark_resolutions, nargs = '+')
|
||||
group_benchmark.add_argument('--benchmark-cycle-count', help = translator.get('help.benchmark_cycle_count'), type = int, default = config.get_int_value('benchmark', 'benchmark_cycle_count', '5'), choices = facefusion.choices.benchmark_cycle_count_range)
|
||||
return program
|
||||
|
||||
|
||||
@@ -222,19 +234,18 @@ def create_execution_program() -> ArgumentParser:
|
||||
program = ArgumentParser(add_help = False)
|
||||
available_execution_providers = get_available_execution_providers()
|
||||
group_execution = program.add_argument_group('execution')
|
||||
group_execution.add_argument('--execution-device-id', help = wording.get('help.execution_device_id'), default = config.get_str_value('execution', 'execution_device_id', '0'))
|
||||
group_execution.add_argument('--execution-providers', help = wording.get('help.execution_providers').format(choices = ', '.join(available_execution_providers)), default = config.get_str_list('execution', 'execution_providers', get_first(available_execution_providers)), choices = available_execution_providers, nargs = '+', metavar = 'EXECUTION_PROVIDERS')
|
||||
group_execution.add_argument('--execution-thread-count', help = wording.get('help.execution_thread_count'), type = int, default = config.get_int_value('execution', 'execution_thread_count', '4'), choices = facefusion.choices.execution_thread_count_range, metavar = create_int_metavar(facefusion.choices.execution_thread_count_range))
|
||||
group_execution.add_argument('--execution-queue-count', help = wording.get('help.execution_queue_count'), type = int, default = config.get_int_value('execution', 'execution_queue_count', '1'), choices = facefusion.choices.execution_queue_count_range, metavar = create_int_metavar(facefusion.choices.execution_queue_count_range))
|
||||
job_store.register_job_keys([ 'execution_device_id', 'execution_providers', 'execution_thread_count', 'execution_queue_count' ])
|
||||
group_execution.add_argument('--execution-device-ids', help = translator.get('help.execution_device_ids'), type = int, default = config.get_int_list('execution', 'execution_device_ids', '0'), nargs = '+', metavar = 'EXECUTION_DEVICE_IDS')
|
||||
group_execution.add_argument('--execution-providers', help = translator.get('help.execution_providers').format(choices = ', '.join(available_execution_providers)), default = config.get_str_list('execution', 'execution_providers', get_first(available_execution_providers)), choices = available_execution_providers, nargs = '+', metavar = 'EXECUTION_PROVIDERS')
|
||||
group_execution.add_argument('--execution-thread-count', help = translator.get('help.execution_thread_count'), type = int, default = config.get_int_value('execution', 'execution_thread_count', '8'), choices = facefusion.choices.execution_thread_count_range, metavar = create_int_metavar(facefusion.choices.execution_thread_count_range))
|
||||
job_store.register_job_keys([ 'execution_device_ids', 'execution_providers', 'execution_thread_count' ])
|
||||
return program
|
||||
|
||||
|
||||
def create_memory_program() -> ArgumentParser:
|
||||
program = ArgumentParser(add_help = False)
|
||||
group_memory = program.add_argument_group('memory')
|
||||
group_memory.add_argument('--video-memory-strategy', help = wording.get('help.video_memory_strategy'), default = config.get_str_value('memory', 'video_memory_strategy', 'strict'), choices = facefusion.choices.video_memory_strategies)
|
||||
group_memory.add_argument('--system-memory-limit', help = wording.get('help.system_memory_limit'), type = int, default = config.get_int_value('memory', 'system_memory_limit', '0'), choices = facefusion.choices.system_memory_limit_range, metavar = create_int_metavar(facefusion.choices.system_memory_limit_range))
|
||||
group_memory.add_argument('--video-memory-strategy', help = translator.get('help.video_memory_strategy'), default = config.get_str_value('memory', 'video_memory_strategy', 'strict'), choices = facefusion.choices.video_memory_strategies)
|
||||
group_memory.add_argument('--system-memory-limit', help = translator.get('help.system_memory_limit'), type = int, default = config.get_int_value('memory', 'system_memory_limit', '0'), choices = facefusion.choices.system_memory_limit_range, metavar = create_int_metavar(facefusion.choices.system_memory_limit_range))
|
||||
job_store.register_job_keys([ 'video_memory_strategy', 'system_memory_limit' ])
|
||||
return program
|
||||
|
||||
@@ -242,7 +253,7 @@ def create_memory_program() -> ArgumentParser:
|
||||
def create_log_level_program() -> ArgumentParser:
|
||||
program = ArgumentParser(add_help = False)
|
||||
group_misc = program.add_argument_group('misc')
|
||||
group_misc.add_argument('--log-level', help = wording.get('help.log_level'), default = config.get_str_value('misc', 'log_level', 'info'), choices = facefusion.choices.log_levels)
|
||||
group_misc.add_argument('--log-level', help = translator.get('help.log_level'), default = config.get_str_value('misc', 'log_level', 'info'), choices = facefusion.choices.log_levels)
|
||||
job_store.register_job_keys([ 'log_level' ])
|
||||
return program
|
||||
|
||||
@@ -250,32 +261,31 @@ def create_log_level_program() -> ArgumentParser:
|
||||
def create_halt_on_error_program() -> ArgumentParser:
|
||||
program = ArgumentParser(add_help = False)
|
||||
group_misc = program.add_argument_group('misc')
|
||||
group_misc.add_argument('--halt-on-error', help = wording.get('help.halt_on_error'), action = 'store_true', default = config.get_bool_value('misc', 'halt_on_error'))
|
||||
group_misc.add_argument('--halt-on-error', help = translator.get('help.halt_on_error'), action = 'store_true', default = config.get_bool_value('misc', 'halt_on_error'))
|
||||
job_store.register_job_keys([ 'halt_on_error' ])
|
||||
return program
|
||||
|
||||
|
||||
def create_job_id_program() -> ArgumentParser:
|
||||
program = ArgumentParser(add_help = False)
|
||||
program.add_argument('job_id', help = wording.get('help.job_id'))
|
||||
job_store.register_job_keys([ 'job_id' ])
|
||||
program.add_argument('job_id', help = translator.get('help.job_id'))
|
||||
return program
|
||||
|
||||
|
||||
def create_job_status_program() -> ArgumentParser:
|
||||
program = ArgumentParser(add_help = False)
|
||||
program.add_argument('job_status', help = wording.get('help.job_status'), choices = facefusion.choices.job_statuses)
|
||||
program.add_argument('job_status', help = translator.get('help.job_status'), choices = facefusion.choices.job_statuses)
|
||||
return program
|
||||
|
||||
|
||||
def create_step_index_program() -> ArgumentParser:
|
||||
program = ArgumentParser(add_help = False)
|
||||
program.add_argument('step_index', help = wording.get('help.step_index'), type = int)
|
||||
program.add_argument('step_index', help = translator.get('help.step_index'), type = int)
|
||||
return program
|
||||
|
||||
|
||||
def collect_step_program() -> ArgumentParser:
|
||||
return ArgumentParser(parents = [ create_face_detector_program(), create_face_landmarker_program(), create_face_selector_program(), create_face_masker_program(), create_frame_extraction_program(), create_output_creation_program(), create_processors_program() ], add_help = False)
|
||||
return ArgumentParser(parents = [ create_face_detector_program(), create_face_landmarker_program(), create_face_selector_program(), create_face_masker_program(), create_voice_extractor_program(), create_frame_extraction_program(), create_output_creation_program(), create_processors_program() ], add_help = False)
|
||||
|
||||
|
||||
def collect_job_program() -> ArgumentParser:
|
||||
@@ -288,27 +298,27 @@ def create_program() -> ArgumentParser:
|
||||
program.add_argument('-v', '--version', version = metadata.get('name') + ' ' + metadata.get('version'), action = 'version')
|
||||
sub_program = program.add_subparsers(dest = 'command')
|
||||
# general
|
||||
sub_program.add_parser('run', help = wording.get('help.run'), parents = [ create_config_path_program(), create_temp_path_program(), create_jobs_path_program(), create_source_paths_program(), create_target_path_program(), create_output_path_program(), collect_step_program(), create_uis_program(), collect_job_program() ], formatter_class = create_help_formatter_large)
|
||||
sub_program.add_parser('headless-run', help = wording.get('help.headless_run'), parents = [ create_config_path_program(), create_temp_path_program(), create_jobs_path_program(), create_source_paths_program(), create_target_path_program(), create_output_path_program(), collect_step_program(), collect_job_program() ], formatter_class = create_help_formatter_large)
|
||||
sub_program.add_parser('batch-run', help = wording.get('help.batch_run'), parents = [ create_config_path_program(), create_temp_path_program(), create_jobs_path_program(), create_source_pattern_program(), create_target_pattern_program(), create_output_pattern_program(), collect_step_program(), collect_job_program() ], formatter_class = create_help_formatter_large)
|
||||
sub_program.add_parser('force-download', help = wording.get('help.force_download'), parents = [ create_download_providers_program(), create_download_scope_program(), create_log_level_program() ], formatter_class = create_help_formatter_large)
|
||||
sub_program.add_parser('benchmark', help = wording.get('help.benchmark'), parents = [ create_temp_path_program(), collect_step_program(), create_benchmark_program(), collect_job_program() ], formatter_class = create_help_formatter_large)
|
||||
sub_program.add_parser('run', help = translator.get('help.run'), parents = [ create_config_path_program(), create_temp_path_program(), create_jobs_path_program(), create_source_paths_program(), create_target_path_program(), create_output_path_program(), collect_step_program(), create_uis_program(), create_benchmark_program(), collect_job_program() ], formatter_class = create_help_formatter_large)
|
||||
sub_program.add_parser('headless-run', help = translator.get('help.headless_run'), parents = [ create_config_path_program(), create_temp_path_program(), create_jobs_path_program(), create_source_paths_program(), create_target_path_program(), create_output_path_program(), collect_step_program(), collect_job_program() ], formatter_class = create_help_formatter_large)
|
||||
sub_program.add_parser('batch-run', help = translator.get('help.batch_run'), parents = [ create_config_path_program(), create_temp_path_program(), create_jobs_path_program(), create_source_pattern_program(), create_target_pattern_program(), create_output_pattern_program(), collect_step_program(), collect_job_program() ], formatter_class = create_help_formatter_large)
|
||||
sub_program.add_parser('force-download', help = translator.get('help.force_download'), parents = [ create_download_providers_program(), create_download_scope_program(), create_log_level_program() ], formatter_class = create_help_formatter_large)
|
||||
sub_program.add_parser('benchmark', help = translator.get('help.benchmark'), parents = [ create_temp_path_program(), collect_step_program(), create_benchmark_program(), collect_job_program() ], formatter_class = create_help_formatter_large)
|
||||
# job manager
|
||||
sub_program.add_parser('job-list', help = wording.get('help.job_list'), parents = [ create_job_status_program(), create_jobs_path_program(), create_log_level_program() ], formatter_class = create_help_formatter_large)
|
||||
sub_program.add_parser('job-create', help = wording.get('help.job_create'), parents = [ create_job_id_program(), create_jobs_path_program(), create_log_level_program() ], formatter_class = create_help_formatter_large)
|
||||
sub_program.add_parser('job-submit', help = wording.get('help.job_submit'), parents = [ create_job_id_program(), create_jobs_path_program(), create_log_level_program() ], formatter_class = create_help_formatter_large)
|
||||
sub_program.add_parser('job-submit-all', help = wording.get('help.job_submit_all'), parents = [ create_jobs_path_program(), create_log_level_program(), create_halt_on_error_program() ], formatter_class = create_help_formatter_large)
|
||||
sub_program.add_parser('job-delete', help = wording.get('help.job_delete'), parents = [ create_job_id_program(), create_jobs_path_program(), create_log_level_program() ], formatter_class = create_help_formatter_large)
|
||||
sub_program.add_parser('job-delete-all', help = wording.get('help.job_delete_all'), parents = [ create_jobs_path_program(), create_log_level_program(), create_halt_on_error_program() ], formatter_class = create_help_formatter_large)
|
||||
sub_program.add_parser('job-add-step', help = wording.get('help.job_add_step'), parents = [ create_job_id_program(), create_config_path_program(), create_jobs_path_program(), create_source_paths_program(), create_target_path_program(), create_output_path_program(), collect_step_program(), create_log_level_program() ], formatter_class = create_help_formatter_large)
|
||||
sub_program.add_parser('job-remix-step', help = wording.get('help.job_remix_step'), parents = [ create_job_id_program(), create_step_index_program(), create_config_path_program(), create_jobs_path_program(), create_source_paths_program(), create_output_path_program(), collect_step_program(), create_log_level_program() ], formatter_class = create_help_formatter_large)
|
||||
sub_program.add_parser('job-insert-step', help = wording.get('help.job_insert_step'), parents = [ create_job_id_program(), create_step_index_program(), create_config_path_program(), create_jobs_path_program(), create_source_paths_program(), create_target_path_program(), create_output_path_program(), collect_step_program(), create_log_level_program() ], formatter_class = create_help_formatter_large)
|
||||
sub_program.add_parser('job-remove-step', help = wording.get('help.job_remove_step'), parents = [ create_job_id_program(), create_step_index_program(), create_jobs_path_program(), create_log_level_program() ], formatter_class = create_help_formatter_large)
|
||||
sub_program.add_parser('job-list', help = translator.get('help.job_list'), parents = [ create_job_status_program(), create_jobs_path_program(), create_log_level_program() ], formatter_class = create_help_formatter_large)
|
||||
sub_program.add_parser('job-create', help = translator.get('help.job_create'), parents = [ create_job_id_program(), create_jobs_path_program(), create_log_level_program() ], formatter_class = create_help_formatter_large)
|
||||
sub_program.add_parser('job-submit', help = translator.get('help.job_submit'), parents = [ create_job_id_program(), create_jobs_path_program(), create_log_level_program() ], formatter_class = create_help_formatter_large)
|
||||
sub_program.add_parser('job-submit-all', help = translator.get('help.job_submit_all'), parents = [ create_jobs_path_program(), create_log_level_program(), create_halt_on_error_program() ], formatter_class = create_help_formatter_large)
|
||||
sub_program.add_parser('job-delete', help = translator.get('help.job_delete'), parents = [ create_job_id_program(), create_jobs_path_program(), create_log_level_program() ], formatter_class = create_help_formatter_large)
|
||||
sub_program.add_parser('job-delete-all', help = translator.get('help.job_delete_all'), parents = [ create_jobs_path_program(), create_log_level_program(), create_halt_on_error_program() ], formatter_class = create_help_formatter_large)
|
||||
sub_program.add_parser('job-add-step', help = translator.get('help.job_add_step'), parents = [ create_job_id_program(), create_config_path_program(), create_jobs_path_program(), create_source_paths_program(), create_target_path_program(), create_output_path_program(), collect_step_program(), create_log_level_program() ], formatter_class = create_help_formatter_large)
|
||||
sub_program.add_parser('job-remix-step', help = translator.get('help.job_remix_step'), parents = [ create_job_id_program(), create_step_index_program(), create_config_path_program(), create_jobs_path_program(), create_source_paths_program(), create_output_path_program(), collect_step_program(), create_log_level_program() ], formatter_class = create_help_formatter_large)
|
||||
sub_program.add_parser('job-insert-step', help = translator.get('help.job_insert_step'), parents = [ create_job_id_program(), create_step_index_program(), create_config_path_program(), create_jobs_path_program(), create_source_paths_program(), create_target_path_program(), create_output_path_program(), collect_step_program(), create_log_level_program() ], formatter_class = create_help_formatter_large)
|
||||
sub_program.add_parser('job-remove-step', help = translator.get('help.job_remove_step'), parents = [ create_job_id_program(), create_step_index_program(), create_jobs_path_program(), create_log_level_program() ], formatter_class = create_help_formatter_large)
|
||||
# job runner
|
||||
sub_program.add_parser('job-run', help = wording.get('help.job_run'), parents = [ create_job_id_program(), create_config_path_program(), create_temp_path_program(), create_jobs_path_program(), collect_job_program() ], formatter_class = create_help_formatter_large)
|
||||
sub_program.add_parser('job-run-all', help = wording.get('help.job_run_all'), parents = [ create_config_path_program(), create_temp_path_program(), create_jobs_path_program(), collect_job_program(), create_halt_on_error_program() ], formatter_class = create_help_formatter_large)
|
||||
sub_program.add_parser('job-retry', help = wording.get('help.job_retry'), parents = [ create_job_id_program(), create_config_path_program(), create_temp_path_program(), create_jobs_path_program(), collect_job_program() ], formatter_class = create_help_formatter_large)
|
||||
sub_program.add_parser('job-retry-all', help = wording.get('help.job_retry_all'), parents = [ create_config_path_program(), create_temp_path_program(), create_jobs_path_program(), collect_job_program(), create_halt_on_error_program() ], formatter_class = create_help_formatter_large)
|
||||
sub_program.add_parser('job-run', help = translator.get('help.job_run'), parents = [ create_job_id_program(), create_config_path_program(), create_temp_path_program(), create_jobs_path_program(), collect_job_program() ], formatter_class = create_help_formatter_large)
|
||||
sub_program.add_parser('job-run-all', help = translator.get('help.job_run_all'), parents = [ create_config_path_program(), create_temp_path_program(), create_jobs_path_program(), collect_job_program(), create_halt_on_error_program() ], formatter_class = create_help_formatter_large)
|
||||
sub_program.add_parser('job-retry', help = translator.get('help.job_retry'), parents = [ create_job_id_program(), create_config_path_program(), create_temp_path_program(), create_jobs_path_program(), collect_job_program() ], formatter_class = create_help_formatter_large)
|
||||
sub_program.add_parser('job-retry-all', help = translator.get('help.job_retry_all'), parents = [ create_config_path_program(), create_temp_path_program(), create_jobs_path_program(), collect_job_program(), create_halt_on_error_program() ], formatter_class = create_help_formatter_large)
|
||||
return ArgumentParser(parents = [ program ], formatter_class = create_help_formatter_small)
|
||||
|
||||
|
||||
|
||||
Some files were not shown because too many files have changed in this diff Show More
Reference in New Issue
Block a user