Duplicate from Alican/pixera

Co-authored-by: Akca <[email protected]>

.gitattributes

@@ -0,0 +1,33 @@
+*.7z filter=lfs diff=lfs merge=lfs -text
+*.arrow filter=lfs diff=lfs merge=lfs -text
+*.bin filter=lfs diff=lfs merge=lfs -text
+*.bz2 filter=lfs diff=lfs merge=lfs -text
+*.ftz filter=lfs diff=lfs merge=lfs -text
+*.gz filter=lfs diff=lfs merge=lfs -text
+*.h5 filter=lfs diff=lfs merge=lfs -text
+*.joblib filter=lfs diff=lfs merge=lfs -text
+*.lfs.* filter=lfs diff=lfs merge=lfs -text
+*.model filter=lfs diff=lfs merge=lfs -text
+*.msgpack filter=lfs diff=lfs merge=lfs -text
+*.npy filter=lfs diff=lfs merge=lfs -text
+*.npz filter=lfs diff=lfs merge=lfs -text
+*.onnx filter=lfs diff=lfs merge=lfs -text
+*.ot filter=lfs diff=lfs merge=lfs -text
+*.parquet filter=lfs diff=lfs merge=lfs -text
+*.pickle filter=lfs diff=lfs merge=lfs -text
+*.pkl filter=lfs diff=lfs merge=lfs -text
+*.pb filter=lfs diff=lfs merge=lfs -text
+*.pt filter=lfs diff=lfs merge=lfs -text
+*.pth filter=lfs diff=lfs merge=lfs -text
+*.rar filter=lfs diff=lfs merge=lfs -text
+saved_model/**/* filter=lfs diff=lfs merge=lfs -text
+*.tar.* filter=lfs diff=lfs merge=lfs -text
+*.tflite filter=lfs diff=lfs merge=lfs -text
+*.tgz filter=lfs diff=lfs merge=lfs -text
+*.wasm filter=lfs diff=lfs merge=lfs -text
+*.xz filter=lfs diff=lfs merge=lfs -text
+*.zip filter=lfs diff=lfs merge=lfs -text
+*.zstandard filter=lfs diff=lfs merge=lfs -text
+*tfevents* filter=lfs diff=lfs merge=lfs -text
+methods/white_box_cartoonizer/saved_models/model-33999.data-00000-of-00001 filter=lfs diff=lfs merge=lfs -text
+examples/pixelArt/white_box_cartoonizer/saved_models/model-33999.data-00000-of-00001 filter=lfs diff=lfs merge=lfs -text

README.md

@@ -0,0 +1,13 @@
+---
+title: Pixera
+emoji: 💻
+colorFrom: gray
+colorTo: blue
+sdk: gradio
+sdk_version: 3.1.1
+app_file: app.py
+pinned: false
+duplicated_from: Alican/pixera
+---
+
+Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

app.py

@@ -0,0 +1,62 @@
+import os
+import cv2
+import torch
+import warnings
+import numpy as np
+import gradio as gr
+import paddlehub as hub
+from PIL import Image
+from methods.img2pixl import pixL
+from examples.pixelArt.combine import combine
+from methods.media import Media
+
+warnings.filterwarnings("ignore")
+
+U2Net = hub.Module(name='U2Net')
+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 initilize(media,pixel_size,checkbox1):
+    #Author:  Alican Akca
+    if media.name.endswith('.gif'):
+      return Media().split(media.name,pixel_size, 'gif')
+    elif media.name.endswith('.mp4'):
+      return None #Media().split(media.name,pixel_size, "video")
+    else:
+      media = Image.open(media.name).convert("RGB")
+      media = cv2.cvtColor(np.asarray(face2paint(model, media)), cv2.COLOR_BGR2RGB)
+      if checkbox1:
+        result = U2Net.Segmentation(images=[media],
+                                    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 = media)
+      else:
+        result = pixL().toThePixL([media], pixel_size)
+      result = Image.fromarray(result)
+      result.save('cache.png')
+      return [None, result, 'cache.png']
+
+inputs = [gr.File(label="Media"),
+          gr.Slider(4, 100, value=12, step = 2, label="Pixel Size"),
+          gr.Checkbox(label="Object-Oriented Inference", value=False)]
+
+outputs = [gr.Video(label="Pixed Media"),
+           gr.Image(label="Pixed Media"),
+           gr.File(label="Download")]
+
+title = "Pixera: Create your own Pixel Art"
+description = """Object-Oriented Inference is currently only available for images. Also, Video Processing has currently suspended."""
+
+gr.Interface(fn = initilize,
+                    inputs = inputs,
+                    outputs = outputs,
+                    title=title,
+                    description=description).launch()
+

examples/pixelArt/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,71 @@
+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.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):
+    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(background).astype(np.uint8)
+    background = cv2.resize(background, (self.ImgW,self.ImgH), interpolation = cv2.INTER_AREA)
+
+    return background

methods/media.py

@@ -0,0 +1,35 @@
+import cv2
+import torch
+import imageio
+from methods.img2pixl import pixL
+
+
+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()
+
+class Media:
+    #Author:  Alican Akca
+    def __init__(self,fname = None,pixel_size = None):
+        self.fname = fname
+        self.pixel_size = pixel_size
+
+    def split(self,fname,pixel_size, mediaType):
+        media = cv2.VideoCapture(fname)
+        frames = []
+        while True:
+            ret, cv2Image = media.read()
+            if not ret:
+                break
+            frames.append(cv2Image)
+        frames = pixL().toThePixL(frames, pixel_size)
+        if mediaType == 'gif':
+            imageio.mimsave('cache.gif', frames)
+            return [None, 'cache.gif', 'cache.gif']       
+        else:
+            output_file = "cache.mp4"
+            out = cv2.VideoWriter(output_file,cv2.VideoWriter_fourcc(*'h264'), 15, (frames[0].shape[1],frames[0].shape[0]))
+            for i in range(len(frames)):
+                out.write(frames[i])
+            out.release()
+            return [output_file, None, output_file]

requirements.txt

@@ -0,0 +1,10 @@
+pip
+torch
+gradio
+Pillow
+imageio
+paddlehub
+torchaudio
+torchvision
+paddlepaddle
+opencv_python

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()