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

imagebaker/__init__.py

@@ -2,4 +2,4 @@ from loguru import logger  # noqa
 
 logger.info("imagebaker package loaded with loguru logger.")
 
-__version__ = "0.0.4"  # noqa
+__version__ = "0.0.48"  # noqa

imagebaker/core/configs/__init__.py

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

imagebaker/core/configs/configs.py

@@ -0,0 +1,156 @@
+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
+from imagebaker import logger
+
+
+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 = 5
+    handle_point_size: int = 8
+    handle_edge_size: int = 5
+
+    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):
+        asset_dir = self.project_dir / "assets"
+        if not asset_dir.exists():
+            asset_dir.mkdir(parents=True)
+            logger.info(f"Created assets folder at {asset_dir}")
+        return asset_dir
+
+    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 = 1000
+    # 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
+    DRAW_CURSOR: Qt.CursorShape = Qt.CrossCursor
+    ERASE_CURSOR: Qt.CursorShape = Qt.CrossCursor
+
+
+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/core/defs/__init__.py

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

imagebaker/core/defs/defs.py

@@ -0,0 +1,258 @@
+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
+    DRAW = 12
+    ERASE = 13
+
+
+class ModelType(str, Enum):
+    DETECTION = "detection"
+    SEGMENTATION = "segmentation"
+    CLASSIFICATION = "classification"
+    PROMPT = "prompt"
+
+
+@dataclass
+class DrawingState:
+    position: QPointF = field(default_factory=lambda: QPointF(0, 0))
+    color: QColor = field(default_factory=lambda: QColor(255, 255, 255))
+    size: int = 5
+
+
+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"
+    drawing_states: list[DrawingState] = field(default_factory=list)
+
+    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,
+            drawing_states=[
+                DrawingState(
+                    QPointF(d.position.x(), d.position.y()),
+                    QColor(d.color.red(), d.color.green(), d.color.blue()),
+                    d.size,
+                )
+                for d in self.drawing_states
+            ],
+        )
+
+
+@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
+    step: int = 0
+    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/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/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/layers/__init__.py

@@ -0,0 +1,3 @@
+from .base_layer import BaseLayer  # noqa: F401
+from .annotable_layer import AnnotableLayer  # noqa: F401
+from .canvas_layer import CanvasLayer  # noqa: F401