imagebaker 0.0.49__py3-none-any.whl → 0.0.50__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

@@ -119,6 +119,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,
         )
 
 

imagebaker/layers/annotable_layer.py

@@ -54,6 +54,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 +158,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 +185,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 +201,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 +224,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 +273,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 +307,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 +325,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 +337,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 +346,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()
@@ -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

imagebaker/list_views/layer_settings.py

@@ -20,7 +20,14 @@ class LayerSettings(QDockWidget):
     layerState = Signal(LayerState)
     messageSignal = Signal(str)
 
-    def __init__(self, parent=None, max_xpos=1000, max_ypos=1000, max_scale=100):
+    def __init__(
+        self,
+        parent=None,
+        max_xpos=1000,
+        max_ypos=1000,
+        max_scale=100,
+        max_edge_width=10,
+    ):
         super().__init__("BaseLayer Settings", parent)
         self.selected_layer: BaseLayer = None
 
@@ -29,6 +36,7 @@ class LayerSettings(QDockWidget):
         self.max_xpos = max_xpos
         self.max_ypos = max_ypos
         self.max_scale = max_scale
+        self.max_edge_width = max_edge_width
         self.init_ui()
         self.setFeatures(
             QDockWidget.DockWidgetMovable | QDockWidget.DockWidgetFloatable
@@ -67,6 +75,12 @@ class LayerSettings(QDockWidget):
         self.main_layout.addWidget(self.scale_y_slider["widget"])
         self.rotation_slider = self.create_slider("Rotation:", 0, 360, 0, 1)
         self.main_layout.addWidget(self.rotation_slider["widget"])
+        self.edge_opacity_slider = self.create_slider("Edge Opacity:", 0, 255, 255, 1)
+        self.main_layout.addWidget(self.edge_opacity_slider["widget"])
+        self.edge_width_slider = self.create_slider(
+            "Edge Width:", 0, self.max_edge_width, 5, 1
+        )
+        self.main_layout.addWidget(self.edge_width_slider["widget"])
 
         # Add stretch to push content to the top
         self.main_layout.addStretch()
@@ -125,7 +139,6 @@ class LayerSettings(QDockWidget):
 
         try:
             self._disable_updates = True
-
             if sender == self.opacity_slider["slider"]:
                 self.selected_layer.opacity = value
             elif sender == self.x_slider["slider"]:
@@ -138,6 +151,12 @@ class LayerSettings(QDockWidget):
                 self.selected_layer.scale_y = value / 100.0
             elif sender == self.rotation_slider["slider"]:
                 self.selected_layer.rotation = value
+            elif sender == self.edge_opacity_slider["slider"]:
+                self.selected_layer.edge_opacity = value
+                self.selected_layer._apply_edge_opacity()
+            elif sender == self.edge_width_slider["slider"]:
+                self.selected_layer.edge_width = value
+                self.selected_layer._apply_edge_opacity()
 
             self.selected_layer.update()  # Trigger a repaint
 
@@ -154,6 +173,10 @@ class LayerSettings(QDockWidget):
             rotation=self.selected_layer.rotation,
             scale_x=self.selected_layer.scale_x,
             scale_y=self.selected_layer.scale_y,
+            opacity=self.selected_layer.opacity,
+            edge_opacity=self.selected_layer.edge_opacity,
+            edge_width=self.selected_layer.edge_width,
+            visible=self.selected_layer.visible,
         )
         logger.info(f"Storing state {bake_settings}")
         self.messageSignal.emit(f"Stored state for {bake_settings.layer_name}")
@@ -211,6 +234,12 @@ class LayerSettings(QDockWidget):
                 self.rotation_slider["slider"].setValue(
                     int(self.selected_layer.rotation)
                 )
+                self.edge_opacity_slider["slider"].setValue(
+                    int(self.selected_layer.edge_opacity)
+                )
+                self.edge_width_slider["slider"].setValue(
+                    int(self.selected_layer.edge_width)
+                )
             else:
                 self.widget.setEnabled(False)
                 self.layer_name_label.setText("No BaseLayer")

imagebaker/models/base_model.py

@@ -39,7 +39,7 @@ class BaseModel(ABC):
         return image
 
     # @abstractmethod
-    def postprocess(self, output) -> PredictionResult:
+    def postprocess(self, output) -> list[PredictionResult]:
         return output
 
     def predict(

imagebaker/tabs/baker_tab.py

@@ -66,6 +66,7 @@ class BakerTab(QWidget):
             max_xpos=self.config.max_xpos,
             max_ypos=self.config.max_ypos,
             max_scale=self.config.max_scale,
+            max_edge_width=self.config.max_edge_width,
         )
         self.layer_list = LayerList(
             canvas=self.current_canvas,
@@ -415,15 +416,7 @@ class BakerTab(QWidget):
         """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.current_canvas.states:
-            states = self.current_canvas.states[step]
-            for state in states:
-                layer = self.current_canvas.get_layer(state.layer_id)
-                if layer:
-                    layer.layer_state = state
-                    layer.update()
+        self.current_canvas.seek_state(step)
 
         # Update the canvas
         self.current_canvas.update()

imagebaker/tabs/layerify_tab.py

@@ -463,6 +463,7 @@ class LayerifyTab(QWidget):
     def handle_model_error(self, error):
         logger.error(f"Model error: {error}")
         QMessageBox.critical(self, "Error", f"Model error: {error}")
+        self.loading_dialog.close()
 
     def save_annotations(self):
         """Save annotations to a JSON file."""

imagebaker/utils/__init__.py

@@ -0,0 +1,3 @@
+from .utils import *  # noqa: F401, F403
+from .transform_mask import *  # noqa: F401, F403
+from .vis import *  # noqa: F401, F403

imagebaker/utils/state_utils.py

@@ -59,9 +59,13 @@ def calculate_intermediate_states(
             visible=current_state.visible,
             allow_annotation_export=current_state.allow_annotation_export,
             playing=current_state.playing,
-            selected=current_state.selected,
+            selected=False,
             is_annotable=current_state.is_annotable,
             status=current_state.status,
+            edge_opacity=previous_state.edge_opacity
+            + (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),
         )
 
         # Deep copy the drawing_states from the previous_state

imagebaker/utils/utils.py

@@ -0,0 +1,26 @@
+import numpy as np
+import cv2
+
+
+def generate_color_map(num_colors: int = 20):
+    """Generate a color map for the segmentation masks"""
+    np.random.seed(42)  # For reproducible colors
+
+    colors = {}
+    for i in range(num_colors):
+        # Generate distinct colors with good visibility
+        # Using HSV color space for better distribution
+        hue = i / num_colors
+        saturation = 0.8 + np.random.random() * 0.2
+        value = 0.8 + np.random.random() * 0.2
+
+        # Convert HSV to BGR (OpenCV uses BGR)
+        hsv_color = np.array(
+            [[[hue * 180, saturation * 255, value * 255]]], dtype=np.uint8
+        )
+        bgr_color = cv2.cvtColor(hsv_color, cv2.COLOR_HSV2BGR)[0][0]
+
+        # Store as (B, G, R) tuple
+        colors[i] = (int(bgr_color[0]), int(bgr_color[1]), int(bgr_color[2]))
+
+    return colors

imagebaker/utils/vis.py

@@ -0,0 +1,174 @@
+from imagebaker.core.defs import PredictionResult
+
+import cv2
+import numpy as np
+from typing import List
+
+
+def annotate_detection(
+    image: np.ndarray,
+    results: List[PredictionResult],
+    color_map: dict[str, tuple[int, int, int]],
+    box_thickness: int = 2,
+    font_face: int = cv2.FONT_HERSHEY_SIMPLEX,
+    text_scale: float = 0.5,
+    text_thickness: int = 1,
+) -> np.ndarray:
+    """
+    Draw bounding boxes and labels on the image
+
+    Args:
+        image: The original image as a numpy array
+        results: List of PredictionResult objects
+
+    Returns:
+        Annotated image as a numpy array
+    """
+    annotated_image = image.copy()
+
+    for result in results:
+        # Extract data from result
+        box = result.rectangle  # [x1, y1, x2, y2]
+        score = result.score
+        class_name = result.class_name
+
+        if not box:
+            continue
+
+        # Get color for this class
+        color = color_map.get(
+            result.class_name, (0, 255, 0)
+        )  # Default to green if not found
+
+        # Draw bounding box
+        cv2.rectangle(
+            annotated_image,
+            (box[0], box[1]),
+            (box[2], box[3]),
+            color,
+            box_thickness,
+        )
+
+        # Prepare label text with class name and score
+        label_text = f"{class_name}: {score:.2f}"
+
+        # Calculate text size to create background rectangle
+        (text_width, text_height), baseline = cv2.getTextSize(
+            label_text,
+            font_face,
+            text_scale,
+            text_thickness,
+        )
+
+        # Draw text background
+        cv2.rectangle(
+            annotated_image,
+            (box[0], box[1] - text_height - 5),
+            (box[0] + text_width, box[1]),
+            color,
+            -1,  # Fill the rectangle
+        )
+
+        # Draw text
+        cv2.putText(
+            annotated_image,
+            label_text,
+            (box[0], box[1] - 5),
+            font_face,
+            text_scale,
+            (255, 255, 255),  # White text
+            text_thickness,
+        )
+
+    return annotated_image
+
+
+def annotate_segmentation(
+    image: np.ndarray,
+    results: List[PredictionResult],
+    color_map: dict[int, tuple[int, int, int]],
+    contour_thickness: int = 2,
+    mask_opacity: float = 0.5,
+    font_face: int = cv2.FONT_HERSHEY_SIMPLEX,
+    text_scale: float = 0.5,
+    text_thickness: int = 1,
+) -> np.ndarray:
+    """
+    Draw segmentation masks and contours on the image
+    """
+    annotated_image = image.copy()
+    mask_overlay = np.zeros_like(image)
+
+    for i, result in enumerate(results):
+        if (result.polygon is not None) or not result.mask:
+            continue
+
+        # Get color for this mask
+        color_idx = i % len(color_map)
+        color = color_map[color_idx]
+
+        # Create mask from polygons
+        mask = np.zeros((image.shape[0], image.shape[1]), dtype=np.uint8)
+        for poly in result.polygon:
+            poly_np = np.array(poly, dtype=np.int32).reshape((-1, 1, 2))
+            cv2.fillPoly(mask, [poly_np], 1)
+
+        # Apply color to mask overlay
+        color_mask = np.zeros_like(image)
+        color_mask[mask == 1] = color
+        mask_overlay = cv2.addWeighted(mask_overlay, 1.0, color_mask, 1.0, 0)
+
+        # Draw contours
+        for poly in result.polygon:
+            poly_np = np.array(poly, dtype=np.int32).reshape((-1, 1, 2))
+            cv2.polylines(
+                annotated_image,
+                [poly_np],
+                True,
+                color,
+                contour_thickness,
+            )
+
+        # Add label text
+        label_position = (
+            result.polygon[0][0] if result.polygon and result.polygon[0] else [10, 10]
+        )
+        label_text = f"{result.class_id}: {result.score:.2f}"
+
+        # Draw text background
+        (text_width, text_height), baseline = cv2.getTextSize(
+            label_text,
+            font_face,
+            text_scale,
+            text_thickness,
+        )
+
+        cv2.rectangle(
+            annotated_image,
+            (label_position[0], label_position[1] - text_height - 5),
+            (label_position[0] + text_width, label_position[1]),
+            color,
+            -1,  # Fill the rectangle
+        )
+
+        # Draw text
+        cv2.putText(
+            annotated_image,
+            label_text,
+            (label_position[0], label_position[1] - 5),
+            font_face,
+            text_scale,
+            (255, 255, 255),  # White text
+            text_thickness,
+        )
+
+    # Blend mask overlay with original image
+    annotated_image = cv2.addWeighted(
+        annotated_image,
+        1.0,
+        mask_overlay,
+        mask_opacity,
+        0,
+    )
+
+    return annotated_image

imagebaker/workers/baker_worker.py

@@ -49,10 +49,23 @@ class BakerWorker(QObject):
                 top_left = QPointF(sys.maxsize, sys.maxsize)
                 bottom_right = QPointF(-sys.maxsize, -sys.maxsize)
 
+                # contains all states in currenct step
                 for state in states:
                     layer = self._get_layer(state.layer_id)
                     if layer and layer.visible and not layer.image.isNull():
+                        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()
 
                         transform = QTransform()

{imagebaker-0.0.49.dist-info → imagebaker-0.0.50.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: imagebaker
-Version: 0.0.49
+Version: 0.0.50
 Summary: A package for baking images.
 Home-page: https://github.com/q-viper/Image-Baker
 Author: Ramkrishna Acharya
@@ -35,7 +35,7 @@ Requires-Dist: mkdocs-awesome-pages-plugin; extra == "docs"
 ![code size in bytes](https://img.shields.io/github/languages/code-size/q-viper/image-baker)
 <!-- ![Tests](https://github.com/q-viper/SmokeSim/actions/workflows/test-on-push.yml/badge.svg) -->
 ![Code Formatting](https://github.com/q-viper/image-baker/actions/workflows/black-formatter.yml/badge.svg)
-
+[![PyPI version](https://img.shields.io/pypi/v/imagebaker.svg)](https://pypi.org/imagebaker/)
 
 <p align="center">
     <img src="assets/demo.gif" alt="Centered Demo" />

{imagebaker-0.0.49.dist-info → imagebaker-0.0.50.dist-info}/RECORD

@@ -1,41 +1,43 @@
-imagebaker/__init__.py,sha256=ep22Ki-KljDvYzGvAfrDe9UU77GWgfoAsLd7t0S273c,130
+imagebaker/__init__.py,sha256=zrrxwyzuqVNeIu3rVPrOGYf6SCd5kWsoGcdqqUfsYX4,258
 imagebaker/core/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 imagebaker/core/configs/__init__.py,sha256=iyR_GOVMFw3XJSm7293YfyTnaLZa7pLQMfn5tGxVofI,31
-imagebaker/core/configs/configs.py,sha256=uyUhoHA9-Ult-vVtnLX-JNmeUght4mUUV80yKWzUO_o,5100
+imagebaker/core/configs/configs.py,sha256=-qy7vmYaaUk3bh49pwsBig8de_3Y2JWjTDeyWcGQods,5130
 imagebaker/core/defs/__init__.py,sha256=NqV7gYIlRkaS7nx_UTNPSNZbdPrx4w-VurKOKyRLbKY,28
-imagebaker/core/defs/defs.py,sha256=nIg2ZQADbpcyC0ZOl54L14yLZ38-SUnfMkklCDfhN3E,8257
+imagebaker/core/defs/defs.py,sha256=-ZItfJdWaK9yFSuFn2LmQ4ncqukAZ_hvYFgE44HUdIo,8394
 imagebaker/core/plugins/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 imagebaker/core/plugins/base_plugin.py,sha256=ROa1HTwV5LgGL-40CHKk_5MZYI5QAT1MzpYO7Fx-9P0,1084
 imagebaker/core/plugins/cosine_plugin.py,sha256=IXBfvaoxrvf-hytg_dT1zFmOfDbcWXBZ7NvIFPJ2tWQ,1251
 imagebaker/layers/__init__.py,sha256=q1kUDHhUXEGBOdu6CHDfqCnE2mraLHRqh0DFHYTbnRY,158
-imagebaker/layers/annotable_layer.py,sha256=ZjDqNMEqB78iEAThotfksv8-xIK6NCr52fI26Rv6CXA,36627
-imagebaker/layers/base_layer.py,sha256=uncseSxTbLKnV84hAPbJLDbBMV0nu1gQ4N-SLHoGB6s,25486
-imagebaker/layers/canvas_layer.py,sha256=47R-g3NAzAQ720tWrIZUYIAupxImdORVYK5BFIRopqo,40414
+imagebaker/layers/annotable_layer.py,sha256=ejBp6nooLtHs8c_G6lOsTJmSwBT404F_dmPsSkjvdEQ,37167
+imagebaker/layers/base_layer.py,sha256=1K7Nt6OPITrILj-p4I6Jf0eaesCpdeecOXGj_8oAQb8,30650
+imagebaker/layers/canvas_layer.py,sha256=7eDo0UHXRRZ5BX3BciPX88JsumzmwVemtS6cBjU9qwM,42115
 imagebaker/list_views/__init__.py,sha256=Aa9slE6do8eYgZp77wrofpd_mlBDwxgF3adMyHYFanE,144
 imagebaker/list_views/annotation_list.py,sha256=HGV6lGlkFjvJvvGnCcLuX1kkfXA0GL8wKo8jOXSBXec,7527
 imagebaker/list_views/canvas_list.py,sha256=JYSYR0peGyJFJ6amL1894KsUHETPUkR3qAWdGL50Lbc,6717
 imagebaker/list_views/image_list.py,sha256=NInkc893FGU7L6oSxy8KrWql-i6RB0BqvkroPAASjVw,4912
 imagebaker/list_views/layer_list.py,sha256=fLx3Ry72fas1W5y_V84hSp41ARneogQN3qjfYTOcpxY,14476
-imagebaker/list_views/layer_settings.py,sha256=38E39z-rEdl0YSe2C_k4wd5CgHPETQeJE5VvJLfFQ-k,8454
+imagebaker/list_views/layer_settings.py,sha256=0WVSCm_RSBKo4pCkYU5c2OYjb_sW8x0UUfFC4So26jQ,9752
 imagebaker/models/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-imagebaker/models/base_model.py,sha256=ZfZ_VgP-jzfmEAdOycVtOYkr03m8EyXWdmK0-50MxIk,4197
+imagebaker/models/base_model.py,sha256=4RyS4vShqWFHhdQDwYluwTPnRPEXjpZl9UjYY_w8NL0,4203
 imagebaker/tabs/__init__.py,sha256=ijg7MA17RvcHA2AuZE4OgRJXWxjecaUAlfASKAoCQ6Q,86
-imagebaker/tabs/baker_tab.py,sha256=kIVoF4w_Ch1YNdHtHsNZKfr46tZWBDSj5xrrEkF1piM,20752
-imagebaker/tabs/layerify_tab.py,sha256=2IEdRyYHhNdY2696YiLcnWWKYN6gYwcKH6jsffYiL5M,32304
-imagebaker/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+imagebaker/tabs/baker_tab.py,sha256=yFQRiNmLIua5BvgW7Ysj5FrNbTLhGxqGRTRCABxeTtw,20493
+imagebaker/tabs/layerify_tab.py,sha256=Qsf9w81-43sB0LZy_vIB4wCzUhHHhoIiarZJvKRxeZ0,32340
+imagebaker/utils/__init__.py,sha256=I1z5VVEf6QPOMvVkgVHDauQ9ew7tcTVguV4Kdi3Lk4Y,130
 imagebaker/utils/image.py,sha256=fq7g3DqSdjF9okxZ3fe5kF4Hxn32rqhvVqxy8yI5bnI,3067
-imagebaker/utils/state_utils.py,sha256=sI0R3ht4W_kQGwOpzUdBjy6M4PaKaAQlj-_MM6pidfM,3584
+imagebaker/utils/state_utils.py,sha256=Y2JVRGVfsoffwfA2lsCcqHwIxH_jOrEJAdH-oWfe2XE,3841
 imagebaker/utils/transform_mask.py,sha256=k8MfTgM5-_U2TvDHQHRelz-leGFX6OcsllV6-J4BKfw,3651
+imagebaker/utils/utils.py,sha256=MnJ4flxxwZbjROWJ5iKHnJxPSSMbfWRbF9GKfVcKutA,840
+imagebaker/utils/vis.py,sha256=f7c44gm6g9ja5hgVeXKfOhHzxHdzXcIUwKiA1RZU_F8,4736
 imagebaker/window/__init__.py,sha256=FIxtUR1qnbQMYzppQv7tEfv1-ueHhpu0Z7xuWZR794w,44
 imagebaker/window/app.py,sha256=e6FGO_BnvkiQC9JN3AmqkgbF72zzZS0hc7PFc43QiVc,4725
 imagebaker/window/main_window.py,sha256=gpJ7DDuPmxhHh_6Rv3YH2J_1AqG7-NM8R3tKNYhFT3E,7030
 imagebaker/workers/__init__.py,sha256=XfXENwAYyNg9q_zR-gOsYJGjzwg_iIb_gING8ydnp9c,154
-imagebaker/workers/baker_worker.py,sha256=JyV1Hu4mzbYhmogc7K3U24adklmT3x3V0ZNMxe7iT-w,10697
+imagebaker/workers/baker_worker.py,sha256=EJTL4ln09NuntFpu0o-Hfk0vCtDxpKqJxJcmtgTnMwo,11297
 imagebaker/workers/layerify_worker.py,sha256=EOqKvhdACtf3y5Ljy6M7MvddAjlZW5DNfBFMtNPD-us,3223
 imagebaker/workers/model_worker.py,sha256=Tlg6_D977iK-kuGCNdQY4OnGiP8QqWY7adpRNXZw4rA,1636
-imagebaker-0.0.49.dist-info/LICENSE,sha256=1vkysFPOnT7y4LsoFTv9YsopIrQvBc2l6vUOfv4KKLc,1082
-imagebaker-0.0.49.dist-info/METADATA,sha256=BldoEWej9PUXnJVw_rpJEYFnjXosJIXWKJB2oY9ZLyI,6736
-imagebaker-0.0.49.dist-info/WHEEL,sha256=tZoeGjtWxWRfdplE7E3d45VPlLNQnvbKiYnx7gwAy8A,92
-imagebaker-0.0.49.dist-info/entry_points.txt,sha256=IDjZHJCiiHpH5IUTByT2en0nMbnnnlrJZ5FPFehUvQM,61
-imagebaker-0.0.49.dist-info/top_level.txt,sha256=Gg-eILTlqJXwVQr0saSwsx3-H4SPdZ2agBZaufe194s,11
-imagebaker-0.0.49.dist-info/RECORD,,
+imagebaker-0.0.50.dist-info/LICENSE,sha256=1vkysFPOnT7y4LsoFTv9YsopIrQvBc2l6vUOfv4KKLc,1082
+imagebaker-0.0.50.dist-info/METADATA,sha256=Zsl37tIGiV9wrQ2zfiaubhmPbhOMucos2V_fF5mtbXU,6829
+imagebaker-0.0.50.dist-info/WHEEL,sha256=tZoeGjtWxWRfdplE7E3d45VPlLNQnvbKiYnx7gwAy8A,92
+imagebaker-0.0.50.dist-info/entry_points.txt,sha256=IDjZHJCiiHpH5IUTByT2en0nMbnnnlrJZ5FPFehUvQM,61
+imagebaker-0.0.50.dist-info/top_level.txt,sha256=Gg-eILTlqJXwVQr0saSwsx3-H4SPdZ2agBZaufe194s,11
+imagebaker-0.0.50.dist-info/RECORD,,