imdiff 0.4.2__tar.gz → 0.4.4__tar.gz

{imdiff-0.4.2 → imdiff-0.4.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: imdiff
-Version: 0.4.2
+Version: 0.4.4
 Summary: Compare image files in different directories
 Author-email: "John T. Goetz" <theodore.goetz@gmail.com>
 Project-URL: homepage, https://gitlab.com/johngoetz/imdiff

{imdiff-0.4.2 → imdiff-0.4.4}/imdiff/gui/file_list_frame.py

@@ -270,7 +270,7 @@ class FileListFrame(ttk.Frame):
             diff_info = 'similar' if nrmse < 0.02 else 'different'
             category = '~' if nrmse < 0.02 else 'D'
 
-        return file_path, category, diff_info
+        return file_path, category, diff_info, comparator
 
     @separate_thread
     def process_files(self):
@@ -286,7 +286,8 @@ class FileListFrame(ttk.Frame):
                     jobs.append(executor.submit(
                         FileListFrame.get_diff_info, file_path, self.files[file_path]))
                 for job in concurrent.futures.as_completed(jobs):
-                    file_path, category, diff_info = job.result()
+                    file_path, category, diff_info, icmp = job.result()
+                    self.files[file_path] = icmp
                     self.file_properties_queue.put((file_path, category, diff_info))
                 self.file_properties_queue.status = IterableQueue.Status.Complete
             finally:
@@ -393,7 +394,8 @@ class FileListFrame(ttk.Frame):
             return
 
         res = FileListFrame.get_diff_info(file_path, self.files[file_path])
-        file_path, category, diff_info = res
+        file_path, category, diff_info, icmp = res
+        self.files[file_path] = icmp
         self.set_file_properties(file_path, category, diff_info)
 
     def sort_filepaths(self, nparts, reverse):

{imdiff-0.4.2 → imdiff-0.4.4}/imdiff/gui/image_canvas.py

@@ -61,6 +61,31 @@ class ImageCanvas(tk.Canvas):
         self.image = image
         self.after_idle(self.update_image)
 
+    def swap_image(self, image):
+        """Swap displayed image without clearing canvas, to avoid flicker."""
+        log.debug(f'[{self.label}] swap image (setting to {image})')
+        if image is None:
+            self.clear()
+            return
+        self.image = image
+        # Reset scaled image to force recalculation
+        self.scaled_image = None
+        # Synchronously update display
+        self.update_scaled_image()
+        # Create PhotoImage before modifying canvas
+        if self.scaled_image:
+            new_tkimage = ImageTk.PhotoImage(self.scaled_image)
+            if self.image_id:
+                # Update existing canvas item - this is atomic and won't flicker
+                self.itemconfig(self.image_id, image=new_tkimage)
+            else:
+                self.image_id = self.create_image(
+                    self.border, self.border, image=new_tkimage, anchor='nw'
+                )
+            # Keep reference to prevent garbage collection
+            self.tkimage = new_tkimage
+            self.update_layout()
+
     def update_scaled_image(self):
         log.debug(f'[{self.label}] update scaled image (image: {self.image})')
         self.scaled_image_updated = False
@@ -155,3 +180,6 @@ class ImageCanvas(tk.Canvas):
         if pos is not None:
             self.position = pos
         self.update_image()
+
+    def raise_to_front(self):
+        self.tk.call('raise', self)

{imdiff-0.4.2 → imdiff-0.4.4}/imdiff/gui/image_frame.py

@@ -1,7 +1,5 @@
 import logging
 import platform
-import multiprocessing
-import time
 
 import tkinter as tk
 import ttkbootstrap as ttk
@@ -80,11 +78,18 @@ class ImageFrame(ttk.Frame):
         )
 
         self.image_frame = ttk.Frame(self)
-        self.images = {
+        self.canvases = {
             'left': ImageCanvas(self.image_frame, 'left'),
             'right': ImageCanvas(self.image_frame, 'right'),
             'diff': ImageCanvas(self.image_frame, 'diff'),
         }
+        self.images = {
+            'left': None,
+            'right': None,
+            'diff': None,
+        }
+
+        self.current_top_image = 'left'
 
         self.comparator = None
         self.button_zoom_fit_if_larger.invoke()
@@ -145,15 +150,15 @@ class ImageFrame(ttk.Frame):
 
     def layout_images(self):
         if platform.system() == 'Linux':
-            mouse_wheel_seqs = ('<Button-4>', '<Button-5>')
+            mouse_wheel_seqs = ('<Button-4>', '<Button-5>', '<MouseWheel>',)
         else:
             mouse_wheel_seqs = ('<MouseWheel>',)
 
         n = self.image_layout_style.get()
         if n == 3:
-            self.images['left'].grid(column=0, row=0, sticky='nsew')
-            self.images['right'].grid(column=1, row=0, sticky='nsew')
-            self.images['diff'].grid(column=2, row=0, sticky='nsew')
+            self.canvases['left'].grid(column=0, row=0, sticky='nsew')
+            self.canvases['right'].grid(column=1, row=0, sticky='nsew')
+            self.canvases['diff'].grid(column=2, row=0, sticky='nsew')
 
             self.image_frame.columnconfigure(0, weight=1)
             self.image_frame.columnconfigure(1, weight=1)
@@ -161,78 +166,81 @@ class ImageFrame(ttk.Frame):
 
             for seq in mouse_wheel_seqs:
                 self.image_frame.unbind(seq)
-                for image in self.images.values():
-                    image.unbind(seq)
+                for canvas in self.canvases.values():
+                    canvas.unbind(seq)
 
         elif n == 2:
-            self.images['left'].grid(column=0, row=0, sticky='nsew')
-            self.images['right'].grid_forget()
-            self.images['diff'].grid(column=1, row=0, sticky='nsew')
+            # Use single 'left' canvas for swapping left/right, plus diff canvas
+            self.canvases['left'].grid(column=0, row=0, sticky='nsew')
+            self.canvases['right'].grid_forget()
+            self.canvases['diff'].grid(column=1, row=0, sticky='nsew')
 
             self.image_frame.columnconfigure(0, weight=1)
             self.image_frame.columnconfigure(1, weight=1)
             self.image_frame.columnconfigure(2, weight=0)
 
+            if self.current_top_image not in ('left', 'right'):
+                self.current_top_image = 'left'
+            self.canvases['left'].swap_image(self.images[self.current_top_image])
+
             for seq in mouse_wheel_seqs:
                 self.image_frame.bind(seq, self.on_mouse_wheel)
-                for image in self.images.values():
-                    image.bind(seq, self.on_mouse_wheel)
+                for canvas in self.canvases.values():
+                    canvas.bind(seq, self.on_mouse_wheel, add='+')
 
         else:
             assert n == 1
-            self.images['left'].grid(column=0, row=0, sticky='nsew')
-            self.images['right'].grid_forget()
-            self.images['diff'].grid_forget()
+            # Use single 'left' canvas for swapping all three images
+            self.canvases['left'].grid(column=0, row=0, sticky='nsew')
+            self.canvases['right'].grid_forget()
+            self.canvases['diff'].grid_forget()
 
             self.image_frame.columnconfigure(0, weight=1)
             self.image_frame.columnconfigure(1, weight=0)
             self.image_frame.columnconfigure(2, weight=0)
 
+            self.canvases['left'].swap_image(self.images[self.current_top_image])
+
             for seq in mouse_wheel_seqs:
                 self.image_frame.bind(seq, self.on_mouse_wheel)
-                for image in self.images.values():
-                    image.bind(seq, self.on_mouse_wheel)
+                for canvas in self.canvases.values():
+                    canvas.bind(seq, self.on_mouse_wheel, add='+')
 
     def bind_events(self):
-        for key in self.images.keys():
-            for otherkey in set(self.images.keys()) - {key}:
-                self.images[key].bind(
-                    '<Button1-Motion>', self.images[otherkey].on_motion, add='+'
+        for key in self.canvases.keys():
+            for otherkey in set(self.canvases.keys()) - {key}:
+                self.canvases[key].bind(
+                    '<Button1-Motion>', self.canvases[otherkey].on_motion, add='+'
                 )
-                self.images[key].bind(
-                    '<ButtonRelease-1>', self.images[otherkey].on_left_up, add='+'
+                self.canvases[key].bind(
+                    '<ButtonRelease-1>', self.canvases[otherkey].on_left_up, add='+'
                 )
 
     def on_mouse_wheel(self, evt):
-        if platform.system() == 'Linux':
-            mouse_wheel_up = evt.num == 5
-        else:
+        if evt.type == tk.EventType.MouseWheel:
             mouse_wheel_up = evt.delta > 0
+        else:
+            mouse_wheel_up = evt.num == 5
 
         n = self.image_layout_style.get()
         if n == 2:
-            if self.images['left'].grid_info():
-                self.images['left'].grid_forget()
-                self.images['right'].grid(column=0, row=0, sticky='nsew')
+            # Toggle between left and right
+            if self.current_top_image == 'left':
+                self.current_top_image = 'right'
             else:
-                assert self.images['right'].grid_info()
-                self.images['left'].grid(column=0, row=0, sticky='nsew')
-                self.images['right'].grid_forget()
+                self.current_top_image = 'left'
         else:
             assert n == 1
-            if self.images['left'].grid_info():
-                next_image = 'right' if mouse_wheel_up else 'diff'
-                self.images['left'].grid_forget()
-                self.images[next_image].grid(column=0, row=0, sticky='nsew')
-            elif self.images['right'].grid_info():
-                next_image = 'diff' if mouse_wheel_up else 'left'
-                self.images['right'].grid_forget()
-                self.images[next_image].grid(column=0, row=0, sticky='nsew')
+            # Cycle through left -> right -> diff -> left (or reverse)
+            cycle = ['left', 'right', 'diff']
+            current_idx = cycle.index(self.current_top_image)
+            if mouse_wheel_up:
+                next_idx = (current_idx + 1) % 3
             else:
-                assert self.images['diff'].grid_info()
-                next_image = 'left' if mouse_wheel_up else 'right'
-                self.images['diff'].grid_forget()
-                self.images[next_image].grid(column=0, row=0, sticky='nsew')
+                next_idx = (current_idx - 1) % 3
+            self.current_top_image = cycle[next_idx]
+
+        self.canvases['left'].swap_image(self.images[self.current_top_image])
 
     def minsize(self):
         width = (
@@ -251,8 +259,8 @@ class ImageFrame(ttk.Frame):
         self.zoom(ImageScaling.Mode.Fit, factor=1, shrink=True, expand=False)
 
     def zoom(self, mode, factor=1, shrink=True, expand=True):
-        for image in self.images.values():
-            image.zoom(mode, factor=factor, shrink=shrink, expand=expand)
+        for canvas in self.canvases.values():
+            canvas.zoom(mode, factor=factor, shrink=shrink, expand=expand)
 
     def post_zoom_menu(self):
         pos = Coordinates(
@@ -264,30 +272,40 @@ class ImageFrame(ttk.Frame):
     def show_diff(self):
         if self.high_contrast.get():
             if self.comparator:
-                self.images['diff'].scaled_image = None
-                self.images['diff'].load_image(self.comparator.high_contrast_diff)
+                self.images['diff'] = self.comparator.high_contrast_diff
+                self.canvases['diff'].scaled_image = None
+                self.canvases['diff'].swap_image(self.images['diff'])
         else:
             if self.comparator:
-                self.images['diff'].scaled_image = None
-                self.images['diff'].load_image(self.comparator.diff)
-
-    @separate_thread
-    def load_images(self, left, right):
-        self.comparator = ImageComparator(left, right)
-        self.images['left'].load_image(self.comparator.left)
-        self.images['right'].load_image(self.comparator.right)
-        self.show_diff()
+                self.images['diff'] = self.comparator.diff
+                self.canvases['diff'].scaled_image = None
+                self.canvases['diff'].swap_image(self.images['diff'])
+        # In mode 1, if diff is currently shown on the left canvas, update it
+        n = self.image_layout_style.get()
+        if n == 1 and self.current_top_image == 'diff':
+            self.canvases['left'].swap_image(self.images[self.current_top_image])
 
     @separate_thread
     def load_comparator(self, comparator):
         self.comparator = comparator
-        self.images['left'].load_image(self.comparator.left)
-        self.images['right'].load_image(self.comparator.right)
+        self.images['left'] = self.comparator.left
+        self.images['right'] = self.comparator.right
         self.show_diff()
+        # In modes 1 and 2, update the displayed image on the left canvas
+        n = self.image_layout_style.get()
+        if n in (1, 2):
+            self.canvases['left'].swap_image(self.images[self.current_top_image])
+        else:
+            for loc in ('left', 'right', 'diff'):
+                self.canvases[loc].swap_image(self.images[loc])
+
+    def load_images(self, left, right):
+        comparator = ImageComparator(left, right)
+        self.load_comparator(comparator)
 
     def clear(self):
-        for image in self.images.values():
-            self.after_idle(image.clear)
+        for canvas in self.canvases.values():
+            self.after_idle(canvas.clear)
 
     def delete(self):
         if self.comparator:
@@ -311,8 +329,20 @@ class ImageFrame(ttk.Frame):
             log.info(f'COPY: {left_file} -> {right_file}')
             self.comparator.copy_left_to_right()
             if self.comparator.right:
-                self.images['right'].load_image(self.comparator.right)
-                self.images['diff'].load_image(self.comparator.diff)
+                self.images['right'] = self.comparator.right
+                if self.high_contrast:
+                    self.images['diff'] = self.comparator.high_contrast_diff
+                else:
+                    self.images['diff'] = self.comparator.diff
+                self.canvases['right'].swap_image(self.images['right'])
+                self.canvases['diff'].swap_image(self.images['diff'])
+                # In modes 1 and 2, update the displayed image on the left canvas
+                n = self.image_layout_style.get()
+                if n in (1, 2) and self.current_top_image in ('right', 'diff'):
+                    self.canvases['left'].swap_image(self.images[self.current_top_image])
+                else:
+                    for loc in ('right', 'diff'):
+                        self.canvases[loc].swap_image(self.images[loc])
             if self.update_item_command:
                 self.update_item_command(right_file, self.comparator)
 
@@ -325,7 +355,18 @@ class ImageFrame(ttk.Frame):
             log.info(f'COPY: {right_file} -> {left_file}')
             self.comparator.copy_right_to_left()
             if self.comparator.left:
-                self.images['left'].load_image(self.comparator.left)
-                self.images['diff'].load_image(self.comparator.diff)
+                self.images['left'] = self.comparator.left
+                if self.high_contrast:
+                    self.images['diff'] = self.comparator.high_contrast_diff
+                else:
+                    self.images['diff'] = self.comparator.diff
+                self.canvases['diff'].load_image(self.comparator.diff)
+                # In modes 1 and 2, update the displayed image on the left canvas
+                n = self.image_layout_style.get()
+                if n in (1, 2) and self.current_top_image in ('left', 'diff'):
+                    self.canvases['left'].swap_image(self.images[self.current_top_image])
+                else:
+                    for loc in ('left', 'diff'):
+                        self.canvases[loc].swap_image(self.images[loc])
             if self.update_item_command:
                 self.update_item_command(left_file, self.comparator)

{imdiff-0.4.2 → imdiff-0.4.4}/imdiff/gui/zoom_menu.py

@@ -62,8 +62,8 @@ class ZoomMenu(TransientMenu):
         )
 
     def post(self, pos):
-        scaling = self.parent.images['left'].scaling
-        scaling_percent = self.parent.images['left'].scaling_percent
+        scaling = self.parent.canvases['left'].scaling
+        scaling_percent = self.parent.canvases['left'].scaling_percent
         self.mode_var.set('FitIfLarger')
         if scaling.mode == ImageScaling.Mode.Original:
             self.mode_var.set('Original')
@@ -112,4 +112,4 @@ class ZoomMenu(TransientMenu):
         self.mode_var.set('Scaled')
 
     def update_scale_var(self):
-        self.scale_var.set(self.parent.images['left'].scaling_percent)
+        self.scale_var.set(self.parent.canvases['left'].scaling_percent)

{imdiff-0.4.2 → imdiff-0.4.4}/imdiff/version.py

@@ -1,2 +1,2 @@
-__version__ = '0.4.2'
+__version__ = '0.4.4'
 version_info = __version__.split('.')

{imdiff-0.4.2 → imdiff-0.4.4}/imdiff.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: imdiff
-Version: 0.4.2
+Version: 0.4.4
 Summary: Compare image files in different directories
 Author-email: "John T. Goetz" <theodore.goetz@gmail.com>
 Project-URL: homepage, https://gitlab.com/johngoetz/imdiff