global refactoring and fixes,

removed support of extracted(aligned) PNG faces. Use old builds to convert from PNG to JPG.

fanseg model file in facelib/ is renamed

core/imagelib/__init__.py

@@ -17,4 +17,6 @@ from .common import normalize_channels, cut_odd_image, overlay_alpha_image
 
 from .IEPolys import IEPolys
 
-from .blur import LinearMotionBlur
+from .blursharpen import LinearMotionBlur, blursharpen
+
+from .filters import apply_random_hsv_shift, apply_random_motion_blur, apply_random_gaussian_blur, apply_random_bilinear_resize

core/imagelib/blur.py

@@ -1,9 +0,0 @@
-import cv2
-import numpy as np
-
-def LinearMotionBlur(image, size, angle):
-    k = np.zeros((size, size), dtype=np.float32)
-    k[ (size-1)// 2 , :] = np.ones(size, dtype=np.float32)
-    k = cv2.warpAffine(k, cv2.getRotationMatrix2D( (size / 2 -0.5 , size / 2 -0.5 ) , angle, 1.0), (size, size) )
-    k = k * ( 1.0 / np.sum(k) )
-    return cv2.filter2D(image, -1, k)

core/imagelib/blursharpen.py

@@ -0,0 +1,38 @@
+import cv2
+import numpy as np
+
+def LinearMotionBlur(image, size, angle):
+    k = np.zeros((size, size), dtype=np.float32)
+    k[ (size-1)// 2 , :] = np.ones(size, dtype=np.float32)
+    k = cv2.warpAffine(k, cv2.getRotationMatrix2D( (size / 2 -0.5 , size / 2 -0.5 ) , angle, 1.0), (size, size) )
+    k = k * ( 1.0 / np.sum(k) )
+    return cv2.filter2D(image, -1, k)
+    
+def blursharpen (img, sharpen_mode=0, kernel_size=3, amount=100):
+    if kernel_size % 2 == 0:
+        kernel_size += 1
+    if amount > 0:
+        if sharpen_mode == 1: #box
+            kernel = np.zeros( (kernel_size, kernel_size), dtype=np.float32)
+            kernel[ kernel_size//2, kernel_size//2] = 1.0
+            box_filter = np.ones( (kernel_size, kernel_size), dtype=np.float32) / (kernel_size**2)
+            kernel = kernel + (kernel - box_filter) * amount
+            return cv2.filter2D(img, -1, kernel)
+        elif sharpen_mode == 2: #gaussian
+            blur = cv2.GaussianBlur(img, (kernel_size, kernel_size) , 0)
+            img = cv2.addWeighted(img, 1.0 + (0.5 * amount), blur, -(0.5 * amount), 0)
+            return img
+    elif amount < 0:
+        n = -amount
+        while n > 0:
+
+            img_blur = cv2.medianBlur(img, 5)
+            if int(n / 10) != 0:
+                img = img_blur
+            else:
+                pass_power = (n % 10) / 10.0
+                img = img*(1.0-pass_power)+img_blur*pass_power
+            n = max(n-10,0)
+
+        return img
+    return img

core/imagelib/filters.py

@@ -0,0 +1,53 @@
+import numpy as np
+from .blursharpen import LinearMotionBlur
+import cv2
+
+def apply_random_hsv_shift(img, rnd_state=None):
+    if rnd_state is None:
+        rnd_state = np.random
+    
+    h, s, v = cv2.split(cv2.cvtColor(img, cv2.COLOR_BGR2HSV))
+    h = ( h + rnd_state.randint(360) ) % 360
+    s = np.clip ( s + rnd_state.random()-0.5, 0, 1 )
+    v = np.clip ( v + rnd_state.random()/2-0.25, 0, 1 )                    
+    img = np.clip( cv2.cvtColor(cv2.merge([h, s, v]), cv2.COLOR_HSV2BGR) , 0, 1 )
+    return img
+    
+def apply_random_motion_blur( img, chance, mb_max_size, rnd_state=None ):
+    if rnd_state is None:
+        rnd_state = np.random
+    
+    mblur_rnd_kernel = rnd_state.randint(mb_max_size)+1
+    mblur_rnd_deg    = rnd_state.randint(360)
+
+    if rnd_state.randint(100) < np.clip(chance, 0, 100):
+        img = LinearMotionBlur (img, mblur_rnd_kernel, mblur_rnd_deg )
+        
+    return img
+    
+def apply_random_gaussian_blur( img, chance, kernel_max_size, rnd_state=None ):
+    if rnd_state is None:
+        rnd_state = np.random
+        
+    if rnd_state.randint(100) < np.clip(chance, 0, 100):
+        gblur_rnd_kernel = rnd_state.randint(kernel_max_size)*2+1
+        img = cv2.GaussianBlur(img, (gblur_rnd_kernel,)*2 , 0)
+    
+    return img
+    
+    
+def apply_random_bilinear_resize( img, chance, max_size_per, rnd_state=None ):
+    if rnd_state is None:
+        rnd_state = np.random
+
+    if rnd_state.randint(100) < np.clip(chance, 0, 100):
+        h,w,c = img.shape
+        
+        trg = rnd_state.rand()
+        rw = w - int( trg * int(w*(max_size_per/100.0)) )                        
+        rh = h - int( trg * int(h*(max_size_per/100.0)) )   
+             
+        img = cv2.resize (img, (rw,rh), cv2.INTER_LINEAR )
+        img = cv2.resize (img, (w,h), cv2.INTER_LINEAR )
+        
+    return img