pixelflow 0.1.3__tar.gz → 0.3.0__tar.gz

{pixelflow-0.1.3 → pixelflow-0.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pixelflow
-Version: 0.1.3
+Version: 0.3.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>
 License: MIT
@@ -8,7 +8,7 @@ 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
-Keywords: computer-vision,visualization,annotation,post-processing,tracking,opencv,yolo,detectron2,ml-results
+Keywords: computer-vision,visualization,annotation,post-processing,tracking,opencv,yolo,detectron2,mayaku,ml-results
 Classifier: Development Status :: 3 - Alpha
 Classifier: Intended Audience :: Developers
 Classifier: Intended Audience :: Science/Research
@@ -57,7 +57,7 @@ zones = pf.Zones()
 zones.add_zone([(100, 400), (500, 400), (500, 600), (100, 600)], zone_id="entrance")
 
 for frame in video:
-    detections = pf.detections.from_ultralytics(model.predict(frame))
+    detections = pf.from_ultralytics(model.predict(frame))
     detections = tracker.update(detections)
     zones.update(detections)
 
@@ -77,6 +77,12 @@ pip install pixelflow
 
 ## Core Concepts
 
+### Two Result Types
+
+Every model output becomes one of two things. **Detections** for anything that localises — detection, segmentation, keypoints, OCR. **Classifications** for anything that only names.
+
+They are peers, not variants of each other: three detections are three objects, while three classifications are three competing answers about one image.
+
 ### Detections - One Format, Every Framework
 
 Convert outputs from any ML framework into a unified format:
@@ -87,28 +93,80 @@ import pixelflow as pf
 # Ultralytics YOLO
 from ultralytics import YOLO
 model = YOLO("yolo11n.pt")
-detections = pf.detections.from_ultralytics(model.predict(image))
+detections = pf.from_ultralytics(model.predict(image))
 
 # Detectron2
 from detectron2.engine import DefaultPredictor
 predictor = DefaultPredictor(cfg)
-detections = pf.detections.from_detectron2(predictor(image), class_names=["person", "car"])
+detections = pf.from_detectron2(predictor(image), labels=["person", "car"])
+
+# Mayaku (returns Instances directly; take labels from the checkpoint)
+from mayaku import from_pretrained
+predictor = from_pretrained("mayaku-n-det")
+detections = pf.from_mayaku(predictor("photo.jpg"), labels=predictor.class_names)
 
 # HuggingFace Transformers
 from transformers import pipeline
 detector = pipeline("object-detection")
-detections = pf.detections.from_transformers(detector(image))
+detections = pf.from_transformers(detector(image))
 
-# Florence-2
-detections = pf.detections.from_florence2(model_output)
+# Florence-2 - captions and OCR reads land in det.text, <OD> classes in det.class_name
+detections = pf.from_florence2(model_output, task_prompt="<OD>")
 
 # SAM (Segment Anything)
-detections = pf.detections.from_sam(masks, scores)
+detections = pf.from_sam(masks, scores)
+
+# RF-DETR
+detections = pf.from_rfdetr(model_output)
+
+# Supervision
+detections = pf.from_supervision(sv_detections)
+
+# EasyOCR - text lands in det.text, the quad in det.segments
+import easyocr
+reader = easyocr.Reader(['en'])
+detections = pf.from_easyocr(reader.readtext("sign.jpg"))
+
+# Plain arrays (numpy or torch) - no framework container to convert from
+detections = pf.from_arrays(boxes, scores, class_ids, labels=model.class_names)
+```
+
+### Classifications - When the Model Only Names
+
+A classifier localises nothing, so its result carries no geometry at all:
+
+```python
+import pixelflow as pf
+
+# Ultralytics -cls checkpoints
+from ultralytics import YOLO
+model = YOLO("yolo11n-cls.pt")
+result = pf.from_ultralytics_classification(model.predict("dog.jpg"))
+
+result.top1.class_name              # 'golden retriever'
+result.top_k(5)                     # -> Classifications, best first
+result.to_json()
+
+# Plain scores - CLIP zero-shot, a vendored ResNet, anything with a score vector
+prompts = ["a photo of a cat", "a photo of a dog"]
+result = pf.from_scores(similarities, labels=prompts)
 
-# OCR Engines
-detections = pf.detections.from_tesseract(tesseract_output)
-detections = pf.detections.from_paddleocr(paddleocr_output)
-detections = pf.detections.from_easyocr(easyocr_output)
+# Multi-label: however many labels genuinely match, not a fixed count
+matches = result.filter_by_confidence(0.3)
+
+# Draw it
+frame = pf.annotate.classification(frame, result, top_k=3)
+```
+
+Scores are reported exactly as the model emitted them. PixelFlow does not normalise,
+re-softmax, or assume they sum to 1, so a softmax over a fixed class list and an
+independent per-label similarity both survive intact. A model emitting logits should
+be converted by the caller, who is the only one who knows which convention applies.
+
+Per-frame paths can skip building a row per class:
+
+```python
+result = pf.from_ultralytics_classification(model.predict(frame), top_k=5)
 ```
 
 ### Powerful Filtering
@@ -222,7 +280,7 @@ import pixelflow as pf
 tracker = pf.tracker.ByteTracker()
 
 for frame in media.frames:
-    detections = pf.detections.from_ultralytics(model.predict(frame))
+    detections = pf.from_ultralytics(model.predict(frame))
     detections = tracker.update(detections)
 
     for det in detections:
@@ -302,7 +360,7 @@ slicer = pf.SlicedInference(
 )
 
 def detector(image):
-    return pf.detections.from_ultralytics(model.predict(image))
+    return pf.from_ultralytics(model.predict(image))
 
 # Run on 4K image - automatically slices, detects, and merges
 large_image = cv2.imread("satellite.jpg")  # 4000x3000
@@ -325,7 +383,7 @@ crossings.add_line(
 )
 
 for frame in media.frames:
-    detections = tracker.update(pf.detections.from_ultralytics(model.predict(frame)))
+    detections = tracker.update(pf.from_ultralytics(model.predict(frame)))
     crossings.update(detections)
 
     print(f"Crossed: {crossings.get_counts()}")
@@ -352,15 +410,19 @@ report = detections.to_json_with_metrics()
 
 | Framework | Converter | Features |
 |-----------|-----------|----------|
+| None (plain numpy/torch arrays) | `from_arrays()` | Boxes, masks, keypoints |
 | Ultralytics (YOLO) | `from_ultralytics()` | Boxes, masks, keypoints |
 | Detectron2 | `from_detectron2()` | Boxes, masks, keypoints |
+| Mayaku | `from_mayaku()` | Boxes, masks, keypoints |
 | HuggingFace Transformers | `from_transformers()` | Boxes, scores |
-| Florence-2 | `from_florence2()` | Boxes, phrases |
+| Florence-2 | `from_florence2()` | Boxes, quads, polygons, captions |
 | SAM | `from_sam()` | Masks, scores |
-| Tesseract OCR | `from_tesseract()` | Text, boxes, confidence |
-| PaddleOCR | `from_paddleocr()` | Text, boxes, structure |
-| EasyOCR | `from_easyocr()` | Text, boxes |
-| PP-Structure | `from_ppstructure()` | Tables, formulas, layouts |
+| EfficientTAM | `from_efficienttam()` | Masks, scores |
+| RF-DETR | `from_rfdetr()` | Boxes, masks |
+| Supervision | `from_supervision()` | Boxes, masks, keypoints |
+| Falcon Perception | `from_falcon_perception()` | Boxes, masks |
+| EasyOCR | `from_easyocr()` | Quads, text, scores |
+| Datamarkin API | `from_datamarkin()` | Boxes, masks, keypoints |
 
 ## Documentation
 

{pixelflow-0.1.3 → pixelflow-0.3.0}/README.md

@@ -19,7 +19,7 @@ zones = pf.Zones()
 zones.add_zone([(100, 400), (500, 400), (500, 600), (100, 600)], zone_id="entrance")
 
 for frame in video:
-    detections = pf.detections.from_ultralytics(model.predict(frame))
+    detections = pf.from_ultralytics(model.predict(frame))
     detections = tracker.update(detections)
     zones.update(detections)
 
@@ -39,6 +39,12 @@ pip install pixelflow
 
 ## Core Concepts
 
+### Two Result Types
+
+Every model output becomes one of two things. **Detections** for anything that localises — detection, segmentation, keypoints, OCR. **Classifications** for anything that only names.
+
+They are peers, not variants of each other: three detections are three objects, while three classifications are three competing answers about one image.
+
 ### Detections - One Format, Every Framework
 
 Convert outputs from any ML framework into a unified format:
@@ -49,28 +55,80 @@ import pixelflow as pf
 # Ultralytics YOLO
 from ultralytics import YOLO
 model = YOLO("yolo11n.pt")
-detections = pf.detections.from_ultralytics(model.predict(image))
+detections = pf.from_ultralytics(model.predict(image))
 
 # Detectron2
 from detectron2.engine import DefaultPredictor
 predictor = DefaultPredictor(cfg)
-detections = pf.detections.from_detectron2(predictor(image), class_names=["person", "car"])
+detections = pf.from_detectron2(predictor(image), labels=["person", "car"])
+
+# Mayaku (returns Instances directly; take labels from the checkpoint)
+from mayaku import from_pretrained
+predictor = from_pretrained("mayaku-n-det")
+detections = pf.from_mayaku(predictor("photo.jpg"), labels=predictor.class_names)
 
 # HuggingFace Transformers
 from transformers import pipeline
 detector = pipeline("object-detection")
-detections = pf.detections.from_transformers(detector(image))
+detections = pf.from_transformers(detector(image))
 
-# Florence-2
-detections = pf.detections.from_florence2(model_output)
+# Florence-2 - captions and OCR reads land in det.text, <OD> classes in det.class_name
+detections = pf.from_florence2(model_output, task_prompt="<OD>")
 
 # SAM (Segment Anything)
-detections = pf.detections.from_sam(masks, scores)
+detections = pf.from_sam(masks, scores)
+
+# RF-DETR
+detections = pf.from_rfdetr(model_output)
+
+# Supervision
+detections = pf.from_supervision(sv_detections)
+
+# EasyOCR - text lands in det.text, the quad in det.segments
+import easyocr
+reader = easyocr.Reader(['en'])
+detections = pf.from_easyocr(reader.readtext("sign.jpg"))
+
+# Plain arrays (numpy or torch) - no framework container to convert from
+detections = pf.from_arrays(boxes, scores, class_ids, labels=model.class_names)
+```
+
+### Classifications - When the Model Only Names
+
+A classifier localises nothing, so its result carries no geometry at all:
+
+```python
+import pixelflow as pf
+
+# Ultralytics -cls checkpoints
+from ultralytics import YOLO
+model = YOLO("yolo11n-cls.pt")
+result = pf.from_ultralytics_classification(model.predict("dog.jpg"))
+
+result.top1.class_name              # 'golden retriever'
+result.top_k(5)                     # -> Classifications, best first
+result.to_json()
+
+# Plain scores - CLIP zero-shot, a vendored ResNet, anything with a score vector
+prompts = ["a photo of a cat", "a photo of a dog"]
+result = pf.from_scores(similarities, labels=prompts)
 
-# OCR Engines
-detections = pf.detections.from_tesseract(tesseract_output)
-detections = pf.detections.from_paddleocr(paddleocr_output)
-detections = pf.detections.from_easyocr(easyocr_output)
+# Multi-label: however many labels genuinely match, not a fixed count
+matches = result.filter_by_confidence(0.3)
+
+# Draw it
+frame = pf.annotate.classification(frame, result, top_k=3)
+```
+
+Scores are reported exactly as the model emitted them. PixelFlow does not normalise,
+re-softmax, or assume they sum to 1, so a softmax over a fixed class list and an
+independent per-label similarity both survive intact. A model emitting logits should
+be converted by the caller, who is the only one who knows which convention applies.
+
+Per-frame paths can skip building a row per class:
+
+```python
+result = pf.from_ultralytics_classification(model.predict(frame), top_k=5)
 ```
 
 ### Powerful Filtering
@@ -184,7 +242,7 @@ import pixelflow as pf
 tracker = pf.tracker.ByteTracker()
 
 for frame in media.frames:
-    detections = pf.detections.from_ultralytics(model.predict(frame))
+    detections = pf.from_ultralytics(model.predict(frame))
     detections = tracker.update(detections)
 
     for det in detections:
@@ -264,7 +322,7 @@ slicer = pf.SlicedInference(
 )
 
 def detector(image):
-    return pf.detections.from_ultralytics(model.predict(image))
+    return pf.from_ultralytics(model.predict(image))
 
 # Run on 4K image - automatically slices, detects, and merges
 large_image = cv2.imread("satellite.jpg")  # 4000x3000
@@ -287,7 +345,7 @@ crossings.add_line(
 )
 
 for frame in media.frames:
-    detections = tracker.update(pf.detections.from_ultralytics(model.predict(frame)))
+    detections = tracker.update(pf.from_ultralytics(model.predict(frame)))
     crossings.update(detections)
 
     print(f"Crossed: {crossings.get_counts()}")
@@ -314,15 +372,19 @@ report = detections.to_json_with_metrics()
 
 | Framework | Converter | Features |
 |-----------|-----------|----------|
+| None (plain numpy/torch arrays) | `from_arrays()` | Boxes, masks, keypoints |
 | Ultralytics (YOLO) | `from_ultralytics()` | Boxes, masks, keypoints |
 | Detectron2 | `from_detectron2()` | Boxes, masks, keypoints |
+| Mayaku | `from_mayaku()` | Boxes, masks, keypoints |
 | HuggingFace Transformers | `from_transformers()` | Boxes, scores |
-| Florence-2 | `from_florence2()` | Boxes, phrases |
+| Florence-2 | `from_florence2()` | Boxes, quads, polygons, captions |
 | SAM | `from_sam()` | Masks, scores |
-| Tesseract OCR | `from_tesseract()` | Text, boxes, confidence |
-| PaddleOCR | `from_paddleocr()` | Text, boxes, structure |
-| EasyOCR | `from_easyocr()` | Text, boxes |
-| PP-Structure | `from_ppstructure()` | Tables, formulas, layouts |
+| EfficientTAM | `from_efficienttam()` | Masks, scores |
+| RF-DETR | `from_rfdetr()` | Boxes, masks |
+| Supervision | `from_supervision()` | Boxes, masks, keypoints |
+| Falcon Perception | `from_falcon_perception()` | Boxes, masks |
+| EasyOCR | `from_easyocr()` | Quads, text, scores |
+| Datamarkin API | `from_datamarkin()` | Boxes, masks, keypoints |
 
 ## Documentation
 

{pixelflow-0.1.3 → pixelflow-0.3.0}/pixelflow/__init__.py

@@ -1,21 +1,29 @@
-__version__ = "0.1.3"
+__version__ = "0.3.0"
 __author__ = "Datamarkin"
 
 # Import core modules
-from . import detections
-
 from . import media
 from . import annotators as annotate
 from . import transforms as transform
 from . import colors
-# from . import zones
-# from . import crossings
 from . import slicer
 from . import smoother
 from . import timer
 from . import tracker
 from . import assets
-from .classes import COCO_CLASSES
+
+# Result types and their converters. Every model output PixelFlow understands becomes
+# one of two things: Detections for anything that localises, Classifications for
+# anything that only names. They are peers, not variants of each other.
+#
+# Converters are flat -- pf.from_ultralytics(...) -- and each subpackage owns its own
+# export list, so a new one is declared once rather than re-typed here. Detection is
+# the unmarked case because almost every model that produces a container localises
+# something; only classification needs the suffix.
+from .detections import *
+from .detections import __all__ as _DETECTION_EXPORTS
+from .classifications import *
+from .classifications import __all__ as _CLASSIFICATION_EXPORTS
 
 # Import specific functions for top-level access
 from .media import (
@@ -32,8 +40,9 @@ from .timer import TimeTracker
 
 # Define the public API
 __all__ = [
-    # Core data structures
-    "detections",
+    # Result types and converters, declared by the subpackages that own them
+    *_DETECTION_EXPORTS,
+    *_CLASSIFICATION_EXPORTS,
 
     # Visual components
     "annotate",
@@ -76,9 +85,6 @@ __all__ = [
     "TimeTracker",
     "tracker",
 
-    # Constants
-    "COCO_CLASSES",
-
     # Metadata
     "__version__",
     "__author__"

{pixelflow-0.1.3 → pixelflow-0.3.0}/pixelflow/annotators/__init__.py

@@ -12,6 +12,7 @@ allowing easy chaining of annotation operations.
 from .anchors import anchors
 from .blur import blur
 from .box import box
+from .classification import classification
 from .label import label
 from .crossing import crossings
 from .mask import mask
@@ -41,6 +42,7 @@ __all__ = [
     # Core annotators
     'anchors',
     'box',
+    'classification',
     'label',
     'mask',
     'keypoint',

{pixelflow-0.1.3 → pixelflow-0.3.0}/pixelflow/annotators/anchors.py

@@ -71,7 +71,7 @@ def anchors(
         >>> image = cv2.imread("path/to/image.jpg")
         >>> model = YOLO("yolo11n.pt")
         >>> outputs = model.predict(image)
-        >>> detections = pf.results.from_ultralytics(outputs)
+        >>> detections = pf.from_ultralytics(outputs)
         >>> 
         >>> # Draw all main anchor points (default)
         >>> annotated = pf.annotators.anchors(image, detections)

{pixelflow-0.1.3 → pixelflow-0.3.0}/pixelflow/annotators/blur.py

@@ -61,7 +61,7 @@ def blur(
         >>> image = cv2.imread("faces_in_crowd.jpg")
         >>> model = YOLO("yolo11n.pt")
         >>> outputs = model.predict(image)  # Raw model outputs
-        >>> detections = pf.results.from_ultralytics(outputs)  # Convert to PixelFlow format
+        >>> detections = pf.from_ultralytics(outputs)  # Convert to PixelFlow format
         >>> 
         >>> # Apply blur with default adaptive settings
         >>> blurred_image = pf.annotators.blur(image, detections)

{pixelflow-0.1.3 → pixelflow-0.3.0}/pixelflow/annotators/box.py

@@ -48,7 +48,7 @@ def box(
         >>> image = cv2.imread("path/to/image.jpg")
         >>> model = YOLO("yolo11n.pt")
         >>> outputs = model.predict(image)  # Raw model outputs
-        >>> detections = pf.results.from_ultralytics(outputs)  # Convert to PixelFlow format
+        >>> detections = pf.from_ultralytics(outputs)  # Convert to PixelFlow format
         >>>
         >>> # Draw boxes with default colors and adaptive thickness
         >>> annotated = pf.annotators.box(image, detections)

pixelflow-0.3.0/pixelflow/annotators/classification.py

@@ -0,0 +1,122 @@
+from typing import TYPE_CHECKING, Optional, Tuple, Union
+
+if TYPE_CHECKING:
+    from ..classifications import Classifications
+
+import cv2
+import numpy as np
+
+from ..colors import _get_color_for_prediction
+from .utils import _caption_with_score, _get_adaptive_params
+
+
+def classification(image: np.ndarray,
+                   classifications: 'Classifications',
+                   top_k: int = 1,
+                   position: str = 'top_left',
+                   font_scale: Optional[float] = None,
+                   text_color: Union[tuple, str] = (255, 255, 255),
+                   bg_color: Optional[tuple] = None,
+                   padding: Optional[int] = None) -> np.ndarray:
+    """
+    Draw a classification result as a stacked panel in a corner of the image.
+
+    A classification describes the whole image rather than a region of it, so it has
+    nowhere to anchor the way a box label does. The panel goes in a corner and lists
+    the best answers top down, one row per candidate, each row carrying its class
+    colour so several rows stay distinguishable at a glance.
+
+    Args:
+        image (np.ndarray): Image to annotate, modified in place.
+        classifications (Classifications): PixelFlow classifications object.
+        top_k (int): How many candidates to draw, best first. Default is 1.
+        position (str): Corner to draw in. One of 'top_left', 'top_right',
+                       'bottom_left', 'bottom_right'. Default is 'top_left'.
+        font_scale (Optional[float]): Font scale. Computed from image size when None.
+        text_color (Union[tuple, str]): RGB text color. Default is white.
+        bg_color (Optional[tuple]): RGB background for every row. When None each row
+                                   takes the color of its own class.
+        padding (Optional[int]): Padding in pixels inside each row. Computed from image
+                                size when None.
+
+    Returns:
+        np.ndarray: The annotated image.
+
+    Example:
+        >>> import pixelflow as pf
+        >>> from ultralytics import YOLO
+        >>>
+        >>> model = YOLO("yolo11n-cls.pt")
+        >>> result = pf.from_ultralytics_classification(model.predict(image))
+        >>>
+        >>> # Just the answer
+        >>> annotated = pf.annotate.classification(image, result)
+        >>>
+        >>> # Top 3, bottom right
+        >>> annotated = pf.annotate.classification(image, result, top_k=3,
+        ...                                        position='bottom_right')
+
+    Notes:
+        - An empty result returns the image unchanged.
+        - A row with no class_name falls back to its class_id, which is always
+          meaningful even when no vocabulary was supplied.
+        - Rows are ranked by confidence, so the panel reads best-first regardless of
+          the order the converter produced.
+    """
+    rows = classifications.top_k(top_k)
+    if len(rows) == 0:
+        return image
+
+    params = _get_adaptive_params(image)
+    if font_scale is None:
+        font_scale = params['font_scale']
+    if padding is None:
+        padding = params['padding']
+    font = cv2.FONT_HERSHEY_SIMPLEX
+    font_thickness = params['font_thickness']
+
+    # Measure every row first: the panel is one block, so its width is set by the
+    # widest line rather than by each row independently.
+    entries, widths, heights = [], [], []
+    for row in rows:
+        caption = row.class_name or (str(row.class_id) if row.class_id is not None else None)
+        text = _caption_with_score(caption, row.confidence)
+        (width, height), _ = cv2.getTextSize(text, font, font_scale, font_thickness)
+        entries.append((text, row))
+        widths.append(width)
+        heights.append(height)
+
+    # One height for every row. Measuring each row's own baseline left the text
+    # jittering up and down inside a panel whose rows are all the same height.
+    text_height = max(heights)
+    row_height = text_height + 2 * padding
+    panel_width = max(widths) + 2 * padding
+    panel_height = row_height * len(entries)
+
+    image_height, image_width = image.shape[:2]
+    margin = params['margin']
+    x = margin if 'left' in position else image_width - panel_width - margin
+    y = margin if position.startswith('top') else image_height - panel_height - margin
+    x, y = max(0, x), max(0, y)
+
+    for index, (text, row) in enumerate(entries):
+        row_top = y + index * row_height
+        cv2.rectangle(
+            image,
+            (x, row_top),
+            (x + panel_width, row_top + row_height),
+            bg_color if bg_color is not None else _get_color_for_prediction(row),
+            -1
+        )
+        cv2.putText(
+            image,
+            text,
+            (x + padding, row_top + padding + text_height),
+            font,
+            font_scale,
+            text_color,
+            font_thickness,
+            cv2.LINE_AA
+        )
+
+    return image

{pixelflow-0.1.3 → pixelflow-0.3.0}/pixelflow/annotators/crossing.py

@@ -252,7 +252,7 @@ def crossings(image: np.ndarray, crossings_manager) -> np.ndarray:
         >>> tracker = pf.tracker.ByteTracker()
         >>> for frame in frames:
         ...     outputs = yolo_model.predict(frame)
-        ...     results = pf.detections.from_ultralytics(outputs)
+        ...     results = pf.from_ultralytics(outputs)
         ...     results = tracker.update(results)
         ...     results = crossings_manager.update(results)  # Update counts
         ...     annotated = pf.annotate.crossings(frame, crossings_manager)

{pixelflow-0.1.3 → pixelflow-0.3.0}/pixelflow/annotators/filled_box.py

@@ -57,7 +57,7 @@ def filled_box(
         >>> image = cv2.imread("people.jpg")
         >>> model = YOLO("yolo11n.pt")
         >>> outputs = model.predict(image)  # Raw YOLO outputs
-        >>> detections = pf.results.from_ultralytics(outputs)  # Convert to PixelFlow format
+        >>> detections = pf.from_ultralytics(outputs)  # Convert to PixelFlow format
         >>> 
         >>> # Draw filled boxes with automatic opacity (recommended for most cases)
         >>> annotated = pf.annotate.filled_box(image, detections)

{pixelflow-0.1.3 → pixelflow-0.3.0}/pixelflow/annotators/grid_overlay.py

@@ -68,7 +68,7 @@ def grid_overlay(
         >>> image = cv2.imread("path/to/image.jpg")
         >>> model = YOLO("yolo11n.pt")
         >>> outputs = model.predict(image)  # Raw model outputs
-        >>> detections = pf.results.from_ultralytics(outputs)  # Convert to PixelFlow format
+        >>> detections = pf.from_ultralytics(outputs)  # Convert to PixelFlow format
         >>> 
         >>> # Draw grids with automatic sizing based on box dimensions
         >>> annotated = pf.annotate.grid_overlay(image, detections)