imagebaker 0.0.4__py3-none-any.whl → 0.0.46__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.4.dist-info → imagebaker-0.0.46.dist-info}/METADATA

@@ -1,10 +1,11 @@
-Metadata-Version: 2.4
+Metadata-Version: 2.1
 Name: imagebaker
-Version: 0.0.4
+Version: 0.0.46
 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
@@ -26,9 +27,22 @@ 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)
+![GitHub License](https://img.shields.io/github/license/q-viper/image-baker)
+![commit activity](https://img.shields.io/github/commit-activity/w/q-viper/SmokeSim/master)
+![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)
+
+
+<p align="center">
+    <img src="assets/demo.gif" alt="Centered Demo" />
+</p>
+
+
+*An example of baked images. (Each object is a layer and an annotation will also be extracted for all layers.)*
 
 Let's bake an image.
 
@@ -37,15 +51,12 @@ Let's bake an image.
 When training computer vision models (especially for detection and segmentation), labeling large amounts of data is crucial for better model performance. Often, the process involves multiple cycles of labeling, training, and evaluation. By generating multiple realistic labeled datasets from a single image, the time spent on labeling can be significantly reduced.
 
 ## What's up with the name?
-
-The concept involves extracting portions of an image (e.g., objects of interest) using tools like polygons or models such as Segment Anything. These extractions are treated as layers, which can then be copied, pasted, and manipulated to create multiple instances of the desired object. By combining these layers step by step, a new labeled image with annotations in JSON format is created. The term "Baking" refers to the process of merging these layers into a single cohesive image.
+The concept involves extracting portions of an image (e.g., objects of interest) using tools like polygons or models such as Segment Anything. These extractions are treated as layers, which can then be copied, pasted, and manipulated to create multiple instances of the desired object. By combining these layers step by step, a new labeled image with annotations in JSON format is created. The term "baking" refers to the process of merging these layers into a single cohesive image.
 
 ## Getting Started
-
 ### Installation
-
 #### Using PIP
-This project is also available in PyPI server.
+This project is also available on the PyPI server.
 
 ```bash
 pip install imagebaker
@@ -61,25 +72,29 @@ pip install -e .
 ```
 
 ### First Run
-
 Run the following command to launch the GUI:
 
-```bash
-imagebaker
-```
+`imagebaker`
 
-If the command does not work, try running the example script after cloning the project.:
+By default, the above command will not run any models on the backend. So please take a look into the example of model definition at [examples/loaded_models.py](examples/loaded_models.py). Then we need to pass it as:
 
-```bash
-python examples/app.py
-```
+`imagebaker --models-file examples/loaded_models.py`
 
-## Features
+For more options, please do: `imagebaker --help` It should give the following options.
+
+![](assets/demo/options.png)
+
+
+* **`--configs-file`** allows us to define custom configs. The custom configs have to inherit LayerConfig and CanvasConfig defined at [imagebaker/core/configs/configs.py](imagebaker/core/configs/configs.py). An example is available at [examples](examples/). 
 
+After cloning and going to the project directory, the following code should work.
+`imagebaker --models-file examples/loaded_models.py --configs-file examples/example_config.py`
+
+## Features
 - **Annotating Images**: Load a folder of images and annotate them using bounding boxes or polygons.
 - **Model Testing**: Define models for detection, segmentation, and prompts (e.g., points or rectangles) by following the base model structure in [imagebaker/models/base_model.py](imagebaker/models/base_model.py). See [examples/loaded_models.py](examples/loaded_models.py) for a working example.
 - **Layerifying**: Crop images based on annotations to create reusable layers. Each cropped image represents a single layer.
-- **Baking States**: Arrange layers to create image variations by dragging, rotating, adjusting opacity, and more. Save the state using the **Save State** button or **Ctrl + S**.
+- **Baking States**: Arrange layers to create image variations by dragging, rotating, adjusting opacity, and more. Save the state using the Save State button or Ctrl + S.
 - **Playing States**: Replay saved states, export them locally, or use them for further predictions.
 - **Exporting States**: Export the final annotated JSON and the baked multilayer image.
 
@@ -89,29 +104,50 @@ python examples/app.py
 * **Delete**: Delete selected annotation/layer.
 * **Left Click**: Select an annotation/layer on mouse position.
 * **Left Click + Drag**: Drag a selected annotation/layer.
-* **Double Left Click**: When using Polygon annotation, completes the polygon.
-* **Right Click**: Deselect an annotation/layer. While on annotating polygon, undo last point.
-* **Ctrl + Mouse Wheel**: Zoom In/Out on the mouse position i.e. resizes the viewport.
+* **Double Left Click**: When using polygon annotation, completes the polygon.
+* **Right Click**: Deselect an annotation/layer. While annotating the polygon, undo the last point.
+* **Ctrl + Mouse Wheel**: Zoom In/Out on the mouse position, i.e., resize the viewport.
 * **Ctrl + Drag**: If done on the background, the viewport is panned.
 * **Ctrl + S**: Save State on Baker Tab.
 * **Ctrl + D**: Draw Mode on Baker Tab. Drawing can happen on a selected or main layer.
 * **Ctrl + E**: Erase Mode on Baker Tab.
-* **Wheel**: Change size of the drawing pointer.
-
+* **Wheel**: Change the size of the drawing pointer.
 
 ## Demo
+### Annotation Page
+This is where the loading of the image folder and annotation, connection with the model running in the backend, and layerifying happen.
 
-## Demo
+![](assets/demo/annotation_page.png)
+
+### Baker Page
+This is where the layer baking happens. And the extraction of the layers as well.
+
+![](assets/demo/baker_page.png)
+
+An example of drawing:
+
+![](assets/demo/drawing.png)
+
+### Annotated
+
+The JSON and the baked image will be exported to the local folder, and in debug mode, the annotations and the mask for each layer will be exported too.
+
+![](assets/demo/annotated_veg_smiley.png)
+
+### Demo Video
 
 To see the tool in action, check out the demo video below:
 
+
 [![Demo Video](https://img.youtube.com/vi/WckMT0r-2Lc/0.jpg)](https://youtu.be/WckMT0r-2Lc)
 
+
 Click on the image above to play the video on YouTube.
 
 
 ## Contributions
 
+
 Contributions are welcome! 
 
-Do you find this project to be useful and looking for some features that is not implemented yet? Feel free to open issues or submit pull requests to improve the project.
+Do you find this project to be useful and are you looking for some features that are not implemented yet? Feel free to open issues or submit pull requests to improve the project.

imagebaker-0.0.46.dist-info/RECORD

@@ -0,0 +1,41 @@
+imagebaker/__init__.py,sha256=UeXmuH87AJb0MVzWgT4HXNtl99XxS7HGenLyI9K93go,127
+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.46.dist-info/LICENSE,sha256=1vkysFPOnT7y4LsoFTv9YsopIrQvBc2l6vUOfv4KKLc,1082
+imagebaker-0.0.46.dist-info/METADATA,sha256=eQ78w8cbBe1zk2PCQlStYW5BzoMj1hO3yxlHnm7xVfA,6733
+imagebaker-0.0.46.dist-info/WHEEL,sha256=tZoeGjtWxWRfdplE7E3d45VPlLNQnvbKiYnx7gwAy8A,92
+imagebaker-0.0.46.dist-info/entry_points.txt,sha256=IDjZHJCiiHpH5IUTByT2en0nMbnnnlrJZ5FPFehUvQM,61
+imagebaker-0.0.46.dist-info/top_level.txt,sha256=Gg-eILTlqJXwVQr0saSwsx3-H4SPdZ2agBZaufe194s,11
+imagebaker-0.0.46.dist-info/RECORD,,

{imagebaker-0.0.4.dist-info → imagebaker-0.0.46.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.4.dist-info/RECORD

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