GIF and Video Processing

app.py

@@ -1,76 +1,53 @@
 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
 
-model = hub.Module(name='U2Net')
+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 GIF(fname,pixel_size):
-    gif = Image.open(fname)
-    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)
-    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 = []
-<<<<<<< HEAD
-    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
-=======
-    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('cache.gif', append_images=frames, save_all=True, loop=1)
-    return Image.open('cache.gif')
->>>>>>> a2e31df8118400de0782a9feb55255620b93cd83
 
-def initilize(image,pixel_size,checkbox1):
-    if image.name.endswith('.gif'):
-      GIF(image.name,pixel_size)
+def initilize(media,pixel_size,checkbox1):
+    #Author:  Alican Akca
+    if media.name.endswith('.gif'):
+      return Media().split(media.name,pixel_size)
+    elif media.name.endswith('.mp4'):
+      return Media().split(media.name,pixel_size)
     else:
-      image = Image.open(image.name).convert("RGB")
-      image = cv2.cvtColor(np.asarray(face2paint(model, image)), cv2.COLOR_BGR2RGB)
+      media = Image.open(media.name).convert("RGB")
+      media = cv2.cvtColor(np.asarray(face2paint(model, media)), cv2.COLOR_BGR2RGB)
       if checkbox1:
-        result = model.Segmentation(
-        images=[image],
-        paths=None,
-        batch_size=1,
-        input_size=320,  
-        output_dir='output',
-        visualization=True)
+        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 = image)
+                                background_image = media)
       else:
-        result = pixL().toThePixL([image], pixel_size)
-      return Image.fromarray(result)
+        result = pixL().toThePixL([media], pixel_size)
+        result.save('cache.png')
+      return [Image.fromarray(result), 'cache.png']
 
-inputs = ["file",
+inputs = [,
                gr.Slider(4, 100, value=12, step = 2, label="Pixel Size"),
                gr.Checkbox(label="Object-Oriented Inference", value=False)]
-outputs = [gr.Image(type="pil",label="Front")]
-
+outputs = [gr.Video(label="Pixed Media"),
+           gr.File(label="Download")]
+title = "Pixera: Create your own Pixel Art"
+description = """Mobile applications will have released soon. ^^ """
 gr.Interface(fn = initilize,
                     inputs = inputs,
                     outputs = outputs).launch()

methods/img2pixl.py

@@ -1,71 +1,61 @@
+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
 
-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
+warnings.filterwarnings("ignore")
 
-  def preprocess(self):
-    for image in self.images:
+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()
 
-      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)
+def initilize(media,pixel_size,checkbox1):
+    #Author:  Alican Akca
+    if media.name.endswith('.gif'):
+      return Media().split(media.name,pixel_size)
+    elif media.name.endswith('.mp4'):
+      return Media().split(media.name,pixel_size)
+    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 = """Mobile applications will have released soon ^^ """
+
+gr.Interface(fn = initilize,
+                    inputs = inputs,
+                    outputs = outputs,
+                    title=title,
+                    description=description).launch()
 
-    return background

methods/media.py

@@ -0,0 +1,32 @@
+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):
+        media = cv2.VideoCapture(fname)
+        frames = []
+        while True:
+            ret, cv2Image = media.read()
+            if not ret:
+                break
+            frames.append(cv2Image)
+        frames = pixL().toThePixL(frames, pixel_size)
+        imageio.mimsave('cache.gif', frames)
+        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, 'cache.gif']

requirements.txt

@@ -1,16 +1,7 @@
 pip
 torch
-tensorflow
-Flask
-gunicorn
+gradio
 Pillow
-opencv_python
-google-cloud-storage
-algorithmia
-scikit-video
-tf_slim
-PyYaml
-flask-ngrok
-paddlepaddle
+imageio
 paddlehub
-numpy==1.19.5
+opencv_python