pynode-flow 0.2.7__tar.gz → 0.2.8__tar.gz

{pynode_flow-0.2.7 → pynode_flow-0.2.8}/Dockerfile

@@ -1,9 +1,11 @@
-FROM docker.io/nvidia/cuda:12.6.0-runtime-ubuntu22.04
+FROM docker.io/nvidia/cuda:12.8.1-runtime-ubuntu22.04
 
 # Set environment variables
 ENV DEBIAN_FRONTEND=noninteractive
 ENV PYTHONUNBUFFERED=1
-ENV CUDA_VERSION=12.6
+# cu128 PyTorch wheels are the first to ship Blackwell (sm_120, e.g. RTX 50xx)
+# kernels; older cu126 builds raise "no kernel image is available".
+ENV CUDA_VERSION=12.8
 
 # Install system dependencies
 RUN apt-get update && apt-get install -y \

{pynode_flow-0.2.7 → pynode_flow-0.2.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pynode-flow
-Version: 0.2.7
+Version: 0.2.8
 Summary: Python based Node-RED-like visual workflow system
 Author: olkham
 License-Expression: MIT
@@ -94,7 +94,7 @@ carries its own documentation in the editor's **Information** panel (ℹ️ tab)
 | **Output** | Image Viewer, Image Writer, Video Writer, Message Writer, Roboflow Upload |
 | **Logic** | Switch (route on conditions), Gate, Sync, Auto Sync |
 | **Network** | MQTT In / Out, UDP In / Out, TCP In / Out, REST Endpoint, Webhook, mDNS Broadcast / Discovery |
-| **Vision** | YOLO, Inference, Crop, Slice Image / Slice Collector, Draw Predictions, Confidence Filter, Label Filter, Merge Predictions, Image Format, Qwen3-VL, vLLM |
+| **Vision** | YOLO, Inference, Crop, Slice Image / Slice Collector, Draw Predictions, Class Map (relabel classes), Confidence Filter, Label Filter, Merge Predictions, Image Format, Qwen3-VL, vLLM |
 | **Supervision** | SV Tracker (ByteTrack), SV Annotate (15 visual styles: boxes, labels, traces, heat maps, privacy blur/pixelate), SV Line Counter (in/out crossing counts + events), SV Polygon Zone (occupancy, enter/exit events) — zone geometry drawn directly on a live frame — SV Smoother (de-jitter boxes), SV Detection Filter (confidence/class/area/aspect/top-K + NMS/NMM), SV Sink (CSV/JSON detection logging) |
 | **Analysis** | BBox Metrics, Polygon Metrics, Point in Shape |
 | **OpenCV** | ~28 image-processing nodes: Blur, Threshold, Morphology, Edge Detector, Find Contours, Perspective, Resize, Rotate, Colormap, Histogram, FFT, Template Match, RealSense Depth, and more |

{pynode_flow-0.2.7 → pynode_flow-0.2.8}/README.md

@@ -29,7 +29,7 @@ carries its own documentation in the editor's **Information** panel (ℹ️ tab)
 | **Output** | Image Viewer, Image Writer, Video Writer, Message Writer, Roboflow Upload |
 | **Logic** | Switch (route on conditions), Gate, Sync, Auto Sync |
 | **Network** | MQTT In / Out, UDP In / Out, TCP In / Out, REST Endpoint, Webhook, mDNS Broadcast / Discovery |
-| **Vision** | YOLO, Inference, Crop, Slice Image / Slice Collector, Draw Predictions, Confidence Filter, Label Filter, Merge Predictions, Image Format, Qwen3-VL, vLLM |
+| **Vision** | YOLO, Inference, Crop, Slice Image / Slice Collector, Draw Predictions, Class Map (relabel classes), Confidence Filter, Label Filter, Merge Predictions, Image Format, Qwen3-VL, vLLM |
 | **Supervision** | SV Tracker (ByteTrack), SV Annotate (15 visual styles: boxes, labels, traces, heat maps, privacy blur/pixelate), SV Line Counter (in/out crossing counts + events), SV Polygon Zone (occupancy, enter/exit events) — zone geometry drawn directly on a live frame — SV Smoother (de-jitter boxes), SV Detection Filter (confidence/class/area/aspect/top-K + NMS/NMM), SV Sink (CSV/JSON detection logging) |
 | **Analysis** | BBox Metrics, Polygon Metrics, Point in Shape |
 | **OpenCV** | ~28 image-processing nodes: Blur, Threshold, Morphology, Edge Detector, Find Contours, Perspective, Resize, Rotate, Colormap, Histogram, FFT, Template Match, RealSense Depth, and more |

{pynode_flow-0.2.7 → pynode_flow-0.2.8}/pynode/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '0.2.7'
-__version_tuple__ = version_tuple = (0, 2, 7)
+__version__ = version = '0.2.8'
+__version_tuple__ = version_tuple = (0, 2, 8)
 
-__commit_id__ = commit_id = 'g6f8c52570'
+__commit_id__ = commit_id = 'g7b8eff347'

{pynode_flow-0.2.7 → pynode_flow-0.2.8}/pynode/nodes/ChangeNode/change_node.py

@@ -5,7 +5,7 @@ Similar to Node-RED's change node.
 
 import json
 import re
-from typing import Any, Dict
+from typing import Any, Dict, List, Optional, Tuple
 from pynode.nodes.base_node import BaseNode, Info, MessageKeys
 
 _info = Info()
@@ -25,6 +25,18 @@ _info.add_bullets(
     ("Delete:", "Remove a property from the message."),
     ("Move:", "Move a property to a different location."),
 )
+_info.add_header("Lists")
+_info.add_text(
+    "Tick 'is list' on a rule when the property holds a list of objects, and "
+    "give the key to work on. The rule then applies to that key in every item, "
+    "however many there are - for example relabelling each detection:"
+)
+_info.add_code("in msg.payload.detections - is list, key class_name - search 2, replace drone").end()
+_info.add_text(
+    "Search-and-replace works on substrings of text values. A value that is "
+    "not text (a number, a boolean) is replaced only when the search matches "
+    "the whole value, and the replacement keeps the type you selected."
+)
 
 
 class ChangeNode(BaseNode):
@@ -52,6 +64,9 @@ class ChangeNode(BaseNode):
     ui_component = 'change-rules-editor'
     ui_component_config = {
         'operations': ['set', 'change', 'move', 'delete'],
+        # Per-rule list mode: apply the rule to `key` inside every item of the
+        # list at the rule's path (see _rule_targets).
+        'list_fields': ['isList', 'key'],
         'value_types': [
             {'value': 'str', 'label': 'String'},
             {'value': 'num', 'label': 'Number'},
@@ -131,6 +146,87 @@ class ChangeNode(BaseNode):
         
         return False
     
+    def _rule_targets(self, msg: Dict, rule: Dict, path: str) -> List[Tuple[Optional[Dict], str]]:
+        """Work out the places a rule applies to.
+
+        Normally that is one place: the property path itself. With ``isList``
+        set, the path must hold a list, and the rule applies to ``key`` inside
+        every object in it - the way to rewrite a field on all detections
+        without knowing how many there are.
+
+        Args:
+            msg: The message being modified.
+            rule: The rule definition.
+            path: The rule's property path.
+
+        Returns:
+            ``(container, key)`` pairs. ``container`` is None for a plain
+            property path, in which case ``key`` is that path.
+        """
+        if not rule.get('isList', rule.get('is_list', False)):
+            return [(None, path)]
+
+        key = str(rule.get('key', rule.get('itemKey', '')) or '').strip()
+        if not key:
+            self.report_error(f"List rule on {path} needs an item key")
+            return []
+
+        items = self._get_nested_value(msg, path)
+        if not isinstance(items, (list, tuple)):
+            self.report_error(f"List rule on {path}: not a list")
+            return []
+
+        return [(item, key) for item in items if isinstance(item, dict)]
+
+    def _target_get(self, msg: Dict, target: Tuple[Optional[Dict], str]) -> Any:
+        """Read a target - a message path, or a key inside a list item."""
+        container, key = target
+        if container is None:
+            return self._get_nested_value(msg, key)
+        return container.get(key)
+
+    def _target_set(self, msg: Dict, target: Tuple[Optional[Dict], str], value: Any) -> None:
+        """Write a target."""
+        container, key = target
+        if container is None:
+            self._set_nested_value(msg, key, value)
+        else:
+            container[key] = value
+
+    def _target_delete(self, msg: Dict, target: Tuple[Optional[Dict], str]) -> bool:
+        """Remove a target, reporting whether anything was there."""
+        container, key = target
+        if container is None:
+            return self._delete_nested_value(msg, key)
+        if key in container:
+            del container[key]
+            return True
+        return False
+
+    def _apply_change(self, msg: Dict, target: Tuple[Optional[Dict], str],
+                      search: Any, search_type: str,
+                      replacement_text: str, replacement_value: Any) -> None:
+        """Search and replace inside one target.
+
+        Text is replaced by substring (or regex). Anything else - a number, a
+        boolean - has no substring to work on, so it is replaced only when the
+        search matches the whole value, and it takes the typed replacement.
+        """
+        current = self._target_get(msg, target)
+        if current is None:
+            return
+
+        if isinstance(current, str):
+            if search_type == 'regex':
+                try:
+                    self._target_set(msg, target, re.sub(str(search), replacement_text, current))
+                except re.error:
+                    self.report_error(f"Invalid regex pattern: {search}")
+            else:
+                self._target_set(msg, target, current.replace(str(search), replacement_text))
+        elif not isinstance(current, (dict, list, tuple)) and str(current) == str(search):
+            self._target_set(msg, target, replacement_value)
+
     def _resolve_value(self, msg: Dict, value: Any, value_type: str) -> Any:
         """
         Resolve a value based on its type.
@@ -189,6 +285,11 @@ class ChangeNode(BaseNode):
             property_path = rule.get('path', rule.get('p', rule.get('property', f'msg.{MessageKeys.PAYLOAD}')))
             
             try:
+                # One target for a plain path; one per list item in list mode.
+                targets = self._rule_targets(msg, rule, property_path)
+                if not targets:
+                    continue
+
                 if rule_type == 'set':
                     # Set property to a value
                     value = rule.get('value', rule.get('to', ''))
@@ -206,7 +307,8 @@ class ChangeNode(BaseNode):
                     else:
                         resolved_value = self._resolve_value(msg, value, value_type)
                     
-                    self._set_nested_value(msg, property_path, resolved_value)
+                    for target in targets:
+                        self._target_set(msg, target, resolved_value)
                     
                 elif rule_type == 'change':
                     # Search and replace within a property
@@ -215,39 +317,36 @@ class ChangeNode(BaseNode):
                     replace = rule.get('replace', rule.get('to', ''))
                     replace_type = rule.get('replaceType', rule.get('tot', 'str'))
                     
-                    current_value = self._get_nested_value(msg, property_path)
-                    
-                    # Resolve replace value
+                    # Resolve the replacement twice over: the text form drives
+                    # substring and regex replacement, the typed form replaces a
+                    # whole non-text value (see _apply_change).
                     if replace_type == 'path':
-                        replace_value = self._get_nested_value(msg, 'msg.' + str(replace) if not str(replace).startswith('msg.') else replace)
+                        replacement_value = self._get_nested_value(msg, 'msg.' + str(replace) if not str(replace).startswith('msg.') else replace)
                     else:
-                        replace_value = str(replace)
+                        replacement_value = self._resolve_value(msg, replace, replace_type)
+                    replacement_text = str(replacement_value) if replacement_value is not None else ''
                     
-                    if current_value is not None:
-                        if isinstance(current_value, str):
-                            if search_type == 'regex':
-                                try:
-                                    new_value = re.sub(search, str(replace_value) if replace_value else '', current_value)
-                                    self._set_nested_value(msg, property_path, new_value)
-                                except re.error as e:
-                                    self.report_error(f"Invalid regex pattern: {search}")
-                            else:
-                                new_value = current_value.replace(str(search), str(replace_value) if replace_value else '')
-                                self._set_nested_value(msg, property_path, new_value)
+                    for target in targets:
+                        self._apply_change(msg, target, search, search_type,
+                                           replacement_text, replacement_value)
                     
                 elif rule_type == 'delete':
                     # Delete a property
-                    self._delete_nested_value(msg, property_path)
+                    for target in targets:
+                        self._target_delete(msg, target)
                     
                 elif rule_type == 'move':
-                    # Move property to another location
+                    # Move property to another location. In list mode the
+                    # destination is a key inside the same item.
                     to_path = rule.get('toPath', rule.get('to', rule.get('toProperty', '')))
                     
                     if to_path:
-                        current_value = self._get_nested_value(msg, property_path)
-                        if current_value is not None:
-                            self._set_nested_value(msg, to_path, current_value)
-                            self._delete_nested_value(msg, property_path)
+                        for target in targets:
+                            container, _ = target
+                            current_value = self._target_get(msg, target)
+                            if current_value is not None:
+                                self._target_set(msg, (container, to_path), current_value)
+                                self._target_delete(msg, target)
                             
             except Exception as e:
                 self.report_error(f"Error applying rule {rule_type} on {property_path}: {str(e)}")

pynode_flow-0.2.8/pynode/nodes/ClassMapNode/__init__.py

@@ -0,0 +1,3 @@
+from ..ClassMapNode.class_map_node import ClassMapNode
+
+__all__ = ['ClassMapNode']

pynode_flow-0.2.8/pynode/nodes/ClassMapNode/class_map_node.py

@@ -0,0 +1,329 @@
+"""
+Class Map Node - relabels detections by class id or class name.
+
+A model reports whatever it was trained with, and often not much: an ONNX model
+carries no label file, so its detections arrive as ``class_id: 2`` /
+``class_name: "2"``. This node applies a mapping of your own - ``2 = drone`` -
+to every detection in the list, leaving boxes, scores and every other field
+untouched.
+"""
+
+import json
+import logging
+import re
+from typing import Any, Dict, List, Optional, Tuple
+
+from pynode.nodes.base_node import BaseNode, Info, MessageKeys
+
+logger = logging.getLogger(__name__)
+
+_info = Info()
+_info.add_text(
+    "Renames detection classes. Give it a mapping from class id (or existing "
+    "class name) to the label you want, and every detection in the list is "
+    "relabelled - useful for models that report bare numeric classes."
+)
+_info.add_header("Inputs")
+_info.add_bullets(
+    ("Input 0:", "Message with a detections list (e.g. from Inference or a tracker)"),
+)
+_info.add_header("Outputs")
+_info.add_bullets(
+    ("Output 0:", "The same message with class_name rewritten on each detection"),
+)
+_info.add_header("Mapping")
+_info.add_text("One entry per line, key first:")
+_info.add_code("2 = drone").text(
+    "- a colon, arrow or comma works as the separator too, quotes are "
+    "optional, and lines starting with # are ignored."
+).end()
+_info.add_code('{"1": "bird", "2": "drone"}').text("A JSON object works too.").end()
+_info.add_header("Options")
+_info.add_bullets(
+    ("Match On:", "Look the key up against the class id, the class name, or either"),
+    ("Unmatched:", "Leave a detection's label alone, replace it with a fallback, or drop it"),
+    ("Detections Path:", "Where the list lives (payload.detections, payload.tracks, ...)"),
+)
+
+# Key/value separators accepted in the line form, longest first so that '->'
+# is not read as '-' followed by '>'.
+_ENTRY_SEPARATOR = re.compile(r'\s*(?:=>|->|=|:|\t|,)\s*')
+
+
+def _unquote(text: str) -> str:
+    """Strip surrounding whitespace and one layer of matching quotes."""
+    text = text.strip()
+    if len(text) >= 2 and text[0] == text[-1] and text[0] in ('"', "'"):
+        text = text[1:-1]
+    return text.strip()
+
+
+def parse_class_map(raw: Any) -> Tuple[Dict[str, str], List[str]]:
+    """Parse the mapping config into ``{key: label}``.
+
+    Accepts a dict (already parsed by the UI), a JSON object, or one entry per
+    line in any of the ``2 = drone`` / ``2: drone`` / ``2 -> drone`` /
+    ``2, drone`` spellings.
+
+    Args:
+        raw: The raw config value.
+
+    Returns:
+        ``(mapping, problems)`` - ``problems`` lists the lines that could not
+        be read, so the caller can report them once instead of per frame.
+    """
+    if isinstance(raw, dict):
+        return {str(k).strip(): str(v) for k, v in raw.items()}, []
+
+    text = str(raw or '').strip()
+    if not text:
+        return {}, []
+
+    if text.startswith('{'):
+        try:
+            data = json.loads(text)
+        except json.JSONDecodeError as e:
+            return {}, [f"invalid JSON ({e.msg} at line {e.lineno})"]
+        if isinstance(data, dict):
+            return {str(k).strip(): str(v) for k, v in data.items()}, []
+        return {}, ["JSON mapping must be an object"]
+
+    mapping: Dict[str, str] = {}
+    problems: List[str] = []
+
+    for line in text.splitlines():
+        line = line.strip()
+        if not line or line.startswith('#'):
+            continue
+
+        parts = _ENTRY_SEPARATOR.split(line, maxsplit=1)
+        if len(parts) != 2:
+            problems.append(line)
+            continue
+
+        key, value = _unquote(parts[0]), _unquote(parts[1])
+        if not key or not value:
+            problems.append(line)
+            continue
+
+        mapping[key] = value
+
+    return mapping, problems
+
+
+class ClassMapNode(BaseNode):
+    """Rewrites ``class_name`` on every detection from a user-supplied map."""
+
+    display_name = 'Class Map'
+    info = str(_info)
+    icon = '🔤'
+    category = 'vision'
+    color = '#C7E9C0'
+    border_color = '#74C476'
+    text_color = '#000000'
+    input_count = 1
+    output_count = 1
+
+    DEFAULT_CONFIG = {
+        'mapping': '',
+        'match_on': 'either',
+        'unmatched': 'keep',
+        'unmatched_label': 'unknown',
+        'detections_path': 'payload.detections',
+    }
+
+    properties = [
+        {
+            'name': 'mapping',
+            'label': 'Class Mapping',
+            'type': 'textarea',
+            'default': DEFAULT_CONFIG['mapping'],
+            'placeholder': '2 = drone\n1 = bird',
+            'help': 'One "id = label" per line, or a JSON object. Lines starting with # are ignored.'
+        },
+        {
+            'name': 'match_on',
+            'label': 'Match On',
+            'type': 'select',
+            'options': [
+                {'value': 'either', 'label': 'Class ID, then class name'},
+                {'value': 'class_id', 'label': 'Class ID only'},
+                {'value': 'class_name', 'label': 'Class name only'},
+            ],
+            'default': DEFAULT_CONFIG['match_on'],
+            'help': 'What the mapping keys are matched against. Name matching ignores case.'
+        },
+        {
+            'name': 'unmatched',
+            'label': 'Unmatched Detections',
+            'type': 'select',
+            'options': [
+                {'value': 'keep', 'label': 'Keep their current label'},
+                {'value': 'label', 'label': 'Relabel with a fallback'},
+                {'value': 'drop', 'label': 'Drop the detection'},
+            ],
+            'default': DEFAULT_CONFIG['unmatched'],
+            'help': 'What to do with a detection whose class is not in the mapping'
+        },
+        {
+            'name': 'unmatched_label',
+            'label': 'Fallback Label',
+            'type': 'text',
+            'default': DEFAULT_CONFIG['unmatched_label'],
+            'showIf': {'unmatched': 'label'},
+            'help': 'Label given to detections that the mapping does not cover'
+        },
+        {
+            'name': 'detections_path',
+            'label': 'Detections Path',
+            'type': 'text',
+            'default': DEFAULT_CONFIG['detections_path'],
+            'help': f'Path to the detections list (e.g. "{DEFAULT_CONFIG["detections_path"]}")'
+        },
+    ]
+
+    def __init__(self, node_id=None, name="class map"):
+        super().__init__(node_id, name)
+        # Parsing is cached against the raw config value: the map is re-read
+        # when the user edits it, not once per frame.
+        self._cached_raw: Any = None
+        self._cached_map: Dict[str, str] = {}
+        self._cached_lower: Dict[str, str] = {}
+
+    def _mapping(self) -> Tuple[Dict[str, str], Dict[str, str]]:
+        """Return ``(mapping, lowercased mapping)``, re-parsing only on change."""
+        raw = self.config.get('mapping', self.DEFAULT_CONFIG['mapping'])
+
+        if raw != self._cached_raw or (raw and not self._cached_map):
+            mapping, problems = parse_class_map(raw)
+            self._cached_raw = raw
+            self._cached_map = mapping
+            self._cached_lower = {k.lower(): v for k, v in mapping.items()}
+            if problems:
+                self.report_error(
+                    "Could not read class mapping entries: " + '; '.join(problems)
+                )
+
+        return self._cached_map, self._cached_lower
+
+    def _lookup(self, det: Dict[str, Any], mapping: Dict[str, str],
+                lower: Dict[str, str], match_on: str) -> Optional[str]:
+        """Find the mapped label for one detection, or None when unmapped."""
+        if match_on in ('class_id', 'either'):
+            class_id = det.get(MessageKeys.CV.CLASS_ID)
+            if class_id is not None:
+                label = mapping.get(str(class_id).strip())
+                if label is not None:
+                    return label
+
+        if match_on in ('class_name', 'either'):
+            class_name = det.get(MessageKeys.CV.CLASS_NAME)
+            if class_name is not None:
+                label = lower.get(str(class_name).strip().lower())
+                if label is not None:
+                    return label
+
+        return None
+
+    def _sync_supervision(self, payload: Dict[str, Any],
+                          detections: List[Any], kept: List[bool]) -> None:
+        """Mirror the new labels onto a live ``sv.Detections`` in the payload.
+
+        Supervision nodes prefer ``payload['sv']`` over the dict list, so an
+        annotator downstream would otherwise keep drawing the old names.
+        """
+        sv_detections = payload.get('sv')
+        if sv_detections is None or not hasattr(sv_detections, 'xyxy'):
+            return
+
+        try:
+            import numpy as np
+
+            if len(kept) != len(sv_detections):
+                # The list came from somewhere else; leave sv alone rather than
+                # pairing labels with the wrong boxes.
+                return
+
+            if not all(kept):
+                sv_detections = sv_detections[np.array(kept, dtype=bool)]
+                payload['sv'] = sv_detections
+
+            names = [
+                str(det.get(MessageKeys.CV.CLASS_NAME, ''))
+                for det in detections if isinstance(det, dict)
+            ]
+            if len(names) == len(sv_detections) and isinstance(sv_detections.data, dict):
+                sv_detections.data['class_name'] = np.array(names)
+
+        except Exception as e:
+            logger.debug(f"Could not sync class names onto payload['sv']: {e}")
+
+    def on_input(self, msg: Dict[str, Any], input_index: int = 0):
+        """Relabel every detection at the configured path."""
+        mapping, lower = self._mapping()
+        unmatched = self.config.get('unmatched', self.DEFAULT_CONFIG['unmatched'])
+
+        if not mapping and unmatched != 'drop':
+            # Nothing configured yet - a pass-through beats an error on a node
+            # the user has only just dropped onto the canvas.
+            self.send(msg)
+            return
+
+        path = self.config.get('detections_path', self.DEFAULT_CONFIG['detections_path'])
+        detections = self._get_nested_value(msg, path)
+        if not isinstance(detections, (list, tuple)):
+            self.send(msg)
+            return
+
+        match_on = self.config.get('match_on', self.DEFAULT_CONFIG['match_on'])
+        fallback = self.config.get('unmatched_label', self.DEFAULT_CONFIG['unmatched_label'])
+
+        out: List[Any] = []
+        kept: List[bool] = []
+        changed = False
+
+        for det in detections:
+            if not isinstance(det, dict):
+                out.append(det)
+                kept.append(True)
+                continue
+
+            label = self._lookup(det, mapping, lower, match_on)
+
+            if label is None:
+                if unmatched == 'drop':
+                    kept.append(False)
+                    changed = True
+                    continue
+                if unmatched == 'label':
+                    label = fallback
+                else:
+                    out.append(det)
+                    kept.append(True)
+                    continue
+
+            if det.get(MessageKeys.CV.CLASS_NAME) != label:
+                # Copy rather than mutate: the same detection dict may still be
+                # referenced by a message that branched upstream of this node.
+                det = dict(det)
+                det[MessageKeys.CV.CLASS_NAME] = label
+                changed = True
+
+            out.append(det)
+            kept.append(True)
+
+        if not changed:
+            self.send(msg)
+            return
+
+        self._set_nested_value(msg, path, out)
+
+        payload = msg.get(MessageKeys.PAYLOAD)
+        if isinstance(payload, dict):
+            # Only when the list we just wrote IS the payload's detections -
+            # a node pointed at payload.tracks must not touch detection_count.
+            if payload.get(MessageKeys.CV.DETECTIONS) is out:
+                payload[MessageKeys.CV.DETECTION_COUNT] = len(out)
+            self._sync_supervision(payload, out, kept)
+
+        self.send(msg)

{pynode_flow-0.2.7 → pynode_flow-0.2.8}/pynode/nodes/DrawPredictionsNode/draw_predictions_node.py

@@ -9,6 +9,7 @@ import logging
 import numpy as np
 from typing import Any, Dict, Optional
 from pynode.nodes.base_node import BaseNode, Info, MessageKeys
+from pynode.nodes.detection_utils import CANONICAL_BBOX_FORMAT, normalized_detection
 
 logger = logging.getLogger(__name__)
 
@@ -18,6 +19,11 @@ _info.add_header("Inputs")
 _info.add_bullets(
     ("Input 0:", "Message with payload.predictions (from YOLO or Inference) and payload.image (base64)"),
 )
+_info.add_text(
+    "Boxes are read in whatever format the producer labelled them with "
+    "(payload.bbox_format, or bbox_format on the detection itself) and "
+    "converted to xyxy before drawing."
+)
 _info.add_header("Outputs")
 _info.add_bullets(
     ("Output 0:", "Annotated image with bounding boxes and labels drawn"),
@@ -264,16 +270,21 @@ class DrawPredictionsNode(BaseNode):
         show_confidence = self.get_config_bool('show_confidence', True)
         show_class = self.get_config_bool('show_class', True)
 
+        # Producers label their boxes differently (Ultralytics emits xyxy, the
+        # ONNX engine centre-based boxes under top_class/top_score), so take the
+        # payload-level format as the default and let each detection override it.
+        default_bbox_format = CANONICAL_BBOX_FORMAT
+        if isinstance(payload, dict):
+            default_bbox_format = payload.get(MessageKeys.CV.BBOX_FORMAT) or CANONICAL_BBOX_FORMAT
+
         # Draw each detection/track
         for i, det in enumerate(detections):
             try:
-                bbox = det.get('bbox', [0, 0, 0, 0])
-                if isinstance(bbox, np.ndarray):
-                    bbox = bbox.tolist()
-                x1, y1, x2, y2 = bbox
-                class_id = det.get('class_id', 0)
-                class_name = det.get('class_name', 'unknown')
-                confidence = det.get('confidence', 0.0)
+                det = normalized_detection(det, default_bbox_format)
+                x1, y1, x2, y2 = det['bbox'] if det.get('bbox') is not None else (0, 0, 0, 0)
+                class_id = det['class_id']
+                class_name = det['class_name']
+                confidence = det['confidence']
                 track_id = det.get('track_id', None)
 
                 x1, y1, x2, y2 = int(x1), int(y1), int(x2), int(y2)