imagebaker 0.0.1__tar.gz → 0.0.3__tar.gz

{imagebaker-0.0.1 → imagebaker-0.0.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: imagebaker
-Version: 0.0.1
+Version: 0.0.3
 Summary: A package for baking images.
 Home-page: https://github.com/q-viper/Image-Baker
 Author: Ramkrishna Acharya

imagebaker-0.0.3/imagebaker/core/configs/__init__.py

@@ -0,0 +1 @@
+from .configs import *  # noqa

imagebaker-0.0.3/imagebaker/core/configs/configs.py

@@ -0,0 +1,149 @@
+from pathlib import Path
+from typing import List, Tuple
+
+from PySide6.QtCore import Qt
+from PySide6.QtGui import QColor
+from pydantic import BaseModel, Field
+
+from imagebaker.core.defs import Label, ModelType
+
+
+class DrawConfig(BaseModel):
+    color: QColor = Field(default_factory=lambda: QColor(255, 255, 255))
+    point_size: int = 5
+    line_width: int = 5
+    control_point_size: int = 1.5
+    ellipse_size: int = 8
+    pen_alpha: int = 150
+    brush_alpha: int = 50
+    brush_fill_pattern: Qt.BrushStyle = Qt.BrushStyle.DiagCrossPattern
+    thumbnail_size: Tuple[int, int] = Field(default_factory=lambda: (50, 50))
+    background_color: QColor = Field(default_factory=lambda: QColor(0, 0, 0, 255))
+    label_font_size: int = 12
+    label_font_background_color: QColor = Field(
+        default_factory=lambda: QColor(0, 0, 0, 150)
+    )
+    handle_color: QColor = Field(default_factory=lambda: QColor(0, 255, 255, 150))
+    handle_width: int = 2
+    handle_point_size: int = 6
+    handle_edge_size: int = 4
+
+    button_width: int = 30
+
+    class Config:
+        arbitrary_types_allowed = True
+
+
+class BaseConfig(BaseModel):
+    project_name: str = "ImageBaker"
+    version: str = "0.1.0"
+    project_dir: Path = Path(".")
+
+    is_debug: bool = True
+    deque_maxlen: int = 10
+
+    # drawing configs #
+    # ON SELECTION
+    selected_draw_config: DrawConfig = DrawConfig(
+        color=QColor(255, 0, 0),
+        point_size=5,
+        line_width=5,
+        ellipse_size=8,
+        pen_alpha=150,
+        brush_alpha=50,
+        thumbnail_size=(50, 50),
+        brush_fill_pattern=Qt.BrushStyle.CrossPattern,
+    )
+    normal_draw_config: DrawConfig = DrawConfig()
+    zoom_in_factor: float = 1.1
+    zoom_out_factor: float = 0.9
+
+    @property
+    def assets_folder(self):
+        return self.project_dir / "assets"
+
+    class Config:
+        arbitrary_types_allowed = True
+
+
+class LayerConfig(BaseConfig):
+    show_labels: bool = True
+    show_annotations: bool = True
+
+    default_label: Label = Field(
+        default_factory=lambda: Label("Unlabeled", QColor(255, 255, 255))
+    )
+    predefined_labels: List[Label] = Field(
+        default_factory=lambda: [
+            Label("Unlabeled", QColor(255, 255, 255)),
+            Label("Label 1", QColor(255, 0, 0)),
+            Label("Label 2", QColor(0, 255, 0)),
+            Label("Label 3", QColor(0, 0, 255)),
+            Label("Custom", QColor(128, 128, 128)),
+        ]
+    )
+
+    def get_label_color(self, label):
+        for lbl in self.predefined_labels:
+            if lbl.name == label:
+                return lbl.color
+        return self.default_label.color
+
+
+class CanvasConfig(BaseConfig):
+    save_on_bake: bool = True
+    bake_timeout: float = -1.0
+    filename_format: str = "{project_name}_{timestamp}"
+    export_format: str = "png"
+    max_xpos: int = 1000
+    max_ypos: int = 1000
+    max_scale: int = 10
+    # whether to allow the use of sliders to change layer properties
+    allow_slider_usage: bool = True
+
+    write_annotations: bool = True
+    write_labels: bool = True
+    write_masks: bool = True
+    fps: int = 5
+
+    @property
+    def export_folder(self):
+        folder = self.project_dir / "assets" / "exports"
+        folder.mkdir(parents=True, exist_ok=True)
+        return folder
+
+
+class CursorDef:
+    POINT_CURSOR: Qt.CursorShape = Qt.CrossCursor
+    POLYGON_CURSOR: Qt.CursorShape = Qt.CrossCursor
+    RECTANGLE_CURSOR: Qt.CursorShape = Qt.CrossCursor
+    IDLE_CURSOR: Qt.CursorShape = Qt.ArrowCursor
+    PAN_CURSOR: Qt.CursorShape = Qt.OpenHandCursor
+    ZOOM_IN_CURSOR: Qt.CursorShape = Qt.SizeFDiagCursor
+    ZOOM_OUT_CURSOR: Qt.CursorShape = Qt.SizeBDiagCursor
+    TRANSFORM_UPDOWN: Qt.CursorShape = Qt.SizeVerCursor
+    TRANSFORM_LEFTRIGHT: Qt.CursorShape = Qt.SizeHorCursor
+    TRANSFORM_ALL: Qt.CursorShape = Qt.SizeAllCursor
+    GRAB_CURSOR: Qt.CursorShape = Qt.OpenHandCursor
+    GRABBING_CURSOR: Qt.CursorShape = Qt.ClosedHandCursor
+
+
+class DefaultModelConfig(BaseModel):
+    model_type: ModelType = ModelType.DETECTION
+    model_name: str = "Dummy Model"
+    model_description: str = "This is a dummy model"
+    model_version: str = "1.0"
+    model_author: str = "Anonymous"
+    model_license: str = "MIT"
+    input_size: Tuple[int, int] = (224, 224)
+    input_channels: int = 3
+    class_names: List[str] = ["class1", "class2", "class3"]
+    device: str = "cpu"
+    return_annotated_image: bool = False
+
+    @property
+    def num_classes(self):
+        return len(self.class_names)
+
+    class Config:
+        arbitrary_types_allowed = True

imagebaker-0.0.3/imagebaker/core/defs/__init__.py

@@ -0,0 +1 @@
+from .defs import *  # noqa

imagebaker-0.0.3/imagebaker/core/defs/defs.py

@@ -0,0 +1,239 @@
+from PySide6.QtCore import QPointF, QRectF
+from PySide6.QtGui import QColor, QPolygonF
+from PySide6.QtGui import QImage
+
+from enum import Enum
+from dataclasses import dataclass, field
+import numpy as np
+from datetime import datetime
+from pydantic import BaseModel
+from pathlib import Path
+
+
+class MouseMode(Enum):
+    IDLE = 0
+    POINT = 1
+    POLYGON = 2
+    RECTANGLE = 3
+    PAN = 4
+    ZOOM_IN = 5
+    ZOOM_OUT = 6
+    RESIZE = 7
+    RESIZE_HEIGHT = 8
+    RESIZE_WIDTH = 9
+    GRAB = 11
+
+
+class ModelType(str, Enum):
+    DETECTION = "detection"
+    SEGMENTATION = "segmentation"
+    CLASSIFICATION = "classification"
+    PROMPT = "prompt"
+
+
+class PredictionResult(BaseModel):
+    class_name: str = None
+    class_id: int = None
+    score: float = None
+    rectangle: list[int] | None = None
+    mask: np.ndarray | None = None
+    keypoints: list[list[int, int]] | None = None
+    polygon: np.ndarray | None = None
+    prompt: str | None = None
+    annotated_image: np.ndarray | None = None
+    annotation_time: str | None = None
+
+    class Config:
+        arbitrary_types_allowed = True
+
+
+@dataclass
+class LayerState:
+    layer_id: str = ""
+    state_step: int = 0
+    layer_name: str = "Layer"
+    opacity: float = 255.00
+    position: QPointF = field(default_factory=lambda: QPointF(0, 0))
+    rotation: float = 0.00
+    scale: float = 1.00
+    scale_x: float = 1.00
+    scale_y: float = 1.00
+    transform_origin: QPointF = field(default_factory=lambda: QPointF(0.0, 0.0))
+    order: int = 0
+    visible: bool = True
+    allow_annotation_export: bool = True
+    playing: bool = False
+    selected: bool = False
+    is_annotable: bool = True
+    status: str = "Ready"
+
+    def copy(self):
+        return LayerState(
+            layer_id=self.layer_id,
+            layer_name=self.layer_name,
+            opacity=self.opacity,
+            position=QPointF(self.position.x(), self.position.y()),
+            rotation=self.rotation,
+            scale=self.scale,
+            scale_x=self.scale_x,
+            scale_y=self.scale_y,
+            transform_origin=QPointF(
+                self.transform_origin.x(), self.transform_origin.y()
+            ),
+            order=self.order,
+            visible=self.visible,
+            allow_annotation_export=self.allow_annotation_export,
+            playing=self.playing,
+            selected=self.selected,
+            is_annotable=self.is_annotable,
+            status=self.status,
+        )
+
+
+@dataclass
+class Label:
+    name: str = "Unlabeled"
+    color: QColor = field(default_factory=lambda: QColor(255, 255, 255))
+
+
+@dataclass
+class Annotation:
+    annotation_id: int
+    label: str
+    color: QColor = field(default_factory=lambda: QColor(255, 255, 255))
+    points: list[QPointF] = field(default_factory=list)
+    # [x, y, width, height]
+    rectangle: QRectF = None
+    polygon: QPolygonF = None
+    is_complete: bool = False
+    selected: bool = False
+    score: float = None
+    annotator: str = "User"
+    annotation_time: str = field(
+        default_factory=lambda: datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+    )
+    visible: bool = True
+    file_path: Path = field(default_factory=lambda: Path("Runtime"))
+    is_model_generated: bool = False
+    model_name: str = None
+
+    def copy(self):
+        ann = Annotation(
+            annotation_id=self.annotation_id,
+            label=self.label,
+            color=QColor(self.color.red(), self.color.green(), self.color.blue()),
+            points=[QPointF(p) for p in self.points],
+            rectangle=QRectF(self.rectangle) if self.rectangle else None,
+            polygon=QPolygonF(self.polygon) if self.polygon else None,
+            is_complete=self.is_complete,
+            selected=self.selected,
+            score=self.score,
+            annotator=self.annotator,
+            annotation_time=self.annotation_time,
+            visible=self.visible,
+            file_path=self.file_path,
+            is_model_generated=self.is_model_generated,
+            model_name=self.model_name,
+        )
+        ann.is_selected = False
+        return ann
+
+    @property
+    def name(self):
+        return f"{self.annotation_id} {self.label}"
+
+    @staticmethod
+    def save_as_json(annotations: list["Annotation"], path: str):
+        import json
+
+        annotations_dict = []
+        for annotation in annotations:
+            rectangle = None
+            if annotation.rectangle:
+                rectangle = [
+                    annotation.rectangle.x(),
+                    annotation.rectangle.y(),
+                    annotation.rectangle.width(),
+                    annotation.rectangle.height(),
+                ]
+            polygon = None
+            if annotation.polygon:
+                polygon = [[p.x(), p.y()] for p in annotation.polygon]
+            points = None
+            if annotation.points:
+                points = [[p.x(), p.y()] for p in annotation.points]
+            data = {
+                "annotation_id": annotation.annotation_id,
+                "label": annotation.label,
+                "color": annotation.color.getRgb(),
+                "points": points,
+                "rectangle": rectangle,
+                "polygon": polygon,
+                "is_complete": annotation.is_complete,
+                "selected": annotation.selected,
+                "score": annotation.score,
+                "annotator": annotation.annotator,
+                "annotation_time": annotation.annotation_time,
+                "visible": annotation.visible,
+                "file_path": str(annotation.file_path),
+                "is_model_generated": annotation.is_model_generated,
+                "model_name": annotation.model_name,
+            }
+            annotations_dict.append(data)
+
+        with open(path, "w") as f:
+            json.dump(annotations_dict, f, indent=4)
+
+    @staticmethod
+    def load_from_json(path: str):
+        import json
+
+        with open(path, "r") as f:
+            data = json.load(f)
+
+        annotations = []
+        for d in data:
+            annotation = Annotation(
+                annotation_id=d["annotation_id"],
+                label=d["label"],
+                color=QColor(*d["color"]),
+                is_complete=d.get("is_complete", False),
+                selected=d.get("selected", False),
+                score=d.get("score", None),
+                annotator=d.get("annotator", None),
+                annotation_time=d.get(
+                    "annotation_time", datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+                ),
+                visible=d.get("visible", True),
+                file_path=Path(d.get("file_path", "Runtime")),
+                is_model_generated=d.get("is_model_generated", False),
+                model_name=d.get("model_name", None),
+            )
+
+            # Handle points safely
+            points_data = d.get("points")
+            if points_data:
+                annotation.points = [QPointF(*p) for p in points_data]
+
+            # Handle rectangle safely
+            rect_data = d.get("rectangle")
+            if rect_data:
+                annotation.rectangle = QRectF(*rect_data)
+
+            # Handle polygon safely
+            polygon_data = d.get("polygon")
+            if polygon_data:
+                annotation.polygon = QPolygonF([QPointF(*p) for p in polygon_data])
+
+            annotations.append(annotation)
+
+        return annotations
+
+
+@dataclass
+class BakingResult:
+    filename: Path
+    image: QImage = field(default=None)
+    masks: list[np.ndarray] = field(default_factory=list)
+    mask_names: list[str] = field(default_factory=list)
+    annotations: list[Annotation] = field(default_factory=list)

imagebaker-0.0.3/imagebaker/core/plugins/base_plugin.py

@@ -0,0 +1,39 @@
+from abc import ABC, abstractmethod
+from imagebaker.core.defs import LayerState
+from imagebaker import logger
+
+
+class BasePlugin(ABC):
+
+    def __init__(self, layer_state: LayerState, final_step: int = -1):
+        self.initial_layer_state = layer_state
+        self.final_step = final_step
+        self.current_step = 0
+
+    def __str__(self):
+        return self.__class__.__name
+
+    @abstractmethod
+    def compute_step(self, step: int):
+        """
+        Compute the step based on the given step.
+
+        :param step: The step to compute the step by.
+        """
+        pass
+
+    def update(self, step: int = 1):
+        """
+        Returns the updated state after passed step.
+
+        :param step: The step to update the state by.
+        """
+        if (
+            self.final_step != -1
+            and step > self.final_step
+            or self.current_step >= self.final_step
+        ):
+            logger.info(f"Final step reached for {self}. Returning last step.")
+            step = self.final_step
+        self.compute_step(step)
+        self.current_step += step

imagebaker-0.0.3/imagebaker/core/plugins/cosine_plugin.py

@@ -0,0 +1,39 @@
+from imagebaker.core.plugins.base_plugin import BasePlugin
+from imagebaker.core.defs import LayerState
+
+import numpy as np
+from PySide6.QtCore import QPointF
+
+
+class CosinePlugin(BasePlugin):
+    """
+    Cosine Plugin implementation.
+    """
+
+    def __init__(self, layer_state: LayerState, amplitude=50, frequency=0.1):
+        """
+        Initialize the CosinePlugin.
+
+        :param layer_state: The LayerState to modify.
+        :param amplitude: The amplitude of the cosine wave (how far it moves).
+        :param frequency: The frequency of the cosine wave (how fast it oscillates).
+        """
+        super().__init__(layer_state)
+        self.amplitude = amplitude
+        self.frequency = frequency
+
+    def compute_step(self, step):
+        """
+        Update the x and y positions of the LayerState based on a cosine curve.
+
+        :param step: The step to compute the cosine value for.
+        """
+        # Compute the new x position based on the cosine curve
+        layer_state = LayerState()
+        layer_state.position = QPointF(
+            self.initial_layer_state.position.x()
+            + self.amplitude * np.cos(self.frequency * step),
+            self.initial_layer_state.position.y(),
+        )
+
+        return layer_state

imagebaker-0.0.3/imagebaker/utils/image.py

@@ -0,0 +1,95 @@
+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]):
+    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-0.0.3/imagebaker/utils/state_utils.py

@@ -0,0 +1,64 @@
+from imagebaker.core.defs import LayerState
+from PySide6.QtCore import QPointF
+
+
+def calculate_intermediate_states(previous_state, current_state, 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.
+    """
+    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(steps):
+        # 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,
+        )
+        intermediate_states.append(interpolated_state)
+
+    # Append the current state as the final state
+    intermediate_states.append(current_state)
+
+    return intermediate_states

imagebaker-0.0.3/imagebaker/utils/transform_mask.py

@@ -0,0 +1,112 @@
+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
+
+
+import cv2
+import numpy as np
+from typing import List, Tuple
+
+
+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-0.0.1 → imagebaker-0.0.3}/imagebaker.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: imagebaker
-Version: 0.0.1
+Version: 0.0.3
 Summary: A package for baking images.
 Home-page: https://github.com/q-viper/Image-Baker
 Author: Ramkrishna Acharya

{imagebaker-0.0.1 → imagebaker-0.0.3}/imagebaker.egg-info/SOURCES.txt

@@ -8,6 +8,14 @@ imagebaker.egg-info/dependency_links.txt
 imagebaker.egg-info/entry_points.txt
 imagebaker.egg-info/requires.txt
 imagebaker.egg-info/top_level.txt
+imagebaker/core/__init__.py
+imagebaker/core/configs/__init__.py
+imagebaker/core/configs/configs.py
+imagebaker/core/defs/__init__.py
+imagebaker/core/defs/defs.py
+imagebaker/core/plugins/__init__.py
+imagebaker/core/plugins/base_plugin.py
+imagebaker/core/plugins/cosine_plugin.py
 imagebaker/layers/__init__.py
 imagebaker/layers/annotable_layer.py
 imagebaker/layers/base_layer.py
@@ -26,6 +34,10 @@ imagebaker/models/segmentation.py
 imagebaker/tabs/__init__.py
 imagebaker/tabs/baker_tab.py
 imagebaker/tabs/layerify_tab.py
+imagebaker/utils/__init__.py
+imagebaker/utils/image.py
+imagebaker/utils/state_utils.py
+imagebaker/utils/transform_mask.py
 imagebaker/window/__init__.py
 imagebaker/window/app.py
 imagebaker/window/main_window.py

{imagebaker-0.0.1 → imagebaker-0.0.3}/setup.py

@@ -2,7 +2,7 @@ from setuptools import setup, find_packages
 
 setup(
     name="imagebaker",
-    version="0.0.1",
+    version="0.0.3",
     packages=find_packages(),  # Automatically finds all packages
     install_requires=[
         "numpy",