move gui to thread over subprocess

Author: joeyfranck56

correct_images_gui_onefile.spec

@@ -6,11 +6,11 @@ block_cipher = None
 a = Analysis(['scripts\\correct_images_gui.py'],
              pathex=['.'],
              binaries=[],
-             datas=[('exiftool/exiftool.exe', '.'), ('cfg/exiftool.cfg', 'cfg'), ('cfg/reg_config.ini', 'cfg'), ('scripts/correct_images.py', '.')],
+             datas=[('exiftool/exiftool.exe', '.'), ('cfg/exiftool.cfg', 'cfg'), ('cfg/reg_config.ini', 'cfg'), ('sentera_radiometric_corrections_icon.ico', '.')],
              hiddenimports=['pkg_resources.py2_warn'],
              hookspath=[],
              runtime_hooks=[],
-             excludes=['FixTk', 'tcl', 'pyinstaller'],
+             excludes=[],
              win_no_prefer_redirects=False,
              win_private_assemblies=False,
              cipher=block_cipher,
@@ -31,4 +31,4 @@ exe = EXE(pyz,
           upx=False,
           upx_exclude=[],
           runtime_tmpdir=None,
-          console=True )
+          console=False )

imgcorrect/__init__.py

@@ -10,6 +10,7 @@
     correct_images,
 )
 from imgcorrect.io import (
+    TqdmToLogger,
     apply_sensor_settings,
     create_cal_df,
     create_image_df,
@@ -34,4 +35,5 @@
     "move_corrected_images",
     "write_image",
     "copy_exif",
+    "TqdmToLogger",
 ]

imgcorrect/corrections.py

@@ -223,7 +223,7 @@ def get_corrections(
     """
     # Create new `pandas` methods which use `tqdm` progress
     # (can use tqdm_gui, optional kwargs, etc.)
-    tqdm.pandas()
+    tqdm.pandas(unit="image", file=io.TqdmToLogger(logger))
 
     logger.info("ILS corrections: %s", "Disabled" if no_ils_correct else "Enabled")
 

imgcorrect/io.py

@@ -201,3 +201,22 @@ def write_corrections_csv(image_df, cal_df, file):
         (lambda x: os.path.relpath(x, base_dir))
     )
     csv_df.to_csv(file, index=False)
+
+
+class TqdmToLogger:
+    """Redirect tqdm output to a logger instance."""
+
+    def __init__(self, logger, level=logging.INFO):
+        """Initialize instance."""
+        self.logger = logger
+        self.level = level
+
+    def write(self, msg):
+        """Write message to logger."""
+        msg = msg.strip()
+        if msg:
+            self.logger.log(self.level, msg)
+
+    def flush(self):
+        """No-op for flush method."""
+        pass

imgcorrect/metadata.py

@@ -39,6 +39,8 @@ def copy_exif(image_df_row, exiftool_path):
         ]
     command.append(image_df_row.temp_path)
 
-    results = subprocess.run(command, capture_output=True)
+    results = subprocess.run(
+        command, capture_output=True, creationflags=subprocess.CREATE_NO_WINDOW
+    )
     if results.returncode != 0:
         raise ValueError("Exiftool command did not run successfully.")

imgcorrect/thermal_convert.py

@@ -10,6 +10,8 @@
 import numpy as np
 from tqdm import tqdm
 
+from imgcorrect.io import TqdmToLogger
+
 ## 12-bit support requires pip install imagecodecs
 
 logger = logging.getLogger(__name__)
@@ -29,7 +31,7 @@ def convert_thermal(input_path, output_path, exiftool_path):
     logger.info("Converting LWIR images from CentiKelvin(uint16) to Celsius(float32)")
     with tempfile.TemporaryDirectory() as temp_dir:
         # copy image to output location
-        for image in tqdm(images):
+        for image in tqdm(images, unit="image", file=TqdmToLogger(logger)):
 
             if "CAL" not in image:
                 # Copy image to temporary directory
@@ -62,7 +64,11 @@ def convert_thermal(input_path, output_path, exiftool_path):
                     "-all",
                     output_image_path,
                 ]
-                results = subprocess.run(command, capture_output=True)
+                results = subprocess.run(
+                    command,
+                    capture_output=True,
+                    creationflags=subprocess.CREATE_NO_WINDOW,
+                )
                 if results.returncode != 0:
                     raise ValueError("Exiftool command did not run successfully.")
 

pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "imgcorrect"
-version = "2.0.0"
+version = "2.0.1"
 description = "Library to perform various corrections on imagery from supported sensors"
 authors = ["Samuel Williams <sam.williams@sentera.com>", "Joseph Franck <joseph.franck@sentera.com>"]
 

run_gui.bat

@@ -0,0 +1 @@
+python scripts/correct_images_gui.py

scripts/correct_images_gui.py

@@ -1,38 +1,72 @@
+import logging
 import os
-import subprocess
 import sys
+import threading
 import tkinter as tk
 from tkinter import filedialog, messagebox
 
-SCRIPT_PATH = os.path.join(os.path.dirname(__file__), "correct_images.py")
+from imgcorrect import corrections
+
+logger = logging.getLogger(__name__)
+
+
+class TextHandler(logging.Handler):
+    def __init__(self, text_widget):
+        super().__init__()
+        self.text_widget = text_widget
+
+    def emit(self, record):
+        msg = self.format(record)
+        # Get the index of the last line
+        last_line_index = self.text_widget.index("end-2l")
+        last_line_text = self.text_widget.get(last_line_index, "end-1c").strip()
+        if last_line_text and last_line_text[0].isdigit():
+            # Replace the last line
+            self.text_widget.after(
+                0, self.text_widget.delete, last_line_index, "end-1c"
+            )
+            self.text_widget.after(0, self.text_widget.insert, tk.END, msg + "\n")
+        else:
+            self.text_widget.after(0, self.text_widget.insert, tk.END, msg + "\n")
+        self.text_widget.after(0, self.text_widget.see, tk.END)
 
 
 class CorrectImagesApp(tk.Tk):
     def __init__(self):
         super().__init__()
         self.title("Sentera Radiometric Corrections")
-        self.geometry("600x500")
-        self.iconbitmap("sentera_radiometric_corrections_icon.ico")
+        self.geometry("800x500")
+        try:
+            self.iconbitmap(
+                os.path.join(sys._MEIPASS, "sentera_radiometric_corrections_icon.ico")
+            )
+        except Exception:
+            self.iconbitmap("sentera_radiometric_corrections_icon.ico")
         self.create_widgets()
 
     def create_widgets(self):
         row = 0
-        tk.Label(self, text="Input Path").grid(row=row, column=0, sticky="w", padx=15)
+        tk.Label(self, text="Input Path").grid(
+            row=row, column=0, sticky="w", padx=(15, 0)
+        )
         self.input_path_var = tk.StringVar()
         tk.Entry(
-            self, textvariable=self.input_path_var, width=50, justify="right"
-        ).grid(row=row, column=1, sticky="e", padx=(0, 5))
+            self, textvariable=self.input_path_var, width=90, justify="right"
+        ).grid(row=row, column=1, sticky="e")
         self.browse_input_button = tk.Button(
             self, text="Browse", command=self.browse_input
         )
         self.browse_input_button.grid(row=row, column=2)
         row += 1
 
-        tk.Label(self, text="Output Path").grid(row=row, column=0, sticky="w", padx=15)
+        tk.Label(self, text="Output Path").grid(
+            row=row, column=0, sticky="w", padx=(15, 0)
+        )
         self.output_path_var = tk.StringVar()
-        tk.Entry(
-            self, textvariable=self.output_path_var, width=50, justify="right"
-        ).grid(row=row, column=1, sticky="e", padx=(0, 5))
+        self.output_path_text = tk.Entry(
+            self, textvariable=self.output_path_var, width=90, justify="right"
+        )
+        self.output_path_text.grid(row=row, column=1, sticky="e")
         self.browse_output_button = tk.Button(
             self, text="Browse", command=self.browse_output
         )
@@ -62,11 +96,11 @@ def create_widgets(self):
 
         self.exiftool_path_var = tk.StringVar()
         self.exiftool_path_label = tk.Label(self, text="ExifTool Path (optional)")
-        self.exiftool_path_label.grid(row=row, column=0, sticky="w", padx=15)
+        self.exiftool_path_label.grid(row=row, column=0, sticky="w", padx=(15, 0))
         self.exiftool_entry = tk.Entry(
-            self, textvariable=self.exiftool_path_var, width=50, justify="right"
+            self, textvariable=self.exiftool_path_var, width=90, justify="right"
         )
-        self.exiftool_entry.grid(row=row, column=1, sticky="w", padx=(0, 5))
+        self.exiftool_entry.grid(row=row, column=1, sticky="e")
         self.exiftool_path_browse_button = tk.Button(
             self, text="Browse", command=self.browse_exiftool
         )
@@ -92,8 +126,9 @@ def create_widgets(self):
         self.delete_original_var = tk.BooleanVar()
         self.delete_overwrite_checkbutton = tk.Checkbutton(
             self,
-            text="Delete/Overwrite Original Images",
+            text="Delete/Overwrite Original",
             variable=self.delete_original_var,
+            command=self.toggle_overwrite,
         )
         self.delete_overwrite_checkbutton.grid(row=row, column=0, sticky="w", padx=15)
         row += 1
@@ -144,12 +179,24 @@ def toggle_advanced_options(self):
             for widget in widgets:
                 widget.grid()
 
+    def toggle_overwrite(self):
+        if self.delete_original_var.get():
+            self.output_path_var.set(self.input_path_var.get())
+            self.browse_output_button["state"] = "disabled"
+            self.output_path_text["state"] = "disabled"
+        else:
+            self.browse_output_button["state"] = "normal"
+            self.output_path_text["state"] = "normal"
+
     def browse_input(self):
         path = filedialog.askdirectory()
         if path:
             self.input_path_var.set(path)
             # Set output path to input path + '-calibrated'
-            calibrated_path = path.rstrip("/\\") + "-calibrated"
+            if not self.delete_original_var.get():
+                calibrated_path = path.rstrip("/\\") + "-calibrated"
+            else:
+                calibrated_path = path
             self.output_path_var.set(calibrated_path)
             # Scroll input Entry to the end
             entry_widget = self.nametowidget(self.children["!entry"])
@@ -187,94 +234,66 @@ def enable_buttons(self):
         self.exiftool_path_browse_button["state"] = "normal"
 
     def run_correction(self):
-        import threading
 
         self.disable_buttons()
         input_path = self.input_path_var.get()
         if not input_path:
             messagebox.showerror("Error", "Input path is required.")
+            self.enable_buttons()
             return
-        cmd = ["python", "-u", SCRIPT_PATH, input_path]
-        if self.calibration_id_var.get():
-            cmd += ["--calibration_id", self.calibration_id_var.get()]
-        if self.output_path_var.get():
-            cmd += ["--output_path", self.output_path_var.get()]
-        if not self.ils_var.get():
-            cmd.append("--no_ils_correct")
-        if not self.reflectance_var.get():
-            cmd.append("--no_reflectance_correct")
-        if self.all_panels_var.get():
-            cmd.append("--all_panels")
-        if self.delete_original_var.get():
-            cmd.append("--delete_original")
+        calibration_id = self.calibration_id_var.get()
+        output_path = self.output_path_var.get()
+        no_ils_correct = not self.ils_var.get()
+        no_reflectance_correct = not self.reflectance_var.get()
+        all_panels = self.all_panels_var.get()
+        delete_original = self.delete_original_var.get()
+
         if self.exiftool_path_var.get():
-            cmd += ["--exiftool_path", self.exiftool_path_var.get()]
+            exiftool_path = self.exiftool_path_var.get()
         else:
-            cmd += ["--exiftool_path", os.path.join(sys._MEIPASS, "exiftool.exe")]
-        if self.uint16_var.get():
-            cmd.append("--uint16_output")
+            exiftool_path = os.path.join(sys._MEIPASS, "exiftool.exe")
+        uint16_output = self.uint16_var.get()
+
         self.output_text.delete(1.0, tk.END)
-        self.output_text.insert(tk.END, f"Running: {' '.join(cmd)}\n")
 
         os.makedirs(self.output_path_var.get(), exist_ok=True)
 
-        def run_subprocess():
-            try:
-                # Open the output file for writing
-                with open(
-                    os.path.join(
-                        os.path.split(self.output_path_var.get())[0],
-                        f"{os.path.split(self.output_path_var.get())[1]}_corrections_log.txt",
-                    ),
-                    "w",
-                    encoding="utf-8",
-                ) as outfile:
-                    process = subprocess.Popen(
-                        cmd,
-                        stdout=subprocess.PIPE,
-                        stderr=subprocess.PIPE,
-                        text=True,
-                        bufsize=1,
-                    )
-
-                    def read_stdout(stream):
-                        for line in iter(stream.readline, ""):
-                            if line:
-                                self.output_text.after(
-                                    0, self.output_text.insert, tk.END, line
-                                )
-                                outfile.write(line)
-                                outfile.flush()
-                        stream.close()
-
-                    def read_stderr(stream):
-                        for line in iter(stream.readline, ""):
-                            if line:
-                                self.output_text.after(
-                                    0, self.output_text.delete, 1.0, tk.END
-                                )
-                                self.output_text.after(
-                                    0, self.output_text.insert, tk.END, line
-                                )
-                                outfile.write(line)
-                                outfile.flush()
-                        stream.close()
-
-                    stdout_thread = threading.Thread(
-                        target=read_stdout, args=(process.stdout,)
-                    )
-                    stderr_thread = threading.Thread(
-                        target=read_stderr, args=(process.stderr,)
-                    )
-                    stdout_thread.start()
-                    stderr_thread.start()
-                    stdout_thread.join()
-                    stderr_thread.join()
-            except Exception as e:
-                self.output_text.after(0, self.display_exception, e)
+        def run_corrections():
+            handler = TextHandler(self.output_text)
+            logging.basicConfig(
+                filename=os.path.join(
+                    os.path.split(output_path)[0],
+                    f"{os.path.basename(output_path)}_radiometric_corrections.log",
+                ),
+                level=logging.INFO,
+                format="%(asctime)s %(levelname)s:%(message)s",
+            )
+            logging.getLogger().addHandler(handler)
+            logger.info("Running Corrections")
+            logger.info(f"Input Path: {input_path}")
+            logger.info(f"Output Path: {output_path}")
+            logger.info(f"ExifTool Path: {exiftool_path}")
+            logger.info(f"Reflectance Correction: {not no_reflectance_correct}")
+            logger.info(f"ILS Correction: {not no_ils_correct}")
+            logger.info(f"Calibration ID: {calibration_id}")
+            logger.info(f"All Panels: {all_panels}")
+            logger.info(f"Delete Original: {delete_original}")
+            logger.info(f"UInt16 Output: {uint16_output}")
+            corrections.correct_images(
+                input_path,
+                calibration_id,
+                output_path,
+                no_ils_correct,
+                no_reflectance_correct,
+                all_panels,
+                delete_original,
+                exiftool_path,
+                uint16_output,
+            )
             self.enable_buttons()
+            logger.info("Corrections complete!")
 
-        threading.Thread(target=run_subprocess, daemon=True).start()
+        threading.Thread(target=run_corrections, daemon=True).start()
 
     def display_output(self, stdout, stderr):
         if stdout: