add morph power option to interactive merger, side effect overwrites key bindings of image color degrade!

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

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:
@@ -427,6 +454,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) )
                                 cur_frame.is_done = False

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

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
+        

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

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):
+        def predictor_morph(face, func_morph_factor=morph_factor):
-            return self.predictor_func(face, 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