imagebaker 0.0.50__py3-none-any.whl → 0.0.53__py3-none-any.whl

imagebaker/tabs/layerify_tab.py

@@ -40,6 +40,7 @@ from imagebaker.core.defs import (
 from collections import deque
 from typing import Deque
 from dataclasses import dataclass
+import os
 
 
 @dataclass
@@ -103,13 +104,17 @@ class LayerifyTab(QWidget):
         """Connect all necessary signals"""
         # Connect all layers in the deque to annotation list
         for layer in self.annotable_layers:
-            layer.annotationAdded.connect(self.annotation_list.update_list)
-            layer.annotationUpdated.connect(self.annotation_list.update_list)
+            # layer.annotationAdded.connect(self.annotation_list.update_list)
+            layer.annotationAdded.connect(self.on_annotation_added)
+            # layer.annotationUpdated.connect(self.annotation_list.update_list)
+            layer.annotationUpdated.connect(self.on_annotation_updated)
             layer.messageSignal.connect(self.messageSignal)
             layer.layerSignal.connect(self.add_layer)
+            layer.labelUpdated.connect(self.on_label_update)
 
         # Connect image list panel signals
         self.image_list_panel.imageSelected.connect(self.on_image_selected)
+        self.image_list_panel.activeImageEntries.connect(self.update_active_entries)
 
     def init_ui(self):
         """Initialize the UI components"""
@@ -118,7 +123,9 @@ class LayerifyTab(QWidget):
             None, parent=self.main_window, max_name_length=self.config.max_name_length
         )
         self.image_list_panel = ImageListPanel(
-            self.image_entries, self.processed_images
+            self.image_entries,
+            self.processed_images,
+            images_per_page=self.config.deque_maxlen,
         )
 
         self.main_window.addDockWidget(Qt.LeftDockWidgetArea, self.image_list_panel)
@@ -162,10 +169,14 @@ class LayerifyTab(QWidget):
         for idx, layer in enumerate(self.annotable_layers):
             layer.setVisible(False)
             # logger.info(f"Layer {idx} hidden.")
+        current_label = self.layer.current_label
+        current_color = self.layer.current_color
 
         if not image_entry.is_baked_result:  # Regular image
             image_path = image_entry.data
             self.curr_image_idx = self.image_entries.index(image_entry)
+            # convert curr_image_idx to correct index
+            self.curr_image_idx = self.curr_image_idx % len(self.annotable_layers)
 
             # Make the corresponding layer visible and set the image
             selected_layer = self.annotable_layers[self.curr_image_idx]
@@ -185,6 +196,9 @@ class LayerifyTab(QWidget):
             # logger.info(f"Layer {self.curr_image_idx} made visible for baked result.")
             self.layer = baked_result_layer  # Set the baked result as the current layer
 
+        # Set the current label and color
+        self.layer.current_label = current_label
+        self.layer.current_color = current_color
         self.annotation_list.layer = self.layer
         self.annotation_list.update_list()
 
@@ -206,11 +220,17 @@ class LayerifyTab(QWidget):
             for i, layer in enumerate(self.annotable_layers):
                 if i < len(self.image_entries):
                     layer.set_image(self.image_entries[i].data)
+                    self.load_layer_annotations(layer)
+                    layer.layer_name = f"Layer_{i + 1}"
                     layer.setVisible(
                         i == 0
                     )  # Only the first layer is visible by default
                     if i == 0:
                         self.layer = layer  # Set the first layer as the current layer
+                        # Select the first item in the image list panel's list widget
+                        if self.image_list_panel.list_widget.count() > 0:
+                            self.image_list_panel.list_widget.setCurrentRow(0)
+
                 else:
                     layer.setVisible(False)
 
@@ -224,12 +244,80 @@ class LayerifyTab(QWidget):
         self.image_list_panel.update_image_list(self.image_entries)
         self.update()
 
+    def save_layer_annotations(
+        self, layer: AnnotableLayer, save_dir: Path | None = None
+    ):
+        """Save annotations for a specific layer"""
+        if len(layer.annotations) > 0:
+            file_path = layer.file_path
+            file_name = file_path.name
+            if save_dir is None:
+                # Save to the cache directory
+                save_dir = self.config.cache_dir
+            save_dir = save_dir / f"{file_name}.json"
+            Annotation.save_as_json(layer.annotations, save_dir)
+            logger.info(f"Saved annotations for {layer.layer_name} to {save_dir}")
+
+    def load_layer_annotations(
+        self, layer: AnnotableLayer, load_dir: Path | None = None
+    ):
+        """Load annotations for a specific layer"""
+        if layer.file_path:
+            file_path = layer.file_path
+            file_name = file_path.name
+            if load_dir is None:
+                load_dir = self.config.cache_dir
+            load_dir = load_dir / f"{file_name}.json"
+            if load_dir.exists():
+                layer.annotations = Annotation.load_from_json(load_dir)
+                logger.info(
+                    f"Loaded annotations for {layer.layer_name} from {load_dir}"
+                )
+            else:
+                logger.warning(f"No annotations found for {layer.layer_name}")
+
+    def update_active_entries(self, image_entries: list[ImageEntry]):
+        """Update the active entries in the image list panel."""
+        self.curr_image_idx = 0
+        for i, layer in enumerate(self.annotable_layers):
+            self.save_layer_annotations(layer)
+            layer.annotations = []
+
+            if i < len(image_entries):
+                # get index on the self.image_entries
+                idx = self.image_entries.index(image_entries[i])
+                if self.image_entries[idx].is_baked_result:
+                    # if the image is a baked result, set the layer to the baked result
+                    layer = self.image_entries[idx].data
+                    layer.file_path = layer.file_path
+                else:
+                    layer.set_image(self.image_entries[idx].data)
+                self.load_layer_annotations(layer)
+
+                layer.layer_name = f"Layer_{idx + 1}"
+                layer.setVisible(i == 0)
+                if i == 0:
+                    self.layer = layer
+                    # update annotation list to the first layer
+                    self.annotation_list.layer = self.layer
+                    self.annotation_list.update_list()
+            else:
+                layer.setVisible(False)
+        logger.info("Updated active entries in image list panel.")
+
     def clear_annotations(self):
         """Safely clear all annotations"""
         try:
             # Clear layer annotations
             self.clearAnnotations.emit()
             self.messageSignal.emit("Annotations cleared")
+            # clear cache annotation of layer
+            annotation_path = (
+                self.config.cache_dir / f"{self.layer.file_path.name}.json"
+            )
+            if annotation_path.exists():
+                os.remove(annotation_path)
+                logger.info(f"Cleared annotations from {annotation_path}")
 
         except Exception as e:
             logger.error(f"Clear error: {str(e)}")
@@ -241,14 +329,17 @@ class LayerifyTab(QWidget):
         Args:
             annotation (Annotation): The annotation that was added.
         """
-        if annotation.label not in self.config.predefined_labels:
+
+        # if annotation.label is not in the predefined labels, add it
+        if annotation.label not in [lbl.name for lbl in self.config.predefined_labels]:
+            logger.info(f"Label {annotation.label} created.")
             self.config.predefined_labels.append(
                 Label(annotation.label, annotation.color)
             )
             self.update_label_combo()
         logger.info(f"Added annotation: {annotation.label}")
         self.messageSignal.emit(f"Added annotation: {annotation.label}")
-
+        self.save_layer_annotations(self.layer)
         # Refresh the annotation list
         self.annotation_list.update_list()
 
@@ -259,11 +350,12 @@ class LayerifyTab(QWidget):
         Args:
             annotation (Annotation): The updated annotation.
         """
-        logger.info(f"Updated annotation: {annotation.label}")
+        # logger.info(f"Updated annotation: {annotation}")
         self.messageSignal.emit(f"Updated annotation: {annotation.label}")
 
         # Refresh the annotation list
         self.annotation_list.update_list()
+        self.save_layer_annotations(self.layer)
 
     def update_label_combo(self):
         """
@@ -276,6 +368,27 @@ class LayerifyTab(QWidget):
             pixmap = QPixmap(16, 16)
             pixmap.fill(label.color)
             self.label_combo.addItem(QIcon(pixmap), label.name)
+        logger.info("Updated label combo box with predefined labels.")
+        self.label_combo.setCurrentText(self.current_label)
+
+    def on_label_update(self, old_new_label: tuple[str, str]):
+        new_labels = []
+        index = 0
+        for i, label in enumerate(self.config.predefined_labels):
+            if label.name == old_new_label[0]:
+                label.name = old_new_label[1]
+                index = i
+            new_labels.append(label)
+
+        self.config.predefined_labels = new_labels
+        logger.info(f"Updated label from {old_new_label[0]} to {old_new_label[1]}")
+        self.messageSignal.emit(
+            f"Updated label from {old_new_label[0]} to {old_new_label[1]}."
+        )
+
+        self.update_label_combo()
+        self.handle_label_change(index=index)
+        self.label_combo.update()
 
     def load_default_image(self):
         """
@@ -471,6 +584,34 @@ class LayerifyTab(QWidget):
             QMessageBox.warning(self, "Warning", "No annotations to save!")
             return
 
+        # an option to save all annotations (i.e. from all layers) or just the current layer
+        options = QMessageBox.StandardButton.Yes | QMessageBox.StandardButton.No
+        # Change the "No" button text to "Just This Layer"
+        msg_box = QMessageBox(self)
+        msg_box.setWindowTitle("Save Annotations")
+        msg_box.setText("Do you want to save annotations from all layers?")
+        yes_button = msg_box.addButton("All Layers", QMessageBox.YesRole)
+        just_this_button = msg_box.addButton("Just This Layer", QMessageBox.NoRole)
+        msg_box.setDefaultButton(yes_button)
+        msg_box.exec()
+        save_all = msg_box.clickedButton() == yes_button
+
+        if save_all:
+            # folder select dialog
+            save_dir = QFileDialog.getExistingDirectory(
+                self, "Select Save Directory", str(self.config.cache_dir)
+            )
+            if not save_dir:
+                QMessageBox.warning(self, "Warning", "No directory selected!")
+                return
+            for layer in self.annotable_layers:
+                if layer.annotations:
+                    self.save_layer_annotations(layer, Path(save_dir))
+            QMessageBox.information(
+                self, "Success", "All annotations saved successfully!"
+            )
+            return
+
         options = QFileDialog.Options()
         file_name, _ = QFileDialog.getSaveFileName(
             self, "Save Annotations", "", "JSON Files (*.json)", options=options
@@ -493,6 +634,34 @@ class LayerifyTab(QWidget):
         """
         Load annotations from a JSON file.
         """
+        # dialog box to load all annotations or just the current layer
+        options = QMessageBox.StandardButton.Yes | QMessageBox.StandardButton.No
+        # Change the "No" button text to "Just This Layer"
+        msg_box = QMessageBox(self)
+        msg_box.setWindowTitle("Load Annotations")
+        msg_box.setText("Do you want to load annotations from all layers?")
+        yes_button = msg_box.addButton("All Layers", QMessageBox.YesRole)
+        just_this_button = msg_box.addButton("Just This Layer", QMessageBox.NoRole)
+        msg_box.setDefaultButton(yes_button)
+        msg_box.exec()
+        load_all = msg_box.clickedButton() == yes_button
+        if load_all:
+            # folder select dialog
+            load_dir = QFileDialog.getExistingDirectory(
+                self, "Select Load Directory", str(self.config.cache_dir)
+            )
+            if not load_dir:
+                QMessageBox.warning(self, "Warning", "No directory selected!")
+                return
+            for layer in self.annotable_layers:
+                layer.annotations = []
+                layer.update()
+                self.load_layer_annotations(layer, Path(load_dir))
+            self.update_annotation_list()
+            QMessageBox.information(
+                self, "Success", "All annotations loaded successfully!"
+            )
+            return
         options = QFileDialog.Options()
         file_name, _ = QFileDialog.getOpenFileName(
             self, "Load Annotations", "", "JSON Files (*.json)", options=options
@@ -589,6 +758,24 @@ class LayerifyTab(QWidget):
         )
         msg = f"Label changed to {self.current_label}"
         self.messageSignal.emit(msg)
+        self.layer.selected_annotation = self.layer._get_selected_annotation()
+        if self.layer.selected_annotation:
+            annotations = []
+            for ann in self.layer.annotations:
+                if ann == self.layer.selected_annotation:
+                    ann.label = label_info.name
+                    ann.color = label_info.color
+                annotations.append(ann)
+
+            self.layer.annotations = annotations
+            self.on_annotation_updated(self.layer.selected_annotation)
+            # disable label change callback
+            self.label_combo.currentIndexChanged.disconnect()
+            self.label_combo.currentIndexChanged.connect(lambda: None)
+            self.update_label_combo()
+            # set it back
+            self.label_combo.currentIndexChanged.connect(self.handle_label_change)
+
         self.layer.update()
         self.update()
 
@@ -628,7 +815,7 @@ class LayerifyTab(QWidget):
             ("🎨", "Color", self.choose_color),
             ("🧅", "Layerify All", self.layerify_all),
             ("🏷️", "Add Label", self.add_new_label),
-            ("🗑️", "Clear", lambda x: self.clearAnnotations.emit()),
+            ("🗑️", "Clear", self.clear_annotations),
         ]
 
         # Folder navigation buttons
@@ -636,18 +823,6 @@ class LayerifyTab(QWidget):
         self.select_folder_btn.clicked.connect(self.select_folder)
         toolbar_layout.addWidget(self.select_folder_btn)
 
-        self.next_image_btn = QPushButton("Next")
-        self.next_image_btn.clicked.connect(self.show_next_image)
-        toolbar_layout.addWidget(self.next_image_btn)
-
-        self.prev_image_btn = QPushButton("Prev")
-        self.prev_image_btn.clicked.connect(self.show_prev_image)
-        toolbar_layout.addWidget(self.prev_image_btn)
-
-        # Initially hide next/prev buttons
-        self.next_image_btn.setVisible(False)
-        self.prev_image_btn.setVisible(False)
-
         # Add mode buttons
         for icon, text, mode in modes:
             btn_txt = icon + text
@@ -703,11 +878,25 @@ class LayerifyTab(QWidget):
                     ImageEntry(is_baked_result=False, data=img_path)
                 )
 
+        # load from bake folder if it exists
+        bake_folder = self.config.bake_dir
+        if bake_folder.exists() and bake_folder.is_dir():
+            for img_path in bake_folder.glob("*.*"):
+                if img_path.suffix.lower() in [
+                    ".jpg",
+                    ".jpeg",
+                    ".png",
+                    ".bmp",
+                    ".tiff",
+                ]:
+                    self.image_entries.append(
+                        ImageEntry(is_baked_result=False, data=img_path)
+                    )
+
     def select_folder(self):
         """Allow the user to select a folder and load images from it."""
         folder_path = QFileDialog.getExistingDirectory(self, "Select Folder")
         if folder_path:
-            self.image_entries = []  # Clear the existing image paths
             folder_path = Path(folder_path)
 
             self._load_images_from_folder(folder_path)
@@ -726,9 +915,6 @@ class LayerifyTab(QWidget):
                 # Load the first set of images into the layers
                 self.load_default_images()
 
-                # Unhide the next/prev buttons if there are multiple images
-                self.next_image_btn.setVisible(len(self.image_entries) > 1)
-                self.prev_image_btn.setVisible(len(self.image_entries) > 1)
             else:
                 QMessageBox.warning(
                     self,
@@ -736,28 +922,6 @@ class LayerifyTab(QWidget):
                     "No valid image files found in the selected folder.",
                 )
 
-    def show_next_image(self):
-        """Show next image in the list. If at the end, show first image."""
-        if self.curr_image_idx < len(self.image_entries) - 1:
-            self.curr_image_idx += 1
-        else:
-            self.curr_image_idx = 0
-        self.layer.set_image(self.image_entries[self.curr_image_idx]["data"])
-        self.messageSignal.emit(
-            f"Showing image {self.curr_image_idx + 1}/{len(self.image_entries)}"
-        )
-
-    def show_prev_image(self):
-        """Show previous image in the list. If at the start, show last image."""
-        if self.curr_image_idx > 0:
-            self.curr_image_idx -= 1
-        else:
-            self.curr_image_idx = len(self.image_entries) - 1
-        self.layer.set_image(self.image_entries[self.curr_image_idx]["data"])
-        self.messageSignal.emit(
-            f"Showing image {self.curr_image_idx + 1}/{len(self.image_entries)}"
-        )
-
     def __del__(self):
         logger.warning(f"Tab {id(self)} deleted")
 
@@ -770,10 +934,20 @@ class LayerifyTab(QWidget):
             config=self.config,
             canvas_config=self.canvas_config,
         )
-        layer.annotations = baking_result.annotations
+        # save it in cache
+        filename = baking_result.filename
+        filepath = self.config.bake_dir / filename.name
+        baking_result.image.save(str(filepath))
+        #
+        Annotation.save_as_json(
+            baking_result.annotations, self.config.cache_dir / f"{filename.name}.json"
+        )
 
-        layer.annotationAdded.connect(self.annotation_list.update_list)
-        layer.annotationUpdated.connect(self.annotation_list.update_list)
+        layer.set_image(filepath)
+
+        layer.annotationAdded.connect(self.on_annotation_added)
+        layer.annotationUpdated.connect(self.on_annotation_updated)
+        layer.labelUpdated.connect(self.on_label_update)
         layer.messageSignal.connect(self.messageSignal)
         layer.layerSignal.connect(self.add_layer)
 
@@ -785,7 +959,7 @@ class LayerifyTab(QWidget):
         self.annotable_layers.append(layer)
 
         # Add baked result to image_entries
-        baked_result_entry = ImageEntry(is_baked_result=True, data=layer)
+        baked_result_entry = ImageEntry(is_baked_result=False, data=filepath)
         self.image_entries.append(baked_result_entry)
         # baking_result.image.save(str(baking_result.filename))
         layer.update()
@@ -793,6 +967,12 @@ class LayerifyTab(QWidget):
         logger.info("A baked result has arrived, adding it to the image list.")
 
         # Update the image list panel
+        # find the page index where this layer is
+        page_index = (
+            self.image_entries.index(baked_result_entry) // self.config.deque_maxlen
+        )
+        # set the current page to the page index
+        self.image_list_panel.current_page = page_index
         self.image_list_panel.update_image_list(self.image_entries)
         self.image_list_panel.imageSelected.emit(baked_result_entry)
 
@@ -831,6 +1011,52 @@ class LayerifyTab(QWidget):
                 self.annotation_list.update_list()
                 logger.info("Selected annotation deleted.")
 
+        # if clicked q, set the mode to point
+        elif key == Qt.Key_Q:
+            self.layer.set_mode(MouseMode.POINT)
+            logger.info("Mouse mode set to POINT.")
+        # if clicked w, set the mode to polygon
+        elif key == Qt.Key_W:
+            self.layer.set_mode(MouseMode.POLYGON)
+            logger.info("Mouse mode set to POLYGON.")
+        # if clicked e, set the mode to rectangle
+        elif key == Qt.Key_E:
+            self.layer.set_mode(MouseMode.RECTANGLE)
+            logger.info("Mouse mode set to RECTANGLE.")
+            # if pressed h key, then toggle visibility of annotations
+        elif event.key() == Qt.Key_H:
+            self.layer.toggle_annotation_visibility()
+
+        # if selected l, then run layerify the selected annotations
+        elif event.key() == Qt.Key_L:
+            if self.layer and self.layer.annotations:
+                selected_annotations = [
+                    ann for ann in self.layer.annotations if ann.selected
+                ]
+                if selected_annotations:
+                    logger.info(
+                        f"Layerifying {len(selected_annotations)} selected annotations."
+                    )
+                    self.layer.layerify_annotation(selected_annotations)
+                else:
+                    # layerify all annotations in the current layer
+                    self.layer.layerify_annotation(self.layer.annotations)
+                logger.info("Layerified all annotations in the current layer.")
+            else:
+                logger.warning("No annotations to layerify.")
+        elif event.key() == Qt.Key_C:
+            # if an annotation is selected, open a dialog box
+            # in that dialog box, ask for a caption
+            self.layer.selected_annotation = self.layer._get_selected_annotation()
+            if self.layer.selected_annotation:
+                current_caption = getattr(self.layer.selected_annotation, "caption", "")
+                text, ok = QInputDialog.getMultiLineText(
+                    self, "Edit Caption", "Enter caption:", current_caption
+                )
+                if ok:
+                    self.layer.selected_annotation.caption = text
+                    self.layer.update()
+
         # Pass the event to the annotation list if it needs to handle it
         if self.annotation_list.hasFocus():
             self.annotation_list.keyPressEvent(event)

imagebaker/utils/image.py

@@ -49,8 +49,11 @@ def draw_annotations(image: np.ndarray, annotations: list[Annotation]) -> np.nda
     Returns:
         np.ndarray: Image with annotations drawn.
     """
+    color = (0, 255, 0, 255) if image.shape[2] == 4 else (0, 255, 0)
+
     for i, ann in enumerate(annotations):
         if ann.rectangle:
+            # if image has alpha channel, make color full alpha
             cv2.rectangle(
                 image,
                 (int(ann.rectangle.x()), int(ann.rectangle.y())),
@@ -58,7 +61,7 @@ def draw_annotations(image: np.ndarray, annotations: list[Annotation]) -> np.nda
                     int(ann.rectangle.x() + ann.rectangle.width()),
                     int(ann.rectangle.y() + ann.rectangle.height()),
                 ),
-                (0, 255, 0),
+                color,
                 2,
             )
             rect_center = ann.rectangle.center()
@@ -69,7 +72,7 @@ def draw_annotations(image: np.ndarray, annotations: list[Annotation]) -> np.nda
                 (int(rect_center.x()), int(rect_center.y())),
                 cv2.FONT_HERSHEY_SIMPLEX,
                 1,
-                (0, 255, 0),
+                color,
                 2,
             )
         elif ann.polygon:
@@ -77,7 +80,7 @@ def draw_annotations(image: np.ndarray, annotations: list[Annotation]) -> np.nda
                 image,
                 [np.array([[int(p.x()), int(p.y())] for p in ann.polygon])],
                 True,
-                (0, 255, 0),
+                color,
                 2,
             )
             polygon_center = ann.polygon.boundingRect().center()
@@ -87,19 +90,19 @@ def draw_annotations(image: np.ndarray, annotations: list[Annotation]) -> np.nda
                 (int(polygon_center.x()), int(polygon_center.y())),
                 cv2.FONT_HERSHEY_SIMPLEX,
                 1,
-                (0, 255, 0),
+                color,
                 2,
             )
         elif ann.points:
             for p in ann.points:
-                cv2.circle(image, (int(p.x()), int(p.y())), 5, (0, 255, 0), -1)
+                cv2.circle(image, (int(p.x()), int(p.y())), 5, color, -1)
             cv2.putText(
                 image,
                 ann.label,
                 (int(ann.points[0].x()), int(ann.points[0].y())),
                 cv2.FONT_HERSHEY_SIMPLEX,
                 1,
-                (0, 255, 0),
+                color,
                 2,
             )
     return image

imagebaker/utils/state_utils.py

@@ -66,6 +66,7 @@ def calculate_intermediate_states(
             + (current_state.edge_opacity - previous_state.edge_opacity) * (i / steps),
             edge_width=previous_state.edge_width
             + (current_state.edge_width - previous_state.edge_width) * (i / steps),
+            caption=previous_state.caption,  # Assuming caption is the same in both states
         )
 
         # Deep copy the drawing_states from the previous_state

imagebaker/window/main_window.py

@@ -175,9 +175,80 @@ class MainWindow(QMainWindow):
         self.status_bar.showMessage(status_text)
 
     def closeEvent(self, event):
-        # Clean up tabs first
-        if hasattr(self, "layerify_tab"):
-            self.layerify_tab.deleteLater()
-        if hasattr(self, "baker_tab"):
-            self.baker_tab.deleteLater()
-        super().closeEvent(event)
+        logger.info("Closing the application.")
+        if self.layerify_config.cleanup_on_exit:
+            import shutil
+
+            if self.layerify_config.bake_dir.exists():
+                shutil.rmtree(self.layerify_config.bake_dir)
+                logger.info(f"Deleted bake directory: {self.layerify_config.bake_dir}")
+            if self.layerify_config.cache_dir.exists():
+                shutil.rmtree(self.layerify_config.cache_dir)
+                logger.info(
+                    f"Deleted cache directory: {self.layerify_config.cache_dir}"
+                )
+
+    def keyPressEvent(self, event):
+        # if pressed escape key, close the application
+        if event.key() == Qt.Key_Escape:
+            logger.info("Escape key pressed, closing the application.")
+            self.close()
+
+        # if ctrl+h, show help dialog
+        elif event.key() == Qt.Key_H and event.modifiers() == Qt.ControlModifier:
+            logger.info("Ctrl+H pressed, showing help dialog.")
+            current_tab = self.tab_widget.currentIndex()
+            if current_tab == 0:
+                info = (
+                    "<b>Layerify Tab Shortcuts:</b><br>"
+                    "<ul>"
+                    "<li><b>Ctrl + C</b>: Copy selected annotation.</li>"
+                    "<li><b>Ctrl + V</b>: Paste copied annotation in its parent image if it is currently open.</li>"
+                    "<li><b>Delete</b>: Delete selected annotation.</li>"
+                    "<li><b>Left Click</b>: Select an annotation on mouse position.</li>"
+                    "<li><b>Left Click + Drag</b>: Drag a selected annotation.</li>"
+                    "<li><b>Double Left Click</b>: When using polygon annotation, completes the polygon.</li>"
+                    "<li><b>Right Click</b>: Unselect an annotation. While annotating the polygon, undo the last point.</li>"
+                    "<li><b>Ctrl + Mouse Wheel</b>: Zoom In/Out on the mouse position, i.e., resize the viewport.</li>"
+                    "<li><b>Ctrl + Drag</b>: If done on the background, the viewport is panned.</li>"
+                    "<li><b>Q</b>: Point mode on annotation.</li>"
+                    "<li><b>W</b>: Polygon mode on annotation.</li>"
+                    "<li><b>E</b>: Rectangle mode on annotation.</li>"
+                    "<li><b>H</b>: Hides/un-hides selected annotation.</li>"
+                    "<li><b>L</b>: Creates layer from an annotation. If any annotation selected, creates only its, else creates layers from all visible annotations.</li>"
+                    "<li><b>C</b>: If any annotation is selected, a input box for Caption is created.</li>"
+                    "<li><b>Numerics</b>: Selecting number 1, 2, till 9 selects label. If not available, asks for a new label.</li>"
+                    "<li><b>Escape</b>: Closes the application.</li>"
+                    "</ul>"
+                )
+            elif current_tab == 1:
+                info = (
+                    "<b>Baker Tab Shortcuts:</b><br>"
+                    "<ul>"
+                    "<li><b>Ctrl + C</b>: Copy selected layer.</li>"
+                    "<li><b>Ctrl + V</b>: Paste copied layer in its parent if it is currently open.</li>"
+                    "<li><b>Delete</b>: Delete selected layer.</li>"
+                    "<li><b>Left Click</b>: Select a layer on mouse position.</li>"
+                    "<li><b>Left Click + Drag</b>: Drag a selected layer.</li>"
+                    "<li><b>Ctrl + S</b>: Save State on Baker Tab.</li>"
+                    "<li><b>Ctrl + D</b>: Draw Mode on Baker Tab. Drawing can happen on a selected or main layer.</li>"
+                    "<li><b>Ctrl + E</b>: Erase Mode on Baker Tab.</li>"
+                    "<li><b>Wheel</b>: Change the size of the drawing pointer.</li>"
+                    "<li><b>W</b>: Moves selected layer one step up in layer list in baker.</li>"
+                    "<li><b>S</b>: Moves selected layer one step down in layer list in baker.</li>"
+                    "<li><b>H</b>: Hides/un-hides selected layer.</li>"
+                    "<li><b>C</b>: Edit Caption for selected layer.</li>"
+                    "<li><b>Escape</b>: Closes the application.</li>"
+                    "</ul>"
+                )
+            else:
+                info = "No shortcuts available for this tab."
+
+            QMessageBox.information(
+                self,
+                "Help",
+                info,
+            )
+
+        # pass event to other widgets
+        return super().keyPressEvent(event)