issues...

app.py

@@ -0,0 +1,54 @@
+import cv2
+import numpy as np
+import gradio as gr
+import paddlehub as hub
+from methods.img2pixl import pixL
+from methods.combine import combine
+from methods.white_box_cartoonizer.cartoonize import WB_Cartoonize
+model = hub.Module(name='U2Net')
+pixl = pixL()
+combine = combine()
+
+def func_tab1(image,pixel_size, checkbox1):
+  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']], 
+                                                      pixel_size),
+                              background_image = image)
+  else:
+    images=images
+    result = pixl.toThePixL(images, pixel_size)
+  return result
+
+def func_tab2():
+  pass
+
+inputs_tab1 = [gr.inputs.Image(type='file', label="Image"),
+               gr.Slider(4, 100, value=12, step = 2, label="Pixel Size"),
+               gr.Checkbox(label="Object-Oriented Inference", value=False)]
+outputs_tab1 = [gr.Image(type="numpy",label="Front")]
+
+inputs_tab2 = [gr.Video()]
+outputs_tab2 = [gr.Video()]
+
+tab1 = gr.Interface(fn = func_tab1,
+                    inputs = inputs_tab1,
+                    outputs = outputs_tab1)
+#Pixera for Videos
+tab2 = gr.Interface(fn = func_tab2,
+                    inputs = inputs_tab2,
+                    outputs = outputs_tab2)
+
+gr.TabbedInterface([tab1], ["Pixera for Images"]).launch()
+

methods/combine.py

@@ -0,0 +1,29 @@
+import cv2
+import numpy as np
+
+class combine:
+    #Author: Alican Akca
+    def __init__(self, size = (400,300),images = [],background_image = None):
+        self.size = size
+        self.images = images
+        self.background_image = background_image
+
+    def combiner(self,images,background_image):
+        original = images[0]
+        masked = images[1]
+        background = cv2.resize(background_image,(images[0].shape[1],images[0].shape[0]))
+        result = blend_images_using_mask(original, background, masked)
+        return result 
+
+def mix_pixel(pix_1, pix_2, perc):
+
+    return (perc/255 * pix_1) + ((255 - perc)/255 * pix_2)
+
+def blend_images_using_mask(img_orig, img_for_overlay, img_mask):
+
+    if len(img_mask.shape) != 3:
+        img_mask = cv2.cvtColor(img_mask, cv2.COLOR_GRAY2BGR)
+
+    img_res = mix_pixel(img_orig, img_for_overlay, img_mask)
+
+    return cv2.cvtColor(img_res.astype(np.uint8), cv2.COLOR_BGR2RGB)

methods/img2pixl.py

@@ -0,0 +1,73 @@
+import cv2
+import numpy as np
+from PIL import Image
+
+class pixL:
+  #Author: Alican Akca
+  def __init__(self,numOfSquaresW = None, numOfSquaresH= None, size = [False, (512,512)],square = 6,ImgH = None,ImgW = None,images = [],background_image = None):
+    self.images = images
+    self.size = size
+    self.background_image = background_image
+    self.ImgH = ImgH
+    self.ImgW = ImgW
+    self.square = square
+    self.numOfSquaresW = numOfSquaresW
+    self.numOfSquaresH = numOfSquaresH
+
+  def preprocess(self):
+    for image in self.images:
+
+      size = (image.shape[0] - (image.shape[0] % 4), image.shape[1] - (image.shape[1] % 4))
+      image = cv2.resize(image, size)
+      image = cv2.cvtColor(image.astype(np.uint8), cv2.COLOR_BGR2RGB)
+    
+    if len(self.images) == 1:
+      return self.images[0]
+    else:
+      return self.images
+
+  def toThePixL(self,images, pixel_size, background_image ):
+    self.background_image = background_image
+    self.images = []
+    self.square = pixel_size
+    for image in images:
+      image = Image.fromarray(image)
+      image = image.convert("RGB")
+      self.ImgW, self.ImgH = image.size
+      self.images.append(pixL.epicAlgorithm(self, image))
+      
+    return pixL.preprocess(self)
+
+  def numOfSquaresFunc(self):
+    self.numOfSquaresW = round((self.ImgW / self.square) + 1)
+    self.numOfSquaresH = round((self.ImgH / self.square) + 1)
+
+  def epicAlgorithm(self, image):
+    pixValues = []
+    pixL.numOfSquaresFunc(self)
+
+    for j in range(1,self.numOfSquaresH):
+
+      for i in range(1,self.numOfSquaresW):
+        
+        pixValues.append((image.getpixel((
+              i * self.square - self.square//2,
+              j * self.square - self.square//2)),
+              (i * self.square - self.square//2,
+              j * self.square - self.square//2)))
+    
+    background = 255 * np.ones(shape=[self.ImgH - self.square, 
+                                      self.ImgW - self.square*2, 3], 
+                                      dtype=np.uint8)                
+    
+    for pen in range(len(pixValues)):
+
+      cv2.rectangle(background, 
+                    pt1=(pixValues[pen][1][0] - self.square,pixValues[pen][1][1] - self.square), 
+                    pt2=(pixValues[pen][1][0] + self.square,pixValues[pen][1][1] + self.square), 
+                    color=(pixValues[pen][0][2],pixValues[pen][0][1],pixValues[pen][0][0]), 
+                    thickness=-1)
+    background = np.array(self.background_image).astype(np.uint8)
+    background = cv2.resize(background, (self.ImgW,self.ImgH), interpolation = cv2.INTER_AREA)
+
+    return background

methods/secondMethod.py

@@ -0,0 +1,12 @@
+import numpy as np
+import cv2 as cv
+from matplotlib import pyplot as plt
+import os
+
+os.chdir("C:\\Users\Alican Akca\\OneDrive - Izmir Universtiy of Economics\\Belgeler\\GitHub\\pixera")
+img = cv.imread(f'{os.getcwd()}\original\1.jpg',0)
+edges = cv.Canny(img,100,200)
+
+plt.subplot(122),plt.imshow(edges,cmap = 'gray')
+plt.title('Edge Image'), plt.xticks([]), plt.yticks([])
+plt.show()

methods/white_box_cartoonizer/cartoonize.py

@@ -0,0 +1,83 @@
+"""
+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

methods/white_box_cartoonizer/components/guided_filter.py

@@ -0,0 +1,73 @@
+"""
+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
+

methods/white_box_cartoonizer/components/network.py

@@ -0,0 +1,72 @@
+"""
+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

methods/white_box_cartoonizer/saved_models/checkpoint

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

requirements.txt

@@ -0,0 +1,15 @@
+pip
+tensorflow
+Flask
+gunicorn
+Pillow
+opencv_python
+google-cloud-storage
+algorithmia
+scikit-video
+tf_slim
+PyYaml
+flask-ngrok
+paddlepaddle
+paddlehub
+numpy==1.19.5

src/GAN.py

@@ -0,0 +1,202 @@
+import os 
+import cv2
+import keras
+import warnings
+import numpy as np
+from PIL import Image
+import matplotlib.pyplot as plt
+
+from tensorflow.keras.optimizers import Adam
+from tensorflow.keras.models import Sequential, Model
+from tensorflow.keras.layers import Dense, LeakyReLU, Reshape, Flatten, Input
+from tensorflow.keras.layers import Conv2D, MaxPooling2D, Activation, Dropout, Conv2DTranspose
+
+from tensorflow.compat.v1.keras.layers import BatchNormalization
+
+images = []
+def load_images(size=(64,64)):
+  pixed_faces =  os.listdir("kaggle/working/results/pixed_faces")
+  images_Path = "kaggle/working/results/pixed_faces"
+  for i in pixed_faces:
+    try:
+      image = cv2.imread(f"{images_Path}/{i}")
+      image = cv2.resize(image,size)
+      images.append(cv2.cvtColor(image, cv2.COLOR_BGR2RGB))
+    except:
+      pass
+
+load_images()
+
+
+#--------vvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvv
+#Author: https://www.kaggle.com/nassimyagoub
+#--------^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+def __init__(self):
+    self.img_shape = (64, 64, 3)
+        
+    self.noise_size = 100
+
+    optimizer = Adam(0.0002,0.5)
+
+    self.discriminator = self.build_discriminator()
+    self.discriminator.compile(loss='binary_crossentropy', 
+                                   optimizer=optimizer,
+                                   metrics=['accuracy'])
+
+    self.generator = self.build_generator()
+    self.generator.compile(loss='binary_crossentropy', optimizer=optimizer)
+        
+    self.combined = Sequential()
+    self.combined.add(self.generator)
+    self.combined.add(self.discriminator)
+        
+    self.discriminator.trainable = False
+        
+    self.combined.compile(loss='binary_crossentropy', optimizer=optimizer)
+        
+    self.combined.summary()
+        
+def build_generator(self):
+    epsilon = 0.00001
+    noise_shape = (self.noise_size,)
+        
+    model = Sequential()
+        
+    model.add(Dense(4*4*512, activation='linear', input_shape=noise_shape))
+    model.add(LeakyReLU(alpha=0.2))
+    model.add(Reshape((4, 4, 512)))
+        
+    model.add(Conv2DTranspose(512, kernel_size=[4,4], strides=[2,2], padding="same",
+                                  kernel_initializer= keras.initializers.TruncatedNormal(stddev=0.02)))
+    model.add(BatchNormalization(momentum=0.9, epsilon=epsilon))
+    model.add(LeakyReLU(alpha=0.2))
+        
+    model.add(Conv2DTranspose(256, kernel_size=[4,4], strides=[2,2], padding="same",
+                                  kernel_initializer= keras.initializers.TruncatedNormal(stddev=0.02)))
+    model.add(BatchNormalization(momentum=0.9, epsilon=epsilon))
+    model.add(LeakyReLU(alpha=0.2))
+        
+    model.add(Conv2DTranspose(128, kernel_size=[4,4], strides=[2,2], padding="same",
+                                  kernel_initializer= keras.initializers.TruncatedNormal(stddev=0.02)))
+    model.add(BatchNormalization(momentum=0.9, epsilon=epsilon))
+    model.add(LeakyReLU(alpha=0.2))
+        
+    model.add(Conv2DTranspose(64, kernel_size=[4,4], strides=[2,2], padding="same",
+                                  kernel_initializer= keras.initializers.TruncatedNormal(stddev=0.02)))
+    model.add(BatchNormalization(momentum=0.9, epsilon=epsilon))
+    model.add(LeakyReLU(alpha=0.2))
+        
+    model.add(Conv2DTranspose(3, kernel_size=[4,4], strides=[1,1], padding="same",
+                                  kernel_initializer= keras.initializers.TruncatedNormal(stddev=0.02)))
+
+    model.add(Activation("tanh"))
+        
+    model.summary()
+
+    noise = Input(shape=noise_shape)
+    img = model(noise)
+
+    return Model(noise, img)
+
+def build_discriminator(self):
+
+    model = Sequential()
+
+    model.add(Conv2D(128, (3,3), padding='same', input_shape=self.img_shape))
+    model.add(LeakyReLU(alpha=0.2))
+    model.add(BatchNormalization())
+    model.add(Conv2D(128, (3,3), padding='same'))
+    model.add(LeakyReLU(alpha=0.2))
+    model.add(BatchNormalization())
+    model.add(MaxPooling2D(pool_size=(3,3)))
+    model.add(Dropout(0.2))
+
+    model.add(Conv2D(128, (3,3), padding='same'))
+    model.add(LeakyReLU(alpha=0.2))
+    model.add(BatchNormalization())
+    model.add(Conv2D(128, (3,3), padding='same'))
+    model.add(LeakyReLU(alpha=0.2))
+    model.add(BatchNormalization())
+    model.add(MaxPooling2D(pool_size=(3,3)))
+    model.add(Dropout(0.3))
+
+    model.add(Flatten())
+    model.add(Dense(128))
+    model.add(LeakyReLU(alpha=0.2))
+    model.add(Dense(128))
+    model.add(LeakyReLU(alpha=0.2))
+    model.add(Dense(1, activation='sigmoid'))
+        
+    model.summary()
+        
+    img = Input(shape=self.img_shape)
+    validity = model(img)
+
+    return Model(img, validity)
+
+def train(self, epochs, batch_size=128, metrics_update=50, save_images=100, save_model=2000):
+
+    X_train = np.array(images)
+    X_train = (X_train.astype(np.float32) - 127.5) / 127.5
+
+    half_batch = int(batch_size / 2)
+        
+    mean_d_loss=[0,0]
+    mean_g_loss=0
+
+    for epoch in range(epochs):
+        idx = np.random.randint(0, X_train.shape[0], half_batch)
+        imgs = X_train[idx]
+
+        noise = np.random.normal(0, 1, (half_batch, self.noise_size))
+        gen_imgs = self.generator.predict(noise)
+
+
+            
+
+        d_loss = 0.5 * np.add(self.discriminator.train_on_batch(imgs, np.ones((half_batch, 1))),
+                                  self.discriminator.train_on_batch(gen_imgs, np.zeros((half_batch, 1))))
+
+
+        noise = np.random.normal(0, 1, (batch_size, self.noise_size))
+
+        valid_y = np.array([1] * batch_size)
+        g_loss = self.combined.train_on_batch(noise, valid_y)
+            
+        mean_d_loss[0] += d_loss[0]
+        mean_d_loss[1] += d_loss[1]
+        mean_g_loss += g_loss
+            
+
+        if epoch % metrics_update == 0:
+            print ("%d [Discriminator loss: %f, acc.: %.2f%%] [Generator loss: %f]" % (epoch, mean_d_loss[0]/metrics_update, 100*mean_d_loss[1]/metrics_update, mean_g_loss/metrics_update))
+            mean_d_loss=[0,0]
+            mean_g_loss=0
+            
+        if epoch % save_images == 0:
+            self.save_images(epoch)
+            
+
+        if epoch % save_model == 0:
+            self.generator.save("kaggle/working/results/generators/generator_%d" % epoch)
+            self.discriminator.save("kaggle/working/results/discriminators/discriminator_%d" % epoch)
+
+
+def save_images(self, epoch):
+    noise = np.random.normal(0, 1, (25, self.noise_size))
+    gen_imgs = self.generator.predict(noise)
+        
+
+    gen_imgs = 0.5 * gen_imgs + 0.5
+
+    fig, axs = plt.subplots(5,5, figsize = (8,8))
+
+    for i in range(5):
+        for j in range(5):
+            axs[i,j].imshow(gen_imgs[5*i+j])
+            axs[i,j].axis('off')
+
+    plt.show()
+        
+    fig.savefig("kaggle/working/results/pandaS_%d.png" % epoch)
+    plt.close()