pynode-flow 0.2.0__py3-none-any.whl

pynode/nodes/OpenCV/resize_node.py

@@ -0,0 +1,175 @@
+"""
+OpenCV Resize Node - resizes images.
+"""
+
+import cv2
+import numpy as np
+from typing import Any, Dict
+from pynode.nodes.base_node import BaseNode, process_image, Info
+
+_info = Info()
+_info.add_text("Resizes images using various modes and interpolation methods. Supports absolute dimensions, scale factors, and aspect-ratio preserving modes.")
+_info.add_header("Inputs")
+_info.add_bullets(("Input 0:", "Source image"))
+_info.add_header("Outputs")
+_info.add_bullets(("Output 0:", "Resized image"))
+_info.add_header("Modes")
+_info.add_bullets(
+    ("Absolute:", "Resize to exact width and height"),
+    ("Scale:", "Multiply dimensions by scale factor"),
+    ("Fit:", "Fit within bounds, preserve aspect ratio"),
+    ("Fill:", "Fill bounds with cropping, preserve aspect ratio")
+)
+_info.add_header("Interpolation")
+_info.add_bullets(
+    ("Nearest:", "Fast, pixelated (good for pixel art)"),
+    ("Linear:", "Balanced quality and speed"),
+    ("Area:", "Best for shrinking images"),
+    ("Cubic:", "High quality for enlarging"),
+    ("Lanczos:", "Highest quality, slowest")
+)
+
+class ResizeNode(BaseNode):
+    """
+    Resize node - resizes images to specified dimensions or scale.
+    """
+    info = str(_info)
+    display_name = 'Resize'
+    icon = '⤡'
+    category = 'opencv'
+    color = '#4A90D9'
+    border_color = '#2E6BB0'
+    text_color = '#FFFFFF'
+    input_count = 1
+    output_count = 1
+    
+    DEFAULT_CONFIG = {
+        'mode': 'scale',
+        'width': 640,
+        'height': 480,
+        'scale': 0.5,
+        'interpolation': 'linear'
+    }
+    
+    properties = [
+        {
+            'name': 'mode',
+            'label': 'Mode',
+            'type': 'select',
+            'options': [
+                {'value': 'absolute', 'label': 'Absolute size'},
+                {'value': 'scale', 'label': 'Scale factor'},
+                {'value': 'fit', 'label': 'Fit within bounds'},
+                {'value': 'fill', 'label': 'Fill bounds (crop)'}
+            ],
+            'default': DEFAULT_CONFIG['mode'],
+            'help': 'How to determine new size'
+        },
+        {
+            'name': 'width',
+            'label': 'Width',
+            'type': 'number',
+            'default': DEFAULT_CONFIG['width'],
+            'min': 1,
+            'help': 'Target width in pixels',
+            'showIf': {'mode': ['absolute', 'fit', 'fill']}
+        },
+        {
+            'name': 'height',
+            'label': 'Height',
+            'type': 'number',
+            'default': DEFAULT_CONFIG['height'],
+            'min': 1,
+            'help': 'Target height in pixels',
+            'showIf': {'mode': ['absolute', 'fit', 'fill']}
+        },
+        {
+            'name': 'scale',
+            'label': 'Scale Factor',
+            'type': 'number',
+            'default': DEFAULT_CONFIG['scale'],
+            'min': 0.01,
+            'max': 10,
+            'step': 0.1,
+            'help': 'Scale multiplier (1.0 = original size)',
+            'showIf': {'mode': 'scale'}
+        },
+        {
+            'name': 'interpolation',
+            'label': 'Interpolation',
+            'type': 'select',
+            'options': [
+                {'value': 'nearest', 'label': 'Nearest neighbor'},
+                {'value': 'linear', 'label': 'Bilinear'},
+                {'value': 'area', 'label': 'Area (best for shrinking)'},
+                {'value': 'cubic', 'label': 'Bicubic'},
+                {'value': 'lanczos', 'label': 'Lanczos'}
+            ],
+            'default': DEFAULT_CONFIG['interpolation'],
+            'help': 'Interpolation method'
+        }
+    ]
+    
+    def __init__(self, node_id=None, name="resize"):
+        super().__init__(node_id, name)
+    
+    @process_image()
+    def on_input(self, image: np.ndarray, msg: Dict[str, Any], input_index: int = 0):
+        """Resize the input image."""
+        mode = self.config.get('mode', 'scale')
+        target_width = self.get_config_int('width', 640)
+        target_height = self.get_config_int('height', 480)
+        scale = self.get_config_float('scale', 0.5)
+        interp_str = self.config.get('interpolation', 'linear')
+        
+        # Map interpolation string to OpenCV constant
+        interp_map = {
+            'nearest': cv2.INTER_NEAREST,
+            'linear': cv2.INTER_LINEAR,
+            'area': cv2.INTER_AREA,
+            'cubic': cv2.INTER_CUBIC,
+            'lanczos': cv2.INTER_LANCZOS4
+        }
+        interpolation = interp_map.get(interp_str, cv2.INTER_LINEAR)
+        
+        h, w = image.shape[:2]
+        
+        if mode == 'absolute':
+            new_width = target_width
+            new_height = target_height
+        elif mode == 'scale':
+            new_width = int(w * scale)
+            new_height = int(h * scale)
+        elif mode == 'fit':
+            # Fit within bounds while maintaining aspect ratio
+            ratio = min(target_width / w, target_height / h)
+            new_width = int(w * ratio)
+            new_height = int(h * ratio)
+        elif mode == 'fill':
+            # Fill bounds while maintaining aspect ratio (may crop)
+            ratio = max(target_width / w, target_height / h)
+            new_width = int(w * ratio)
+            new_height = int(h * ratio)
+        else:
+            new_width = w
+            new_height = h
+        
+        # Ensure minimum size
+        new_width = max(1, new_width)
+        new_height = max(1, new_height)
+        
+        result = cv2.resize(image, (new_width, new_height), interpolation=interpolation)
+        
+        # For fill mode, crop to target size
+        if mode == 'fill':
+            y_offset = (new_height - target_height) // 2
+            x_offset = (new_width - target_width) // 2
+            result = result[y_offset:y_offset + target_height, 
+                           x_offset:x_offset + target_width]
+        
+        extra_fields = {
+            'original_size': {'width': w, 'height': h},
+            'new_size': {'width': result.shape[1], 'height': result.shape[0]}
+        }
+        
+        return result, extra_fields

pynode/nodes/OpenCV/rotate_node.py

@@ -0,0 +1,159 @@
+"""
+OpenCV Rotate Node - rotates images.
+"""
+
+import cv2
+import numpy as np
+from typing import Any, Dict
+from pynode.nodes.base_node import BaseNode, process_image, Info
+
+_info = Info()
+_info.add_text("Rotates and flips images. Supports preset rotations (90°, 180°), custom angles, and flip operations.")
+_info.add_header("Inputs")
+_info.add_bullets(("Input 0:", "Source image"))
+_info.add_header("Outputs")
+_info.add_bullets(("Output 0:", "Rotated/flipped image"))
+_info.add_header("Modes")
+_info.add_bullets(
+    ("90° CW/CCW:", "Fast 90-degree rotations"),
+    ("180°:", "Rotate upside down"),
+    ("Custom Angle:", "Rotate by any angle in degrees"),
+    ("Flip H/V/Both:", "Mirror image horizontally, vertically, or both")
+)
+_info.add_header("Custom Angle Options")
+_info.add_bullets(
+    ("Expand Canvas:", "Grow canvas to fit rotated image"),
+    ("Fill Color:", "Color for empty areas (B,G,R format)")
+)
+
+class RotateNode(BaseNode):
+    """
+    Rotate node - rotates images by specified angle.
+    """
+    info = str(_info)
+    display_name = 'Rotate'
+    icon = '↻'
+    category = 'opencv'
+    color = '#4A90D9'
+    border_color = '#2E6BB0'
+    text_color = '#FFFFFF'
+    input_count = 1
+    output_count = 1
+    
+    DEFAULT_CONFIG = {
+        'mode': '90cw',
+        'angle': 45,
+        'expand': 'yes',
+        'fill_color': '0,0,0'
+    }
+    
+    properties = [
+        {
+            'name': 'mode',
+            'label': 'Mode',
+            'type': 'select',
+            'options': [
+                {'value': 'angle', 'label': 'Custom angle'},
+                {'value': '90cw', 'label': '90° clockwise'},
+                {'value': '90ccw', 'label': '90° counter-clockwise'},
+                {'value': '180', 'label': '180°'},
+                {'value': 'flip_h', 'label': 'Flip horizontal'},
+                {'value': 'flip_v', 'label': 'Flip vertical'},
+                {'value': 'flip_both', 'label': 'Flip both'}
+            ],
+            'default': DEFAULT_CONFIG['mode'],
+            'help': 'Rotation mode'
+        },
+        {
+            'name': 'angle',
+            'label': 'Angle (degrees)',
+            'type': 'number',
+            'default': DEFAULT_CONFIG['angle'],
+            'min': -360,
+            'max': 360,
+            'help': 'Rotation angle in degrees (positive = counter-clockwise)',
+            'showIf': {'mode': 'angle'}
+        },
+        {
+            'name': 'expand',
+            'label': 'Expand Canvas',
+            'type': 'select',
+            'options': [
+                {'value': 'yes', 'label': 'Yes'},
+                {'value': 'no', 'label': 'No'}
+            ],
+            'default': DEFAULT_CONFIG['expand'],
+            'help': 'Expand canvas to fit rotated image',
+            'showIf': {'mode': 'angle'}
+        },
+        {
+            'name': 'fill_color',
+            'label': 'Fill Color (B,G,R)',
+            'type': 'text',
+            'default': DEFAULT_CONFIG['fill_color'],
+            'help': 'Color to fill empty areas',
+            'showIf': {'mode': 'angle'}
+        }
+    ]
+    
+    def __init__(self, node_id=None, name="rotate"):
+        super().__init__(node_id, name)
+    
+    def _parse_color(self, color_str):
+        """Parse color string to BGR tuple."""
+        try:
+            parts = [int(x.strip()) for x in str(color_str).split(',')]
+            if len(parts) >= 3:
+                return (parts[0], parts[1], parts[2])
+            return (0, 0, 0)
+        except Exception:
+            return (0, 0, 0)
+    
+    @process_image()
+    def on_input(self, image: np.ndarray, msg: Dict[str, Any], input_index: int = 0):
+        """Rotate the input image."""
+        mode = self.config.get('mode', '90cw')
+        
+        if mode == '90cw':
+            result = cv2.rotate(image, cv2.ROTATE_90_CLOCKWISE)
+        elif mode == '90ccw':
+            result = cv2.rotate(image, cv2.ROTATE_90_COUNTERCLOCKWISE)
+        elif mode == '180':
+            result = cv2.rotate(image, cv2.ROTATE_180)
+        elif mode == 'flip_h':
+            result = cv2.flip(image, 1)
+        elif mode == 'flip_v':
+            result = cv2.flip(image, 0)
+        elif mode == 'flip_both':
+            result = cv2.flip(image, -1)
+        elif mode == 'angle':
+            angle = self.get_config_float('angle', 45)
+            expand = self.get_config_bool('expand', True)
+            fill_color = self._parse_color(self.config.get('fill_color', '0,0,0'))
+            
+            h, w = image.shape[:2]
+            center = (w // 2, h // 2)
+            
+            # Get rotation matrix
+            M = cv2.getRotationMatrix2D(center, angle, 1.0)
+            
+            if expand:
+                # Calculate new bounding box size
+                cos = np.abs(M[0, 0])
+                sin = np.abs(M[0, 1])
+                new_w = int(h * sin + w * cos)
+                new_h = int(h * cos + w * sin)
+                
+                # Adjust the rotation matrix
+                M[0, 2] += (new_w - w) / 2
+                M[1, 2] += (new_h - h) / 2
+                
+                result = cv2.warpAffine(image, M, (new_w, new_h), 
+                                        borderValue=fill_color)
+            else:
+                result = cv2.warpAffine(image, M, (w, h), 
+                                        borderValue=fill_color)
+        else:
+            result = image
+        
+        return result

pynode/nodes/OpenCV/template_match_node.py

@@ -0,0 +1,227 @@
+"""
+OpenCV Template Matching Node - finds template in image.
+"""
+
+import cv2
+import numpy as np
+from typing import Any, Dict
+from pynode.nodes.base_node import BaseNode, Info, MessageKeys
+
+_info = Info()
+_info.add_text("Finds occurrences of a template image within a larger image. Useful for object detection, pattern recognition, and image search.")
+_info.add_header("Inputs")
+_info.add_bullets(
+    ("Input 0:", "Source image to search in"),
+    ("Input 1:", "Template image to find")
+)
+_info.add_header("Outputs")
+_info.add_bullets(("Output 0:", "Image with matches drawn (if enabled)"))
+_info.add_header("Properties")
+_info.add_bullets(
+    ("Method:", "Matching algorithm (normalized methods recommended)"),
+    ("Threshold:", "Match confidence threshold (0-1)"),
+    ("Multi Match:", "Find all matches or best only"),
+    ("Draw Matches:", "Draw rectangles around found matches")
+)
+_info.add_header("Message Fields")
+_info.add_bullets(
+    ("matches:", "List of match locations and scores"),
+    ("match_count:", "Number of matches found")
+)
+
+class TemplateMatchNode(BaseNode):
+    """
+    Template Match node - finds occurrences of a template image in the input.
+    """
+    info = str(_info)
+    display_name = 'Template Match'
+    icon = '🔍'
+    category = 'opencv'
+    color = '#4A90D9'
+    border_color = '#2E6BB0'
+    text_color = '#FFFFFF'
+    input_count = 2  # Input 0: image, Input 1: template
+    output_count = 1
+    
+    DEFAULT_CONFIG = {
+        'method': 'ccoeff_normed',
+        'threshold': 0.8,
+        'multi_match': 'no',
+        'draw_matches': 'yes',
+        'match_color': '0,255,0'
+    }
+    
+    properties = [
+        {
+            'name': 'method',
+            'label': 'Method',
+            'type': 'select',
+            'options': [
+                {'value': 'ccoeff_normed', 'label': 'Correlation Coefficient (normalized)'},
+                {'value': 'ccorr_normed', 'label': 'Cross Correlation (normalized)'},
+                {'value': 'sqdiff_normed', 'label': 'Squared Difference (normalized)'},
+                {'value': 'ccoeff', 'label': 'Correlation Coefficient'},
+                {'value': 'ccorr', 'label': 'Cross Correlation'},
+                {'value': 'sqdiff', 'label': 'Squared Difference'}
+            ],
+            'default': DEFAULT_CONFIG['method'],
+            'help': 'Template matching method'
+        },
+        {
+            'name': 'threshold',
+            'label': 'Threshold',
+            'type': 'number',
+            'default': DEFAULT_CONFIG['threshold'],
+            'min': 0,
+            'max': 1,
+            'step': 0.05,
+            'help': 'Match threshold (0-1)'
+        },
+        {
+            'name': 'multi_match',
+            'label': 'Multi Match',
+            'type': 'select',
+            'options': [
+                {'value': 'yes', 'label': 'Yes (find all)'},
+                {'value': 'no', 'label': 'No (best only)'}
+            ],
+            'default': DEFAULT_CONFIG['multi_match'],
+            'help': 'Find multiple matches above threshold'
+        },
+        {
+            'name': 'draw_matches',
+            'label': 'Draw Matches',
+            'type': 'select',
+            'options': [
+                {'value': 'yes', 'label': 'Yes'},
+                {'value': 'no', 'label': 'No'}
+            ],
+            'default': DEFAULT_CONFIG['draw_matches'],
+            'help': 'Draw rectangles around matches'
+        },
+        {
+            'name': 'match_color',
+            'label': 'Match Color (B,G,R)',
+            'type': 'text',
+            'default': DEFAULT_CONFIG['match_color'],
+            'help': 'Color for match rectangles'
+        }
+    ]
+    
+    def __init__(self, node_id=None, name="template match"):
+        super().__init__(node_id, name)
+        self._template = None
+    
+    def _parse_color(self, color_str):
+        """Parse color string to BGR tuple."""
+        try:
+            parts = [int(x.strip()) for x in str(color_str).split(',')]
+            if len(parts) >= 3:
+                return (parts[0], parts[1], parts[2])
+            return (0, 255, 0)
+        except Exception:
+            return (0, 255, 0)
+    
+    def on_input(self, msg: Dict[str, Any], input_index: int = 0):
+        """Process template matching."""
+        if MessageKeys.PAYLOAD not in msg:
+            self.send(msg)
+            return
+        
+        img, format_type = self.decode_image(msg[MessageKeys.PAYLOAD])
+        if img is None:
+            self.send(msg)
+            return
+        
+        # Input 1 is the template
+        if input_index == 1:
+            self._template = img
+            return
+        
+        # Input 0 is the image to search
+        if self._template is None:
+            msg['matches'] = []
+            msg['match_count'] = 0
+            self.send(msg)
+            return
+        
+        method_str = self.config.get('method', 'ccoeff_normed')
+        threshold = self.get_config_float('threshold', 0.8)
+        multi_match = self.get_config_bool('multi_match', False)
+        draw = self.get_config_bool('draw_matches', True)
+        match_color = self._parse_color(self.config.get('match_color', '0,255,0'))
+        
+        # Map method string to OpenCV constant
+        method_map = {
+            'ccoeff_normed': cv2.TM_CCOEFF_NORMED,
+            'ccorr_normed': cv2.TM_CCORR_NORMED,
+            'sqdiff_normed': cv2.TM_SQDIFF_NORMED,
+            'ccoeff': cv2.TM_CCOEFF,
+            'ccorr': cv2.TM_CCORR,
+            'sqdiff': cv2.TM_SQDIFF
+        }
+        method = method_map.get(method_str, cv2.TM_CCOEFF_NORMED)
+        
+        # Perform template matching
+        result = cv2.matchTemplate(img, self._template, method)
+        
+        h, w = self._template.shape[:2]
+        matches = []
+        
+        # For SQDIFF methods, lower is better
+        is_sqdiff = method in [cv2.TM_SQDIFF, cv2.TM_SQDIFF_NORMED]
+        
+        if multi_match:
+            if is_sqdiff:
+                locations = np.where(result <= (1 - threshold))
+            else:
+                locations = np.where(result >= threshold)
+            
+            for pt in zip(*locations[::-1]):
+                score = float(result[pt[1], pt[0]])
+                matches.append({
+                    'x': int(pt[0]),
+                    'y': int(pt[1]),
+                    'width': w,
+                    'height': h,
+                    'score': score if not is_sqdiff else 1 - score
+                })
+        else:
+            min_val, max_val, min_loc, max_loc = cv2.minMaxLoc(result)
+            
+            if is_sqdiff:
+                best_loc = min_loc
+                best_score = 1 - min_val
+            else:
+                best_loc = max_loc
+                best_score = max_val
+            
+            if (is_sqdiff and min_val <= (1 - threshold)) or \
+               (not is_sqdiff and max_val >= threshold):
+                matches.append({
+                    'x': int(best_loc[0]),
+                    'y': int(best_loc[1]),
+                    'width': w,
+                    'height': h,
+                    'score': float(best_score)
+                })
+        
+        # Draw matches if requested
+        if draw and matches:
+            if len(img.shape) == 2:
+                output = cv2.cvtColor(img, cv2.COLOR_GRAY2BGR)
+            else:
+                output = img.copy()
+            
+            for match in matches:
+                pt1 = (match['x'], match['y'])
+                pt2 = (match['x'] + w, match['y'] + h)
+                cv2.rectangle(output, pt1, pt2, match_color, 2)
+            
+            if MessageKeys.PAYLOAD not in msg or not isinstance(msg[MessageKeys.PAYLOAD], dict):
+                msg[MessageKeys.PAYLOAD] = {}
+            msg[MessageKeys.PAYLOAD][MessageKeys.IMAGE.PATH] = self.encode_image(output, format_type)
+        
+        msg['matches'] = matches
+        msg['match_count'] = len(matches)
+        self.send(msg)