refactor: most of main code

Author: JingShing

script/contrast_and_saturation.py

@@ -1,41 +1,22 @@
 import cv2
-import numpy
+import numpy as np
 import math
 
-def contrast_and_brightness(img, brightness=0 , contrast=100):
+def contrast_and_brightness(img, brightness=0, contrast=100):
     B = brightness / 255.0
-    c = contrast / 255.0 
+    c = contrast / 255.0
     k = math.tan((45 + 44 * c) / 180 * math.pi)
 
-    img = (img - 127.5 * (1 - B)) * k + 127.5 * (1 + B)
-      
-    # values between 0-255
-    img = numpy.clip(img, 0, 255).astype(numpy.uint8)
-    return img
-    
-def saturation_and_lightness(img, lightness, saturation):
-    # origin_img = img
-
-    # astype image and turn to float
-    fImg = img.astype(numpy.float32)
-    fImg = fImg / 255.0
+    adjusted_img = (img - 127.5 * (1 - B)) * k + 127.5 * (1 + B)
+    return np.clip(adjusted_img, 0, 255).astype(np.uint8)
 
-    # color space exchange BGR -> HLS
+def saturation_and_lightness(img, lightness, saturation):
+    fImg = img.astype(np.float32) / 255.0
     hlsImg = cv2.cvtColor(fImg, cv2.COLOR_BGR2HLS)
-    hlsCopy = numpy.copy(hlsImg)
-
-    # lightness = 0 # lightness edited to "1 +/- n %"
-    # saturation = 300 # saturation edited to "1 +/- n %"
-
-    # brightness
-    hlsCopy[:, :, 1] = (1 + lightness / 100.0) * hlsCopy[:, :, 1]
-    hlsCopy[:, :, 1][hlsCopy[:, :, 1] > 1] = 1  # Between 0-1
 
-    # saturation
-    hlsCopy[:, :, 2] = (1 + saturation / 100.0) * hlsCopy[:, :, 2]
-    hlsCopy[:, :, 2][hlsCopy[:, :, 2] > 1] = 1  # Between 0-1
+    # 調整亮度和飽和度
+    hlsImg[:, :, 1] = np.clip(hlsImg[:, :, 1] * (1 + lightness / 100.0), 0, 1)
+    hlsImg[:, :, 2] = np.clip(hlsImg[:, :, 2] * (1 + saturation / 100.0), 0, 1)
 
-    # color space exchange back HLS -> BGR 
-    result_img = cv2.cvtColor(hlsCopy, cv2.COLOR_HLS2BGR)
-    result_img = ((result_img * 255).astype(numpy.uint8))
-    return result_img
+    result_img = (cv2.cvtColor(hlsImg, cv2.COLOR_HLS2BGR) * 255).astype(np.uint8)
+    return result_img

script/display_image.py

@@ -7,25 +7,26 @@
 class Display_image:
     def __init__(self, width=500, height=500):
         pygame.init()
+        self.new_x, self.new_y = 0, 0
+        self.scale_rate = 1
+        self.image_drag = False
         self.display_screen_resize(width, height)
         pygame.display.set_caption("Display Screen")
-        pygame.display.set_icon(pygame.image.load(resource_path("assets\icon\icon.png")))
+        pygame.display.set_icon(pygame.image.load(resource_path("assets/icon/icon.png")))
 
         self.limit_size = [800, 600]
-        self.or_image = pygame.image.load(resource_path(sample_image_path)).convert_alpha()
-        self.image = pygame.image.load(resource_path(sample_image_path)).convert_alpha()
-        self.new_x = 0
-        self.new_y = 0
-        self.scale_rate = 1
+        self.image_path = resource_path(sample_image_path)
+        self.load_initial_image()
+
+    def load_initial_image(self):
+        self.or_image = pygame.image.load(self.image_path).convert_alpha()
+        self.image = self.or_image.copy()
         self.scale_image()
-        self.image_drag = False
 
     def image_load(self, image_path):
-        image_path.replace("\\", "/")
-        file_name = re.split("/", image_path)[-1]
-        file_format = file_name.split('.')[-1]
-        if not file_format in ['mp4', 'avi', 'flv']:
-            self.or_image = pygame.image.load(image_path)
+        image_path = image_path.replace("\\", "/")
+        if not image_path.split('.')[-1] in ['mp4', 'avi', 'flv']:
+            self.or_image = pygame.image.load(image_path).convert_alpha()
             self.scale_image()
 
     def display_screen_resize(self, width=10, height=10, mode=0):
@@ -36,74 +37,58 @@ def display_screen_resize(self, width=10, height=10, mode=0):
             self.display_screen = pygame.display.set_mode(self.image.get_size())
 
     def image_resize_limit(self):
-        self_image_size = self.image.get_size()
-        x_rate = 1
-        y_rate = 1
-        new_rate = 1
-        if self_image_size[0] > self.limit_size[0]:
-            x_rate = self.limit_size[0] / self_image_size[0]
-        if self_image_size[1] > self.limit_size[1]:
-            y_rate = self.limit_size[1] / self_image_size[1]
-        new_rate = min(x_rate, y_rate)
-        self.or_scale_rate = new_rate
-        self.image = pygame.transform.scale(self.or_image, (self_image_size[0]*new_rate, self_image_size[1]*new_rate))
+        img_size = self.image.get_size()
+        x_rate = self.limit_size[0] / img_size[0] if img_size[0] > self.limit_size[0] else 1
+        y_rate = self.limit_size[1] / img_size[1] if img_size[1] > self.limit_size[1] else 1
+        self.scale_rate = min(x_rate, y_rate)
+        self.image = pygame.transform.scale(self.or_image, (int(img_size[0] * self.scale_rate), int(img_size[1] * self.scale_rate)))
         self.scale_image()
 
     def cv_to_pygame(self, cv_img):
-        frame = cv2.cvtColor(cv_img, cv2.COLOR_BGR2RGB)
-        frame = cv2.transpose(frame)
-        frame = pygame.surfarray.make_surface(frame)
-        self.or_image = frame
+        rgb_img = cv2.cvtColor(cv_img, cv2.COLOR_BGR2RGB)
+        self.or_image = pygame.surfarray.make_surface(rgb_img.swapaxes(0, 1))
         self.scale_image()
 
     def display_update(self):
         self.display_screen.fill('black')
-        if self.display_screen.get_size() != self.image.get_size():
-            self.display_screen_resize(mode=1)
         self.display_screen.blit(self.scaled_image, self.scaled_image_rect)
         pygame.display.update()
 
     def scale_image(self):
-        image_size = self.image.get_size()
-        self.scaled_image = pygame.transform.scale(self.or_image, (image_size[0]*self.scale_rate, image_size[1]*self.scale_rate))
-        self.scaled_image_rect = self.scaled_image.get_rect(topleft = (self.new_x, self.new_y))
+        img_size = self.image.get_size()
+        self.scaled_image = pygame.transform.scale(self.or_image, (int(img_size[0] * self.scale_rate), int(img_size[1] * self.scale_rate)))
+        self.scaled_image_rect = self.scaled_image.get_rect(topleft=(self.new_x, self.new_y))
+
+    def handle_events(self):
+        for event in pygame.event.get():
+            if event.type == pygame.QUIT:
+                self.quit()
+            elif event.type == pygame.MOUSEBUTTONDOWN:
+                if event.button == 1 and self.scaled_image_rect.collidepoint(event.pos):
+                    self.image_drag = True
+                elif event.button == 2:
+                    self.reset_image()
+                elif event.button == 4:
+                    self.scale_rate += 0.1
+                    self.scale_image()
+                elif event.button == 5:
+                    self.scale_rate = max(0.1, self.scale_rate - 0.1)
+                    self.scale_image()
+            elif event.type == pygame.MOUSEBUTTONUP and event.button == 1:
+                self.image_drag = False
+            elif event.type == pygame.MOUSEMOTION and self.image_drag:
+                self.scaled_image_rect.move_ip(event.rel)
+                self.new_x, self.new_y = self.scaled_image_rect.topleft
+
+    def reset_image(self):
+        self.new_x, self.new_y, self.scale_rate = 0, 0, 1
+        self.scale_image()
 
     def run(self):
         while True:
-            for event in pygame.event.get():
-                if event.type == pygame.QUIT:
-                    self.quit()
-                elif event.type == pygame.MOUSEBUTTONDOWN:
-                    if event.button == 1:
-                        if self.scaled_image_rect.collidepoint(event.pos):
-                            self.image_drag = True
-                    elif event.button == 2:
-                        self.new_x = 0
-                        self.new_y = 0
-                        self.scale_rate = 1
-                        self.scale_image()
-                    elif event.button == 4:
-                        self.scale_rate += 0.1
-                        self.scale_image()
-                    elif event.button == 5:
-                        self.scale_rate -= 0.1
-                        if self.scale_rate < 0:
-                            self.scale_rate = 0
-                        self.scale_image()
-                    # 1 - left click
-                    # 2 - middle click
-                    # 3 - right click
-                    # 4 - scroll up
-                    # 5 - scroll down
-                elif event.type == pygame.MOUSEBUTTONUP:
-                    self.image_drag = False
-                if event.type == pygame.MOUSEMOTION:
-                    if self.image_drag:
-                        self.scaled_image_rect.move_ip(event.rel)
-                        self.new_x = self.scaled_image_rect[0]
-                        self.new_y = self.scaled_image_rect[1]
+            self.handle_events()
             self.display_update()
 
     def quit(self):
         pygame.quit()
-        sys.exit()
+        sys.exit()

script/gif_process.py

@@ -19,11 +19,6 @@ def gif_edit(path, set_dict):
     img_list = []
     for frame in ImageSequence.Iterator(gif):
         process.update(1)
-        # frame = frame.convert('RGBA')
-        # opencv_img = np.array(frame, dtype=np.uint8)
-        # opencv_img = cv2.cvtColor(opencv_img, cv2.COLOR_RGBA2BGRA)
-
-        # edit area
         frame = transform(frame, set_dict)
 
         cv2.imshow('frame_rendering', frame)

script/gui_helper_new.py

@@ -52,22 +52,14 @@ def only_digit(self, input_str):
         elif input_str[0] == '+' or input_str[0] == '-' or str.isdigit(input_str[0]):
             str_len = len(input_str)
             cmp_str = input_str[1:str_len]
-            # print(cmp_str)
             if str.isdigit(cmp_str) or cmp_str == '':
                 return True
             else:
                 return False
-        # elif str.isdigit(input_str) or input_str == '':
-        #     return True
         else:
             return False
 
     def switch_frame(self, index):
-        # new_frame = frame_class(self)
-        # if self.frame is not None:
-        #     self.frame.destroy()
-        #     del self.frame
-        #     self.frame.kill()
         if self.frame is not None:
             self.frame.grid_forget()
         self.frame_index = index

script/main.py

@@ -1,14 +1,14 @@
 from pixel_converter import *
 from gui_helper_new import *
 from display_image import Display_image
+from threading import Thread
+
+def gui_run(display):
+    gui_helper = Gui_helper_main(display)
+    gui_helper.run()
 
 if __name__ == '__main__':
     display = Display_image()
-    from threading import Thread
-    def gui_run():
-        gui_help = Gui_helper_main(display)
-        gui_help.run()
-    thread1 = Thread(target=gui_run)
-    thread1.setDaemon(True)
+    thread1 = Thread(target=gui_run, args=(display,), daemon=True)
     thread1.start()
-    display.run()
+    display.run()