Squashed commit of the following:

commit 40be6443bca076f01e30930cd1c27d88d032df89
Author: ryanontheinstide <[email protected]>
Date:   Wed Jan 29 09:51:43 2025 -0500

    similarity filter, lazy condition, remove redundant VAE

Author: ryanontheinstide

README.MD

@@ -26,10 +26,8 @@ The intention for this repository is to build a suite of nodes that can be used
 - **QuickShapeMask**: Rapidly generate shape masks (circle, square) with customizable dimensions.
 - **DTypeConverter**: Convert masks between different data types (float16, uint8, float32, float64).
 - **FastWebcamCapture**: High-performance webcam capture node with resizing capabilities.
-
-### VAE Tools 🖼️
-- **TAESDVaeEncode**: TAESD VAE encoding node.
-- **TAESDVaeDecode**: TAESD VAE decoding node.
+- **SimilarityFilter**: Filter out similar consecutive images and control downstream execution. Perfect for optimizing real-time workflows by skipping redundant processing of similar frames.
+- **LazyCondition**: Powerful conditional execution node that supports any input type. Uses lazy evaluation to truly skip execution of unused paths and maintains state to avoid feedback loops.
 
 ## Movement Patterns 🔄
 
@@ -61,6 +59,12 @@ Sequence controls allow you to specify exact values to cycle through. You can co
 ### FPS Monitor
 Outputs an image and mask showing current and average FPS. Useful for performance monitoring in real-time workflows.
 
+### Utility Controls
+Use utility nodes to optimize and control your workflow:
+- **FPS Monitor**: Monitor performance with a visual overlay
+- **SimilarityFilter**: Skip processing of similar frames by comparing consecutive images. Great for optimizing real-time workflows by only processing frames that have meaningful changes.
+- **LazyCondition**: Create conditional execution paths that truly skip processing of unused branches. Works with any input type (images, latents, text, numbers) and maintains state of the last successful output to avoid feedback loops.
+
 ## Examples 🎬
 
 ### Value Control Demo

__init__.py

@@ -1,9 +1,8 @@
 from .controls.value_controls import FloatControl, IntControl, StringControl
 from .controls.sequence_controls import FloatSequence, IntSequence, StringSequence
-from .controls.utility_controls import FPSMonitor
+from .controls.utility_controls import FPSMonitor, SimilarityFilter, LazyCondition
 from .controls.motion_controls import MotionController, ROINode, IntegerMotionController
 from .quick_shape_mask import QuickShapeMask
-from .tiny_vae import TAESDVaeEncode, TAESDVaeDecode
 from .misc_nodes import DTypeConverter, FastWebcamCapture
 
 NODE_CLASS_MAPPINGS = {
@@ -14,14 +13,18 @@
     "IntSequence": IntSequence,
     "StringSequence": StringSequence,
     "FPSMonitor": FPSMonitor,
+    "SimilarityFilter": SimilarityFilter,
+    "LazyCondition": LazyCondition,
     "MotionController": MotionController,
     "IntegerMotionController": IntegerMotionController,
+
+
+
+
     "ROINode": ROINode,
     #"IntervalControl": IntervalCo  ntrol,
     #"DeltaControl": DeltaControl,
     "QuickShapeMask": QuickShapeMask,
-    "TAESDVaeEncode": TAESDVaeEncode,
-    "TAESDVaeDecode": TAESDVaeDecode,
     "DTypeConverter": DTypeConverter,
     "FastWebcamCapture": FastWebcamCapture,
 }
@@ -44,8 +47,13 @@
     "TAESDVaeDecode": "TAESD VAE Decode (RyanOnTheInside)",
     "DTypeConverter": "DType Converter (RyanOnTheInside)",
     "FastWebcamCapture": "Fast Webcam Capture (RyanOnTheInside)",
+    "SimilarityFilter": "Similarity Filter (RyanOnTheInside)",
+    "LazyCondition": "Lazy Condition (RyanOnTheInside)",
+
+
 }
 
+
 WEB_DIRECTORY = "./web/js"
 
 __all__ = ['NODE_CLASS_MAPPINGS', 'NODE_DISPLAY_NAME_MAPPINGS'] 

controls/similar_image_filter.py

@@ -0,0 +1,44 @@
+import torch
+from typing import Optional
+import random
+
+class SimilarImageFilter:
+    def __init__(self, threshold: float = 0.98, max_skip_frame: float = 10) -> None:
+        self.threshold = threshold
+
+        self.prev_tensor = None
+        self.cos = torch.nn.CosineSimilarity(dim=0, eps=1e-6)
+        self.max_skip_frame = max_skip_frame
+        self.skip_count = 0
+
+    def __call__(self, x: torch.Tensor) -> Optional[torch.Tensor]:
+        if self.prev_tensor is None:
+            self.prev_tensor = x.detach().clone()
+            return x
+        else:
+            cos_sim = self.cos(self.prev_tensor.reshape(-1), x.reshape(-1)).item()
+            sample = random.uniform(0, 1)
+            if self.threshold >= 1:
+                skip_prob = 0
+            else:
+                skip_prob = max(0, 1 - (1 - cos_sim) / (1 - self.threshold))
+
+            # not skip frame
+            if skip_prob < sample:
+                self.prev_tensor = x.detach().clone()
+                return x
+            # skip frame
+            else:
+                if self.skip_count > self.max_skip_frame:
+                    self.skip_count = 0
+                    self.prev_tensor = x.detach().clone()
+                    return x
+                else:
+                    self.skip_count += 1
+                    return None
+
+    def set_threshold(self, threshold: float) -> None:
+        self.threshold = threshold
+    
+    def set_max_skip_frame(self, max_skip_frame: float) -> None:
+        self.max_skip_frame = max_skip_frame

controls/utility_controls.py

@@ -1,8 +1,15 @@
-from ..base.control_base import ControlNodeBase
+import os
+import sys
 import time
 import numpy as np
 import cv2
 import torch
+import random
+
+# Add package root to Python path
+sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+from base.control_base import ControlNodeBase
+from controls.similar_image_filter import SimilarImageFilter
 
 class FPSMonitor(ControlNodeBase):
     """Generates an FPS overlay as an image and mask"""
@@ -121,3 +128,154 @@ def update(self, width: int, height: int, text_color: int, text_size: float, win
         self.set_state(state)
 
         return (state["cached_image"], state["cached_mask"])
+
+class SimilarityFilter(ControlNodeBase):
+    DESCRIPTION = "Filters out similar consecutive images and outputs a signal to control downstream execution."
+    
+    @classmethod
+    def INPUT_TYPES(s):
+        return {
+            "required": {
+                "image": ("IMAGE", {
+                    "tooltip": "Input image to compare with previous frame"
+                }),
+                "always_execute": ("BOOLEAN", {
+                    "default": False,
+                }),
+                "threshold": ("FLOAT", {
+                    "default": 0.98,
+                    "min": 0.0,
+                    "max": 1.0,
+                    "step": 0.01,
+                    "tooltip": "Similarity threshold (0-1). Higher values mean more frames are considered similar"
+                }),
+                "max_skip_frames": ("INT", {
+                    "default": 10,
+                    "min": 1,
+                    "max": 100,
+                    "step": 1,
+                    "tooltip": "Maximum number of consecutive frames to skip before forcing execution"
+                }),
+            }
+        }
+    
+    RETURN_TYPES = ("IMAGE", "BOOLEAN")
+    RETURN_NAMES = ("image", "should_execute")
+    FUNCTION = "update"
+    CATEGORY = "real-time/control/utility"
+
+    def __init__(self):
+        super().__init__()
+        self._similarity_filter = SimilarImageFilter()
+
+    def update(self, image, threshold=0.98, max_skip_frames=10, always_execute=False):
+        print(f"[DEBUG] Input image object: {hex(id(image))}, shape: {image.shape}, device: {image.device}")
+        
+        # Get state with defaults
+        state = self.get_state({
+            "prev_image": None,
+            "skip_count": 0
+        })
+
+        # First frame case
+        if state["prev_image"] is None:
+            state["prev_image"] = image.detach().clone()
+            state["skip_count"] = 0
+            self.set_state(state)
+            return (image, True)  # Always execute first frame
+
+        # Update filter parameters
+        self._similarity_filter.set_threshold(threshold)
+        self._similarity_filter.set_max_skip_frame(max_skip_frames)
+        
+        # Use filter to check similarity
+        result = self._similarity_filter(image)
+        should_execute = result is not None
+
+        # If we should skip (probability check)
+        if not should_execute:
+            # Check if we've skipped too many frames
+            if state["skip_count"] >= max_skip_frames:
+                state["prev_image"] = image.detach().clone()
+                state["skip_count"] = 0
+                self.set_state(state)
+                return (image, True)  # Force execution after max skips
+                
+            # Skip frame - return previous image and False for execution
+            state["skip_count"] += 1
+            self.set_state(state)
+            return (state["prev_image"], False)
+
+        # Frame is different enough - process it
+        state["prev_image"] = image.detach().clone()
+        state["skip_count"] = 0
+        self.set_state(state)
+        return (image, True)
+
+class AlwaysEqualProxy(str):
+    #borrowed from https://github.com/theUpsider/ComfyUI-Logic
+    def __eq__(self, _):
+        return True
+
+    def __ne__(self, _):
+        return False
+
+class LazyCondition(ControlNodeBase):
+    DESCRIPTION = "Uses lazy evaluation to truly skip execution of unused paths. Maintains state of the last value to circumvent feedback loops."
+    
+    @classmethod
+    def INPUT_TYPES(s):
+        return {
+            "required": {
+                "condition": (AlwaysEqualProxy("*"), {
+                    "tooltip": "When truthy (non-zero, non-empty, non-None), evaluates and returns if_true path. When falsy, returns either fallback or previous state of if_true.",
+                    "forceInput": True,
+                }),
+                "if_true": (AlwaysEqualProxy("*"), {
+                    "lazy": True,
+                    "tooltip": "The path that should only be evaluated when condition is truthy"
+                }),
+                "fallback": (AlwaysEqualProxy("*"), {
+                    "tooltip": "Alternative value to use when condition is falsy or no previous state of if_true"
+                }),
+                "use_fallback": ("BOOLEAN", {
+                    "default": False,
+                    "tooltip": "When False, uses last successful if_true result (if one exists). When True, uses fallback value"
+                }),
+            }
+        }
+    
+    RETURN_TYPES = (AlwaysEqualProxy("*"),)
+    FUNCTION = "update"
+    CATEGORY = "real-time/control/utility"
+
+    def check_lazy_status(self, condition, if_true, fallback, use_fallback):
+        """Only evaluate the if_true path if condition is truthy."""
+        needed = ["fallback"]  # Always need the fallback value
+        if condition:
+            needed.append("if_true")
+        return needed
+
+    def update(self, condition, if_true, fallback, use_fallback):
+        """Route to either if_true output or fallback value, maintaining state of last if_true."""
+        state = self.get_state({
+            "prev_output": None
+        })
+
+        if condition:  # Let Python handle truthiness
+            # Update last state when we run if_true path
+            state["prev_output"] = if_true if if_true is not None else fallback
+            if hasattr(if_true, 'detach'):
+                state["prev_output"] = if_true.detach().clone()
+            self.set_state(state)
+            return (if_true,)
+        else:
+            if use_fallback or state["prev_output"] is None:
+                return (fallback,)
+            else:
+                return (state["prev_output"],)
+
+
+
+
+