pixelflow 0.5.0__tar.gz → 0.6.0__tar.gz

{pixelflow-0.5.0 → pixelflow-0.6.0}/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2025 datamarkin
+Copyright (c) 2025 Emrah NAZIF
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

{pixelflow-0.5.0 → pixelflow-0.6.0}/PKG-INFO

@@ -1,13 +1,13 @@
 Metadata-Version: 2.4
 Name: pixelflow
-Version: 0.5.0
+Version: 0.6.0
 Summary: Computer vision processing library for visualizing and analyzing detection results from ML models
-Author-email: Emrah Nazif <emrah@datamarkin.com>, Datamarkin <support@datamarkin.com>
+Author-email: Emrah Nazif <emrah@datamarkin.com>
 License: MIT
-Project-URL: Homepage, https://github.com/datamarkin/pixelflow
-Project-URL: Repository, https://github.com/datamarkin/pixelflow
-Project-URL: Issues, https://github.com/datamarkin/pixelflow/issues
-Project-URL: Documentation, https://pixelflow.datamarkin.com
+Project-URL: Homepage, https://github.com/emrahnazif/pixelflow
+Project-URL: Repository, https://github.com/emrahnazif/pixelflow
+Project-URL: Issues, https://github.com/emrahnazif/pixelflow/issues
+Project-URL: Documentation, https://emrah.fr/pixelflow/
 Keywords: computer-vision,visualization,annotation,post-processing,tracking,opencv,yolo,detectron2,mayaku,ml-results
 Classifier: Development Status :: 3 - Alpha
 Classifier: Intended Audience :: Developers
@@ -15,14 +15,13 @@ Classifier: Intended Audience :: Science/Research
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Operating System :: OS Independent
 Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
 Classifier: Topic :: Scientific/Engineering :: Image Recognition
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
-Requires-Python: >=3.9
+Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: shapely>=2.0.0
@@ -39,8 +38,8 @@ Dynamic: license-file
 # PixelFlow
 
 [![PyPI version](https://badge.fury.io/py/pixelflow.svg)](https://badge.fury.io/py/pixelflow)
-[![CI](https://github.com/datamarkin/pixelflow/actions/workflows/ci.yml/badge.svg)](https://github.com/datamarkin/pixelflow/actions/workflows/ci.yml)
-[![Python 3.9+](https://img.shields.io/badge/python-3.9+-blue.svg)](https://www.python.org/downloads/)
+[![CI](https://github.com/emrahnazif/pixelflow/actions/workflows/ci.yml/badge.svg)](https://github.com/emrahnazif/pixelflow/actions/workflows/ci.yml)
+[![Python 3.10+](https://img.shields.io/badge/python-3.10+-blue.svg)](https://www.python.org/downloads/)
 [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
 
 **The computer vision library that gets out of your way.**
@@ -132,6 +131,17 @@ detections = pf.from_easyocr(reader.readtext("sign.jpg"))
 detections = pf.from_arrays(boxes, scores, class_ids, labels=model.class_names)
 ```
 
+Segmentation models answer with raster masks. One call turns them into polygons,
+whichever model they came from:
+
+```python
+detections = pf.from_arrays(boxes, scores, masks=masks)   # boolean (N, H, W)
+detections.masks_to_segments()                            # fills det.segments
+detections.masks_to_segments(keep_masks=False)            # ...and drops the rasters
+
+polygon = pf.mask_to_polygon(mask)                        # or one mask at a time
+```
+
 ### Classifications - When the Model Only Names
 
 A classifier localises nothing, so its result carries no geometry at all:
@@ -457,7 +467,7 @@ report = detections.to_json_with_metrics()
 
 ## Documentation
 
-Full documentation available at [https://datamarkin.com/docs/pixelflow/](https://datamarkin.com/docs/pixelflow/)
+Full documentation available at [https://emrah.fr/pixelflow/](https://emrah.fr/pixelflow/)
 
 ## Contributing
 
@@ -469,4 +479,4 @@ MIT License - see LICENSE file for details.
 
 ---
 
-Built with love by [Datamarkin](https://datamarkin.com)
+Built with love by [Emrah Nazif](https://emrah.fr)

{pixelflow-0.5.0 → pixelflow-0.6.0}/README.md

@@ -1,8 +1,8 @@
 # PixelFlow
 
 [![PyPI version](https://badge.fury.io/py/pixelflow.svg)](https://badge.fury.io/py/pixelflow)
-[![CI](https://github.com/datamarkin/pixelflow/actions/workflows/ci.yml/badge.svg)](https://github.com/datamarkin/pixelflow/actions/workflows/ci.yml)
-[![Python 3.9+](https://img.shields.io/badge/python-3.9+-blue.svg)](https://www.python.org/downloads/)
+[![CI](https://github.com/emrahnazif/pixelflow/actions/workflows/ci.yml/badge.svg)](https://github.com/emrahnazif/pixelflow/actions/workflows/ci.yml)
+[![Python 3.10+](https://img.shields.io/badge/python-3.10+-blue.svg)](https://www.python.org/downloads/)
 [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
 
 **The computer vision library that gets out of your way.**
@@ -94,6 +94,17 @@ detections = pf.from_easyocr(reader.readtext("sign.jpg"))
 detections = pf.from_arrays(boxes, scores, class_ids, labels=model.class_names)
 ```
 
+Segmentation models answer with raster masks. One call turns them into polygons,
+whichever model they came from:
+
+```python
+detections = pf.from_arrays(boxes, scores, masks=masks)   # boolean (N, H, W)
+detections.masks_to_segments()                            # fills det.segments
+detections.masks_to_segments(keep_masks=False)            # ...and drops the rasters
+
+polygon = pf.mask_to_polygon(mask)                        # or one mask at a time
+```
+
 ### Classifications - When the Model Only Names
 
 A classifier localises nothing, so its result carries no geometry at all:
@@ -419,7 +430,7 @@ report = detections.to_json_with_metrics()
 
 ## Documentation
 
-Full documentation available at [https://datamarkin.com/docs/pixelflow/](https://datamarkin.com/docs/pixelflow/)
+Full documentation available at [https://emrah.fr/pixelflow/](https://emrah.fr/pixelflow/)
 
 ## Contributing
 
@@ -431,4 +442,4 @@ MIT License - see LICENSE file for details.
 
 ---
 
-Built with love by [Datamarkin](https://datamarkin.com)
+Built with love by [Emrah Nazif](https://emrah.fr)

{pixelflow-0.5.0 → pixelflow-0.6.0}/pixelflow/__init__.py

@@ -1,5 +1,5 @@
-__version__ = "0.5.0"
-__author__ = "Datamarkin"
+__version__ = "0.6.0"
+__author__ = "Emrah NAZIF"
 
 # Import core modules
 from . import media
@@ -29,6 +29,7 @@ from .media import (
     read_image, read_video, encode_image, display_video, display_image, save_image,
     close_display, to_pil, from_pil,
 )
+from .masks import mask_to_polygon
 from .zones import Zones
 from .crossings import Crossings
 from .slicer import SlicedInference, auto_slice_size
@@ -95,6 +96,9 @@ __all__ = [
     "to_pil",
     "from_pil",
 
+    # Mask geometry
+    "mask_to_polygon",
+
     # Spatial analysis
     "zones",
     "Zones",

{pixelflow-0.5.0 → pixelflow-0.6.0}/pixelflow/detections/detections.py

@@ -17,8 +17,8 @@ from PIL import Image
 from pixelflow.validators import (validate_bbox,
                                   validate_segments,
                                   round_coord,
-                                  round_to_decimal,
-                                  simplify_polygon)
+                                  round_to_decimal)
+from pixelflow.masks import mask_to_polygon, simplify_polygon
 from typing import (List,
                     Iterator, Optional, Union, Any, Dict)
 
@@ -33,6 +33,11 @@ __all__ = ["KeyPoint", "Detection", "Detections"]
 _PNG_MASK_DTYPES = frozenset(("bool", "uint8", "uint16"))
 
 
+def _is_raster_mask(mask: Any) -> bool:
+    """Whether an entry of `Detection.masks` is a pixel raster rather than a polygon."""
+    return isinstance(mask, np.ndarray)
+
+
 def _is_png_encodable(mask: np.ndarray) -> bool:
     """Whether a mask array can be losslessly PNG-encoded by Pillow."""
     if mask.size == 0 or str(mask.dtype) not in _PNG_MASK_DTYPES:
@@ -170,6 +175,11 @@ class Detection:
                                     segments this field is not yet normalized to one shape.
         segments (Optional[List[List[float]]]): Object outline as one polygon, normalized by
                                     validate_segments to [[x, y], ...] at two decimals, or None.
+                                    Coordinates follow the pixel-corner convention bbox uses:
+                                    pixel (row i, column j) covers x from j to j + 1 and y
+                                    from i to i + 1. Polygons a model computed itself (the
+                                    Ultralytics converter passes them through) only
+                                    approximate this; masks_to_segments() makes them exact.
         keypoints (Optional[List[KeyPoint]]): List of KeyPoint objects for pose/structure data.
         class_id (Optional[Union[int, str]]): Numeric or string class identifier from model.
         class_name (Optional[str]): Human-readable class name (e.g., "person", "vehicle").
@@ -373,7 +383,7 @@ class Detection:
         if self.masks:
             serializable_masks = []
             for mask in self.masks:
-                if isinstance(mask, np.ndarray):
+                if _is_raster_mask(mask):
                     if _is_png_encodable(mask):
                         # Binary mask - PNG-encode, then base64 for JSON
                         # transport. PNG compresses masks losslessly; encoding
@@ -533,8 +543,83 @@ class Detection:
             - Recommended for real-time applications with complex segmentation masks
         """
         if self.masks:
-            # Apply the simplify function to each mask (assuming self.masks is a list of polygons)
-            self.masks = [simplify_polygon(mask, tolerance, preserve_topology) for mask in self.masks]
+            # A raster is not a polygon: it passes through untouched, as documented.
+            self.masks = [
+                mask if _is_raster_mask(mask)
+                else simplify_polygon(mask, tolerance, preserve_topology)
+                for mask in self.masks
+            ]
+
+    def masks_to_segments(self, tolerance: float = 1.5, keep_masks: bool = True) -> bool:
+        """
+        Fill `segments` with the outline of this detection's raster mask.
+
+        Converts the raster in `masks` to one polygon with `mask_to_polygon` and
+        stores it in `segments`. Lets a result from any segmentation model be drawn,
+        stored or sent as a polygon without carrying the raster along.
+
+        Args:
+            tolerance (float): Simplification tolerance in pixels, passed to
+                              `mask_to_polygon`. Range: [0.0, inf). Default is 1.5.
+            keep_masks (bool): Whether to keep the raster in `masks` after converting.
+                              False drops it to save memory. Default is True.
+
+        Returns:
+            bool: True if `segments` was set, False if the detection was left unchanged.
+
+        Raises:
+            ValueError: If `tolerance` is negative.
+
+        Example:
+            >>> import numpy as np
+            >>> import pixelflow as pf
+            >>>
+            >>> mask = np.zeros((480, 640), dtype=bool)
+            >>> mask[100:200, 50:300] = True
+            >>> detection = pf.Detection(bbox=[50, 100, 300, 200], masks=[mask])
+            >>>
+            >>> # Fill segments, keep the raster for drawing
+            >>> detection.masks_to_segments()
+            True
+            >>> detection.segments
+            [[50.0, 100.0], [50.0, 200.0], [300.0, 200.0], [300.0, 100.0]]
+            >>>
+            >>> # Finer outline, raster dropped
+            >>> detection.masks_to_segments(tolerance=0.5, keep_masks=False)
+            True
+            >>> detection.masks is None
+            True
+
+        Notes:
+            - Modifies the detection in-place
+            - A detection with no mask, a polygon mask, or an empty raster is left
+              unchanged
+            - Existing `segments` are replaced when a raster is present: the raster
+              is what the model produced, and a polygon derived from it follows the
+              pixel-corner convention exactly
+            - Several rasters of the same shape are treated as parts of one object
+              and merged before tracing; `segments` still receives one outline
+            - With `keep_masks=False` only a converted raster is dropped. A raster
+              that produced no polygon stays, so no geometry is lost silently
+        """
+        if not self.masks:
+            return False
+
+        # Only a 2D raster can be traced; stacked or multi-channel arrays are left alone.
+        rasters = [m for m in self.masks if _is_raster_mask(m) and m.ndim == 2]
+        if not rasters:
+            return False
+        rasters = [m for m in rasters if m.shape == rasters[0].shape]
+
+        polygon = mask_to_polygon(np.logical_or.reduce(rasters), tolerance=tolerance)
+        if polygon is None:
+            return False
+
+        self.segments = polygon
+        if not keep_masks:
+            converted = {id(m) for m in rasters}
+            self.masks = [m for m in self.masks if id(m) not in converted] or None
+        return True
 
     def copy(self) -> "Detection":
         """
@@ -796,6 +881,60 @@ class Detections:
             detection.simplify_masks(tolerance=tolerance, preserve_topology=preserve_topology)
         return self
 
+    def masks_to_segments(self, tolerance: float = 1.5, keep_masks: bool = True) -> 'Detections':
+        """
+        Fill `segments` from the raster mask of every detection in the collection.
+
+        Turns the output of any segmentation model into polygons: each detection's
+        raster in `masks` is traced along its pixel corners, simplified, and stored in
+        `segments`. Every source then shares one polygon convention, whichever model
+        produced it.
+
+        Args:
+            tolerance (float): Simplification tolerance in pixels. Higher values give
+                              fewer points. Range: [0.0, inf). Default is 1.5.
+            keep_masks (bool): Whether to keep the rasters in `masks` after
+                              converting. False drops them to save memory.
+                              Default is True.
+
+        Returns:
+            Detections: Returns self for method chaining.
+
+        Raises:
+            ValueError: If `tolerance` is negative.
+
+        Example:
+            >>> import pixelflow as pf
+            >>>
+            >>> # SAM-style output: boxes and boolean (N, H, W) masks
+            >>> detections = pf.from_arrays(boxes, scores, masks=masks)
+            >>> detections.masks_to_segments()
+            >>> detections[0].segments  # [[x, y], ...]
+            >>>
+            >>> # Draw outlines, which read `segments`
+            >>> image = pf.annotate.polygon(image, detections)
+            >>>
+            >>> # Keep only polygons, e.g. before serializing
+            >>> payload = detections.masks_to_segments(keep_masks=False).to_json()
+            >>>
+            >>> # Finer outlines at the cost of more points
+            >>> detections.masks_to_segments(tolerance=0.5)
+
+        Notes:
+            - Modifies detections in-place; order and every other field are untouched
+            - Detections without a raster mask, or with an empty one, are left unchanged
+            - Existing `segments` are replaced where a raster is present, which also
+              brings Ultralytics' own polygons onto the pixel-corner convention
+            - One outline per detection: holes and all but the largest region are
+              dropped. See `mask_to_polygon` for the exact rules
+
+        Performance Notes:
+            - A few milliseconds per detection at full-HD; cost follows object size
+        """
+        for detection in self.detections:
+            detection.masks_to_segments(tolerance=tolerance, keep_masks=keep_masks)
+        return self
+
     def copy(self) -> "Detections":
         """
         Create a deep copy of all detections in the collection.

pixelflow-0.6.0/pixelflow/masks.py

@@ -0,0 +1,212 @@
+"""Raster masks to polygons.
+
+Segmentation models answer in pixels - a boolean ``H x W`` raster per object - while
+everything that stores, edits or transmits an outline wants a polygon. This module is
+the bridge, and it settles the one question a bridge has to settle: where exactly a
+polygon vertex sits relative to the pixels it encloses.
+
+The convention is pixel corners. Pixel ``(row i, column j)`` covers the square from
+``x = j`` to ``x = j + 1`` and ``y = i`` to ``y = i + 1``, and the polygon runs along
+the outside edges of the pixels it encloses. A mask covering columns 10..19 therefore
+spans ``x = 10`` to ``x = 20``, which is the same box ``[x1, y1, x2, y2]`` describes
+for that object. Tracing through pixel centres instead - what ``cv2.findContours``
+returns - shrinks every object by half a pixel on each side and turns a one-pixel-wide
+line into a polygon of zero area.
+"""
+
+import cv2
+import numpy as np
+
+from pixelflow.validators import validate_segments
+
+__all__ = ["mask_to_polygon", "simplify_polygon"]
+
+
+def _trace_outline(region: np.ndarray) -> np.ndarray:
+    """
+    Trace the outer boundary of one connected region along its pixel corners.
+
+    Returns ``(N, 2)`` int32 ``(x, y)`` points in doubled coordinates: pixel corners
+    land on even numbers and the midpoints of pixel edges on odd ones, so the caller
+    halves the result. Staying in integers until then keeps every vertex exact.
+    """
+    height, width = region.shape
+
+    # Each pixel becomes a 3x3 block on a (2H+1, 2W+1) grid: its centre at an
+    # odd/odd position, dilated out to its own corners. Neighbouring pixels share
+    # the grid points on their common edge, so the filled shape is the region's
+    # true footprint and its border passes through real pixel corners.
+    grid = np.zeros((2 * height + 1, 2 * width + 1), dtype=np.uint8)
+    grid[1::2, 1::2] = region
+    grid = cv2.dilate(grid, np.ones((3, 3), dtype=np.uint8))
+
+    contours, _ = cv2.findContours(grid, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_NONE)
+    points = max(contours, key=len)[:, 0, :]
+
+    # OpenCV's border follower steps diagonally across a concave corner, from one
+    # edge midpoint to the next, because the corner itself has no background among
+    # its four neighbours. Every diagonal step is such a cut.
+    following = np.roll(points, -1, axis=0)
+    diagonal = np.abs(following - points).sum(axis=1) == 2
+    start, end = points[diagonal], following[diagonal]
+    # Each midpoint has one even coordinate; the corner takes the even one of each.
+    corners = np.where(start % 2 == 0, start, end)
+    return np.insert(points, np.nonzero(diagonal)[0] + 1, corners, axis=0)
+
+
+def _simplify_outline(outline: np.ndarray, epsilon: float) -> np.ndarray:
+    """
+    Douglas-Peucker on a closed outline, with its four extreme vertices pinned.
+
+    Simplifying the loop as a whole is free to drop the leftmost or topmost vertex
+    whenever it lies within `epsilon` of the result, which pulls the polygon's
+    bounding box inside the mask's. Cutting the loop at one vertex per side and
+    simplifying each arc between them keeps those vertices, so the box around the
+    polygon is exactly the box around the mask at any tolerance.
+    """
+    xs, ys = outline[:, 0], outline[:, 1]
+
+    def extreme(primary, secondary):
+        # First along one axis, ties broken along the other.
+        candidates = np.flatnonzero(primary == primary.min())
+        return int(candidates[np.argmin(secondary[candidates])])
+
+    # Each side is a straight run of points; taking the end of the run rather than
+    # any point on it pins a real corner, so a rectangle keeps exactly four.
+    anchors = sorted([
+        extreme(xs, ys),    # leftmost, then topmost
+        extreme(ys, -xs),   # topmost, then rightmost
+        extreme(-xs, -ys),  # rightmost, then bottommost
+        extreme(-ys, xs),   # bottommost, then leftmost
+    ])
+
+    arcs = []
+    for start, end in zip(anchors, anchors[1:] + [anchors[0] + len(outline)]):
+        # Both end anchors included; the last arc wraps round to the first anchor.
+        arc = outline.take(np.arange(start, end + 1), axis=0, mode="wrap")
+        # An open curve keeps both end points; the last one opens the next arc.
+        arcs.append(cv2.approxPolyDP(arc.reshape(-1, 1, 2), epsilon, False)[:-1, 0, :])
+    return np.concatenate(arcs)
+
+
+def mask_to_polygon(mask, tolerance: float = 1.5):
+    """
+    Convert one raster mask into one polygon outlining its largest region.
+
+    Traces the outer boundary of the largest connected region along its pixel
+    corners, then reduces the vertex count with Douglas-Peucker simplification.
+    The result is in the shape `Detection.segments` holds, so it can be assigned
+    directly.
+
+    Args:
+        mask: 2D array of shape `(H, W)`. Non-zero pixels are the object, so a
+              boolean mask and a 0/255 uint8 mask behave the same. A probability
+              map must be thresholded by the caller first.
+        tolerance (float): Maximum distance in pixels a simplified edge may stray
+                          from the traced outline. Range: [0.0, inf). `0` keeps
+                          the exact pixel staircase and only removes points on
+                          straight runs. Default is 1.5.
+
+    Returns:
+        Optional[List[List[float]]]: The polygon as `[[x, y], ...]` in the mask's own
+            pixel coordinates, not closed (the first point is not repeated at the
+            end). None if the mask is empty.
+
+    Raises:
+        ValueError: If `mask` is not 2D, or `tolerance` is negative.
+
+    Example:
+        >>> import numpy as np
+        >>> import pixelflow as pf
+        >>>
+        >>> mask = np.zeros((480, 640), dtype=bool)
+        >>> mask[100:200, 50:300] = True
+        >>>
+        >>> # A rectangle comes back as its four pixel corners
+        >>> pf.mask_to_polygon(mask)
+        [[50.0, 100.0], [50.0, 200.0], [300.0, 200.0], [300.0, 100.0]]
+        >>>
+        >>> # Exact outline, every stair of the pixel boundary kept
+        >>> outline = pf.mask_to_polygon(mask, tolerance=0)
+        >>>
+        >>> # Assign straight to a detection
+        >>> detection = pf.Detection(bbox=[50, 100, 300, 200])
+        >>> detection.segments = pf.mask_to_polygon(mask)
+
+    Notes:
+        - Coordinates are pixel corners: a mask covering columns 10..19 spans
+          x = 10 to x = 20, so the polygon's bounding box equals the mask's
+        - One polygon per mask. Holes are filled and every region but the largest
+          is dropped, because `segments` holds a single outline
+        - Regions are 4-connected: pixels touching only at a corner are separate
+          regions. A region that pinches to a single corner still yields one
+          outline, which touches itself at that corner
+        - Simplification only removes vertices, and never the outermost one on
+          each side, so the remaining points are exact pixel corners and the
+          bounding box is exact at any tolerance
+        - The pixel staircase on a slanted edge is itself about one pixel of
+          noise. Below a tolerance of roughly 1.5 the stairs survive and a large
+          object keeps hundreds of points; at 1.5 it keeps tens
+        - No object is too small: a one-pixel mask returns the four corners of
+          that pixel at any tolerance, because the extreme vertices are kept
+
+    Performance Notes:
+        - One pass over the frame finds the occupied area; all other work is
+          proportional to that area, not the image
+        - In a 1920x1281 mask: well under 1 ms for a 20 px object, around 5 ms
+          for one 1000 px across
+    """
+    mask = np.asarray(mask)
+    if mask.ndim != 2:
+        raise ValueError(f"mask must be 2D (H, W), got shape {mask.shape}")
+    if tolerance < 0:
+        raise ValueError(f"tolerance must be >= 0, got {tolerance}")
+
+    if mask.dtype != np.bool_:
+        mask = mask != 0
+    # A boolean array is already the 0/1 bytes OpenCV wants, so view it, don't copy it.
+    binary = np.ascontiguousarray(mask).view(np.uint8)
+
+    # Crop to the occupied part of the frame before anything else: an object is
+    # usually a small part of the image, and every later step costs by the pixel.
+    left, top, width, height = cv2.boundingRect(binary)
+    if width == 0:
+        return None
+    binary = binary[top:top + height, left:left + width]
+
+    # Label 0 is the background, so the regions start at 1.
+    _, labels, stats, _ = cv2.connectedComponentsWithStats(binary, connectivity=4)
+    largest = 1 + int(np.argmax(stats[1:, cv2.CC_STAT_AREA]))
+    x, y, width, height = (int(v) for v in stats[largest, :4])
+    region = (labels[y:y + height, x:x + width] == largest).astype(np.uint8)
+
+    outline = _simplify_outline(_trace_outline(region), 2.0 * tolerance)  # doubled, like the points
+    return validate_segments(outline / 2.0 + (left + x, top + y))
+
+
+def simplify_polygon(polygon_points, tolerance: float = 2.0, preserve_topology: bool = True):
+    """
+    Reduce the number of points in one polygon with Douglas-Peucker simplification.
+
+    Args:
+        polygon_points: The polygon as a sequence of (x, y) points. A closing point
+                        that repeats the first one is accepted and dropped.
+        tolerance (float): Maximum distance in pixels a simplified edge may stray from
+                           the original outline (higher = more simplified).
+        preserve_topology (bool): Accepted for backwards compatibility and ignored.
+                                  Plain Douglas-Peucker can, on a thin shape and a
+                                  large tolerance, produce an outline that crosses
+                                  itself.
+
+    Returns:
+        List[List[float]]: The simplified polygon as ``[[x, y], ...]`` at the shared
+            precision, not closed.
+    """
+    points = np.asarray(polygon_points, dtype=np.float32).reshape(-1, 2)
+    if len(points) > 1 and np.array_equal(points[0], points[-1]):
+        points = points[:-1]
+    if len(points) > 3:
+        # Douglas-Peucker only ever drops vertices, so the survivors are the caller's
+        # own points; validate_segments rounds the float32 artefacts back out of them.
+        points = cv2.approxPolyDP(points.reshape(-1, 1, 2), float(tolerance), True)[:, 0, :]
+    return validate_segments(points)

{pixelflow-0.5.0 → pixelflow-0.6.0}/pixelflow/validators.py

@@ -9,7 +9,6 @@ Optional fields; see round_coord for why a KeyPoint raises instead.
 import math
 
 import numpy as np
-from shapely.geometry import Polygon as Shapely_Polygon
 
 
 # How much precision pixelflow keeps. Truncating pixel coordinates to whole
@@ -124,25 +123,3 @@ def round_to_decimal(value, decimals=CONFIDENCE_DECIMALS):
     if value is not None:
         return round(float(value), decimals)
     return None
-
-
-def simplify_polygon(polygon_points: list, tolerance: float = 2.0, preserve_topology: bool = True) -> list:
-    """
-    Simplifies a single polygon using Shapely.
-
-    Args:
-        polygon_points (list): A list of tuples representing a polygon.
-        tolerance (float): The tolerance factor for simplification (higher = more simplified).
-        preserve_topology (bool): If True, the function will try to preserve the polygon's topology.
-
-    Returns:
-        list: A simplified polygon represented as a list of tuples.
-    """
-    # Convert the list of tuples to a Shapely Polygon
-    polygon = Shapely_Polygon(polygon_points)
-
-    # Simplify the polygon using the specified tolerance
-    simplified_polygon = polygon.simplify(tolerance=tolerance, preserve_topology=preserve_topology)
-
-    # Return the simplified coordinates as a list of tuples
-    return list(simplified_polygon.exterior.coords)

{pixelflow-0.5.0 → pixelflow-0.6.0}/pixelflow.egg-info/PKG-INFO

@@ -1,13 +1,13 @@
 Metadata-Version: 2.4
 Name: pixelflow
-Version: 0.5.0
+Version: 0.6.0
 Summary: Computer vision processing library for visualizing and analyzing detection results from ML models
-Author-email: Emrah Nazif <emrah@datamarkin.com>, Datamarkin <support@datamarkin.com>
+Author-email: Emrah Nazif <emrah@datamarkin.com>
 License: MIT
-Project-URL: Homepage, https://github.com/datamarkin/pixelflow
-Project-URL: Repository, https://github.com/datamarkin/pixelflow
-Project-URL: Issues, https://github.com/datamarkin/pixelflow/issues
-Project-URL: Documentation, https://pixelflow.datamarkin.com
+Project-URL: Homepage, https://github.com/emrahnazif/pixelflow
+Project-URL: Repository, https://github.com/emrahnazif/pixelflow
+Project-URL: Issues, https://github.com/emrahnazif/pixelflow/issues
+Project-URL: Documentation, https://emrah.fr/pixelflow/
 Keywords: computer-vision,visualization,annotation,post-processing,tracking,opencv,yolo,detectron2,mayaku,ml-results
 Classifier: Development Status :: 3 - Alpha
 Classifier: Intended Audience :: Developers
@@ -15,14 +15,13 @@ Classifier: Intended Audience :: Science/Research
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Operating System :: OS Independent
 Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
 Classifier: Topic :: Scientific/Engineering :: Image Recognition
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
-Requires-Python: >=3.9
+Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: shapely>=2.0.0
@@ -39,8 +38,8 @@ Dynamic: license-file
 # PixelFlow
 
 [![PyPI version](https://badge.fury.io/py/pixelflow.svg)](https://badge.fury.io/py/pixelflow)
-[![CI](https://github.com/datamarkin/pixelflow/actions/workflows/ci.yml/badge.svg)](https://github.com/datamarkin/pixelflow/actions/workflows/ci.yml)
-[![Python 3.9+](https://img.shields.io/badge/python-3.9+-blue.svg)](https://www.python.org/downloads/)
+[![CI](https://github.com/emrahnazif/pixelflow/actions/workflows/ci.yml/badge.svg)](https://github.com/emrahnazif/pixelflow/actions/workflows/ci.yml)
+[![Python 3.10+](https://img.shields.io/badge/python-3.10+-blue.svg)](https://www.python.org/downloads/)
 [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
 
 **The computer vision library that gets out of your way.**
@@ -132,6 +131,17 @@ detections = pf.from_easyocr(reader.readtext("sign.jpg"))
 detections = pf.from_arrays(boxes, scores, class_ids, labels=model.class_names)
 ```
 
+Segmentation models answer with raster masks. One call turns them into polygons,
+whichever model they came from:
+
+```python
+detections = pf.from_arrays(boxes, scores, masks=masks)   # boolean (N, H, W)
+detections.masks_to_segments()                            # fills det.segments
+detections.masks_to_segments(keep_masks=False)            # ...and drops the rasters
+
+polygon = pf.mask_to_polygon(mask)                        # or one mask at a time
+```
+
 ### Classifications - When the Model Only Names
 
 A classifier localises nothing, so its result carries no geometry at all:
@@ -457,7 +467,7 @@ report = detections.to_json_with_metrics()
 
 ## Documentation
 
-Full documentation available at [https://datamarkin.com/docs/pixelflow/](https://datamarkin.com/docs/pixelflow/)
+Full documentation available at [https://emrah.fr/pixelflow/](https://emrah.fr/pixelflow/)
 
 ## Contributing
 
@@ -469,4 +479,4 @@ MIT License - see LICENSE file for details.
 
 ---
 
-Built with love by [Datamarkin](https://datamarkin.com)
+Built with love by [Emrah Nazif](https://emrah.fr)

{pixelflow-0.5.0 → pixelflow-0.6.0}/pixelflow.egg-info/SOURCES.txt

@@ -7,6 +7,7 @@ pixelflow/buffer.py
 pixelflow/colors.py
 pixelflow/crossings.py
 pixelflow/labels.py
+pixelflow/masks.py
 pixelflow/media.py
 pixelflow/slicer.py
 pixelflow/smoother.py

{pixelflow-0.5.0 → pixelflow-0.6.0}/pyproject.toml

@@ -7,11 +7,10 @@ name = "pixelflow"
 dynamic = ["version"]
 description = "Computer vision processing library for visualizing and analyzing detection results from ML models"
 readme = "README.md"
-requires-python = ">=3.9"
+requires-python = ">=3.10"
 license = {text = "MIT"}
 authors = [
-    {name = "Emrah Nazif", email = "emrah@datamarkin.com"},
-    {name = "Datamarkin", email = "support@datamarkin.com"}
+    {name = "Emrah Nazif", email = "emrah@datamarkin.com"}
 ]
 
 keywords = [
@@ -34,7 +33,6 @@ classifiers = [
     "License :: OSI Approved :: MIT License",
     "Operating System :: OS Independent",
     "Programming Language :: Python :: 3",
-    "Programming Language :: Python :: 3.9",
     "Programming Language :: Python :: 3.10",
     "Programming Language :: Python :: 3.11",
     "Programming Language :: Python :: 3.12",
@@ -59,10 +57,10 @@ dev = [
 ]
 
 [project.urls]
-Homepage = "https://github.com/datamarkin/pixelflow"
-Repository = "https://github.com/datamarkin/pixelflow"
-Issues = "https://github.com/datamarkin/pixelflow/issues"
-Documentation = "https://pixelflow.datamarkin.com"
+Homepage = "https://github.com/emrahnazif/pixelflow"
+Repository = "https://github.com/emrahnazif/pixelflow"
+Issues = "https://github.com/emrahnazif/pixelflow/issues"
+Documentation = "https://emrah.fr/pixelflow/"
 
 [tool.setuptools.dynamic]
 version = {attr = "pixelflow.__version__"}