pynode-flow 0.2.5__tar.gz → 0.2.6__tar.gz

{pynode_flow-0.2.5 → pynode_flow-0.2.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pynode-flow
-Version: 0.2.5
+Version: 0.2.6
 Summary: Python based Node-RED-like visual workflow system
 Author: olkham
 License-Expression: MIT

{pynode_flow-0.2.5 → pynode_flow-0.2.6}/pynode/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '0.2.5'
-__version_tuple__ = version_tuple = (0, 2, 5)
+__version__ = version = '0.2.6'
+__version_tuple__ = version_tuple = (0, 2, 6)
 
-__commit_id__ = commit_id = 'g5581f8362'
+__commit_id__ = commit_id = 'gfd6285bef'

{pynode_flow-0.2.5 → pynode_flow-0.2.6}/pynode/nodes/SliceNode/slice_collector_node.py

@@ -6,12 +6,20 @@ Designed to work with SliceImageNode in a slice-detect-merge workflow.
 from dataclasses import dataclass
 import time
 from typing import Any, Dict, List, Optional
+import numpy as np
 from pynode.nodes.base_node import BaseNode, Info, MessageKeys
 
+try:
+    import cv2
+    _HAS_CV2 = True
+except ImportError:
+    cv2 = None
+    _HAS_CV2 = False
+
 _info = Info()
 _info.add_text("Collects detection predictions from multiple image slices sent as separate messages, then merges them into a unified result.")
 _info.add_header("Inputs")
-_info.add_bullets(("Input 0:", "Individual slice prediction messages with slice metadata (from split output mode)"))
+_info.add_bullets(("Input 0:", "Slice predictions from SliceImageNode. Auto-detects 'array' mode (all slices in one message) or 'split' mode (separate messages)."))
 _info.add_header("Outputs")
 _info.add_bullets(
     ("Output 0:", "Merged predictions after all slices collected and NMS applied"),
@@ -22,9 +30,11 @@ _info.add_bullets(
     ("NMS IoU Threshold:", "Threshold for Non-Maximum Suppression"),
     ("Match Metric:", "IoU or IoS for duplicate detection matching"),
     ("Class Agnostic NMS:", "Apply NMS across all classes vs per-class"),
+    ("Reconstruct Image from Slices:", "Rebuild the original parent image by stitching the collected tiles back together"),
+    ("Draw Slice Bounds:", "Draw each slice's rectangle on the reconstructed image to visualize tile placement and overlap"),
 )
 _info.add_header("Usage")
-_info.add_text("Designed for workflows: SliceImageNode (split mode) → Inference → SliceCollectorNode")
+_info.add_text("Works with either SliceImageNode output mode. Split: SliceImageNode (split) → Split → Inference → SliceCollectorNode. Array: SliceImageNode (array) → SliceCollectorNode")
 
 @dataclass(frozen=True)
 class NodeKeys:
@@ -45,6 +55,9 @@ class NodeKeys:
     MATCH_METRIC = 'match_metric'
     CLASS_AGNOSTIC = 'class_agnostic'
     TIMEOUT = 'timeout'
+    RECONSTRUCT_IMAGE = 'reconstruct_image'
+    DRAW_SLICE_BOUNDS = 'draw_slice_bounds'
+    SLICE_IMAGE = 'slice_image'
 
 
 class SliceCollectorNode(BaseNode):
@@ -74,6 +87,8 @@ class SliceCollectorNode(BaseNode):
         NodeKeys.NMS_THRESHOLD: 0.5,
         NodeKeys.MATCH_METRIC: 'iou',
         NodeKeys.CLASS_AGNOSTIC: False,
+        NodeKeys.RECONSTRUCT_IMAGE: False,
+        NodeKeys.DRAW_SLICE_BOUNDS: False,
         MessageKeys.DROP_MESSAGES: False
     }
     
@@ -105,6 +120,19 @@ class SliceCollectorNode(BaseNode):
             'label': 'Class Agnostic NMS',
             'type': 'checkbox',
             'default': DEFAULT_CONFIG[NodeKeys.CLASS_AGNOSTIC]
+        },
+        {
+            'name': NodeKeys.RECONSTRUCT_IMAGE,
+            'label': 'Reconstruct Image from Slices',
+            'type': 'checkbox',
+            'default': DEFAULT_CONFIG[NodeKeys.RECONSTRUCT_IMAGE]
+        },
+        {
+            'name': NodeKeys.DRAW_SLICE_BOUNDS,
+            'label': 'Draw Slice Bounds',
+            'type': 'checkbox',
+            'default': DEFAULT_CONFIG[NodeKeys.DRAW_SLICE_BOUNDS],
+            'showIf': {NodeKeys.RECONSTRUCT_IMAGE: True}
         }
     ]
     
@@ -227,11 +255,14 @@ class SliceCollectorNode(BaseNode):
             del self._collections[k]
     
     def _process_collection(self, collection_id: str) -> Optional[Dict]:
-        """Process a complete collection and return merged result."""
+        """Process a complete collection (by id) and return merged result."""
         collection = self._collections.get(collection_id)
         if not collection:
             return None
-        
+        return self._merge_collection(collection)
+    
+    def _merge_collection(self, collection: Dict) -> Optional[Dict]:
+        """Merge all slices in a collection dict and return the merged result."""
         nms_threshold = self.get_config_float(NodeKeys.NMS_THRESHOLD, self.DEFAULT_CONFIG[NodeKeys.NMS_THRESHOLD])
         match_metric = self.config.get(NodeKeys.MATCH_METRIC, self.DEFAULT_CONFIG[NodeKeys.MATCH_METRIC])
         class_agnostic = self.get_config_bool(NodeKeys.CLASS_AGNOSTIC, self.DEFAULT_CONFIG[NodeKeys.CLASS_AGNOSTIC])
@@ -263,7 +294,7 @@ class SliceCollectorNode(BaseNode):
         # Sort by confidence
         final_detections = sorted(final_detections, key=lambda x: x.get(MessageKeys.CV.CONFIDENCE, 0), reverse=True)
         
-        return {
+        result = {
             MessageKeys.CV.DETECTIONS: final_detections,
             MessageKeys.CV.DETECTION_COUNT: len(final_detections),
             NodeKeys.ORIGINAL_WIDTH: collection.get(NodeKeys.ORIGINAL_WIDTH, 0),
@@ -272,12 +303,204 @@ class SliceCollectorNode(BaseNode):
             MessageKeys.CV.BBOX_FORMAT: 'xyxy',
             MessageKeys.IMAGE.PATH: collection.get(MessageKeys.IMAGE.PATH)
         }
+        
+        # Optionally rebuild the parent image from the collected tiles
+        if self.get_config_bool(NodeKeys.RECONSTRUCT_IMAGE, self.DEFAULT_CONFIG[NodeKeys.RECONSTRUCT_IMAGE]):
+            reconstructed = self._reconstruct_image(collection)
+            if reconstructed is not None:
+                result[MessageKeys.IMAGE.PATH] = reconstructed
+        
+        return result
+    
+    def _reconstruct_image(self, collection: Dict) -> Optional[Any]:
+        """
+        Rebuild the original parent image by stitching the collected slice
+        tiles back into a single canvas sized to the original image.
+        
+        Tiles are placed using their slice bbox (or offset). Overlapping
+        regions are overwritten; if a full-image slice is present it is used
+        as the base before overlaying the tiles.
+        """
+        if not _HAS_CV2:
+            self.report_error("OpenCV (cv2) is required to reconstruct the image from slices")
+            return None
+        
+        width = collection.get(NodeKeys.ORIGINAL_WIDTH, 0)
+        height = collection.get(NodeKeys.ORIGINAL_HEIGHT, 0)
+        
+        if width <= 0 or height <= 0:
+            self.report_error("Cannot reconstruct image: unknown original dimensions")
+            return None
+        
+        canvas = None
+        encode_format = None
+        tile_bounds: List[tuple] = []
+        
+        # Place the full image (if any) first, then overlay tiles on top
+        ordered_slices = sorted(
+            collection[NodeKeys.SLICES].values(),
+            key=lambda s: 0 if s.get(NodeKeys.IS_FULL_IMAGE, False) else 1
+        )
+        
+        for slice_data in ordered_slices:
+            img_payload = slice_data.get(NodeKeys.SLICE_IMAGE)
+            if img_payload is None:
+                continue
+            
+            slice_img, fmt = self.decode_image(img_payload)
+            if slice_img is None:
+                continue
+            
+            if encode_format is None:
+                encode_format = fmt
+            
+            if canvas is None:
+                if slice_img.ndim == 3:
+                    canvas = np.zeros((height, width, slice_img.shape[2]), dtype=slice_img.dtype)
+                else:
+                    canvas = np.zeros((height, width), dtype=slice_img.dtype)
+            
+            sh, sw = slice_img.shape[:2]
+            is_full_image = slice_data.get(NodeKeys.IS_FULL_IMAGE, False)
+            
+            if is_full_image:
+                x1, y1 = 0, 0
+            else:
+                bbox = slice_data.get(NodeKeys.SLICE_BBOX)
+                if bbox and len(bbox) >= 4:
+                    x1, y1 = int(bbox[0]), int(bbox[1])
+                else:
+                    offset = slice_data.get(NodeKeys.OFFSET, [0, 0])
+                    x1, y1 = int(offset[0]), int(offset[1])
+            
+            x1 = max(0, min(x1, width))
+            y1 = max(0, min(y1, height))
+            x2 = min(x1 + sw, width)
+            y2 = min(y1 + sh, height)
+            
+            if x2 <= x1 or y2 <= y1:
+                continue
+            
+            canvas[y1:y2, x1:x2] = slice_img[0:(y2 - y1), 0:(x2 - x1)]
+            
+            # Record tile bounds for optional overlay (exclude the full image)
+            if not is_full_image:
+                tile_bounds.append((x1, y1, x2, y2))
+        
+        if canvas is None:
+            return None
+        
+        # Optionally draw the slice bounds so the overlap is visible
+        if self.get_config_bool(NodeKeys.DRAW_SLICE_BOUNDS, self.DEFAULT_CONFIG[NodeKeys.DRAW_SLICE_BOUNDS]):
+            self._draw_slice_bounds(canvas, tile_bounds)
+        
+        return self.encode_image(canvas, encode_format)
+    
+    def _draw_slice_bounds(self, canvas: Any, tile_bounds: List[tuple]):
+        """
+        Draw a rectangle for each slice on the reconstructed canvas so the user
+        can see where each tile sits and how much adjacent tiles overlap.
+        """
+        if not _HAS_CV2 or not tile_bounds:
+            return
+        
+        # Cycle through distinct colors (BGR) so adjacent tiles are easy to tell apart
+        colors = [
+            (0, 255, 0),    # green
+            (0, 0, 255),    # red
+            (255, 0, 0),    # blue
+            (0, 255, 255),  # yellow
+            (255, 0, 255),  # magenta
+            (255, 255, 0),  # cyan
+        ]
+        
+        # Scale line thickness with image size for visibility on large images
+        max_dim = max(canvas.shape[0], canvas.shape[1])
+        thickness = max(1, max_dim // 500)
+        
+        for i, (x1, y1, x2, y2) in enumerate(tile_bounds):
+            color = colors[i % len(colors)]
+            # Inset by half the thickness so edge tiles' borders stay visible
+            cv2.rectangle(  # type: ignore[union-attr]
+                canvas,
+                (int(x1), int(y1)),
+                (int(x2) - 1, int(y2) - 1),
+                color,
+                thickness
+            )
+    
+    def _handle_array(self, msg: Dict[str, Any], slices: List[Any]):
+        """
+        Handle 'array' output mode from SliceImageNode where every slice arrives
+        together in a single message as a list. All slices are available at once,
+        so the collection is built and merged immediately (no buffering/timeout).
+        """
+        collection: Dict[str, Any] = {
+            NodeKeys.SLICES: {},
+            NodeKeys.ORIGINAL_WIDTH: msg.get(NodeKeys.ORIGINAL_WIDTH, 0),
+            NodeKeys.ORIGINAL_HEIGHT: msg.get(NodeKeys.ORIGINAL_HEIGHT, 0),
+            MessageKeys.IMAGE.PATH: None
+        }
+        
+        for i, item in enumerate(slices):
+            if not isinstance(item, dict):
+                continue
+            
+            item_payload = item.get(MessageKeys.PAYLOAD, {})
+            if not isinstance(item_payload, dict):
+                item_payload = {}
+            
+            offset = item.get(NodeKeys.OFFSET, item_payload.get(NodeKeys.OFFSET, [0, 0]))
+            slice_bbox = item.get(NodeKeys.BBOX,
+                                  item.get(NodeKeys.SLICE_BBOX, item_payload.get(NodeKeys.BBOX)))
+            is_full_image = item.get(NodeKeys.IS_FULL_IMAGE, item_payload.get(NodeKeys.IS_FULL_IMAGE, False))
+            slice_index = item.get(NodeKeys.SLICE_INDEX, i)
+            detections = item_payload.get(MessageKeys.CV.DETECTIONS,
+                                          item.get(MessageKeys.CV.DETECTIONS, []))
+            image = item_payload.get(MessageKeys.IMAGE.PATH, item.get(MessageKeys.IMAGE.PATH))
+            
+            ow = item.get(NodeKeys.ORIGINAL_WIDTH, item_payload.get(NodeKeys.ORIGINAL_WIDTH, 0))
+            oh = item.get(NodeKeys.ORIGINAL_HEIGHT, item_payload.get(NodeKeys.ORIGINAL_HEIGHT, 0))
+            if ow > 0:
+                collection[NodeKeys.ORIGINAL_WIDTH] = ow
+            if oh > 0:
+                collection[NodeKeys.ORIGINAL_HEIGHT] = oh
+            
+            collection[NodeKeys.SLICES][slice_index] = {
+                MessageKeys.CV.DETECTIONS: detections,
+                NodeKeys.OFFSET: offset,
+                NodeKeys.SLICE_BBOX: slice_bbox,
+                NodeKeys.SLICE_IMAGE: image,
+                NodeKeys.IS_FULL_IMAGE: is_full_image
+            }
+            
+            if is_full_image and image is not None:
+                collection[MessageKeys.IMAGE.PATH] = image
+        
+        if not collection[NodeKeys.SLICES]:
+            self.report_error("No slices found in array-mode message")
+            return
+        
+        result = self._merge_collection(collection)
+        if result:
+            out_msg = msg.copy()
+            out_msg[MessageKeys.PAYLOAD] = result
+            out_msg[MessageKeys.TOPIC] = msg.get(MessageKeys.TOPIC, 'merged_predictions')
+            out_msg.pop('parts', None)
+            self.send(out_msg)
     
     def on_input(self, msg: Dict[str, Any], input_index: int = 0):
         """
         Collect slice predictions and merge when complete.
         
-        Expected msg format (from Split of SliceImageNode output, processed by YOLO):
+        Works seamlessly with either SliceImageNode output mode:
+        
+        - 'array' mode: all slices arrive together in one message where
+          'payload' is a list of slice dicts. Merged immediately.
+        - 'split' mode: each slice arrives as its own message (buffered by
+          parent id via 'parts', merged once all slices are collected).
+        
+        Expected 'split' msg format (from Split of SliceImageNode, processed by YOLO):
         {
             'payload': {
                 'image': ...,
@@ -299,6 +522,14 @@ class SliceCollectorNode(BaseNode):
         self._cleanup_expired()
         
         payload = msg.get(MessageKeys.PAYLOAD, {})
+        
+        # Auto-detect output mode from SliceImageNode:
+        #   - 'array' mode: payload is a list of all slices in one message
+        #   - 'split' mode: payload is a single slice dict across many messages
+        if isinstance(payload, list):
+            self._handle_array(msg, payload)
+            return
+        
         parts = msg.get('parts', {})
         
         # Get collection ID (from parts or generate one)
@@ -306,9 +537,14 @@ class SliceCollectorNode(BaseNode):
         expected_count = parts.get('count', 1)
         slice_index = parts.get('index', msg.get(NodeKeys.SLICE_INDEX, 0))
         
-        # Get slice metadata (check message level first, then payload)
-        offset = msg.get( NodeKeys.OFFSET, payload.get(NodeKeys.OFFSET, [0, 0]) if isinstance(payload, dict) else [0, 0])
-        slice_bbox = msg.get(NodeKeys.BBOX, payload.get(NodeKeys.BBOX, None) if isinstance(payload, dict) else None)
+        # Get slice metadata (check message level first, then payload).
+        # SliceImageNode emits these at message level as 'slice_offset' / 'slice_bbox'.
+        offset = msg.get(NodeKeys.SLICE_OFFSET,
+                         msg.get(NodeKeys.OFFSET,
+                                 payload.get(NodeKeys.OFFSET, [0, 0]) if isinstance(payload, dict) else [0, 0]))
+        slice_bbox = msg.get(NodeKeys.SLICE_BBOX,
+                             msg.get(NodeKeys.BBOX,
+                                     payload.get(NodeKeys.BBOX, None) if isinstance(payload, dict) else None))
         is_full_image = msg.get(NodeKeys.IS_FULL_IMAGE, payload.get(NodeKeys.IS_FULL_IMAGE, False) if isinstance(payload, dict) else False)
         original_width = msg.get(NodeKeys.ORIGINAL_WIDTH, payload.get(NodeKeys.ORIGINAL_WIDTH, 0) if isinstance(payload, dict) else 0)
         original_height = msg.get(NodeKeys.ORIGINAL_HEIGHT, payload.get(NodeKeys.ORIGINAL_HEIGHT, 0) if isinstance(payload, dict) else 0)
@@ -339,6 +575,8 @@ class SliceCollectorNode(BaseNode):
         collection[NodeKeys.SLICES][slice_index] = {
             MessageKeys.CV.DETECTIONS: detections,
             NodeKeys.OFFSET: offset,
+            NodeKeys.SLICE_BBOX: slice_bbox,
+            NodeKeys.SLICE_IMAGE: image,
             NodeKeys.IS_FULL_IMAGE: is_full_image
         }
         

{pynode_flow-0.2.5 → pynode_flow-0.2.6}/pynode/nodes/SliceNode/slice_image_node.py

@@ -26,7 +26,9 @@ _info.add_header("Configuration")
 _info.add_bullets(
     ("Output Mode:", "Array (all slices in one message) or Split (separate messages)"),
     ("Auto Slice:", "Automatically calculate slice size based on image resolution"),
-    ("Slice Width/Height:", "Manual slice dimensions in pixels"),
+    ("Slice By:", "Tile Size (pixels) or Tile Count (nx, ny)"),
+    ("Slice Width/Height:", "Manual slice dimensions in pixels (Tile Size mode)"),
+    ("Num Slices X/Y:", "Number of columns/rows of tiles (Tile Count mode)"),
     ("Overlap Ratios:", "Overlap between adjacent slices (0-1)"),
     ("Include Full Image:", "Also include the original full image in output"),
 )
@@ -53,6 +55,9 @@ class SliceImageNode(BaseNode):
     DEFAULT_CONFIG = {
         'slice_width': 640,
         'slice_height': 640,
+        'num_slices_x': 2,
+        'num_slices_y': 2,
+        'slice_mode': 'size',
         'overlap_width_ratio': 0.2,
         'overlap_height_ratio': 0.2,
         'auto_slice': False,
@@ -79,19 +84,44 @@ class SliceImageNode(BaseNode):
             'type': 'checkbox',
             'default': False
         },
+        {
+            'name': 'slice_mode',
+            'label': 'Slice By',
+            'type': 'select',
+            'options': [
+                {'value': 'size', 'label': 'Tile Size (pixels)'},
+                {'value': 'count', 'label': 'Tile Count (nx, ny)'}
+            ],
+            'default': 'size',
+            'showIf': {'auto_slice': False}
+        },
         {
             'name': 'slice_width',
             'label': 'Slice Width (pixels)',
             'type': 'number',
             'default': 640,
-            'showIf': {'auto_slice': False}
+            'showIf': {'auto_slice': False, 'slice_mode': 'size'}
         },
         {
             'name': 'slice_height',
             'label': 'Slice Height (pixels)',
             'type': 'number',
             'default': 640,
-            'showIf': {'auto_slice': False}
+            'showIf': {'auto_slice': False, 'slice_mode': 'size'}
+        },
+        {
+            'name': 'num_slices_x',
+            'label': 'Num Slices X (columns)',
+            'type': 'number',
+            'default': 2,
+            'showIf': {'auto_slice': False, 'slice_mode': 'count'}
+        },
+        {
+            'name': 'num_slices_y',
+            'label': 'Num Slices Y (rows)',
+            'type': 'number',
+            'default': 2,
+            'showIf': {'auto_slice': False, 'slice_mode': 'count'}
         },
         {
             'name': 'overlap_width_ratio',
@@ -231,6 +261,65 @@ class SliceImageNode(BaseNode):
         
         return slice_bboxes
     
+    def _get_slice_bboxes_by_count(
+        self,
+        image_height: int,
+        image_width: int,
+        num_slices_x: int,
+        num_slices_y: int,
+        overlap_height_ratio: float,
+        overlap_width_ratio: float
+    ) -> List[List[int]]:
+        """
+        Generate slice bounding boxes for a fixed grid of nx x ny tiles.
+        
+        Tile size is derived from the requested overlap ratio so that adjacent
+        tiles overlap by that fraction, while guaranteeing exactly
+        num_slices_x * num_slices_y tiles that together cover the whole image.
+        
+        Returns list of [x_min, y_min, x_max, y_max] for each slice.
+        """
+        if overlap_height_ratio >= 1.0 or overlap_width_ratio >= 1.0:
+            raise ValueError("Overlap ratio must be less than 1.0")
+        
+        nx = max(1, int(num_slices_x))
+        ny = max(1, int(num_slices_y))
+        
+        x_starts, slice_width = self._axis_starts(image_width, nx, overlap_width_ratio)
+        y_starts, slice_height = self._axis_starts(image_height, ny, overlap_height_ratio)
+        
+        slice_bboxes = []
+        for y_min in y_starts:
+            for x_min in x_starts:
+                slice_bboxes.append([
+                    x_min,
+                    y_min,
+                    min(x_min + slice_width, image_width),
+                    min(y_min + slice_height, image_height)
+                ])
+        
+        return slice_bboxes
+    
+    def _axis_starts(self, length: int, count: int, overlap_ratio: float) -> Tuple[List[int], int]:
+        """
+        Compute evenly spaced tile start positions along one axis.
+        
+        Returns (list of start coordinates, tile size in pixels) for ``count``
+        tiles overlapping by ``overlap_ratio`` that span ``length`` pixels.
+        """
+        if count <= 1:
+            return [0], length
+        
+        # size such that: (count-1) * size * (1 - overlap) + size = length
+        denom = (count - 1) * (1.0 - overlap_ratio) + 1.0
+        slice_size = int(round(length / denom)) if denom > 0 else length
+        slice_size = max(1, min(slice_size, length))
+        
+        last_start = length - slice_size
+        starts = [int(round(i * last_start / (count - 1))) for i in range(count)]
+        
+        return starts, slice_size
+    
     def _slice_image(self, image: np.ndarray) -> List[Dict[str, Any]]:
         """
         Slice the image into tiles based on configuration.
@@ -253,21 +342,41 @@ class SliceImageNode(BaseNode):
                 }]
             overlap_width_ratio = x_overlap / slice_width if slice_width > 0 else 0.2
             overlap_height_ratio = y_overlap / slice_height if slice_height > 0 else 0.2
+            slice_bboxes = self._get_slice_bboxes(
+                image_height=height,
+                image_width=width,
+                slice_height=slice_height,
+                slice_width=slice_width,
+                overlap_height_ratio=overlap_height_ratio,
+                overlap_width_ratio=overlap_width_ratio
+            )
         else:
-            slice_width = self.get_config_int('slice_width', 640)
-            slice_height = self.get_config_int('slice_height', 640)
+            slice_mode = self.config.get('slice_mode', 'size')
             overlap_width_ratio = self.get_config_float('overlap_width_ratio', 0.2)
             overlap_height_ratio = self.get_config_float('overlap_height_ratio', 0.2)
-        
-        # Get slice bounding boxes
-        slice_bboxes = self._get_slice_bboxes(
-            image_height=height,
-            image_width=width,
-            slice_height=slice_height,
-            slice_width=slice_width,
-            overlap_height_ratio=overlap_height_ratio,
-            overlap_width_ratio=overlap_width_ratio
-        )
+            
+            if slice_mode == 'count':
+                num_slices_x = self.get_config_int('num_slices_x', 2)
+                num_slices_y = self.get_config_int('num_slices_y', 2)
+                slice_bboxes = self._get_slice_bboxes_by_count(
+                    image_height=height,
+                    image_width=width,
+                    num_slices_x=num_slices_x,
+                    num_slices_y=num_slices_y,
+                    overlap_height_ratio=overlap_height_ratio,
+                    overlap_width_ratio=overlap_width_ratio
+                )
+            else:
+                slice_width = self.get_config_int('slice_width', 640)
+                slice_height = self.get_config_int('slice_height', 640)
+                slice_bboxes = self._get_slice_bboxes(
+                    image_height=height,
+                    image_width=width,
+                    slice_height=slice_height,
+                    slice_width=slice_width,
+                    overlap_height_ratio=overlap_height_ratio,
+                    overlap_width_ratio=overlap_width_ratio
+                )
         
         slices = []
         for bbox in slice_bboxes:

{pynode_flow-0.2.5 → pynode_flow-0.2.6}/pynode/nodes/VideoReaderNode/video_reader_node.py

@@ -27,7 +27,9 @@ _info.add_bullets(
 _info.add_header("Transport Controls")
 _info.add_bullets(
     ("⏮ Step back:", "Show the previous frame (while paused/stopped)."),
-    ("⏯ Play/Pause:", "Toggle playback from the current position."),
+    ("▶/⏸ Play/Pause:", "Toggle playback from the current position. The icon "
+                        "shows what the next click will do: ▶ while paused/"
+                        "stopped, ⏸ while playing."),
     ("⏹ Stop:", "Halt playback and seek back to the first frame."),
     ("⏭ Step forward:", "Show the next frame (while paused/stopped)."),
     ("Progress bar:", "Drag the slider along the bottom of the node to scrub "
@@ -76,7 +78,11 @@ class VideoReaderNode(BaseNode):
     ui_component_config = {
         'buttons': [
             {'icon': '⏮', 'action': 'step_prev', 'title': 'Step back one frame'},
-            {'icon': '⏯', 'action': 'play_pause', 'title': 'Play / Pause'},
+            # activeIcon/activeTitle are swapped in by the frontend while the
+            # node reports playing=true, so the button always shows the action
+            # the next click will take.
+            {'icon': '▶', 'action': 'play_pause', 'title': 'Play',
+             'activeIcon': '⏸', 'activeTitle': 'Pause'},
             {'icon': '⏹', 'action': 'stop', 'title': 'Stop (back to first frame)'},
             {'icon': '⏭', 'action': 'step_next', 'title': 'Step forward one frame'},
         ],

{pynode_flow-0.2.5 → pynode_flow-0.2.6}/pynode/static/js/debug.js

@@ -89,6 +89,7 @@ export function updateCounterDisplay(nodeId, displayText) {
 export function updateVideoPosition(nodeId, data) {
     const posEl = document.getElementById(`transport-pos-${nodeId}`);
     const sliderEl = document.getElementById(`transport-progress-${nodeId}`);
+    const playBtn = document.getElementById(`transport-btn-${nodeId}-play_pause`);
     const total = data.total > 0 ? data.total : 0;
     const frame = data.frame ?? 0;
     if (posEl) {
@@ -107,6 +108,18 @@ export function updateVideoPosition(nodeId, data) {
         sliderEl.max = total > 0 ? total - 1 : 0;
         sliderEl.value = frame;
     }
+    // Show the action the next click will take: pause while playing, play
+    // while paused/stopped. The icons come from the node's button config
+    // (see the transport-controls branch in nodes.js).
+    if (playBtn && playBtn.dataset.activeIcon) {
+        const playing = !!data.playing;
+        const icon = playing ? playBtn.dataset.activeIcon : playBtn.dataset.idleIcon;
+        const title = playing ? playBtn.dataset.activeTitle : playBtn.dataset.idleTitle;
+        if (playBtn.textContent !== icon) {
+            playBtn.textContent = icon;
+        }
+        playBtn.title = title;
+    }
 }
 
 export function updateImageViewer(nodeId, frameData) {