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

imagebaker/workers/baker_worker.py

@@ -0,0 +1,247 @@
+from PySide6.QtGui import QImage, QPainter, QTransform, QPolygonF, QPen, QPixmap
+from PySide6.QtCore import (
+    Qt,
+    QPoint,
+    QPointF,
+    Signal,
+    QRectF,
+    QObject,
+)
+import sys
+from pathlib import Path
+
+from imagebaker.core.defs.defs import BakingResult, Annotation, LayerState
+from imagebaker.utils.transform_mask import mask_to_polygons, mask_to_rectangles
+from imagebaker import logger
+from imagebaker.utils.image import qpixmap_to_numpy
+
+
+class BakerWorker(QObject):
+    finished = Signal(list)  # Emit a list of BakingResult objects
+    error = Signal(str)
+
+    def __init__(
+        self,
+        states: dict[int, list["LayerState"]],
+        layers: list["Layer"],
+        filename: Path,
+    ):
+        """
+        Worker to bake the images and masks for a given set of states.
+
+        Args:
+            states: Dictionary of step -> list of LayerState objects
+            layers: List of Layer objects
+            filename: Path to the output file
+        """
+        super().__init__()
+        self.states = states  # Dictionary of step -> list of states
+        self.layers = layers
+        self.filename = filename
+
+    def process(self):
+        results = []
+        try:
+            for step, states in sorted(self.states.items()):
+                logger.info(f"Processing step {step}")
+
+                # Calculate bounding box for all layers in this step
+                top_left = QPointF(sys.maxsize, sys.maxsize)
+                bottom_right = QPointF(-sys.maxsize, -sys.maxsize)
+
+                for state in states:
+                    layer = self._get_layer(state.layer_id)
+                    if layer and layer.visible and not layer.image.isNull():
+                        layer.layer_state = state
+                        layer.update()
+
+                        transform = QTransform()
+                        transform.translate(layer.position.x(), layer.position.y())
+                        transform.rotate(layer.rotation)
+                        transform.scale(layer.scale_x, layer.scale_y)
+
+                        original_rect = QRectF(QPointF(0, 0), layer.image.size())
+                        transformed_rect = transform.mapRect(original_rect)
+
+                        top_left.setX(min(top_left.x(), transformed_rect.left()))
+                        top_left.setY(min(top_left.y(), transformed_rect.top()))
+                        bottom_right.setX(
+                            max(bottom_right.x(), transformed_rect.right())
+                        )
+                        bottom_right.setY(
+                            max(bottom_right.y(), transformed_rect.bottom())
+                        )
+
+                # Create the output image for this step
+                width = int(bottom_right.x() - top_left.x())
+                height = int(bottom_right.y() - top_left.y())
+                if width <= 0 or height <= 0:
+                    continue
+
+                image = QImage(width, height, QImage.Format_ARGB32)
+                image.fill(Qt.transparent)
+                masks = []
+                mask_names = []
+                new_annotations = []
+
+                painter = QPainter(image)
+                try:
+                    painter.setRenderHints(
+                        QPainter.Antialiasing | QPainter.SmoothPixmapTransform
+                    )
+                    for state in states:
+                        layer = self._get_layer(state.layer_id)
+
+                        if layer and layer.visible and not layer.image.isNull():
+                            # Draw the layer image with transformations
+                            painter.save()
+                            try:
+                                painter.translate(layer.position - top_left)
+                                painter.rotate(layer.rotation)
+                                painter.scale(layer.scale_x, layer.scale_y)
+                                pixmap_with_alpha = QPixmap(layer.image.size())
+                                pixmap_with_alpha.fill(Qt.transparent)
+
+                                temp_painter = QPainter(pixmap_with_alpha)
+                                try:
+                                    opacity = layer.opacity / 255.0
+                                    temp_painter.setOpacity(opacity)
+                                    temp_painter.drawPixmap(0, 0, layer.image)
+                                finally:
+                                    temp_painter.end()
+
+                                painter.drawPixmap(0, 0, pixmap_with_alpha)
+                            finally:
+                                painter.restore()
+
+                            # Draw the drawing states
+                            if state.drawing_states:
+                                painter.save()
+                                try:
+                                    painter.translate(layer.position - top_left)
+                                    painter.rotate(layer.rotation)
+                                    painter.scale(layer.scale_x, layer.scale_y)
+                                    for drawing_state in state.drawing_states:
+                                        painter.setPen(
+                                            QPen(
+                                                drawing_state.color,
+                                                drawing_state.size,
+                                                Qt.SolidLine,
+                                                Qt.RoundCap,
+                                                Qt.RoundJoin,
+                                            )
+                                        )
+                                        painter.drawPoint(
+                                            drawing_state.position - top_left
+                                        )
+                                finally:
+                                    painter.restore()
+
+                            # Generate the layer mask
+                            layer_mask = QImage(width, height, QImage.Format_ARGB32)
+                            layer_mask.fill(Qt.transparent)
+                            mask_painter = QPainter(layer_mask)
+                            try:
+                                mask_painter.setRenderHints(
+                                    QPainter.Antialiasing
+                                    | QPainter.SmoothPixmapTransform
+                                )
+                                mask_painter.translate(layer.position - top_left)
+                                mask_painter.rotate(layer.rotation)
+                                mask_painter.scale(layer.scale_x, layer.scale_y)
+                                mask_painter.drawPixmap(QPoint(0, 0), layer.image)
+
+                                if state.drawing_states:
+                                    mask_painter.save()
+                                    try:
+                                        for drawing_state in state.drawing_states:
+                                            mask_painter.setPen(
+                                                QPen(
+                                                    Qt.black,
+                                                    drawing_state.size,
+                                                    Qt.SolidLine,
+                                                    Qt.RoundCap,
+                                                    Qt.RoundJoin,
+                                                )
+                                            )
+                                            mask_painter.drawPoint(
+                                                drawing_state.position
+                                            )
+                                    finally:
+                                        mask_painter.restore()
+                            finally:
+                                mask_painter.end()
+
+                            # Convert mask to 8-bit
+                            mask_arr = qpixmap_to_numpy(layer_mask)
+                            alpha_channel = mask_arr[:, :, 3].copy()  # Extract alpha
+
+                            # Binarize the mask (0 or 255)
+                            alpha_channel[alpha_channel > 0] = 255
+
+                            masks.append(alpha_channel)
+                            mask_names.append(layer.layer_name)
+
+                            # Generate annotations
+                            if layer.allow_annotation_export:
+                                ann: Annotation = layer.annotations[0]
+                                new_annotation = self._generate_annotation(
+                                    ann, alpha_channel
+                                )
+                                new_annotations.append(new_annotation)
+                finally:
+                    painter.end()
+
+                # Save the image
+                filename = self.filename.parent / f"{self.filename.stem}_{step}.png"
+
+                # Append the result
+                results.append(
+                    BakingResult(
+                        filename=filename,
+                        step=step,
+                        image=image,
+                        masks=masks,
+                        mask_names=mask_names,
+                        annotations=new_annotations,
+                    )
+                )
+
+            # Emit all results
+            self.finished.emit(results)
+
+        except Exception as e:
+            logger.error(f"Error in BakerWorker: {e}")
+            self.error.emit(str(e))
+            traceback.print_exc()
+
+    def _get_layer(self, layer_id):
+        for layer in self.layers:
+            if layer.layer_id == layer_id:
+                return layer
+        return None
+
+    def _generate_annotation(self, ann: Annotation, alpha_channel):
+        """Generate an annotation based on the alpha channel."""
+        new_annotation = Annotation(
+            label=ann.label,
+            color=ann.color,
+            annotation_id=ann.annotation_id,
+            is_complete=True,
+            visible=True,
+        )
+
+        if ann.points:
+            new_annotation.points = ann.points
+        elif ann.rectangle:
+            xywhs = mask_to_rectangles(alpha_channel, merge_rectangles=True)
+            new_annotation.rectangle = QRectF(
+                xywhs[0][0], xywhs[0][1], xywhs[0][2], xywhs[0][3]
+            )
+        elif ann.polygon:
+            polygon = mask_to_polygons(alpha_channel, merge_polygons=True)
+            poly = QPolygonF([QPointF(p[0], p[1]) for p in polygon[0]])
+            new_annotation.polygon = poly
+        else:
+            logger.info("No annotation found")
+        return new_annotation

imagebaker/workers/layerify_worker.py

@@ -0,0 +1,91 @@
+from PySide6.QtCore import (
+    Qt,
+    Signal,
+    QObject,
+)
+from PySide6.QtGui import (
+    QColor,
+    QPixmap,
+    QPainter,
+    QImage,
+)
+
+
+from imagebaker.core.defs import Annotation
+from imagebaker import logger
+
+
+class LayerifyWorker(QObject):
+    finished = Signal(Annotation, QPixmap)
+    error = Signal(str)
+
+    def __init__(self, image, annotations, config):
+        """
+        Worker to layerify an image based on annotations.
+
+        Args:
+            image (QPixmap): Image to layerify.
+            annotations (List[Annotation]): List of annotations to layerify.
+            config (Config): Config object containing settings.
+        """
+        super().__init__()
+        self.image = image.copy()
+        self.annotations = annotations
+        self.config = config
+
+    def process(self):
+        try:
+            for annotation in self.annotations:
+                logger.info(f"Layerifying annotation {annotation}")
+                if annotation.rectangle:
+                    cropped_image = self.image.copy(annotation.rectangle.toRect())
+                elif annotation.polygon:
+                    # Get bounding box and crop
+                    bounding_rect = annotation.polygon.boundingRect().toRect()
+                    cropped_pixmap = self.image.copy(bounding_rect)
+
+                    # Convert to ARGB32 format to ensure alpha channel support
+                    cropped_image = cropped_pixmap.toImage().convertToFormat(
+                        QImage.Format_ARGB32
+                    )
+
+                    # Create mask with sharp edges
+                    mask = QImage(cropped_image.size(), QImage.Format_ARGB32)
+                    mask.fill(Qt.transparent)
+
+                    # Translate polygon coordinates
+                    translated_poly = annotation.polygon.translated(
+                        -bounding_rect.topLeft()
+                    )
+
+                    # Draw mask without anti-aliasing
+                    painter = QPainter(mask)
+                    painter.setRenderHint(QPainter.Antialiasing, False)
+                    painter.setBrush(QColor(255, 255, 255, 255))  # Opaque white
+                    painter.setPen(Qt.NoPen)
+                    painter.drawPolygon(translated_poly)
+                    painter.end()
+
+                    # Apply mask to image
+                    for y in range(cropped_image.height()):
+                        for x in range(cropped_image.width()):
+                            mask_alpha = mask.pixelColor(x, y).alpha()
+                            color = cropped_image.pixelColor(x, y)
+
+                            # Set alpha to 0 outside polygon, 255 inside
+                            color.setAlpha(255 if mask_alpha > 0 else 0)
+                            cropped_image.setPixelColor(x, y, color)
+
+                    # Convert back to pixmap with proper alpha
+                    cropped_image = QPixmap.fromImage(cropped_image)
+                else:
+                    cropped_image = self.image
+
+                self.finished.emit(annotation, cropped_image)
+
+        except Exception as e:
+            print(e)
+            import traceback
+
+            traceback.print_exc()
+            self.error.emit(str(e))

imagebaker/workers/model_worker.py

@@ -0,0 +1,54 @@
+from imagebaker import logger
+from imagebaker.models.base_model import BaseModel
+from PySide6.QtCore import QObject, Signal
+import numpy as np
+import traceback
+
+
+class ModelPredictionWorker(QObject):
+    finished = Signal(list)
+    error = Signal(str)
+
+    def __init__(
+        self,
+        model: BaseModel,
+        image: np.ndarray,
+        points: list[int],
+        polygons: list[list[int]],
+        rectangles: list[list[int]],
+        label_hints: list[int],
+    ):
+        """
+        A worker that runs the model prediction in a separate thread.
+
+        Args:
+            model (BaseModel): The model to use for prediction.
+            image (np.ndarray): The image to predict on.
+            points (list[int]): The points to predict on.
+            polygons (list[list[int]]): The polygons to predict on.
+            rectangles (list[list[int]]): The rectangles to predict on.
+            label_hints (list[int]): The label hints to use.
+        """
+        super().__init__()
+        self.model = model
+        self.image = image
+        self.points = points
+        self.polygons = polygons
+        self.rectangles = rectangles
+        self.label_hints = label_hints
+
+    def process(self):
+        try:
+            result = self.model.predict(
+                self.image,
+                self.points,
+                self.rectangles,
+                self.polygons,
+                self.label_hints,
+            )
+            self.finished.emit(result)
+        except Exception as e:
+            self.error.emit(str(e))
+            traceback.print_exc()
+            logger.error(f"Model error: {e}")
+            return

{imagebaker-0.0.41.dist-info → imagebaker-0.0.48.dist-info}/METADATA

@@ -1,10 +1,11 @@
-Metadata-Version: 2.4
+Metadata-Version: 2.1
 Name: imagebaker
-Version: 0.0.41
+Version: 0.0.48
 Summary: A package for baking images.
-Author-email: Ramkrishna Acharya <qramkrishna@gmail.com>
+Home-page: https://github.com/q-viper/Image-Baker
+Author: Ramkrishna Acharya
+Author-email: qramkrishna@gmail.com
 License: MIT
-Project-URL: Homepage, https://github.com/q-viper/Image-Baker
 Classifier: Programming Language :: Python :: 3
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Operating System :: OS Independent
@@ -15,7 +16,7 @@ Requires-Dist: numpy>=1.21
 Requires-Dist: matplotlib>=3.4
 Requires-Dist: opencv-python>=4.5
 Requires-Dist: black>=23.1
-Requires-Dist: pydantic>=2.0
+Requires-Dist: pydantic>=2.11.1
 Requires-Dist: flake8>=6.0
 Requires-Dist: typer>=0.9
 Requires-Dist: PySide6==6.8.3
@@ -26,7 +27,6 @@ Requires-Dist: mkdocs-material>=9.0; extra == "docs"
 Requires-Dist: mkdocstrings[python]>=0.21; extra == "docs"
 Requires-Dist: pymdown-extensions>=8.0; extra == "docs"
 Requires-Dist: mkdocs-awesome-pages-plugin; extra == "docs"
-Dynamic: license-file
 
 # Image-Baker
 ![Dependabot Status](https://img.shields.io/badge/dependabot-active-brightgreen)

imagebaker-0.0.48.dist-info/RECORD

@@ -0,0 +1,41 @@
+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,,

{imagebaker-0.0.41.dist-info → imagebaker-0.0.48.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (78.1.0)
+Generator: bdist_wheel (0.45.1)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

imagebaker-0.0.41.dist-info/RECORD

@@ -1,7 +0,0 @@
-imagebaker/__init__.py,sha256=UeXmuH87AJb0MVzWgT4HXNtl99XxS7HGenLyI9K93go,127
-imagebaker-0.0.41.dist-info/licenses/LICENSE,sha256=1vkysFPOnT7y4LsoFTv9YsopIrQvBc2l6vUOfv4KKLc,1082
-imagebaker-0.0.41.dist-info/METADATA,sha256=lJ-4W657mS5XgQ0mKDISr3tdVzTVYSTcTnda-sAPLbs,6761
-imagebaker-0.0.41.dist-info/WHEEL,sha256=CmyFI0kx5cdEMTLiONQRbGQwjIoR1aIYB7eCAQ4KPJ0,91
-imagebaker-0.0.41.dist-info/entry_points.txt,sha256=IDjZHJCiiHpH5IUTByT2en0nMbnnnlrJZ5FPFehUvQM,61
-imagebaker-0.0.41.dist-info/top_level.txt,sha256=Gg-eILTlqJXwVQr0saSwsx3-H4SPdZ2agBZaufe194s,11
-imagebaker-0.0.41.dist-info/RECORD,,