pynode-flow 0.2.0__py3-none-any.whl

pynode/nodes/OpenCV/fft_node.py

@@ -0,0 +1,102 @@
+"""
+OpenCV FFT Node - performs Fast Fourier Transform on an 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("Performs Fast Fourier Transform (FFT) on an input image to extract frequency components.")
+_info.add_header("Inputs")
+_info.add_bullet("Input 0:", "Input image (converted to grayscale automatically)")
+_info.add_header("Outputs")
+_info.add_bullet("Output 0:", "Magnitude Spectrum (visualizable) + FFT Complex Data (in metadata)")
+_info.add_header("Notes")
+_info.add_text("The complex frequency data is stored in the message metadata ('_fft_data') for downstream processing by the Frequency Filter node.")
+_info.add_text("The visible output is the Magnitude Spectrum (log-scaled).")
+
+
+class FFTNode(BaseNode):
+    """
+    FFT Node - converts image to frequency domain.
+    """
+    info = str(_info)
+    display_name = 'FFT'
+    icon = '∿'
+    category = 'opencv'
+    color = '#8E44AD'  # Purple-ish
+    border_color = '#6C3483'
+    text_color = '#FFFFFF'
+    input_count = 1
+    output_count = 1
+    
+    DEFAULT_CONFIG = {
+        'output_view': 'magnitude'
+    }
+    
+    properties = [
+        {
+            'name': 'output_view',
+            'label': 'Output View',
+            'type': 'select',
+            'options': [
+                {'value': 'magnitude', 'label': 'Magnitude Spectrum'}
+            ],
+            'default': DEFAULT_CONFIG['output_view'],
+            'help': 'What to display in the image payload'
+        }
+    ]
+    
+    def on_input(self, msg: Dict[str, Any], input_index: int = 0):
+        """Process incoming image and compute FFT."""
+        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
+        
+        if format_type is None:
+            format_type = 'numpy_array'
+            
+        # Convert to grayscale if necessary
+        if len(img.shape) == 3:
+            gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
+        else:
+            gray = img
+            
+        # Compute DFT
+        # cv2.dft expects float32
+        dft = cv2.dft(np.float32(gray), flags=cv2.DFT_COMPLEX_OUTPUT)
+        dft_shift = np.fft.fftshift(dft)
+        
+        # Compute Magnitude Spectrum for visualization
+        # magnitude = sqrt(Re^2 + Im^2)
+        magnitude = cv2.magnitude(dft_shift[:,:,0], dft_shift[:,:,1])
+        
+        # Log scale: 20 * log(1 + mag)
+        magnitude_spectrum = 20 * np.log(magnitude + 1)
+        
+        # Normalize to 0-255
+        cv2.normalize(magnitude_spectrum, magnitude_spectrum, 0, 255, cv2.NORM_MINMAX)
+        result_img = np.uint8(magnitude_spectrum)
+        
+        # Create new message with result
+        new_msg = msg.copy()
+        
+        # Encode result image
+        if not isinstance(new_msg.get(MessageKeys.PAYLOAD), dict):
+            new_msg[MessageKeys.PAYLOAD] = {}
+            
+        new_msg[MessageKeys.PAYLOAD][MessageKeys.IMAGE.PATH] = self.encode_image(result_img, format_type)
+        
+        # Store complex data for downstream nodes
+        # Use a hidden key to pass the raw complex numpy array
+        new_msg['_fft_data'] = dft_shift
+        new_msg['_fft_shape'] = gray.shape  # Store original shape
+        
+        self.send(new_msg)

pynode/nodes/OpenCV/focus_estimation_node.py

@@ -0,0 +1,189 @@
+"""
+OpenCV Focus Estimation Node - measures image sharpness using various focus operators.
+"""
+
+import cv2
+import numpy as np
+from typing import Any, Dict
+from pynode.nodes.base_node import BaseNode, process_image, Info, MessageKeys
+
+_info = Info()
+_info.add_text("Estimates image focus/sharpness using various computational methods. Outputs a focus score indicating how sharp the image is.")
+_info.add_header("Inputs")
+_info.add_bullets(("Input 0:", "Source image"))
+_info.add_header("Outputs")
+_info.add_bullets(("Output 0:", "Message with focus score (and optionally the image)"))
+_info.add_header("Focus Methods")
+_info.add_bullets(
+    ("Laplacian:", "Variance of Laplacian operator - best for general use"),
+    ("Tenengrad:", "Sobel gradient magnitude - excellent edge detection"),
+    ("Sobel + Variance:", "Combined gradient and variance - robust method"),
+    ("Brenner Gradient:", "Pixel difference method - fast and simple"),
+    ("Local Variance:", "Local intensity variations - works for high contrast"),
+    ("Entropy:", "Shannon entropy - good for texture-rich images")
+)
+_info.add_header("Output")
+_info.add_bullets(
+    ("focus_score:", "Numerical sharpness value (higher = sharper)"),
+    ("method:", "The focus estimation method used"),
+    ("image:", "Original image (if 'Include Image' is enabled)")
+)
+
+class FocusEstimationNode(BaseNode):
+    """
+    Focus Estimation node - measures image sharpness using various focus operators.
+    """
+    info = str(_info)
+    display_name = 'Focus Estimation'
+    icon = '⌖'
+    category = 'opencv'
+    color = '#4A90D9'
+    border_color = '#2E6BB0'
+    text_color = '#FFFFFF'
+    input_count = 1
+    output_count = 1
+    
+    DEFAULT_CONFIG = {
+        'method': 'laplacian',
+        'include_image': False
+    }
+    
+    properties = [
+        {
+            'name': 'method',
+            'label': 'Focus Method',
+            'type': 'select',
+            'options': [
+                {'value': 'laplacian', 'label': 'Laplacian (Recommended)'},
+                {'value': 'tenengrad', 'label': 'Tenengrad (Sobel)'},
+                {'value': 'sobel_variance', 'label': 'Sobel + Variance'},
+                {'value': 'brenner', 'label': 'Brenner Gradient'},
+                {'value': 'variance', 'label': 'Local Variance'},
+                {'value': 'entropy', 'label': 'Entropy'}
+            ],
+            'default': DEFAULT_CONFIG['method'],
+            'help': 'Method to compute focus score'
+        },
+        {
+            'name': 'include_image',
+            'label': 'Include Image',
+            'type': 'checkbox',
+            'default': DEFAULT_CONFIG['include_image'],
+            'help': 'Include image in output message'
+        }
+    ]
+    
+    def __init__(self, node_id=None, name="focus_estimation"):
+        super().__init__(node_id, name)
+    
+    def _compute_laplacian(self, gray: np.ndarray) -> float:
+        """
+        Laplacian-based focus measure.
+        Returns variance of Laplacian - sharp images have higher variance.
+        """
+        laplacian = cv2.Laplacian(gray, cv2.CV_64F)
+        return float(np.var(laplacian))
+    
+    def _compute_tenengrad(self, gray: np.ndarray) -> float:
+        """
+        Tenengrad (Sobel gradient) focus measure.
+        Returns mean gradient magnitude - sharp images have stronger edges.
+        """
+        sobel_x = cv2.Sobel(gray, cv2.CV_64F, 1, 0, ksize=3)
+        sobel_y = cv2.Sobel(gray, cv2.CV_64F, 0, 1, ksize=3)
+        tenengrad = np.sqrt(sobel_x**2 + sobel_y**2)
+        return float(np.mean(tenengrad))
+    
+    def _compute_sobel_variance(self, gray: np.ndarray) -> float:
+        """
+        Combined Sobel + Variance focus measure.
+        Returns sum of mean gradient magnitude and variance.
+        """
+        sobel_x = cv2.Sobel(gray, cv2.CV_64F, 1, 0, ksize=3)
+        sobel_y = cv2.Sobel(gray, cv2.CV_64F, 0, 1, ksize=3)
+        sobel_magnitude = np.sqrt(sobel_x**2 + sobel_y**2)
+        variance = np.var(gray)
+        return float(np.mean(sobel_magnitude) + variance)
+    
+    def _compute_brenner_gradient(self, gray: np.ndarray) -> float:
+        """
+        Brenner gradient focus measure.
+        Returns sum of squared differences between pixels 2 positions apart.
+        """
+        shifted = np.roll(gray, -2, axis=1)
+        diff = (gray.astype(np.float64) - shifted.astype(np.float64)) ** 2
+        return float(np.sum(diff))
+    
+    def _compute_local_variance(self, gray: np.ndarray, ksize: int = 5) -> float:
+        """
+        Local variance focus measure.
+        Returns mean of local variance - sharp images have higher local variations.
+        """
+        gray_float = gray.astype(np.float64)
+        mean = cv2.blur(gray_float, (ksize, ksize))
+        squared_mean = cv2.blur(gray_float**2, (ksize, ksize))
+        variance = squared_mean - (mean**2)
+        return float(np.mean(variance))
+    
+    def _compute_entropy(self, gray: np.ndarray) -> float:
+        """
+        Entropy-based focus measure using Shannon entropy.
+        Returns entropy value - sharp images have higher entropy.
+        """
+        # Compute histogram
+        hist = cv2.calcHist([gray], [0], None, [256], [0, 256])
+        hist = hist.flatten()
+        
+        # Normalize histogram to get probability distribution
+        hist = hist / hist.sum()
+        
+        # Remove zero entries
+        hist = hist[hist > 0]
+        
+        # Compute Shannon entropy
+        entropy = -np.sum(hist * np.log2(hist))
+        return float(entropy)
+    
+    @process_image()
+    def on_input(self, image: np.ndarray, msg: Dict[str, Any], input_index: int = 0):
+        """Compute focus score for the input image."""
+        method = self.config.get('method', 'laplacian')
+        include_image = self.get_config_bool('include_image', False)
+        
+        # Convert to grayscale for focus computation
+        gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
+        
+        # Compute focus score based on selected method
+        if method == 'laplacian':
+            focus_score = self._compute_laplacian(gray)
+        elif method == 'tenengrad':
+            focus_score = self._compute_tenengrad(gray)
+        elif method == 'sobel_variance':
+            focus_score = self._compute_sobel_variance(gray)
+        elif method == 'brenner':
+            focus_score = self._compute_brenner_gradient(gray)
+        elif method == 'variance':
+            focus_score = self._compute_local_variance(gray)
+        elif method == 'entropy':
+            focus_score = self._compute_entropy(gray)
+        else:
+            focus_score = self._compute_laplacian(gray)
+        
+        # Create output message with focus score
+        output_msg = {MessageKeys.PAYLOAD: {}}
+
+        # Store the focus estimation results in msg.payload
+        output_msg[MessageKeys.PAYLOAD] = {
+            'focus_score': focus_score,
+            'method': method
+        }
+        
+        # Include image if requested
+        if include_image:
+            output_msg[MessageKeys.PAYLOAD][MessageKeys.IMAGE.PATH] = image
+        
+        # Send the message with focus information
+        self.send(output_msg, 0)
+        
+        # Return None since we're sending a custom message
+        return None

pynode/nodes/OpenCV/frequency_filter_node.py

@@ -0,0 +1,241 @@
+"""
+OpenCV Frequency Filter Node - filters frequencies and performs inverse FFT.
+"""
+
+import logging
+
+import cv2
+import numpy as np
+from typing import Any, Dict
+from pynode.nodes.base_node import BaseNode, Info, MessageKeys
+
+logger = logging.getLogger(__name__)
+
+_info = Info()
+_info.add_text("Modifies frequency components (filtering) and reconstructs the image via Inverse FFT.")
+_info.add_header("Inputs")
+_info.add_bullet("Input 0:", "FFT Node output (must contain frequency data)")
+_info.add_header("Outputs")
+_info.add_bullet("Output 0:", "Filtered Image (spatial domain) or Filtered Spectrum")
+_info.add_header("Operations")
+_info.add_bullets(
+    ("Low Pass:", "Keeps low frequencies (center), suppresses details/noise. Blurs the image."),
+    ("High Pass:", "Keeps high frequencies (edges), suppresses smooth areas. Edge detection."),
+    ("Notch Filter:", "Manually blocks specific frequency spots (harmonics/noise) using coordinates.")
+)
+_info.add_header("Notch Configuration")
+_info.add_text("Enter coordinates to block in the 'Notch Filters' field. Format: x,y,radius; x2,y2,radius2.")
+_info.add_text("Example: '100,200,5; 340,150,10' blocks two circular regions.")
+
+
+class FrequencyFilterNode(BaseNode):
+    """
+    Frequency Filter Node - applies masks to frequency domain data.
+    """
+    info = str(_info)
+    display_name = 'Freq Filter'
+    icon = '⌖'
+    category = 'opencv'
+    color = '#8E44AD'  # Same purple scheme
+    border_color = '#6C3483'
+    text_color = '#FFFFFF'
+    input_count = 1
+    output_count = 1
+    
+    DEFAULT_CONFIG = {
+        'filter_type': 'low_pass',
+        'radius': 30,
+        'notch_filters': '',
+        'symmetric_notches': 'true',
+        'output_mode': 'reconstructed'
+    }
+    
+    properties = [
+        {
+            'name': 'filter_type',
+            'label': 'Filter Type',
+            'type': 'select',
+            'options': [
+                {'value': 'low_pass', 'label': 'Low Pass (Blur)'},
+                {'value': 'high_pass', 'label': 'High Pass (Edges)'},
+                {'value': 'none', 'label': 'None (Pass Through / Just Notches)'}
+            ],
+            'default': DEFAULT_CONFIG['filter_type']
+        },
+        {
+            'name': 'radius',
+            'label': 'Cutoff Radius',
+            'type': 'number',
+            'default': DEFAULT_CONFIG['radius'],
+            'min': 1,
+            'max': 500
+        },
+        {
+            'name': 'notch_filters',
+            'label': 'Notch Filters (x,y,r; ...)',
+            'type': 'text',
+            'default': DEFAULT_CONFIG['notch_filters'],
+            'help': 'Block specific frequencies. Format: x,y,radius (semicolon separated). E.g. 120,45,5'
+        },
+        {
+            'name': 'symmetric_notches',
+            'label': 'Apply Symmetrically',
+            'type': 'checkbox',
+            'default': DEFAULT_CONFIG['symmetric_notches'],
+            'help': 'Automatically block the symmetric point across the center (required for real signals)'
+        },
+        {
+            'name': 'output_mode',
+            'label': 'Output Mode',
+            'type': 'select',
+            'options': [
+                {'value': 'reconstructed', 'label': 'Reconstructed Image'},
+                {'value': 'spectrum', 'label': 'Filtered Spectrum (View)'},
+                {'value': 'both', 'label': 'Both (Reconstructed + Spectrum)'}
+            ],
+            'default': DEFAULT_CONFIG['output_mode'],
+            'help': 'View the resulting image or the modified frequency spectrum'
+        }
+    ]
+    
+    def on_input(self, msg: Dict[str, Any], input_index: int = 0):
+        """Process incoming frequency data."""
+        # Check for FFT data
+        dft_shift = msg.get('_fft_data')
+        
+        if dft_shift is None:
+            # If no FFT data, try to look for image in payload to auto-convert (optional convenience)
+            # But strictly, we should expect FFT data.
+            # Let's pass through if we can't process
+            self.send(msg)
+            return
+            
+        rows, cols = dft_shift.shape[:2]
+        crow, ccol = rows//2, cols//2  # Center
+        
+        # Create a mask, first separate channels (2 channels: Real, Imag)
+        # We need a mask that applies to both channels
+        mask = np.zeros((rows, cols, 2), np.uint8)
+        
+        try:
+            radius = int(self.config.get('radius', 30))
+        except ValueError:
+            radius = 30
+            
+        filter_type = self.config.get('filter_type', 'low_pass')
+        
+        # Create circular mask area
+        # Using grid indices
+        y, x = np.ogrid[:rows, :cols]
+        mask_area = (x - ccol)**2 + (y - crow)**2 <= radius*radius
+        
+        if filter_type == 'low_pass':
+            # 1 inside circle, 0 outside
+            mask[mask_area] = 1
+        elif filter_type == 'high_pass':
+            # 0 inside circle, 1 outside
+            mask[~mask_area] = 1
+        else: # none / pass-through
+            mask.fill(1)
+            
+        # Apply Notch Filters (Manual Blocking)
+        notch_str = self.config.get('notch_filters', '')
+        symmetric = self.config.get('symmetric_notches', 'true') == 'true'
+        
+        if notch_str:
+            try:
+                for notch_def in notch_str.split(';'):
+                    if not notch_def.strip():
+                        continue
+                    
+                    parts = [float(p.strip()) for p in notch_def.split(',') if p.strip()]
+                    if len(parts) >= 2:
+                        nx, ny = int(parts[0]), int(parts[1])
+                        # Default radius 5 if not specified
+                        nr = int(parts[2]) if len(parts) > 2 else 5
+                        
+                        # Apply notch at (nx, ny)
+                        # Remember x matches cols index, y matches rows index
+                        notch_area = (x - nx)**2 + (y - ny)**2 <= nr*nr
+                        mask[notch_area] = 0
+                        
+                        if symmetric:
+                            # Calculate symmetric point relative to center (ccol, crow)
+                            # Actually relative to image dimensions: (cols - x, rows - y)
+                            # Center is at axis of rotation
+                            # Point (x, y) reflected across (cx, cy) is (2cx - x, 2cy - y)
+                            # Since cx=cols/2, 2cx = cols. So (cols - x, rows - y) approximately
+                            # Let's use exact center calculation
+                            
+                            # Center of image is (cols/2, rows/2).
+                            # Because indices are 0-based, exact center is (cols-1)/2 ?? 
+                            # FFT shift puts DC at rows//2, cols//2.
+                            
+                            sym_x = 2 * ccol - nx
+                            sym_y = 2 * crow - ny
+                            
+                            # Ensure within bounds
+                            # if 0 <= sym_x < cols and 0 <= sym_y < rows:
+                            # Actually, simpler logic:
+                            # The mask uses coordinates. Creating a circular mask at sym coords works.
+                            
+                            notch_area_sym = (x - sym_x)**2 + (y - sym_y)**2 <= nr*nr
+                            mask[notch_area_sym] = 0
+                            
+            except Exception as e:
+                # Log error but continue with what we have
+                logger.error(f"Error parsing notch filters: {e}")
+            
+        # Apply mask
+        fshift = dft_shift * mask
+        
+        result_img = None
+        spectrum_img = None
+        output_mode = self.config.get('output_mode', 'reconstructed')
+        
+        def compute_spectrum(f_data):
+            mag = cv2.magnitude(f_data[:,:,0], f_data[:,:,1])
+            mag_spec = 20 * np.log(mag + 1)
+            cv2.normalize(mag_spec, mag_spec, 0, 255, cv2.NORM_MINMAX)
+            return np.uint8(mag_spec)
+
+        def compute_reconstruction(f_data):
+            f_ishift = np.fft.ifftshift(f_data)
+            img_b = cv2.idft(f_ishift)
+            img_b = cv2.magnitude(img_b[:,:,0], img_b[:,:,1])
+            cv2.normalize(img_b, img_b, 0, 255, cv2.NORM_MINMAX)
+            return np.uint8(img_b)
+            
+        if output_mode == 'spectrum':
+            result_img = compute_spectrum(fshift)
+        elif output_mode == 'both':
+            result_img = compute_reconstruction(fshift)
+            spectrum_img = compute_spectrum(fshift)
+        else:
+            result_img = compute_reconstruction(fshift)
+        
+        # Create response
+        new_msg = msg.copy()
+        
+        # Update payload
+        # Use existing format type or default to jpg
+        # We can extract format from payload path if present, or just assume
+        # The encode_image method usually handles basic types.
+        
+        # We need to construct a proper payload structure if it doesn't exist
+        if MessageKeys.PAYLOAD not in new_msg or not isinstance(new_msg[MessageKeys.PAYLOAD], dict):
+             new_msg[MessageKeys.PAYLOAD] = {}
+             
+        # Encode
+        # Use bgr_numpy_dict to provide a consistent object structure (data, width, height, etc)
+        # while keeping the data as numpy array for efficiency.
+        format_type = 'bgr_numpy_dict'
+        new_msg[MessageKeys.PAYLOAD][MessageKeys.IMAGE.PATH] = self.encode_image(result_img, format_type)
+        
+        if spectrum_img is not None:
+             new_msg[MessageKeys.PAYLOAD]['spectrum'] = self.encode_image(spectrum_img, format_type)
+        
+        # Update metadata for chaining (optional)
+        new_msg['_fft_data'] = fshift
+        
+        self.send(new_msg)

pynode/nodes/OpenCV/histogram_node.py

@@ -0,0 +1,160 @@
+"""
+OpenCV Histogram Node - computes and optionally equalizes image histograms.
+"""
+
+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("Computes histograms and applies histogram operations for contrast enhancement. For color images, operates on the L channel in LAB color space.")
+_info.add_header("Inputs")
+_info.add_bullets(("Input 0:", "Image (color or grayscale)"))
+_info.add_header("Outputs")
+_info.add_bullets(
+    ("Output 0:", "Processed image"),
+    ("msg.histogram:", "Array of 256 values representing pixel distribution")
+)
+_info.add_header("Operations")
+_info.add_bullets(
+    ("Compute only:", "Calculate histogram without modifying image"),
+    ("Equalize:", "Standard histogram equalization for global contrast"),
+    ("CLAHE:", "Adaptive equalization that prevents over-amplification"),
+    ("Normalize:", "Stretch pixel values to specified range")
+)
+_info.add_header("Tips")
+_info.add_bullets(
+    ("CLAHE:", "Best for images with varying lighting conditions"),
+    ("Clip Limit:", "Higher values = more contrast, may increase noise")
+)
+
+
+class HistogramNode(BaseNode):
+    info = str(_info)
+    """
+    Histogram node - computes histograms and applies histogram equalization.
+    """
+    display_name = 'Histogram'
+    icon = '📊'
+    category = 'opencv'
+    color = '#4A90D9'
+    border_color = '#2E6BB0'
+    text_color = '#FFFFFF'
+    input_count = 1
+    output_count = 1
+    
+    DEFAULT_CONFIG = {
+        'operation': 'equalize',
+        'clip_limit': 2.0,
+        'tile_size': 8,
+        'normalize_alpha': 0,
+        'normalize_beta': 255
+    }
+    
+    properties = [
+        {
+            'name': 'operation',
+            'label': 'Operation',
+            'type': 'select',
+            'options': [
+                {'value': 'compute', 'label': 'Compute histogram only'},
+                {'value': 'equalize', 'label': 'Histogram equalization'},
+                {'value': 'clahe', 'label': 'CLAHE (adaptive)'},
+                {'value': 'normalize', 'label': 'Normalize'}
+            ],
+            'default': DEFAULT_CONFIG['operation'],
+            'help': 'Histogram operation to perform'
+        },
+        {
+            'name': 'clip_limit',
+            'label': 'CLAHE Clip Limit',
+            'type': 'number',
+            'default': DEFAULT_CONFIG['clip_limit'],
+            'min': 0.1,
+            'max': 10,
+            'step': 0.1,
+            'help': 'Threshold for contrast limiting (CLAHE)',
+            'showIf': {'operation': 'clahe'}
+        },
+        {
+            'name': 'tile_size',
+            'label': 'CLAHE Tile Size',
+            'type': 'number',
+            'default': DEFAULT_CONFIG['tile_size'],
+            'min': 2,
+            'max': 32,
+            'help': 'Size of grid for CLAHE',
+            'showIf': {'operation': 'clahe'}
+        },
+        {
+            'name': 'normalize_alpha',
+            'label': 'Normalize Alpha',
+            'type': 'number',
+            'default': DEFAULT_CONFIG['normalize_alpha'],
+            'min': 0,
+            'max': 255,
+            'help': 'Lower bound for normalization',
+            'showIf': {'operation': 'normalize'}
+        },
+        {
+            'name': 'normalize_beta',
+            'label': 'Normalize Beta',
+            'type': 'number',
+            'default': DEFAULT_CONFIG['normalize_beta'],
+            'min': 0,
+            'max': 255,
+            'help': 'Upper bound for normalization',
+            'showIf': {'operation': 'normalize'}
+        }
+    ]
+    
+    def __init__(self, node_id=None, name="histogram"):
+        super().__init__(node_id, name)
+    
+    @process_image()
+    def on_input(self, image: np.ndarray, msg: Dict[str, Any], input_index: int = 0):
+        """Process image histogram."""
+        operation = self.config.get('operation', 'equalize')
+        clip_limit = self.get_config_float('clip_limit', 2.0)
+        tile_size = self.get_config_int('tile_size', 8)
+        alpha = self.get_config_int('normalize_alpha', 0)
+        beta = self.get_config_int('normalize_beta', 255)
+        
+        # Convert to grayscale for processing if color
+        if len(image.shape) == 3:
+            is_color = True
+            # Convert to LAB for better color handling
+            lab = cv2.cvtColor(image, cv2.COLOR_BGR2LAB)
+            l_channel = lab[:, :, 0]
+        else:
+            is_color = False
+            l_channel = image
+        
+        # Compute histogram
+        hist = cv2.calcHist([l_channel], [0], None, [256], [0, 256])
+        extra_fields = {'histogram': hist.flatten().tolist()}
+        
+        if operation == 'compute':
+            # Just compute, don't modify image
+            return image, extra_fields
+        
+        if operation == 'equalize':
+            result = cv2.equalizeHist(l_channel)
+        elif operation == 'clahe':
+            clahe = cv2.createCLAHE(clipLimit=clip_limit, 
+                                    tileGridSize=(tile_size, tile_size))
+            result = clahe.apply(l_channel)
+        elif operation == 'normalize':
+            result = cv2.normalize(l_channel, None, alpha, beta, cv2.NORM_MINMAX)
+        else:
+            result = l_channel
+        
+        # Reconstruct color image if needed
+        if is_color:
+            lab[:, :, 0] = result
+            output = cv2.cvtColor(lab, cv2.COLOR_LAB2BGR)
+        else:
+            output = result
+        
+        return output, extra_fields