imagebaker 0.0.41__py3-none-any.whl → 0.0.46__py3-none-any.whl

imagebaker/utils/image.py

@@ -0,0 +1,105 @@
+import numpy as np
+from PySide6.QtGui import QPixmap, QImage
+import cv2
+
+from imagebaker.core.defs.defs import Annotation
+
+
+def qpixmap_to_numpy(pixmap: QPixmap | QImage) -> np.ndarray:
+    """
+    Convert QPixmap to RGBA numpy array.
+
+    Args:
+        pixmap: The QPixmap to convert
+
+    Returns:
+        numpy.ndarray: Array with shape (height, width, 4) containing RGBA values
+    """
+
+    if isinstance(pixmap, QPixmap):
+        # Convert QPixmap to QImage first
+        image = pixmap.toImage()
+    else:
+        image = pixmap
+    # Convert to Format_RGBA8888 for consistent channel ordering
+    if image.format() != QImage.Format_RGBA8888:
+        image = image.convertToFormat(QImage.Format_RGBA8888)
+
+    width = image.width()
+    height = image.height()
+
+    # Get the bytes directly from the QImage
+    ptr = image.constBits()
+
+    # Convert memoryview to bytes and then to numpy array
+    bytes_data = bytes(ptr)
+    arr = np.frombuffer(bytes_data, dtype=np.uint8).reshape((height, width, 4))
+
+    return arr
+
+
+def draw_annotations(image: np.ndarray, annotations: list[Annotation]) -> np.ndarray:
+    """
+    Draw annotations on an image.
+
+    Args:
+        image (np.ndarray): Image to draw on.
+        annotations (list[Annotation]): List of annotations to draw.
+
+    Returns:
+        np.ndarray: Image with annotations drawn.
+    """
+    for i, ann in enumerate(annotations):
+        if ann.rectangle:
+            cv2.rectangle(
+                image,
+                (int(ann.rectangle.x()), int(ann.rectangle.y())),
+                (
+                    int(ann.rectangle.x() + ann.rectangle.width()),
+                    int(ann.rectangle.y() + ann.rectangle.height()),
+                ),
+                (0, 255, 0),
+                2,
+            )
+            rect_center = ann.rectangle.center()
+
+            cv2.putText(
+                image,
+                ann.label,
+                (int(rect_center.x()), int(rect_center.y())),
+                cv2.FONT_HERSHEY_SIMPLEX,
+                1,
+                (0, 255, 0),
+                2,
+            )
+        elif ann.polygon:
+            cv2.polylines(
+                image,
+                [np.array([[int(p.x()), int(p.y())] for p in ann.polygon])],
+                True,
+                (0, 255, 0),
+                2,
+            )
+            polygon_center = ann.polygon.boundingRect().center()
+            cv2.putText(
+                image,
+                ann.label,
+                (int(polygon_center.x()), int(polygon_center.y())),
+                cv2.FONT_HERSHEY_SIMPLEX,
+                1,
+                (0, 255, 0),
+                2,
+            )
+        elif ann.points:
+            for p in ann.points:
+                cv2.circle(image, (int(p.x()), int(p.y())), 5, (0, 255, 0), -1)
+            cv2.putText(
+                image,
+                ann.label,
+                (int(ann.points[0].x()), int(ann.points[0].y())),
+                cv2.FONT_HERSHEY_SIMPLEX,
+                1,
+                (0, 255, 0),
+                2,
+            )
+    return image

imagebaker/utils/state_utils.py

@@ -0,0 +1,92 @@
+from imagebaker.core.defs import LayerState, DrawingState
+from PySide6.QtCore import QPointF
+
+
+def calculate_intermediate_states(
+    previous_state: LayerState | None, current_state: LayerState | None, steps: int
+):
+    """
+    Calculate intermediate states between previous_state and current_state for a layer.
+    Append the current_state to the list of states after calculating intermediates.
+
+    Args:
+        previous_state (LayerState): Previous state of the layer.
+        current_state (LayerState): Current state of the layer.
+        steps (int): Number of intermediate states to calculate.
+    """
+    if not previous_state or not current_state:
+        return [current_state]  # If no previous state, return only the current state
+
+    intermediate_states = []
+    for i in range(1, steps + 1):
+        # Interpolate attributes between previous_state and current_state
+        interpolated_state = LayerState(
+            layer_id=current_state.layer_id,
+            layer_name=current_state.layer_name,
+            opacity=previous_state.opacity
+            + (current_state.opacity - previous_state.opacity) * (i / steps),
+            position=QPointF(
+                previous_state.position.x()
+                + (current_state.position.x() - previous_state.position.x())
+                * (i / steps),
+                previous_state.position.y()
+                + (current_state.position.y() - previous_state.position.y())
+                * (i / steps),
+            ),
+            rotation=previous_state.rotation
+            + (current_state.rotation - previous_state.rotation) * (i / steps),
+            scale=previous_state.scale
+            + (current_state.scale - previous_state.scale) * (i / steps),
+            scale_x=previous_state.scale_x
+            + (current_state.scale_x - previous_state.scale_x) * (i / steps),
+            scale_y=previous_state.scale_y
+            + (current_state.scale_y - previous_state.scale_y) * (i / steps),
+            transform_origin=QPointF(
+                previous_state.transform_origin.x()
+                + (
+                    current_state.transform_origin.x()
+                    - previous_state.transform_origin.x()
+                )
+                * (i / steps),
+                previous_state.transform_origin.y()
+                + (
+                    current_state.transform_origin.y()
+                    - previous_state.transform_origin.y()
+                )
+                * (i / steps),
+            ),
+            order=current_state.order,
+            visible=current_state.visible,
+            allow_annotation_export=current_state.allow_annotation_export,
+            playing=current_state.playing,
+            selected=current_state.selected,
+            is_annotable=current_state.is_annotable,
+            status=current_state.status,
+        )
+
+        # Deep copy the drawing_states from the previous_state
+        interpolated_state.drawing_states = [
+            DrawingState(
+                position=d.position,
+                color=d.color,
+                size=d.size,
+            )
+            for d in current_state.drawing_states
+        ]
+
+        intermediate_states.append(interpolated_state)
+
+    # Append the current state as the final state
+    current_state.drawing_states.extend(
+        [
+            DrawingState(
+                position=d.position,
+                color=d.color,
+                size=d.size,
+            )
+            for d in current_state.drawing_states
+        ]
+    )
+    intermediate_states.append(current_state)
+
+    return intermediate_states

imagebaker/utils/transform_mask.py

@@ -0,0 +1,107 @@
+import cv2
+import numpy as np
+from typing import List, Tuple
+
+
+def mask_to_polygons(
+    mask: np.ndarray,
+    min_polygon_area: float = 10,
+    merge_polygons: bool = False,
+    merge_distance: int = 5,  # Max distance between polygons to merge
+) -> List[List[Tuple[int, int]]]:
+    """
+    Convert a binary mask to a list of polygons.
+    Each polygon is a list of (x, y) coordinates.
+
+    Args:
+        mask (np.ndarray): Binary mask (0 or 255).
+        min_polygon_area (float): Minimum area for a polygon to be included.
+        merge_polygons (bool): If True, merges nearby/overlapping polygons.
+        merge_distance (int): Max distance between polygons to merge (if merge_polygons=True).
+
+    Returns:
+        List[List[Tuple[int, int]]]: List of polygons, each represented as a list of (x, y) points.
+    """
+    contours, _ = cv2.findContours(
+        mask.astype(np.uint8), cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE
+    )
+
+    polygons = []
+    for contour in contours:
+        area = cv2.contourArea(contour)
+        if area >= min_polygon_area:
+            polygons.append(contour)
+
+    # Sort polygons by area (descending)
+    polygons = sorted(
+        polygons, key=lambda p: cv2.contourArea(np.array(p)), reverse=True
+    )
+
+    # Merge polygons if requested
+    if merge_polygons and len(polygons) > 1:
+        # Use morphological dilation to merge nearby regions
+        kernel = np.ones((merge_distance, merge_distance), np.uint8)
+        merged_mask = cv2.dilate(mask, kernel, iterations=1)
+
+        # Re-extract contours after merging
+        merged_contours, _ = cv2.findContours(
+            merged_mask.astype(np.uint8), cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE
+        )
+
+        # Filter again by area
+        merged_polygons = []
+        for contour in merged_contours:
+            area = cv2.contourArea(contour)
+            if area >= min_polygon_area:
+                merged_polygons.append(contour)
+
+        polygons = merged_polygons
+
+    # Convert contours to list of points
+    result = []
+    for poly in polygons:
+        points = poly.squeeze().tolist()  # Remove extra dimensions
+        if len(points) >= 3:  # Ensure it's a valid polygon
+            result.append([(int(x), int(y)) for x, y in points])
+
+    return result
+
+
+def mask_to_rectangles(
+    mask: np.ndarray,
+    merge_rectangles: bool = False,
+    merge_threshold: int = 1,
+    merge_epsilon: float = 0.5,
+) -> List[Tuple[int, int, int, int]]:
+    """
+    Convert a binary mask to a list of rectangles.
+    Each rectangle is a tuple of (x, y, w, h).
+
+    Args:
+        mask (np.ndarray): Binary mask (0 or 255).
+        merge_rectangles (bool): If True, merges overlapping or nearby rectangles.
+        merge_threshold (int): Min number of rectangles to merge into one.
+        merge_epsilon (float): Controls how close rectangles must be to merge (0.0 to 1.0).
+
+    Returns:
+        List[Tuple[int, int, int, int]]: List of rectangles, each as (x, y, w, h).
+    """
+    contours, _ = cv2.findContours(
+        mask.astype(np.uint8), cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE
+    )
+
+    rectangles = []
+    for contour in contours:
+        x, y, w, h = cv2.boundingRect(contour)
+        rectangles.append((x, y, w, h))
+
+    if merge_rectangles and len(rectangles) > 1:
+        # Convert rectangles to the format expected by groupRectangles
+        rects = np.array(rectangles)
+        # groupRectangles requires [x, y, w, h] format
+        grouped_rects, _ = cv2.groupRectangles(
+            rects.tolist(), merge_threshold, merge_epsilon
+        )
+        rectangles = [tuple(map(int, rect)) for rect in grouped_rects]
+
+    return rectangles

imagebaker/window/__init__.py

@@ -0,0 +1 @@
+from .main_window import MainWindow  # noqa

imagebaker/window/app.py

@@ -0,0 +1,136 @@
+from imagebaker.window.main_window import MainWindow
+from imagebaker.core.configs import LayerConfig, CanvasConfig
+from imagebaker import logger
+
+import importlib.util
+import runpy
+import ast
+import typer
+from pathlib import Path
+from PySide6.QtWidgets import QApplication
+
+app_cli = typer.Typer()
+
+
+def find_and_import_subclass(file_path: str, base_class_name: str):
+    """
+    Find and import the first subclass of a given base class in a Python file.
+
+    Args:
+        file_path (str): The path to the Python file to inspect.
+        base_class_name (str): The name of the base class to look for subclasses of.
+
+    Returns:
+        type: The first subclass found, or None if no subclass is found.
+    """
+    with open(file_path, "r") as file:
+        tree = ast.parse(file.read(), filename=file_path)
+
+    for node in ast.walk(tree):
+        if isinstance(node, ast.ClassDef):
+            for base in node.bases:
+                if isinstance(base, ast.Name) and base.id == base_class_name:
+                    # Dynamically import the file and return the class
+                    module_name = Path(file_path).stem
+                    spec = importlib.util.spec_from_file_location(
+                        module_name, file_path
+                    )
+                    module = importlib.util.module_from_spec(spec)
+                    spec.loader.exec_module(module)
+                    return getattr(module, node.name)
+    return None
+
+
+def load_models(file_path: str):
+    """Dynamically load the LOADED_MODELS object from the specified file."""
+    try:
+        # Ensure the file path is absolute
+        file_path = Path(file_path).resolve()
+
+        # Execute the file and return its global variables
+        loaded_globals = runpy.run_path(str(file_path))
+    except Exception as e:
+        logger.error(f"Failed to load models from {file_path}: {e}")
+        return {}
+
+    # Ensure LOADED_MODELS exists in the loaded context
+    if "LOADED_MODELS" not in loaded_globals:
+        logger.warning(f"No LOADED_MODELS object found in {file_path}.")
+        return {}
+
+    return loaded_globals.get("LOADED_MODELS", {})
+
+
+@app_cli.command()
+def run(
+    models_file: str = typer.Option(
+        "loaded_models.py", help="Path to the Python file defining LOADED_MODELS."
+    ),
+    project_dir: str = typer.Option(
+        ".", help="The project directory to use for the application."
+    ),
+    configs_file: str = typer.Option(
+        "imagebaker/core/configs.py",
+        help="The Python file to search for LayerConfig and CanvasConfig subclasses.",
+    ),
+):
+    """
+    Run the ImageBaker application.
+
+    Args:
+        models_file (str): Path to the Python file defining LOADED_MODELS.
+        project_dir (str): The project directory to use for the application.
+        configs_file (str): The Python file to search for LayerConfig and CanvasConfig subclasses.
+    """
+    models_file_path = Path(models_file)
+    if not models_file_path.is_file():
+        logger.warning(f"Models file not found: {models_file_path}")
+        LOADED_MODELS = {None: None}
+    else:
+        LOADED_MODELS = load_models(models_file_path)
+
+    configs_file_path = Path(configs_file)
+    if not configs_file_path.is_file():
+        logger.warning(f"Configs file not found: {configs_file_path}")
+        layer_config_class = None
+        canvas_config_class = None
+    else:
+        # Find and import subclasses of LayerConfig and CanvasConfig
+        layer_config_class = find_and_import_subclass(configs_file_path, "LayerConfig")
+        canvas_config_class = find_and_import_subclass(
+            configs_file_path, "CanvasConfig"
+        )
+
+    # Use the imported subclass if found, or fall back to the default
+    if layer_config_class:
+        logger.info(f"Using LayerConfig subclass: {layer_config_class.__name__}")
+        layer_config = layer_config_class()
+    else:
+        logger.info("No LayerConfig subclass found. Using default LayerConfig.")
+        layer_config = LayerConfig(project_dir=project_dir)
+
+    if canvas_config_class:
+        logger.info(f"Using CanvasConfig subclass: {canvas_config_class.__name__}")
+        canvas_config = canvas_config_class()
+    else:
+        logger.info("No CanvasConfig subclass found. Using default CanvasConfig.")
+        canvas_config = CanvasConfig(project_dir=project_dir)
+
+    main(layer_config, canvas_config, LOADED_MODELS)
+
+
+def main(layer_config, canvas_config, LOADED_MODELS):
+
+    # Initialize the application
+    app = QApplication([])
+    window = MainWindow(
+        layerify_config=layer_config,
+        canvas_config=canvas_config,
+        loaded_models=LOADED_MODELS,
+    )
+    window.show()
+    app.exec()
+
+
+if __name__ == "__main__":
+    app_cli()

imagebaker/window/main_window.py

@@ -0,0 +1,181 @@
+from imagebaker.core.configs import LayerConfig, CanvasConfig
+from imagebaker import logger
+from imagebaker.tabs import LayerifyTab, BakerTab
+
+from PySide6.QtCore import Qt, QTimer
+from PySide6.QtWidgets import (
+    QMainWindow,
+    QMessageBox,
+    QTabWidget,
+)
+
+
+class MainWindow(QMainWindow):
+
+    def __init__(
+        self,
+        layerify_config: LayerConfig = LayerConfig(),
+        canvas_config: CanvasConfig = CanvasConfig(),
+        loaded_models=None,
+    ):
+        """
+        Main window for Image Baker application.
+
+        Args:
+            layerify_config (LayerConfig): Configuration for Layerify tab.
+            canvas_config (CanvasConfig): Configuration for Canvas tab.
+            loaded_models (dict): Dictionary of loaded models.
+        """
+        super().__init__()
+        self.layerify_config = layerify_config
+        self.canvas_config = canvas_config
+        self.loaded_models = loaded_models
+
+        # Use QTimer to defer UI initialization
+        QTimer.singleShot(0, self.init_ui)
+
+    def init_ui(self):
+        """Initialize the main window and set up tabs."""
+        try:
+            self.setWindowTitle("Image Baker")
+            self.setGeometry(100, 100, 1200, 800)
+
+            self.status_bar = self.statusBar()
+            self.status_bar.showMessage("Ready")
+
+            # Create main tab widget
+            self.tab_widget = QTabWidget()
+            self.tab_widget.currentChanged.connect(self.handle_tab_change)
+            self.setCentralWidget(self.tab_widget)
+
+            # Initialize tabs
+            self.layerify_tab = LayerifyTab(
+                self, self.layerify_config, self.canvas_config, self.loaded_models
+            )
+            self.baker_tab = BakerTab(self, self.canvas_config)
+
+            self.tab_widget.addTab(self.layerify_tab, "Layerify")
+            self.tab_widget.addTab(self.baker_tab, "Baker")
+
+            # Connect signals
+            self.baker_tab.messageSignal.connect(self.update_status)
+            self.layerify_tab.layerAdded.connect(self.baker_tab.add_layer)
+            self.baker_tab.bakingResult.connect(self.layerify_tab.add_baked_result)
+            self.layerify_tab.gotToTab.connect(self.goto_tab)
+            # Use QTimer for safe signal connection
+            QTimer.singleShot(0, self._connect_final_signals)
+
+            # Handle initial tab state
+            self.handle_tab_change(0)
+
+        except Exception as e:
+            logger.error(f"MainWindow initialization error: {e}")
+            import traceback
+
+            traceback.print_exc()
+            QMessageBox.critical(self, "Initialization Error", str(e))
+
+    def _connect_final_signals(self):
+        """Connect signals that might require fully initialized objects"""
+        try:
+            self.layerify_tab.clearAnnotations.connect(
+                lambda: QTimer.singleShot(0, self.clear_annotations),
+                Qt.QueuedConnection,
+            )
+            self.layerify_tab.messageSignal.connect(self.update_status)
+        except Exception as e:
+            logger.error(f"Final signal connection error: {e}")
+
+    def goto_tab(self, tab_index):
+        """Switch to the specified tab index."""
+        self.tab_widget.setCurrentIndex(tab_index)
+        self.update_status("Switched to Layerify tab")
+
+    def clear_annotations(self):
+        """Clear all annotations and layers from both tabs."""
+        try:
+            logger.info("Clearing all annotations")
+            # Clear annotations in Layerify tab
+            self.layerify_tab.layer.annotations.clear()
+            self.layerify_tab.layer.update()
+
+            # Clear layers in Baker tab
+            self.baker_tab.layer_list.clear_layers()
+            self.baker_tab.current_canvas.clear_layers()
+
+            # Update annotation list
+            self.layerify_tab.update_annotation_list()
+
+            # Update status
+            self.update_status("All annotations cleared")
+        except Exception as e:
+            logger.error(f"Error handling clear: {str(e)}")
+            self.status_bar.showMessage(f"Error handling clear: {str(e)}")
+
+    def handle_tab_change(self, index):
+        """Control annotation panel visibility based on tab"""
+        current_tab = self.tab_widget.tabText(index)
+        logger.info(f"Switched to {current_tab} tab.")
+
+        if current_tab == "Layerify":
+            self.layerify_tab.toolbar_dock.setVisible(True)
+            self.layerify_tab.toolbar.setVisible(True)
+            self.layerify_tab.annotation_list.setVisible(True)
+            self.layerify_tab.image_list_panel.setVisible(True)
+
+            self.baker_tab.layer_settings.setVisible(False)
+            self.baker_tab.layer_list.setVisible(True)
+            self.baker_tab.toolbar.setVisible(False)
+            self.baker_tab.canvas_list.setVisible(False)
+
+        else:
+            self.layerify_tab.annotation_list.setVisible(False)
+            self.layerify_tab.toolbar.setVisible(False)
+            self.layerify_tab.toolbar_dock.setVisible(False)
+            self.layerify_tab.image_list_panel.setVisible(False)
+
+            self.baker_tab.layer_list.setVisible(True)
+            self.baker_tab.layer_settings.setVisible(True)
+            self.baker_tab.toolbar.setVisible(True)
+            self.baker_tab.toolbar_dock.setVisible(True)
+            self.baker_tab.canvas_list.setVisible(True)
+            self.baker_tab.canvas_list.update_canvas_list()
+            # self.baker_tab.
+
+    def update_status(self, msg):
+        """Update status bar that's visible in all tabs"""
+        # if current tab is layerify
+        if self.tab_widget.currentIndex() == 0:
+            status_text = f"{msg} | Label: {self.layerify_tab.current_label}"
+            status_text += (
+                f"| Model: {self.layerify_tab.current_model.name} "
+                if self.layerify_tab.current_model
+                else ""
+            )
+            status_text += (
+                f"| Annotations: {len(self.layerify_tab.layer.annotations)}"
+                if self.layerify_tab.layer
+                else ""
+            )
+            status_text += (
+                f"| Layers: {len(self.baker_tab.current_canvas.layers)}"
+                if self.baker_tab.current_canvas
+                else ""
+            )
+            status_text += f"| Image: {self.layerify_tab.curr_image_idx + 1}"
+            status_text += f"/{len(self.layerify_tab.image_entries)}"
+        elif self.tab_widget.currentIndex() == 1:
+            status_text = (
+                f"{msg} | Num Layers: {len(self.baker_tab.current_canvas.layers)}"
+                if self.baker_tab.current_canvas
+                else ""
+            )
+        self.status_bar.showMessage(status_text)
+
+    def closeEvent(self, event):
+        # Clean up tabs first
+        if hasattr(self, "layerify_tab"):
+            self.layerify_tab.deleteLater()
+        if hasattr(self, "baker_tab"):
+            self.baker_tab.deleteLater()
+        super().closeEvent(event)

imagebaker/workers/__init__.py

@@ -0,0 +1,3 @@
+from .layerify_worker import LayerifyWorker  # noqa
+from .baker_worker import BakerWorker  # noqa
+from .model_worker import ModelPredictionWorker  # noqa