GUI added, core code altered to be more modular for the purpose of GUI

events

Author: fighder

arg_handler.py

@@ -2,7 +2,7 @@
 import sys
 
 parse = argparse.ArgumentParser()
-parse.add_argument("-o",default="default")
+parse.add_argument("-o",default="color")
 parse.add_argument("-emoji",nargs='?',const=True,default=False)
 parse.add_argument("-i",type=float,default=1.0)
 parse.add_argument("-minframes",type=int,default=24)
@@ -12,7 +12,7 @@
 class rgbif_args():
     global parse
     input_path = r"\Desktop\input.gif"
-    operator = "default"
+    operator = "color"
     output_path = "\\Desktop\\output_{0}.gif"
     emoji = False
     intensity = 1.0

rgbif.py

@@ -4,24 +4,18 @@
 from os import path
 import requests
 import arg_handler
-from pygifsicle import optimize
 
-my_arg_handler = arg_handler.rgbif_args()
+input_gif_path = "input.gif"
 
-input_gif_path = my_arg_handler.input_path
+output_gif_path = "output.gif"
 
-output_gif_path = my_arg_handler.output_path
+operator = "color"
 
-operator = my_arg_handler.operator
+emoji = False
 
-emoji = my_arg_handler.emoji
+minimum_frames = 24
 
-minimum_frames = my_arg_handler.minimum_frames
-
-intensity = my_arg_handler.intensity
-
-imgs = ImageList()
-single_gif = Image()
+intensity = 1.0
 
 def isLocal(uri):
     if path.isfile(uri):
@@ -34,79 +28,90 @@ def scrape(imgURL):
     img_data = Blob(res.content)
     return img_data
 
-def extendImageToMinimumFrames(img):
+def extendImageToMinimumFrames(img,min_frames):
     extendedImg = ImageList()
-    while len(extendedImg) < minimum_frames:
+    while len(extendedImg) < min_frames:
         for frame in img:
             extendedImg.append(frame)
-        #print(len(extendedImg))
     return extendedImg
 
-def applyRGB(operator_string):
-    filterlist = ImageList()
-    total_frames = len(imgs)
-    #print(total_frames)
-    for (i,frame) in enumerate(imgs):
+def rgbFrames(src_imagelist,src_image_size,operator_string,intensity):
+    print(intensity,operator_string)
+    processed_imagelist = ImageList()
+    total_frames = len(src_imagelist)
+ 
+    for (i,frame) in enumerate(src_imagelist):
         percent = float(i)/float(total_frames-1)
-        sH = 0.5*math.sin(percent*math.pi*2)+0.5
-        sS = 0.5*intensity*math.sin(percent*math.pi*2*10)+0.5
-        sL = 0.25*math.sin(percent*math.pi*4)+0.5
-        #
-        h = sH
-        s = sS
-        l = sL
+        h = 0.5*math.sin(percent*math.pi*2)+0.5
+        s = intensity*(0.5*math.sin(percent*math.pi*2*10)+0.5)
+        l = 0.25*math.sin(percent*math.pi*4)+0.5
+
         c = ColorHSL(h,s,l)
 
-        filter = Image(Geometry(single_gif.columns(),single_gif.rows()),c)
+        filter = Image(Geometry(src_image_size.columns(),src_image_size.rows()),c)
 
         if operator_string == "color":
             frame.composite(filter, 0,0,CompositeOperator.ColorizeCompositeOp)
         elif operator_string == "hue": 
             frame.composite(filter, 0,0,CompositeOperator.HueCompositeOp)
         elif operator_string == "overlay":    
             frame.composite(filter, 0,0,CompositeOperator.OverlayCompositeOp)
-        elif operator_string == "diff":
+        elif operator_string == "difference":
             frame.composite(filter, 0,0,CompositeOperator.DifferenceCompositeOp)
         elif operator_string == "dissolve":    
             frame.composite(filter, 0,0,CompositeOperator.DissolveCompositeOp)
         elif operator_string == "multiply":    
             frame.composite(filter, 0,0,CompositeOperator.MultiplyCompositeOp)
 
         frame.transparent(c)
-        filterlist.append(frame)
-    return filterlist
+        processed_imagelist.append(frame)
 
-if __name__ == "__main__":
-    if not isLocal(input_gif_path):
-        scraped_data = scrape(input_gif_path)
-        single_gif = Image(scraped_data)
-        imgs.readImages(scraped_data)
-    else:
-        single_gif = Image(input_gif_path)
-        imgs.readImages(input_gif_path)
-
-    if len(imgs) < minimum_frames:
-        imgs = extendImageToMinimumFrames(imgs)
-
-    if operator == "default":
-        new_gif_color = applyRGB("color")
-        new_gif_hue = applyRGB("hue")
-        #
-        if emoji:
-            new_gif_color.scaleImages(Geometry(48,48))
-            new_gif_hue.scaleImages(Geometry(48,48))
-        #
-        new_gif_color.writeImages(r"\Desktop\output_color.gif")
-        new_gif_hue.writeImages(r"\Desktop\output_hue.gif")
-        #
-        #optimize(r"\Desktop\output_color.gif")
-        #optimize(r"\Desktop\output_hue.gif")
+    return processed_imagelist
+
+def creatRGBIF(uri="input.gif",min_frames=24,operation="color",intensity=1,emoji=False,output_path="output.gif"):
+    input_gif_imagelist = ImageList()
+    input_gif_single_frame = Image()
+
+    #check if input path directs to an existing local file, else interpret the path as an url and retrieve the gif data online
+    if not isLocal(uri):
+        scraped_data = scrape(uri)
+        input_gif_single_frame = Image(scraped_data)
+        input_gif_imagelist.readImages(scraped_data)
     else:
-        new_gif = applyRGB(operator)
-        #
-        if emoji:
-            new_gif.scaleImages(Geometry(48,48))
-        #
-        new_gif.writeImages(output_gif_path)
-        #
-        #optimize(output_gif_path)
+        input_gif_single_frame = Image(uri)
+        input_gif_imagelist.readImages(uri)
+
+    #extend the gif till it reaches the minimum amount of frames
+    if len(input_gif_imagelist) < min_frames:
+        input_gif_imagelist = extendImageToMinimumFrames(input_gif_imagelist,min_frames)
+
+    output_gif_imagelist = rgbFrames(input_gif_imagelist,input_gif_single_frame,operation,intensity)
+
+    if emoji:
+        output_gif_imagelist.scaleImages(Geometry(48,48))
+
+    if not output_path.endswith(".gif"):
+        output_path += ".gif"
+
+    output_gif_imagelist.writeImages(output_path)
+
+
+
+if __name__ == "__main__":
+
+    #if this script is ran in a console, assign command line arguments
+    my_arg_handler = arg_handler.rgbif_args()
+
+    input_gif_path = my_arg_handler.input_path
+
+    output_gif_path = my_arg_handler.output_path
+
+    operator = my_arg_handler.operator
+
+    emoji = my_arg_handler.emoji
+
+    minimum_frames = my_arg_handler.minimum_frames
+
+    intensity = my_arg_handler.intensity
+    #
+    creatRGBIF(uri=input_gif_path,min_frames=minimum_frames,operation=operator,intensity=intensity,emoji=emoji,output_path=output_gif_path)

rgbif_gui.py

@@ -0,0 +1,105 @@
+from tkinter import *
+from tkinter import filedialog
+from rgbif import input_gif_path, output_gif_path, operator,emoji, minimum_frames, intensity,creatRGBIF
+import os
+
+supported_file_types = [
+    ("All Format",".*"),
+    ("BMP",".bmp"),
+    ("GIF",".gif"),
+    ("JPEG",".jpeg"),
+    ("JPEG",".jpg"),
+    ("MNG",".mng"),
+    ("MIFF",".miff"),
+    ("PNG",".png"),
+    ("TIFF",".tiff"),
+    ("TIFF",".tif"),
+]
+
+def browse_file():
+    return filedialog.askopenfilename(parent=root,initialdir=os.getcwd(),filetypes=supported_file_types)
+
+def save_as():
+    return filedialog.asksaveasfilename(parent=root,initialdir=os.getcwd(),filetypes=[("GIF",".gif")])
+
+if __name__ == "__main__":
+
+    root = Tk()
+
+    root.title("rgbif.exe")
+
+    #input GUI
+    input_gif_path_var = StringVar()
+    input_gif_path_var.set("input.gif")
+    input_gif_path_gui_dir_field = Entry(root, text=input_gif_path_var)
+    input_gif_path_gui_dir_field.grid(row=0,column=0,columnspan=10,sticky=W+E,padx=10,pady=10)
+
+    inputput_gif_path_browse_btn = Button(root,width=15,text="Select Input",command=lambda : input_gif_path_var.set(browse_file()))
+    inputput_gif_path_browse_btn.grid(row=0,column=11,sticky=E,padx=5,pady=10)
+    #
+
+    #output GUI
+    output_gif_path_var = StringVar()
+    output_gif_path_var.set("output.gif")
+    output_gif_path_gui_dir_field = Entry(root, text=output_gif_path_var)
+    output_gif_path_gui_dir_field.grid(row=1,column=0,columnspan=10,padx=10,sticky=W+E,pady=10)
+
+    output_gif_path_browse_btn = Button(root,width = 15,text="Select Output",command=lambda : output_gif_path_var.set(save_as()))
+    output_gif_path_browse_btn.grid(row=1,column=11,sticky=E,padx=5,pady=10)
+    #
+
+    #operator GUI
+    operator_options=[
+        "color",
+        "hue",
+        "overlay",
+        "difference",
+        "dissolve",
+        "multiply"
+    ]
+
+    operator_var = StringVar()
+    operator_var.set(operator_options[0])
+
+    operator_label = Label(root,text="Operations")
+    operator_label.grid(row=2,column=0,sticky=W,padx=5,pady=5)
+
+    operator_gui_dropdown_value = OptionMenu(root,operator_var,*operator_options)
+    operator_gui_dropdown_value.grid(row=2,column=1,sticky=W,pady=5)
+    #
+    
+    #other options GUI
+    minimum_frames_label = Label(root,text="minimum frames")
+    minimum_frames_label.grid(row=3,column=0,sticky=W,padx=5,pady=5)
+
+    minimum_frames_gui_input_field = Entry(root,width=5)
+    minimum_frames_gui_input_field.insert(0,24)
+    minimum_frames_gui_input_field.grid(row=3,column=1,columnspan=1,sticky=W,pady=5)
+
+    intensity_label = Label(root,text="intensity")
+    intensity_label.grid(row=3,column=2,sticky=W,padx=5,pady=5)
+
+    intensity_gui_input_field = Entry(root,width=5)
+    intensity_gui_input_field.insert(0,1.0)
+    intensity_gui_input_field.grid(row=3,column=3,columnspan=1,sticky=W,pady=5)
+
+    emoji_var = BooleanVar()
+    emoji_label = Label(root,text="emoji")
+    emoji_label.grid(row=3,column=4,sticky=W,padx=5,pady=5)
+
+    emoji_gui_toggle = Checkbutton(root,variable=emoji_var)
+    emoji_gui_toggle.grid(row=3,column=5,sticky=W,padx=5,pady=5)
+    #
+
+    #covert button
+    convert_btn = Button(root,text="Convert", command=lambda:creatRGBIF(
+        uri=input_gif_path_gui_dir_field.get(),
+        operation=operator_var.get(),
+        min_frames=int(minimum_frames_gui_input_field.get()),
+        intensity=float(intensity_gui_input_field.get()),
+        emoji=emoji_var.get(),
+        output_path=output_gif_path_gui_dir_field.get()
+        ))
+    convert_btn.grid(row=4, column=0,columnspan=1, sticky=W,padx=5, pady=5)
+
+    root.mainloop()