graxpert 3.2.0a0.dev4__py3-none-any.whl

graxpert/ui/right_menu.py

@@ -0,0 +1,315 @@
+import tkinter as tk
+import webbrowser
+from tkinter import messagebox
+
+import customtkinter as ctk
+from customtkinter import CTkFont, CTkImage, CTkLabel, CTkSwitch, CTkTextbox
+from packaging import version
+
+from graxpert.ai_model_handling import bge_ai_models_dir, deconvolution_object_ai_models_dir, deconvolution_stars_ai_models_dir, denoise_ai_models_dir, list_local_versions, list_remote_versions
+from graxpert.application.app import graxpert
+from graxpert.application.app_events import AppEvents
+from graxpert.application.eventbus import eventbus
+from graxpert.localization import _, lang
+from graxpert.resource_utils import resource_image
+from graxpert.s3_secrets import bge_bucket_name, deconvolution_object_bucket_name, deconvolution_stars_bucket_name, denoise_bucket_name
+from graxpert.ui.widgets import GraXpertOptionMenu, GraXpertScrollableFrame, ProcessingStep, ValueSlider, padx, pady
+
+
+class HelpText(CTkTextbox):
+    def __init__(self, master, text="", rows=1, font=None, **kwargs):
+        super().__init__(master, width=250, fg_color="transparent", wrap="word", activate_scrollbars=False, **kwargs)
+        self.configure(height=self._font.metrics("linespace") * rows + 4 * pady)
+        self.insert("0.0", text)
+
+
+class RightFrameBase(GraXpertScrollableFrame):
+    def __init__(self, master, **kwargs):
+        super().__init__(master, **kwargs)
+        self.row = 0
+        self.heading_font = CTkFont(size=15, weight="bold")
+        self.heading_font2 = CTkFont(size=13, weight="bold")
+
+    def nrow(self):
+        self.row += 1
+        return self.row
+
+
+class HelpFrame(RightFrameBase):
+    def __init__(self, master, **kwargs):
+        super().__init__(master, **kwargs)
+
+        self.img = resource_image("GraXpert_LOGO_Hauptvariante.png")
+        self.create_and_place_children()
+        self.setup_layout()
+
+    def _on_destroy(self, event):
+        """This method is called when the widget is destroyed."""
+        if self.img:
+            self.img.close()
+
+    def default_grid(self):
+        return {"column": 0, "row": self.nrow(), "padx": padx, "pady": pady, "sticky": tk.EW}
+
+    def create_and_place_children(self):
+
+        logo = CTkImage(
+            light_image=self.img,
+            dark_image=self.img,
+            size=(225, 111),
+        )
+
+        CTkLabel(self, image=logo, text="").grid(column=0, row=self.nrow(), padx=padx, pady=pady, sticky=tk.NSEW)
+        CTkLabel(self, text=_("Instructions"), font=self.heading_font).grid(column=0, row=self.nrow(), pady=pady, sticky=tk.N)
+
+        ProcessingStep(self, number=1, indent=0, title=_(" Loading")).grid(**self.default_grid())
+        HelpText(self, text=_("Load your image.")).grid(**self.default_grid())
+
+        ProcessingStep(self, number=2, indent=0, title=_(" Stretch Options")).grid(**self.default_grid())
+        HelpText(self, rows=2, text=_("Stretch your image if necessary to reveal gradients.")).grid(**self.default_grid())
+
+        ProcessingStep(self, number=3, indent=0, title=_(" Sample Selection")).grid(**self.default_grid())
+        HelpText(
+            self,
+            rows=5,
+            text=_("Select background points\n  a) manually with left click\n  b) automatically via grid (grid selection)" "\nYou can remove already set points by right clicking on them."),
+        ).grid(**self.default_grid())
+
+        ProcessingStep(self, number=4, indent=0, title=_(" Calculation")).grid(**self.default_grid())
+        HelpText(self, rows=2, text=_("Click on Calculate Background to get the processed image.")).grid(**self.default_grid())
+
+        ProcessingStep(self, number=5, indent=0, title=_(" Saving")).grid(**self.default_grid())
+        HelpText(self, text=_("Save the processed image.")).grid(**self.default_grid())
+
+        CTkLabel(self, text=_("Keybindings"), font=self.heading_font).grid(column=0, row=self.nrow(), pady=pady, sticky=tk.N)
+
+        HelpText(self, text=_("Left click on picture: Set sample point")).grid(**self.default_grid())
+        HelpText(self, rows=2, text=_("Left click on picture + drag: Move picture")).grid(**self.default_grid())
+        HelpText(self, rows=2, text=_("Left click on sample point + drag: Move sample point")).grid(**self.default_grid())
+        HelpText(self, rows=2, text=_("Right click on sample point: Delete sample point")).grid(**self.default_grid())
+        HelpText(self, text=_("Mouse wheel: Zoom")).grid(**self.default_grid())
+        HelpText(self, rows=3, text=_("Ctrl+Z/Y: Undo/Redo sample point")).grid(**self.default_grid())
+
+        CTkLabel(self, text=_("Licenses"), font=self.heading_font).grid(column=0, row=self.nrow(), pady=pady, sticky=tk.N)
+
+        def callback(url):
+            webbrowser.open_new(url)
+
+        row = self.nrow()
+        HelpText(self, text=_("GraXpert is licensed under GPL-3:")).grid(column=0, row=row, padx=padx, pady=pady, sticky=tk.W)
+        url_link_1 = "https://raw.githubusercontent.com/Steffenhir/GraXpert/main/License.md"
+        url_label_1 = CTkLabel(self, text="<Link>", text_color="dodger blue")
+        url_label_1.grid(column=0, row=row, padx=padx, sticky=tk.E)
+        url_label_1.bind("<Button-1>", lambda e: callback(url_link_1))
+
+        row = self.nrow()
+        HelpText(self, rows=2, text=_("Background Extraction AI models are licensed under CC BY-NC-SA:")).grid(column=0, row=row, padx=padx, pady=pady, sticky=tk.W)
+        url_link_2 = "https://raw.githubusercontent.com/Steffenhir/GraXpert/main/licenses/BGE-Model-LICENSE.html"
+        url_label_2 = CTkLabel(self, text="<Link>", text_color="dodger blue")
+        url_label_2.grid(column=0, row=row, padx=padx, sticky=tk.E)
+        url_label_2.bind("<Button-1>", lambda e: callback(url_link_2))
+
+        row = self.nrow()
+        HelpText(self, rows=2, text=_("Deconvolution AI models are licensed under CC BY-NC-SA:")).grid(column=0, row=row, padx=padx, pady=pady, sticky=tk.W)
+        url_link_3 = "https://raw.githubusercontent.com/Steffenhir/GraXpert/main/licenses/Deconvolution-Model-LICENSE.html"
+        url_label_3 = CTkLabel(self, text="<Link>", text_color="dodger blue")
+        url_label_3.grid(column=0, row=row, padx=padx, sticky=tk.E)
+        url_label_3.bind("<Button-1>", lambda e: callback(url_link_3))
+
+        row = self.nrow()
+        HelpText(self, rows=2, text=_("Denoising AI models are licensed under CC BY-NC-SA:")).grid(column=0, row=row, padx=padx, pady=pady, sticky=tk.W)
+        url_link_3 = "https://raw.githubusercontent.com/Steffenhir/GraXpert/main/licenses/Denoise-Model-LICENSE.html"
+        url_label_3 = CTkLabel(self, text="<Link>", text_color="dodger blue")
+        url_label_3.grid(column=0, row=row, padx=padx, sticky=tk.E)
+        url_label_3.bind("<Button-1>", lambda e: callback(url_link_3))
+
+    def setup_layout(self):
+        self.columnconfigure(0, weight=1)
+        self.rowconfigure(0, weight=1)
+
+
+class AdvancedFrame(RightFrameBase):
+    def __init__(self, master, **kwargs):
+        super().__init__(master, **kwargs)
+
+        # sample points
+        self.sample_size = tk.IntVar()
+        self.sample_size.set(graxpert.prefs.sample_size)
+        self.sample_size.trace_add("write", lambda a, b, c: eventbus.emit(AppEvents.SAMPLE_SIZE_CHANGED, {"sample_size": self.sample_size.get()}))
+
+        self.sample_color = tk.IntVar()
+        self.sample_color.set(graxpert.prefs.sample_color)
+        self.sample_color.trace_add("write", lambda a, b, c: eventbus.emit(AppEvents.SAMPLE_COLOR_CHANGED, {"sample_color": self.sample_color.get()}))
+
+        # interpolation
+        self.rbf_kernels = ["thin_plate", "quintic", "cubic", "linear"]
+        self.rbf_kernel = tk.StringVar()
+        self.rbf_kernel.set(graxpert.prefs.RBF_kernel)
+        self.rbf_kernel.trace_add("write", lambda a, b, c: eventbus.emit(AppEvents.RBF_KERNEL_CHANGED, {"RBF_kernel": self.rbf_kernel.get()}))
+
+        self.spline_orders = ["1", "2", "3", "4", "5"]
+        self.spline_order = tk.StringVar()
+        self.spline_order.set(str(graxpert.prefs.spline_order))
+        self.spline_order.trace_add("write", lambda a, b, c: eventbus.emit(AppEvents.SPLINE_ORDER_CHANGED, {"spline_order": int(self.spline_order.get())}))
+
+        self.corr_types = ["Subtraction", "Division"]
+        self.corr_type = tk.StringVar()
+        self.corr_type.set(graxpert.prefs.corr_type)
+        self.corr_type.trace_add("write", lambda a, b, c: eventbus.emit(AppEvents.CORRECTION_TYPE_CHANGED, {"corr_type": self.corr_type.get()}))
+
+        # interface
+        self.langs = ["English", "Deutsch"]
+        self.lang = tk.StringVar()
+        self.lang.set(graxpert.prefs.lang)
+        self.lang.trace_add("write", lambda a, b, c: eventbus.emit(AppEvents.LANGUAGE_CHANGED, {"lang": self.lang.get()}))
+
+        self.scaling = tk.DoubleVar()
+        self.scaling.set(graxpert.prefs.scaling)
+        self.scaling.trace_add("write", self.on_scaling_change)
+
+        # bge ai model
+        bge_remote_versions = list_remote_versions(bge_bucket_name)
+        bge_local_versions = list_local_versions(bge_ai_models_dir)
+        self.bge_ai_options = set([])
+        self.bge_ai_options.update([rv["version"] for rv in bge_remote_versions])
+        self.bge_ai_options.update([lv["version"] for lv in bge_local_versions])
+        self.bge_ai_options = sorted(self.bge_ai_options, key=lambda k: version.parse(k), reverse=True)
+
+        self.bge_ai_version = tk.StringVar(master)
+        self.bge_ai_version.set("None")  # default value
+        if graxpert.prefs.bge_ai_version is not None:
+            self.bge_ai_version.set(graxpert.prefs.bge_ai_version)
+        else:
+            self.bge_ai_options.insert(0, "None")
+        self.bge_ai_version.trace_add("write", lambda a, b, c: eventbus.emit(AppEvents.BGE_AI_VERSION_CHANGED, {"bge_ai_version": self.bge_ai_version.get()}))
+
+        # object deconvolution ai models
+        deconvolution_object_ai_remote_versions = list_remote_versions(deconvolution_object_bucket_name)
+        deconvolution_object_ai_local_versions = list_local_versions(deconvolution_object_ai_models_dir)
+        self.deconvolution_object_ai_options = set([])
+        self.deconvolution_object_ai_options.update([rv["version"] for rv in deconvolution_object_ai_remote_versions])
+        self.deconvolution_object_ai_options.update([lv["version"] for lv in deconvolution_object_ai_local_versions])
+        self.deconvolution_object_ai_options = sorted(self.deconvolution_object_ai_options, key=lambda k: version.parse(k), reverse=True)
+
+        self.deconvolution_object_ai_version = tk.StringVar(master)
+        self.deconvolution_object_ai_version.set("None")  # default value
+        if graxpert.prefs.deconvolution_object_ai_version is not None:
+            self.deconvolution_object_ai_version.set(graxpert.prefs.deconvolution_object_ai_version)
+        else:
+            self.deconvolution_object_ai_options.insert(0, "None")
+        self.deconvolution_object_ai_version.trace_add(
+            "write", lambda a, b, c: eventbus.emit(AppEvents.DECONVOLUTION_OBJECT_AI_VERSION_CHANGED, {"deconvolution_object_ai_version": self.deconvolution_object_ai_version.get()})
+        )
+
+        # stars deconvolution ai models
+        deconvolution_stars_ai_remote_versions = list_remote_versions(deconvolution_stars_bucket_name)
+        deconvolution_stars_ai_local_versions = list_local_versions(deconvolution_stars_ai_models_dir)
+        self.deconvolution_stars_ai_options = set([])
+        self.deconvolution_stars_ai_options.update([rv["version"] for rv in deconvolution_stars_ai_remote_versions])
+        self.deconvolution_stars_ai_options.update([lv["version"] for lv in deconvolution_stars_ai_local_versions])
+        self.deconvolution_stars_ai_options = sorted(self.deconvolution_stars_ai_options, key=lambda k: version.parse(k), reverse=True)
+
+        self.deconvolution_stars_ai_version = tk.StringVar(master)
+        self.deconvolution_stars_ai_version.set("None")  # default value
+        if graxpert.prefs.deconvolution_stars_ai_version is not None:
+            self.deconvolution_stars_ai_version.set(graxpert.prefs.deconvolution_stars_ai_version)
+        else:
+            self.deconvolution_stars_ai_options.insert(0, "None")
+        self.deconvolution_stars_ai_version.trace_add(
+            "write", lambda a, b, c: eventbus.emit(AppEvents.DECONVOLUTION_STARS_AI_VERSION_CHANGED, {"deconvolution_stars_ai_version": self.deconvolution_stars_ai_version.get()})
+        )
+
+        # denoise ai model
+        denoise_remote_versions = list_remote_versions(denoise_bucket_name)
+        denoise_local_versions = list_local_versions(denoise_ai_models_dir)
+        self.denoise_ai_options = set([])
+        self.denoise_ai_options.update([rv["version"] for rv in denoise_remote_versions])
+        self.denoise_ai_options.update([lv["version"] for lv in denoise_local_versions])
+        self.denoise_ai_options = sorted(self.denoise_ai_options, key=lambda k: version.parse(k), reverse=True)
+
+        self.denoise_ai_version = tk.StringVar(master)
+        self.denoise_ai_version.set("None")  # default value
+        if graxpert.prefs.denoise_ai_version is not None:
+            self.denoise_ai_version.set(graxpert.prefs.denoise_ai_version)
+        else:
+            self.denoise_ai_options.insert(0, "None")
+        self.denoise_ai_version.trace_add("write", lambda a, b, c: eventbus.emit(AppEvents.DENOISE_AI_VERSION_CHANGED, {"denoise_ai_version": self.denoise_ai_version.get()}))
+
+        # ai settings
+        self.ai_batch_size_options = ["1", "2", "4", "8", "16", "32"]
+        self.ai_batch_size = tk.IntVar()
+        self.ai_batch_size.set(graxpert.prefs.ai_batch_size)
+        self.ai_batch_size.trace_add("write", lambda a, b, c: eventbus.emit(AppEvents.AI_BATCH_SIZE_CHANGED, {"ai_batch_size": self.ai_batch_size.get()}))
+
+        self.ai_gpu_acceleration = tk.BooleanVar()
+        self.ai_gpu_acceleration.set(graxpert.prefs.ai_gpu_acceleration)
+        self.ai_gpu_acceleration.trace_add("write", lambda a, b, c: eventbus.emit(AppEvents.AI_GPU_ACCELERATION_CHANGED, {"ai_gpu_acceleration": self.ai_gpu_acceleration.get()}))
+
+        self.create_and_place_children()
+        self.setup_layout()
+
+    def on_scaling_change(self, a, b, c):
+        eventbus.emit(AppEvents.SCALING_CHANGED, {"scaling": self.scaling.get()})
+        ctk.set_widget_scaling(self.scaling.get())
+
+    def create_and_place_children(self):
+        CTkLabel(self, text=_("Advanced Settings"), font=self.heading_font).grid(column=0, row=self.nrow(), pady=pady, sticky=tk.N)
+
+        # sample points
+        CTkLabel(self, text=_("Sample Points"), font=self.heading_font2).grid(column=0, row=self.nrow(), pady=pady, sticky=tk.N)
+
+        ValueSlider(self, variable=self.sample_size, variable_name=_("Sample size"), min_value=5, max_value=50, precision=0).grid(**self.default_grid())
+        ValueSlider(self, variable=self.sample_color, variable_name=_("Sample color"), min_value=0, max_value=360, precision=0).grid(**self.default_grid())
+
+        # interpolation
+        CTkLabel(self, text=_("Interpolation"), font=self.heading_font2).grid(column=0, row=self.nrow(), pady=pady, sticky=tk.N)
+
+        CTkLabel(self, text=_("RBF Kernel")).grid(column=0, row=self.nrow(), pady=pady, sticky=tk.N)
+        GraXpertOptionMenu(self, variable=self.rbf_kernel, values=self.rbf_kernels).grid(**self.default_grid())
+
+        CTkLabel(self, text=_("Spline order")).grid(column=0, row=self.nrow(), pady=pady, sticky=tk.N)
+        GraXpertOptionMenu(self, variable=self.spline_order, values=self.spline_orders).grid(**self.default_grid())
+
+        CTkLabel(self, text=_("Correction")).grid(column=0, row=self.nrow(), pady=pady, sticky=tk.N)
+        GraXpertOptionMenu(self, variable=self.corr_type, values=self.corr_types).grid(**self.default_grid())
+
+        # interface
+        CTkLabel(self, text=_("Interface"), font=self.heading_font2).grid(column=0, row=self.nrow(), pady=pady, sticky=tk.N)
+
+        def lang_change(lang):
+            messagebox.showerror("", _("Please restart the program to change the language."))
+
+        CTkLabel(self, text=_("Language")).grid(column=0, row=self.nrow(), pady=pady, sticky=tk.N)
+        GraXpertOptionMenu(self, variable=self.lang, values=self.langs).grid(**self.default_grid())
+
+        ValueSlider(self, variable=self.scaling, variable_name=_("Scaling"), min_value=1, max_value=2, precision=1).grid(**self.default_grid())
+
+        # bge ai model
+        CTkLabel(self, text=_("Background Extraction AI-Model"), font=self.heading_font2).grid(column=0, row=self.nrow(), pady=pady, sticky=tk.N)
+        GraXpertOptionMenu(self, variable=self.bge_ai_version, values=self.bge_ai_options).grid(**self.default_grid())
+
+        # object-deconvolution ai model
+        CTkLabel(self, text=_("Object Deconvolution AI-Model"), font=self.heading_font2).grid(column=0, row=self.nrow(), pady=pady, sticky=tk.N)
+        GraXpertOptionMenu(self, variable=self.deconvolution_object_ai_version, values=self.deconvolution_object_ai_options).grid(**self.default_grid())
+
+        # stars-deconvolution ai model
+        CTkLabel(self, text=_("Stars Deconvolution AI-Model"), font=self.heading_font2).grid(column=0, row=self.nrow(), pady=pady, sticky=tk.N)
+        GraXpertOptionMenu(self, variable=self.deconvolution_stars_ai_version, values=self.deconvolution_stars_ai_options).grid(**self.default_grid())
+
+        # denoise ai model
+        CTkLabel(self, text=_("Denoising AI-Model"), font=self.heading_font2).grid(column=0, row=self.nrow(), pady=pady, sticky=tk.N)
+        GraXpertOptionMenu(self, variable=self.denoise_ai_version, values=self.denoise_ai_options).grid(**self.default_grid())
+
+        # ai settings
+        CTkLabel(self, text=_("AI inference batch size"), font=self.heading_font2).grid(column=0, row=self.nrow(), pady=pady, sticky=tk.N)
+        GraXpertOptionMenu(self, variable=self.ai_batch_size, values=self.ai_batch_size_options).grid(**self.default_grid())
+
+        CTkLabel(self, text=_("AI Hardware Acceleration"), font=self.heading_font2).grid(column=0, row=self.nrow(), pady=pady, sticky=tk.N)
+        CTkSwitch(self, text=_("Enable Acceleration"), variable=self.ai_gpu_acceleration).grid(column=0, row=self.nrow(), pady=pady, sticky=tk.N)
+
+    def setup_layout(self):
+        self.columnconfigure(0, weight=1)
+        self.rowconfigure(0, weight=1)
+
+    def default_grid(self):
+        return {"column": 0, "row": self.nrow(), "padx": padx, "pady": pady}

graxpert/ui/statusbar.py

@@ -0,0 +1,102 @@
+import tkinter as tk
+
+from customtkinter import CTkFrame, CTkLabel, StringVar
+
+import graxpert.ui.tooltip as tooltip
+from graxpert.application.app import graxpert
+from graxpert.application.app_events import AppEvents
+from graxpert.application.eventbus import eventbus
+from graxpert.AstroImageRepository import ImageTypes
+from graxpert.localization import _
+from graxpert.ui.ui_events import UiEvents
+from graxpert.ui.widgets import GraXpertCheckbox, GraXpertOptionMenu, ProcessingStep, ValueSlider, default_label_width, padx, pady
+
+
+class StatusBar(CTkFrame):
+    def __init__(self, master, **kwargs):
+        super().__init__(master, **kwargs)
+
+        self.stretch_options = ["No Stretch", "10% Bg, 3 sigma", "15% Bg, 3 sigma", "20% Bg, 3 sigma", "30% Bg, 2 sigma"]
+        self.stretch_option_current = StringVar()
+        self.stretch_option_current.set(graxpert.prefs.stretch_option)
+        self.stretch_option_current.trace_add("write", lambda a, b, c: eventbus.emit(AppEvents.STRETCH_OPTION_CHANGED, {"stretch_option": self.stretch_option_current.get()}))
+
+        self.saturation = tk.DoubleVar()
+        self.saturation.set(graxpert.prefs.saturation)
+        self.saturation.trace_add("write", lambda a, b, c: eventbus.emit(AppEvents.CHANGE_SATURATION_REQUEST, {"saturation": self.saturation.get()}))
+
+        self.channels_linked = tk.BooleanVar()
+        self.channels_linked.set(graxpert.prefs.channels_linked_option)
+        self.channels_linked.trace_add("write", lambda a, b, c: eventbus.emit(AppEvents.CHANNELS_LINKED_CHANGED, {"channels_linked": self.channels_linked.get()}))
+
+        self.create_children()
+        self.setup_layout()
+        self.place_children()
+        self.register_events()
+
+    # widget setup
+    def create_children(self):
+        self.label_image_info = CTkLabel(self, text="image info")
+        self.label_image_pixel = CTkLabel(self, text="(x, y)")
+
+        self.stretch_option_frame = CTkFrame(self)
+
+        self.stretch_options_title = ProcessingStep(self.stretch_option_frame, number=0, indent=2, title=_(" Stretch Options"))
+        self.stretch_menu = GraXpertOptionMenu(
+            self.stretch_option_frame,
+            variable=self.stretch_option_current,
+            values=self.stretch_options,
+        )
+        tooltip.Tooltip(self.stretch_menu, text=tooltip.stretch_text)
+        self.saturation_slider = ValueSlider(
+            self.stretch_option_frame,
+            width=default_label_width,
+            variable_name=_("Saturation"),
+            variable=self.saturation,
+            min_value=0,
+            max_value=3,
+            precision=1,
+        )
+        self.channels_linked_switch = GraXpertCheckbox(self.stretch_option_frame, width=default_label_width, text=_("Channels linked"), variable=self.channels_linked)
+
+    def setup_layout(self):
+        self.columnconfigure(0, weight=1)
+        self.rowconfigure(0, weight=1)
+
+    def place_children(self):
+        self.stretch_option_frame.grid(column=0, row=0, sticky=tk.NS)
+        self.label_image_info.grid(column=0, row=0, padx=padx, sticky=tk.W)
+        self.label_image_pixel.grid(column=0, row=0, padx=padx, sticky=tk.E)
+
+        self.stretch_menu.grid(column=0, row=0, padx=padx, pady=pady, sticky=tk.E)
+        self.saturation_slider.grid(column=1, row=0, padx=padx, pady=pady, sticky=tk.EW)
+        self.channels_linked_switch.grid(column=2, row=0, padx=padx, pady=pady, sticky=tk.W)
+
+    def register_events(self):
+        eventbus.add_listener(AppEvents.LOAD_IMAGE_END, self.on_load_image_end)
+        eventbus.add_listener(UiEvents.MOUSE_MOVED, self.on_mouse_move)
+
+    # event handling
+    def on_load_image_end(self, event):
+        self.label_image_info.configure(
+            text=f"{graxpert.data_type} : {graxpert.images.get(ImageTypes.Original).img_display.width} x {graxpert.images.get(ImageTypes.Original).img_display.height} {graxpert.images.get(ImageTypes.Original).img_display.mode}"
+        )
+
+    def on_mouse_move(self, event):
+        if graxpert.images.get(graxpert.display_type) is None:
+            return
+
+        image_point = graxpert.to_image_point(event["mouse_event"].x, event["mouse_event"].y)
+        if len(image_point) != 0:
+            text = "x=" + f"{image_point[0]:.2f}" + ",y=" + f"{image_point[1]:.2f}  "
+            if graxpert.images.get(graxpert.display_type).img_array.shape[2] == 3:
+                R, G, B = graxpert.images.get(graxpert.display_type).get_local_median(image_point)
+                text = text + "RGB = (" + f"{R:.4f}," + f"{G:.4f}," + f"{B:.4f})"
+
+            if graxpert.images.get(graxpert.display_type).img_array.shape[2] == 1:
+                L = graxpert.images.get(graxpert.display_type).get_local_median(image_point)
+                text = text + "L= " + f"{L:.4f}"
+
+            self.label_image_pixel.configure(text=text)
+        else:
+            self.label_image_pixel.configure(text="(--, --)")

graxpert/ui/styling.py

@@ -0,0 +1,23 @@
+import os
+import shutil
+from importlib import resources
+
+import customtkinter
+
+from graxpert.resource_utils import resource_path, temp_resource_path
+from graxpert.ui_scaling import get_scaling_factor
+
+
+def style():
+    theme_file = "graxpert-dark-blue.json"
+
+    # Use importlib.resources to get a reliable path to the theme file
+    # This works whether the code is run from source or installed via pip/pipx
+    with resources.as_file(resources.files('graxpert.theme').joinpath(theme_file)) as theme_path:
+        # Now copy the file from the reliably found path
+        shutil.copy(theme_path, temp_resource_path(theme_file))
+
+    customtkinter.set_default_color_theme(temp_resource_path(theme_file))
+    customtkinter.set_appearance_mode("dark")
+    scaling = get_scaling_factor()
+    customtkinter.set_widget_scaling(scaling)

graxpert/ui/tooltip.py

@@ -0,0 +1,194 @@
+import tkinter as tk
+import tkinter.ttk as ttk
+
+from customtkinter import CTkFrame, CTkLabel, CTkToplevel
+
+from graxpert.application.app_events import AppEvents
+from graxpert.application.eventbus import eventbus
+from graxpert.localization import _
+from graxpert.ui_scaling import get_scaling_factor
+
+
+class Tooltip:
+    """
+    It creates a tooltip for a given widget as the mouse goes on it.
+
+    see:
+
+    http://stackoverflow.com/questions/3221956/
+           what-is-the-simplest-way-to-make-tooltips-
+           in-tkinter/36221216#36221216
+
+    http://www.daniweb.com/programming/software-development/
+           code/484591/a-tooltip-class-for-tkinter
+
+    - Originally written by vegaseat on 2014.09.09.
+
+    - Modified to include a delay time by Victor Zaccardo on 2016.03.25.
+
+    - Modified
+        - to correct extreme right and extreme bottom behavior,
+        - to stay inside the screen whenever the tooltip might go out on
+          the top but still the screen is higher than the tooltip,
+        - to use the more flexible mouse positioning,
+        - to add customizable background color, padding, waittime and
+          wraplength on creation
+      by Alberto Vassena on 2016.11.05.
+
+      Tested on Ubuntu 16.04/16.10, running Python 3.5.2
+
+    TODO: themes styles support
+    """
+
+    def __init__(self, widget, *, pad=(5, 3, 5, 3), text="widget info", waittime=500, wraplength=250):
+        self.waittime = waittime  # in miliseconds, originally 500
+        self.wraplength = wraplength * get_scaling_factor()  # in pixels, originally 180
+        self.widget = widget
+        self.text = text
+        self.widget.bind("<Enter>", self.onEnter)
+        self.widget.bind("<Leave>", self.onLeave)
+        self.widget.bind("<ButtonPress>", self.onLeave)
+        self.pad = pad
+        self.id = None
+        self.tw = None
+        self.enable_tt = True
+        eventbus.add_listener(AppEvents.CALCULATE_REQUEST, lambda e: self.disable())
+        eventbus.add_listener(AppEvents.DENOISE_REQUEST, lambda e: self.disable())
+        eventbus.add_listener(AppEvents.CALCULATE_END, lambda e: self.enable())
+        eventbus.add_listener(AppEvents.DENOISE_END, lambda e: self.enable())
+
+    def onEnter(self, event=None):
+        self.schedule()
+
+    def onLeave(self, event=None):
+        self.unschedule()
+        self.hide()
+
+    def schedule(self):
+        self.unschedule()
+        self.id = self.widget.after(self.waittime, self.show)
+
+    def unschedule(self):
+        id_ = self.id
+        self.id = None
+        if id_:
+            self.widget.after_cancel(id_)
+
+    def show(self):
+
+        if not self.enable_tt:
+            return
+
+        def tip_pos_calculator(widget, label, *, tip_delta=(10, 5), pad=(5, 3, 5, 3)):
+            w = widget
+
+            s_width, s_height = w.winfo_screenwidth(), w.winfo_screenheight()
+
+            width, height = (pad[0] + label.winfo_reqwidth() + pad[2], pad[1] + label.winfo_reqheight() + pad[3])
+
+            mouse_x, mouse_y = w.winfo_pointerxy()
+
+            x1, y1 = mouse_x + tip_delta[0], mouse_y + tip_delta[1]
+            x2, y2 = x1 + width, y1 + height
+
+            x_delta = x2 - s_width
+            if x_delta < 0:
+                x_delta = 0
+            y_delta = y2 - s_height
+            if y_delta < 0:
+                y_delta = 0
+
+            offscreen = (x_delta, y_delta) != (0, 0)
+
+            if offscreen:
+                if x_delta:
+                    x1 = mouse_x - tip_delta[0] - width
+
+                if y_delta:
+                    y1 = mouse_y - tip_delta[1] - height
+
+            offscreen_again = y1 < 0  # out on the top
+
+            if offscreen_again:
+                # No further checks will be done.
+
+                # TIP:
+                # A further mod might automagically augment the
+                # wraplength when the tooltip is too high to be
+                # kept inside the screen.
+                y1 = 0
+
+            return x1, y1
+
+        pad = self.pad
+        widget = self.widget
+
+        # creates a toplevel window
+        self.tw = CTkToplevel(widget)
+
+        # Leaves only the label and removes the app window
+        self.tw.wm_overrideredirect(True)
+
+        win = CTkFrame(self.tw, border_width=0)
+        label = CTkLabel(win, text=self.text, justify=tk.LEFT, wraplength=self.wraplength)
+
+        label.grid(padx=(pad[0], pad[2]), pady=(pad[1], pad[3]), sticky=tk.NSEW)
+        win.grid()
+
+        x, y = tip_pos_calculator(widget, label)
+
+        self.tw.wm_geometry("+%d+%d" % (x, y))
+
+    def hide(self):
+        tw = self.tw
+        if tw:
+            tw.destroy()
+        self.tw = None
+
+    def enable(self):
+        self.enable_tt = True
+
+    def disable(self):
+        self.enable_tt = False
+        self.hide()
+
+
+load_text = _("Load your image you would like to correct. \n" "\n" "Supported formats: .tiff, .fits, .png, .jpg \n" "Supported bitdepths: 16 bit integer, 32 bit float")
+
+stretch_text = _("Automatically stretch the picture to make gradients more visible. " "The saved pictures are unaffected by the stretch.")
+
+reset_text = _("Reset all the chosen background points.")
+
+bg_select_text = _("Creates a grid with the specified amount of points per row " "and rejects points below a threshold defined by the tolerance.")
+
+bg_tol_text = _("The tolerance adjusts the threshold for rejection of background points " "with automatic background selection")
+
+bg_flood_text = _("If enabled, additional grid points are automatically created based on " "1) the luminance of the sample just added and " "2) the grid tolerance slider below.")
+
+num_points_text = _("Adjust the number of points per row for the grid created by" " automatic background selection.")
+
+interpol_type_text = _("Choose between different interpolation methods.")
+
+smoothing_text = _(
+    "Adjust the smoothing parameter for the interpolation method. "
+    "A too small smoothing parameter may lead to over- and undershooting "
+    "inbetween background points, while a too large smoothing parameter "
+    "may not be suited for large deviations in gradients."
+)
+
+calculate_text = _("Use the specified interpolation method to calculate a background model " "and subtract it from the picture. This may take a while.")
+
+deconvolution_type_text = _("Choose between different deconvolution methods.")
+deconvolution_text = _("Use GraXpert's deconvolution AI model to reduce the blur in your image. This may take a while")
+deconvolution_strength_text = _("Determines strength of deconvolution.")
+deconvolution_psfsize_text = _("Informs the AI on how much blur to expect in the image. The right parameters is found when all artifacts disappear.")
+
+denoise_text = _("Use GraXpert's denoising AI model to reduce the noise in your image. This may take a while")
+denoise_strength_text = _("Determines strength of denoising.")
+denoise_threshold_text = _("Determines the upper bound up to which pixels are denoised. Pixels above this threshold are not denoised and taken from the original image.")
+
+saveas_text = _("Choose the bitdepth of the saved pictures and the file format. " "If you are working with a .fits image the fits header will " "be preserved.")
+saveas_stretched_text = _("Enable to save the stretched image instead of the linear one. The color saturation is not changed.")
+save_pic_text = _("Save the currently selected picture")
+
+display_text = _("Switch display between \n" "\n" "Original: Your original picture \n" "Processed: Picture with subtracted background model \n" "Background: The background model")

graxpert/ui/ui_events.py

@@ -0,0 +1,19 @@
+from enum import Enum, auto
+
+
+class UiEvents(Enum):
+    # main ui requests
+    RESET_ZOOM_REQUEST = auto()
+    # menu requests
+    SHOW_MENU_REQUEST = auto()
+    # crop
+    TURN_ON_CROP_MODE = auto()
+    TURN_OFF_CROP_MODE = auto()
+    APPLY_CROP_REQUEST = auto()
+    # right sidebar requests
+    HELP_FRAME_TOGGLED = auto()
+    ADVANCED_FRAME_TOGGLED = auto()
+    # mouse events
+    MOUSE_MOVED = auto()
+    # cosmetics
+    DISPLAY_START_BADGE_REQUEST = auto()