imagebaker 0.0.48__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.48"  # noqa
+try:
+    __version__ = version("imagebaker")
+except PackageNotFoundError:
+    __version__ = "0.0.0"

imagebaker/core/configs/configs.py

@@ -8,6 +8,11 @@ from pydantic import BaseModel, Field
 from imagebaker.core.defs import Label, ModelType
 from imagebaker import logger
 
+try:
+    from imagebaker import __version__
+except ImportError:
+    __version__ = "unknown"
+
 
 class DrawConfig(BaseModel):
     color: QColor = Field(default_factory=lambda: QColor(255, 255, 255))
@@ -37,11 +42,13 @@ class DrawConfig(BaseModel):
 
 class BaseConfig(BaseModel):
     project_name: str = "ImageBaker"
-    version: str = "0.1.0"
+    version: str = __version__
     project_dir: Path = Path(".")
 
     is_debug: bool = True
     deque_maxlen: int = 10
+    # max num_characters to show in name
+    max_name_length: int = 15
 
     # drawing configs #
     # ON SELECTION
@@ -87,6 +94,8 @@ class LayerConfig(BaseConfig):
             Label("Custom", QColor(128, 128, 128)),
         ]
     )
+    # whether to search image in subfolders as well
+    full_search: bool = False
 
     def get_label_color(self, label):
         for lbl in self.predefined_labels:
@@ -110,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()
@@ -472,10 +482,13 @@ class AnnotableLayer(BaseLayer):
                     self.selected_annotation.polygon[self.active_point_index] = (
                         clamped_pos
                     )
+                elif self.selected_annotation.points:
+                    self.selected_annotation.points[0] = clamped_pos
                 self.annotationMoved.emit()
                 self.annotationUpdated.emit(self.selected_annotation)
                 self.update()
                 return
+
             if self.mouse_mode == MouseMode.PAN and event.buttons() & Qt.LeftButton:
                 if self.pan_start:
                     delta = event.position() - self.pan_start
@@ -534,6 +547,7 @@ class AnnotableLayer(BaseLayer):
                 self.mouse_mode = MouseMode.IDLE
                 for ann in self.annotations:
                     ann.selected = False
+                    self.annotationUpdated.emit(ann)
                 self.update()
 
         # If left-clicked
@@ -559,7 +573,9 @@ class AnnotableLayer(BaseLayer):
                 elif self.selected_annotation.polygon:
                     self.initial_polygon = QPolygonF(self.selected_annotation.polygon)
                     if "point_" in self.active_handle:
-                        self.active_point = int(self.active_handle.split("_")[1])
+                        self.active_point_index = int(self.active_handle.split("_")[1])
+                elif self.selected_annotation.points:
+                    self.active_point_index = 0
 
             # If pan mode
             if self.mouse_mode == MouseMode.PAN:
@@ -646,6 +662,11 @@ class AnnotableLayer(BaseLayer):
                 if annotation.polygon.containsPoint(pos, Qt.OddEvenFill):
                     return annotation, "move"
 
+            # Check points
+            elif annotation.points:
+                if (annotation.points[0] - pos).manhattanLength() < margin:
+                    return annotation, "point_0"
+
         return None, None
 
     def handle_mouse_double_click(self, event: QMouseEvent, pos: QPoint):
@@ -656,6 +677,73 @@ class AnnotableLayer(BaseLayer):
                 break
         # if left double click
         if event.button() == Qt.LeftButton:
+            img_pos = self.widget_to_image_pos(event.position())
+
+            self.selected_annotation, self.active_handle = (
+                self.find_annotation_and_handle_at(img_pos)
+            )
+
+            if self.selected_annotation:
+                if self.selected_annotation.polygon and self.active_handle:
+                    if "point_" in self.active_handle:
+                        index = int(self.active_handle.split("_")[1])
+                        # Remove the point at the clicked index
+                        polygon = self.selected_annotation.polygon
+                        polygon = QPolygonF(
+                            [p for i, p in enumerate(polygon) if i != index]
+                        )
+
+                        self.selected_annotation.polygon = polygon
+                        self.annotationUpdated.emit(self.selected_annotation)
+                        self.update()
+                        logger.info(f"Removed point at index {index}")
+                        return
+
+                # Check if an edge was double-clicked
+                polygon = self.selected_annotation.polygon
+                if polygon:
+                    for i in range(len(polygon)):
+                        start_point = polygon[i]
+                        end_point = polygon[
+                            (i + 1) % len(polygon)
+                        ]  # Wrap around to the first point
+
+                        # Calculate the vector along the edge and the vector from the start point to the clicked position
+                        line_vector = end_point - start_point
+                        point_vector = img_pos - start_point
+
+                        # Calculate the length of the edge
+                        line_length_squared = (
+                            line_vector.x() ** 2 + line_vector.y() ** 2
+                        )
+                        if line_length_squared == 0:
+                            continue  # Avoid division by zero for degenerate edges
+
+                        # Project the point onto the line (normalized)
+                        projection = (
+                            point_vector.x() * line_vector.x()
+                            + point_vector.y() * line_vector.y()
+                        ) / line_length_squared
+
+                        # Clamp the projection to the range [0, 1] to ensure it lies on the segment
+                        projection = max(0, min(1, projection))
+
+                        # Calculate the projection point on the edge
+                        projection_point = start_point + projection * line_vector
+
+                        # Calculate the perpendicular distance from the clicked position to the edge
+                        perpendicular_distance = (
+                            img_pos - projection_point
+                        ).manhattanLength()
+
+                        # Check if the perpendicular distance is within the margin
+                        if perpendicular_distance < 10:  # Margin of 10
+                            # Insert a new point at the projection point
+                            polygon.insert(i + 1, projection_point)
+                            self.annotationUpdated.emit(self.selected_annotation)
+                            self.update()
+                            return
+
             # if drawing a polygon, close the polygon
             if (
                 self.current_annotation
@@ -670,20 +758,20 @@ class AnnotableLayer(BaseLayer):
                 return
 
             # did we click on an annotation?
-            annotation = self.find_annotation_at(self.widget_to_image_pos(pos))
-            if annotation:
-                # toggle selection
-                annotation.selected = not annotation.selected
-
-                # make all other annotations unselected
-                for ann in self.annotations:
-                    if ann != annotation:
-                        ann.selected = False
-            else:
-                # we clicked on the background
-                # make all annotations unselected
-                for ann in self.annotations:
-                    ann.selected = False
+            # annotation = self.find_annotation_at(self.widget_to_image_pos(pos))
+            # if annotation:
+            #     # toggle selection
+            #     annotation.selected = not annotation.selected
+
+            #     # make all other annotations unselected
+            #     for ann in self.annotations:
+            #         if ann != annotation:
+            #             ann.selected = False
+            # else:
+            #     # we clicked on the background
+            #     # make all annotations unselected
+            #     for ann in self.annotations:
+            #         ann.selected = False
             # update the view
             for ann in self.annotations:
                 self.annotationUpdated.emit(ann)
@@ -828,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/annotation_list.py

@@ -23,9 +23,10 @@ from imagebaker import logger
 class AnnotationList(QDockWidget):
     messageSignal = Signal(str)
 
-    def __init__(self, layer: AnnotableLayer, parent=None):
+    def __init__(self, layer: AnnotableLayer, parent=None, max_name_length=15):
         super().__init__("Annotations", parent)
         self.layer = layer
+        self.max_name_length = max_name_length
         self.init_ui()
 
     def init_ui(self):
@@ -100,7 +101,7 @@ class AnnotationList(QDockWidget):
                 else ann.annotator
             )
             secondary_text.append(score_text)
-            short_path = ann.file_path.stem
+            short_path = ann.file_path.stem[: self.max_name_length]
             secondary_text.append(f"<span style='color:#666;'>{short_path}</span>")
 
             if secondary_text:

imagebaker/list_views/image_list.py

@@ -25,6 +25,7 @@ class ImageListPanel(QDockWidget):
         image_entries: list["ImageEntry"],
         processed_images: set[Path],
         parent=None,
+        max_name_length=15,
     ):
         """
         :param image_entries: List of image paths to display.
@@ -35,6 +36,7 @@ class ImageListPanel(QDockWidget):
         self.processed_images = processed_images
         self.current_page = 0
         self.images_per_page = 10
+        self.max_name_length = max_name_length
         self.init_ui()
 
     def init_ui(self):
@@ -104,7 +106,7 @@ class ImageListPanel(QDockWidget):
                 thumbnail_pixmap = QPixmap(str(image_entry.data)).scaled(
                     50, 50, Qt.KeepAspectRatio, Qt.SmoothTransformation
                 )
-                name_label_text = Path(image_entry.data).name
+                name_label_text = Path(image_entry.data).name[: self.max_name_length]
 
             thumbnail_label.setPixmap(thumbnail_pixmap)
             item_layout.addWidget(thumbnail_label)

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

@@ -114,7 +114,9 @@ class LayerifyTab(QWidget):
     def init_ui(self):
         """Initialize the UI components"""
         # Create annotation list and image list panel
-        self.annotation_list = AnnotationList(None, parent=self.main_window)
+        self.annotation_list = AnnotationList(
+            None, parent=self.main_window, max_name_length=self.config.max_name_length
+        )
         self.image_list_panel = ImageListPanel(
             self.image_entries, self.processed_images
         )
@@ -197,18 +199,7 @@ class LayerifyTab(QWidget):
         if not self.image_entries:
             assets_folder = self.config.assets_folder
             if assets_folder.exists() and assets_folder.is_dir():
-                for img_path in assets_folder.rglob("*.*"):
-                    if img_path.suffix.lower() in [
-                        ".jpg",
-                        ".jpeg",
-                        ".png",
-                        ".bmp",
-                        ".tiff",
-                    ]:
-                        # Add regular images as dictionaries with type and data
-                        self.image_entries.append(
-                            ImageEntry(is_baked_result=False, data=img_path)
-                        )
+                self._load_images_from_folder(assets_folder)
 
         # Load images into layers if any are found
         if self.image_entries:
@@ -472,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."""
@@ -690,6 +682,27 @@ class LayerifyTab(QWidget):
         self.model_combo.currentIndexChanged.connect(self.handle_model_change)
         toolbar_layout.addWidget(self.model_combo)
 
+    def _load_images_from_folder(self, folder_path: Path):
+        """Load images from a folder and update the image list."""
+        self.image_entries = []  # Clear the existing image paths
+
+        if self.config.full_search:
+            image_paths = list(folder_path.rglob("*.*"))
+        else:
+            image_paths = list(folder_path.glob("*.*"))
+
+        for img_path in image_paths:
+            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")
@@ -697,18 +710,7 @@ class LayerifyTab(QWidget):
             self.image_entries = []  # Clear the existing image paths
             folder_path = Path(folder_path)
 
-            # Use rglob to get all image files in the folder and subfolders
-            for img_path in folder_path.rglob("*.*"):
-                if img_path.suffix.lower() in [
-                    ".jpg",
-                    ".jpeg",
-                    ".png",
-                    ".bmp",
-                    ".tiff",
-                ]:
-                    self.image_entries.append(
-                        ImageEntry(is_baked_result=False, data=img_path)
-                    )
+            self._load_images_from_folder(folder_path)
 
             self.curr_image_idx = 0  # Reset the current image index
 

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/window/main_window.py

@@ -1,6 +1,8 @@
 from imagebaker.core.configs import LayerConfig, CanvasConfig
 from imagebaker import logger
 from imagebaker.tabs import LayerifyTab, BakerTab
+from imagebaker import __version__
+
 
 from PySide6.QtCore import Qt, QTimer
 from PySide6.QtWidgets import (
@@ -37,7 +39,7 @@ class MainWindow(QMainWindow):
     def init_ui(self):
         """Initialize the main window and set up tabs."""
         try:
-            self.setWindowTitle("Image Baker")
+            self.setWindowTitle(f"Image Baker v{__version__}")
             self.setGeometry(100, 100, 1200, 800)
 
             self.status_bar = self.statusBar()

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.48.dist-info → imagebaker-0.0.50.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: imagebaker
-Version: 0.0.48
+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.50.dist-info/RECORD

@@ -0,0 +1,43 @@
+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=-qy7vmYaaUk3bh49pwsBig8de_3Y2JWjTDeyWcGQods,5130
+imagebaker/core/defs/__init__.py,sha256=NqV7gYIlRkaS7nx_UTNPSNZbdPrx4w-VurKOKyRLbKY,28
+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=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=0WVSCm_RSBKo4pCkYU5c2OYjb_sW8x0UUfFC4So26jQ,9752
+imagebaker/models/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+imagebaker/models/base_model.py,sha256=4RyS4vShqWFHhdQDwYluwTPnRPEXjpZl9UjYY_w8NL0,4203
+imagebaker/tabs/__init__.py,sha256=ijg7MA17RvcHA2AuZE4OgRJXWxjecaUAlfASKAoCQ6Q,86
+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=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=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.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,,

imagebaker-0.0.48.dist-info/RECORD

@@ -1,41 +0,0 @@
-imagebaker/__init__.py,sha256=6so9hrBqCwTtCvUvaNB-hBAtmag8RbMJz5irhPANmD4,128
-imagebaker/core/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-imagebaker/core/configs/__init__.py,sha256=iyR_GOVMFw3XJSm7293YfyTnaLZa7pLQMfn5tGxVofI,31
-imagebaker/core/configs/configs.py,sha256=5KRZfLShu4JqV459n5dX4AlbIlkySyAmJr8OzYG4X7Q,4850
-imagebaker/core/defs/__init__.py,sha256=NqV7gYIlRkaS7nx_UTNPSNZbdPrx4w-VurKOKyRLbKY,28
-imagebaker/core/defs/defs.py,sha256=nIg2ZQADbpcyC0ZOl54L14yLZ38-SUnfMkklCDfhN3E,8257
-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=8Y35JvgSQMBTkvjG8VlD1xQgTsskyMwjU6ETU_xalAw,32819
-imagebaker/layers/base_layer.py,sha256=uncseSxTbLKnV84hAPbJLDbBMV0nu1gQ4N-SLHoGB6s,25486
-imagebaker/layers/canvas_layer.py,sha256=47R-g3NAzAQ720tWrIZUYIAupxImdORVYK5BFIRopqo,40414
-imagebaker/list_views/__init__.py,sha256=Aa9slE6do8eYgZp77wrofpd_mlBDwxgF3adMyHYFanE,144
-imagebaker/list_views/annotation_list.py,sha256=Wx2MbDGxcGeqss9TccFWVVYvlDo9hsefBMQBi4s72is,7436
-imagebaker/list_views/canvas_list.py,sha256=JYSYR0peGyJFJ6amL1894KsUHETPUkR3qAWdGL50Lbc,6717
-imagebaker/list_views/image_list.py,sha256=o4yGNXRffPJOZxd_c9JIK9MVzJkeWtXbZUF7pAVmfzw,4813
-imagebaker/list_views/layer_list.py,sha256=fLx3Ry72fas1W5y_V84hSp41ARneogQN3qjfYTOcpxY,14476
-imagebaker/list_views/layer_settings.py,sha256=38E39z-rEdl0YSe2C_k4wd5CgHPETQeJE5VvJLfFQ-k,8454
-imagebaker/models/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-imagebaker/models/base_model.py,sha256=ZfZ_VgP-jzfmEAdOycVtOYkr03m8EyXWdmK0-50MxIk,4197
-imagebaker/tabs/__init__.py,sha256=ijg7MA17RvcHA2AuZE4OgRJXWxjecaUAlfASKAoCQ6Q,86
-imagebaker/tabs/baker_tab.py,sha256=kIVoF4w_Ch1YNdHtHsNZKfr46tZWBDSj5xrrEkF1piM,20752
-imagebaker/tabs/layerify_tab.py,sha256=L8FqZf5JHHYc8BCRKwLWIRdgUSq2YvS7XiJ5Zd5kkTo,32427
-imagebaker/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-imagebaker/utils/image.py,sha256=fq7g3DqSdjF9okxZ3fe5kF4Hxn32rqhvVqxy8yI5bnI,3067
-imagebaker/utils/state_utils.py,sha256=sI0R3ht4W_kQGwOpzUdBjy6M4PaKaAQlj-_MM6pidfM,3584
-imagebaker/utils/transform_mask.py,sha256=k8MfTgM5-_U2TvDHQHRelz-leGFX6OcsllV6-J4BKfw,3651
-imagebaker/window/__init__.py,sha256=FIxtUR1qnbQMYzppQv7tEfv1-ueHhpu0Z7xuWZR794w,44
-imagebaker/window/app.py,sha256=e6FGO_BnvkiQC9JN3AmqkgbF72zzZS0hc7PFc43QiVc,4725
-imagebaker/window/main_window.py,sha256=GM5Pf7wpR8u99FarL7eqyc09Khwi6TWEgka6MvrjP6Y,6978
-imagebaker/workers/__init__.py,sha256=XfXENwAYyNg9q_zR-gOsYJGjzwg_iIb_gING8ydnp9c,154
-imagebaker/workers/baker_worker.py,sha256=JyV1Hu4mzbYhmogc7K3U24adklmT3x3V0ZNMxe7iT-w,10697
-imagebaker/workers/layerify_worker.py,sha256=EOqKvhdACtf3y5Ljy6M7MvddAjlZW5DNfBFMtNPD-us,3223
-imagebaker/workers/model_worker.py,sha256=Tlg6_D977iK-kuGCNdQY4OnGiP8QqWY7adpRNXZw4rA,1636
-imagebaker-0.0.48.dist-info/LICENSE,sha256=1vkysFPOnT7y4LsoFTv9YsopIrQvBc2l6vUOfv4KKLc,1082
-imagebaker-0.0.48.dist-info/METADATA,sha256=RpP88IOsQrk0ju2vBDfwcUpC9D6swAk-FDCC4srIg1U,6736
-imagebaker-0.0.48.dist-info/WHEEL,sha256=tZoeGjtWxWRfdplE7E3d45VPlLNQnvbKiYnx7gwAy8A,92
-imagebaker-0.0.48.dist-info/entry_points.txt,sha256=IDjZHJCiiHpH5IUTByT2en0nMbnnnlrJZ5FPFehUvQM,61
-imagebaker-0.0.48.dist-info/top_level.txt,sha256=Gg-eILTlqJXwVQr0saSwsx3-H4SPdZ2agBZaufe194s,11
-imagebaker-0.0.48.dist-info/RECORD,,