imagebaker 0.0.49__py3-none-any.whl → 0.0.51__py3-none-any.whl

imagebaker/__init__.py

@@ -1,5 +1,9 @@
 from loguru import logger  # noqa
+from importlib.metadata import version, PackageNotFoundError
 
 logger.info("imagebaker package loaded with loguru logger.")
 
-# __version__ = "0.0.49"  # noqa
+try:
+    __version__ = version("imagebaker")
+except PackageNotFoundError:
+    __version__ = "0.0.0"

imagebaker/core/configs/configs.py

@@ -74,6 +74,22 @@ class BaseConfig(BaseModel):
             logger.info(f"Created assets folder at {asset_dir}")
         return asset_dir
 
+    @property
+    def cache_dir(self):
+        cache_dir = self.project_dir / ".imagebaker" / "cache"
+        if not cache_dir.exists():
+            cache_dir.mkdir(parents=True)
+            logger.info(f"Created cache folder at {cache_dir}")
+        return cache_dir
+
+    @property
+    def bake_dir(self):
+        bake_dir = self.project_dir / ".imagebaker" / "bake"
+        if not bake_dir.exists():
+            bake_dir.mkdir(parents=True)
+            logger.info(f"Created bake folder at {bake_dir}")
+        return bake_dir
+
     class Config:
         arbitrary_types_allowed = True
 
@@ -96,6 +112,7 @@ class LayerConfig(BaseConfig):
     )
     # whether to search image in subfolders as well
     full_search: bool = False
+    cleanup_on_exit: bool = False
 
     def get_label_color(self, label):
         for lbl in self.predefined_labels:
@@ -119,6 +136,7 @@ class CanvasConfig(BaseConfig):
     write_labels: bool = True
     write_masks: bool = True
     fps: int = 5
+    max_edge_width: int = 100
 
     @property
     def export_folder(self):

imagebaker/core/defs/defs.py

@@ -76,6 +76,8 @@ class LayerState:
     is_annotable: bool = True
     status: str = "Ready"
     drawing_states: list[DrawingState] = field(default_factory=list)
+    edge_opacity: int = 100
+    edge_width: int = 10
 
     def copy(self):
         return LayerState(
@@ -105,6 +107,8 @@ class LayerState:
                 )
                 for d in self.drawing_states
             ],
+            edge_opacity=self.edge_opacity,
+            edge_width=self.edge_width,
         )
 
 
@@ -206,6 +210,10 @@ class Annotation:
     def load_from_json(path: str):
         import json
 
+        # if path does not exist, return empty list
+        if not Path(path).exists():
+            return []
+
         with open(path, "r") as f:
             data = json.load(f)
 

imagebaker/layers/annotable_layer.py

@@ -42,6 +42,7 @@ class AnnotableLayer(BaseLayer):
     annotationCleared = Signal()
     annotationMoved = Signal()
     layersChanged = Signal()
+    labelUpdated = Signal(tuple)
 
     def __init__(self, parent, config: LayerConfig, canvas_config: CanvasConfig):
         super().__init__(parent, config)
@@ -54,6 +55,7 @@ class AnnotableLayer(BaseLayer):
         self.file_path: Path = Path("Runtime")
         self.layers: list[BaseLayer] = []
         self.is_annotable = True
+        self.handle_zoom: float = 1
 
     def init_ui(self):
         logger.info(f"Initializing Layer UI of {self.layer_name}")
@@ -157,14 +159,14 @@ class AnnotableLayer(BaseLayer):
             self.config.normal_draw_config.brush_alpha,
         )
 
-        pen = QPen(pen_color, self.config.normal_draw_config.line_width)
+        pen = QPen(pen_color, self.config.normal_draw_config.line_width / self.scale)
         brush = QBrush(brush_color, Qt.DiagCrossPattern)
 
         if annotation.selected:
             painter.setPen(
                 QPen(
                     self.config.selected_draw_config.color,
-                    self.config.selected_draw_config.line_width,
+                    self.config.selected_draw_config.line_width / self.scale,
                 )
             )
             painter.setBrush(
@@ -184,8 +186,8 @@ class AnnotableLayer(BaseLayer):
             elif annotation.points:
                 painter.drawEllipse(
                     annotation.points[0],
-                    self.config.selected_draw_config.ellipse_size,
-                    self.config.selected_draw_config.ellipse_size,
+                    self.config.selected_draw_config.ellipse_size / self.scale,
+                    self.config.selected_draw_config.ellipse_size / self.scale,
                 )
 
         if is_temp:
@@ -200,8 +202,8 @@ class AnnotableLayer(BaseLayer):
             for point in annotation.points:
                 painter.drawEllipse(
                     point,
-                    self.config.normal_draw_config.point_size,
-                    self.config.normal_draw_config.point_size,
+                    self.config.normal_draw_config.point_size / self.scale,
+                    self.config.normal_draw_config.point_size / self.scale,
                 )
         elif annotation.rectangle:
             painter.drawRect(annotation.rectangle)
@@ -223,28 +225,34 @@ class AnnotableLayer(BaseLayer):
             ]
             painter.save()
             painter.setPen(
-                QPen(Qt.black, self.config.normal_draw_config.control_point_size)
+                QPen(
+                    Qt.black,
+                    self.config.normal_draw_config.control_point_size / self.scale,
+                )
             )
             painter.setBrush(QBrush(Qt.white))
             for corner in corners:
                 painter.drawEllipse(
                     corner,
-                    self.config.normal_draw_config.point_size,
-                    self.config.normal_draw_config.point_size,
+                    self.config.normal_draw_config.point_size / self.scale,
+                    self.config.normal_draw_config.point_size / self.scale,
                 )
             painter.restore()
 
         if annotation.polygon and len(annotation.polygon) > 0:
             painter.save()
             painter.setPen(
-                QPen(Qt.white, self.config.normal_draw_config.control_point_size)
+                QPen(
+                    Qt.white,
+                    self.config.normal_draw_config.control_point_size / self.scale,
+                )
             )
             painter.setBrush(QBrush(Qt.darkGray))
             for point in annotation.polygon:
                 painter.drawEllipse(
                     point,
-                    self.config.normal_draw_config.point_size,
-                    self.config.normal_draw_config.point_size,
+                    self.config.normal_draw_config.point_size / self.scale,
+                    self.config.normal_draw_config.point_size / self.scale,
                 )
             painter.restore()
 
@@ -266,7 +274,7 @@ class AnnotableLayer(BaseLayer):
             # Set up font
             font = painter.font()
             font.setPixelSize(
-                self.config.normal_draw_config.label_font_size
+                self.config.normal_draw_config.label_font_size * self.scale
             )  # Fixed screen size
             painter.setFont(font)
 
@@ -300,7 +308,10 @@ class AnnotableLayer(BaseLayer):
             painter.save()
             handle_color = self.config.selected_draw_config.handle_color
             painter.setPen(
-                QPen(handle_color, self.config.selected_draw_config.handle_width)
+                QPen(
+                    handle_color,
+                    self.config.selected_draw_config.handle_width / self.scale,
+                )
             )
             painter.setBrush(QBrush(handle_color))
 
@@ -315,8 +326,8 @@ class AnnotableLayer(BaseLayer):
                 ]:
                     painter.drawEllipse(
                         corner,
-                        self.config.selected_draw_config.handle_point_size,
-                        self.config.selected_draw_config.handle_point_size,
+                        self.config.selected_draw_config.handle_point_size / self.scale,
+                        self.config.selected_draw_config.handle_point_size / self.scale,
                     )
                 # Draw edge handles
                 for edge in [
@@ -327,8 +338,8 @@ class AnnotableLayer(BaseLayer):
                 ]:
                     painter.drawEllipse(
                         edge,
-                        self.config.selected_draw_config.handle_edge_size,
-                        self.config.selected_draw_config.handle_edge_size,
+                        self.config.selected_draw_config.handle_edge_size / self.scale,
+                        self.config.selected_draw_config.handle_edge_size / self.scale,
                     )
 
             elif annotation.polygon:
@@ -336,8 +347,8 @@ class AnnotableLayer(BaseLayer):
                 for point in annotation.polygon:
                     painter.drawEllipse(
                         point,
-                        self.config.selected_draw_config.handle_point_size,
-                        self.config.selected_draw_config.handle_point_size,
+                        self.config.selected_draw_config.handle_point_size / self.scale,
+                        self.config.selected_draw_config.handle_point_size / self.scale,
                     )
 
             painter.restore()
@@ -524,13 +535,11 @@ class AnnotableLayer(BaseLayer):
                     self.current_annotation.polygon = QPolygonF(
                         [p for p in self.current_annotation.polygon][:-1]
                     )
-                    self.update()
 
                 # If the polygon is now empty, reset to idle mode
                 if len(self.current_annotation.polygon) == 0:
                     self.current_annotation = None
                     self.mouse_mode = MouseMode.IDLE
-                    self.update()
 
             # If not drawing a polygon, go to idle mode
             if not self.current_annotation:
@@ -538,7 +547,7 @@ class AnnotableLayer(BaseLayer):
                 for ann in self.annotations:
                     ann.selected = False
                     self.annotationUpdated.emit(ann)
-                self.update()
+            self.update()
 
         # If left-clicked
         if event.button() == Qt.LeftButton:
@@ -741,8 +750,8 @@ class AnnotableLayer(BaseLayer):
                 and len(self.current_annotation.polygon) >= 3
             ):
                 self.current_annotation.is_complete = True
+
                 self.finalize_annotation()
-                self.annotationAdded.emit(self.current_annotation)
                 self.current_annotation = None
 
                 return
@@ -784,6 +793,7 @@ class AnnotableLayer(BaseLayer):
             self, "Edit Label", "Enter new label:", text=annotation.label
         )
         if ok and new_label:
+            self.labelUpdated.emit((annotation.label, new_label))
             annotation.label = new_label
             self.annotationUpdated.emit(annotation)  # Emit signal
             self.update()
@@ -906,6 +916,8 @@ class AnnotableLayer(BaseLayer):
             f"{annotation.label} {annotation.annotation_id} {annotation.annotator}"
         )
 
+        new_layer._apply_edge_opacity()
+        new_layer.update()
         self.messageSignal.emit(f"Layerified: {new_layer.layer_name}")
         logger.info(f"Num annotations: {len(self.annotations)}")
 

imagebaker/layers/base_layer.py

@@ -18,6 +18,8 @@ from PySide6.QtWidgets import QWidget
 
 from typing import Optional
 from pathlib import Path
+import cv2
+import numpy as np
 
 
 class BaseLayer(QWidget):
@@ -157,7 +159,8 @@ class BaseLayer(QWidget):
         self.offset: QPointF = QPointF(0, 0)
         self.pan_start: QPointF = None
         self.pan_offset: QPointF = None
-        self.image = QPixmap()
+        self._image = QPixmap()
+        self._original_image = QPixmap()
         self.annotations: list[Annotation] = []
         self.current_annotation: Optional[Annotation] = None
         self.copied_annotation: Optional[Annotation] = None
@@ -365,8 +368,120 @@ class BaseLayer(QWidget):
             self.reset_view()
             self.update()
 
+        self._original_image = self.image.copy()  # Store a copy of the original image
         self.original_size = QSizeF(self.image.size())  # Store original size
 
+    @property
+    def image(self):
+        """
+        Get the current image of the canvas layer.
+
+        Returns:
+            QPixmap: The current image of the canvas layer.
+        """
+        return self._image
+
+    @image.setter
+    def image(self, value: QPixmap):
+        """
+        Set the image of the canvas layer.
+
+        Args:
+            value (QPixmap): The new image for the canvas layer.
+        """
+        self._image = value
+
+    def _apply_edge_opacity(self):
+        """
+        Apply edge opacity to the image. This function modifies the edges of the image
+        to have reduced opacity based on the configuration.
+        """
+        logger.debug("Applying edge opacity to the image.")
+        edge_width = self.edge_width
+        edge_opacity = self.edge_opacity
+
+        # Convert QPixmap to QImage for pixel manipulation
+        image = self._original_image.toImage()
+        image = image.convertToFormat(
+            QImage.Format_ARGB32
+        )  # Ensure format supports alpha
+
+        width = image.width()
+        height = image.height()
+        annotation = self.annotations[0] if self.annotations else None
+        if annotation is None:
+            return
+
+        if annotation.rectangle:
+            for x in range(width):
+                for y in range(height):
+                    color = image.pixelColor(x, y)
+                    if color.alpha() != 0:  # If the pixel is not fully transparent
+                        # Calculate horizontal and vertical distances to the edges
+                        horizontal_distance = min(x, width - x - 1)
+                        vertical_distance = min(y, height - y - 1)
+
+                        # If the pixel is within the edge region
+                        if (
+                            horizontal_distance < edge_width
+                            or vertical_distance < edge_width
+                        ):
+                            distance_to_edge = min(
+                                horizontal_distance, vertical_distance
+                            )
+                            # Calculate the new alpha based on the distance to the edge
+                            factor = (edge_width - distance_to_edge) / edge_width
+                            new_alpha = int(
+                                color.alpha()
+                                * ((1 - factor) + (factor * (edge_opacity / 255.0)))
+                            )
+                            color.setAlpha(new_alpha)
+                            image.setPixelColor(x, y, color)
+
+        elif annotation.polygon:
+            # Extract alpha channel and find contours
+            alpha_image = image.convertToFormat(QImage.Format_Alpha8)
+            bytes_per_line = (
+                alpha_image.bytesPerLine()
+            )  # Get the stride (bytes per line)
+            alpha_data = alpha_image.bits().tobytes()
+
+            # Extract only the valid data (remove padding)
+            alpha_array = np.frombuffer(alpha_data, dtype=np.uint8).reshape(
+                (alpha_image.height(), bytes_per_line)
+            )[
+                :, : alpha_image.width()
+            ]  # Remove padding to match the actual width
+
+            # Use OpenCV to find contours
+            contours, _ = cv2.findContours(
+                alpha_array, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE
+            )
+
+            # Iterate over each pixel and apply edge opacity
+            for x in range(width):
+                for y in range(height):
+                    color = image.pixelColor(x, y)
+                    if color.alpha() != 0:  # If the pixel is not fully transparent
+                        # Calculate distance to the nearest contour
+                        distance_to_edge = cv2.pointPolygonTest(
+                            contours[0], (x, y), True
+                        )  # True for distance calculation
+
+                        # If the pixel is within the edge region
+                        if 0 <= distance_to_edge < edge_width:
+                            # Calculate the new alpha based on the distance to the edge
+                            factor = (edge_width - distance_to_edge) / edge_width
+                            new_alpha = int(
+                                color.alpha()
+                                * ((1 - factor) + (factor * (edge_opacity / 255.0)))
+                            )
+                            color.setAlpha(new_alpha)
+                            image.setPixelColor(x, y, color)
+
+        # Convert the modified QImage back to QPixmap
+        self.image = QPixmap.fromImage(image)
+
     def get_thumbnail(self, annotation: Annotation = None):
         """
         Generate a thumbnail for the layer or a specific annotation.
@@ -722,3 +837,19 @@ class BaseLayer(QWidget):
     @drawing_states.setter
     def drawing_states(self, value: list[DrawingState]):
         self.layer_state.drawing_states = value
+
+    @property
+    def edge_opacity(self) -> int:
+        return self.layer_state.edge_opacity
+
+    @edge_opacity.setter
+    def edge_opacity(self, value: int):
+        self.layer_state.edge_opacity = value
+
+    @property
+    def edge_width(self) -> int:
+        return self.layer_state.edge_width
+
+    @edge_width.setter
+    def edge_width(self, value: int):
+        self.layer_state.edge_width = value

imagebaker/layers/canvas_layer.py

@@ -27,6 +27,7 @@ from PySide6.QtGui import (
     QMouseEvent,
     QKeyEvent,
     QTransform,
+    QImage,
 )
 from PySide6.QtWidgets import (
     QApplication,
@@ -57,7 +58,6 @@ class CanvasLayer(BaseLayer):
             config (CanvasConfig): Configuration settings for the canvas layer.
         """
         super().__init__(parent, config)
-        self.image = QPixmap()
         self.is_annotable = False
         self.last_pan_point = None
         self.state_thumbnail = dict()
@@ -178,6 +178,7 @@ class CanvasLayer(BaseLayer):
                 opacity = layer.opacity / 255.0
                 temp_painter.setOpacity(opacity)  # Scale opacity to 0.0-1.0
                 temp_painter.drawPixmap(0, 0, layer.image)
+
                 temp_painter.end()
 
                 # Draw the modified pixmap
@@ -287,20 +288,20 @@ class CanvasLayer(BaseLayer):
         painter.setPen(
             QPen(
                 self.config.selected_draw_config.handle_color,
-                self.config.selected_draw_config.handle_width,
+                self.config.selected_draw_config.handle_width / self.scale,
             )
         )
         painter.setBrush(self.config.selected_draw_config.handle_color)
         painter.drawEllipse(
             rotation_pos,
-            self.config.selected_draw_config.handle_point_size * 2,
-            self.config.selected_draw_config.handle_point_size * 2,
+            self.config.selected_draw_config.handle_point_size * 1.1 / self.scale,
+            self.config.selected_draw_config.handle_point_size * 1.1 / self.scale,
         )
         # now draw rotation symbol
         painter.setPen(
             QPen(
                 self.config.selected_draw_config.handle_color,
-                self.config.selected_draw_config.handle_width,
+                self.config.selected_draw_config.handle_width / self.scale,
             )
         )
         painter.drawLine(
@@ -323,21 +324,23 @@ class CanvasLayer(BaseLayer):
         # Draw scale handles
         handle_color = self.config.selected_draw_config.handle_color
         painter.setPen(
-            QPen(handle_color, self.config.selected_draw_config.handle_width)
+            QPen(
+                handle_color, self.config.selected_draw_config.handle_width / self.scale
+            )
         )
         painter.setBrush(self.config.selected_draw_config.handle_color)
         for corner in corners:
             painter.drawEllipse(
                 corner,
-                self.config.selected_draw_config.handle_point_size,
-                self.config.selected_draw_config.handle_point_size,
+                self.config.selected_draw_config.handle_point_size / self.scale,
+                self.config.selected_draw_config.handle_point_size / self.scale,
             )
         for edge in edges:
             # draw small circles on the edges
             painter.drawEllipse(
                 edge,
-                self.config.selected_draw_config.handle_edge_size,
-                self.config.selected_draw_config.handle_edge_size,
+                self.config.selected_draw_config.handle_edge_size / self.scale,
+                self.config.selected_draw_config.handle_edge_size / self.scale,
             )
             # draw sides
             painter.drawLine(
@@ -874,6 +877,33 @@ class CanvasLayer(BaseLayer):
         """
         self.export_current_state(export_to_annotation_tab=True)
 
+    def seek_state(self, step):
+        """Seek to a specific state using the timeline slider."""
+        self.messageSignal.emit(f"Seeking to step {step}")
+        logger.info(f"Seeking to step {step}")
+
+        # Get the states for the selected step
+        if step in self.states:
+            states = self.states[step]
+            for state in states:
+                layer = self.get_layer(state.layer_id)
+                if layer:
+                    # Update the layer's state
+                    update_opacities = False
+                    logger.debug(
+                        f"Updating layer {layer.layer_name} with state: {state}"
+                    )
+
+                    if (
+                        layer.edge_width != state.edge_width
+                        or layer.edge_opacity != state.edge_opacity
+                    ):
+                        update_opacities = True
+                    layer.layer_state = state
+                    if update_opacities:
+                        layer._apply_edge_opacity()
+                    layer.update()
+
     def play_states(self):
         """Play all the states stored in self.states."""
         if len(self.states) == 0:
@@ -896,7 +926,19 @@ class CanvasLayer(BaseLayer):
                 layer = self.get_layer(state.layer_id)
                 if layer:
                     # Update the layer's state
+                    update_opacities = False
+                    logger.debug(
+                        f"Updating layer {layer.layer_name} with state: {state}"
+                    )
+
+                    if (
+                        layer.edge_width != state.edge_width
+                        or layer.edge_opacity != state.edge_opacity
+                    ):
+                        update_opacities = True
                     layer.layer_state = state
+                    if update_opacities:
+                        layer._apply_edge_opacity()
                     layer.update()
 
             # Update the UI to reflect the changes
@@ -988,7 +1030,7 @@ class CanvasLayer(BaseLayer):
                     logger.info(f"Saved baked image to {filename}")
                     if self.config.write_annotations:
                         image = qpixmap_to_numpy(image.copy())
-                        image = cv2.cvtColor(image, cv2.COLOR_RGBA2BGR)
+                        image = cv2.cvtColor(image, cv2.COLOR_RGBA2BGRA)
                         drawn = draw_annotations(image, annotations)
                         write_to = filename.parent / f"annotated_{filename.name}"
 

imagebaker/list_views/annotation_list.py

@@ -52,6 +52,7 @@ class AnnotationList(QDockWidget):
         if self.layer is None:
             return
         for idx, ann in enumerate(self.layer.annotations):
+
             item = QListWidgetItem(self.list_widget)
 
             # Create container widget

imagebaker/list_views/image_list.py

@@ -19,6 +19,7 @@ from pathlib import Path
 
 class ImageListPanel(QDockWidget):
     imageSelected = Signal(Path)
+    activeImageEntries = Signal(list)
 
     def __init__(
         self,
@@ -26,6 +27,7 @@ class ImageListPanel(QDockWidget):
         processed_images: set[Path],
         parent=None,
         max_name_length=15,
+        images_per_page=10,
     ):
         """
         :param image_entries: List of image paths to display.
@@ -35,7 +37,7 @@ class ImageListPanel(QDockWidget):
         self.image_entries: list["ImageEntry"] = image_entries
         self.processed_images = processed_images
         self.current_page = 0
-        self.images_per_page = 10
+        self.images_per_page = images_per_page
         self.max_name_length = max_name_length
         self.init_ui()
 
@@ -90,7 +92,20 @@ class ImageListPanel(QDockWidget):
         """Update the image list with image paths and baked results."""
         self.list_widget.clear()
 
-        for idx, image_entry in enumerate(image_entries):
+        # Calculate the range of images to display for the current page
+        start_index = self.current_page * self.images_per_page
+        end_index = min(start_index + self.images_per_page, len(image_entries))
+
+        # Update the pagination label
+        self.pagination_label.setText(
+            f"Showing {start_index + 1} to {end_index} of {len(image_entries)}"
+        )
+
+        # Display only the images for the current page
+        active_image_entries = []
+        for idx, image_entry in enumerate(
+            image_entries[start_index:end_index], start=start_index + 1
+        ):
             item_widget = QWidget()
             item_layout = QHBoxLayout(item_widget)
             item_layout.setContentsMargins(5, 5, 5, 5)
@@ -101,7 +116,7 @@ class ImageListPanel(QDockWidget):
                 thumbnail_pixmap = (
                     image_entry.data.get_thumbnail()
                 )  # Baked result thumbnail
-                name_label_text = f"Baked Result {idx + 1}"
+                name_label_text = f"Baked Result {idx}"
             else:
                 thumbnail_pixmap = QPixmap(str(image_entry.data)).scaled(
                     50, 50, Qt.KeepAspectRatio, Qt.SmoothTransformation
@@ -126,11 +141,9 @@ class ImageListPanel(QDockWidget):
 
             # Store metadata for the image
             list_item.setData(Qt.UserRole, image_entry)
-        self.pagination_label.setText(
-            f"Showing {self.current_page * self.images_per_page + 1} to "
-            f"{min((self.current_page + 1) * self.images_per_page, len(image_entries))} "
-            f"of {len(image_entries)}"
-        )
+            active_image_entries.append(image_entry)
+
+        self.activeImageEntries.emit(active_image_entries)
         self.update()
 
     def handle_item_clicked(self, item: QListWidgetItem):