imagebaker 0.0.2__tar.gz → 0.0.3__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: imagebaker
-Version: 0.0.2
+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/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.2 → imagebaker-0.0.3}/imagebaker.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: imagebaker
-Version: 0.0.2
+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.2 → imagebaker-0.0.3}/imagebaker.egg-info/SOURCES.txt

@@ -34,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.2 → imagebaker-0.0.3}/setup.py

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