pynode-flow 0.2.0__py3-none-any.whl

pynode/nodes/OpenCV/hough_circles_node.py

@@ -0,0 +1,224 @@
+"""
+OpenCV Hough Circles Node - detects circles in images.
+"""
+
+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("Detects circles in images using the Hough Circle Transform. Applies median blur internally to reduce noise.")
+_info.add_header("Inputs")
+_info.add_bullets(("Input 0:", "Image (color or grayscale)"))
+_info.add_header("Outputs")
+_info.add_bullets(
+    ("Output 0:", "Image with circles drawn (if enabled)"),
+    ("msg.circles:", "Array of detected circles with normalized x, y, radius (0.0-1.0)")
+)
+_info.add_header("Normalized Output")
+_info.add_text("Circle positions and radii are normalized (0.0-1.0) for resolution independence.")
+_info.add_header("Key Parameters")
+_info.add_bullets(
+    ("DP:", "Accumulator resolution ratio (1 = same as image, 2 = half)"),
+    ("Min Distance:", "Minimum distance between circle centers (normalized 0.0-1.0)"),
+    ("Canny Threshold:", "Higher threshold for internal Canny edge detection"),
+    ("Accumulator Threshold:", "Lower = more circles detected (may include false positives)"),
+    ("Min/Max Radius:", "Circle radius constraints (normalized 0.0-1.0, relative to image width)")
+)
+_info.add_header("Tips")
+_info.add_bullets(
+    ("No circles found?", "Try lowering Accumulator Threshold"),
+    ("Too many false positives?", "Increase Accumulator Threshold or Min Distance")
+)
+
+
+class HoughCirclesNode(BaseNode):
+    info = str(_info)
+    """
+    Hough Circles node - detects circles in images using Hough transform.
+    """
+    display_name = 'Hough Circles'
+    icon = '◯'
+    category = 'opencv'
+    color = '#4A90D9'
+    border_color = '#2E6BB0'
+    text_color = '#FFFFFF'
+    input_count = 1
+    output_count = 1
+    
+    DEFAULT_CONFIG = {
+        'dp': 1.2,
+        'min_dist': 0.1,
+        'param1': 100,
+        'param2': 30,
+        'min_radius': 0.02,
+        'max_radius': 0.0,
+        'draw_circles': 'yes',
+        'circle_color': '0,255,0'
+    }
+    
+    properties = [
+        {
+            'name': 'dp',
+            'label': 'DP (resolution ratio)',
+            'type': 'number',
+            'default': DEFAULT_CONFIG['dp'],
+            'min': 1,
+            'step': 0.1,
+            'help': 'Inverse ratio of accumulator resolution (1 = same as image)'
+        },
+        {
+            'name': 'min_dist',
+            'label': 'Min Distance',
+            'type': 'number',
+            'default': DEFAULT_CONFIG['min_dist'],
+            'min': 0.01,
+            'max': 1.0,
+            'step': 0.01,
+            'help': 'Minimum distance between circle centers (normalized 0.0-1.0)'
+        },
+        {
+            'name': 'param1',
+            'label': 'Canny Threshold',
+            'type': 'number',
+            'default': DEFAULT_CONFIG['param1'],
+            'min': 1,
+            'help': 'Higher threshold for Canny edge detector'
+        },
+        {
+            'name': 'param2',
+            'label': 'Accumulator Threshold',
+            'type': 'number',
+            'default': DEFAULT_CONFIG['param2'],
+            'min': 1,
+            'help': 'Accumulator threshold for circle detection'
+        },
+        {
+            'name': 'min_radius',
+            'label': 'Min Radius',
+            'type': 'number',
+            'default': DEFAULT_CONFIG['min_radius'],
+            'min': 0.0,
+            'max': 1.0,
+            'step': 0.01,
+            'help': 'Minimum circle radius (normalized 0.0-1.0, 0 = no minimum)'
+        },
+        {
+            'name': 'max_radius',
+            'label': 'Max Radius',
+            'type': 'number',
+            'default': DEFAULT_CONFIG['max_radius'],
+            'min': 0.0,
+            'max': 1.0,
+            'step': 0.01,
+            'help': 'Maximum circle radius (normalized 0.0-1.0, 0 = no maximum)'
+        },
+        {
+            'name': 'draw_circles',
+            'label': 'Draw Circles',
+            'type': 'select',
+            'options': [
+                {'value': 'yes', 'label': 'Yes'},
+                {'value': 'no', 'label': 'No'}
+            ],
+            'default': DEFAULT_CONFIG['draw_circles'],
+            'help': 'Draw detected circles on output'
+        },
+        {
+            'name': 'circle_color',
+            'label': 'Circle Color (B,G,R)',
+            'type': 'text',
+            'default': DEFAULT_CONFIG['circle_color'],
+            'help': 'Color for drawn circles'
+        }
+    ]
+    
+    def __init__(self, node_id=None, name="hough circles"):
+        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, 255, 0)
+        except Exception:
+            return (0, 255, 0)
+    
+    def on_input(self, msg: Dict[str, Any], input_index: int = 0):
+        """Detect circles in the input image."""
+        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
+        
+        h, w = img.shape[:2]
+        
+        dp = self.get_config_float('dp', 1.2)
+        # Convert normalized min_dist to pixels
+        min_dist = int(self.get_config_float('min_dist', 0.1) * w)
+        min_dist = max(1, min_dist)  # Ensure at least 1 pixel
+        param1 = self.get_config_int('param1', 100)
+        param2 = self.get_config_int('param2', 30)
+        # Convert normalized radius to pixels
+        min_radius = int(self.get_config_float('min_radius', 0.02) * w)
+        max_radius_norm = self.get_config_float('max_radius', 0.0)
+        max_radius = int(max_radius_norm * w) if max_radius_norm > 0 else 0
+        draw = self.get_config_bool('draw_circles', True)
+        circle_color = self._parse_color(self.config.get('circle_color', '0,255,0'))
+        
+        # Convert to grayscale if needed
+        if len(img.shape) == 3:
+            gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
+        else:
+            gray = img
+        
+        # Apply slight blur to reduce noise
+        gray = cv2.medianBlur(gray, 5)
+        
+        # Detect circles
+        circles = cv2.HoughCircles(gray, cv2.HOUGH_GRADIENT, dp, min_dist,
+                                   param1=param1, param2=param2,
+                                   minRadius=min_radius, maxRadius=max_radius)
+        
+        circles_data = []
+        if circles is not None:
+            circles = np.uint16(np.around(circles))
+            for circle in circles[0, :]:
+                cx, cy, radius = circle
+                # Output normalized coordinates
+                circles_data.append({
+                    'x': float(cx) / w,
+                    'y': float(cy) / h,
+                    'radius': float(radius) / w,
+                    'x_px': int(cx),
+                    'y_px': int(cy),
+                    'radius_px': int(radius),
+                    'area': float(np.pi * radius * radius)
+                })
+            
+            # Draw circles if requested
+            if draw:
+                if len(img.shape) == 2:
+                    output = cv2.cvtColor(img, cv2.COLOR_GRAY2BGR)
+                else:
+                    output = img.copy()
+                
+                for circle in circles[0, :]:
+                    cx, cy, radius = circle
+                    cv2.circle(output, (cx, cy), radius, circle_color, 2)
+                    cv2.circle(output, (cx, cy), 2, (0, 0, 255), 3)  # center
+                
+                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['circles'] = circles_data
+        msg['circle_count'] = len(circles_data)
+        self.send(msg)

pynode/nodes/OpenCV/hough_lines_node.py

@@ -0,0 +1,243 @@
+"""
+OpenCV Hough Lines Node - detects lines in images.
+"""
+
+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("Detects lines in images using the Hough Line Transform. Works best on edge-detected images (use Edge Detector node first).")
+_info.add_header("Inputs")
+_info.add_bullets(("Input 0:", "Edge-detected or binary image recommended"))
+_info.add_header("Outputs")
+_info.add_bullets(
+    ("Output 0:", "Image with lines drawn (if enabled)"),
+    ("msg.lines:", "Array of detected lines with normalized coordinates (0.0-1.0)")
+)
+_info.add_header("Normalized Coordinates")
+_info.add_text("Line coordinates and parameters are normalized for resolution independence.")
+_info.add_header("Methods")
+_info.add_bullets(
+    ("Standard:", "Returns lines in polar form (rho, theta)"),
+    ("Probabilistic:", "Returns line segments with normalized endpoints (x1,y1,x2,y2)")
+)
+_info.add_header("Key Parameters")
+_info.add_bullets(
+    ("Rho:", "Distance resolution in pixels (typically 1)"),
+    ("Theta:", "Angle resolution in degrees (typically 1)"),
+    ("Threshold:", "Minimum votes needed to detect a line"),
+    ("Min Length:", "Minimum line segment length (normalized 0.0-1.0, probabilistic only)"),
+    ("Max Gap:", "Maximum gap to connect segments (normalized 0.0-1.0, probabilistic only)")
+)
+
+
+class HoughLinesNode(BaseNode):
+    info = str(_info)
+    """
+    Hough Lines node - detects lines in images using Hough transform.
+    Works best on edge-detected images.
+    """
+    display_name = 'Hough Lines'
+    icon = '╱'
+    category = 'opencv'
+    color = '#4A90D9'
+    border_color = '#2E6BB0'
+    text_color = '#FFFFFF'
+    input_count = 1
+    output_count = 1
+    
+    DEFAULT_CONFIG = {
+        'method': 'probabilistic',
+        'rho': 1,
+        'theta_degrees': 1,
+        'threshold': 100,
+        'min_length': 0.1,
+        'max_gap': 0.02,
+        'draw_lines': 'yes',
+        'line_color': '0,0,255'
+    }
+    
+    properties = [
+        {
+            'name': 'method',
+            'label': 'Method',
+            'type': 'select',
+            'options': [
+                {'value': 'standard', 'label': 'Standard'},
+                {'value': 'probabilistic', 'label': 'Probabilistic'}
+            ],
+            'default': DEFAULT_CONFIG['method'],
+            'help': 'Hough transform method'
+        },
+        {
+            'name': 'rho',
+            'label': 'Rho (pixels)',
+            'type': 'number',
+            'default': DEFAULT_CONFIG['rho'],
+            'min': 1,
+            'help': 'Distance resolution in pixels'
+        },
+        {
+            'name': 'theta_degrees',
+            'label': 'Theta (degrees)',
+            'type': 'number',
+            'default': DEFAULT_CONFIG['theta_degrees'],
+            'min': 0.1,
+            'step': 0.1,
+            'help': 'Angle resolution in degrees'
+        },
+        {
+            'name': 'threshold',
+            'label': 'Threshold',
+            'type': 'number',
+            'default': DEFAULT_CONFIG['threshold'],
+            'min': 1,
+            'help': 'Accumulator threshold'
+        },
+        {
+            'name': 'min_length',
+            'label': 'Min Line Length',
+            'type': 'number',
+            'default': DEFAULT_CONFIG['min_length'],
+            'min': 0.01,
+            'max': 1.0,
+            'step': 0.01,
+            'help': 'Minimum line length (normalized 0.0-1.0, probabilistic only)',
+            'showIf': {'method': 'probabilistic'}
+        },
+        {
+            'name': 'max_gap',
+            'label': 'Max Line Gap',
+            'type': 'number',
+            'default': DEFAULT_CONFIG['max_gap'],
+            'min': 0.01,
+            'max': 1.0,
+            'step': 0.01,
+            'help': 'Maximum gap between line segments (normalized 0.0-1.0, probabilistic only)',
+            'showIf': {'method': 'probabilistic'}
+        },
+        {
+            'name': 'draw_lines',
+            'label': 'Draw Lines',
+            'type': 'select',
+            'options': [
+                {'value': 'yes', 'label': 'Yes'},
+                {'value': 'no', 'label': 'No'}
+            ],
+            'default': DEFAULT_CONFIG['draw_lines'],
+            'help': 'Draw detected lines on output'
+        },
+        {
+            'name': 'line_color',
+            'label': 'Line Color (B,G,R)',
+            'type': 'text',
+            'default': DEFAULT_CONFIG['line_color'],
+            'help': 'Color for drawn lines'
+        }
+    ]
+    
+    def __init__(self, node_id=None, name="hough lines"):
+        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, 255)
+        except Exception:
+            return (0, 0, 255)
+    
+    def on_input(self, msg: Dict[str, Any], input_index: int = 0):
+        """Detect lines in the input image."""
+        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
+        
+        h, w = img.shape[:2]
+        diag = np.sqrt(w*w + h*h)  # Diagonal for length normalization
+        
+        method = self.config.get('method', 'probabilistic')
+        rho = self.get_config_float('rho', 1)
+        theta = self.get_config_float('theta_degrees', 1) * np.pi / 180
+        threshold = self.get_config_int('threshold', 100)
+        # Convert normalized length/gap to pixels
+        min_length = int(self.get_config_float('min_length', 0.1) * diag)
+        max_gap = int(self.get_config_float('max_gap', 0.02) * diag)
+        draw = self.get_config_bool('draw_lines', True)
+        line_color = self._parse_color(self.config.get('line_color', '0,0,255'))
+        
+        # Convert to grayscale if needed
+        if len(img.shape) == 3:
+            gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
+        else:
+            gray = img
+        
+        lines_data = []
+        
+        if method == 'standard':
+            lines = cv2.HoughLines(gray, rho, theta, threshold)
+            if lines is not None:
+                for line in lines:
+                    r, t = line[0]
+                    lines_data.append({
+                        'rho': float(r),
+                        'theta': float(t),
+                        'theta_degrees': float(t * 180 / np.pi)
+                    })
+        else:  # probabilistic
+            lines = cv2.HoughLinesP(gray, rho, theta, threshold, 
+                                    minLineLength=min_length, maxLineGap=max_gap)
+            if lines is not None:
+                for line in lines:
+                    x1, y1, x2, y2 = line[0]
+                    length = np.sqrt((x2 - x1)**2 + (y2 - y1)**2)
+                    angle = np.arctan2(y2 - y1, x2 - x1) * 180 / np.pi
+                    # Output normalized coordinates
+                    lines_data.append({
+                        'x1': float(x1) / w, 'y1': float(y1) / h,
+                        'x2': float(x2) / w, 'y2': float(y2) / h,
+                        'x1_px': int(x1), 'y1_px': int(y1),
+                        'x2_px': int(x2), 'y2_px': int(y2),
+                        'length': float(length) / diag,
+                        'length_px': float(length),
+                        'angle': float(angle)
+                    })
+        
+        # Draw lines if requested
+        if draw and lines is not None:
+            if len(img.shape) == 2:
+                output = cv2.cvtColor(img, cv2.COLOR_GRAY2BGR)
+            else:
+                output = img.copy()
+            
+            if method == 'standard':
+                for line in lines:
+                    r, t = line[0]
+                    a, b = np.cos(t), np.sin(t)
+                    x0, y0 = a * r, b * r
+                    x1 = int(x0 + 1000 * (-b))
+                    y1 = int(y0 + 1000 * (a))
+                    x2 = int(x0 - 1000 * (-b))
+                    y2 = int(y0 - 1000 * (a))
+                    cv2.line(output, (x1, y1), (x2, y2), line_color, 2)
+            else:
+                for line in lines:
+                    x1, y1, x2, y2 = line[0]
+                    cv2.line(output, (x1, y1), (x2, y2), line_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['lines'] = lines_data
+        msg['line_count'] = len(lines_data)
+        self.send(msg)

pynode/nodes/OpenCV/in_range_node.py

@@ -0,0 +1,186 @@
+"""
+OpenCV In Range Node - filters image pixels by color/intensity range.
+Useful for color-based object detection and masking.
+"""
+
+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("Creates a binary mask from pixels within a specified color/intensity range. Useful for color-based object detection and masking. Works best with HSV color space for color filtering.")
+_info.add_header("Inputs")
+_info.add_bullets(("Input 0:", "Image (any color space, HSV recommended)"))
+_info.add_header("Outputs")
+_info.add_bullets(
+    ("Output 0:", "Binary mask (white = in range, black = out of range)"),
+    ("Output 1:", "Masked image (original with out-of-range pixels blacked out)")
+)
+_info.add_header("Properties")
+_info.add_bullets(
+    ("Channel 1 (H/B):", "Min/Max for first channel (Hue 0-179 in HSV)"),
+    ("Channel 2 (S/G):", "Min/Max for second channel (Saturation in HSV)"),
+    ("Channel 3 (V/R):", "Min/Max for third channel (Value in HSV)"),
+    ("Output Mode:", "Choose mask only, masked image only, or both")
+)
+
+class InRangeNode(BaseNode):
+    """
+    In Range node - creates a binary mask from pixels within a color range.
+    Works with any color space (HSV recommended for color filtering).
+    """
+    info = str(_info)
+    display_name = 'In Range'
+    icon = '🎯'
+    category = 'opencv'
+    color = '#4A90D9'
+    border_color = '#2E6BB0'
+    text_color = '#FFFFFF'
+    input_count = 1
+    output_count = 2  # Output 0: mask, Output 1: masked image
+    
+    DEFAULT_CONFIG = {
+        'channel1_min': 0,
+        'channel1_max': 180,
+        'channel2_min': 50,
+        'channel2_max': 255,
+        'channel3_min': 50,
+        'channel3_max': 255,
+        'output_mode': 'both'
+    }
+    
+    properties = [
+        {
+            'name': 'channel1_min',
+            'label': 'Channel 1 Min (H/B)',
+            'type': 'number',
+            'default': DEFAULT_CONFIG['channel1_min'],
+            'min': 0,
+            'max': 255,
+            'help': 'Minimum value for channel 1 (Hue in HSV: 0-179)'
+        },
+        {
+            'name': 'channel1_max',
+            'label': 'Channel 1 Max (H/B)',
+            'type': 'number',
+            'default': DEFAULT_CONFIG['channel1_max'],
+            'min': 0,
+            'max': 255,
+            'help': 'Maximum value for channel 1'
+        },
+        {
+            'name': 'channel2_min',
+            'label': 'Channel 2 Min (S/G)',
+            'type': 'number',
+            'default': DEFAULT_CONFIG['channel2_min'],
+            'min': 0,
+            'max': 255,
+            'help': 'Minimum value for channel 2 (Saturation in HSV)'
+        },
+        {
+            'name': 'channel2_max',
+            'label': 'Channel 2 Max (S/G)',
+            'type': 'number',
+            'default': DEFAULT_CONFIG['channel2_max'],
+            'min': 0,
+            'max': 255,
+            'help': 'Maximum value for channel 2'
+        },
+        {
+            'name': 'channel3_min',
+            'label': 'Channel 3 Min (V/R)',
+            'type': 'number',
+            'default': DEFAULT_CONFIG['channel3_min'],
+            'min': 0,
+            'max': 255,
+            'help': 'Minimum value for channel 3 (Value in HSV)'
+        },
+        {
+            'name': 'channel3_max',
+            'label': 'Channel 3 Max (V/R)',
+            'type': 'number',
+            'default': DEFAULT_CONFIG['channel3_max'],
+            'min': 0,
+            'max': 255,
+            'help': 'Maximum value for channel 3'
+        },
+        {
+            'name': 'output_mode',
+            'label': 'Output Mode',
+            'type': 'select',
+            'options': [
+                {'value': 'mask', 'label': 'Mask only'},
+                {'value': 'masked', 'label': 'Masked image only'},
+                {'value': 'both', 'label': 'Both (mask + masked)'}
+            ],
+            'default': DEFAULT_CONFIG['output_mode'],
+            'help': 'What to include in output'
+        }
+    ]
+    
+    def __init__(self, node_id=None, name="in range"):
+        super().__init__(node_id, name)
+    
+    def on_input(self, msg: Dict[str, Any], input_index: int = 0):
+        """Apply color range filter to the input image."""
+        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
+        
+        # Get range values
+        lower = np.array([
+            self.get_config_int('channel1_min', 0),
+            self.get_config_int('channel2_min', 0),
+            self.get_config_int('channel3_min', 0)
+        ])
+        upper = np.array([
+            self.get_config_int('channel1_max', 255),
+            self.get_config_int('channel2_max', 255),
+            self.get_config_int('channel3_max', 255)
+        ])
+        
+        output_mode = self.config.get('output_mode', 'both')
+        
+        # Handle grayscale images
+        if len(img.shape) == 2:
+            mask = cv2.inRange(img, lower[0], upper[0])
+        else:
+            mask = cv2.inRange(img, lower, upper)
+        
+        # Apply mask to get masked image
+        if len(img.shape) == 2:
+            masked = cv2.bitwise_and(img, img, mask=mask)
+        else:
+            masked = cv2.bitwise_and(img, img, mask=mask)
+        
+        # Count non-zero pixels
+        pixel_count = cv2.countNonZero(mask)
+        total_pixels = mask.shape[0] * mask.shape[1]
+        coverage = pixel_count / total_pixels if total_pixels > 0 else 0
+        
+        msg['mask_pixels'] = pixel_count
+        msg['mask_coverage'] = coverage
+        
+        if MessageKeys.PAYLOAD not in msg or not isinstance(msg[MessageKeys.PAYLOAD], dict):
+            msg[MessageKeys.PAYLOAD] = {}
+        
+        if output_mode == 'mask':
+            msg[MessageKeys.PAYLOAD][MessageKeys.IMAGE.PATH] = self.encode_image(mask, format_type)
+            self.send(msg, 0)
+        elif output_mode == 'masked':
+            msg[MessageKeys.PAYLOAD][MessageKeys.IMAGE.PATH] = self.encode_image(masked, format_type)
+            self.send(msg, 0)
+        else:  # both
+            msg[MessageKeys.PAYLOAD][MessageKeys.IMAGE.PATH] = self.encode_image(mask, format_type)
+            msg[MessageKeys.PAYLOAD]['masked_image'] = self.encode_image(masked, format_type)
+            self.send(msg, 0)
+            
+            msg2 = msg.copy()
+            msg2[MessageKeys.PAYLOAD] = {MessageKeys.IMAGE.PATH: self.encode_image(masked, format_type)}
+            self.send(msg2, 1)