diff --git a/mainscripts/Merger.py b/mainscripts/Merger.py index fba37f1..4da9734 100644 --- a/mainscripts/Merger.py +++ b/mainscripts/Merger.py @@ -14,7 +14,7 @@ from core.joblib import MPClassFuncOnDemand, MPFunc from core.leras import nn from DFLIMG import DFLIMG from facelib import FaceEnhancer, FaceType, LandmarksProcessor, XSegNet -from merger import FrameInfo, InteractiveMergerSubprocessor, MergerConfig +from merger import FrameInfo, InteractiveMergerSubprocessor, MergerConfig, MergerConfigMaskedMorph def main (model_class_name=None, @@ -78,7 +78,7 @@ def main (model_class_name=None, input_path_image_paths = pathex.get_image_paths(input_path) - if cfg.type == MergerConfig.TYPE_MASKED: + if cfg.type == MergerConfig.TYPE_MASKED or cfg.type == MergerConfig.TYPE_MASKED_MORPH: if not aligned_path.exists(): io.log_err('Aligned directory not found. Please ensure it exists.') return diff --git a/merger/InteractiveMergerSubprocessor.py b/merger/InteractiveMergerSubprocessor.py index 58db0c1..371eb59 100644 --- a/merger/InteractiveMergerSubprocessor.py +++ b/merger/InteractiveMergerSubprocessor.py @@ -11,7 +11,7 @@ from core import imagelib, pathex from core.cv2ex import * from core.interact import interact as io from core.joblib import Subprocessor -from merger import MergeFaceAvatar, MergeMasked, MergerConfig +from merger import MergeFaceAvatar, MergeMasked, MergeMaskedMorph, MergerConfig from .MergerScreen import Screen, ScreenManager @@ -105,6 +105,7 @@ class InteractiveMergerSubprocessor(Subprocessor): else: if cfg.type == MergerConfig.TYPE_MASKED: try: + final_img = MergeMasked (self.predictor_func, self.predictor_input_shape, face_enhancer_func=self.face_enhancer_func, xseg_256_extract_func=self.xseg_256_extract_func, @@ -116,6 +117,21 @@ class InteractiveMergerSubprocessor(Subprocessor): raise Subprocessor.SilenceException else: raise Exception( f'Error while merging file [{filepath}]: {e_str}' ) + elif cfg.type == MergerConfig.TYPE_MASKED_MORPH: + try: + + final_img = MergeMaskedMorph (self.predictor_func, self.predictor_input_shape, + face_enhancer_func=self.face_enhancer_func, + xseg_256_extract_func=self.xseg_256_extract_func, + cfg=cfg, + frame_info=frame_info) + except Exception as e: + e_str = traceback.format_exc() + if 'MemoryError' in e_str: + raise Subprocessor.SilenceException + else: + raise Exception( f'Error while merging file [{filepath}]: {e_str}' ) + elif cfg.type == MergerConfig.TYPE_FACE_AVATAR: final_img = MergeFaceAvatar (self.predictor_func, self.predictor_input_shape, @@ -290,6 +306,7 @@ class InteractiveMergerSubprocessor(Subprocessor): help_images = { MergerConfig.TYPE_MASKED : cv2_imread ( str(Path(__file__).parent / 'gfx' / 'help_merger_masked.jpg') ), MergerConfig.TYPE_FACE_AVATAR : cv2_imread ( str(Path(__file__).parent / 'gfx' / 'help_merger_face_avatar.jpg') ), + MergerConfig.TYPE_MASKED_MORPH : cv2_imread ( str(Path(__file__).parent / 'gfx' / 'help_merger_masked.jpg') ), } self.main_screen = Screen(initial_scale_to_width=1368, image=None, waiting_icon=True) @@ -332,7 +349,17 @@ class InteractiveMergerSubprocessor(Subprocessor): 'c' : lambda cfg,shift_pressed: cfg.toggle_color_transfer_mode(), 'n' : lambda cfg,shift_pressed: cfg.toggle_sharpen_mode(), } + + #TODO remove side effects + + self.masked_morph_keys_funcs = self.masked_keys_funcs.copy() + self.masked_morph_keys_funcs.update({ + 'p' : lambda cfg,shift_pressed: cfg.add_morph_power(1 if not shift_pressed else 5), + ';' : lambda cfg,shift_pressed: cfg.add_morph_power(-1), + ':' : lambda cfg,shift_pressed: cfg.add_morph_power(-5)}) + self.masked_keys = list(self.masked_keys_funcs.keys()) + self.masked_morph_keys = list(self.masked_morph_keys_funcs.keys()) #overridable optional def on_clients_finalized(self): @@ -417,7 +444,7 @@ class InteractiveMergerSubprocessor(Subprocessor): self.is_interactive_quitting = True elif self.screen_manager.get_current() is self.main_screen: - if self.merger_config.type == MergerConfig.TYPE_MASKED and chr_key in self.masked_keys: + if (self.merger_config.type == MergerConfig.TYPE_MASKED and chr_key in self.masked_keys) or (self.merger_config.type == MergerConfig.TYPE_MASKED_MORPH and chr_key in self.masked_morph_keys): self.process_remain_frames = False if cur_frame is not None: @@ -426,6 +453,9 @@ class InteractiveMergerSubprocessor(Subprocessor): if cfg.type == MergerConfig.TYPE_MASKED: self.masked_keys_funcs[chr_key](cfg, shift_pressed) + + if cfg.type == MergerConfig.TYPE_MASKED_MORPH: + self.masked_morph_keys_funcs[chr_key](cfg, shift_pressed) if prev_cfg != cfg: io.log_info ( cfg.to_string(cur_frame.frame_info.filepath.name) ) diff --git a/merger/MergeMasked.py b/merger/MergeMasked.py index 7d2caa4..cdc3d42 100644 --- a/merger/MergeMasked.py +++ b/merger/MergeMasked.py @@ -351,3 +351,344 @@ def MergeMasked (predictor_func, final_img = np.concatenate ( [final_img, final_mask], -1) return (final_img*255).astype(np.uint8) + +def MergeMaskedMorph (predictor_func, + predictor_input_shape, + face_enhancer_func, + xseg_256_extract_func, + cfg, + frame_info): + img_bgr_uint8 = cv2_imread(frame_info.filepath) + img_bgr_uint8 = imagelib.normalize_channels (img_bgr_uint8, 3) + img_bgr = img_bgr_uint8.astype(np.float32) / 255.0 + + outs = [] + for face_num, img_landmarks in enumerate( frame_info.landmarks_list ): + out_img, out_img_merging_mask = MergeMaskedFaceMorph (predictor_func, predictor_input_shape, face_enhancer_func, xseg_256_extract_func, cfg, frame_info, img_bgr_uint8, img_bgr, img_landmarks) + outs += [ (out_img, out_img_merging_mask) ] + + #Combining multiple face outputs + final_img = None + final_mask = None + for img, merging_mask in outs: + h,w,c = img.shape + + if final_img is None: + final_img = img + final_mask = merging_mask + else: + final_img = final_img*(1-merging_mask) + img*merging_mask + final_mask = np.clip (final_mask + merging_mask, 0, 1 ) + + final_img = np.concatenate ( [final_img, final_mask], -1) + + return (final_img*255).astype(np.uint8) + + + +def MergeMaskedFaceMorph (predictor_func, predictor_input_shape, + face_enhancer_func, + xseg_256_extract_func, + cfg, frame_info, img_bgr_uint8, img_bgr, img_face_landmarks): + + img_size = img_bgr.shape[1], img_bgr.shape[0] + img_face_mask_a = LandmarksProcessor.get_image_hull_mask (img_bgr.shape, img_face_landmarks) + + input_size = predictor_input_shape[0] + mask_subres_size = input_size*4 + output_size = input_size + if cfg.super_resolution_power != 0: + output_size *= 4 + + face_mat = LandmarksProcessor.get_transform_mat (img_face_landmarks, output_size, face_type=cfg.face_type) + face_output_mat = LandmarksProcessor.get_transform_mat (img_face_landmarks, output_size, face_type=cfg.face_type, scale= 1.0 + 0.01*cfg.output_face_scale) + + if mask_subres_size == output_size: + face_mask_output_mat = face_output_mat + else: + face_mask_output_mat = LandmarksProcessor.get_transform_mat (img_face_landmarks, mask_subres_size, face_type=cfg.face_type, scale= 1.0 + 0.01*cfg.output_face_scale) + + dst_face_bgr = cv2.warpAffine( img_bgr , face_mat, (output_size, output_size), flags=cv2.INTER_CUBIC ) + dst_face_bgr = np.clip(dst_face_bgr, 0, 1) + + dst_face_mask_a_0 = cv2.warpAffine( img_face_mask_a, face_mat, (output_size, output_size), flags=cv2.INTER_CUBIC ) + dst_face_mask_a_0 = np.clip(dst_face_mask_a_0, 0, 1) + + predictor_input_bgr = cv2.resize (dst_face_bgr, (input_size,input_size) ) + + predicted = predictor_func (predictor_input_bgr, (cfg.morph_power / 100.0)) + prd_face_bgr = np.clip (predicted[0], 0, 1.0) + prd_face_mask_a_0 = np.clip (predicted[1], 0, 1.0) + prd_face_dst_mask_a_0 = np.clip (predicted[2], 0, 1.0) + + if cfg.super_resolution_power != 0: + prd_face_bgr_enhanced = face_enhancer_func(prd_face_bgr, is_tanh=True, preserve_size=False) + mod = cfg.super_resolution_power / 100.0 + prd_face_bgr = cv2.resize(prd_face_bgr, (output_size,output_size))*(1.0-mod) + prd_face_bgr_enhanced*mod + prd_face_bgr = np.clip(prd_face_bgr, 0, 1) + + if cfg.super_resolution_power != 0: + prd_face_mask_a_0 = cv2.resize (prd_face_mask_a_0, (output_size, output_size), interpolation=cv2.INTER_CUBIC) + prd_face_dst_mask_a_0 = cv2.resize (prd_face_dst_mask_a_0, (output_size, output_size), interpolation=cv2.INTER_CUBIC) + + if cfg.mask_mode == 0: #full + wrk_face_mask_a_0 = np.ones_like(dst_face_mask_a_0) + elif cfg.mask_mode == 1: #dst + wrk_face_mask_a_0 = cv2.resize (dst_face_mask_a_0, (output_size,output_size), interpolation=cv2.INTER_CUBIC) + elif cfg.mask_mode == 2: #learned-prd + wrk_face_mask_a_0 = prd_face_mask_a_0 + elif cfg.mask_mode == 3: #learned-dst + wrk_face_mask_a_0 = prd_face_dst_mask_a_0 + elif cfg.mask_mode == 4: #learned-prd*learned-dst + wrk_face_mask_a_0 = prd_face_mask_a_0*prd_face_dst_mask_a_0 + elif cfg.mask_mode == 5: #learned-prd+learned-dst + wrk_face_mask_a_0 = np.clip( prd_face_mask_a_0+prd_face_dst_mask_a_0, 0, 1) + elif cfg.mask_mode >= 6 and cfg.mask_mode <= 9: #XSeg modes + if cfg.mask_mode == 6 or cfg.mask_mode == 8 or cfg.mask_mode == 9: + # obtain XSeg-prd + prd_face_xseg_bgr = cv2.resize (prd_face_bgr, (xseg_input_size,)*2, interpolation=cv2.INTER_CUBIC) + prd_face_xseg_mask = xseg_256_extract_func(prd_face_xseg_bgr) + X_prd_face_mask_a_0 = cv2.resize ( prd_face_xseg_mask, (output_size, output_size), interpolation=cv2.INTER_CUBIC) + + if cfg.mask_mode >= 7 and cfg.mask_mode <= 9: + # obtain XSeg-dst + xseg_mat = LandmarksProcessor.get_transform_mat (img_face_landmarks, xseg_input_size, face_type=cfg.face_type) + dst_face_xseg_bgr = cv2.warpAffine(img_bgr, xseg_mat, (xseg_input_size,)*2, flags=cv2.INTER_CUBIC ) + dst_face_xseg_mask = xseg_256_extract_func(dst_face_xseg_bgr) + X_dst_face_mask_a_0 = cv2.resize (dst_face_xseg_mask, (output_size,output_size), interpolation=cv2.INTER_CUBIC) + + if cfg.mask_mode == 6: #'XSeg-prd' + wrk_face_mask_a_0 = X_prd_face_mask_a_0 + elif cfg.mask_mode == 7: #'XSeg-dst' + wrk_face_mask_a_0 = X_dst_face_mask_a_0 + elif cfg.mask_mode == 8: #'XSeg-prd*XSeg-dst' + wrk_face_mask_a_0 = X_prd_face_mask_a_0 * X_dst_face_mask_a_0 + elif cfg.mask_mode == 9: #learned-prd*learned-dst*XSeg-prd*XSeg-dst + wrk_face_mask_a_0 = prd_face_mask_a_0 * prd_face_dst_mask_a_0 * X_prd_face_mask_a_0 * X_dst_face_mask_a_0 + + wrk_face_mask_a_0[ wrk_face_mask_a_0 < (1.0/255.0) ] = 0.0 # get rid of noise + + # resize to mask_subres_size + if wrk_face_mask_a_0.shape[0] != mask_subres_size: + wrk_face_mask_a_0 = cv2.resize (wrk_face_mask_a_0, (mask_subres_size, mask_subres_size), interpolation=cv2.INTER_CUBIC) + + # process mask in local predicted space + if 'raw' not in cfg.mode: + # add zero pad + wrk_face_mask_a_0 = np.pad (wrk_face_mask_a_0, input_size) + + ero = cfg.erode_mask_modifier + blur = cfg.blur_mask_modifier + + if ero > 0: + wrk_face_mask_a_0 = cv2.erode(wrk_face_mask_a_0, cv2.getStructuringElement(cv2.MORPH_ELLIPSE,(ero,ero)), iterations = 1 ) + elif ero < 0: + wrk_face_mask_a_0 = cv2.dilate(wrk_face_mask_a_0, cv2.getStructuringElement(cv2.MORPH_ELLIPSE,(-ero,-ero)), iterations = 1 ) + + # clip eroded/dilated mask in actual predict area + # pad with half blur size in order to accuratelly fade to zero at the boundary + clip_size = input_size + blur // 2 + + wrk_face_mask_a_0[:clip_size,:] = 0 + wrk_face_mask_a_0[-clip_size:,:] = 0 + wrk_face_mask_a_0[:,:clip_size] = 0 + wrk_face_mask_a_0[:,-clip_size:] = 0 + + if blur > 0: + blur = blur + (1-blur % 2) + wrk_face_mask_a_0 = cv2.GaussianBlur(wrk_face_mask_a_0, (blur, blur) , 0) + + wrk_face_mask_a_0 = wrk_face_mask_a_0[input_size:-input_size,input_size:-input_size] + + wrk_face_mask_a_0 = np.clip(wrk_face_mask_a_0, 0, 1) + + img_face_mask_a = cv2.warpAffine( wrk_face_mask_a_0, face_mask_output_mat, img_size, np.zeros(img_bgr.shape[0:2], dtype=np.float32), flags=cv2.WARP_INVERSE_MAP | cv2.INTER_CUBIC )[...,None] + img_face_mask_a = np.clip (img_face_mask_a, 0.0, 1.0) + img_face_mask_a [ img_face_mask_a < (1.0/255.0) ] = 0.0 # get rid of noise + + if wrk_face_mask_a_0.shape[0] != output_size: + wrk_face_mask_a_0 = cv2.resize (wrk_face_mask_a_0, (output_size,output_size), interpolation=cv2.INTER_CUBIC) + + wrk_face_mask_a = wrk_face_mask_a_0[...,None] + + out_img = None + out_merging_mask_a = None + if cfg.mode == 'original': + return img_bgr, img_face_mask_a + + elif 'raw' in cfg.mode: + if cfg.mode == 'raw-rgb': + out_img_face = cv2.warpAffine( prd_face_bgr, face_output_mat, img_size, np.empty_like(img_bgr), cv2.WARP_INVERSE_MAP | cv2.INTER_CUBIC) + out_img_face_mask = cv2.warpAffine( np.ones_like(prd_face_bgr), face_output_mat, img_size, np.empty_like(img_bgr), cv2.WARP_INVERSE_MAP | cv2.INTER_CUBIC) + out_img = img_bgr*(1-out_img_face_mask) + out_img_face*out_img_face_mask + out_merging_mask_a = img_face_mask_a + elif cfg.mode == 'raw-predict': + out_img = prd_face_bgr + out_merging_mask_a = wrk_face_mask_a + else: + raise ValueError(f"undefined raw type {cfg.mode}") + + out_img = np.clip (out_img, 0.0, 1.0 ) + else: + + # Process if the mask meets minimum size + maxregion = np.argwhere( img_face_mask_a >= 0.1 ) + if maxregion.size != 0: + miny,minx = maxregion.min(axis=0)[:2] + maxy,maxx = maxregion.max(axis=0)[:2] + lenx = maxx - minx + leny = maxy - miny + if min(lenx,leny) >= 4: + wrk_face_mask_area_a = wrk_face_mask_a.copy() + wrk_face_mask_area_a[wrk_face_mask_area_a>0] = 1.0 + + if 'seamless' not in cfg.mode and cfg.color_transfer_mode != 0: + if cfg.color_transfer_mode == 1: #rct + prd_face_bgr = imagelib.reinhard_color_transfer ( np.clip( prd_face_bgr*wrk_face_mask_area_a*255, 0, 255).astype(np.uint8), + np.clip( dst_face_bgr*wrk_face_mask_area_a*255, 0, 255).astype(np.uint8), ) + + prd_face_bgr = np.clip( prd_face_bgr.astype(np.float32) / 255.0, 0.0, 1.0) + elif cfg.color_transfer_mode == 2: #lct + prd_face_bgr = imagelib.linear_color_transfer (prd_face_bgr, dst_face_bgr) + elif cfg.color_transfer_mode == 3: #mkl + prd_face_bgr = imagelib.color_transfer_mkl (prd_face_bgr, dst_face_bgr) + elif cfg.color_transfer_mode == 4: #mkl-m + prd_face_bgr = imagelib.color_transfer_mkl (prd_face_bgr*wrk_face_mask_area_a, dst_face_bgr*wrk_face_mask_area_a) + elif cfg.color_transfer_mode == 5: #idt + prd_face_bgr = imagelib.color_transfer_idt (prd_face_bgr, dst_face_bgr) + elif cfg.color_transfer_mode == 6: #idt-m + prd_face_bgr = imagelib.color_transfer_idt (prd_face_bgr*wrk_face_mask_area_a, dst_face_bgr*wrk_face_mask_area_a) + elif cfg.color_transfer_mode == 7: #sot-m + prd_face_bgr = imagelib.color_transfer_sot (prd_face_bgr*wrk_face_mask_area_a, dst_face_bgr*wrk_face_mask_area_a, steps=10, batch_size=30) + prd_face_bgr = np.clip (prd_face_bgr, 0.0, 1.0) + elif cfg.color_transfer_mode == 8: #mix-m + prd_face_bgr = imagelib.color_transfer_mix (prd_face_bgr*wrk_face_mask_area_a, dst_face_bgr*wrk_face_mask_area_a) + + if cfg.mode == 'hist-match': + hist_mask_a = np.ones ( prd_face_bgr.shape[:2] + (1,) , dtype=np.float32) + + if cfg.masked_hist_match: + hist_mask_a *= wrk_face_mask_area_a + + white = (1.0-hist_mask_a)* np.ones ( prd_face_bgr.shape[:2] + (1,) , dtype=np.float32) + + hist_match_1 = prd_face_bgr*hist_mask_a + white + hist_match_1[ hist_match_1 > 1.0 ] = 1.0 + + hist_match_2 = dst_face_bgr*hist_mask_a + white + hist_match_2[ hist_match_1 > 1.0 ] = 1.0 + + prd_face_bgr = imagelib.color_hist_match(hist_match_1, hist_match_2, cfg.hist_match_threshold ).astype(dtype=np.float32) + + if 'seamless' in cfg.mode: + #mask used for cv2.seamlessClone + img_face_seamless_mask_a = None + for i in range(1,10): + a = img_face_mask_a > i / 10.0 + if len(np.argwhere(a)) == 0: + continue + img_face_seamless_mask_a = img_face_mask_a.copy() + img_face_seamless_mask_a[a] = 1.0 + img_face_seamless_mask_a[img_face_seamless_mask_a <= i / 10.0] = 0.0 + break + + out_img = cv2.warpAffine( prd_face_bgr, face_output_mat, img_size, np.empty_like(img_bgr), cv2.WARP_INVERSE_MAP | cv2.INTER_CUBIC ) + out_img = np.clip(out_img, 0.0, 1.0) + + if 'seamless' in cfg.mode: + try: + #calc same bounding rect and center point as in cv2.seamlessClone to prevent jittering (not flickering) + l,t,w,h = cv2.boundingRect( (img_face_seamless_mask_a*255).astype(np.uint8) ) + s_maskx, s_masky = int(l+w/2), int(t+h/2) + out_img = cv2.seamlessClone( (out_img*255).astype(np.uint8), img_bgr_uint8, (img_face_seamless_mask_a*255).astype(np.uint8), (s_maskx,s_masky) , cv2.NORMAL_CLONE ) + out_img = out_img.astype(dtype=np.float32) / 255.0 + except Exception as e: + #seamlessClone may fail in some cases + e_str = traceback.format_exc() + + if 'MemoryError' in e_str: + raise Exception("Seamless fail: " + e_str) #reraise MemoryError in order to reprocess this data by other processes + else: + print ("Seamless fail: " + e_str) + + cfg_mp = cfg.motion_blur_power / 100.0 + + out_img = img_bgr*(1-img_face_mask_a) + (out_img*img_face_mask_a) + + if ('seamless' in cfg.mode and cfg.color_transfer_mode != 0) or \ + cfg.mode == 'seamless-hist-match' or \ + cfg_mp != 0 or \ + cfg.blursharpen_amount != 0 or \ + cfg.image_denoise_power != 0 or \ + cfg.bicubic_degrade_power != 0: + + out_face_bgr = cv2.warpAffine( out_img, face_mat, (output_size, output_size), flags=cv2.INTER_CUBIC ) + + if 'seamless' in cfg.mode and cfg.color_transfer_mode != 0: + if cfg.color_transfer_mode == 1: + out_face_bgr = imagelib.reinhard_color_transfer ( np.clip(out_face_bgr*wrk_face_mask_area_a*255, 0, 255).astype(np.uint8), + np.clip(dst_face_bgr*wrk_face_mask_area_a*255, 0, 255).astype(np.uint8) ) + out_face_bgr = np.clip( out_face_bgr.astype(np.float32) / 255.0, 0.0, 1.0) + elif cfg.color_transfer_mode == 2: #lct + out_face_bgr = imagelib.linear_color_transfer (out_face_bgr, dst_face_bgr) + elif cfg.color_transfer_mode == 3: #mkl + out_face_bgr = imagelib.color_transfer_mkl (out_face_bgr, dst_face_bgr) + elif cfg.color_transfer_mode == 4: #mkl-m + out_face_bgr = imagelib.color_transfer_mkl (out_face_bgr*wrk_face_mask_area_a, dst_face_bgr*wrk_face_mask_area_a) + elif cfg.color_transfer_mode == 5: #idt + out_face_bgr = imagelib.color_transfer_idt (out_face_bgr, dst_face_bgr) + elif cfg.color_transfer_mode == 6: #idt-m + out_face_bgr = imagelib.color_transfer_idt (out_face_bgr*wrk_face_mask_area_a, dst_face_bgr*wrk_face_mask_area_a) + elif cfg.color_transfer_mode == 7: #sot-m + out_face_bgr = imagelib.color_transfer_sot (out_face_bgr*wrk_face_mask_area_a, dst_face_bgr*wrk_face_mask_area_a, steps=10, batch_size=30) + out_face_bgr = np.clip (out_face_bgr, 0.0, 1.0) + elif cfg.color_transfer_mode == 8: #mix-m + out_face_bgr = imagelib.color_transfer_mix (out_face_bgr*wrk_face_mask_area_a, dst_face_bgr*wrk_face_mask_area_a) + + if cfg.mode == 'seamless-hist-match': + out_face_bgr = imagelib.color_hist_match(out_face_bgr, dst_face_bgr, cfg.hist_match_threshold) + + if cfg_mp != 0: + k_size = int(frame_info.motion_power*cfg_mp) + if k_size >= 1: + k_size = np.clip (k_size+1, 2, 50) + if cfg.super_resolution_power != 0: + k_size *= 2 + out_face_bgr = imagelib.LinearMotionBlur (out_face_bgr, k_size , frame_info.motion_deg) + + if cfg.blursharpen_amount != 0: + out_face_bgr = imagelib.blursharpen ( out_face_bgr, cfg.sharpen_mode, 3, cfg.blursharpen_amount) + + if cfg.image_denoise_power != 0: + n = cfg.image_denoise_power + while n > 0: + img_bgr_denoised = cv2.medianBlur(img_bgr, 5) + if int(n / 100) != 0: + img_bgr = img_bgr_denoised + else: + pass_power = (n % 100) / 100.0 + img_bgr = img_bgr*(1.0-pass_power)+img_bgr_denoised*pass_power + n = max(n-10,0) + + if cfg.bicubic_degrade_power != 0: + p = 1.0 - cfg.bicubic_degrade_power / 101.0 + img_bgr_downscaled = cv2.resize (img_bgr, ( int(img_size[0]*p), int(img_size[1]*p ) ), interpolation=cv2.INTER_CUBIC) + img_bgr = cv2.resize (img_bgr_downscaled, img_size, interpolation=cv2.INTER_CUBIC) + + new_out = cv2.warpAffine( out_face_bgr, face_mat, img_size, np.empty_like(img_bgr), cv2.WARP_INVERSE_MAP | cv2.INTER_CUBIC ) + + out_img = np.clip( img_bgr*(1-img_face_mask_a) + (new_out*img_face_mask_a) , 0, 1.0 ) + + if cfg.color_degrade_power != 0: + out_img_reduced = imagelib.reduce_colors(out_img, 256) + if cfg.color_degrade_power == 100: + out_img = out_img_reduced + else: + alpha = cfg.color_degrade_power / 100.0 + out_img = (out_img*(1.0-alpha) + out_img_reduced*alpha) + out_merging_mask_a = img_face_mask_a + + if out_img is None: + out_img = img_bgr.copy() + + return out_img, out_merging_mask_a diff --git a/merger/MergerConfig.py b/merger/MergerConfig.py index eba1493..b268a40 100644 --- a/merger/MergerConfig.py +++ b/merger/MergerConfig.py @@ -9,10 +9,12 @@ class MergerConfig(object): TYPE_NONE = 0 TYPE_MASKED = 1 TYPE_FACE_AVATAR = 2 + #### TYPE_IMAGE = 3 TYPE_IMAGE_WITH_LANDMARKS = 4 + TYPE_MASKED_MORPH = 5 def __init__(self, type=0, sharpen_mode=0, @@ -327,3 +329,87 @@ class MergerConfigFaceAvatar(MergerConfig): f"add_source_image : {self.add_source_image}\n") + \ super().to_string(filename) + "================" + +class MergerConfigMaskedMorph(MergerConfigMasked): + + #override + def __init__(self, face_type=FaceType.WHOLE_FACE, + default_mode = 'overlay', + mode='overlay', + masked_hist_match=True, + hist_match_threshold = 238, + mask_mode = 4, + erode_mask_modifier = 0, + blur_mask_modifier = 0, + motion_blur_power = 0, + output_face_scale = 0, + super_resolution_power = 0, + color_transfer_mode = ctm_str_dict['rct'], + image_denoise_power = 0, + bicubic_degrade_power = 0, + color_degrade_power = 0, + morph_power=100, + **kwargs + ): + + MergerConfig.__init__(self, type=MergerConfig.TYPE_MASKED_MORPH, **kwargs) + + self.face_type = face_type + if self.face_type not in [FaceType.WHOLE_FACE, FaceType.HEAD ]: + raise ValueError("MergerConfigMaskedMorph does not support this type of face.") + + self.default_mode = default_mode + + #default changeable params + if mode not in mode_str_dict: + mode = mode_dict[1] + + self.mode = mode + self.masked_hist_match = masked_hist_match + self.hist_match_threshold = hist_match_threshold + self.mask_mode = mask_mode + self.erode_mask_modifier = erode_mask_modifier + self.blur_mask_modifier = blur_mask_modifier + self.motion_blur_power = motion_blur_power + self.output_face_scale = output_face_scale + self.super_resolution_power = super_resolution_power + self.color_transfer_mode = color_transfer_mode + self.image_denoise_power = image_denoise_power + self.bicubic_degrade_power = bicubic_degrade_power + self.color_degrade_power = color_degrade_power + self.morph_power = morph_power + + + + #override + def to_string(self, filename): + r = super().to_string(filename) + if r.endswith('================'): + r = r[:-16] + + r += f"""morph_power: {self.morph_power}\n""" + + r += "================" + + return r + + #override + def ask_settings(self): + + super().ask_settings() + + self.morph_power = np.clip ( io.input_int ("Morph power in percent (overwrites morph factor)", 0, add_info="0..100"), 0, 100) + + #override + def add_morph_power(self, diff): + self.morph_power = np.clip ( self.morph_power+diff , 0, 100) + + def __eq__(self, other): + #check equality of changeable params + + if isinstance(other, MergerConfigMaskedMorph): + return super().__eq__(other) and \ + self.morph_power == other.morph_power + + return False + \ No newline at end of file diff --git a/merger/__init__.py b/merger/__init__.py index 82a4414..26301a4 100644 --- a/merger/__init__.py +++ b/merger/__init__.py @@ -1,5 +1,6 @@ from .FrameInfo import FrameInfo -from .MergerConfig import MergerConfig, MergerConfigMasked, MergerConfigFaceAvatar +from .MergerConfig import MergerConfig, MergerConfigMasked, MergerConfigFaceAvatar, MergerConfigMaskedMorph from .MergeMasked import MergeMasked +from .MergeMasked import MergeMaskedMorph from .MergeAvatar import MergeFaceAvatar from .InteractiveMergerSubprocessor import InteractiveMergerSubprocessor \ No newline at end of file diff --git a/models/Model_AMP/Model.py b/models/Model_AMP/Model.py index 9347944..c1c13f5 100644 --- a/models/Model_AMP/Model.py +++ b/models/Model_AMP/Model.py @@ -800,11 +800,11 @@ class AMPModel(ModelBase): def get_MergerConfig(self): morph_factor = np.clip ( io.input_number ("Morph factor", 0.75, add_info="0.0 .. 1.0"), 0.0, 1.0 ) - def predictor_morph(face): - return self.predictor_func(face, morph_factor) + def predictor_morph(face, func_morph_factor=morph_factor): + return self.predictor_func(face, func_morph_factor) import merger - return predictor_morph, (self.options['resolution'], self.options['resolution'], 3), merger.MergerConfigMasked(face_type=self.face_type, default_mode = 'overlay') + return predictor_morph, (self.options['resolution'], self.options['resolution'], 3), merger.MergerConfigMaskedMorph(face_type=self.face_type, default_mode = 'overlay') Model = AMPModel