For Version 2

app.py

@@ -1,69 +1,65 @@
 import cv2
+import torch
 import numpy as np
 import gradio as gr
-from PIL import Image
 import paddlehub as hub
+from PIL import Image
 from methods.img2pixl import pixL
 from examples.pixelArt.combine import combine
-from examples.pixelArt.white_box_cartoonizer.cartoonize import WB_Cartoonize
+
 model = hub.Module(name='U2Net')
-pixl = pixL()
-combine = combine()
+device = "cuda" if torch.cuda.is_available() else "cpu"
+face2paint = torch.hub.load("bryandlee/animegan2-pytorch:main", "face2paint", device=device, size=512)
+model = torch.hub.load("bryandlee/animegan2-pytorch", "generator", device=device).eval()
 
 def GIF(fname,pixel_size):
-    print(fname)
     gif = Image.open(fname)
-    frames = []
-    for i in range(gif.n_frames):
+    frames = [] 
+    for i in range(gif.n_frames): #First Step: Splitting the GIF into frames
         gif.seek(i)
         frame = Image.new('RGB', gif.size)
         frame.paste(gif)
         frame = np.array(frame)
         frames.append(frame)
-    print(len(frames))
-    
-    result = pixl.toThePixL(frames, pixel_size)
-    print(len(result), result[0].shape)
+    result = pixL().toThePixL(frames, pixel_size)
+    for frame in result:          #Second Step: Adding Cartoon Effect to each frame
+        frame = Image.fromarray(frame)
+        frame = cv2.cvtColor(np.asarray(face2paint(model, frame)), cv2.COLOR_BGR2RGB)
     frames = []
-    for frame in result:
-        
-        frame = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
-        frame = Image.fromarray(frame)    
-        frames.append(frame)
-    print(type(frames), len(frames), type(frames[0]), frames[0].size)
-    frames[0].save('new.gif', append_images=frames, save_all=True, loop=1)
-    return Image.open('cache.gif')
+    for frame in result:          #Third Step: Combining the frames into a GIF
+      frame = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
+      frame = Image.fromarray(frame)    
+      frames.append(frame)
+    frames[0].save('cache.gif', append_images=frames, save_all=True, loop=1)
+    cache = Image.open('cache.gif')
+    return cache
 
-def func_tab1(image,pixel_size, checkbox1):
-  if image.name.endswith('.gif'):
-    GIF(image.name,pixel_size)
-  else:
-    image = cv2.imread(image.name)
-    image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
-    image = WB_Cartoonize().infer(image)
-    image = np.array(image)
-    image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
-    if checkbox1:
-      result = model.Segmentation(
-          images=[image],
-          paths=None,
-          batch_size=1,
-          input_size=320,  
-          output_dir='output',
-          visualization=True)
-      result = combine.combiner(images = pixl.toThePixL([result[0]['front'][:,:,::-1], result[0]['mask']], 
+def initilize(image,pixel_size,checkbox1):
+    if image.name.endswith('.gif'):
+      GIF(image.name,pixel_size)
+    else:
+      image = Image.open(image.name).convert("RGB")
+      image = cv2.cvtColor(np.asarray(face2paint(model, image)), cv2.COLOR_BGR2RGB)
+      if checkbox1:
+        result = model.Segmentation(
+        images=[image],
+        paths=None,
+        batch_size=1,
+        input_size=320,  
+        output_dir='output',
+        visualization=True)
+        result = combine.combiner(images = pixL().toThePixL([result[0]['front'][:,:,::-1], result[0]['mask']], 
                                                         pixel_size),
                                 background_image = image)
-    else:
-      result = pixl.toThePixL([image], pixel_size)
-    return result
+      else:
+        result = pixL().toThePixL([image], pixel_size)
+      return Image.fromarray(result)
 
-inputs_tab1 = [gr.inputs.Image(type='file', label="Image"),
+inputs = ["file",
                gr.Slider(4, 100, value=12, step = 2, label="Pixel Size"),
                gr.Checkbox(label="Object-Oriented Inference", value=False)]
-outputs_tab1 = [gr.Image(type="file",label="Front")]
-
-gr.Interface(fn = func_tab1,
-                    inputs = inputs_tab1,
-                    outputs = outputs_tab1).launch()
+outputs = [gr.Image(type="pil",label="Front")]
 
+gr.Interface(fn = initilize,
+                    inputs = inputs,
+                    outputs = outputs).launch()

examples/pixelArt/white_box_cartoonizer/cartoonize.py

@@ -1,83 +0,0 @@
-"""
-Internal code snippets were obtained from https://github.com/SystemErrorWang/White-box-Cartoonization/
-
-For it to work tensorflow version 2.x changes were obtained from https://github.com/steubk/White-box-Cartoonization 
-"""
-import os
-import uuid
-import time
-import subprocess
-import sys
-
-import cv2
-import numpy as np
-
-try:
-    import tensorflow.compat.v1 as tf
-except ImportError:
-    import tensorflow as tf
-
-from methods.white_box_cartoonizer.components.guided_filter import gf
-from methods.white_box_cartoonizer.components.network import nk
-
-weights_dir = f'{os.getcwd()}/methods/white_box_cartoonizer/saved_models'
-gpu = len(sys.argv) < 2 or sys.argv[1] != '--cpu'
-
-class WB_Cartoonize:
-    def __init__(self):
-        if not os.path.exists(weights_dir):
-            raise FileNotFoundError("Weights Directory not found, check path")             
-    
-    def resize_crop(self, image):
-        h, w, c = np.shape(image)
-        if min(h, w) > 720:
-            if h > w:
-                h, w = int(720*h/w), 720
-            else:
-                h, w = 720, int(720*w/h)
-        image = cv2.resize(image, (w, h),
-                            interpolation=cv2.INTER_AREA)
-        h, w = (h//8)*8, (w//8)*8
-        image = image[:h, :w, :]
-        return image
-
-    def load_model(self, weights_dir, gpu):
-        try:
-            tf.disable_eager_execution()
-        except:
-            None
-        
-        tf.reset_default_graph()
-
-        self.input_photo = tf.placeholder(tf.float32, [1, None, None, 3], name='input_image')
-        network_out = nk.unet_generator(self.input_photo)
-        self.final_out = gf.guided_filter(self.input_photo, network_out, r=1, eps=5e-3)
-
-        all_vars = tf.trainable_variables()
-        gene_vars = [var for var in all_vars if 'generator' in var.name]
-        saver = tf.train.Saver(var_list=gene_vars)
-        
-        if gpu:
-            gpu_options = tf.GPUOptions(allow_growth=True)
-            device_count = {'GPU':1}
-        else:
-            gpu_options = None
-            device_count = {'GPU':0}
-        
-        config = tf.ConfigProto(gpu_options=gpu_options, device_count=device_count)
-        
-        self.sess = tf.Session(config=config)
-
-        self.sess.run(tf.global_variables_initializer())
-        saver.restore(self.sess, tf.train.latest_checkpoint(weights_dir))
-
-    def infer(self, image):
-        self.input_photo = image
-        self.load_model(weights_dir, gpu)
-        image = self.resize_crop(image)
-        batch_image = image.astype(np.float32)/127.5 - 1
-        batch_image = np.expand_dims(batch_image, axis=0)
-        output = self.sess.run(self.final_out, feed_dict={self.input_photo: batch_image})
-        output = (np.squeeze(output)+1)*127.5
-        output = np.clip(output, 0, 255).astype(np.uint8)
-        return output

examples/pixelArt/white_box_cartoonizer/components/guided_filter.py

@@ -1,73 +0,0 @@
-"""
-Code copyrights are with: https://github.com/SystemErrorWang/White-box-Cartoonization/
-
-To adapt the code with tensorflow v2 changes obtained from: https://github.com/steubk/White-box-Cartoonization 
-"""
-try:
-    import tensorflow.compat.v1 as tf
-except ImportError:
-    import tensorflow as tf
-
-import numpy as np
-
-class gf:
-    def tf_box_filter(x, r):
-        k_size = int(2*r+1)
-        ch = x.get_shape().as_list()[-1]
-        weight = 1/(k_size**2)
-        box_kernel = weight*np.ones((k_size, k_size, ch, 1))
-        box_kernel = np.array(box_kernel).astype(np.float32)
-        output = tf.nn.depthwise_conv2d(x, box_kernel, [1, 1, 1, 1], 'SAME')
-        return output
-
-
-
-    def guided_filter(x, y, r, eps=1e-2):
-        
-        x_shape = tf.shape(x)
-        #y_shape = tf.shape(y)
-
-        N = gf.tf_box_filter(tf.ones((1, x_shape[1], x_shape[2], 1), dtype=x.dtype), r)
-
-        mean_x = gf.tf_box_filter(x, r) / N
-        mean_y = gf.tf_box_filter(y, r) / N
-        cov_xy = gf.tf_box_filter(x * y, r) / N - mean_x * mean_y
-        var_x  = gf.tf_box_filter(x * x, r) / N - mean_x * mean_x
-
-        A = cov_xy / (var_x + eps)
-        b = mean_y - A * mean_x
-
-        mean_A = gf.tf_box_filter(A, r) / N
-        mean_b = gf.tf_box_filter(b, r) / N
-
-        output = tf.add(mean_A * x, mean_b, name='final_add')
-
-        return output
-
-
-
-    def fast_guided_filter(lr_x, lr_y, hr_x, r=1, eps=1e-8):
-        
-        #assert lr_x.shape.ndims == 4 and lr_y.shape.ndims == 4 and hr_x.shape.ndims == 4
-    
-        lr_x_shape = tf.shape(lr_x)
-        #lr_y_shape = tf.shape(lr_y)
-        hr_x_shape = tf.shape(hr_x)
-        
-        N = gf.tf_box_filter(tf.ones((1, lr_x_shape[1], lr_x_shape[2], 1), dtype=lr_x.dtype), r)
-
-        mean_x = gf.tf_box_filter(lr_x, r) / N
-        mean_y = gf.tf_box_filter(lr_y, r) / N
-        cov_xy = gf.tf_box_filter(lr_x * lr_y, r) / N - mean_x * mean_y
-        var_x  = gf.tf_box_filter(lr_x * lr_x, r) / N - mean_x * mean_x
-
-        A = cov_xy / (var_x + eps)
-        b = mean_y - A * mean_x
-
-        mean_A = tf.image.resize_images(A, hr_x_shape[1: 3])
-        mean_b = tf.image.resize_images(b, hr_x_shape[1: 3])
-
-        output = mean_A * hr_x + mean_b
-        
-        return output
-

examples/pixelArt/white_box_cartoonizer/components/network.py

@@ -1,72 +0,0 @@
-"""
-Code copyrights are with: https://github.com/SystemErrorWang/White-box-Cartoonization/
-
-To adapt the code with tensorflow v2 changes obtained from: https://github.com/steubk/White-box-Cartoonization 
-"""
-try:
-    import tensorflow.compat.v1 as tf
-    import tf_slim as slim
-except ImportError:
-    import tensorflow as tf
-    import tensorflow.contrib.slim as slim
-
-import numpy as np
-
-
-class nk:
-    def resblock(inputs, out_channel=32, name='resblock'):
-        
-        with tf.variable_scope(name):
-            
-            x = slim.convolution2d(inputs, out_channel, [3, 3], 
-                                activation_fn=None, scope='conv1')
-            x = tf.nn.leaky_relu(x)
-            x = slim.convolution2d(x, out_channel, [3, 3], 
-                                activation_fn=None, scope='conv2')
-            
-            return x + inputs
-
-
-
-
-    def unet_generator(inputs, channel=32, num_blocks=4, name='generator', reuse=False):
-        with tf.variable_scope(name, reuse=reuse):
-            
-            x0 = slim.convolution2d(inputs, channel, [7, 7], activation_fn=None)
-            x0 = tf.nn.leaky_relu(x0)
-            
-            x1 = slim.convolution2d(x0, channel, [3, 3], stride=2, activation_fn=None)
-            x1 = tf.nn.leaky_relu(x1)
-            x1 = slim.convolution2d(x1, channel*2, [3, 3], activation_fn=None)
-            x1 = tf.nn.leaky_relu(x1)
-            
-            x2 = slim.convolution2d(x1, channel*2, [3, 3], stride=2, activation_fn=None)
-            x2 = tf.nn.leaky_relu(x2)
-            x2 = slim.convolution2d(x2, channel*4, [3, 3], activation_fn=None)
-            x2 = tf.nn.leaky_relu(x2)
-            
-            for idx in range(num_blocks):
-                x2 = nk.resblock(x2, out_channel=channel*4, name='block_{}'.format(idx))
-                
-            x2 = slim.convolution2d(x2, channel*2, [3, 3], activation_fn=None)
-            x2 = tf.nn.leaky_relu(x2)
-            
-            h1, w1 = tf.shape(x2)[1], tf.shape(x2)[2]
-            x3 = tf.image.resize_bilinear(x2, (h1*2, w1*2))
-            x3 = slim.convolution2d(x3+x1, channel*2, [3, 3], activation_fn=None)
-            x3 = tf.nn.leaky_relu(x3)
-            x3 = slim.convolution2d(x3, channel, [3, 3], activation_fn=None)
-            x3 = tf.nn.leaky_relu(x3)
-
-            h2, w2 = tf.shape(x3)[1], tf.shape(x3)[2]
-            x4 = tf.image.resize_bilinear(x3, (h2*2, w2*2))
-            x4 = slim.convolution2d(x4+x0, channel, [3, 3], activation_fn=None)
-            x4 = tf.nn.leaky_relu(x4)
-            x4 = slim.convolution2d(x4, 3, [7, 7], activation_fn=None)
-            
-            return x4
-
-if __name__ == '__main__':
-    
-
-    pass

examples/pixelArt/white_box_cartoonizer/saved_models/checkpoint

@@ -1,3 +0,0 @@
-model_checkpoint_path: "model-33999"
-all_model_checkpoint_paths: "model-33999"
-all_model_checkpoint_paths: "model-37499"

requirements.txt

@@ -1,4 +1,5 @@
 pip
+torch
 tensorflow
 Flask
 gunicorn