diff --git a/.DS_Store b/.DS_Store index d568d1d..3dfb035 100644 Binary files a/.DS_Store and b/.DS_Store differ diff --git a/__init__.py b/__init__.py index 0513b52..f72c555 100644 --- a/__init__.py +++ b/__init__.py @@ -97,6 +97,7 @@ from .nodes.FL_SceneCut import FL_SceneCut from .nodes.FL_GeminiTextAPI import FL_GeminiTextAPI from .nodes.FL_JS import FL_JS from .nodes.FL_HFDatasetDownloader import FL_HFDatasetDownloader +from .nodes.FL_WF_Agent import FL_WF_Agent NODE_CLASS_MAPPINGS = { @@ -200,6 +201,7 @@ NODE_CLASS_MAPPINGS = { "FL_GeminiTextAPI": FL_GeminiTextAPI, "FL_JS": FL_JS, "FL_HFDatasetDownloader": FL_HFDatasetDownloader, + "FL_WF_Agent": FL_WF_Agent, } @@ -304,6 +306,7 @@ NODE_DISPLAY_NAME_MAPPINGS = { "FL_GeminiTextAPI": "FL Gemini Text API", "FL_JS": "FL JavaScript", "FL_HFDatasetDownloader": "FL HF Dataset Downloader", + "FL_WF_Agent": "FL Workflow Agent", } diff --git a/nodes/FL_Dalle3.py b/nodes/FL_Dalle3.py index 4102885..6dabbdc 100644 --- a/nodes/FL_Dalle3.py +++ b/nodes/FL_Dalle3.py @@ -15,7 +15,7 @@ class FL_Dalle3: def __init__(self): self.__client = openai.AsyncOpenAI() self.__previous_params = None - self.__cache_images = None + self.__cache_images = Nonee self.__cache_revised_prompts = None @classmethod diff --git a/nodes/FL_WF_Agent.py b/nodes/FL_WF_Agent.py new file mode 100644 index 0000000..ca8d7a8 --- /dev/null +++ b/nodes/FL_WF_Agent.py @@ -0,0 +1,123 @@ +import os +import sys +import subprocess +from .scanner import NodeScanner + +class FL_WF_Agent: + """ + A node that uses Gemini AI to generate and execute JavaScript code for workflow manipulation + """ + def __init__(self): + # Initialize scanner + self.scanner = NodeScanner(os.path.dirname(os.path.dirname(os.path.dirname(__file__)))) + print("FL_WF_Agent: Scanner initialized") + + # Automatically run the scanner once at startup to ensure cache file exists + try: + print("FL_WF_Agent: Running initial node scan to create cache...") + self.scanner.scan_nodes() + print("FL_WF_Agent: Initial node scan completed") + except Exception as e: + print(f"FL_WF_Agent: Error during initial scan: {str(e)}") + + @classmethod + def INPUT_TYPES(cls): + return { + "required": { + "event": (["before_queued", "after_queued", "status", "progress", "executing", + "executed", "execution_start", "execution_error", "execution_success", + "execution_cached"], {"default": "before_queued"}), + "code_prompt": ("STRING", {"multiline": True, "default": "Enter your code generation prompt here"}), + "api_key": ("STRING", {"default": ""}), + "javascript": ("STRING", {"default": "// Generated code will appear here", "multiline": True}), + }, + "optional": { + "scan_nodes": ("BOOLEAN", {"default": False}), + } + } + + RETURN_TYPES = () + FUNCTION = "exec_entrypoint" + OUTPUT_NODE = True + CATEGORY = "Fill-Nodes" + + def exec_entrypoint(self, event, code_prompt, api_key, javascript, scan_nodes=False): + try: + if scan_nodes: + print("\nFL_WF_Agent: Starting scanner execution...") + + # Get absolute path to scanner.py + scanner_path = os.path.join(os.path.dirname(os.path.abspath(__file__)), "scanner.py") + print(f"Scanner path: {scanner_path}") + + # Get cache directory and expected file path for the node definitions + cache_dir = os.path.join(os.path.dirname(os.path.dirname(os.path.abspath(__file__))), 'web', 'nodes') + cache_file = os.path.join(cache_dir, 'node_definitions.txt') + + print(f"Expected cache directory: {cache_dir}") + print(f"Expected cache file: {cache_file}") + print(f"Cache directory exists: {os.path.exists(cache_dir)}") + print(f"Cache file exists before scan: {os.path.exists(cache_file)}") + + # Execute scanner.py as subprocess with proper Python interpreter + process = subprocess.Popen( + [sys.executable, scanner_path], + stdout=subprocess.PIPE, + stderr=subprocess.PIPE, + text=True # Get string output instead of bytes + ) + + stdout, stderr = process.communicate() + + # Check if file exists after scan + print(f"Cache file exists after scan: {os.path.exists(cache_file)}") + if os.path.exists(cache_file): + print(f"Cache file size: {os.path.getsize(cache_file)} bytes") + print(f"Cache file absolute path: {os.path.abspath(cache_file)}") + # Get the first few lines to confirm content + try: + with open(cache_file, 'r') as f: + first_lines = [next(f) for _ in range(5)] + print(f"First few lines of cache file: {first_lines}") + except Exception as e: + print(f"Error reading cache file: {str(e)}") + + if process.returncode == 0: + print("Scanner completed successfully") + scan_feedback = { + "success": True, + "message": "Node scan completed successfully!", + "stdout": stdout, + "cache_path": os.path.abspath(cache_file), + "cache_exists": os.path.exists(cache_file), + "cache_size": os.path.getsize(cache_file) if os.path.exists(cache_file) else 0 + } + else: + print(f"Scanner failed with return code: {process.returncode}") + scan_feedback = { + "success": False, + "message": f"Scan failed with error: {stderr}", + "stderr": stderr, + "cache_path": os.path.abspath(cache_file) if os.path.exists(cache_file) else "N/A", + "cache_exists": os.path.exists(cache_file) + } + + # Print all output for debugging + print("\nScanner stdout:") + print(stdout) + if stderr: + print("\nScanner stderr:") + print(stderr) + + return {"ui": {"scan_feedback": scan_feedback}} + + return () + + except Exception as e: + import traceback + print(f"FL_WF_Agent ERROR: {str(e)}") + print(f"Traceback:\n{traceback.format_exc()}") + return {"ui": {"scan_feedback": { + "success": False, + "message": f"Scan failed: {str(e)}" + }}} \ No newline at end of file diff --git a/nodes/scanner.py b/nodes/scanner.py new file mode 100644 index 0000000..28e1415 --- /dev/null +++ b/nodes/scanner.py @@ -0,0 +1,589 @@ +import os +import sys +import json +import inspect +import importlib.util +import time +from pathlib import Path + +class NodeScanner: + def __init__(self, comfy_path): + self.comfy_path = os.path.abspath(comfy_path) + if self.comfy_path not in sys.path: + sys.path.append(self.comfy_path) + + # Get the directory containing this script + self.base_dir = os.path.dirname(os.path.dirname(os.path.abspath(__file__))) + + # Set up cache directory paths + self.cache_dir = os.path.join(self.base_dir, 'web', 'nodes') + self.cache_file = os.path.join(self.cache_dir, 'node_definitions.txt') + + print(f"\nScanner initialized with:") + print(f"Base directory: {self.base_dir}") + print(f"Cache directory: {self.cache_dir}") + print(f"Cache file: {self.cache_file}") + + self.ensure_cache_dir() + + def ensure_cache_dir(self): + try: + # First ensure the web directory exists + web_dir = os.path.join(self.base_dir, 'web') + if not os.path.exists(web_dir): + os.makedirs(web_dir) + print(f"Created web directory: {web_dir}") + + # Then create the nodes directory + if not os.path.exists(self.cache_dir): + os.makedirs(self.cache_dir) + print(f"Created cache directory: {self.cache_dir}") + + # Test if we can write to the cache directory + test_file = os.path.join(self.cache_dir, 'test_write.tmp') + with open(test_file, 'w') as f: + f.write('test') + os.remove(test_file) + print(f"Cache directory is writable: {self.cache_dir}") + + return True + except Exception as e: + print(f"ERROR: Failed to create directory structure:") + print(f" - {str(e)}") + print(f" - Base dir exists: {os.path.exists(self.base_dir)}") + print(f" - Web dir exists: {os.path.exists(web_dir if 'web_dir' in locals() else 'N/A')}") + print(f" - Cache dir exists: {os.path.exists(self.cache_dir)}") + print(f" - Have write permission: {os.access(self.base_dir, os.W_OK)}") + print(f" - Current working directory: {os.getcwd()}") + return False + + def scan_nodes(self): + if not os.path.exists(self.comfy_path): + print(f"ERROR: ComfyUI path does not exist: {self.comfy_path}") + return {} + + try: + nodes = {} + total_found = 0 + custom_nodes_path = os.path.join(self.comfy_path, 'custom_nodes') + + if not os.path.exists(custom_nodes_path): + print(f"ERROR: Custom nodes directory not found: {custom_nodes_path}") + return {} + + print(f"\nScanning custom nodes in: {custom_nodes_path}") + + for root, dirs, files in os.walk(custom_nodes_path): + # Skip scanning ourselves and unwanted directories + if 'scanner.py' in files: + files.remove('scanner.py') + dirs[:] = [d for d in dirs if d not in {'__pycache__', '.git', 'web'}] + + for file in files: + if file.endswith('.py'): + try: + found_nodes = self.extract_node_info(os.path.join(root, file)) + if found_nodes: + nodes.update(found_nodes) + total_found += len(found_nodes) + print(f"Found {len(found_nodes)} nodes in {file}") + except Exception as e: + if not str(e).startswith("No module named"): + print(f"Error processing {file}: {str(e)}") + + print(f"\nScan complete. Found {total_found} nodes.") + if nodes and self.ensure_cache_dir(): + self.cache_definitions(nodes) + return nodes + + except Exception as e: + print(f"ERROR during scanning: {str(e)}") + return {} + + def extract_node_info(self, file_path): + """Extract node information by reading the file as text""" + try: + with open(file_path, 'r', encoding='utf-8') as f: + content = f.read() + + # Extract basic node info without importing + nodes = {} + + # Look for NODE_CLASS_MAPPINGS + if 'NODE_CLASS_MAPPINGS' in content: + # Find class definitions + class_blocks = content.split('class ')[1:] + + for block in class_blocks: + try: + # Get class name + class_name = block.split('(')[0].strip() + + # Extract category if exists + category = 'Unknown' + if 'CATEGORY' in block: + category_line = [l for l in block.split('\n') if 'CATEGORY' in l] + if category_line: + category = category_line[0].split('=')[1].strip().strip('"\'') + + # Extract docstring if exists + description = None + if '"""' in block or "'''" in block: + doc_start = block.find('"""') if '"""' in block else block.find("'''") + if doc_start > -1: + doc_end = block.find('"""', doc_start + 3) if '"""' in block else block.find("'''", doc_start + 3) + if doc_end > -1: + description = block[doc_start+3:doc_end].strip() + + nodes[class_name] = { + 'name': class_name, + 'category': category, + 'description': description, + 'inputs': self.extract_input_types_from_text(block), + 'outputs': self.extract_output_types_from_text(block) + } + except Exception as e: + print(f"Error parsing class in {os.path.basename(file_path)}: {str(e)}") + continue + + return nodes + + except Exception as e: + print(f"Error reading {os.path.basename(file_path)}: {str(e)}") + return None + + def get_input_types(self, node_class): + """Extract input types from node class""" + try: + if hasattr(node_class, 'INPUT_TYPES'): + if inspect.ismethod(node_class.INPUT_TYPES): + input_types = node_class.INPUT_TYPES() + else: + input_types = node_class.INPUT_TYPES + return input_types + except Exception as e: + print(f"ERROR getting input types: {str(e)}") + return {} + + def extract_input_types_from_text(self, class_text): + """Extract input types from class text with improved parsing""" + inputs = {'required': {}, 'optional': {}} + + if 'INPUT_TYPES' in class_text: + try: + # Find the INPUT_TYPES block + input_block = "" + start = class_text.find('INPUT_TYPES') + block_start = class_text.find('{', start) + + if block_start > -1: + # Count braces to find matching end + brace_count = 1 + pos = block_start + 1 + + while brace_count > 0 and pos < len(class_text): + if class_text[pos] == '{': + brace_count += 1 + elif class_text[pos] == '}': + brace_count -= 1 + pos += 1 + + input_block = class_text[block_start:pos] + + # Parse required inputs + if '"required"' in input_block or "'required'" in input_block: + req_section = self._extract_section(input_block, 'required') + inputs['required'] = self._parse_input_section(req_section) + + # Parse optional inputs + if '"optional"' in input_block or "'optional'" in input_block: + opt_section = self._extract_section(input_block, 'optional') + inputs['optional'] = self._parse_input_section(opt_section) + + except Exception as e: + print(f"Error parsing INPUT_TYPES: {str(e)}") + + return inputs + + def _extract_section(self, text, section_name): + """Helper to extract a section (required/optional) from INPUT_TYPES text""" + try: + start = text.find(f'"{section_name}"') + if start == -1: + start = text.find(f"'{section_name}'") + + if start > -1: + start = text.find('{', start) + if start > -1: + brace_count = 1 + pos = start + 1 + + while brace_count > 0 and pos < len(text): + if text[pos] == '{': + brace_count += 1 + elif text[pos] == '}': + brace_count -= 1 + pos += 1 + + return text[start:pos] + except Exception as e: + print(f"Error extracting section {section_name}: {str(e)}") + return "" + + def _parse_input_section(self, section_text): + """Helper to parse individual input definitions""" + inputs = {} + + try: + # Split into lines and clean up + lines = section_text.split('\n') + for line in lines: + line = line.strip() + if ':' in line and ('(' in line or '[' in line or '"' in line or "'" in line): + # Extract name + name = line.split(':')[0].strip().strip('"\'') + + # Extract type info + type_info = [] + + # Look for common patterns + if '(' in line: # Tuple/list definitions + start = line.find('(') + end = line.find(')', start) + if end > start: + types = line[start+1:end].split(',') + type_info = [t.strip().strip('"\'') for t in types if t.strip()] + + elif '[' in line: # List definitions + start = line.find('[') + end = line.find(']', start) + if end > start: + types = line[start+1:end].split(',') + type_info = [t.strip().strip('"\'') for t in types if t.strip()] + + elif '"' in line or "'" in line: # Simple string definitions + parts = line.split(':')[1].split(',')[0].strip() + if parts: + type_info = [parts.strip().strip('"\'')] + + if name and type_info: + inputs[name] = type_info + + except Exception as e: + print(f"Error parsing input section: {str(e)}") + + return inputs + + def extract_output_types_from_text(self, class_text): + """Extract output types from class text""" + outputs = { + 'return_types': (), + 'return_names': None + } + + try: + # Find RETURN_TYPES + if 'RETURN_TYPES' in class_text: + start = class_text.find('RETURN_TYPES') + end = class_text.find('\n', start) + if end > start: + types_text = class_text[start:end] + if '=' in types_text: + types_str = types_text.split('=')[1].strip().strip('()') + outputs['return_types'] = tuple(t.strip().strip('"\'') for t in types_str.split(',') if t.strip()) + + # Find RETURN_NAMES + if 'RETURN_NAMES' in class_text: + start = class_text.find('RETURN_NAMES') + end = class_text.find('\n', start) + if end > start: + names_text = class_text[start:end] + if '=' in names_text: + names_str = names_text.split('=')[1].strip().strip('()') + outputs['return_names'] = tuple(n.strip().strip('"\'') for n in names_str.split(',') if n.strip()) + + except Exception as e: + print(f"Error parsing output types: {str(e)}") + + return outputs + + def cache_definitions(self, definitions): + if not definitions: + print("No definitions to cache - skipping cache write") + return False + + print(f"\nWriting cache file to: {self.cache_file}") + try: + # Ensure parent directories exist + os.makedirs(os.path.dirname(self.cache_file), exist_ok=True) + + # Convert to text format + content = [] + for node_name, info in definitions.items(): + # Node header + content.append(f"Node: {node_name}") + content.append(f"Category: {info['category']}") + if info.get('description'): + content.append(f"Description: {info['description']}") + + # Inputs + content.append("Inputs:") + if 'required' in info['inputs']: + content.append(" Required:") + for name, types in info['inputs']['required'].items(): + content.append(f" - {name}: {', '.join(types)}") + if 'optional' in info['inputs']: + content.append(" Optional:") + for name, types in info['inputs']['optional'].items(): + content.append(f" - {name}: {', '.join(types)}") + + # Outputs + content.append("Outputs:") + return_types = info['outputs']['return_types'] + return_names = info['outputs']['return_names'] + if return_names: + for t, n in zip(return_types, return_names): + content.append(f" - {n} ({t})") + else: + for t in return_types: + content.append(f" - {t}") + + content.append("-" * 50) # Separator between nodes + + # Write to temporary file first + temp_file = self.cache_file + '.tmp' + with open(temp_file, 'w', encoding='utf-8') as f: + f.write('\n'.join(content)) + f.flush() + os.fsync(f.fileno()) + + print(f"Temp file written: {temp_file}") + print(f"Temp file exists: {os.path.exists(temp_file)}") + print(f"Temp file size: {os.path.getsize(temp_file) if os.path.exists(temp_file) else 0}") + + # Safely move the temp file to final location + if os.path.exists(self.cache_file): + backup_file = self.cache_file + '.bak' + if os.path.exists(backup_file): + os.remove(backup_file) + os.rename(self.cache_file, backup_file) + print(f"Created backup file: {backup_file}") + + # Move temp file to final location + os.rename(temp_file, self.cache_file) + + # Verify the file was created + if not os.path.exists(self.cache_file): + raise Exception(f"File was not created at {self.cache_file}") + + # Try to open and read the file to verify it's accessible + try: + with open(self.cache_file, 'r', encoding='utf-8') as f: + test_content = f.read(100) # Read first 100 chars as a test + print(f"File is readable. First 100 chars: {test_content[:100]}") + except Exception as e: + print(f"WARNING: File created but couldn't be read: {str(e)}") + + # Check server path + comfy_dir = os.path.dirname(os.path.dirname(os.path.dirname(self.base_dir))) + print(f"ComfyUI root directory: {comfy_dir}") + + # Generate the URL path that browsers would use + relative_path = os.path.relpath(self.cache_file, comfy_dir) + url_path = '/' + relative_path.replace('\\', '/') + print(f"Relative web path for browser access: {url_path}") + + size = os.path.getsize(self.cache_file) + print(f"Cache written successfully ({size:,} bytes)") + print(f"Cache file absolute path: {os.path.abspath(self.cache_file)}") + return True + + except Exception as e: + print(f"ERROR: Failed to write cache: {str(e)}") + # Print more diagnostic information + print(f" - Temp file exists: {os.path.exists(temp_file if 'temp_file' in locals() else 'N/A')}") + print(f" - Cache dir exists: {os.path.exists(os.path.dirname(self.cache_file))}") + print(f" - Current working directory: {os.getcwd()}") + print(f" - Permission to write: {os.access(os.path.dirname(self.cache_file), os.W_OK)}") + + if 'temp_file' in locals() and os.path.exists(temp_file): + try: + os.remove(temp_file) + except: + pass + return False + + def node_to_compact_format(self, node_name, info): + """Convert node info to compact format""" + lines = [] + + # Node name and category + lines.append(f"#N {node_name} #C {info['category']}") + + # Inputs + input_parts = [] + if 'required' in info['inputs']: + for name, types in info['inputs']['required'].items(): + input_parts.append(f"{name}:{','.join(types)}") + if 'optional' in info['inputs']: + for name, types in info['inputs']['optional'].items(): + input_parts.append(f"{name}:{','.join(types)}?") + if input_parts: + lines.append(f"#I {' '.join(input_parts)}") + + # Outputs + if info['outputs']['return_types']: + out_types = ','.join(info['outputs']['return_types']) + if info['outputs']['return_names']: + out_names = ','.join(info['outputs']['return_names']) + lines.append(f"#O {out_types} #N {out_names}") + else: + lines.append(f"#O {out_types}") + + # Description + if info.get('description'): + lines.append(f"#D {info['description']}") + + lines.append("---") + return '\n'.join(lines) + + def parse_compact_format(self, content): + """Parse compact format back into node definitions""" + definitions = {} + current_node = None + current_info = {} + + for line in content.split('\n'): + line = line.strip() + if not line or line == '---': + if current_node: + definitions[current_node] = current_info + current_node = None + current_info = {} + continue + + parts = line.split() + if line.startswith('#N') and '#C' in line: + # Node name and category + name_idx = line.index('#C') + current_node = ' '.join(parts[1:name_idx]).strip() + current_info['category'] = ' '.join(parts[name_idx+1:]).strip() + current_info['inputs'] = {'required': {}, 'optional': {}} + current_info['outputs'] = {'return_types': (), 'return_names': None} + + elif line.startswith('#I'): + # Inputs + for input_def in ' '.join(parts[1:]).split(): + name, type_info = input_def.split(':') + if type_info.endswith('?'): + # Optional input + type_info = type_info[:-1] + current_info['inputs']['optional'][name] = type_info.split(',') + else: + # Required input + current_info['inputs']['required'][name] = type_info.split(',') + + elif line.startswith('#O'): + # Outputs + if '#N' in line: + # Has named outputs + type_idx = line.index('#N') + types = ' '.join(parts[1:type_idx]).strip().split(',') + names = ' '.join(parts[type_idx+1:]).strip().split(',') + current_info['outputs']['return_types'] = tuple(types) + current_info['outputs']['return_names'] = tuple(names) + else: + # Just types + current_info['outputs']['return_types'] = tuple(parts[1].split(',')) + + elif line.startswith('#D'): + # Description + current_info['description'] = ' '.join(parts[1:]) + + return definitions + + def load_cache(self): + """Load cached node definitions from compact format""" + try: + if os.path.exists(self.cache_file): + with open(self.cache_file, 'r') as f: + return json.load(f) + except Exception as e: + print(f"Error loading cache: {str(e)}") + return None + + def is_cache_valid(self, max_age_hours=24): + """Check if cache is valid based on age""" + cache_data = self.load_cache() + if not cache_data: + return False + + cache_age = time.time() - cache_data['timestamp'] + return cache_age < (max_age_hours * 3600) + + def get_nodes_for_llm(self): + """Get node definitions in LLM-friendly format""" + cache_data = self.load_cache() + if not cache_data: + return "No node definitions available." + + llm_text = "Available Custom Nodes:\n\n" + for name, info in cache_data['definitions'].items(): + llm_text += f"Node: {name}\n" + if info['description']: + llm_text += f"Description: {info['description']}\n" + llm_text += f"Category: {info['category']}\n" + + # Inputs + llm_text += "Inputs:\n" + if 'required' in info['inputs']: + for input_name, input_info in info['inputs']['required'].items(): + llm_text += f" - {input_name} ({input_info[0]})\n" + if 'optional' in info['inputs']: + for input_name, input_info in info['inputs']['optional'].items(): + llm_text += f" - {input_name} ({input_info[0]}) [Optional]\n" + + # Outputs + llm_text += "Outputs:\n" + return_types = info['outputs']['return_types'] + return_names = info['outputs']['return_names'] + if return_names: + for i, (t, n) in enumerate(zip(return_types, return_names)): + llm_text += f" - {n} ({t})\n" + else: + for t in return_types: + llm_text += f" - {t}\n" + + llm_text += "\n" + + return llm_text + + +if __name__ == "__main__": + try: + # Get ComfyUI path from command line or use default parent directory + default_path = os.path.dirname(os.path.dirname(os.path.dirname(os.path.dirname(__file__)))) + comfy_path = sys.argv[1] if len(sys.argv) > 1 else default_path + + print(f"\n=== NodeScanner CLI ===") + print(f"├── ComfyUI path: {comfy_path}") + + scanner = NodeScanner(comfy_path) + print("├── Starting node scan...") + + results = scanner.scan_nodes() + + if results: + print(f"└── Found {len(results)} nodes") + print("\nNode Summary:") + for node_name, info in results.items(): + print(f"├── Node: {node_name}") + print(f"│ ├── Category: {info['category']}") + if info.get('description'): + print(f"│ └── Description: {info['description']}") + else: + print("└── No nodes were found or errors occurred during scanning") + + except Exception as e: + print(f"\nERROR: Script failed with error: {str(e)}") + sys.exit(1) \ No newline at end of file diff --git a/web/.DS_Store b/web/.DS_Store new file mode 100644 index 0000000..b2d52db Binary files /dev/null and b/web/.DS_Store differ diff --git a/web/nodes/fl_wf_agent.js b/web/nodes/fl_wf_agent.js new file mode 100644 index 0000000..b07f640 --- /dev/null +++ b/web/nodes/fl_wf_agent.js @@ -0,0 +1,1212 @@ +import { app } from "../../../scripts/app.js"; +import { api } from "../../../scripts/api.js"; + +const GEMINI_BASE_URL = 'https://generativelanguage.googleapis.com'; +const GEMINI_API_VERSION = 'v1'; +const GEMINI_MODEL = 'gemini-2.0-flash'; +const SYSTEM_PROMPT = `You are a JavaScript code generator for ComfyUI workflow automation. + +Your task is to generate code based on the user's prompt that utilizes the available workflow manipulation functions. +Only return the JavaScript code itself, no explanations or additional text DO NOT HAVE mark down astrics around the code. ONLY +respond with the raw text of the code. +Focus on creating clean, efficient code that accomplishes the requested workflow automation. + +Available functions and capabilities: +- Node Management: find(), findLast(), create(), remove(), bypass(), unbypass(), pin(), unpin() +- Connection Management: connect(), getValues(), setValues() +- Layout Management: putOnLeft(), putOnRight(), putOnTop(), putOnBottom(), moveToRight(), moveToBottom() +- Workflow Control: generate(), cancel(), enableAutoQueue(), disableAutoQueue(), setBatchCount() +- System Control: enableSleep(), disableSleep(), enableScreenSaver(), disableScreenSaver(), sendImages() + +When generating code: +1. Use proper error handling where appropriate +2. Leverage the provided utility functions +3. Keep the code concise but readable +4. Focus on achieving the specific workflow automation goal +5. Consider edge cases and validation + +Remember: Only output the JavaScript code itself - no explanations, comments or additional text unless they are code comments. + +Here is an example of how to structure the code. The user prompt for this example was "make the basic comfy workflow that builds itself slowly, that deletes +itself. + +// Animation Timing +const CREATE_DELAY = 100; // Delay between creating nodes (ms) +const DELETE_DELAY = 100; // Delay between deleting nodes (ms) +const PAUSE_DELAY = 100; // Pause before dismantling (ms) + +// Node Positioning +const START_X = 100; // Starting X position +const START_Y = 100; // Starting Y position +const SPACING_X = 400; // Horizontal spacing between nodes +const SPACING_Y = 250; // Vertical spacing (for neg prompt) + +// Generation Parameters +const CHECKPOINT = "v1-5-pruned.ckpt"; +const POSITIVE_PROMPT = "beautiful landscape, mountains, lake, sunset"; +const NEGATIVE_PROMPT = "blur, haze, ugly, text"; +const STEPS = 20; +const CFG = 7; +const SAMPLER = "euler"; +const WIDTH = 512; +const HEIGHT = 512; +const BATCH_SIZE = 1; + +async function sleep(ms) { + return new Promise(resolve => setTimeout(resolve, ms)); +} + +async function buildAndDestroyWorkflow() { + const nodes = []; + + // Create Checkpoint Loader + const checkpoint = create("CheckpointLoaderSimple", { + ckpt_name: CHECKPOINT + }); + checkpoint.pos[0] = START_X; + checkpoint.pos[1] = START_Y; + nodes.push(checkpoint); + await sleep(CREATE_DELAY); + + // Create Positive CLIP + const clipPos = create("CLIPTextEncode", { + text: POSITIVE_PROMPT + }); + clipPos.pos[0] = START_X + SPACING_X; + clipPos.pos[1] = START_Y; + connect(checkpoint, "CLIP", clipPos, "clip"); + nodes.push(clipPos); + await sleep(CREATE_DELAY); + + // Create Negative CLIP + const clipNeg = create("CLIPTextEncode", { + text: NEGATIVE_PROMPT + }); + clipNeg.pos[0] = START_X + SPACING_X; + clipNeg.pos[1] = START_Y + SPACING_Y; + connect(checkpoint, "CLIP", clipNeg, "clip"); + nodes.push(clipNeg); + await sleep(CREATE_DELAY); + + // Create KSampler + const sampler = create("KSampler", { + steps: STEPS, + cfg: CFG, + sampler_name: SAMPLER, + scheduler: "normal", + denoise: 1, + seed: generateSeed() + }); + sampler.pos[0] = START_X + SPACING_X * 2; + sampler.pos[1] = START_Y; + connect(checkpoint, "MODEL", sampler, "model"); + connect(clipPos, "CONDITIONING", sampler, "positive"); + connect(clipNeg, "CONDITIONING", sampler, "negative"); + nodes.push(sampler); + await sleep(CREATE_DELAY); + + // Create VAE Decode + const vae = create("VAEDecode", {}); + vae.pos[0] = START_X + SPACING_X * 3; + vae.pos[1] = START_Y; + connect(checkpoint, "VAE", vae, "vae"); + connect(sampler, "LATENT", vae, "samples"); + nodes.push(vae); + await sleep(CREATE_DELAY); + + // Create Save Image + const save = create("SaveImage", { + filename_prefix: "ComfyUI" + }); + save.pos[0] = START_X + SPACING_X * 4; + save.pos[1] = START_Y; + connect(vae, "IMAGE", save, "images"); + nodes.push(save); + await sleep(CREATE_DELAY); + + // Pause before dismantling + await sleep(PAUSE_DELAY); + + // Remove nodes in sequence + for (const node of nodes) { + remove(node); + await sleep(DELETE_DELAY); + } +} + +// Execute the workflow +buildAndDestroyWorkflow(); + + +ONLY respond with raw text. do not use any markdown ticks or reply with anything else other than the code itself. again, i need the code +as raw text + +When creating nodes in the code, always ensure that you put a 100ms to help the user visually understand whats happening when they click exdcute +`; + + + + + +const MIN_SEED = 0; +const MAX_SEED = parseInt("0xffffffffffffffff", 16); +const STEPS_OF_SEED = 10; +const DEFAULT_MARGIN_X = 32; +const DEFAULT_MARGIN_Y = 64; +let SLEEP = true; + +function getNodes(type) { + return app.graph._nodes.filter(e => e.comfyClass === "FL_WF_Agent" && + e.widgets?.find(e => e.name === "event")?.value === type); +} + +function execNodes(type, args) { + const nodes = getNodes(type); + for (const node of nodes) { + execNode(node, args); + } +} + +function execNode(node, args) { + try { + if (!node.__eventHandler__) { + node.__eventHandler__ = {}; + } + if (!node.properties) { + node.properties = {}; + } + if (!node.properties.__eventHandler__) { + node.properties.__eventHandler__ = {}; + } + + const SELF = node; + const COMMAND = node.widgets?.find(e => e.name === "javascript")?.value; + const STATE = node.__eventHandler__; + const PROPS = node.properties.__eventHandler__; + const NODES = app.graph._nodes; + const LINKS = app.graph.links; + const ARGS = args ?? []; + + const DATE = new Date(); + const YEAR = DATE.getFullYear(); + const MONTH = DATE.getMonth() + 1; + const DAY = DATE.getDay(); + const HOURS = DATE.getHours(); + const MINUTES = DATE.getMinutes(); + const SECONDS = DATE.getSeconds(); + + const BATCH_COUNT = getBatchCount(); + const QUEUE_MODE = getQueueMode(); + const AUTO_QUEUE = getQueueMode() !== "disabled"; + + const create = (className, values, options) => createNode.apply(node, [className, values, options]); + + eval(COMMAND); + } catch(err) { + console.error(err); + } +} + +function getDefaultCommand() { + const nodes = app.graph._nodes + .filter(e => e && e.comfyClass !== "FL_WF_Agent") + .sort((a, b) => a.id - b.id); + + let text = ""; + for (const node of nodes) { + const nodeId = node.id; + const nodeTitle = node.title; + text += `var n${nodeId} = find(${nodeId}); // ${nodeTitle}\n`; + } + text += `\n// You can use javascript code here!`; + text += `\n// COMMAND: string`; + text += `\n// STATE: `; + text += `\n// PROPS: `; + text += `\n// NODES: Node[]`; + text += `\n// LINKS: Link[]`; + text += `\n// ARGS: any[]`; + text += `\n// DATE: Date`; + text += `\n// YEAR: number`; + text += `\n// MONTH: number`; + text += `\n// DAY: number`; + text += `\n// HOURS: number`; + text += `\n// MINUTES: number`; + text += `\n// SECONDS: number`; + text += `\n// QUEUE_MODE: "disabled"|"instant"|"change"`; + text += `\n// AUTO_QUEUE: boolean`; + text += `\n// BATCH_COUNT: number`; + text += `\n// SLEEP: boolean`; + text += `\n`; + text += `\n// find(ID|TITLE|TYPE) => Node`; + text += `\n// findLast(ID|TITLE|TYPE) => Node`; + text += `\n// exec(...NODE)`; + text += `\n// getValues(NODE) => { key: value, ... }`; + text += `\n// setValues(NODE, { key: value, ... })`; + text += `\n// connect(OUTPUT_NODE, OUTPUT_SLOT_NAME, INPUT_NODE, INPUT_SLOT_NAME?)`; + text += `\n// create(TYPE, { key: value, ... }) => Node`; + text += `\n// generateSeed() => number`; + text += `\n// generateFloat(min, max) => number`; + text += `\n// generateInt(min, max) => number`; + text += `\n// random(...any[]) => any`; + text += `\n// bypass(...NODE)`; + text += `\n// unbypass(...NODE)`; + text += `\n// pin(...NODE)`; + text += `\n// unpin(...NODE)`; + text += `\n// remove(...NODE)`; + text += `\n// select(...NODE)`; + text += `\n// putOnLeft(NODE, TARGET_NODE)`; + text += `\n// putOnRight(NODE, TARGET_NODE)`; + text += `\n// putOnTop(NODE, TARGET_NODE)`; + text += `\n// putOnBottom(NODE, TARGET_NODE)`; + text += `\n// moveToRight(NODE)`; + text += `\n// moveToBottom(NODE)`; + text += `\n// getRect(NODE) => [x, y, width, height]`; + text += `\n// setRect(NODE, x?, y?, width?, height?)`; + text += `\n// generate() // Start generation.`; + text += `\n// cancel() // Cancel current generation.`; + text += `\n// enableAutoQueue()`; + text += `\n// disableAutoQueue()`; + text += `\n// setBatchCount(number)`; + text += `\n// disableSleep()`; + text += `\n// enableSleep()`; + text += `\n// disableScreenSaver()`; + text += `\n// enableScreenSaver()`; + text += `\n// sendImages(url, field, ...PREVIEW_NODE)`; + return text; +} + +function findNode(n) { + if (typeof n === "number") { + return find(n); + } else if (typeof n === "string") { + return find(n); + } else if (typeof n === "object") { + return n; + } +} + +function enableAutoQueue() { + return setQueueMode("instant"); +} + +function disableAutoQueue() { + return setQueueMode("disabled"); +} + +function exec(...nodes) { + nodes = nodes.map(findNode); + for (const node of nodes) { + node.exec(); + } +} + +function getQueueMode() { + return app.extensionManager.queueSettings.mode; +} + +function setQueueMode(v) { + if (typeof v === "boolean") { + app.extensionManager.queueSettings.mode = v ? "instant" : "disabled"; + } else { + app.extensionManager.queueSettings.mode = v; + } +} + +function getBatchCount() { + return app.extensionManager.queueSettings.batchCount; +} + +function setBatchCount(v) { + app.extensionManager.queueSettings.batchCount = v; +} + +const createNode = function(className, values, options) { + values = values ?? {}; + options = { select: true, shiftY: 0, before: false, ...(options || {}) }; + const node = LiteGraph.createNode(className); + if (!node) { + throw new Error(`${className} not found.`); + } + + if (node.widgets) { + for (const [key, value] of Object.entries(values)) { + const widget = node.widgets.find(e => e.name === key); + if (widget) { + widget.value = value; + } + } + } + + app.graph.add(node); + + if (options.select) { + app.canvas.selectNode(node, false); + } + + putOnRight(node, this); + moveToBottom(node); + + return node; +} + +// methods +const match = function(node, query) { + if (typeof query === "number") { + return node.id === query; + } else if (typeof query === "string") { + return node.title === query || node.comfyClass === query || node.type === query; + } else if (typeof query === "object") { + return node.id === query.id; + } else { + return false; + } +} + +const find = function(query) { + for (let i = 0; i < app.graph._nodes.length; i++) { + const n = app.graph._nodes[i]; + if (match(n, query)) { + return n; + } + } +} + +const findLast = function(query) { + for (let i = app.graph._nodes.length - 1; i >= 0; i--) { + const n = app.graph._nodes[i]; + if (match(n, query)) { + return n; + } + } +} + +const getValues = function(node) { + node = findNode(node); + let result = {}; + if (node.widgets) { + for (const widget of node.widgets) { + result[widget.name] = widget.value; + } + } + return result; +} + +const getValue = getValues; + +const setValues = function(node, values) { + node = findNode(node); + if (node.widgets) { + for (const [key, value] of Object.entries(values)) { + const widget = node.widgets.find(e => e.name === key); + if (widget) { + widget.value = value; + } + } + } +} + +const setValue = setValues; + +const connect = function(outputNode, outputName, inputNode, inputName) { + outputNode = findNode(outputNode); + inputNode = findNode(inputNode); + + if (!inputName) { + inputName = outputName; + } + + outputName = outputName.toUpperCase(); + inputName = inputName.toLowerCase(); + + let output = outputName ? outputNode.outputs?.find(e => e.name.toUpperCase() === outputName) : null; + let outputSlot; + let input = inputName ? inputNode.inputs?.find(e => e.name.toLowerCase() === inputName) : null; + let inputSlot; + + if (output) { + outputSlot = outputNode.findOutputSlot(output.name); + if (!input) { + input = inputNode.inputs?.find(e => e.type === output.type); + if (input) { + inputSlot = inputNode.findInputSlot(input.name); + } + } + } + + if (input) { + inputSlot = inputNode.findInputSlot(input.name); + if (!output) { + output = outputNode.outputs?.find(e => e.type === input.type); + if (output) { + outputSlot = outputNode.findOutputSlot(output.name); + } + } + } + + if (typeof inputSlot === "number" && typeof outputSlot === "number") { + outputNode.connect(outputSlot, inputNode.id, inputSlot); + } +} + +const generateFloat = function(min, max) { + if (typeof min !== "number") { + min = Number.MIN_SAFE_INTEGER; + } + if (typeof max !== "number") { + max = Number.MAX_SAFE_INTEGER; + } + return Math.random() * (max - min) + min; +} + +const generateInt = function(min, max) { + return Math.floor(generateFloat(min, max)); +} + +const generateSeed = function() { + let max = Math.min(1125899906842624, MAX_SEED); + let min = Math.max(-1125899906842624, MIN_SEED); + let range = (max - min) / (STEPS_OF_SEED / 10); + return Math.floor(Math.random() * range) * (STEPS_OF_SEED / 10) + min; +} + +const random = function(...args) { + return args[generateInt(0, args.length)]; +} + +const bypass = function(...nodes) { + nodes = nodes.map(findNode); + for (const node of nodes) { + node.mode = 4; + } +} + +const unbypass = function(...nodes) { + nodes = nodes.map(findNode); + for (const node of nodes) { + node.mode = 0; + } +} + +const pin = function(...nodes) { + nodes = nodes.map(findNode); + for (const node of nodes) { + node.pin(true); + } +} + +const unpin = function(...nodes) { + nodes = nodes.map(findNode); + for (const node of nodes) { + node.pin(false); + } +} + +const remove = function(...nodes) { + nodes = nodes.map(findNode); + for (const node of nodes) { + app.graph.remove(node); + } +} + +const select = function(...nodes) { + nodes = nodes.map(findNode); + app.canvas.deselectAllNodes(); + app.canvas.selectNodes(nodes); +} + +const generate = function() { + app.queuePrompt(0, getBatchCount()); +} + +const cancel = function() { + api.interrupt(); +} + +const putOnLeft = function(targetNode, anchorNode) { + targetNode = findNode(targetNode); + anchorNode = findNode(anchorNode); + targetNode.pos[0] = anchorNode.pos[0] - targetNode.size[0] - DEFAULT_MARGIN_X; + targetNode.pos[1] = anchorNode.pos[1]; +} + +const putOnRight = function(targetNode, anchorNode) { + targetNode = findNode(targetNode); + anchorNode = findNode(anchorNode); + targetNode.pos[0] = anchorNode.pos[0] + anchorNode.size[0] + DEFAULT_MARGIN_X; + targetNode.pos[1] = anchorNode.pos[1]; +} + +const putOnTop = function(targetNode, anchorNode) { + targetNode = findNode(targetNode); + anchorNode = findNode(anchorNode); + targetNode.pos[0] = anchorNode.pos[0]; + targetNode.pos[1] = anchorNode.pos[1] - targetNode.size[1] - DEFAULT_MARGIN_Y; +} + +const putOnBottom = function(targetNode, anchorNode) { + targetNode = findNode(targetNode); + anchorNode = findNode(anchorNode); + targetNode.pos[0] = anchorNode.pos[0]; + targetNode.pos[1] = anchorNode.pos[1] + anchorNode.size[1] + DEFAULT_MARGIN_Y; +} + +const moveToRight = function(targetNode) { + targetNode = findNode(targetNode); + let isChanged = true; + while(isChanged) { + isChanged = false; + for (const node of app.graph._nodes) { + if (node.id === targetNode.id) { + continue; + } + const top = node.pos[1]; + const bottom = node.pos[1] + node.size[1]; + const left = node.pos[0]; + const right = node.pos[0] + node.size[0]; + const isCollisionX = left <= node.pos[0] + targetNode.size[0] && + right >= targetNode.pos[0]; + const isCollisionY = top <= node.pos[1] + targetNode.size[1] && + bottom >= targetNode.pos[1]; + + if (isCollisionX && isCollisionY) { + targetNode.pos[0] = right + DEFAULT_MARGIN_X; + isChanged = true; + } + } + } +} + +const moveToBottom = function(targetNode) { + targetNode = findNode(targetNode); + let isChanged = true; + while(isChanged) { + isChanged = false; + for (const node of app.graph._nodes) { + if (node.id === targetNode.id) { + continue; + } + const top = node.pos[1]; + const bottom = node.pos[1] + node.size[1]; + const left = node.pos[0]; + const right = node.pos[0] + node.size[0]; + const isCollisionX = left <= targetNode.pos[0] + targetNode.size[0] && + right >= targetNode.pos[0]; + const isCollisionY = top <= targetNode.pos[1] + targetNode.size[1] && + bottom >= targetNode.pos[1]; + + if (isCollisionX && isCollisionY) { + targetNode.pos[1] = bottom + DEFAULT_MARGIN_Y; + isChanged = true; + } + } + } +} + +const getX = function(node) { + return findNode(node).pos[0]; +} + +const getY = function(node) { + return findNode(node).pos[1]; +} + +const getWidth = function(node) { + return findNode(node).size[0]; +} + +const getHeight = function(node) { + return findNode(node).size[1]; +} + +const getRect = function(node) { + node = findNode(node); + return [ + node.pos[0], + node.pos[1], + node.size[0], + node.size[1], + ]; +} + +const setX = function(node, n) { + node = findNode(node); + node.pos[0] = n; +} + +const setY = function(node, n) { + node = findNode(node); + node.pos[1] = n; +} + +const setWidth = function(node, w) { + node = findNode(node); + node.size[0] = w; + node.onResize(node.size); +} + +const setHeight = function(node, h) { + node = findNode(node); + node.size[1] = h; + node.onResize(node.size); +} + +const setRect = function(node, x, y, width, height) { + node = findNode(node); + if (typeof x !== "number") { + x = getX(node); + } + if (typeof y !== "number") { + y = getY(node); + } + if (typeof width !== "number") { + width = getWidth(node); + } + if (typeof height !== "number") { + height = getHeight(node); + } + node.pos[0] = x; + node.pos[1] = y; + node.size[0] = width; + node.size[1] = height; + node.onResize(node.size); +} + +const disableSleep = async function() { + const response = await api.fetchApi(`/shinich39/event-handler/disable-sleep`, { + method: "GET", + }); + + if (response.status !== 200) { + throw new Error(response.statusText); + } + SLEEP = false; + console.log("[FL_WF_Agent] Disable system sleep"); +} + +const enableSleep = async function() { + const response = await api.fetchApi(`/shinich39/event-handler/enable-sleep`, { + method: "GET", + }); + + if (response.status !== 200) { + throw new Error(response.statusText); + } + SLEEP = true; + console.log("[FL_WF_Agent] Enable system sleep"); +} + +const disableScreenSaver = async function() { + const response = await api.fetchApi(`/shinich39/event-handler/disable-screen-saver`, { + method: "GET", + }); + + if (response.status !== 200) { + throw new Error(response.statusText); + } + SLEEP = false; + console.log("[FL_WF_Agent] Disable screen saver"); +} + +const enableScreenSaver = async function() { + const response = await api.fetchApi(`/shinich39/event-handler/enable-screen-saver`, { + method: "GET", + }); + + if (response.status !== 200) { + throw new Error(response.statusText); + } + SLEEP = true; + console.log("[FL_WF_Agent] Enable screen saver"); +} + +const getPathFromImg = function(img) { + const url = new URL(img.src); + let filename = url.searchParams.get("filename"); + if (filename && filename !== "") { + filename = "/" + filename; + } + let subdir = url.searchParams.get("subfolder"); + if (subdir && subdir !== "") { + subdir = "/" + subdir; + } + let dir = url.searchParams.get("type"); + if (dir && dir !== "") { + dir = "/" + dir; + } + return `ComfyUI${dir}${subdir}${filename}`; +} + +const sendImages = async function(url, field, ...filePaths) { + filePaths = filePaths.reduce((acc, cur) => { + if (typeof cur === "object" && cur.comfyClass === "PreviewImage") { + if (cur.imgs) { + acc.push( + ...cur.imgs.map((img) => getPathFromImg(img)) + ); + } + } else if (typeof cur === "string") { + acc.push(cur); + } + return acc; + }, []); + + if (filePaths.length < 1) { + throw new Error("Images not found"); + } + + const response = await api.fetchApi(`/shinich39/event-handler/send-images`, { + method: "POST", + body: JSON.stringify({ + url: url, + field: field, + files: filePaths, + }), + }); + + if (response.status !== 200) { + throw new Error(response.statusText); + } +} + +app.registerExtension({ + name: "Comfy.FL_WF_Agent", + async setup() { + setTimeout(() => { + const origQueuePrompt = app.queuePrompt; + app.queuePrompt = async function(...args) { + execNodes("before_queued", args); + const r = await origQueuePrompt.apply(this, arguments); + return r; + } + + api.addEventListener("promptQueued", function(...args) { + execNodes("after_queued", args); + }); + + api.addEventListener("status", function(...args) { + execNodes("status", args); + }); + + api.addEventListener("progress", function(...args) { + execNodes("progress", args); + }); + + api.addEventListener("executing", function(...args) { + execNodes("executing", args); + }); + + api.addEventListener("executed", function(...args) { + execNodes("executed", args); + }); + + api.addEventListener("execution_start", function(...args) { + execNodes("execution_start", args); + }); + + api.addEventListener("execution_success", function(...args) { + execNodes("execution_success", args); + }); + + api.addEventListener("execution_error", function(...args) { + execNodes("execution_error", args); + }); + + api.addEventListener("execution_cached", function(...args) { + execNodes("execution_cached", args); + }); + + console.log("[FL_WF_Agent] Event added."); + }, 1024); + }, + nodeCreated(node) { + if (node.comfyClass === "FL_WF_Agent") { + const jsWidget = node.widgets?.find(e => e.name === "javascript"); + if (jsWidget && jsWidget.value === "// Generated code will appear here") { // Only set default if it's the placeholder + console.log("[FL_WF_Agent] Setting default JS command for new node:", node.id); + jsWidget.value = getDefaultCommand(); + } + + // Helper function to list available Gemini models + async function listGeminiModels(apiKey) { + try { + const response = await fetch(`${GEMINI_BASE_URL}/${GEMINI_API_VERSION}/models?key=${apiKey}`); + if (!response.ok) { + throw new Error(`Failed to list models: ${response.statusText}`); + } + const data = await response.json(); + console.log("[FL_WF_Agent] Available Gemini Models:", data.models); + return data.models; + } catch (error) { + console.error("[FL_WF_Agent] Error listing models:", error); + throw error; + } + } + + // Helper function to sanitize Gemini response + function sanitizeGeminiResponse(text) { + // Remove markdown code blocks + text = text.replace(/```javascript\n/g, ''); + text = text.replace(/```js\n/g, ''); + text = text.replace(/```\n/g, ''); + text = text.replace(/```/g, ''); + + // Remove potential HTML/XML tags that might slip through + text = text.replace(/<\/?[^>]+(>|$)/g, ''); + + // Remove any leading/trailing whitespace + text = text.trim(); + + // Convert smart quotes to regular quotes + text = text.replace(/[''‛`]/g, "'"); + text = text.replace(/[""]/g, '"'); + + return text; + } + + // Helper function to call Gemini API + async function callGeminiAPI(prompt, apiKey) { + console.log("[FL_WF_Agent] Calling Gemini API with prompt:", prompt); + + if (!apiKey) { + throw new Error("API key is required"); + } + + try { + // Try to read node definitions from cache + let nodeDefinitions = "No node definitions found. Please run 'Scan Nodes' first."; + + // First try the direct absolute path + const absolutePath = "/custom_nodes/ComfyUI_Fill-Nodes/web/nodes/node_definitions.txt"; + console.log("[FL_WF_Agent] Trying to load node definitions from absolute path:", absolutePath); + + try { + const response = await fetch(absolutePath); + console.log("[FL_WF_Agent] Response status:", response.status); + + if (response.ok) { + nodeDefinitions = await response.text(); + console.log("[FL_WF_Agent] Successfully loaded node definitions, size:", nodeDefinitions.length); + } else { + console.warn("[FL_WF_Agent] Failed to load from absolute path. Status:", response.status); + + // Try a relative path + const relativePath = "./custom_nodes/ComfyUI_Fill-Nodes/web/nodes/node_definitions.txt"; + console.log("[FL_WF_Agent] Trying relative path:", relativePath); + + try { + const relResponse = await fetch(relativePath); + if (relResponse.ok) { + nodeDefinitions = await relResponse.text(); + console.log("[FL_WF_Agent] Successfully loaded from relative path, size:", nodeDefinitions.length); + } else { + console.warn("[FL_WF_Agent] Failed to load from relative path. Status:", relResponse.status); + + // Try a direct file path based on the current URL + const pathFromOrigin = `${window.location.origin}/custom_nodes/ComfyUI_Fill-Nodes/web/nodes/node_definitions.txt`; + console.log("[FL_WF_Agent] Trying path from origin:", pathFromOrigin); + + try { + const originResponse = await fetch(pathFromOrigin); + if (originResponse.ok) { + nodeDefinitions = await originResponse.text(); + console.log("[FL_WF_Agent] Successfully loaded from origin path, size:", nodeDefinitions.length); + } else { + console.warn("[FL_WF_Agent] Failed to load from origin path. Status:", originResponse.status); + } + } catch (e) { + console.warn("[FL_WF_Agent] Error loading from origin path:", e); + } + } + } catch (e) { + console.warn("[FL_WF_Agent] Error loading from relative path:", e); + } + } + } catch (e) { + console.warn("[FL_WF_Agent] Error loading from absolute path:", e); + } + + // Log server-side file system data to console + console.log("[FL_WF_Agent] Creating mock node definitions as fallback since file could not be accessed"); + + // If we couldn't load from the file, create some basic node definitions + if (nodeDefinitions === "No node definitions found. Please run 'Scan Nodes' first.") { + nodeDefinitions = ` +Node: CheckpointLoaderSimple +Category: loaders +Inputs: + Required: + - ckpt_name: STRING +Outputs: + - MODEL + - CLIP + - VAE +-------------------------------------------------- +Node: CLIPTextEncode +Category: conditioning +Inputs: + Required: + - text: STRING + - clip: CLIP +Outputs: + - CONDITIONING +-------------------------------------------------- +Node: KSampler +Category: sampling +Inputs: + Required: + - model: MODEL + - positive: CONDITIONING + - negative: CONDITIONING + - latent_image: LATENT + - seed: INT + - steps: INT + - cfg: FLOAT + - sampler_name: STRING + - scheduler: STRING + - denoise: FLOAT +Outputs: + - LATENT +-------------------------------------------------- +Node: VAEDecode +Category: latent +Inputs: + Required: + - samples: LATENT + - vae: VAE +Outputs: + - IMAGE +-------------------------------------------------- +Node: SaveImage +Category: image +Inputs: + Required: + - images: IMAGE + - filename_prefix: STRING +Outputs: + - IMAGE +`; + console.log("[FL_WF_Agent] Using fallback node definitions with basic nodes"); + } + + // Use hardcoded system prompt with node definitions + const systemPrompt = `${SYSTEM_PROMPT}\n\nAvailable ComfyUI Nodes:\n${nodeDefinitions}\n\nUse these nodes when generating code - they represent the actual nodes available in the system.`; + + // List available models first + const models = await listGeminiModels(apiKey); + const modelName = GEMINI_MODEL; + + if (!models.some(m => m.name.includes(modelName))) { + throw new Error(`Model ${modelName} not found. Available models: ${models.map(m => m.name).join(', ')}`); + } + + const requestBody = { + contents: [{ + parts: [{ + text: `${systemPrompt}\nUser prompt: ${prompt}` + }] + }] + }; + + const response = await fetch(`${GEMINI_BASE_URL}/${GEMINI_API_VERSION}/models/${modelName}:generateContent?key=${apiKey}`, { + method: 'POST', + headers: { + 'Content-Type': 'application/json', + }, + body: JSON.stringify(requestBody) + }); + + if (!response.ok) { + const errorData = await response.json(); + console.error("[FL_WF_Agent] API Error Response:", errorData); + throw new Error(`Gemini API Error (${response.status}): ${JSON.stringify(errorData)}`); + } + + const data = await response.json(); + + if (!data.candidates?.[0]?.content?.parts?.[0]?.text) { + console.error("[FL_WF_Agent] Unexpected API response format:", data); + throw new Error("Invalid response format from Gemini API"); + } + + return data.candidates[0].content.parts[0].text.trim(); + + } catch (error) { + console.error("[FL_WF_Agent] API Call Error:", error); + throw error; + } + } + + // Add code generation button + const generateCodeWidget = node.addWidget("button", "🤖 Generate Code", null, async () => { + try { + const promptWidget = node.widgets?.find(e => e.name === "code_prompt"); + const apiKeyWidget = node.widgets?.find(e => e.name === "api_key"); + const jsWidget = node.widgets?.find(e => e.name === "javascript"); + + if (!promptWidget?.value?.trim()) { + app.ui.dialog.show("Error", "Please enter a code prompt"); + return; + } + + if (!apiKeyWidget?.value?.trim()) { + app.ui.dialog.show("Error", "Please enter a valid Gemini API key"); + return; + } + + app.ui.dialog.show("Status", "Generating code..."); + + const generatedCode = await callGeminiAPI(promptWidget.value, apiKeyWidget.value); + + if (generatedCode && jsWidget) { + // Sanitize the generated code before setting it + jsWidget.value = sanitizeGeminiResponse(generatedCode); + node.setDirtyCanvas(true); + app.ui.dialog.show("Success", "Code generated successfully!"); + } else { + throw new Error("Failed to update code widget"); + } + + } catch (error) { + console.error("[FL_WF_Agent] Code generation error:", error); + app.ui.dialog.show("Error", `Failed to generate code: ${error.message}`); + } + }, { + serialize: false + }); + generateCodeWidget.computeSize = () => [140, 26]; + + // Add scan nodes button + const scanNodesWidget = node.addWidget("button", "🔍 Scan Nodes", null, async () => { + try { + console.log("[FL_WF_Agent] Starting node scan..."); + app.ui.dialog.show("Status", "Starting node scan... This may take a moment."); + + // Log current paths for debugging + console.log("[FL_WF_Agent] Current location:", window.location.href); + console.log("[FL_WF_Agent] Expected cache path:", `${window.location.origin}/custom_nodes/ComfyUI_Fill-Nodes/web/nodes/node_definitions.txt`); + console.log("[FL_WF_Agent] Relative cache path:", '/custom_nodes/ComfyUI_Fill-Nodes/web/nodes/node_definitions.txt'); + + // Debug server directory structure + console.log("[FL_WF_Agent] Checking current server file structure..."); + + // Set scan_nodes widget to true to trigger scan + const scanWidget = node.widgets?.find(e => e.name === "scan_nodes"); + if (!scanWidget) { + throw new Error("Scan nodes widget not found"); + } + + // Set the value and trigger execution + scanWidget.value = true; + + // Queue the node for execution + if (node.triggerSlot) { + node.triggerSlot(0); + } else { + node.onExecuted?.({}); // Fallback execution + } + + app.graph.setDirtyCanvas(true); + + // Try to detect if file becomes available after scan completes + setTimeout(async () => { + console.log("[FL_WF_Agent] Checking for cache file after scan..."); + try { + const testResponse = await fetch('/custom_nodes/ComfyUI_Fill-Nodes/web/nodes/node_definitions.txt'); + console.log("[FL_WF_Agent] Cache file check result:", testResponse.status); + if (testResponse.ok) { + console.log("[FL_WF_Agent] Cache file is now accessible!"); + const textSample = await testResponse.text(); + console.log("[FL_WF_Agent] First 100 chars:", textSample.substring(0, 100)); + } else { + console.log("[FL_WF_Agent] Cache file still not accessible after scan!"); + } + } catch (e) { + console.log("[FL_WF_Agent] Error checking cache file:", e); + } + }, 5000); + + } catch (error) { + console.error("[FL_WF_Agent] Scan error:", error); + app.ui.dialog.show("Error", `Failed to start scan: ${error.message}`); + + // Reset scan widget on error + const scanWidget = node.widgets?.find(e => e.name === "scan_nodes"); + if (scanWidget) { + scanWidget.value = false; + } + } + }, { + serialize: false + }); + scanNodesWidget.computeSize = () => [140, 26]; + + // Add handler for scan feedback + node.onExecuted = function(message) { + console.log("[FL_WF_Agent] Node executed, message:", message); + + if (message?.ui?.scan_feedback) { + const feedback = message.ui.scan_feedback; + console.log("[FL_WF_Agent] Received scan feedback:", feedback); + + // Display detailed directory information + if (feedback.directory_info) { + console.log("[FL_WF_Agent] Directory info:", feedback.directory_info); + } + + if (feedback.success) { + // Try multiple paths to check if the file is accessible + const pathsToTry = [ + '/custom_nodes/ComfyUI_Fill-Nodes/web/nodes/node_definitions.txt', + './custom_nodes/ComfyUI_Fill-Nodes/web/nodes/node_definitions.txt', + `${window.location.origin}/custom_nodes/ComfyUI_Fill-Nodes/web/nodes/node_definitions.txt` + ]; + + console.log("[FL_WF_Agent] Trying multiple paths to locate the file:"); + + pathsToTry.forEach((path, index) => { + fetch(path) + .then(response => { + console.log(`[FL_WF_Agent] Path ${index+1} (${path}) check result:`, response.status); + if (response.ok) { + return response.text().then(text => { + console.log(`[FL_WF_Agent] File at path ${index+1} exists, content length:`, text.length); + console.log(`[FL_WF_Agent] First 100 chars:`, text.substring(0, 100)); + }); + } + return `File not found at path ${index+1}`; + }) + .catch(error => { + console.error(`[FL_WF_Agent] Error checking path ${index+1}:`, error); + }); + }); + + app.ui.dialog.show("Success", feedback.message); + if (feedback.stdout) { + console.log("[FL_WF_Agent] Scanner output:", feedback.stdout); + } + } else { + app.ui.dialog.show("Error", feedback.message); + if (feedback.stderr) { + console.error("[FL_WF_Agent] Scanner error:", feedback.stderr); + } + } + + // Reset scan_nodes widget + const scanWidget = this.widgets?.find(e => e.name === "scan_nodes"); + if (scanWidget) { + scanWidget.value = false; + } + } + }; + + // Add execute button + const execButton = node.addWidget("button", "Execute", null, () => {}, { + serialize: false + }); + execButton.computeSize = () => [140, 26]; + execButton.callback = () => execNode(node, []); + + node.exec = () => execNode(node, []); + } + } +}); \ No newline at end of file diff --git a/web/nodes/node_definitions.txt b/web/nodes/node_definitions.txt new file mode 100644 index 0000000..d3739bc --- /dev/null +++ b/web/nodes/node_definitions.txt @@ -0,0 +1,4892 @@ +Node: SaveImageWebsocket: + @classmethod + def INPUT_TYPES +Category: api/image +Inputs: + Required: + - {"images: IMAGE + Optional: +Outputs: +-------------------------------------------------- +Node: Segment: + @classmethod + def INPUT_TYPES +Category: 🧪AILab/🧽RMBG +Inputs: + Required: + Optional: +Outputs: + - IMAGE (IMAGE) + - MASK (MASK) +-------------------------------------------------- +Node: for preview +Category: Unknown +Inputs: + Required: + Optional: +Outputs: +-------------------------------------------------- +Node: AiLab_PreviewBase: + def __init__ +Category: Unknown +Inputs: + Required: + Optional: +Outputs: +-------------------------------------------------- +Node: AiLab_Preview +Category: 🧪AILab/🛠️UTIL/🖼️IMAGE +Inputs: + Required: + Optional: + - image: IMAGE, {"default": None} + - mask: MASK, {"default": None} +Outputs: + - IMAGE (IMAGE) + - MASK (MASK) +-------------------------------------------------- +Node: AiLab_MaskPreview +Category: 🧪AILab/🛠️UTIL/🖼️IMAGE +Inputs: + Required: + - {"mask: MASK + Optional: +Outputs: + - MASK (MASK) +-------------------------------------------------- +Node: AiLab_ImagePreview +Category: 🧪AILab/🛠️UTIL/🖼️IMAGE +Inputs: + Required: + - {"image: IMAGE + Optional: +Outputs: + - IMAGE (IMAGE) +-------------------------------------------------- +Node: AiLab_LoadImage: + @classmethod + def INPUT_TYPES +Category: 🧪AILab/🛠️UTIL/🖼️IMAGE +Inputs: + Required: + - image: sorted(files + - mask_channel: ["alpha, red, green, blue"], {"default": "alpha, tooltip": "Select channel to extract mask from"} + - scale_by: FLOAT, {"default": 1.0, min": 0.01, max": 8.0, step": 0.01, tooltip": "Scale image by this factor (ignored if longest_side > 0 + - longest_side: INT, {"default": 0, min": 0, max": 8192, step": 8, tooltip": "Resize image so longest side equals this value (0 = disabled + Optional: +Outputs: + - IMAGE (IMAGE) + - MASK (MASK) + - MASK_IMAGE (IMAGE) + - WIDTH (INT) + - HEIGHT (INT) +-------------------------------------------------- +Node: mappings +NODE_CLASS_MAPPINGS = { + "AiLab_LoadImage": AiLab_LoadImage, + "AiLab_Preview": AiLab_Preview, + "AiLab_ImagePreview": AiLab_ImagePreview, + "AiLab_MaskPreview": AiLab_MaskPreview, +} + +# Node display name mappings +NODE_DISPLAY_NAME_MAPPINGS = { + "AiLab_LoadImage": "Load Image +Category: Unknown +Inputs: + Required: + Optional: +Outputs: +-------------------------------------------------- +Node: FaceSegment: + def __init__ +Category: 🧪AILab/🧽RMBG +Inputs: + Required: + Optional: +Outputs: + - IMAGE (IMAGE) + - MASK (MASK) +-------------------------------------------------- +Node: masks + combined_mask = None + for class_name in selected_classes: + mask = +Category: Unknown +Inputs: + Required: + Optional: +Outputs: +-------------------------------------------------- +Node: FashionSegmentAccessories: + @classmethod + def INPUT_TYPES +Category: 🧪AILab/🧽RMBG +Inputs: + Required: + Optional: + - **{cls_name: BOOLEAN, {"default": False} +Outputs: + - accessories_options (ACCESSORIES_OPTIONS) +-------------------------------------------------- +Node: FashionSegmentClothing: + def __init__ +Category: 🧪AILab/🧽RMBG +Inputs: + Required: + - images: IMAGE + - accessories_options: ACCESSORIES_OPTIONS + Optional: + - **{cls_name: BOOLEAN, {"default": False} + - process_res: INT, {"default": 512, min": 128, max": 2048, step": 32} + - mask_blur: INT, {"default": 0, min": 0, max": 64, step": 1} + - mask_offset: INT, {"default": 0, min": -64, max": 64, step": 1} + - background_color: ["Alpha, black, white, gray, green, blue, red"], {"default": "Alpha"} + - invert_output: BOOLEAN, {"default": False} +Outputs: + - images (IMAGE) + - mask (MASK) +-------------------------------------------------- +Node: BodySegment: + def __init__ +Category: 🧪AILab/🧽RMBG +Inputs: + Required: + Optional: +Outputs: + - IMAGE (IMAGE) + - MASK (MASK) +-------------------------------------------------- +Node: masks + combined_mask = np.zeros_like +Category: Unknown +Inputs: + Required: + Optional: +Outputs: +-------------------------------------------------- +Node: BaseModelLoader: + def __init__ +Category: Unknown +Inputs: + Required: + Optional: +Outputs: +-------------------------------------------------- +Node: RMBGModel +Category: Unknown +Inputs: + Required: + Optional: +Outputs: +-------------------------------------------------- +Node: = getattr +Category: Unknown +Inputs: + Required: + Optional: +Outputs: +-------------------------------------------------- +Node: InspyrenetModel +Category: Unknown +Inputs: + Required: + Optional: +Outputs: +-------------------------------------------------- +Node: BENModel +Category: Unknown +Inputs: + Required: + Optional: +Outputs: +-------------------------------------------------- +Node: BEN2Model +Category: Unknown +Inputs: + Required: + Optional: +Outputs: +-------------------------------------------------- +Node: RMBG: + def __init__ +Category: 🧪AILab/🧽RMBG +Inputs: + Required: + Optional: +Outputs: + - IMAGE (IMAGE) + - MASK (MASK) + - MASK_IMAGE (IMAGE) +-------------------------------------------------- +Node: BiRefNetModel: + def __init__ +Category: Unknown +Inputs: + Required: + Optional: +Outputs: +-------------------------------------------------- +Node: BiRefNetRMBG: + def __init__ +Category: 🧪AILab/🧽RMBG +Inputs: + Required: + Optional: +Outputs: + - IMAGE (IMAGE) + - MASK (MASK) +-------------------------------------------------- +Node: ClothesSegment: + def __init__ +Category: 🧪AILab/🧽RMBG +Inputs: + Required: + Optional: +Outputs: + - IMAGE (IMAGE) + - MASK (MASK) +-------------------------------------------------- +Node: _: + """ + An opinionated batch image loader. This is used for loading groups for batch processing. + + Folder structure: + + ```plain + groups/ + baseprompt.txt + g1/ + 0001.png + 0002.png + subprompt.txt + g2/ + 0003.png + 0004.png + subprompt.txt + ... + ``` + """ + + CATEGORY = "jamesWalker55" + INPUT_TYPES = lambda: { + "required": { + "groups_dir": +Category: jamesWalker55 +Description: An opinionated batch image loader. This is used for loading groups for batch processing. + + Folder structure: + + ```plain + groups/ + baseprompt.txt + g1/ + 0001.png + 0002.png + subprompt.txt + g2/ + 0003.png + 0004.png + subprompt.txt + ... + ``` +Inputs: + Required: + - groups_dir: STRING, {"default": "./groups, multiline": False} + - groups_id: INT, {"default": 1, min": 0, step": 1, max": 9999} + - {"default: *.png + Optional: +Outputs: + - STRING + - STRING + - IMAGE + - INT + - STRING +-------------------------------------------------- +Node: GroupedWorkspace: + """ + YAML structure: + + ```yaml + positive: | + {positive}, + simple background, white background, + + negative: | + {negative}, + low quality, + + image_pattern: '{frame_id:04d}.png' + + groups: + - start_id: 1 + positive: ... + negative: ... + - start_id: 5 + positive: ... + negative: ... + ... + ``` + """ + + _original_definition: dict + _base_path: Path + _base_pos: str + _base_neg: str + _image_pattern: str + _groups: list[dict] + + def __init__ +Category: Unknown +Description: YAML structure: + + ```yaml + positive: | + {positive}, + simple background, white background, + + negative: | + {negative}, + low quality, + + image_pattern: '{frame_id:04d}.png' + + groups: + - start_id: 1 + positive: ... + negative: ... + - start_id: 5 + positive: ... + negative: ... + ... + ``` +Inputs: + Required: + Optional: +Outputs: +-------------------------------------------------- +Node: __: + """ + An opinionated batch image loader. This is used for loading groups for batch processing. + + "base_path" controls where the images are loaded relative from. Defaults to the + folder containing the definition file. + """ + + CATEGORY = "jamesWalker55" + INPUT_TYPES = lambda: { + "required": { + "definition_path": +Category: jamesWalker55 +Description: An opinionated batch image loader. This is used for loading groups for batch processing. + + "base_path" controls where the images are loaded relative from. Defaults to the + folder containing the definition file. +Inputs: + Required: + - {"default: ./groups.yml + - group_id: INT, {"default": 1, min": 0, step": 1, max": 9999} + - base_path: STRING, {"default": ""} + Optional: +Outputs: + - STRING + - STRING + - IMAGE + - INT + - STRING + - GROUP_INFO +-------------------------------------------------- +Node: _: + """ + An opinionated image loader. This is used for loading groups for batch processing. + + "base_path" controls where the images are loaded relative from. Defaults to the + folder containing the definition file. + """ + + CATEGORY = "jamesWalker55" + INPUT_TYPES = lambda: { + "required": { + "definition_path": +Category: jamesWalker55 +Description: An opinionated image loader. This is used for loading groups for batch processing. + + "base_path" controls where the images are loaded relative from. Defaults to the + folder containing the definition file. +Inputs: + Required: + - {"default: ./groups.yml + - frame_id: INT, {"default": 1, min": 0, step": 1, max": 9999} + - base_path: STRING, {"default": ""} + Optional: +Outputs: + - STRING + - STRING + - IMAGE + - STRING + - GROUP_INFO +-------------------------------------------------- +Node: _: + CATEGORY = "jamesWalker55" + INPUT_TYPES = lambda: { + "required": { + "group_info": +Category: jamesWalker55 +Inputs: + Required: + - group_info: GROUP_INFO + - key: STRING, {"default": ""} + Optional: +Outputs: + - FLOAT +-------------------------------------------------- +Node: _: + CATEGORY = "jamesWalker55" + INPUT_TYPES = lambda: { + "required": { + "format": +Category: jamesWalker55 +Inputs: + Required: + - format: STRING, {"default": "%Y-%m-%dT%H:%M:%S"} + Optional: +Outputs: + - STRING +-------------------------------------------------- +Node: _: + CATEGORY = "jamesWalker55" + BLEND_TYPES = +Category: jamesWalker55 +Inputs: + Required: + - blend_type: cls.BLEND_TYPES, {"default": "mix"} + - factor: FLOAT, {"min": 0, max": 1, step": 0.01, default": 0.5} + - image_a: IMAGE + - image_b: IMAGE + Optional: +Outputs: + - IMAGE +-------------------------------------------------- +Node: _: + CATEGORY = "jamesWalker55" + INPUT_TYPES = lambda: { + "required": { + "image": +Category: jamesWalker55 +Inputs: + Required: + - image: IMAGE + - resize_length: INT, {"default": 512, min": 8, step": 8} + - crop_rect: CROP_RECT + Optional: +Outputs: + - IMAGE +-------------------------------------------------- +Node: _: + CATEGORY = "jamesWalker55" + INPUT_TYPES = lambda: { + "required": { + "path": +Category: jamesWalker55 +Inputs: + Required: + - path: STRING, {"default": "./audio.mp3"} + - gain_db: FLOAT, {"default": 0, min": -100, max": 100} + - offset_seconds: FLOAT, {"default": 0, min": 0, max": FLOAT_MAX} + - duration_seconds: FLOAT, {"default": 0, min": 0, max": FLOAT_MAX} + - resample_to_hz: FLOAT, {"default": 0, min": 0, max": FLOAT_MAX} + - make_stereo: BOOLEAN, {"default": True} + Optional: +Outputs: + - AUDIO +-------------------------------------------------- +Node: _: + CATEGORY = "jamesWalker55" + INPUT_TYPES = lambda: { + "required": { + "paths": +Category: jamesWalker55 +Inputs: + Required: + - default: ./frame000001.png\n./frame000002.png\n./frame000003.png + - multiline: True + - dynamicPrompts: False + - ignore_missing_images: ("false, true + Optional: +Outputs: + - IMAGE +-------------------------------------------------- +Node: _: + CATEGORY = "jamesWalker55" + INPUT_TYPES = lambda: { + "required": { + "images": +Category: jamesWalker55 +Inputs: + Required: + - images: IMAGE + - {"default: ./frame{ + - start_index: INT, {"default": 0, min": 0, step": 1} + - overwrite: ("false, true + Optional: +Outputs: +-------------------------------------------------- +Node: _: + CATEGORY = "jamesWalker55" + INPUT_TYPES = lambda: { + "required": { + "mask": +Category: jamesWalker55 +Inputs: + Required: + - mask: MASK + - batch_size: INT, {"default": 1, min": 1, step": 1} + Optional: +Outputs: + - MASK_SEQUENCE +-------------------------------------------------- +Node: _: + CATEGORY = "jamesWalker55" + INPUT_TYPES = lambda: {"required": {}} + RETURN_TYPES = +Category: jamesWalker55 +Inputs: + Required: + Optional: +Outputs: + - IMAGE + - MASK +-------------------------------------------------- +Node: _: + """ + https://pytorch.org/vision/main/auto_examples/plot_optical_flow.html + """ + + CATEGORY = "jamesWalker55" + INPUT_TYPES = lambda: { + "required": { + "image_a": +Category: jamesWalker55 +Description: https://pytorch.org/vision/main/auto_examples/plot_optical_flow.html +Inputs: + Required: + - image_a: IMAGE + - image_b: IMAGE + Optional: +Outputs: + - RAFT_FLOW +-------------------------------------------------- +Node: _: + """ + https://pytorch.org/vision/main/auto_examples/plot_optical_flow.html + """ + + CATEGORY = "jamesWalker55" + INPUT_TYPES = lambda: { + "required": { + "raft_flow": +Category: jamesWalker55 +Description: https://pytorch.org/vision/main/auto_examples/plot_optical_flow.html +Inputs: + Required: + - raft_flow: RAFT_FLOW + Optional: +Outputs: + - IMAGE +-------------------------------------------------- +Node: _: + """ + This is a utility function for loading motion flows from an EXR image file. + This is intended for use with Blender's vector pass in the Cycles renderer. + + In Blender, enable the vector pass. In the compositor, use "Separate Color" to + extract the "Blue" and "Alpha" channels of the vector pass. Then, combine them + using "Combine Color" to two of the RGB channels. Finally, render to the "OpenEXR" + format. + + https://gist.github.com/andres-fr/4ddbb300d418ed65951ce88766236f9c + """ + + CATEGORY = "jamesWalker55" + INPUT_TYPES = lambda: { + "required": { + "path": +Category: jamesWalker55 +Description: This is a utility function for loading motion flows from an EXR image file. + This is intended for use with Blender's vector pass in the Cycles renderer. + + In Blender, enable the vector pass. In the compositor, use "Separate Color" to + extract the "Blue" and "Alpha" channels of the vector pass. Then, combine them + using "Combine Color" to two of the RGB channels. Finally, render to the "OpenEXR" + format. + + https://gist.github.com/andres-fr/4ddbb300d418ed65951ce88766236f9c +Inputs: + Required: + - path: STRING, {"default": ""} + - x_channel: ("R, G, B, A + - y_channel: ("R, G, B, A + - invert_x: ("false, true + - invert_y: ("false, true + Optional: +Outputs: + - RAFT_FLOW +-------------------------------------------------- +Node: RangedConfig: + def __init__ +Category: Unknown +Description: \ +p: | + masterpiece, best quality, + {sp}, + +n: | + {sn}, + embedding:EasyNegative, embedding:bad-artist, embedding:bad-hands-5, embedding:bad-image-v2-39000, + lowres, ((bad anatomy)), ((bad hands)), text, missing finger, extra digits, fewer digits, blurry, ((mutated hands and fingers)), (poorly drawn face), ((mutation)), ((deformed face)), (ugly), ((bad proportions)), ((extra limbs)), extra face, (double head), (extra head), ((extra feet)), monster, logo, cropped, worst quality, low quality, normal quality, jpeg, humpbacked, long body, long neck, ((jpeg artifacts)), + +path: "{i:04d}.png" + +example: 0 + +ranges: + 1: + sp: positive subprompt for 1-4 + sn: negative subprompt for 1-4 + 5: + sp: positive subprompt for 5-... + sn: negative subprompt for 5-... + example: 1 +Inputs: + Required: + Optional: +Outputs: +-------------------------------------------------- +Node: _: + CATEGORY = "jamesWalker55" + INPUT_TYPES = lambda: { + "required": { + "config": +Category: jamesWalker55 +Inputs: + Required: + - {"default: 16 + - ranges_key: STRING, {"default": "ranges, multiline": False} + - path_key: STRING, {"default": "path, multiline": False} + - batch_idx: INT, {"default": 0, min": 0, step": 1, max": 999999} + - i_start: INT, {"default": 1, min": 0, step": 1, max": 999999} + - i_stop: INT, {"default": 100, min": 0, step": 1, max": 999999} + - inclusive: ("false, true + Optional: +Outputs: + - INFO_HASH (INFO_HASH) + - IMAGE (IMAGE) + - BATCH_I_START (INT) + - BATCH_I_STOP (INT) +-------------------------------------------------- +Node: _: + CATEGORY = "jamesWalker55" + INPUT_TYPES = lambda: { + "required": { + "info_hash": +Category: jamesWalker55 +Inputs: + Required: + - info_hash: INFO_HASH + Optional: +Outputs: +-------------------------------------------------- +Node: _: + CATEGORY = "jamesWalker55" + INPUT_TYPES = lambda: { + "required": { + "info_hash_list": +Category: jamesWalker55 +Inputs: + Required: + - info_hash_list: INFO_HASH_LIST + - i: INT, {"default": 0, step": 1, min": -99999999, max": 99999999} + Optional: +Outputs: + - INFO_HASH +-------------------------------------------------- +Node: _: + CATEGORY = "jamesWalker55" + INPUT_TYPES = lambda: { + "required": { + "image_a": +Category: jamesWalker55 +Inputs: + Required: + - image_a: IMAGE + - image_b: IMAGE + Optional: +Outputs: + - IMAGE +-------------------------------------------------- +Node: _: + """ + Batch-load images in a given folder. To avoid loading too many images at once, + you can use `paginate_size` and `paginate_page` to load a subset of the images. + + To disable pagination functionality, leave `paginate_size` and `paginate_page` at 0. + """ + + CATEGORY = "jamesWalker55" + INPUT_TYPES = lambda: { + "required": { + "image_dir": +Category: jamesWalker55 +Description: Batch-load images in a given folder. To avoid loading too many images at once, + you can use `paginate_size` and `paginate_page` to load a subset of the images. + + To disable pagination functionality, leave `paginate_size` and `paginate_page` at 0. +Inputs: + Required: + - image_dir: STRING, {"default": "./images, multiline": False} + - glob_pattern: STRING, {"default": "*.png, multiline": False} + - paginate_size: INT, {"default": 0, min": 0} + - paginate_page: INT, {"default": 0, min": 0} + Optional: +Outputs: + - IMAGE (IMAGE) + - FRAME_COUNT (INT) + - FILENAMES (STRING) +-------------------------------------------------- +Node: Audio +Category: Unknown +Inputs: + Required: + Optional: +Outputs: +-------------------------------------------------- +Node: _: + CATEGORY = "jamesWalker55" + INPUT_TYPES = lambda: { + "required": { + "a": +Category: jamesWalker55 +Inputs: + Required: + - a: STRING_LIST + - b: STRING_LIST + Optional: +Outputs: + - STRING_LIST +-------------------------------------------------- +Node: ResultItem +Category: Unknown +Inputs: + Required: + Optional: +Outputs: +-------------------------------------------------- +Node: _: + CATEGORY = "jamesWalker55" + INPUT_TYPES = lambda: { + "required": { + "audio": +Category: jamesWalker55 +Inputs: + Required: + - audio: AUDIO + - path: STRING, {"default": "./audio.mp3"} + - overwrite: BOOLEAN, {"default": True} + Optional: +Outputs: +-------------------------------------------------- +Node: _: + CATEGORY = "jamesWalker55" + INPUT_TYPES = lambda: { + "required": { + "value": +Category: jamesWalker55 +Inputs: + Required: + - value: LATENT + - {"default: latent + Optional: +Outputs: + - LATENT +-------------------------------------------------- +Node: _: + CATEGORY = "jamesWalker55" + INPUT_TYPES = lambda: { + "required": { + "string_list": +Category: jamesWalker55 +Inputs: + Required: + - string_list: STRING_LIST + - clip: CLIP + Optional: +Outputs: + - CONDITIONING +-------------------------------------------------- +Node: _: + CATEGORY = "jamesWalker55" + INPUT_TYPES = lambda: { + "required": { + "default": +Category: jamesWalker55 +Inputs: + Required: + - default: IMAGE + - path: STRING, {"default": "./image.png"} + Optional: +Outputs: + - IMAGE +-------------------------------------------------- +Node: _: + CATEGORY = "jamesWalker55" + INPUT_TYPES = lambda: { + "required": { + "path_pattern": +Category: jamesWalker55 +Inputs: + Required: + - {"default: ./frame{ + - start_index: INT, {"default": 0, min": 0, step": 1, max": 999999} + - stop_index: INT, {"default": 16, min": 1, step": 1, max": 999999} + - inclusive: ("false, true + - ignore_missing_images: ("false, true + Optional: +Outputs: + - IMAGE +-------------------------------------------------- +Node: LoopImageSequence: + CATEGORY = "jamesWalker55" + INPUT_TYPES = lambda: { + "required": { + "images": +Category: jamesWalker55 +Inputs: + Required: + - images: IMAGE + - target_frames: INT, {"default": 16, step": 1} + Optional: +Outputs: + - IMAGE +-------------------------------------------------- +Node: _: + CATEGORY = "jamesWalker55/rc" + INPUT_TYPES = lambda: { + "required": { + "key": +Category: jamesWalker55/rc +Inputs: + Required: + - {"default: input_latent + - latent: LATENT + Optional: +Outputs: +-------------------------------------------------- +Node: _: + CATEGORY = "jamesWalker55" + INPUT_TYPES = lambda: { + "required": { + "mask_sequence_1": +Category: jamesWalker55 +Inputs: + Required: + - mask_sequence_1: MASK_SEQUENCE + - mask_sequence_2: MASK_SEQUENCE + Optional: +Outputs: + - MASK_SEQUENCE +-------------------------------------------------- +Node: _: + CATEGORY = "jamesWalker55" + INPUT_TYPES = lambda: { + "required": { + "samples": +Category: jamesWalker55 +Inputs: + Required: + - samples: LATENT + - mask_sequence: MASK_SEQUENCE + Optional: +Outputs: + - LATENT +-------------------------------------------------- +Node: CropRect +Category: Unknown +Inputs: + Required: + Optional: +Outputs: +-------------------------------------------------- +Node: _: + CATEGORY = "jamesWalker55" + INPUT_TYPES = lambda: { + "required": { + "x": +Category: jamesWalker55 +Inputs: + Required: + - x: INT, {"default": 0, min": 0, max": MAX_RESOLUTION, step": 1} + - y: INT, {"default": 0, min": 0, max": MAX_RESOLUTION, step": 1} + - {"default: 512 + Optional: +Outputs: + - CROP_RECT +-------------------------------------------------- +Node: _: + CATEGORY = "jamesWalker55" + INPUT_TYPES = lambda: { + "required": { + "original_image": +Category: jamesWalker55 +Inputs: + Required: + - original_image: IMAGE + - cropped_image: IMAGE + - cropped_mask: MASK + - crop_rect: CROP_RECT + Optional: +Outputs: + - IMAGE +-------------------------------------------------- +Node: _: + CATEGORY = category + INPUT_TYPES = lambda: {"required": required_inputs} + RETURN_TYPES = tuple +Category: category +Description: parses '\\n' literals in a string to actual '\n' characters +Inputs: + Required: + Optional: +Outputs: + - tuple(return_types +-------------------------------------------------- +Node: ReferenceOnlySimple: + CATEGORY = "jamesWalker55" + INPUT_TYPES = lambda: { + "required": { + "model": +Category: jamesWalker55 +Inputs: + Required: + - model: MODEL + - reference: LATENT + - initial_latent: LATENT + - batch_size: INT, {"default": 1, min": 1, max": 64} + Optional: +Outputs: + - MODEL + - LATENT +-------------------------------------------------- +Node: _: + """ + Set the strength of the previously-added ControlNet, number of values must be + equal to batch size. + """ + + CATEGORY = "jamesWalker55" + INPUT_TYPES = lambda: { + "required": { + "conditioning": +Category: jamesWalker55 +Description: Set the strength of the previously-added ControlNet, number of values must be + equal to batch size. +Inputs: + Required: + - conditioning: CONDITIONING + - default: 0.25 + - multiline: True + - dynamicPrompts: False + Optional: +Outputs: + - CONDITIONING +-------------------------------------------------- +Node: ManagerFuncsInComfyUI +Category: Unknown +Description: provide unified (node -> node pack) mapping list +Inputs: + Required: + Optional: +Outputs: +-------------------------------------------------- +Node: params are global +Category: Unknown +Description: # Coding a Python Function +You are an expert python coder who specializes in writing custom nodes for ComfyUI. + +## Available Python Modules +It is not required to use any of these libraries, but if you do use any import in your code it must be on this list: +[[IMPORTS]] + +## Input Data +Here is some important information about the input data: +- input_data_1: [[INPUT1]] +- input_data_2: [[INPUT2]] +[[CONNECTIONS]][[EXAMPLES]][[CODEBLOCK]] +## Coding Instructions +- Your job is to code the user's requested node given the inputs and desired output type. +- Respond with only a brief plan and the code in one function named generated_function that takes two kwargs named 'input_data_1' and 'input_data_2'. +- All functions you must define should be inner functions of generated_function. +- You may briefly plan your code in plain text, but after write only the code contents of the function itself inside of a `python` code block. +- Do include needed available imports in your code before the function. +- If the request is simple enough to do without imports, like math, just do that. +- If an input is a Tensor and the output is a Tensor, it should be the same shape unless otherwise specified by the user. +- Image tensors come in the shape (batch, width, height, rgb_channels), if outputting an image, use the same shape as the input image tensor. + - To know the tensor is an image, it will come with the last dimension as 3 + - An example image tensor for a single 512x786 image: (1, 512, 786, 3) + - An animation is a tensor with a larger batch of images of the same shape +- Your resulting code should be as compute efficient as possible. +- Make sure to deallocate memory for anything which uses it. +- You may not use `open` or fetch files from the internet. +- If there is a code block above, insure that the the generated_function args and kwargs match the example below. + +### Example Generated function: +User: output a list of all prime numbers up to the input number +```python +import math +def generated_function(input_data_1=None, input_data_2=None): + def is_prime(n): + if n <= 1: + return False + for i in range(2, int(math.sqrt(n))+1): + if n % i == 0: + return False + return True + primes = [] + num = input_data_1 + while num > 1: + if is_prime(num): + primes.append(num) + num -= 1 + return primes +``` + +## Write the Code +Inputs: + Required: + Optional: +Outputs: +-------------------------------------------------- +Node: AnyNode: + """Ask it to make up any node for you. """ + + NAME = "AnyNode" + CATEGORY = "utils" + + ALLOWED_IMPORTS = {"os", "re", "json", "random", "string", "sys", "math", "datetime", "collections", "itertools", "functools", "numpy", "openai", "traceback", "torch", "time", "sklearn", "torchvision", "matplotlib", "io", "base64", "wave", "google.generativeai", "chromadb", "uuid", "comfy", "scipy", "torchaudio", "torchvision", "cv2", "PIL"} + CODING_ATTEMPTS = 3 + + def __init__ +Category: utils +Description: Ask it to make up any node for you. +Inputs: + Required: + - multiline: True + - default: gpt-4o + Optional: + - any: any_type + - any2: any_type +Outputs: + - any (any_type) + - control (CTRL) +-------------------------------------------------- +Node: AnyNodeGemini +Category: Unknown +Inputs: + Required: + - multiline: True + - default: gemini-1.5-flash + Optional: + - any: any_type + - any2: any_type +Outputs: +-------------------------------------------------- +Node: AnyNodeOpenAICompatible +Category: Unknown +Inputs: + Required: + - multiline: True + - default: http + Optional: + - any: any_type + - any2: any_type + - default: ollama +Outputs: +-------------------------------------------------- +Node: AnyNodeAnthropic +Category: Unknown +Inputs: + Required: + - multiline: True + - default: claude-3-5-sonnet-20240620 + Optional: + - any: any_type + - any2: any_type +Outputs: +-------------------------------------------------- +Node: AnyNodeCodeViewer: + @classmethod + def INPUT_TYPES +Category: utils +Inputs: + Required: + - ctrl: CTRL, {"forceInput": True} + Optional: + - multiline: True + - default: No Comment yet. +Outputs: + - control (CTRL) +-------------------------------------------------- +Node: ShowText: + @classmethod + def INPUT_TYPES +Category: utils +Inputs: + Required: + - text: STRING, {"forceInput": True} + Optional: +Outputs: + - STRING +-------------------------------------------------- +Node: ConstrainImage: + """ + A node that constrains an image to a maximum and minimum size while maintaining aspect ratio. + """ + + @classmethod + def INPUT_TYPES +Category: image +Description: A node that constrains an image to a maximum and minimum size while maintaining aspect ratio. +Inputs: + Required: + - images: IMAGE + - max_width: INT, {"default": 1024, min": 0} + - max_height: INT, {"default": 1024, min": 0} + - min_width: INT, {"default": 0, min": 0} + - min_height: INT, {"default": 0, min": 0} + - crop_if_required: ["yes, no"], {"default": "no"} + Optional: +Outputs: + - IMAGE +-------------------------------------------------- +Node: AnyType +Category: Unknown +Inputs: + Required: + Optional: +Outputs: +-------------------------------------------------- +Node: ReroutePrimitive: + @classmethod + def INPUT_TYPES +Category: __hidden__ +Inputs: + Required: + - {"value: any + Optional: +Outputs: + - any +-------------------------------------------------- +Node: MultiPrimitive: + @classmethod + def INPUT_TYPES +Category: utils +Inputs: + Required: + Optional: + - {"value: any +Outputs: + - any +-------------------------------------------------- +Node: MathExpression: + + @classmethod + def INPUT_TYPES +Category: utils +Inputs: + Required: + - words: autocompleteWords + - separator: + Optional: + - a: any + - b: any + - c: any +Outputs: + - INT + - FLOAT +-------------------------------------------------- +Node: ConstrainImageforVideo: + """ + A node that constrains an image to a maximum and minimum size while maintaining aspect ratio. + """ + + @classmethod + def INPUT_TYPES +Category: image +Description: A node that constrains an image to a maximum and minimum size while maintaining aspect ratio. +Inputs: + Required: + - images: IMAGE + - max_width: INT, {"default": 1024, min": 0} + - max_height: INT, {"default": 1024, min": 0} + - min_width: INT, {"default": 0, min": 0} + - min_height: INT, {"default": 0, min": 0} + - crop_if_required: ["yes, no"], {"default": "no"} + Optional: +Outputs: + - IMAGE (IMAGE) +-------------------------------------------------- +Node: LoraLoaderWithImages +Category: Unknown +Inputs: + Required: + Optional: +Outputs: + - *getattr(LoraLoader (*LoraLoader.RETURN_TYPES) + - RETURN_NAMES (STRING) +-------------------------------------------------- +Node: CheckpointLoaderSimpleWithImages +Category: Unknown +Inputs: + Required: + Optional: +Outputs: + - *getattr(CheckpointLoaderSimple (*CheckpointLoaderSimple.RETURN_TYPES) + - RETURN_NAMES (STRING) +-------------------------------------------------- +Node: PlaySound: + @classmethod + def INPUT_TYPES +Category: utils +Inputs: + Required: + - any: any, {} + - mode: ["always, on empty queue"], {} + - volume: FLOAT, {"min": 0, max": 1, step": 0.1, default": 0.5} + - file: STRING, { "default": "notify.mp3" } + Optional: +Outputs: + - any +-------------------------------------------------- +Node: TextFileNode: + RETURN_TYPES = +Category: utils +Inputs: + Required: + Optional: +Outputs: + - STRING +-------------------------------------------------- +Node: LoadText +Category: Unknown +Inputs: + Required: + - root_dir: list(get_valid_dirs( + - source: root_dir + - type: set + - target: $this.disabled + - value: False + - url: /pysssss/text-file/{$source.value} + Optional: +Outputs: +-------------------------------------------------- +Node: SaveText +Category: Unknown +Inputs: + Required: + - root_dir: list(get_valid_dirs( + - file: STRING, {"default": "file.txt"} + - append: ["append, overwrite, new only"], {} + - default: True + - source: append + - type: set + - left: $source.value + - op: eq + - right: append + - target: $this.disabled + - value: True + - text: STRING, {"forceInput": True, multiline": True} + Optional: +Outputs: +-------------------------------------------------- +Node: Repeater: + @classmethod + def INPUT_TYPES +Category: utils +Inputs: + Required: + - source: any, {} + - repeats: INT, {"min": 0, max": 5000, default": 2} + - output: ["single, multi"], {} + - node_mode: ["reuse, create"], {} + Optional: +Outputs: + - any +-------------------------------------------------- +Node: SystemNotification: + @classmethod + def INPUT_TYPES +Category: utils +Inputs: + Required: + - message: STRING, {"default": "Your notification has triggered."} + - any: any, {} + - mode: ["always, on empty queue"], {} + Optional: +Outputs: + - any +-------------------------------------------------- +Node: StringFunction: + @classmethod + def INPUT_TYPES +Category: utils +Inputs: + Required: + - action: ["append, replace"], {} + - tidy_tags: ["yes, no"], {} + Optional: + - text_a: STRING, {"multiline": True, dynamicPrompts": False} + - text_b: STRING, {"multiline": True, dynamicPrompts": False} + - text_c: STRING, {"multiline": True, dynamicPrompts": False} +Outputs: + - STRING +-------------------------------------------------- +Node: Yolov8DetectionNode: + def __init__ +Category: yolov8 +Inputs: + Required: + - image: IMAGE + - model_name: folder_paths.get_filename_list("yolov8 + Optional: +Outputs: + - IMAGE + - JSON +-------------------------------------------------- +Node: Yolov8SegNode: + def __init__ +Category: yolov8 +Inputs: + Required: + - image: IMAGE + - model_name: folder_paths.get_filename_list("yolov8 + - class_id: INT, {"default": 0} + Optional: +Outputs: + - IMAGE + - MASK +-------------------------------------------------- +Node: is 0 +Category: Unknown +Inputs: + Required: + Optional: +Outputs: +-------------------------------------------------- +Node: IFWhisperSpeech: + @classmethod + def INPUT_TYPES +Category: ImpactFrames💥🎞️ +Description: \ + Electromagnetism is a fundamental force of nature that encompasses the interaction between + electrically charged particles. It is described by Maxwell's equations, which unify electricity, magnetism, + and light into a single theory. In essence, electric charges produce electric fields that exert forces on + other charges, while moving charges (currents) generate magnetic fields. These magnetic fields, in turn, + can affect the motion of charges and currents. The interaction between electric and magnetic fields propagates + through space as electromagnetic waves, which include visible light, radio waves, and X-rays. Electromagnetic + forces are responsible for practically all the phenomena encountered in daily life, excluding gravity. +Inputs: + Required: + - text: STRING, {"multiline": True, default": node.sample_text} + - file_name: STRING, {"default": node.file_name} + - speaker: node.audio_files, {} + - torch_compile: BOOLEAN, {"default": False} + Optional: + - cps: FLOAT, {"default": node.cps, min": 10.0, max": 20.0, step": 0.25} + - overlap: FLOAT, {"default": node.overlap, min": 0.0, max": 200.0, step": 0.25} +Outputs: + - audios (AUDIO) + - wav_16k_path (STRING) + - output_audio (AUDIO) +-------------------------------------------------- +Node: FL_GradGenerator: + @classmethod + def INPUT_TYPES +Category: 🏵️Fill Nodes/experiments +Inputs: + Required: + - width: INT, {"default": 512, min": 64, max": 4096} + - height: INT, {"default": 512, min": 64, max": 4096} + - color_mode: ["RGB, HSV"] + - interpolation: ["Linear, Ease In, Ease Out, Ease In-Out"] + - gradient_colors: STRING, {"default": "[]"} + Optional: +Outputs: + - IMAGE +-------------------------------------------------- +Node: FL_SaveWebPImage +Category: 🏵️Fill Nodes/Image +Inputs: + Required: + - {"images: IMAGE + - filename_prefix: STRING, {"default": "ComfyUI"} + - quality: INT, {"default": 80, min": 1, max": 100, step": 1} + Optional: +Outputs: + - IMAGE + - STRING +-------------------------------------------------- +Node: EventHandler +Category: utils +Inputs: + Required: + - javascript: STRING, {"default": , multiline": True} + Optional: +Outputs: +-------------------------------------------------- +Node: DownloadAndLoadGIMMVFIModel: + @classmethod + def INPUT_TYPES +Category: GIMM-VFI +Inputs: + Required: + Optional: + - precision: ["fp32, bf16, fp16"], {"default": "fp32"} + - torch_compile: BOOLEAN, {"default": False, tooltip": "Compile part of the model with torch.compile, requires Triton"} +Outputs: + - gimmvfi_model (GIMMVIF_MODEL) +-------------------------------------------------- +Node: GIMMVFI_interpolate: + @classmethod + def INPUT_TYPES +Category: PyramidFlowWrapper +Inputs: + Required: + - gimmvfi_model: GIMMVIF_MODEL + - images: IMAGE, {"tooltip": "The images to interpolate between"} + - ds_factor: FLOAT, {"default": 1.0, min": 0.01, max": 1.0, step": 0.01} + - interpolation_factor: INT, {"default": 8, min": 1, max": 100, step": 1} + - seed: INT, {"default": 0, min": 0, max": 0xffffffffffffffff} + Optional: + - output_flows: BOOLEAN, {"default": False, tooltip": "Output the flow tensors"} +Outputs: + - images (IMAGE) + - flow_tensors (IMAGE) +-------------------------------------------------- +Node: Film: + + def __init__ +Category: 😺dzNodes/LayerFilter +Inputs: + Required: + - image: IMAGE + - center_x: FLOAT, {"default": 0.5, min": 0, max": 1, step": 0.01} + - center_y: FLOAT, {"default": 0.5, min": 0, max": 1, step": 0.01} + - saturation: FLOAT, {"default": 1, min": 0.01, max": 3, step": 0.01} + - vignette_intensity: FLOAT, {"default": 0.5, min": 0, max": 1, step": 0.01} + - grain_power: FLOAT, {"default": 0.15, min": 0, max": 1, step": 0.01} + - grain_scale: FLOAT, {"default": 1.0, min": 0.1, max": 10, step": 0.1} + - grain_sat: FLOAT, {"default": 0.5, min": 0, max": 1, step": 0.01} + - grain_shadows: FLOAT, {"default": 0.6, min": 0, max": 1, step": 0.01} + - grain_highs: FLOAT, {"default": 0.2, min": 0, max": 1, step": 0.01} + - blur_strength: INT, {"default": 90, min": 0, max": 256, step": 1} + - blur_focus_spread: FLOAT, {"default": 2.2, min": 0.1, max": 8, step": 0.1} + - focal_depth: FLOAT, {"default": 0.9, min": 0.0, max": 1, step": 0.01} + Optional: + - depth_map: IMAGE +Outputs: + - image (IMAGE) +-------------------------------------------------- +Node: ExtendCanvasV2: + + def __init__ +Category: 😺dzNodes/LayerUtility +Inputs: + Required: + - image: IMAGE + - invert_mask: BOOLEAN, {"default": True} + - top: INT, {"default": 0, min": -99999, max": 99999, step": 1} + - bottom: INT, {"default": 0, min": -99999, max": 99999, step": 1} + - left: INT, {"default": 0, min": -99999, max": 99999, step": 1} + - right: INT, {"default": 0, min": -99999, max": 99999, step": 1} + - color: STRING, {"default": "#000000"} + Optional: + - mask: MASK +Outputs: + - image (IMAGE) + - mask (MASK) +-------------------------------------------------- +Node: DropShadowV3: + + def __init__ +Category: 😺dzNodes/LayerStyle +Inputs: + Required: + - layer_image: IMAGE + - invert_mask: BOOLEAN, {"default": True} + - blend_mode: chop_mode_v2 + - opacity: INT, {"default": 50, min": 0, max": 100, step": 1} + - distance_x: INT, {"default": 25, min": -9999, max": 9999, step": 1} + - distance_y: INT, {"default": 25, min": -9999, max": 9999, step": 1} + - grow: INT, {"default": 6, min": -9999, max": 9999, step": 1} + - blur: INT, {"default": 18, min": 0, max": 1000, step": 1} + - shadow_color: STRING, {"default": "#000000"} + Optional: + - background_image: IMAGE + - layer_mask: MASK +Outputs: + - image (IMAGE) +-------------------------------------------------- +Node: ImageMaskScaleAs: + + def __init__ +Category: 😺dzNodes/LayerUtility +Inputs: + Required: + - scale_as: any, {} + - fit: fit_mode + - method: method_mode + Optional: + - image: IMAGE + - mask: MASK +Outputs: + - image (IMAGE) + - mask (MASK) + - original_size (BOX) + - widht (INT) + - height (INT) +-------------------------------------------------- +Node: LS_ImageMaskScaleAsV2: + + def __init__ +Category: 😺dzNodes/LayerUtility +Inputs: + Required: + - scale_as: any, {} + - fit: fit_mode + - method: method_mode + - background_color: STRING, {"default": "#FFFFFF"} + Optional: + - image: IMAGE + - mask: MASK +Outputs: + - image (IMAGE) + - mask (MASK) + - original_size (BOX) + - widht (INT) + - height (INT) +-------------------------------------------------- +Node: ColorAdapter: + + def __init__ +Category: 😺dzNodes/LayerColor +Inputs: + Required: + - image: IMAGE + - color_ref_image: IMAGE + - opacity: INT, {"default": 75, min": 0, max": 100, step": 1} + Optional: +Outputs: + - image (IMAGE) +-------------------------------------------------- +Node: ColorCorrectShadowAndHighlight: + + def __init__ +Category: 😺dzNodes/LayerColor +Inputs: + Required: + - image: IMAGE + - shadow_brightness: FLOAT, {"default": 1, min": 0.0, max": 3, step": 0.01} + - shadow_saturation: FLOAT, {"default": 1, min": 0.0, max": 3, step": 0.01} + - shadow_hue: INT, {"default": 0, min": -255, max": 255, step": 1} + - shadow_level_offset: INT, {"default": 0, min": -99, max": 99, step": 1} + - shadow_range: FLOAT, {"default": 0.25, min": 0.01, max": 0.99, step": 0.01} + - highlight_brightness: FLOAT, {"default": 1, min": 0.0, max": 3, step": 0.01} + - highlight_saturation: FLOAT, {"default": 1, min": 0.0, max": 3, step": 0.01} + - highlight_hue: INT, {"default": 0, min": -255, max": 255, step": 1} + - highlight_level_offset: INT, {"default": 0, min": -99, max": 99, step": 1} + - highlight_range: FLOAT, {"default": 0.25, min": 0.01, max": 0.99, step": 0.01} + Optional: + - mask: MASK +Outputs: + - image (IMAGE) +-------------------------------------------------- +Node: LS_ColorCorrectShadow_And_Highlight_V2: + + def __init__ +Category: 😺dzNodes/LayerColor +Inputs: + Required: + - image: IMAGE + - shadow_brightness: FLOAT, {"default": 1, min": 0.0, max": 3, step": 0.01} + - shadow_saturation: FLOAT, {"default": 1, min": 0.0, max": 3, step": 0.01} + - shadow_hue: INT, {"default": 0, min": -255, max": 255, step": 1} + - shadow_level_offset: INT, {"default": 0, min": -99, max": 99, step": 1} + - shadow_range: FLOAT, {"default": 0.25, min": 0.01, max": 0.99, step": 0.01} + - highlight_brightness: FLOAT, {"default": 1, min": 0.0, max": 3, step": 0.01} + - highlight_saturation: FLOAT, {"default": 1, min": 0.0, max": 3, step": 0.01} + - highlight_hue: INT, {"default": 0, min": -255, max": 255, step": 1} + - highlight_level_offset: INT, {"default": 0, min": -99, max": 99, step": 1} + - highlight_range: FLOAT, {"default": 0.25, min": 0.01, max": 0.99, step": 0.01} + Optional: + - mask: MASK +Outputs: + - image (IMAGE) +-------------------------------------------------- +Node: ColorImageV2: + + def __init__ +Category: 😺dzNodes/LayerUtility +Inputs: + Required: + - size: size_list + - custom_width: INT, {"default": 512, min": 4, max": 99999, step": 1} + - custom_height: INT, {"default": 512, min": 4, max": 99999, step": 1} + - color: STRING, {"default": "#000000"} + Optional: + - size_as: any, {} +Outputs: + - image (IMAGE) +-------------------------------------------------- +Node: GradientMap: + def __init__ +Category: 😺dzNodes/LayerStyle +Inputs: + Required: + - image: IMAGE + - start_color: STRING, {"default": "#015A52"} + - mid_color: STRING, {"default": "#02AF9F"} + - end_color: STRING, {"default": "#7FFFEC"} + - mid_point: FLOAT, {"default": 0.6, min": 0.0, max": 1.0, step": 0.01} + - opacity: INT, {"default": 100, min": 0, max": 100, step": 1} + Optional: + - layer_mask: MASK +Outputs: + - image (IMAGE) + - gradient (IMAGE) +-------------------------------------------------- +Node: ImageOpacity: + + def __init__ +Category: 😺dzNodes/LayerUtility +Inputs: + Required: + - image: IMAGE + - opacity: INT, {"default": 100, min": 0, max": 100, step": 1} + - invert_mask: BOOLEAN, {"default": True} + Optional: + - mask: MASK +Outputs: + - image (IMAGE) + - mask (MASK) +-------------------------------------------------- +Node: MaskGrain: + + def __init__ +Category: 😺dzNodes/LayerMask +Inputs: + Required: + - mask: MASK + - grain: INT, {"default": 6, min": 0, max": 127, step": 1} + - invert_mask: BOOLEAN, {"default": False} + Optional: +Outputs: + - mask (MASK) +-------------------------------------------------- +Node: ImageChannelSplit: + + def __init__ +Category: 😺dzNodes/LayerUtility +Inputs: + Required: + - image: IMAGE + - mode: channel_mode + Optional: +Outputs: + - channel_1 (IMAGE) + - channel_2 (IMAGE) + - channel_3 (IMAGE) + - channel_4 (IMAGE) +-------------------------------------------------- +Node: LayerImageTransform: + + def __init__ +Category: 😺dzNodes/LayerUtility +Inputs: + Required: + - image: IMAGE + - x: INT, {"default": 0, min": -99999, max": 99999, step": 1} + - y: INT, {"default": 0, min": -99999, max": 99999, step": 1} + - mirror: mirror_mode + - scale: FLOAT, {"default": 1, min": 0.01, max": 100, step": 0.01} + - aspect_ratio: FLOAT, {"default": 1, min": 0.01, max": 100, step": 0.01} + - rotate: FLOAT, {"default": 0, min": -999999, max": 999999, step": 0.01} + - transform_method: method_mode + - anti_aliasing: INT, {"default": 2, min": 0, max": 16, step": 1} + Optional: +Outputs: + - image (IMAGE) +-------------------------------------------------- +Node: ImageShift: + + def __init__ +Category: 😺dzNodes/LayerUtility +Inputs: + Required: + - image: IMAGE + - shift_x: INT, {"default": 256, min": -9999, max": 9999, step": 1} + - shift_y: INT, {"default": 256, min": -9999, max": 9999, step": 1} + - cyclic: BOOLEAN, {"default": True} + - background_color: STRING, {"default": "#000000"} + - border_mask_width: INT, {"default": 20, min": 0, max": 999, step": 1} + - border_mask_blur: INT, {"default": 12, min": 0, max": 999, step": 1} + Optional: + - mask: MASK +Outputs: + - image (IMAGE) + - mask (MASK) + - border_mask (MASK) +-------------------------------------------------- +Node: StrokeV2: + + def __init__ +Category: 😺dzNodes/LayerStyle +Inputs: + Required: + - background_image: IMAGE + - layer_image: IMAGE + - invert_mask: BOOLEAN, {"default": True} + - blend_mode: chop_mode_v2 + - opacity: INT, {"default": 100, min": 0, max": 100, step": 1} + - stroke_grow: INT, {"default": 0, min": -999, max": 999, step": 1} + - stroke_width: INT, {"default": 8, min": 0, max": 999, step": 1} + - blur: INT, {"default": 0, min": 0, max": 100, step": 1} + - stroke_color: STRING, {"default": "#FF0000"} + Optional: + - layer_mask: MASK +Outputs: + - image (IMAGE) +-------------------------------------------------- +Node: GaussianBlur: + + def __init__ +Category: 😺dzNodes/LayerFilter +Inputs: + Required: + - image: IMAGE + - blur: INT, {"default": 20, min": 1, max": 999, step": 1} + Optional: +Outputs: + - image (IMAGE) +-------------------------------------------------- +Node: LS_GaussianBlurV2: + + def __init__ +Category: 😺dzNodes/LayerFilter +Inputs: + Required: + - image: IMAGE + - blur: FLOAT, {"default": 20, min": 0, max": 1000, step": 0.05} + Optional: +Outputs: + - image (IMAGE) +-------------------------------------------------- +Node: SoftLight: + + def __init__ +Category: 😺dzNodes/LayerFilter +Inputs: + Required: + - image: IMAGE + - soft: FLOAT, {"default": 1, min": 0.2, max": 10, step": 0.01} + - threshold: INT, {"default": -10, min": -255, max": 255, step": 1} + - opacity: INT, {"default": 100, min": 0, max": 100, step": 1} + Optional: +Outputs: + - image (IMAGE) +-------------------------------------------------- +Node: ColorCorrectExposure: + + def __init__ +Category: 😺dzNodes/LayerColor +Inputs: + Required: + - image: IMAGE + - exposure: INT, {"default": 20, min": -100, max": 100, step": 1} + Optional: +Outputs: + - image (IMAGE) +-------------------------------------------------- +Node: ColorCorrectLUTapply: + + def __init__ +Category: 😺dzNodes/LayerColor +Inputs: + Required: + - image: IMAGE + - LUT: LUT_LIST + - color_space: color_space_list + - strength: INT, {"default": 100, min": 0, max": 100, step": 1} + Optional: +Outputs: + - image (IMAGE) +-------------------------------------------------- +Node: ColorCorrectYUV: + + def __init__ +Category: 😺dzNodes/LayerColor +Inputs: + Required: + - image: IMAGE + - Y: INT, {"default": 0, min": -255, max": 255, step": 1} + - U: INT, {"default": 0, min": -255, max": 255, step": 1} + - V: INT, {"default": 0, min": -255, max": 255, step": 1} + Optional: +Outputs: + - image (IMAGE) +-------------------------------------------------- +Node: ImageHub: + + def __init__ +Category: 😺dzNodes/LayerUtility +Inputs: + Required: + - output: INT, {"default": 1, min": 1, max": 9, step": 1} + - random_output: BOOLEAN, {"default": False} + Optional: + - input1_image: IMAGE + - input1_mask: MASK + - input2_image: IMAGE + - input2_mask: MASK + - input3_image: IMAGE + - input3_mask: MASK + - input4_image: IMAGE + - input4_mask: MASK + - input5_image: IMAGE + - input5_mask: MASK + - input6_image: IMAGE + - input6_mask: MASK + - input7_image: IMAGE + - input7_mask: MASK + - input8_image: IMAGE + - input8_mask: MASK + - input9_image: IMAGE + - input9_mask: MASK +Outputs: + - image (IMAGE) + - mask (MASK) +-------------------------------------------------- +Node: DropShadowV2: + + def __init__ +Category: 😺dzNodes/LayerStyle +Inputs: + Required: + - background_image: IMAGE + - layer_image: IMAGE + - invert_mask: BOOLEAN, {"default": True} + - blend_mode: chop_mode_v2 + - opacity: INT, {"default": 50, min": 0, max": 100, step": 1} + - distance_x: INT, {"default": 25, min": -9999, max": 9999, step": 1} + - distance_y: INT, {"default": 25, min": -9999, max": 9999, step": 1} + - grow: INT, {"default": 6, min": -9999, max": 9999, step": 1} + - blur: INT, {"default": 18, min": 0, max": 100, step": 1} + - shadow_color: STRING, {"default": "#000000"} + Optional: + - layer_mask: MASK +Outputs: + - image (IMAGE) +-------------------------------------------------- +Node: ColorOverlayV2: + + def __init__ +Category: 😺dzNodes/LayerStyle +Inputs: + Required: + - background_image: IMAGE + - layer_image: IMAGE + - invert_mask: BOOLEAN, {"default": True} + - blend_mode: chop_mode_v2 + - opacity: INT, {"default": 100, min": 0, max": 100, step": 1} + - color: STRING, {"default": "#FFBF30"} + Optional: + - layer_mask: MASK +Outputs: + - image (IMAGE) +-------------------------------------------------- +Node: MaskStroke: + + def __init__ +Category: 😺dzNodes/LayerMask +Inputs: + Required: + - mask: MASK + - invert_mask: BOOLEAN, {"default": True} + - stroke_grow: INT, {"default": 0, min": -999, max": 999, step": 1} + - stroke_width: INT, {"default": 20, min": 0, max": 999, step": 1} + - blur: INT, {"default": 6, min": 0, max": 100, step": 1} + Optional: +Outputs: + - mask (MASK) +-------------------------------------------------- +Node: AddGrain: + + def __init__ +Category: 😺dzNodes/LayerFilter +Inputs: + Required: + - image: IMAGE + - grain_power: FLOAT, {"default": 0.5, min": 0, max": 1, step": 0.01} + - grain_scale: FLOAT, {"default": 1, min": 0.1, max": 10, step": 0.1} + - grain_sat: FLOAT, {"default": 1, min": 0, max": 1, step": 0.01} + Optional: +Outputs: + - image (IMAGE) +-------------------------------------------------- +Node: AutoAdjustV2: + + def __init__ +Category: 😺dzNodes/LayerColor +Inputs: + Required: + - image: IMAGE + - strength: INT, {"default": 100, min": 0, max": 100, step": 1} + - brightness: INT, {"default": 0, min": -100, max": 100, step": 1} + - contrast: INT, {"default": 0, min": -100, max": 100, step": 1} + - saturation: INT, {"default": 0, min": -100, max": 100, step": 1} + - red: INT, {"default": 0, min": -100, max": 100, step": 1} + - green: INT, {"default": 0, min": -100, max": 100, step": 1} + - blue: INT, {"default": 0, min": -100, max": 100, step": 1} + - mode: mode_list + Optional: + - mask: MASK +Outputs: + - image (IMAGE) +-------------------------------------------------- +Node: RestoreCropBox: + + def __init__ +Category: 😺dzNodes/LayerUtility +Inputs: + Required: + - background_image: IMAGE + - croped_image: IMAGE + - invert_mask: BOOLEAN, {"default": False} + - crop_box: BOX + Optional: + - croped_mask: MASK +Outputs: + - image (IMAGE) + - mask (MASK) +-------------------------------------------------- +Node: ColorValuetoRGBValue: + + def __init__ +Category: 😺dzNodes/LayerUtility/Data +Inputs: + Required: + - color_value: any, {} + Optional: +Outputs: + - R (INT) + - G (INT) + - B (INT) +-------------------------------------------------- +Node: ICMask_Data: + def __init__ +Category: Unknown +Inputs: + Required: + Optional: +Outputs: +-------------------------------------------------- +Node: LS_ICMask: + def __init__ +Category: 😺dzNodes/LayerUtility +Inputs: + Required: + - first_image: IMAGE + - default: #FFFFFF + Optional: + - first_mask: MASK + - second_image: IMAGE + - second_mask: MASK +Outputs: + - image (IMAGE) + - mask (MASK) + - icmask_data (ICMASK_DATA) +-------------------------------------------------- +Node: LS_ICMask_CropBack: + + def __init__ +Category: 😺dzNodes/LayerUtility +Inputs: + Required: + - { "image: IMAGE + - icmask_data: ICMASK_DATA + Optional: +Outputs: + - IMAGE +-------------------------------------------------- +Node: PrintInfo: + + @classmethod + def INPUT_TYPES +Category: 😺dzNodes/LayerUtility/Data +Inputs: + Required: + - anything: any, {} + Optional: +Outputs: + - text (STRING) +-------------------------------------------------- +Node: ImageScaleByAspectRatioV2: + + def __init__ +Category: 😺dzNodes/LayerUtility +Inputs: + Required: + - aspect_ratio: ratio_list + - proportional_width: INT, {"default": 1, min": 1, max": 1e8, step": 1} + - proportional_height: INT, {"default": 1, min": 1, max": 1e8, step": 1} + - fit: fit_mode + - method: method_mode + - round_to_multiple: multiple_list + - scale_to_side: scale_to_list + - scale_to_length: INT, {"default": 1024, min": 4, max": 1e8, step": 1} + - background_color: STRING, {"default": "#000000"} + Optional: + - image: IMAGE + - mask: MASK +Outputs: + - image (IMAGE) + - mask (MASK) + - original_size (BOX) + - width (INT) + - height (INT) +-------------------------------------------------- +Node: MaskMotionBlur: + + def __init__ +Category: 😺dzNodes/LayerMask +Inputs: + Required: + - mask: MASK + - invert_mask: BOOLEAN, {"default": True} + - blur: INT, {"default": 20, min": 1, max": 9999, step": 1} + - angle: FLOAT, {"default": 0, min": -360, max": 360, step": 0.1} + Optional: +Outputs: + - mask (MASK) +-------------------------------------------------- +Node: CheckMask: + + def __init__ +Category: 😺dzNodes/LayerUtility +Inputs: + Required: + - mask: MASK + - white_point: INT, {"default": 1, min": 1, max": 254, step": 1} + - area_percent: INT, {"default": 1, min": 1, max": 99, step": 1} + Optional: +Outputs: + - bool (BOOLEAN) +-------------------------------------------------- +Node: FilmV2: + + def __init__ +Category: 😺dzNodes/LayerFilter +Inputs: + Required: + - image: IMAGE + - center_x: FLOAT, {"default": 0.5, min": 0, max": 1, step": 0.01} + - center_y: FLOAT, {"default": 0.5, min": 0, max": 1, step": 0.01} + - saturation: FLOAT, {"default": 1, min": 0.01, max": 3, step": 0.01} + - vignette_intensity: FLOAT, {"default": 0.5, min": 0, max": 1, step": 0.01} + - grain_method: grain_method_list + - grain_power: FLOAT, {"default": 0.15, min": 0, max": 1, step": 0.01} + - grain_scale: FLOAT, {"default": 1, min": 0.1, max": 10, step": 0.1} + - grain_sat: FLOAT, {"default": 0.5, min": 0, max": 1, step": 0.01} + - filmgrainer_shadows: FLOAT, {"default": 0.6, min": 0, max": 1, step": 0.01} + - filmgrainer_highs: FLOAT, {"default": 0.2, min": 0, max": 1, step": 0.01} + - blur_strength: INT, {"default": 90, min": 0, max": 256, step": 1} + - blur_focus_spread: FLOAT, {"default": 2.2, min": 0.1, max": 8, step": 0.1} + - focal_depth: FLOAT, {"default": 0.9, min": 0.0, max": 1, step": 0.01} + Optional: + - depth_map: IMAGE +Outputs: + - image (IMAGE) +-------------------------------------------------- +Node: ColorBalance: + + def __init__ +Category: 😺dzNodes/LayerColor +Inputs: + Required: + - image: IMAGE + - cyan_red: FLOAT, {"default": 0, min": -1.0, max": 1.0, step": 0.001} + - magenta_green: FLOAT, {"default": 0, min": -1.0, max": 1.0, step": 0.001} + - yellow_blue: FLOAT, {"default": 0, min": -1.0, max": 1.0, step": 0.001} + Optional: +Outputs: + - image (IMAGE) +-------------------------------------------------- +Node: ColorOverlay: + + def __init__ +Category: 😺dzNodes/LayerStyle +Inputs: + Required: + - background_image: IMAGE + - layer_image: IMAGE + - invert_mask: BOOLEAN, {"default": True} + - blend_mode: chop_mode + - opacity: INT, {"default": 100, min": 0, max": 100, step": 1} + - color: STRING, {"default": "#FFBF30"} + Optional: + - layer_mask: MASK +Outputs: + - image (IMAGE) +-------------------------------------------------- +Node: PixelSpread: + + def __init__ +Category: 😺dzNodes/LayerMask +Inputs: + Required: + - image: IMAGE + - invert_mask: BOOLEAN, {"default": False} + - mask_grow: INT, {"default": 0, min": -999, max": 999, step": 1} + Optional: + - mask: MASK +Outputs: + - image (IMAGE) +-------------------------------------------------- +Node: GradientOverlayV2: + + def __init__ +Category: 😺dzNodes/LayerStyle +Inputs: + Required: + - background_image: IMAGE + - layer_image: IMAGE + - invert_mask: BOOLEAN, {"default": True} + - blend_mode: chop_mode_v2 + - opacity: INT, {"default": 100, min": 0, max": 100, step": 1} + - start_color: STRING, {"default": "#FFBF30"} + - start_alpha: INT, {"default": 255, min": 0, max": 255, step": 1} + - end_color: STRING, {"default": "#FE0000"} + - end_alpha: INT, {"default": 255, min": 0, max": 255, step": 1} + - angle: INT, {"default": 0, min": -180, max": 180, step": 1} + Optional: + - layer_mask: MASK +Outputs: + - image (IMAGE) +-------------------------------------------------- +Node: SegformerPipeline: + def __init__ +Category: Unknown +Inputs: + Required: + Optional: +Outputs: +-------------------------------------------------- +Node: Segformer_B2_Clothes: + + def __init__ +Category: 😺dzNodes/LayerMask +Inputs: + Required: + - image: IMAGE + - face: BOOLEAN, {"default": False} + - hair: BOOLEAN, {"default": False} + - hat: BOOLEAN, {"default": False} + - sunglass: BOOLEAN, {"default": False} + - left_arm: BOOLEAN, {"default": False} + - right_arm: BOOLEAN, {"default": False} + - left_leg: BOOLEAN, {"default": False} + - right_leg: BOOLEAN, {"default": False} + - upper_clothes: BOOLEAN, {"default": False} + - skirt: BOOLEAN, {"default": False} + - pants: BOOLEAN, {"default": False} + - dress: BOOLEAN, {"default": False} + - belt: BOOLEAN, {"default": False} + - shoe: BOOLEAN, {"default": False} + - bag: BOOLEAN, {"default": False} + - scarf: BOOLEAN, {"default": False} + - detail_method: method_list + - detail_erode: INT, {"default": 12, min": 1, max": 255, step": 1} + - detail_dilate: INT, {"default": 6, min": 1, max": 255, step": 1} + - FLOAT", {"default: 0.99 + - process_detail: BOOLEAN, {"default": True} + - device: device_list + - max_megapixels: FLOAT, {"default": 2.0, min": 1, max": 999, step": 0.1} + Optional: +Outputs: + - image (IMAGE) + - mask (MASK) +-------------------------------------------------- +Node: SegformerClothesPipelineLoader: + + def __init__ +Category: 😺dzNodes/LayerMask +Inputs: + Required: + - { "model: model_list + - face: BOOLEAN, {"default": False, label_on": "enabled(脸 + - hair: BOOLEAN, {"default": False, label_on": "enabled(头发 + - hat: BOOLEAN, {"default": False, label_on": "enabled(帽子 + - sunglass: BOOLEAN, {"default": False, label_on": "enabled(墨镜 + - left_arm: BOOLEAN, {"default": False, label_on": "enabled(左臂 + - right_arm: BOOLEAN, {"default": False, label_on": "enabled(右臂 + - left_leg: BOOLEAN, {"default": False, label_on": "enabled(左腿 + - right_leg: BOOLEAN, {"default": False, label_on": "enabled(右腿 + - left_shoe: BOOLEAN, {"default": False, label_on": "enabled(左鞋 + - right_shoe: BOOLEAN, {"default": False, label_on": "enabled(右鞋 + - upper_clothes: BOOLEAN, {"default": False, label_on": "enabled(上衣 + - skirt: BOOLEAN, {"default": False, label_on": "enabled(短裙 + - pants: BOOLEAN, {"default": False, label_on": "enabled(裤子 + - dress: BOOLEAN, {"default": False, label_on": "enabled(连衣裙 + - belt: BOOLEAN, {"default": False, label_on": "enabled(腰带 + - bag: BOOLEAN, {"default": False, label_on": "enabled(背包 + - scarf: BOOLEAN, {"default": False, label_on": "enabled(围巾 + Optional: +Outputs: + - segformer_pipeline (SegPipeline) +-------------------------------------------------- +Node: SegformerFashionPipelineLoader: + + def __init__ +Category: 😺dzNodes/LayerMask +Inputs: + Required: + - { "model: model_list + - shirt: BOOLEAN, {"default": False, label_on": "enabled(衬衫、罩衫 + - top: BOOLEAN, {"default": False, label_on": "enabled(上衣、t恤 + - sweater: BOOLEAN, {"default": False, label_on": "enabled(毛衣 + - cardigan: BOOLEAN, {"default": False, label_on": "enabled(开襟毛衫 + - jacket: BOOLEAN, {"default": False, label_on": "enabled(夹克 + - vest: BOOLEAN, {"default": False, label_on": "enabled(背心 + - pants: BOOLEAN, {"default": False, label_on": "enabled(裤子 + - shorts: BOOLEAN, {"default": False, label_on": "enabled(短裤 + - skirt: BOOLEAN, {"default": False, label_on": "enabled(裙子 + - coat: BOOLEAN, {"default": False, label_on": "enabled(外套 + - dress: BOOLEAN, {"default": False, label_on": "enabled(连衣裙 + - jumpsuit: BOOLEAN, {"default": False, label_on": "enabled(连身裤 + - cape: BOOLEAN, {"default": False, label_on": "enabled(斗篷 + - glasses: BOOLEAN, {"default": False, label_on": "enabled(眼镜 + - hat: BOOLEAN, {"default": False, label_on": "enabled(帽子 + - hairaccessory: BOOLEAN, {"default": False, label_on": "enabled(头带 + - tie: BOOLEAN, {"default": False, label_on": "enabled(领带 + - glove: BOOLEAN, {"default": False, label_on": "enabled(手套 + - watch: BOOLEAN, {"default": False, label_on": "enabled(手表 + - belt: BOOLEAN, {"default": False, label_on": "enabled(皮带 + - legwarmer: BOOLEAN, {"default": False, label_on": "enabled(腿套 + - tights: BOOLEAN, {"default": False, label_on": "enabled(裤袜 + - sock: BOOLEAN, {"default": False, label_on": "enabled(袜子 + - shoe: BOOLEAN, {"default": False, label_on": "enabled(鞋子 + - bagwallet: BOOLEAN, {"default": False, label_on": "enabled(手包 + - scarf: BOOLEAN, {"default": False, label_on": "enabled(围巾 + - umbrella: BOOLEAN, {"default": False, label_on": "enabled(雨伞 + - hood: BOOLEAN, {"default": False, label_on": "enabled(兜帽 + - collar: BOOLEAN, {"default": False, label_on": "enabled(衣领 + - lapel: BOOLEAN, {"default": False, label_on": "enabled(翻领 + - epaulette: BOOLEAN, {"default": False, label_on": "enabled(肩章 + - sleeve: BOOLEAN, {"default": False, label_on": "enabled(袖子 + - pocket: BOOLEAN, {"default": False, label_on": "enabled(口袋 + - neckline: BOOLEAN, {"default": False, label_on": "enabled(领口 + - buckle: BOOLEAN, {"default": False, label_on": "enabled(带扣 + - zipper: BOOLEAN, {"default": False, label_on": "enabled(拉链 + - applique: BOOLEAN, {"default": False, label_on": "enabled(贴花 + - bead: BOOLEAN, {"default": False, label_on": "enabled(珠子 + - bow: BOOLEAN, {"default": False, label_on": "enabled(蝴蝶结 + - flower: BOOLEAN, {"default": False, label_on": "enabled(花 + - fringe: BOOLEAN, {"default": False, label_on": "enabled(刘海 + - ribbon: BOOLEAN, {"default": False, label_on": "enabled(丝带 + - rivet: BOOLEAN, {"default": False, label_on": "enabled(铆钉 + - ruffle: BOOLEAN, {"default": False, label_on": "enabled(褶饰 + - sequin: BOOLEAN, {"default": False, label_on": "enabled(亮片 + - tassel: BOOLEAN, {"default": False, label_on": "enabled(流苏 + Optional: +Outputs: + - segformer_pipeline (SegPipeline) +-------------------------------------------------- +Node: SegformerUltraV2: + + def __init__ +Category: 😺dzNodes/LayerMask +Inputs: + Required: + - image: IMAGE + - segformer_pipeline: SegPipeline + - detail_method: method_list + - detail_erode: INT, {"default": 8, min": 1, max": 255, step": 1} + - detail_dilate: INT, {"default": 6, min": 1, max": 255, step": 1} + - black_point: FLOAT, {"default": 0.01, min": 0.01, max": 0.98, step": 0.01, display": "slider"} + - white_point: FLOAT, {"default": 0.99, min": 0.02, max": 0.99, step": 0.01, display": "slider"} + - process_detail: BOOLEAN, {"default": True} + - device: device_list + - max_megapixels: FLOAT, {"default": 2.0, min": 1, max": 999, step": 0.1} + Optional: +Outputs: + - image (IMAGE) + - mask (MASK) +-------------------------------------------------- +Node: LS_HDREffects: + @classmethod + def INPUT_TYPES +Category: 😺dzNodes/LayerFilter +Inputs: + Required: + - {'image: IMAGE, {'default': None} + - hdr_intensity: FLOAT, {'default': 0.5, min': 0.0, max': 5.0, step': 0.01} + - shadow_intensity: FLOAT, {'default': 0.25, min': 0.0, max': 1.0, step': 0.01} + - highlight_intensity: FLOAT, {'default': 0.75, min': 0.0, max': 1.0, step': 0.01} + - gamma_intensity: FLOAT, {'default': 0.25, min': 0.0, max': 1.0, step': 0.01} + - contrast: FLOAT, {'default': 0.1, min': 0.0, max': 1.0, step': 0.01} + - enhance_color: FLOAT, {'default': 0.25, min': 0.0, max': 1.0, step': 0.01} + Optional: +Outputs: + - image (IMAGE) +-------------------------------------------------- +Node: TextImage: + + def __init__ +Category: 😺dzNodes/LayerUtility +Inputs: + Required: + - text: STRING, {"multiline": True, default": "Text"} + - font_file: FONT_LIST + - spacing: INT, {"default": 0, min": -9999, max": 9999, step": 1} + - leading: INT, {"default": 0, min": -9999, max": 9999, step": 1} + - horizontal_border: FLOAT, {"default": 5, min": -100, max": 100, step": 0.1} + - vertical_border: FLOAT, {"default": 5, min": -100, max": 100, step": 0.1} + - scale: FLOAT, {"default": 80, min": 0.1, max": 999, step": 0.01} + - variation_range: INT, {"default": 0, min": 0, max": 100, step": 1} + - variation_seed: INT, {"default": random_seed, min": 0, max": 999999999999, step": 1} + - layout: layout_list + - width: INT, {"default": 512, min": 4, max": 999999, step": 1} + - height: INT, {"default": 512, min": 4, max": 999999, step": 1} + - text_color: STRING, {"default": "#FFA000"} + - background_color: STRING, {"default": "#FFFFFF"} + Optional: + - size_as: any, {} +Outputs: + - image (IMAGE) + - mask (MASK) +-------------------------------------------------- +Node: TextJoin: + + def __init__ +Category: 😺dzNodes/LayerUtility/Data +Inputs: + Required: + - text_1: STRING, {"default": , multiline": False, forceInput":False} + Optional: + - text_2: STRING, {"default": , multiline": False, forceInput":False} + - text_3: STRING, {"default": , multiline": False, forceInput":False} + - text_4: STRING, {"default": , multiline": False, forceInput":False} +Outputs: + - text (STRING) +-------------------------------------------------- +Node: LS_TextJoinV2: + + def __init__ +Category: 😺dzNodes/LayerUtility/Data +Inputs: + Required: + - text_1: STRING, {"default": , multiline": False, forceInput":True} + - delimiter: STRING, {"default": , , multiline": False} + Optional: + - text_2: STRING, {"default": , multiline": False, forceInput":True} + - text_3: STRING, {"default": , multiline": False, forceInput":True} + - text_4: STRING, {"default": , multiline": False, forceInput":True} +Outputs: + - text (STRING) +-------------------------------------------------- +Node: ImageBlendAdvance: + + def __init__ +Category: 😺dzNodes/LayerUtility +Inputs: + Required: + - background_image: IMAGE + - layer_image: IMAGE + - invert_mask: BOOLEAN, {"default": True} + - blend_mode: chop_mode + - opacity: INT, {"default": 100, min": 0, max": 100, step": 1} + - x_percent: FLOAT, {"default": 50, min": -999, max": 999, step": 0.01} + - y_percent: FLOAT, {"default": 50, min": -999, max": 999, step": 0.01} + - mirror: mirror_mode + - scale: FLOAT, {"default": 1, min": 0.01, max": 100, step": 0.01} + - aspect_ratio: FLOAT, {"default": 1, min": 0.01, max": 100, step": 0.01} + - rotate: FLOAT, {"default": 0, min": -999999, max": 999999, step": 0.01} + - transform_method: method_mode + - anti_aliasing: INT, {"default": 0, min": 0, max": 16, step": 1} + Optional: + - layer_mask: MASK +Outputs: + - image (IMAGE) + - mask (MASK) +-------------------------------------------------- +Node: MaskEdgeUltraDetailV2: + def __init__ +Category: 😺dzNodes/LayerMask +Inputs: + Required: + - image: IMAGE + - mask: MASK + - method: method_list + - mask_grow: INT, {"default": 0, min": 0, max": 256, step": 1} + - fix_gap: INT, {"default": 0, min": 0, max": 32, step": 1} + - fix_threshold: FLOAT, {"default": 0.75, min": 0.01, max": 0.99, step": 0.01} + - edge_erode: INT, {"default": 6, min": 1, max": 255, step": 1} + - edte_dilate: INT, {"default": 6, min": 1, max": 255, step": 1} + - black_point: FLOAT, {"default": 0.01, min": 0.01, max": 0.98, step": 0.01, display": "slider"} + - white_point: FLOAT, {"default": 0.99, min": 0.02, max": 0.99, step": 0.01, display": "slider"} + - device: device_list + - max_megapixels: FLOAT, {"default": 2.0, min": 1, max": 999, step": 0.1} + Optional: +Outputs: + - image (IMAGE) + - mask (MASK) +-------------------------------------------------- +Node: WaterColor: + + def __init__ +Category: 😺dzNodes/LayerFilter +Inputs: + Required: + - image: IMAGE + - line_density: INT, {"default": 50, min": 1, max": 100, step": 1} + - opacity: INT, {"default": 100, min": 0, max": 100, step": 1} + Optional: +Outputs: + - image (IMAGE) +-------------------------------------------------- +Node: CropByMask: + + def __init__ +Category: 😺dzNodes/LayerUtility +Inputs: + Required: + - image: IMAGE + - mask_for_crop: MASK + - invert_mask: BOOLEAN, {"default": False} + - detect: detect_mode + - top_reserve: INT, {"default": 20, min": -9999, max": 9999, step": 1} + - bottom_reserve: INT, {"default": 20, min": -9999, max": 9999, step": 1} + - left_reserve: INT, {"default": 20, min": -9999, max": 9999, step": 1} + - right_reserve: INT, {"default": 20, min": -9999, max": 9999, step": 1} + Optional: +Outputs: + - croped_image (IMAGE) + - croped_mask (MASK) + - crop_box (BOX) + - box_preview (IMAGE) +-------------------------------------------------- +Node: OuterGlowV2: + + def __init__ +Category: 😺dzNodes/LayerStyle +Inputs: + Required: + - background_image: IMAGE + - layer_image: IMAGE + - invert_mask: BOOLEAN, {"default": True} + - blend_mode: chop_mode_list + - opacity: INT, {"default": 100, min": 0, max": 100, step": 1} + - brightness: INT, {"default": 5, min": 2, max": 20, step": 1} + - glow_range: INT, {"default": 48, min": -9999, max": 9999, step": 1} + - blur: INT, {"default": 25, min": 0, max": 9999, step": 1} + - light_color: STRING, {"default": "#FFBF30"} + - glow_color: STRING, {"default": "#FE0000"} + Optional: + - layer_mask: MASK +Outputs: + - image (IMAGE) +-------------------------------------------------- +Node: ChannelShake: + + def __init__ +Category: 😺dzNodes/LayerFilter +Inputs: + Required: + - image: IMAGE + - distance: INT, {"default": 20, min": 1, max": 999, step": 1} + - angle: FLOAT, {"default": 40, min": -360, max": 360, step": 0.1} + - mode: channel_mode + Optional: +Outputs: + - image (IMAGE) +-------------------------------------------------- +Node: InnerGlow: + + def __init__ +Category: 😺dzNodes/LayerStyle +Inputs: + Required: + - background_image: IMAGE + - layer_image: IMAGE + - invert_mask: BOOLEAN, {"default": True} + - blend_mode: chop_mode + - opacity: INT, {"default": 100, min": 0, max": 100, step": 1} + - brightness: INT, {"default": 5, min": 2, max": 20, step": 1} + - glow_range: INT, {"default": 48, min": -9999, max": 9999, step": 1} + - blur: INT, {"default": 25, min": 0, max": 9999, step": 1} + - light_color: STRING, {"default": "#FFBF30"} + - glow_color: STRING, {"default": "#FE0000"} + Optional: + - layer_mask: MASK +Outputs: + - image (IMAGE) +-------------------------------------------------- +Node: ImageRemoveAlpha: + + def __init__ +Category: 😺dzNodes/LayerUtility +Inputs: + Required: + - RGBA_image: IMAGE + - fill_background: BOOLEAN, {"default": False} + - background_color: STRING, {"default": "#000000"} + Optional: + - mask: MASK +Outputs: + - RGB_image (IMAGE) +-------------------------------------------------- +Node: MaskEdgeUltraDetail: + def __init__ +Category: 😺dzNodes/LayerMask +Inputs: + Required: + - image: IMAGE + - mask: MASK + - method: method_list + - mask_grow: INT, {"default": 0, min": -999, max": 999, step": 1} + - fix_gap: INT, {"default": 0, min": 0, max": 32, step": 1} + - fix_threshold: FLOAT, {"default": 0.75, min": 0.01, max": 0.99, step": 0.01} + - detail_range: INT, {"default": 12, min": 1, max": 256, step": 1} + - black_point: FLOAT, {"default": 0.01, min": 0.01, max": 0.98, step": 0.01} + - white_point: FLOAT, {"default": 0.99, min": 0.02, max": 0.99, step": 0.01} + Optional: +Outputs: + - image (IMAGE) + - mask (MASK) +-------------------------------------------------- +Node: Stroke: + + def __init__ +Category: 😺dzNodes/LayerStyle +Inputs: + Required: + - background_image: IMAGE + - layer_image: IMAGE + - invert_mask: BOOLEAN, {"default": True} + - blend_mode: chop_mode + - opacity: INT, {"default": 100, min": 0, max": 100, step": 1} + - stroke_grow: INT, {"default": 0, min": -999, max": 999, step": 1} + - stroke_width: INT, {"default": 8, min": 0, max": 999, step": 1} + - blur: INT, {"default": 0, min": 0, max": 100, step": 1} + - stroke_color: STRING, {"default": "#FF0000"} + Optional: + - layer_mask: MASK +Outputs: + - image (IMAGE) +-------------------------------------------------- +Node: MaskByColor: + + def __init__ +Category: 😺dzNodes/LayerMask +Inputs: + Required: + - image: IMAGE + - color: COLOR, {"default": "#FFFFFF"} + - color_in_HEX: STRING, {"default": ""} + - threshold: INT, { "default": 50, min": 0, max": 100, step": 1, } + - fix_gap: INT, {"default": 2, min": 0, max": 32, step": 1} + - fix_threshold: FLOAT, {"default": 0.75, min": 0.01, max": 0.99, step": 0.01} + - invert_mask: BOOLEAN, {"default": False} + Optional: + - mask: MASK +Outputs: + - mask (MASK) +-------------------------------------------------- +Node: ShadowAndHighlightMask: + + def __init__ +Category: 😺dzNodes/LayerMask +Inputs: + Required: + - image: IMAGE + - shadow_level_offset: INT, {"default": 0, min": -99, max": 99, step": 1} + - shadow_range: FLOAT, {"default": 0.25, min": 0.01, max": 0.99, step": 0.01} + - highlight_level_offset: INT, {"default": 0, min": -99, max": 99, step": 1} + - highlight_range: FLOAT, {"default": 0.25, min": 0.01, max": 0.99, step": 0.01} + Optional: + - mask: MASK +Outputs: + - shadow_mask (MASK) + - highlight_mask (MASK) +-------------------------------------------------- +Node: LS_ShadowAndHighlightMaskV2: + + def __init__ +Category: 😺dzNodes/LayerMask +Inputs: + Required: + - image: IMAGE + - shadow_level_offset: INT, {"default": 0, min": -99, max": 99, step": 1} + - shadow_range: FLOAT, {"default": 0.25, min": 0.01, max": 0.99, step": 0.01} + - highlight_level_offset: INT, {"default": 0, min": -99, max": 99, step": 1} + - highlight_range: FLOAT, {"default": 0.25, min": 0.01, max": 0.99, step": 0.01} + Optional: + - mask: MASK +Outputs: + - shadow_mask (MASK) + - highlight_mask (MASK) +-------------------------------------------------- +Node: MaskInvert: + + def __init__ +Category: 😺dzNodes/LayerMask +Inputs: + Required: + - mask: MASK + Optional: +Outputs: + - mask (MASK) +-------------------------------------------------- +Node: SimpleTextImage: + + def __init__ +Category: 😺dzNodes/LayerUtility +Inputs: + Required: + - font_file: FONT_LIST + - align: ["center, left, right"] + - char_per_line: INT, {"default": 80, min": 1, max": 8096, step": 1} + - leading: INT, {"default": 8, min": 0, max": 8096, step": 1} + - font_size: INT, {"default": 72, min": 1, max": 2500, step": 1} + - text_color: STRING, {"default": "#FFFFFF"} + - stroke_width: INT, {"default": 0, min": 0, max": 8096, step": 1} + - stroke_color: STRING, {"default": "#FF8000"} + - x_offset: INT, {"default": 0, min": 0, max": 8096, step": 1} + - y_offset: INT, {"default": 0, min": 0, max": 8096, step": 1} + - width: INT, {"default": 512, min": 1, max": 8096, step": 1} + - height: INT, {"default": 512, min": 1, max": 8096, step": 1} + Optional: + - size_as: any, {} +Outputs: + - image (IMAGE) + - mask (MASK) +-------------------------------------------------- +Node: ColorValuetoGrayValue: + + def __init__ +Category: 😺dzNodes/LayerUtility/Data +Inputs: + Required: + - color_value: any, {} + Optional: +Outputs: + - gray(256_level) (INT) + - gray(100_level) (INT) +-------------------------------------------------- +Node: ColorCorrectHSV: + + def __init__ +Category: 😺dzNodes/LayerColor +Inputs: + Required: + - image: IMAGE + - H: INT, {"default": 0, min": -255, max": 255, step": 1} + - S: INT, {"default": 0, min": -255, max": 255, step": 1} + - V: INT, {"default": 0, min": -255, max": 255, step": 1} + Optional: +Outputs: + - image (IMAGE) +-------------------------------------------------- +Node: AutoBrightness: + + def __init__ +Category: 😺dzNodes/LayerColor +Inputs: + Required: + - image: IMAGE + - strength: INT, {"default": 75, min": 0, max": 100, step": 1} + - saturation: INT, {"default": 8, min": -255, max": 255, step": 1} + Optional: + - mask: MASK +Outputs: + - image (IMAGE) +-------------------------------------------------- +Node: ColorPicker: + + def __init__ +Category: 😺dzNodes/LayerUtility +Inputs: + Required: + - color: COLOR, {"default": "#FFFFFF"} + - mode: mode_list + Optional: +Outputs: + - value (STRING) +-------------------------------------------------- +Node: GradientOverlay: + + def __init__ +Category: 😺dzNodes/LayerStyle +Inputs: + Required: + - background_image: IMAGE + - layer_image: IMAGE + - invert_mask: BOOLEAN, {"default": True} + - blend_mode: chop_mode + - opacity: INT, {"default": 100, min": 0, max": 100, step": 1} + - start_color: STRING, {"default": "#FFBF30"} + - start_alpha: INT, {"default": 255, min": 0, max": 255, step": 1} + - end_color: STRING, {"default": "#FE0000"} + - end_alpha: INT, {"default": 255, min": 0, max": 255, step": 1} + - angle: INT, {"default": 0, min": -180, max": 180, step": 1} + Optional: + - layer_mask: MASK +Outputs: + - image (IMAGE) +-------------------------------------------------- +Node: ImageScaleRestore: + + def __init__ +Category: 😺dzNodes/LayerUtility +Inputs: + Required: + - image: IMAGE + - scale: FLOAT, {"default": 1, min": 0.01, max": 100, step": 0.01} + - method: method_mode + - scale_by_longest_side: BOOLEAN, {"default": False} + - longest_side: INT, {"default": 1024, min": 4, max": 999999, step": 1} + Optional: + - mask: MASK + - original_size: BOX +Outputs: + - image (IMAGE) + - mask (MASK) + - original_size (BOX) + - width (INT) + - height (INT) +-------------------------------------------------- +Node: MaskBoxDetect: + + def __init__ +Category: 😺dzNodes/LayerMask +Inputs: + Required: + - mask: MASK + - detect: detect_mode + - x_adjust: INT, {"default": 0, min": -9999, max": 9999, step": 1} + - y_adjust: INT, {"default": 0, min": -9999, max": 9999, step": 1} + - scale_adjust: FLOAT, {"default": 1.0, min": 0.01, max": 100, step": 0.01} + Optional: +Outputs: + - box_preview (IMAGE) + - x_percent (FLOAT) + - y_percent (FLOAT) + - width (INT) + - height (INT) + - x (INT) + - y (INT) +-------------------------------------------------- +Node: SharpAndSoft: + + def __init__ +Category: 😺dzNodes/LayerFilter +Inputs: + Required: + - images: IMAGE + - enhance: enhance_list + Optional: +Outputs: + - image (IMAGE) +-------------------------------------------------- +Node: OuterGlow: + + def __init__ +Category: 😺dzNodes/LayerStyle +Inputs: + Required: + - background_image: IMAGE + - layer_image: IMAGE + - invert_mask: BOOLEAN, {"default": True} + - blend_mode: chop_mode + - opacity: INT, {"default": 100, min": 0, max": 100, step": 1} + - brightness: INT, {"default": 5, min": 2, max": 20, step": 1} + - glow_range: INT, {"default": 48, min": -9999, max": 9999, step": 1} + - blur: INT, {"default": 25, min": 0, max": 9999, step": 1} + - light_color: STRING, {"default": "#FFBF30"} + - glow_color: STRING, {"default": "#FE0000"} + Optional: + - layer_mask: MASK +Outputs: + - image (IMAGE) +-------------------------------------------------- +Node: ExtendCanvas: + + def __init__ +Category: 😺dzNodes/LayerUtility +Inputs: + Required: + - image: IMAGE + - invert_mask: BOOLEAN, {"default": True} + - top: INT, {"default": 0, min": 0, max": 99999, step": 1} + - bottom: INT, {"default": 0, min": 0, max": 99999, step": 1} + - left: INT, {"default": 0, min": 0, max": 99999, step": 1} + - right: INT, {"default": 0, min": 0, max": 99999, step": 1} + - color: COLOR, {"default": "#000000"} + Optional: + - mask: MASK +Outputs: + - image (IMAGE) + - mask (MASK) +-------------------------------------------------- +Node: ImageChannelMerge: + + def __init__ +Category: 😺dzNodes/LayerUtility +Inputs: + Required: + - channel_1: IMAGE + - channel_2: IMAGE + - channel_3: IMAGE + - mode: channel_mode + Optional: + - channel_4: IMAGE +Outputs: + - image (IMAGE) +-------------------------------------------------- +Node: ImageToMask: + def __init__ +Category: 😺dzNodes/LayerMask +Inputs: + Required: + - image: IMAGE + - channel: channel_list + - black_point: INT, {"default": 0, min": 0, max": 255, step": 1, display": "slider"} + - white_point: INT, {"default": 255, min": 0, max": 255, step": 1, display": "slider"} + - gray_point: FLOAT, {"default": 1.0, min": 0.01, max": 9.99, step": 0.01} + - invert_output_mask: BOOLEAN, {"default": False} + Optional: + - mask: MASK +Outputs: + - mask (MASK) +-------------------------------------------------- +Node: LightLeak: + + def __init__ +Category: 😺dzNodes/LayerFilter +Inputs: + Required: + - image: IMAGE + - light: light_list + - corner: corner_list + - hue: INT, {"default": 0, min": -255, max": 255, step": 1} + - saturation: INT, {"default": 0, min": -255, max": 255, step": 1} + - opacity: INT, {"default": 100, min": 0, max": 100, step": 1} + Optional: +Outputs: + - image (IMAGE) +-------------------------------------------------- +Node: ImageCombineAlpha: + + def __init__ +Category: 😺dzNodes/LayerUtility +Inputs: + Required: + - RGB_image: IMAGE + - mask: MASK + Optional: +Outputs: + - RGBA_image (IMAGE) +-------------------------------------------------- +Node: MaskGradient: + + def __init__ +Category: 😺dzNodes/LayerMask +Inputs: + Required: + - mask: MASK + - invert_mask: BOOLEAN, {"default": True} + - gradient_side: side + - gradient_scale: INT, {"default": 100, min": 1, max": 9999, step": 1} + - gradient_offset: INT, {"default": 0, min": -9999, max": 9999, step": 1} + - opacity: INT, {"default": 100, min": 0, max": 100, step": 1} + Optional: +Outputs: + - mask (MASK) +-------------------------------------------------- +Node: DropShadow: + + def __init__ +Category: 😺dzNodes/LayerStyle +Inputs: + Required: + - background_image: IMAGE + - layer_image: IMAGE + - invert_mask: BOOLEAN, {"default": True} + - blend_mode: chop_mode + - opacity: INT, {"default": 50, min": 0, max": 100, step": 1} + - distance_x: INT, {"default": 25, min": -9999, max": 9999, step": 1} + - distance_y: INT, {"default": 25, min": -9999, max": 9999, step": 1} + - grow: INT, {"default": 6, min": -9999, max": 9999, step": 1} + - blur: INT, {"default": 18, min": 0, max": 100, step": 1} + - shadow_color: STRING, {"default": "#000000"} + Optional: + - layer_mask: MASK +Outputs: + - image (IMAGE) +-------------------------------------------------- +Node: ImageBlend: + + def __init__ +Category: 😺dzNodes/LayerUtility +Inputs: + Required: + - background_image: IMAGE + - layer_image: IMAGE + - invert_mask: BOOLEAN, {"default": True} + - blend_mode: chop_mode + - opacity: INT, {"default": 100, min": 0, max": 100, step": 1} + Optional: + - layer_mask: MASK +Outputs: + - image (IMAGE) +-------------------------------------------------- +Node: BatchSelector: + + def __init__ +Category: 😺dzNodes/LayerUtility/SystemIO +Inputs: + Required: + - select: STRING, {"default": "0, } + Optional: + - images: IMAGE + - masks: MASK +Outputs: + - image (IMAGE) + - mask (MASK) +-------------------------------------------------- +Node: AutoAdjust: + + def __init__ +Category: 😺dzNodes/LayerColor +Inputs: + Required: + - image: IMAGE + - strength: INT, {"default": 100, min": 0, max": 100, step": 1} + - brightness: INT, {"default": 0, min": -100, max": 100, step": 1} + - contrast: INT, {"default": 0, min": -100, max": 100, step": 1} + - saturation: INT, {"default": 0, min": -100, max": 100, step": 1} + - red: INT, {"default": 0, min": -100, max": 100, step": 1} + - green: INT, {"default": 0, min": -100, max": 100, step": 1} + - blue: INT, {"default": 0, min": -100, max": 100, step": 1} + Optional: +Outputs: + - image (IMAGE) +-------------------------------------------------- +Node: ColorImage: + + def __init__ +Category: 😺dzNodes/LayerUtility +Inputs: + Required: + - width: INT, {"default": 512, min": 4, max": 99999, step": 1} + - height: INT, {"default": 512, min": 4, max": 99999, step": 1} + - color: STRING, {"default": "#000000"} + Optional: +Outputs: + - image (IMAGE) +-------------------------------------------------- +Node: TextImage_v2: + + def __init__ +Category: 😺dzNodes/LayerUtility +Inputs: + Required: + - text: STRING, {"multiline": True, default": "Text"} + - font_file: FONT_LIST + - spacing: INT, {"default": 0, min": -9999, max": 9999, step": 1} + - leading: INT, {"default": 0, min": -9999, max": 9999, step": 1} + - horizontal_border: FLOAT, {"default": 5, min": -100, max": 100, step": 0.1} + - vertical_border: FLOAT, {"default": 5, min": -100, max": 100, step": 0.1} + - scale: FLOAT, {"default": 80, min": 0.1, max": 999, step": 0.01} + - variation_range: INT, {"default": 0, min": 0, max": 100, step": 1} + - variation_seed: INT, {"default": random_seed, min": 0, max": 999999999999, step": 1} + - layout: layout_list + - width: INT, {"default": 512, min": 4, max": 999999, step": 1} + - height: INT, {"default": 512, min": 4, max": 999999, step": 1} + - text_color: STRING, {"default": "#FFA000"} + - background_color: STRING, {"default": "#FFFFFF"} + Optional: + - size_as: any, {} +Outputs: + - image (IMAGE) + - mask (MASK) +-------------------------------------------------- +Node: ColorCorrectLAB: + + def __init__ +Category: 😺dzNodes/LayerColor +Inputs: + Required: + - image: IMAGE + - L: INT, {"default": 0, min": -255, max": 255, step": 1} + - A: INT, {"default": 0, min": -255, max": 255, step": 1} + - B: INT, {"default": 0, min": -255, max": 255, step": 1} + Optional: +Outputs: + - image (IMAGE) +-------------------------------------------------- +Node: GradientImageV2: + + def __init__ +Category: 😺dzNodes/LayerUtility +Inputs: + Required: + - size: size_list + - custom_width: INT, {"default": 512, min": 4, max": 99999, step": 1} + - custom_height: INT, {"default": 512, min": 4, max": 99999, step": 1} + - angle: INT, {"default": 0, min": -360, max": 360, step": 1} + - start_color: STRING, {"default": "#FFFFFF"} + - end_color: STRING, {"default": "#000000"} + Optional: + - size_as: any, {} +Outputs: + - image (IMAGE) +-------------------------------------------------- +Node: LS_RoundedRectangle: + + def __init__ +Category: 😺dzNodes/LayerUtility +Inputs: + Required: + - image: IMAGE + - rounded_rect_radius: INT, {"default": 50, min": 0, max": 100, step": 1} + - anti_aliasing: INT, {"default": 2, min": 0, max": 16, step": 1} + - top: FLOAT, {"default": 8, min": -100, max": 100, step": 0.1} + - bottom: FLOAT, {"default": 8, min": -100, max": 100, step": 0.1} + - left: FLOAT, {"default": 8, min": -100, max": 100, step": 0.1} + - right: FLOAT, {"default": 8, min": -100, max": 100, step": 0.1} + - detect: detect_mode + - obj_ext_top: FLOAT, {"default": 8, min": -100, max": 100, step": 0.1} + - obj_ext_bottom: FLOAT, {"default": 8, min": -100, max": 100, step": 0.1} + - obj_ext_left: FLOAT, {"default": 8, min": -100, max": 100, step": 0.1} + - obj_ext_right: FLOAT, {"default": 8, min": -100, max": 100, step": 0.1} + Optional: + - object_mask: MASK + - crop_box: BOX +Outputs: + - image (IMAGE) + - mask (MASK) +-------------------------------------------------- +Node: ImageScaleByAspectRatio: + + def __init__ +Category: 😺dzNodes/LayerUtility +Inputs: + Required: + - aspect_ratio: ratio_list + - proportional_width: INT, {"default": 2, min": 1, max": 999, step": 1} + - proportional_height: INT, {"default": 1, min": 1, max": 999, step": 1} + - fit: fit_mode + - method: method_mode + - round_to_multiple: multiple_list + - scale_to_longest_side: BOOLEAN, {"default": False} + - longest_side: INT, {"default": 1024, min": 4, max": 999999, step": 1} + Optional: + - image: IMAGE + - mask: MASK +Outputs: + - image (IMAGE) + - mask (MASK) + - original_size (BOX) + - width (INT) + - height (INT) +-------------------------------------------------- +Node: InnerShadow: + + def __init__ +Category: 😺dzNodes/LayerStyle +Inputs: + Required: + - background_image: IMAGE + - layer_image: IMAGE + - invert_mask: BOOLEAN, {"default": True} + - blend_mode: chop_mode + - opacity: INT, {"default": 50, min": 0, max": 100, step": 1} + - distance_x: INT, {"default": 5, min": -9999, max": 9999, step": 1} + - distance_y: INT, {"default": 5, min": -9999, max": 9999, step": 1} + - grow: INT, {"default": 2, min": -9999, max": 9999, step": 1} + - blur: INT, {"default": 15, min": 0, max": 100, step": 1} + - shadow_color: STRING, {"default": "#000000"} + Optional: + - layer_mask: MASK +Outputs: + - image (IMAGE) +-------------------------------------------------- +Node: LayerMaskTransform: + + def __init__ +Category: 😺dzNodes/LayerUtility +Inputs: + Required: + - mask: MASK + - x: INT, {"default": 0, min": -99999, max": 99999, step": 1} + - y: INT, {"default": 0, min": -99999, max": 99999, step": 1} + - mirror: mirror_mode + - scale: FLOAT, {"default": 1, min": 0.01, max": 100, step": 0.01} + - aspect_ratio: FLOAT, {"default": 1, min": 0.01, max": 100, step": 0.01} + - rotate: FLOAT, {"default": 0, min": -999999, max": 999999, step": 0.01} + - transform_method: method_mode + - anti_aliasing: INT, {"default": 2, min": 0, max": 16, step": 1} + Optional: +Outputs: + - mask (MASK) +-------------------------------------------------- +Node: HLFrequencyDetailRestore: + + def __init__ +Category: 😺dzNodes/LayerUtility +Inputs: + Required: + - image: IMAGE + - detail_image: IMAGE + - keep_high_freq: INT, {"default": 64, min": 0, max": 1023} + - erase_low_freq: INT, {"default": 32, min": 0, max": 1023} + - mask_blur: INT, {"default": 16, min": 0, max": 1023} + Optional: + - mask: MASK +Outputs: + - image (IMAGE) +-------------------------------------------------- +Node: LSImageTaggerSave: + def __init__ +Category: 😺dzNodes/LayerUtility/SystemIO +Inputs: + Required: + - {"image: IMAGE + - tag_text: STRING, {"default": , forceInput":True} + - custom_path: STRING, {"default": ""} + - filename_prefix: STRING, {"default": "comfyui"} + - timestamp: ["None, second, millisecond"] + - format: ["png, jpg"] + - quality: INT, {"default": 80, min": 10, max": 100, step": 1} + - preview: BOOLEAN, {"default": True} + Optional: +Outputs: +-------------------------------------------------- +Node: ImageBlendV2: + + def __init__ +Category: 😺dzNodes/LayerUtility +Inputs: + Required: + - background_image: IMAGE + - layer_image: IMAGE + - invert_mask: BOOLEAN, {"default": True} + - blend_mode: chop_mode_v2 + - opacity: INT, {"default": 100, min": 0, max": 100, step": 1} + Optional: + - layer_mask: MASK +Outputs: + - image (IMAGE) +-------------------------------------------------- +Node: ImageReelPipeline: + def __init__ +Category: Unknown +Inputs: + Required: + Optional: +Outputs: +-------------------------------------------------- +Node: ImageReel: + + def __init__ +Category: 😺dzNodes/LayerUtility +Inputs: + Required: + - image1: IMAGE + - image1_text: STRING, {"multiline": False, default": "image1"} + - image2_text: STRING, {"multiline": False, default": "image2"} + - image3_text: STRING, {"multiline": False, default": "image3"} + - image4_text: STRING, {"multiline": False, default": "image4"} + - reel_height: INT, {"default": 512, min": 64, max": 2048} + - border: INT, {"default": 32, min": 8, max": 512} + Optional: + - image2: IMAGE + - image3: IMAGE + - image4: IMAGE +Outputs: + - reel (Reel) +-------------------------------------------------- +Node: ImageReelComposit: + + def __init__ +Category: 😺dzNodes/LayerUtility +Inputs: + Required: + - reel_1: Reel + - font_file: FONT_LIST + - font_size: INT, {"default": 40, min": 4, max": 1024} + - border: INT, {"default": 32, min": 8, max": 512} + - color_theme: color_theme_list + Optional: + - reel_2: Reel + - reel_3: Reel + - reel_4: Reel +Outputs: + - image1 (IMAGE) +-------------------------------------------------- +Node: LS_LoadVQAModel: + + def __init__ +Category: 😺dzNodes/LayerUtility +Inputs: + Required: + - model: model_list + - precision: precision_list + - device: device_list + Optional: +Outputs: + - vqa_model (VQA_MODEL) +-------------------------------------------------- +Node: LS_VQA_Prompt: + + def __init__ +Category: 😺dzNodes/LayerUtility +Inputs: + Required: + Optional: +Outputs: + - text (STRING) +-------------------------------------------------- +Node: ColorCorrectBrightnessAndContrast: + + def __init__ +Category: 😺dzNodes/LayerColor +Inputs: + Required: + - image: IMAGE + - brightness: FLOAT, {"default": 1, min": 0.0, max": 3, step": 0.01} + - contrast: FLOAT, {"default": 1, min": 0.0, max": 3, step": 0.01} + - saturation: FLOAT, {"default": 1, min": 0.0, max": 3, step": 0.01} + Optional: +Outputs: + - image (IMAGE) +-------------------------------------------------- +Node: LS_ColorCorrect_Brightness_And_Contrast_V2: + def __init__ +Category: 😺dzNodes/LayerColor +Inputs: + Required: + - image: IMAGE + - brightness: FLOAT, {"default": 1, min": 0.0, max": 3, step": 0.01} + - contrast: FLOAT, {"default": 1, min": 0.0, max": 3, step": 0.01} + - saturation: FLOAT, {"default": 1, min": 0.0, max": 3, step": 0.01} + Optional: +Outputs: + - image (IMAGE) +-------------------------------------------------- +Node: CheckMaskV2: + + def __init__ +Category: 😺dzNodes/LayerUtility +Inputs: + Required: + - mask: MASK + - method: method_list + - white_point: INT, {"default": 1, min": 1, max": 254, step": 1} + - area_percent: FLOAT, {"default": 0.01, min": 0, max": 100, step": 0.01} + Optional: +Outputs: + - bool (BOOLEAN) +-------------------------------------------------- +Node: CropByMaskV3: + + def __init__ +Category: 😺dzNodes/LayerUtility +Inputs: + Required: + - image: IMAGE + - mask: MASK + - invert_mask: BOOLEAN, {"default": False} + - detect: detect_mode + - top_reserve: INT, {"default": 20, min": -9999, max": 9999, step": 1} + - bottom_reserve: INT, {"default": 20, min": -9999, max": 9999, step": 1} + - left_reserve: INT, {"default": 20, min": -9999, max": 9999, step": 1} + - right_reserve: INT, {"default": 20, min": -9999, max": 9999, step": 1} + - round_to_multiple: multiple_list + Optional: + - crop_box: BOX +Outputs: + - croped_image (IMAGE) + - croped_mask (MASK) + - crop_box (BOX) + - box_preview (IMAGE) +-------------------------------------------------- +Node: ColorCorrectGamma: + + def __init__ +Category: 😺dzNodes/LayerColor +Inputs: + Required: + - image: IMAGE + - gamma: FLOAT, {"default": 1, min": 0.1, max": 10, step": 0.01} + Optional: +Outputs: + - image (IMAGE) +-------------------------------------------------- +Node: LS_ColorName: + + def __init__ +Category: 😺dzNodes/LayerColor +Inputs: + Required: + - color: STRING, {"default": "#000000, forceInput":False} + - palette: list(palettes.keys( + Optional: +Outputs: + - color_name (STRING) +-------------------------------------------------- +Node: LS_NameToColor: + + def __init__ +Category: 😺dzNodes/LayerColor +Inputs: + Required: + - color_name: STRING, {"default": "white, forceInput":False} + - palette: list(palettes.keys( + - in_palette_only: BOOLEAN, {"default": False} + - default_color: STRING, {"default": "#000000, forceInput": False} + - size: size_list + - custom_width: INT, {"default": 512, min": 4, max": 99999, step": 1} + - custom_height: INT, {"default": 512, min": 4, max": 99999, step": 1} + Optional: + - size_as: any, {} +Outputs: + - image (IMAGE) + - color (STRING) +-------------------------------------------------- +Node: ColorTemperature: + def __init__ +Category: 😺dzNodes/LayerColor +Inputs: + Required: + - image: IMAGE + - temperature: FLOAT, {"default": 0, min": -100, max": 100, step": 1} + Optional: +Outputs: + - image (IMAGE) +-------------------------------------------------- +Node: ColorValuetoHSVValue: + + def __init__ +Category: 😺dzNodes/LayerUtility/Data +Inputs: + Required: + - color_value: any, {} + Optional: +Outputs: + - H (INT) + - S (INT) + - V (INT) +-------------------------------------------------- +Node: ImageBlendAdvanceV2: + + def __init__ +Category: 😺dzNodes/LayerUtility +Inputs: + Required: + - background_image: IMAGE + - layer_image: IMAGE + - invert_mask: BOOLEAN, {"default": True} + - blend_mode: chop_mode_v2 + - opacity: INT, {"default": 100, min": 0, max": 100, step": 1} + - x_percent: FLOAT, {"default": 50, min": -999, max": 999, step": 0.01} + - y_percent: FLOAT, {"default": 50, min": -999, max": 999, step": 0.01} + - mirror: mirror_mode + - scale: FLOAT, {"default": 1, min": 0.01, max": 100, step": 0.01} + - aspect_ratio: FLOAT, {"default": 1, min": 0.01, max": 100, step": 0.01} + - rotate: FLOAT, {"default": 0, min": -999999, max": 999999, step": 0.01} + - transform_method: method_mode + - anti_aliasing: INT, {"default": 0, min": 0, max": 16, step": 1} + Optional: + - layer_mask: MASK +Outputs: + - image (IMAGE) + - mask (MASK) +-------------------------------------------------- +Node: LS_AnyRerouter +Category: 😺dzNodes/LayerUtility/Data +Inputs: + Required: + - any: anything, {} + Optional: +Outputs: + - any (anything) +-------------------------------------------------- +Node: CropBoxResolve: + + def __init__ +Category: 😺dzNodes/LayerUtility +Inputs: + Required: + - crop_box: BOX + Optional: +Outputs: + - x (INT) + - y (INT) + - width (INT) + - height (INT) +-------------------------------------------------- +Node: BlendIfMask: + + def __init__ +Category: 😺dzNodes/LayerMask +Inputs: + Required: + - image: IMAGE + - invert_mask: BOOLEAN, {"default": True} + - blend_if: blend_if_list + - black_point: INT, {"default": 0, min": 0, max": 254, step": 1, display": "slider"} + - black_range: INT, {"default": 0, min": 0, max": 255, step": 1} + - white_point: INT, {"default": 255, min": 1, max": 255, step": 1, display": "slider"} + - white_range: INT, {"default": 0, min": 0, max": 255, step": 1} + Optional: + - mask: MASK +Outputs: + - mask (MASK) +-------------------------------------------------- +Node: XYtoPercent: + + def __init__ +Category: 😺dzNodes/LayerUtility/Data +Inputs: + Required: + - background_image: IMAGE + - layer_image: IMAGE + - x: INT, {"default": 0, min": -99999, max": 99999, step": 1} + - y: INT, {"default": 0, min": -99999, max": 99999, step": 1} + Optional: +Outputs: + - x_percent (FLOAT) + - y_percent (FLOAT) +-------------------------------------------------- +Node: MotionBlur: + + def __init__ +Category: 😺dzNodes/LayerFilter +Inputs: + Required: + - image: IMAGE + - angle: INT, {"default": 0, min": -90, max": 90, step": 1} + - blur: INT, {"default": 20, min": 1, max": 999, step": 1} + Optional: +Outputs: + - image (IMAGE) +-------------------------------------------------- +Node: InnerGlowV2: + + def __init__ +Category: 😺dzNodes/LayerStyle +Inputs: + Required: + - background_image: IMAGE + - layer_image: IMAGE + - invert_mask: BOOLEAN, {"default": True} + - blend_mode: chop_mode_list + - opacity: INT, {"default": 100, min": 0, max": 100, step": 1} + - brightness: INT, {"default": 5, min": 2, max": 20, step": 1} + - glow_range: INT, {"default": 48, min": -9999, max": 9999, step": 1} + - blur: INT, {"default": 25, min": 0, max": 9999, step": 1} + - light_color: STRING, {"default": "#FFBF30"} + - glow_color: STRING, {"default": "#FE0000"} + Optional: + - layer_mask: MASK +Outputs: + - image (IMAGE) +-------------------------------------------------- +Node: SeedNode: + def __init__ +Category: 😺dzNodes/LayerUtility/Data +Inputs: + Required: + - seed: INT, {"default": 0, min": 0, max": 1e18, step": 1} + Optional: +Outputs: + - seed (INT) +-------------------------------------------------- +Node: BooleanOperator: + def __init__ +Category: 😺dzNodes/LayerUtility/Data +Inputs: + Required: + - a: any + - b: any + - operator: operator_list + Optional: +Outputs: + - output (BOOLEAN) +-------------------------------------------------- +Node: BooleanOperatorV2: + def __init__ +Category: 😺dzNodes/LayerUtility/Data +Inputs: + Required: + - a_value: STRING, {"default": , multiline": False} + - b_value: STRING, {"default": , multiline": False} + - operator: operator_list + Optional: + - a: any + - b: any +Outputs: + - output (BOOLEAN) + - string (STRING) +-------------------------------------------------- +Node: NumberCalculator: + def __init__ +Category: 😺dzNodes/LayerUtility/Data +Inputs: + Required: + - a: any, {} + - b: any, {} + - operator: operator_list + Optional: +Outputs: + - int (INT) + - float (FLOAT) +-------------------------------------------------- +Node: NumberCalculatorV2: + def __init__ +Category: 😺dzNodes/LayerUtility/Data +Inputs: + Required: + - a_value: STRING, {"default": , multiline": False} + - b_value: STRING, {"default": , multiline": False} + - operator: operator_list + Optional: + - a: any + - b: any +Outputs: + - int (INT) + - float (FLOAT) + - string (STRING) +-------------------------------------------------- +Node: StringCondition: + def __init__ +Category: 😺dzNodes/LayerUtility/Data +Inputs: + Required: + - text: STRING, {"multiline": False} + - condition: string_condition_list + - sub_string: STRING, {"multiline": False} + Optional: +Outputs: + - output (BOOLEAN) + - string (STRING) +-------------------------------------------------- +Node: TextBoxNode: + def __init__ +Category: 😺dzNodes/LayerUtility/Data +Inputs: + Required: + - text: STRING, {"multiline": True} + Optional: +Outputs: + - text (STRING) +-------------------------------------------------- +Node: StringNode: + def __init__ +Category: 😺dzNodes/LayerUtility/Data +Inputs: + Required: + - string: STRING, {"multiline": False} + Optional: +Outputs: + - string (STRING) +-------------------------------------------------- +Node: IntegerNode: + def __init__ +Category: 😺dzNodes/LayerUtility/Data +Inputs: + Required: + - int_value: INT, {"default": 0, min": -1e18, max": 1e18, step": 1} + Optional: +Outputs: + - int (INT) + - string (STRING) +-------------------------------------------------- +Node: FloatNode: + def __init__ +Category: 😺dzNodes/LayerUtility/Data +Inputs: + Required: + - float_value: FLOAT, {"default": 0, min": -1e18, max": 1e18, step": 0.00001} + Optional: +Outputs: + - float (FLOAT) + - string (STRING) +-------------------------------------------------- +Node: BooleanNode: + def __init__ +Category: 😺dzNodes/LayerUtility/Data +Inputs: + Required: + - bool_value: BOOLEAN, {"default": False} + Optional: +Outputs: + - boolean (BOOLEAN) + - string (STRING) +-------------------------------------------------- +Node: IfExecute: + + @classmethod + def INPUT_TYPES +Category: 😺dzNodes/LayerUtility/Data +Inputs: + Required: + - if_condition: any + - when_TRUE: any + - when_FALSE: any + Optional: +Outputs: + - ? (any) +-------------------------------------------------- +Node: SwitchCaseNode: + + @classmethod + def INPUT_TYPES +Category: 😺dzNodes/LayerUtility/Data +Inputs: + Required: + - switch_condition: STRING, {"default": , multiline": False} + - case_1: STRING, {"default": , multiline": False} + - case_2: STRING, {"default": , multiline": False} + - case_3: STRING, {"default": , multiline": False} + - input_default: any + Optional: + - input_1: any + - input_2: any + - input_3: any +Outputs: + - ? (any) +-------------------------------------------------- +Node: QueueStopNode +Category: 😺dzNodes/LayerUtility/SystemIO +Inputs: + Required: + - any: any + - mode: mode_list + - stop: BOOLEAN, {"default": True} + Optional: +Outputs: + - any (any) +-------------------------------------------------- +Node: RemBgUltra: + def __init__ +Category: 😺dzNodes/LayerMask +Inputs: + Required: + - image: IMAGE + - detail_range: INT, {"default": 8, min": 1, max": 256, step": 1} + - black_point: FLOAT, {"default": 0.01, min": 0.01, max": 0.98, step": 0.01} + - white_point: FLOAT, {"default": 0.99, min": 0.02, max": 0.99, step": 0.01} + - process_detail: BOOLEAN, {"default": True} + Optional: +Outputs: + - image (IMAGE) + - mask (MASK) +-------------------------------------------------- +Node: InnerShadowV2: + + def __init__ +Category: 😺dzNodes/LayerStyle +Inputs: + Required: + - background_image: IMAGE + - layer_image: IMAGE + - invert_mask: BOOLEAN, {"default": True} + - blend_mode: chop_mode_v2 + - opacity: INT, {"default": 50, min": 0, max": 100, step": 1} + - distance_x: INT, {"default": 5, min": -9999, max": 9999, step": 1} + - distance_y: INT, {"default": 5, min": -9999, max": 9999, step": 1} + - grow: INT, {"default": 2, min": -9999, max": 9999, step": 1} + - blur: INT, {"default": 15, min": 0, max": 100, step": 1} + - shadow_color: STRING, {"default": "#000000"} + Optional: + - layer_mask: MASK +Outputs: + - image (IMAGE) +-------------------------------------------------- +Node: SkinBeauty: + + def __init__ +Category: 😺dzNodes/LayerFilter +Inputs: + Required: + - image: IMAGE + - smooth: INT, {"default": 20, min": 1, max": 64, step": 1} + - threshold: INT, {"default": -10, min": -255, max": 255, step": 1} + - opacity: INT, {"default": 100, min": 0, max": 100, step": 1} + Optional: +Outputs: + - image (IMAGE) + - beauty_mask (MASK) +-------------------------------------------------- +Node: CreateGradientMask: + + def __init__ +Category: 😺dzNodes/LayerMask +Inputs: + Required: + - width: INT, {"default": 512, min": 4, max": 99999, step": 1} + - height: INT, {"default": 512, min": 4, max": 99999, step": 1} + - gradient_side: side + - gradient_scale: INT, {"default": 100, min": 1, max": 9999, step": 1} + - gradient_offset: INT, {"default": 0, min": -9999, max": 9999, step": 1} + - opacity: INT, {"default": 100, min": 0, max": 100, step": 1} + Optional: + - size_as: any, {} +Outputs: + - mask (MASK) +-------------------------------------------------- +Node: ColorMap: + + def __init__ +Category: 😺dzNodes/LayerFilter +Inputs: + Required: + - image: IMAGE + - color_map: colormap_list + - opacity: INT, {"default": 100, min": 0, max": 100, step": 1} + Optional: +Outputs: + - image (IMAGE) +-------------------------------------------------- +Node: LSRandomGenerator: + + def __init__ +Category: 😺dzNodes/LayerUtility/Data +Inputs: + Required: + - min_value: FLOAT, {"default": 0, min": -1.0e14, max": 1.0e14, step": 0.01} + - max_value: FLOAT, {"default": 10, min": -1.0e14, max": 1.0e14, step": 0.01} + - float_decimal_places: INT, {"default": 1, min": 1, max": 14, step": 1} + - fix_seed: BOOLEAN, {"default": False} + Optional: + - image: IMAGE +Outputs: + - int (INT) + - float (FLOAT) + - bool (BOOLEAN) +-------------------------------------------------- +Node: LS_RandomGeneratorV2: + + def __init__ +Category: 😺dzNodes/LayerUtility/Data +Inputs: + Required: + - min_value: FLOAT, {"default": 0, min": -1.0e14, max": 1.0e14, step": 0.01} + - max_value: FLOAT, {"default": 10, min": -1.0e14, max": 1.0e14, step": 0.01} + - least: FLOAT, {"default": 0, min": 0, max": 1.0e14, step": 0.01} + - float_decimal_places: INT, {"default": 1, min": 1, max": 14, step": 1} + - seed: INT, {"default": 0, min": 0, max": 1e14, step": 1} + Optional: + - image: IMAGE +Outputs: + - int (INT) + - float (FLOAT) + - bool (BOOLEAN) +-------------------------------------------------- +Node: RmBgUltraV2: + def __init__ +Category: 😺dzNodes/LayerMask +Inputs: + Required: + - image: IMAGE + - detail_method: method_list + - detail_erode: INT, {"default": 6, min": 1, max": 255, step": 1} + - detail_dilate: INT, {"default": 6, min": 1, max": 255, step": 1} + - black_point: FLOAT, {"default": 0.01, min": 0.01, max": 0.98, step": 0.01, display": "slider"} + - white_point: FLOAT, {"default": 0.99, min": 0.02, max": 0.99, step": 0.01, display": "slider"} + - process_detail: BOOLEAN, {"default": True} + - device: device_list + - max_megapixels: FLOAT, {"default": 2.0, min": 1, max": 999, step": 0.1} + Optional: +Outputs: + - image (IMAGE) + - mask (MASK) +-------------------------------------------------- +Node: ColorCorrectLevels: + + def __init__ +Category: 😺dzNodes/LayerColor +Inputs: + Required: + - image: IMAGE + - channel: channel_list + - black_point: INT, {"default": 0, min": 0, max": 255, step": 1, display": "slider"} + - white_point: INT, {"default": 255, min": 0, max": 255, step": 1, display": "slider"} + - gray_point: FLOAT, {"default": 1, min": 0.01, max": 9.99, step": 0.01} + - output_black_point: INT, {"default": 0, min": 0, max": 255, step": 1} + - output_white_point: INT, {"default": 255, min": 0, max": 255, step": 1} + Optional: +Outputs: + - image (IMAGE) +-------------------------------------------------- +Node: GetImageSize: + + def __init__ +Category: 😺dzNodes/LayerUtility +Inputs: + Required: + - image: IMAGE + Optional: +Outputs: + - width (INT) + - height (INT) + - original_size (BOX) +-------------------------------------------------- +Node: LS_TextPreseter: + def __init__ +Category: 😺dzNodes/LayerUtility/Data +Inputs: + Required: + - title: STRING, {"default": , multiline": False} + - content: STRING, {"default": , multiline": True} + Optional: + - text_preset: LS_TEXT_PRESET +Outputs: + - text_preset (LS_TEXT_PRESET) +-------------------------------------------------- +Node: LS_ChoiceTextPreset: + def __init__ +Category: 😺dzNodes/LayerUtility/Data +Inputs: + Required: + - { "text_preset: LS_TEXT_PRESET + - choice_title: STRING, {"default": , multiline": False} + - random_choice: BOOLEAN, {"default": False} + - default: INT, {"default": 0, min": 0, max": 1e4, step": 1} + - seed: INT, {"default": 0, min": 0, max": 1e18, step": 1} + Optional: +Outputs: + - title (STRING) + - content (STRING) +-------------------------------------------------- +Node: ImageScaleRestoreV2: + + def __init__ +Category: 😺dzNodes/LayerUtility +Inputs: + Required: + - image: IMAGE + - scale: FLOAT, {"default": 1, min": 0.01, max": 100, step": 0.01} + - method: method_mode + - scale_by: scale_by_list + - scale_by_length: INT, {"default": 1024, min": 4, max": 99999999, step": 1} + Optional: + - mask: MASK + - original_size: BOX +Outputs: + - image (IMAGE) + - mask (MASK) + - original_size (BOX) + - width (INT) + - height (INT) +-------------------------------------------------- +Node: MaskGrow: + + def __init__ +Category: 😺dzNodes/LayerMask +Inputs: + Required: + - mask: MASK + - invert_mask: BOOLEAN, {"default": True} + - grow: INT, {"default": 4, min": -999, max": 999, step": 1} + - blur: INT, {"default": 4, min": 0, max": 999, step": 1} + Optional: +Outputs: + - mask (MASK) +-------------------------------------------------- +Node: LS_GetMainColorsV2: + + def __init__ +Category: 😺dzNodes/LayerUtility +Inputs: + Required: + - image: IMAGE + - k_means_algorithm: k_means_algorithm_list + Optional: +Outputs: + - preview_image (IMAGE) + - color_1 (STRING) + - color_2 (STRING) + - color_3 (STRING) + - color_4 (STRING) + - color_5 (STRING) +-------------------------------------------------- +Node: LS_GetMainColors: + + def __init__ +Category: 😺dzNodes/LayerUtility +Inputs: + Required: + - image: IMAGE + - k_means_algorithm: k_means_algorithm_list + Optional: +Outputs: + - preview_image (IMAGE) + - color_1 (STRING) + - color_2 (STRING) + - color_3 (STRING) + - color_4 (STRING) + - color_5 (STRING) +-------------------------------------------------- +Node: MaskEdgeShrink: + + def __init__ +Category: 😺dzNodes/LayerMask +Inputs: + Required: + - mask: MASK + - invert_mask: BOOLEAN, {"default": True} + - shrink_level: INT, {"default": 4, min": 0, max": 16, step": 1} + - soft: INT, {"default": 6, min": 0, max": 64, step": 1} + - edge_shrink: INT, {"default": 1, min": 0, max": 999, step": 1} + - edge_reserve: INT, {"default": 25, min": 0, max": 100, step": 1} + Optional: +Outputs: + - mask (MASK) +-------------------------------------------------- +Node: ColorCorrectRGB: + + def __init__ +Category: 😺dzNodes/LayerColor +Inputs: + Required: + - image: IMAGE + - R: INT, {"default": 0, min": -255, max": 255, step": 1} + - G: INT, {"default": 0, min": -255, max": 255, step": 1} + - B: INT, {"default": 0, min": -255, max": 255, step": 1} + Optional: +Outputs: + - image (IMAGE) +-------------------------------------------------- +Node: GradientImage: + + def __init__ +Category: 😺dzNodes/LayerUtility +Inputs: + Required: + - width: INT, {"default": 512, min": 4, max": 99999, step": 1} + - height: INT, {"default": 512, min": 4, max": 99999, step": 1} + - angle: INT, {"default": 0, min": -360, max": 360, step": 1} + - start_color: STRING, {"default": "#FFFFFF"} + - end_color: STRING, {"default": "#000000"} + Optional: +Outputs: + - image (IMAGE) +-------------------------------------------------- +Node: CropByMaskV2: + + def __init__ +Category: 😺dzNodes/LayerUtility +Inputs: + Required: + - image: IMAGE + - mask: MASK + - invert_mask: BOOLEAN, {"default": False} + - detect: detect_mode + - top_reserve: INT, {"default": 20, min": -9999, max": 9999, step": 1} + - bottom_reserve: INT, {"default": 20, min": -9999, max": 9999, step": 1} + - left_reserve: INT, {"default": 20, min": -9999, max": 9999, step": 1} + - right_reserve: INT, {"default": 20, min": -9999, max": 9999, step": 1} + - round_to_multiple: multiple_list + Optional: + - crop_box: BOX +Outputs: + - croped_image (IMAGE) + - croped_mask (MASK) + - crop_box (BOX) + - box_preview (IMAGE) +-------------------------------------------------- +Node: MaskPreview +Category: 😺dzNodes/LayerMask +Inputs: + Required: + - {"mask: MASK + Optional: +Outputs: +-------------------------------------------------- +Node: ImageBlendAdvanceV3: + + def __init__ +Category: 😺dzNodes/LayerUtility +Inputs: + Required: + - layer_image: IMAGE + - invert_mask: BOOLEAN, {"default": True} + - blend_mode: chop_mode_v2 + - opacity: INT, {"default": 100, min": 0, max": 100, step": 1} + - x_percent: FLOAT, {"default": 50, min": -999, max": 999, step": 0.01} + - y_percent: FLOAT, {"default": 50, min": -999, max": 999, step": 0.01} + - mirror: mirror_mode + - scale: FLOAT, {"default": 1, min": 0.01, max": 100, step": 0.01} + - aspect_ratio: FLOAT, {"default": 1, min": 0.01, max": 100, step": 0.01} + - rotate: FLOAT, {"default": 0, min": -999999, max": 999999, step": 0.01} + - transform_method: method_mode + - anti_aliasing: INT, {"default": 0, min": 0, max": 16, step": 1} + Optional: + - background_image: IMAGE + - layer_mask: MASK +Outputs: + - image (IMAGE) + - mask (MASK) +-------------------------------------------------- +Node: PurgeVRAM: + + def __init__ +Category: 😺dzNodes/LayerUtility/SystemIO +Inputs: + Required: + - anything: any, {} + - purge_cache: BOOLEAN, {"default": True} + - purge_models: BOOLEAN, {"default": True} + Optional: +Outputs: +-------------------------------------------------- +Node: PurgeVRAM_V2: + + def __init__ +Category: 😺dzNodes/LayerUtility/SystemIO +Inputs: + Required: + - anything: any, {} + - purge_cache: BOOLEAN, {"default": True} + - purge_models: BOOLEAN, {"default": True} + Optional: +Outputs: + - any (any) +-------------------------------------------------- +Node: VideoCombine: + @classmethod + def INPUT_TYPES +Category: Video Helper Suite 🎥🅥🅗🅢 +Inputs: + Required: + Optional: +Outputs: + - Filenames (VHS_FILENAMES) +-------------------------------------------------- +Node: LoadAudio: + @classmethod + def INPUT_TYPES +Category: audio +Inputs: + Required: + - {"audio: sorted(files + Optional: +Outputs: + - AUDIO +-------------------------------------------------- +Node: LoadAudioUpload: + @classmethod + def INPUT_TYPES +Category: Video Helper Suite 🎥🅥🅗🅢/audio +Inputs: + Required: + - audio: sorted(files + - start_time: FLOAT, {"default": 0, min": 0, max": 10000000, step": 0.01} + - duration: FLOAT, {"default": 0, min": 0, max": 10000000, step": 0.01} + Optional: +Outputs: + - audio (AUDIO) +-------------------------------------------------- +Node: AudioToVHSAudio: + """Legacy method for external nodes that utilized VHS_AUDIO, + VHS_AUDIO is deprecated as a format and should no longer be used""" + @classmethod + def INPUT_TYPES +Category: Video Helper Suite 🎥🅥🅗🅢/audio +Description: Legacy method for external nodes that utilized VHS_AUDIO, + VHS_AUDIO is deprecated as a format and should no longer be used +Inputs: + Required: + - {"audio: AUDIO + Optional: +Outputs: + - vhs_audio (VHS_AUDIO) +-------------------------------------------------- +Node: VHSAudioToAudio: + """Legacy method for external nodes that utilized VHS_AUDIO, + VHS_AUDIO is deprecated as a format and should no longer be used""" + @classmethod + def INPUT_TYPES +Category: Video Helper Suite 🎥🅥🅗🅢/audio +Description: Legacy method for external nodes that utilized VHS_AUDIO, + VHS_AUDIO is deprecated as a format and should no longer be used +Inputs: + Required: + - {"vhs_audio: VHS_AUDIO + Optional: +Outputs: + - audio (AUDIO) +-------------------------------------------------- +Node: PruneOutputs: + @classmethod + def INPUT_TYPES +Category: Video Helper Suite 🎥🅥🅗🅢 +Inputs: + Required: + - filenames: VHS_FILENAMES + - options: ["Intermediate, Intermediate and Utility"] + Optional: +Outputs: +-------------------------------------------------- +Node: BatchManager: + def __init__ +Category: Video Helper Suite 🎥🅥🅗🅢 +Inputs: + Required: + - frames_per_batch: INT, {"default": 16, min": 1, max": BIGMAX, step": 1} + Optional: +Outputs: + - meta_batch (VHS_BatchManager) +-------------------------------------------------- +Node: VideoInfo: + @classmethod + def INPUT_TYPES +Category: Video Helper Suite 🎥🅥🅗🅢 +Inputs: + Required: + - video_info: VHS_VIDEOINFO + Optional: +Outputs: + - FLOAT + - INT + - FLOAT + - INT + - INT + - FLOAT + - INT + - FLOAT + - INT + - INT +-------------------------------------------------- +Node: VideoInfoSource: + @classmethod + def INPUT_TYPES +Category: Video Helper Suite 🎥🅥🅗🅢 +Inputs: + Required: + - video_info: VHS_VIDEOINFO + Optional: +Outputs: + - FLOAT + - INT + - FLOAT + - INT + - INT +-------------------------------------------------- +Node: VideoInfoLoaded: + @classmethod + def INPUT_TYPES +Category: Video Helper Suite 🎥🅥🅗🅢 +Inputs: + Required: + - video_info: VHS_VIDEOINFO + Optional: +Outputs: + - FLOAT + - INT + - FLOAT + - INT + - INT +-------------------------------------------------- +Node: SelectFilename: + @classmethod + def INPUT_TYPES +Category: Video Helper Suite 🎥🅥🅗🅢 +Inputs: + Required: + - {"filenames: VHS_FILENAMES + Optional: +Outputs: + - Filename (STRING) +-------------------------------------------------- +Node: Unbatch: +Category: Unknown +Inputs: + Required: + Optional: +Outputs: +-------------------------------------------------- +Node: Any +Category: Video Helper Suite 🎥🅥🅗🅢 +Inputs: + Required: + - {"batched: * + Optional: +Outputs: + - unbatched (Any('*')) +-------------------------------------------------- +Node: SelectLatest: + @classmethod + def INPUT_TYPES +Category: Video Helper Suite 🎥🅥🅗🅢 +Inputs: + Required: + - {"filename_prefix: STRING, {'default': 'output/AnimateDiff, vhs_path_extensions': []} + - filename_postfix: STRING, {"placeholder": ".webm"} + Optional: +Outputs: + - Filename (STRING) +-------------------------------------------------- +Node: VariableLineWidthEffectNode: + @classmethod + def INPUT_TYPES +Category: SyntaxNodes/Processing +Description: Convert mask to proper format and shape +Inputs: + Required: + - images: IMAGE + - line_spacing: INT, {"default": 5, min": 1, max": 20} + - displacement_strength: FLOAT, {"default": 30.0, min": 1.0, max": 100.0} + - line_thickness: INT, {"default": 1, min": 1, max": 5} + - invert: BOOLEAN, {"default": False} + - color_intensity: FLOAT, {"default": 3.0, min": 0.0, max": 5.0} + - start_color_r: INT, {"default": 0, min": 0, max": 255} + - start_color_g: INT, {"default": 0, min": 0, max": 255} + - start_color_b: INT, {"default": 255, min": 0, max": 255} + - end_color_r: INT, {"default": 255, min": 0, max": 255} + - end_color_g: INT, {"default": 0, min": 0, max": 255} + - end_color_b: INT, {"default": 0, min": 0, max": 255} + Optional: + - mask: MASK +Outputs: + - IMAGE +-------------------------------------------------- +Node: PaperCraftNode: + def __init__ +Category: 🎨 Image/Effects +Inputs: + Required: + - image: IMAGE + - default: 0.2 + - min: 0.0 + - max: 1.0 + - step: 0.05 + Optional: + - mask: MASK +Outputs: + - IMAGE +-------------------------------------------------- +Node: DepthToLidarEffectNode: + def __init__ +Category: SyntaxNodes/Processing +Description: Reset the previous frame memory for a new sequence. +Inputs: + Required: + - depth_map: IMAGE + - default: 1 + - min: 1 + - max: 5 + - step: 1 + Optional: +Outputs: + - IMAGE +-------------------------------------------------- +Node: RegionBoundaryNode: + @classmethod + def INPUT_TYPES +Category: SyntaxNodes/Processing +Inputs: + Required: + - image: IMAGE + - segments: INT, {"default": 100, min": 10, max": 1000, step": 10} + - compactness: FLOAT, {"default": 10.0, min": 1.0, max": 100.0, step": 1.0} + - line_color: INT, {"default": 0xFFFFFF, min": 0, max": 0xFFFFFF, step": 1} + Optional: +Outputs: + - IMAGE +-------------------------------------------------- +Node: LuminanceParticleNode: + def __init__ +Category: Unknown +Description: Create new particles at edge points with initial directions and lifespan. +Inputs: + Required: + - depth_map: IMAGE + - default: 50 + - min: 1 + - max: 100 + - step: 1 + Optional: +Outputs: + - IMAGE +-------------------------------------------------- +Node: EdgeTracingNode: + def __init__ +Category: Unknown +Description: Convert a tensor to a PIL image. +Inputs: + Required: + - input_image: IMAGE + - low_threshold: INT, {"default": 50, min": 0, max": 255} + - high_threshold: INT, {"default": 150, min": 0, max": 255} + - num_particles: INT, {"default": 1000, min": 1, max": 50000} + - speed: INT, {"default": 10, min": 1, max": 100} + - edge_opacity: FLOAT, {"default": 0.5, min": 0.0, max": 1.0} + - particle_size: INT, {"default": 1, min": 1, max": 10} + Optional: +Outputs: + - IMAGE +-------------------------------------------------- +Node: VoxelNode: + def __init__ +Category: SyntaxNodes/Processing +Inputs: + Required: + - image: IMAGE + - default: 0.2 + - min: 0.0 + - max: 1.0 + - step: 0.05 + Optional: + - mask: MASK +Outputs: + - IMAGE +-------------------------------------------------- +Node: GhostingNode: + def __init__ +Category: SyntaxNodes/Processing +Inputs: + Required: + - image: IMAGE + - default: 5 + - min: 1 + - max: 20 + - step: 1 + Optional: + - mask: MASK +Outputs: + - IMAGE +-------------------------------------------------- +Node: ImageListToImageBatch: + @classmethod + def INPUT_TYPES +Category: SyntaxNodes/Conversion +Inputs: + Required: + - images: IMAGE + Optional: +Outputs: + - IMAGE +-------------------------------------------------- +Node: ImageBatchToImageList: + @classmethod + def INPUT_TYPES +Category: SyntaxNodes/Conversion +Inputs: + Required: + - {"image: IMAGE + Optional: +Outputs: + - IMAGE +-------------------------------------------------- +Node: CyberpunkWindowNode: + def __init__ +Category: SyntaxNodes/Processing +Inputs: + Required: + - image: IMAGE + - custom_text: STRING, {"default": "MOVEMENT, multiline": False} + - default: 0 + - min: 0 + - max: 1 + - step: 1 + Optional: +Outputs: + - IMAGE +-------------------------------------------------- +Node: RGBStreakNode: + @classmethod + def INPUT_TYPES +Category: image/effects +Inputs: + Required: + - image: IMAGE + - default: 0.95 + - min: 0.1 + - max: 0.99 + - step: 0.01 + Optional: +Outputs: + - IMAGE +-------------------------------------------------- +Node: JigsawPuzzleNode: + @classmethod + def INPUT_TYPES +Category: 🖼️ Image/Effects +Description: Converts a ComfyUI tensor to a NumPy array (for OpenCV). +Inputs: + Required: + - image: IMAGE + - pieces: INT, {"default": 50, min": 10, max": 500, step": 10} + - piece_size: INT, {"default": 64, min": 32, max": 100, step": 1} + - background: IMAGE, {"optional": True} + - num_remove: INT, {"default": 3, min": 0, max": 100, step": 1} + Optional: + - {"default: 3 +Outputs: + - IMAGE +-------------------------------------------------- +Node: EdgeMeasurementOverlayNode: + def __init__ +Category: Unknown +Inputs: + Required: + - image: IMAGE + - default: 0.7 + - min: 0.0 + - max: 1.0 + - step: 0.1 + Optional: +Outputs: + - IMAGE +-------------------------------------------------- +Node: UpTrackNode: + def __init__ +Category: SyntaxNodes/Processing +Description: Normalize angle to -180 to 180 range +Inputs: + Required: + - image: IMAGE + - default: 5.0 + - min: 0.0 + - max: 45.0 + - step: 1.0 + - display: combo + - labels: Upright Lock, Follow Flip + Optional: +Outputs: + - IMAGE +-------------------------------------------------- +Node: LowPolyNode: + def __init__ +Category: Unknown +Inputs: + Required: + - image: IMAGE + - default: 5 + - min: 1 + - max: 20 + - step: 1 + Optional: +Outputs: + - IMAGE +-------------------------------------------------- +Node: if it can't be imported +Category: Unknown +Inputs: + Required: + Optional: +Outputs: +-------------------------------------------------- +Node: PngInfo: + def __init__ +Category: Unknown +Inputs: + Required: + Optional: +Outputs: +-------------------------------------------------- +Node: FrequencyBeatSyncNode: + def __init__ +Category: Video Processing +Description: Convert tensor to PIL Image +Inputs: + Required: + - video_folder: STRING, {"default": "videos"} + - audio_path: STRING, {"default": "audio.mp3"} + - width: INT, {"default": 512, min": 64, max": 2048} + - height: INT, {"default": 512, min": 64, max": 2048} + - fps: INT, {"default": 30, min": 1, max": 60} + - max_beats: INT, {"default": 0, min": 0, max": 1000, step": 1} + - max_frames: INT, {"default": 150, min": 0, max": 1000, step": 1} + - effect_intensity: FLOAT, {"default": 1.0, min": 0.1, max": 5.0, step": 0.1} + - output_mode: ["Frames for Editing, Direct Video Output"] + - filename_prefix: STRING, {"default": "BeatSync"} + Optional: +Outputs: + - frames (IMAGE) + - audio (AUDIO) +-------------------------------------------------- +Node: PointillismNode: + def __init__ +Category: Unknown +Inputs: + Required: + - image: IMAGE + - dot_radius: INT, {"default": 3, min": 1, max": 10} + - dot_density: INT, {"default": 20000, min": 1000, max": 200000} + Optional: +Outputs: + - IMAGE +-------------------------------------------------- +Node: LS_CollageGenerator: + """随机分割生成指定数量的不规则小矩形。""" + def __init__ +Category: Unknown +Description: 随机分割生成指定数量的不规则小矩形。 +Inputs: + Required: + Optional: +Outputs: +-------------------------------------------------- +Node: PIP_Collage: + def __init__ +Category: PIP 动漫人脸检测 +Inputs: + Required: + - images: IMAGE, {"description": "输入图像"} + - default: multi + - min: 0.0 + - max: 1.0 + - step: 0.01 + - display: 模式 + - description: 选择多人模式或单人模式 + Optional: +Outputs: + - 输出图像 (IMAGE) + - 遮罩 (MASK) +-------------------------------------------------- +Node: mappings +NODE_CLASS_MAPPINGS = { + "PIP_AnimeFaceDetect": PIP_AnimeFaceDetect, + "PIP_Collage": PIP_Collage, + "PIP_GridComic": PIP_GridComic +} + +# Node display name mappings +NODE_DISPLAY_NAME_MAPPINGS = { + "PIP_AnimeFaceDetect": "PIP 动漫人脸检测", + "PIP_Collage": "PIP 随机拼图", + "PIP_GridComic": "PIP 格漫拼图" +} +Category: Unknown +Inputs: + Required: + Optional: +Outputs: +-------------------------------------------------- +Node: PIP_AnimeFaceDetect: + @classmethod + def INPUT_TYPES +Category: PIP 动漫人脸检测 +Inputs: + Required: + - image_in: IMAGE, {} + - score_threshold: FLOAT, {"default": 0.25, min": 0.0, max": 1.0, step": 0.01, label": "置信度阈值"} + - iou_threshold: FLOAT, {"default": 0.7, min": 0.0, max": 1.0, step": 0.01, label": "IOU 阈值"} + - expand_ratio: FLOAT, {"default": 0.0, min": 0.0, max": 1.0, step": 0.01, label": "扩展比例"} + Optional: +Outputs: + - 带框图像 (IMAGE) + - 裁剪人脸 (IMAGE) + - 人脸遮罩 (MASK) + - 人脸检测结果 (STRING) +-------------------------------------------------- +Node: MangaStyleLayoutGenerator: + """创意漫画布局生成器，使用真实漫画的多样化布局风格""" + def __init__ +Category: Unknown +Description: 创意漫画布局生成器，使用真实漫画的多样化布局风格 +Inputs: + Required: + Optional: +Outputs: +-------------------------------------------------- +Node: PIP_GridComic: + def __init__ +Category: PIP 动漫人脸检测 +Description: 将图像调整到目标尺寸，根据图像类型优化裁剪，并可选择旋转 +Inputs: + Required: + - character_image: IMAGE, {"description": "角色图像 (1:2 + - expression_image: IMAGE, {"description": "表情图像 (2:1 + - scene_image: IMAGE, {"description": "场景图像 (1:1 + - item_image: IMAGE, {"description": "物品图像 (1:1 + - default: 0 + - min: 0 + - max: 1e18 + - step: 1 + - display: 随机种子 + Optional: +Outputs: + - 输出图像 (IMAGE) + - 遮罩 (MASK) +-------------------------------------------------- +Node: DebouncedHotReloader +Category: Unknown +Description: Hot reloader with debouncing mechanism to reload modules on file changes. +Inputs: + Required: + Optional: +Outputs: +-------------------------------------------------- +Node: HotReloaderService: + """Service to manage the hot reloading of modules.""" + + def __init__ +Category: Unknown +Description: Service to manage the hot reloading of modules. +Inputs: + Required: + Optional: +Outputs: +-------------------------------------------------- +Node: variables for help documentation +Category: Unknown +Inputs: + Required: + Optional: +Outputs: +-------------------------------------------------- +Node: RyanOnTheInside +Category: Unknown +Inputs: + Required: + Optional: +Outputs: +-------------------------------------------------- +Node: ProgressMixin: + def start_progress +Category: Unknown +Description: ██████╗ ██╗ ██╗ █████╗ ███╗ ██╗ ██████╗ ███╗ ██╗ + ██╔══██╗╚██╗ ██╔╝██╔══██╗████╗ ██║ ██╔═══██╗████╗ ██║ + ██████╔╝ ╚████╔╝ ███████║██╔██╗ ██║ ██║ ██║██╔██╗ ██║ + ██╔══██╗ ╚██╔╝ ██╔══██║██║╚██╗██║ ██║ ██║██║╚██╗██║ + ██║ ██║ ██║ ██║ ██║██║ ╚████║ ╚██████╔╝██║ ╚████║ + ╚═╝ ╚═╝ ╚═╝ ╚═╝ ╚═╝╚═╝ ╚═══╝ ╚═════╝ ╚═╝ ╚═══╝ +████████╗██╗ ██╗███████╗ ██╗███╗ ██╗███████╗██╗██████╗ ███████╗ +╚══██╔══╝██║ ██║██╔════╝ ██║████╗ ██║██╔════╝██║██╔══██╗██╔════╝ + ██║ ███████║█████╗ ██║██╔██╗ ██║███████╗██║██║ ██║█████╗ + ██║ ██╔══██║██╔══╝ ██║██║╚██╗██║╚════██║██║██║ ██║██╔══╝ + ██║ ██║ ██║███████╗ ██║██║ ╚████║███████║██║██████╔╝███████╗ + ╚═╝ ╚═╝ ╚═╝╚══════╝ ╚═╝╚═╝ ╚═══╝╚══════╝╚═╝╚═════╝ ╚══════╝ + + ⚡ R Y A N O N T H E I N S I D E ⚡ +Inputs: + Required: + Optional: +Outputs: +-------------------------------------------------- +Node: ShellAgentOutputText: + TYPE_STR = "text" + @classmethod + def INPUT_TYPES +Category: shellagent +Inputs: + Required: + - s.TYPE_STR: STRING, {"tooltip": f"The {s.TYPE_STR} to output."} + - output_name: STRING, {"multiline": False, default": f"output_{s.TYPE_STR}"} + Optional: +Outputs: +-------------------------------------------------- +Node: ShellAgentOutputFloat +Category: Unknown +Inputs: + Required: + - s.TYPE_STR: FLOAT, {"tooltip": f"The {s.TYPE_STR} to output."} + - output_name: STRING, {"multiline": False, default": f"output_{s.TYPE_STR}"} + Optional: +Outputs: +-------------------------------------------------- +Node: ShellAgentOutputInteger +Category: Unknown +Inputs: + Required: + - s.TYPE_STR: INT, {"tooltip": f"The {s.TYPE_STR} to output."} + - output_name: STRING, {"multiline": False, default": f"output_{s.TYPE_STR}"} + Optional: +Outputs: +-------------------------------------------------- +Node: ShellAgentOutputBoolean +Category: Unknown +Inputs: + Required: + - s.TYPE_STR: BOOLEAN, {"tooltip": f"The {s.TYPE_STR} to output."} + - output_name: STRING, {"multiline": False, default": f"output_{s.TYPE_STR}"} + Optional: +Outputs: +-------------------------------------------------- +Node: ShellAgentSaveImages +Category: shellagent +Inputs: + Required: + - images: IMAGE, {"tooltip": "The images to save."} + - output_name: STRING, {"multiline": False, default": "output_image"} + - filename_prefix: STRING, {"default": "ComfyUI, tooltip": "The prefix for the file to save. This may include formatting information such as %date:yyyy-MM-dd% or %Empty Latent Image.width% to include values from nodes."} + Optional: +Outputs: +-------------------------------------------------- +Node: ShellAgentSaveImage +Category: Unknown +Inputs: + Required: + Optional: +Outputs: +-------------------------------------------------- +Node: ShellAgentSaveVideoVHS: + @classmethod + def INPUT_TYPES +Category: shellagent +Inputs: + Required: + - filenames: VHS_FILENAMES, {"tooltip": "The filenames to save."} + - output_name: STRING, {"multiline": False, default": "output_video"} + Optional: +Outputs: +-------------------------------------------------- +Node: ShellAgentPluginInputText: + @classmethod + def INPUT_TYPES +Category: shellagent +Inputs: + Required: + - {"multiline: False + Optional: + - {"multiline: False +Outputs: + - text (STRING) +-------------------------------------------------- +Node: ShellAgentPluginInputFloat: + @classmethod + def INPUT_TYPES +Category: shellagent +Inputs: + Required: + - {"multiline: False + Optional: + - {"default: } + - {"multiline: False +Outputs: + - float (FLOAT) +-------------------------------------------------- +Node: ShellAgentPluginInputInteger: + @classmethod + def INPUT_TYPES +Category: shellagent +Inputs: + Required: + - {"multiline: False + Optional: + - {"default: 1 + - {"multiline: False +Outputs: + - int (INT) +-------------------------------------------------- +Node: ShellAgentPluginInputBoolean: + @classmethod + def INPUT_TYPES +Category: shellagent +Inputs: + Required: + - {"multiline: False + Optional: + - {"default: False} + - {"multiline: True +Outputs: + - boolean (BOOLEAN) +-------------------------------------------------- +Node: ShellAgentPluginInputImage: + @classmethod + def INPUT_TYPES +Category: shellagent +Inputs: + Required: + - {"multiline: False + - sorted(files), {"image_upload: files + Optional: + - {"multiline: False +Outputs: + - image (IMAGE) +-------------------------------------------------- +Node: ShellAgentPluginInputVideo: +# @classmethod +# def INPUT_TYPES +Category: shellagent +Inputs: + Required: + - # {"multiline: False + - # "STRING", {"video_upload: files + Optional: + - # {"multiline: True +Outputs: + - video (STRING) +-------------------------------------------------- +Node: ShellAgentPluginInputImage: +# @classmethod +# def INPUT_TYPES +Category: shellagent +Inputs: + Required: + - # {"multiline: False + - # "STRING", {"image_upload: files + Optional: + - # {"multiline: True +Outputs: + - image (IMAGE) +-------------------------------------------------- +Node: ShellAgentPluginInputVideo: + @classmethod + def INPUT_TYPES +Category: shellagent +Inputs: + Required: + - {"multiline: False + - { "video_upload: True } + - # "STRING", {"video_upload: files + Optional: + - {"multiline: True +Outputs: + - video (STRING) +-------------------------------------------------- +Node: ShellAgentPluginInputAudio: + @classmethod + def INPUT_TYPES +Category: shellagent +Inputs: + Required: + - {"multiline: False + - sorted(files), {"audio_upload: files + Optional: + - {"multiline: True +Outputs: + - AUDIO +-------------------------------------------------- +Node: ShellAgentSaveAudios +Category: shellagent +Inputs: + Required: + - {"audio: AUDIO + - output_name: STRING, {"multiline": False, default": "output_audio"} + - filename_prefix: STRING, {"default": "audio/ComfyUI"} + Optional: +Outputs: +-------------------------------------------------- +Node: ShellAgentSaveAudio +Category: Unknown +Inputs: + Required: + Optional: +Outputs: +-------------------------------------------------- \ No newline at end of file diff --git a/web/nodes/node_definitions.txt.bak b/web/nodes/node_definitions.txt.bak new file mode 100644 index 0000000..d3739bc --- /dev/null +++ b/web/nodes/node_definitions.txt.bak @@ -0,0 +1,4892 @@ +Node: SaveImageWebsocket: + @classmethod + def INPUT_TYPES +Category: api/image +Inputs: + Required: + - {"images: IMAGE + Optional: +Outputs: +-------------------------------------------------- +Node: Segment: + @classmethod + def INPUT_TYPES +Category: 🧪AILab/🧽RMBG +Inputs: + Required: + Optional: +Outputs: + - IMAGE (IMAGE) + - MASK (MASK) +-------------------------------------------------- +Node: for preview +Category: Unknown +Inputs: + Required: + Optional: +Outputs: +-------------------------------------------------- +Node: AiLab_PreviewBase: + def __init__ +Category: Unknown +Inputs: + Required: + Optional: +Outputs: +-------------------------------------------------- +Node: AiLab_Preview +Category: 🧪AILab/🛠️UTIL/🖼️IMAGE +Inputs: + Required: + Optional: + - image: IMAGE, {"default": None} + - mask: MASK, {"default": None} +Outputs: + - IMAGE (IMAGE) + - MASK (MASK) +-------------------------------------------------- +Node: AiLab_MaskPreview +Category: 🧪AILab/🛠️UTIL/🖼️IMAGE +Inputs: + Required: + - {"mask: MASK + Optional: +Outputs: + - MASK (MASK) +-------------------------------------------------- +Node: AiLab_ImagePreview +Category: 🧪AILab/🛠️UTIL/🖼️IMAGE +Inputs: + Required: + - {"image: IMAGE + Optional: +Outputs: + - IMAGE (IMAGE) +-------------------------------------------------- +Node: AiLab_LoadImage: + @classmethod + def INPUT_TYPES +Category: 🧪AILab/🛠️UTIL/🖼️IMAGE +Inputs: + Required: + - image: sorted(files + - mask_channel: ["alpha, red, green, blue"], {"default": "alpha, tooltip": "Select channel to extract mask from"} + - scale_by: FLOAT, {"default": 1.0, min": 0.01, max": 8.0, step": 0.01, tooltip": "Scale image by this factor (ignored if longest_side > 0 + - longest_side: INT, {"default": 0, min": 0, max": 8192, step": 8, tooltip": "Resize image so longest side equals this value (0 = disabled + Optional: +Outputs: + - IMAGE (IMAGE) + - MASK (MASK) + - MASK_IMAGE (IMAGE) + - WIDTH (INT) + - HEIGHT (INT) +-------------------------------------------------- +Node: mappings +NODE_CLASS_MAPPINGS = { + "AiLab_LoadImage": AiLab_LoadImage, + "AiLab_Preview": AiLab_Preview, + "AiLab_ImagePreview": AiLab_ImagePreview, + "AiLab_MaskPreview": AiLab_MaskPreview, +} + +# Node display name mappings +NODE_DISPLAY_NAME_MAPPINGS = { + "AiLab_LoadImage": "Load Image +Category: Unknown +Inputs: + Required: + Optional: +Outputs: +-------------------------------------------------- +Node: FaceSegment: + def __init__ +Category: 🧪AILab/🧽RMBG +Inputs: + Required: + Optional: +Outputs: + - IMAGE (IMAGE) + - MASK (MASK) +-------------------------------------------------- +Node: masks + combined_mask = None + for class_name in selected_classes: + mask = +Category: Unknown +Inputs: + Required: + Optional: +Outputs: +-------------------------------------------------- +Node: FashionSegmentAccessories: + @classmethod + def INPUT_TYPES +Category: 🧪AILab/🧽RMBG +Inputs: + Required: + Optional: + - **{cls_name: BOOLEAN, {"default": False} +Outputs: + - accessories_options (ACCESSORIES_OPTIONS) +-------------------------------------------------- +Node: FashionSegmentClothing: + def __init__ +Category: 🧪AILab/🧽RMBG +Inputs: + Required: + - images: IMAGE + - accessories_options: ACCESSORIES_OPTIONS + Optional: + - **{cls_name: BOOLEAN, {"default": False} + - process_res: INT, {"default": 512, min": 128, max": 2048, step": 32} + - mask_blur: INT, {"default": 0, min": 0, max": 64, step": 1} + - mask_offset: INT, {"default": 0, min": -64, max": 64, step": 1} + - background_color: ["Alpha, black, white, gray, green, blue, red"], {"default": "Alpha"} + - invert_output: BOOLEAN, {"default": False} +Outputs: + - images (IMAGE) + - mask (MASK) +-------------------------------------------------- +Node: BodySegment: + def __init__ +Category: 🧪AILab/🧽RMBG +Inputs: + Required: + Optional: +Outputs: + - IMAGE (IMAGE) + - MASK (MASK) +-------------------------------------------------- +Node: masks + combined_mask = np.zeros_like +Category: Unknown +Inputs: + Required: + Optional: +Outputs: +-------------------------------------------------- +Node: BaseModelLoader: + def __init__ +Category: Unknown +Inputs: + Required: + Optional: +Outputs: +-------------------------------------------------- +Node: RMBGModel +Category: Unknown +Inputs: + Required: + Optional: +Outputs: +-------------------------------------------------- +Node: = getattr +Category: Unknown +Inputs: + Required: + Optional: +Outputs: +-------------------------------------------------- +Node: InspyrenetModel +Category: Unknown +Inputs: + Required: + Optional: +Outputs: +-------------------------------------------------- +Node: BENModel +Category: Unknown +Inputs: + Required: + Optional: +Outputs: +-------------------------------------------------- +Node: BEN2Model +Category: Unknown +Inputs: + Required: + Optional: +Outputs: +-------------------------------------------------- +Node: RMBG: + def __init__ +Category: 🧪AILab/🧽RMBG +Inputs: + Required: + Optional: +Outputs: + - IMAGE (IMAGE) + - MASK (MASK) + - MASK_IMAGE (IMAGE) +-------------------------------------------------- +Node: BiRefNetModel: + def __init__ +Category: Unknown +Inputs: + Required: + Optional: +Outputs: +-------------------------------------------------- +Node: BiRefNetRMBG: + def __init__ +Category: 🧪AILab/🧽RMBG +Inputs: + Required: + Optional: +Outputs: + - IMAGE (IMAGE) + - MASK (MASK) +-------------------------------------------------- +Node: ClothesSegment: + def __init__ +Category: 🧪AILab/🧽RMBG +Inputs: + Required: + Optional: +Outputs: + - IMAGE (IMAGE) + - MASK (MASK) +-------------------------------------------------- +Node: _: + """ + An opinionated batch image loader. This is used for loading groups for batch processing. + + Folder structure: + + ```plain + groups/ + baseprompt.txt + g1/ + 0001.png + 0002.png + subprompt.txt + g2/ + 0003.png + 0004.png + subprompt.txt + ... + ``` + """ + + CATEGORY = "jamesWalker55" + INPUT_TYPES = lambda: { + "required": { + "groups_dir": +Category: jamesWalker55 +Description: An opinionated batch image loader. This is used for loading groups for batch processing. + + Folder structure: + + ```plain + groups/ + baseprompt.txt + g1/ + 0001.png + 0002.png + subprompt.txt + g2/ + 0003.png + 0004.png + subprompt.txt + ... + ``` +Inputs: + Required: + - groups_dir: STRING, {"default": "./groups, multiline": False} + - groups_id: INT, {"default": 1, min": 0, step": 1, max": 9999} + - {"default: *.png + Optional: +Outputs: + - STRING + - STRING + - IMAGE + - INT + - STRING +-------------------------------------------------- +Node: GroupedWorkspace: + """ + YAML structure: + + ```yaml + positive: | + {positive}, + simple background, white background, + + negative: | + {negative}, + low quality, + + image_pattern: '{frame_id:04d}.png' + + groups: + - start_id: 1 + positive: ... + negative: ... + - start_id: 5 + positive: ... + negative: ... + ... + ``` + """ + + _original_definition: dict + _base_path: Path + _base_pos: str + _base_neg: str + _image_pattern: str + _groups: list[dict] + + def __init__ +Category: Unknown +Description: YAML structure: + + ```yaml + positive: | + {positive}, + simple background, white background, + + negative: | + {negative}, + low quality, + + image_pattern: '{frame_id:04d}.png' + + groups: + - start_id: 1 + positive: ... + negative: ... + - start_id: 5 + positive: ... + negative: ... + ... + ``` +Inputs: + Required: + Optional: +Outputs: +-------------------------------------------------- +Node: __: + """ + An opinionated batch image loader. This is used for loading groups for batch processing. + + "base_path" controls where the images are loaded relative from. Defaults to the + folder containing the definition file. + """ + + CATEGORY = "jamesWalker55" + INPUT_TYPES = lambda: { + "required": { + "definition_path": +Category: jamesWalker55 +Description: An opinionated batch image loader. This is used for loading groups for batch processing. + + "base_path" controls where the images are loaded relative from. Defaults to the + folder containing the definition file. +Inputs: + Required: + - {"default: ./groups.yml + - group_id: INT, {"default": 1, min": 0, step": 1, max": 9999} + - base_path: STRING, {"default": ""} + Optional: +Outputs: + - STRING + - STRING + - IMAGE + - INT + - STRING + - GROUP_INFO +-------------------------------------------------- +Node: _: + """ + An opinionated image loader. This is used for loading groups for batch processing. + + "base_path" controls where the images are loaded relative from. Defaults to the + folder containing the definition file. + """ + + CATEGORY = "jamesWalker55" + INPUT_TYPES = lambda: { + "required": { + "definition_path": +Category: jamesWalker55 +Description: An opinionated image loader. This is used for loading groups for batch processing. + + "base_path" controls where the images are loaded relative from. Defaults to the + folder containing the definition file. +Inputs: + Required: + - {"default: ./groups.yml + - frame_id: INT, {"default": 1, min": 0, step": 1, max": 9999} + - base_path: STRING, {"default": ""} + Optional: +Outputs: + - STRING + - STRING + - IMAGE + - STRING + - GROUP_INFO +-------------------------------------------------- +Node: _: + CATEGORY = "jamesWalker55" + INPUT_TYPES = lambda: { + "required": { + "group_info": +Category: jamesWalker55 +Inputs: + Required: + - group_info: GROUP_INFO + - key: STRING, {"default": ""} + Optional: +Outputs: + - FLOAT +-------------------------------------------------- +Node: _: + CATEGORY = "jamesWalker55" + INPUT_TYPES = lambda: { + "required": { + "format": +Category: jamesWalker55 +Inputs: + Required: + - format: STRING, {"default": "%Y-%m-%dT%H:%M:%S"} + Optional: +Outputs: + - STRING +-------------------------------------------------- +Node: _: + CATEGORY = "jamesWalker55" + BLEND_TYPES = +Category: jamesWalker55 +Inputs: + Required: + - blend_type: cls.BLEND_TYPES, {"default": "mix"} + - factor: FLOAT, {"min": 0, max": 1, step": 0.01, default": 0.5} + - image_a: IMAGE + - image_b: IMAGE + Optional: +Outputs: + - IMAGE +-------------------------------------------------- +Node: _: + CATEGORY = "jamesWalker55" + INPUT_TYPES = lambda: { + "required": { + "image": +Category: jamesWalker55 +Inputs: + Required: + - image: IMAGE + - resize_length: INT, {"default": 512, min": 8, step": 8} + - crop_rect: CROP_RECT + Optional: +Outputs: + - IMAGE +-------------------------------------------------- +Node: _: + CATEGORY = "jamesWalker55" + INPUT_TYPES = lambda: { + "required": { + "path": +Category: jamesWalker55 +Inputs: + Required: + - path: STRING, {"default": "./audio.mp3"} + - gain_db: FLOAT, {"default": 0, min": -100, max": 100} + - offset_seconds: FLOAT, {"default": 0, min": 0, max": FLOAT_MAX} + - duration_seconds: FLOAT, {"default": 0, min": 0, max": FLOAT_MAX} + - resample_to_hz: FLOAT, {"default": 0, min": 0, max": FLOAT_MAX} + - make_stereo: BOOLEAN, {"default": True} + Optional: +Outputs: + - AUDIO +-------------------------------------------------- +Node: _: + CATEGORY = "jamesWalker55" + INPUT_TYPES = lambda: { + "required": { + "paths": +Category: jamesWalker55 +Inputs: + Required: + - default: ./frame000001.png\n./frame000002.png\n./frame000003.png + - multiline: True + - dynamicPrompts: False + - ignore_missing_images: ("false, true + Optional: +Outputs: + - IMAGE +-------------------------------------------------- +Node: _: + CATEGORY = "jamesWalker55" + INPUT_TYPES = lambda: { + "required": { + "images": +Category: jamesWalker55 +Inputs: + Required: + - images: IMAGE + - {"default: ./frame{ + - start_index: INT, {"default": 0, min": 0, step": 1} + - overwrite: ("false, true + Optional: +Outputs: +-------------------------------------------------- +Node: _: + CATEGORY = "jamesWalker55" + INPUT_TYPES = lambda: { + "required": { + "mask": +Category: jamesWalker55 +Inputs: + Required: + - mask: MASK + - batch_size: INT, {"default": 1, min": 1, step": 1} + Optional: +Outputs: + - MASK_SEQUENCE +-------------------------------------------------- +Node: _: + CATEGORY = "jamesWalker55" + INPUT_TYPES = lambda: {"required": {}} + RETURN_TYPES = +Category: jamesWalker55 +Inputs: + Required: + Optional: +Outputs: + - IMAGE + - MASK +-------------------------------------------------- +Node: _: + """ + https://pytorch.org/vision/main/auto_examples/plot_optical_flow.html + """ + + CATEGORY = "jamesWalker55" + INPUT_TYPES = lambda: { + "required": { + "image_a": +Category: jamesWalker55 +Description: https://pytorch.org/vision/main/auto_examples/plot_optical_flow.html +Inputs: + Required: + - image_a: IMAGE + - image_b: IMAGE + Optional: +Outputs: + - RAFT_FLOW +-------------------------------------------------- +Node: _: + """ + https://pytorch.org/vision/main/auto_examples/plot_optical_flow.html + """ + + CATEGORY = "jamesWalker55" + INPUT_TYPES = lambda: { + "required": { + "raft_flow": +Category: jamesWalker55 +Description: https://pytorch.org/vision/main/auto_examples/plot_optical_flow.html +Inputs: + Required: + - raft_flow: RAFT_FLOW + Optional: +Outputs: + - IMAGE +-------------------------------------------------- +Node: _: + """ + This is a utility function for loading motion flows from an EXR image file. + This is intended for use with Blender's vector pass in the Cycles renderer. + + In Blender, enable the vector pass. In the compositor, use "Separate Color" to + extract the "Blue" and "Alpha" channels of the vector pass. Then, combine them + using "Combine Color" to two of the RGB channels. Finally, render to the "OpenEXR" + format. + + https://gist.github.com/andres-fr/4ddbb300d418ed65951ce88766236f9c + """ + + CATEGORY = "jamesWalker55" + INPUT_TYPES = lambda: { + "required": { + "path": +Category: jamesWalker55 +Description: This is a utility function for loading motion flows from an EXR image file. + This is intended for use with Blender's vector pass in the Cycles renderer. + + In Blender, enable the vector pass. In the compositor, use "Separate Color" to + extract the "Blue" and "Alpha" channels of the vector pass. Then, combine them + using "Combine Color" to two of the RGB channels. Finally, render to the "OpenEXR" + format. + + https://gist.github.com/andres-fr/4ddbb300d418ed65951ce88766236f9c +Inputs: + Required: + - path: STRING, {"default": ""} + - x_channel: ("R, G, B, A + - y_channel: ("R, G, B, A + - invert_x: ("false, true + - invert_y: ("false, true + Optional: +Outputs: + - RAFT_FLOW +-------------------------------------------------- +Node: RangedConfig: + def __init__ +Category: Unknown +Description: \ +p: | + masterpiece, best quality, + {sp}, + +n: | + {sn}, + embedding:EasyNegative, embedding:bad-artist, embedding:bad-hands-5, embedding:bad-image-v2-39000, + lowres, ((bad anatomy)), ((bad hands)), text, missing finger, extra digits, fewer digits, blurry, ((mutated hands and fingers)), (poorly drawn face), ((mutation)), ((deformed face)), (ugly), ((bad proportions)), ((extra limbs)), extra face, (double head), (extra head), ((extra feet)), monster, logo, cropped, worst quality, low quality, normal quality, jpeg, humpbacked, long body, long neck, ((jpeg artifacts)), + +path: "{i:04d}.png" + +example: 0 + +ranges: + 1: + sp: positive subprompt for 1-4 + sn: negative subprompt for 1-4 + 5: + sp: positive subprompt for 5-... + sn: negative subprompt for 5-... + example: 1 +Inputs: + Required: + Optional: +Outputs: +-------------------------------------------------- +Node: _: + CATEGORY = "jamesWalker55" + INPUT_TYPES = lambda: { + "required": { + "config": +Category: jamesWalker55 +Inputs: + Required: + - {"default: 16 + - ranges_key: STRING, {"default": "ranges, multiline": False} + - path_key: STRING, {"default": "path, multiline": False} + - batch_idx: INT, {"default": 0, min": 0, step": 1, max": 999999} + - i_start: INT, {"default": 1, min": 0, step": 1, max": 999999} + - i_stop: INT, {"default": 100, min": 0, step": 1, max": 999999} + - inclusive: ("false, true + Optional: +Outputs: + - INFO_HASH (INFO_HASH) + - IMAGE (IMAGE) + - BATCH_I_START (INT) + - BATCH_I_STOP (INT) +-------------------------------------------------- +Node: _: + CATEGORY = "jamesWalker55" + INPUT_TYPES = lambda: { + "required": { + "info_hash": +Category: jamesWalker55 +Inputs: + Required: + - info_hash: INFO_HASH + Optional: +Outputs: +-------------------------------------------------- +Node: _: + CATEGORY = "jamesWalker55" + INPUT_TYPES = lambda: { + "required": { + "info_hash_list": +Category: jamesWalker55 +Inputs: + Required: + - info_hash_list: INFO_HASH_LIST + - i: INT, {"default": 0, step": 1, min": -99999999, max": 99999999} + Optional: +Outputs: + - INFO_HASH +-------------------------------------------------- +Node: _: + CATEGORY = "jamesWalker55" + INPUT_TYPES = lambda: { + "required": { + "image_a": +Category: jamesWalker55 +Inputs: + Required: + - image_a: IMAGE + - image_b: IMAGE + Optional: +Outputs: + - IMAGE +-------------------------------------------------- +Node: _: + """ + Batch-load images in a given folder. To avoid loading too many images at once, + you can use `paginate_size` and `paginate_page` to load a subset of the images. + + To disable pagination functionality, leave `paginate_size` and `paginate_page` at 0. + """ + + CATEGORY = "jamesWalker55" + INPUT_TYPES = lambda: { + "required": { + "image_dir": +Category: jamesWalker55 +Description: Batch-load images in a given folder. To avoid loading too many images at once, + you can use `paginate_size` and `paginate_page` to load a subset of the images. + + To disable pagination functionality, leave `paginate_size` and `paginate_page` at 0. +Inputs: + Required: + - image_dir: STRING, {"default": "./images, multiline": False} + - glob_pattern: STRING, {"default": "*.png, multiline": False} + - paginate_size: INT, {"default": 0, min": 0} + - paginate_page: INT, {"default": 0, min": 0} + Optional: +Outputs: + - IMAGE (IMAGE) + - FRAME_COUNT (INT) + - FILENAMES (STRING) +-------------------------------------------------- +Node: Audio +Category: Unknown +Inputs: + Required: + Optional: +Outputs: +-------------------------------------------------- +Node: _: + CATEGORY = "jamesWalker55" + INPUT_TYPES = lambda: { + "required": { + "a": +Category: jamesWalker55 +Inputs: + Required: + - a: STRING_LIST + - b: STRING_LIST + Optional: +Outputs: + - STRING_LIST +-------------------------------------------------- +Node: ResultItem +Category: Unknown +Inputs: + Required: + Optional: +Outputs: +-------------------------------------------------- +Node: _: + CATEGORY = "jamesWalker55" + INPUT_TYPES = lambda: { + "required": { + "audio": +Category: jamesWalker55 +Inputs: + Required: + - audio: AUDIO + - path: STRING, {"default": "./audio.mp3"} + - overwrite: BOOLEAN, {"default": True} + Optional: +Outputs: +-------------------------------------------------- +Node: _: + CATEGORY = "jamesWalker55" + INPUT_TYPES = lambda: { + "required": { + "value": +Category: jamesWalker55 +Inputs: + Required: + - value: LATENT + - {"default: latent + Optional: +Outputs: + - LATENT +-------------------------------------------------- +Node: _: + CATEGORY = "jamesWalker55" + INPUT_TYPES = lambda: { + "required": { + "string_list": +Category: jamesWalker55 +Inputs: + Required: + - string_list: STRING_LIST + - clip: CLIP + Optional: +Outputs: + - CONDITIONING +-------------------------------------------------- +Node: _: + CATEGORY = "jamesWalker55" + INPUT_TYPES = lambda: { + "required": { + "default": +Category: jamesWalker55 +Inputs: + Required: + - default: IMAGE + - path: STRING, {"default": "./image.png"} + Optional: +Outputs: + - IMAGE +-------------------------------------------------- +Node: _: + CATEGORY = "jamesWalker55" + INPUT_TYPES = lambda: { + "required": { + "path_pattern": +Category: jamesWalker55 +Inputs: + Required: + - {"default: ./frame{ + - start_index: INT, {"default": 0, min": 0, step": 1, max": 999999} + - stop_index: INT, {"default": 16, min": 1, step": 1, max": 999999} + - inclusive: ("false, true + - ignore_missing_images: ("false, true + Optional: +Outputs: + - IMAGE +-------------------------------------------------- +Node: LoopImageSequence: + CATEGORY = "jamesWalker55" + INPUT_TYPES = lambda: { + "required": { + "images": +Category: jamesWalker55 +Inputs: + Required: + - images: IMAGE + - target_frames: INT, {"default": 16, step": 1} + Optional: +Outputs: + - IMAGE +-------------------------------------------------- +Node: _: + CATEGORY = "jamesWalker55/rc" + INPUT_TYPES = lambda: { + "required": { + "key": +Category: jamesWalker55/rc +Inputs: + Required: + - {"default: input_latent + - latent: LATENT + Optional: +Outputs: +-------------------------------------------------- +Node: _: + CATEGORY = "jamesWalker55" + INPUT_TYPES = lambda: { + "required": { + "mask_sequence_1": +Category: jamesWalker55 +Inputs: + Required: + - mask_sequence_1: MASK_SEQUENCE + - mask_sequence_2: MASK_SEQUENCE + Optional: +Outputs: + - MASK_SEQUENCE +-------------------------------------------------- +Node: _: + CATEGORY = "jamesWalker55" + INPUT_TYPES = lambda: { + "required": { + "samples": +Category: jamesWalker55 +Inputs: + Required: + - samples: LATENT + - mask_sequence: MASK_SEQUENCE + Optional: +Outputs: + - LATENT +-------------------------------------------------- +Node: CropRect +Category: Unknown +Inputs: + Required: + Optional: +Outputs: +-------------------------------------------------- +Node: _: + CATEGORY = "jamesWalker55" + INPUT_TYPES = lambda: { + "required": { + "x": +Category: jamesWalker55 +Inputs: + Required: + - x: INT, {"default": 0, min": 0, max": MAX_RESOLUTION, step": 1} + - y: INT, {"default": 0, min": 0, max": MAX_RESOLUTION, step": 1} + - {"default: 512 + Optional: +Outputs: + - CROP_RECT +-------------------------------------------------- +Node: _: + CATEGORY = "jamesWalker55" + INPUT_TYPES = lambda: { + "required": { + "original_image": +Category: jamesWalker55 +Inputs: + Required: + - original_image: IMAGE + - cropped_image: IMAGE + - cropped_mask: MASK + - crop_rect: CROP_RECT + Optional: +Outputs: + - IMAGE +-------------------------------------------------- +Node: _: + CATEGORY = category + INPUT_TYPES = lambda: {"required": required_inputs} + RETURN_TYPES = tuple +Category: category +Description: parses '\\n' literals in a string to actual '\n' characters +Inputs: + Required: + Optional: +Outputs: + - tuple(return_types +-------------------------------------------------- +Node: ReferenceOnlySimple: + CATEGORY = "jamesWalker55" + INPUT_TYPES = lambda: { + "required": { + "model": +Category: jamesWalker55 +Inputs: + Required: + - model: MODEL + - reference: LATENT + - initial_latent: LATENT + - batch_size: INT, {"default": 1, min": 1, max": 64} + Optional: +Outputs: + - MODEL + - LATENT +-------------------------------------------------- +Node: _: + """ + Set the strength of the previously-added ControlNet, number of values must be + equal to batch size. + """ + + CATEGORY = "jamesWalker55" + INPUT_TYPES = lambda: { + "required": { + "conditioning": +Category: jamesWalker55 +Description: Set the strength of the previously-added ControlNet, number of values must be + equal to batch size. +Inputs: + Required: + - conditioning: CONDITIONING + - default: 0.25 + - multiline: True + - dynamicPrompts: False + Optional: +Outputs: + - CONDITIONING +-------------------------------------------------- +Node: ManagerFuncsInComfyUI +Category: Unknown +Description: provide unified (node -> node pack) mapping list +Inputs: + Required: + Optional: +Outputs: +-------------------------------------------------- +Node: params are global +Category: Unknown +Description: # Coding a Python Function +You are an expert python coder who specializes in writing custom nodes for ComfyUI. + +## Available Python Modules +It is not required to use any of these libraries, but if you do use any import in your code it must be on this list: +[[IMPORTS]] + +## Input Data +Here is some important information about the input data: +- input_data_1: [[INPUT1]] +- input_data_2: [[INPUT2]] +[[CONNECTIONS]][[EXAMPLES]][[CODEBLOCK]] +## Coding Instructions +- Your job is to code the user's requested node given the inputs and desired output type. +- Respond with only a brief plan and the code in one function named generated_function that takes two kwargs named 'input_data_1' and 'input_data_2'. +- All functions you must define should be inner functions of generated_function. +- You may briefly plan your code in plain text, but after write only the code contents of the function itself inside of a `python` code block. +- Do include needed available imports in your code before the function. +- If the request is simple enough to do without imports, like math, just do that. +- If an input is a Tensor and the output is a Tensor, it should be the same shape unless otherwise specified by the user. +- Image tensors come in the shape (batch, width, height, rgb_channels), if outputting an image, use the same shape as the input image tensor. + - To know the tensor is an image, it will come with the last dimension as 3 + - An example image tensor for a single 512x786 image: (1, 512, 786, 3) + - An animation is a tensor with a larger batch of images of the same shape +- Your resulting code should be as compute efficient as possible. +- Make sure to deallocate memory for anything which uses it. +- You may not use `open` or fetch files from the internet. +- If there is a code block above, insure that the the generated_function args and kwargs match the example below. + +### Example Generated function: +User: output a list of all prime numbers up to the input number +```python +import math +def generated_function(input_data_1=None, input_data_2=None): + def is_prime(n): + if n <= 1: + return False + for i in range(2, int(math.sqrt(n))+1): + if n % i == 0: + return False + return True + primes = [] + num = input_data_1 + while num > 1: + if is_prime(num): + primes.append(num) + num -= 1 + return primes +``` + +## Write the Code +Inputs: + Required: + Optional: +Outputs: +-------------------------------------------------- +Node: AnyNode: + """Ask it to make up any node for you. """ + + NAME = "AnyNode" + CATEGORY = "utils" + + ALLOWED_IMPORTS = {"os", "re", "json", "random", "string", "sys", "math", "datetime", "collections", "itertools", "functools", "numpy", "openai", "traceback", "torch", "time", "sklearn", "torchvision", "matplotlib", "io", "base64", "wave", "google.generativeai", "chromadb", "uuid", "comfy", "scipy", "torchaudio", "torchvision", "cv2", "PIL"} + CODING_ATTEMPTS = 3 + + def __init__ +Category: utils +Description: Ask it to make up any node for you. +Inputs: + Required: + - multiline: True + - default: gpt-4o + Optional: + - any: any_type + - any2: any_type +Outputs: + - any (any_type) + - control (CTRL) +-------------------------------------------------- +Node: AnyNodeGemini +Category: Unknown +Inputs: + Required: + - multiline: True + - default: gemini-1.5-flash + Optional: + - any: any_type + - any2: any_type +Outputs: +-------------------------------------------------- +Node: AnyNodeOpenAICompatible +Category: Unknown +Inputs: + Required: + - multiline: True + - default: http + Optional: + - any: any_type + - any2: any_type + - default: ollama +Outputs: +-------------------------------------------------- +Node: AnyNodeAnthropic +Category: Unknown +Inputs: + Required: + - multiline: True + - default: claude-3-5-sonnet-20240620 + Optional: + - any: any_type + - any2: any_type +Outputs: +-------------------------------------------------- +Node: AnyNodeCodeViewer: + @classmethod + def INPUT_TYPES +Category: utils +Inputs: + Required: + - ctrl: CTRL, {"forceInput": True} + Optional: + - multiline: True + - default: No Comment yet. +Outputs: + - control (CTRL) +-------------------------------------------------- +Node: ShowText: + @classmethod + def INPUT_TYPES +Category: utils +Inputs: + Required: + - text: STRING, {"forceInput": True} + Optional: +Outputs: + - STRING +-------------------------------------------------- +Node: ConstrainImage: + """ + A node that constrains an image to a maximum and minimum size while maintaining aspect ratio. + """ + + @classmethod + def INPUT_TYPES +Category: image +Description: A node that constrains an image to a maximum and minimum size while maintaining aspect ratio. +Inputs: + Required: + - images: IMAGE + - max_width: INT, {"default": 1024, min": 0} + - max_height: INT, {"default": 1024, min": 0} + - min_width: INT, {"default": 0, min": 0} + - min_height: INT, {"default": 0, min": 0} + - crop_if_required: ["yes, no"], {"default": "no"} + Optional: +Outputs: + - IMAGE +-------------------------------------------------- +Node: AnyType +Category: Unknown +Inputs: + Required: + Optional: +Outputs: +-------------------------------------------------- +Node: ReroutePrimitive: + @classmethod + def INPUT_TYPES +Category: __hidden__ +Inputs: + Required: + - {"value: any + Optional: +Outputs: + - any +-------------------------------------------------- +Node: MultiPrimitive: + @classmethod + def INPUT_TYPES +Category: utils +Inputs: + Required: + Optional: + - {"value: any +Outputs: + - any +-------------------------------------------------- +Node: MathExpression: + + @classmethod + def INPUT_TYPES +Category: utils +Inputs: + Required: + - words: autocompleteWords + - separator: + Optional: + - a: any + - b: any + - c: any +Outputs: + - INT + - FLOAT +-------------------------------------------------- +Node: ConstrainImageforVideo: + """ + A node that constrains an image to a maximum and minimum size while maintaining aspect ratio. + """ + + @classmethod + def INPUT_TYPES +Category: image +Description: A node that constrains an image to a maximum and minimum size while maintaining aspect ratio. +Inputs: + Required: + - images: IMAGE + - max_width: INT, {"default": 1024, min": 0} + - max_height: INT, {"default": 1024, min": 0} + - min_width: INT, {"default": 0, min": 0} + - min_height: INT, {"default": 0, min": 0} + - crop_if_required: ["yes, no"], {"default": "no"} + Optional: +Outputs: + - IMAGE (IMAGE) +-------------------------------------------------- +Node: LoraLoaderWithImages +Category: Unknown +Inputs: + Required: + Optional: +Outputs: + - *getattr(LoraLoader (*LoraLoader.RETURN_TYPES) + - RETURN_NAMES (STRING) +-------------------------------------------------- +Node: CheckpointLoaderSimpleWithImages +Category: Unknown +Inputs: + Required: + Optional: +Outputs: + - *getattr(CheckpointLoaderSimple (*CheckpointLoaderSimple.RETURN_TYPES) + - RETURN_NAMES (STRING) +-------------------------------------------------- +Node: PlaySound: + @classmethod + def INPUT_TYPES +Category: utils +Inputs: + Required: + - any: any, {} + - mode: ["always, on empty queue"], {} + - volume: FLOAT, {"min": 0, max": 1, step": 0.1, default": 0.5} + - file: STRING, { "default": "notify.mp3" } + Optional: +Outputs: + - any +-------------------------------------------------- +Node: TextFileNode: + RETURN_TYPES = +Category: utils +Inputs: + Required: + Optional: +Outputs: + - STRING +-------------------------------------------------- +Node: LoadText +Category: Unknown +Inputs: + Required: + - root_dir: list(get_valid_dirs( + - source: root_dir + - type: set + - target: $this.disabled + - value: False + - url: /pysssss/text-file/{$source.value} + Optional: +Outputs: +-------------------------------------------------- +Node: SaveText +Category: Unknown +Inputs: + Required: + - root_dir: list(get_valid_dirs( + - file: STRING, {"default": "file.txt"} + - append: ["append, overwrite, new only"], {} + - default: True + - source: append + - type: set + - left: $source.value + - op: eq + - right: append + - target: $this.disabled + - value: True + - text: STRING, {"forceInput": True, multiline": True} + Optional: +Outputs: +-------------------------------------------------- +Node: Repeater: + @classmethod + def INPUT_TYPES +Category: utils +Inputs: + Required: + - source: any, {} + - repeats: INT, {"min": 0, max": 5000, default": 2} + - output: ["single, multi"], {} + - node_mode: ["reuse, create"], {} + Optional: +Outputs: + - any +-------------------------------------------------- +Node: SystemNotification: + @classmethod + def INPUT_TYPES +Category: utils +Inputs: + Required: + - message: STRING, {"default": "Your notification has triggered."} + - any: any, {} + - mode: ["always, on empty queue"], {} + Optional: +Outputs: + - any +-------------------------------------------------- +Node: StringFunction: + @classmethod + def INPUT_TYPES +Category: utils +Inputs: + Required: + - action: ["append, replace"], {} + - tidy_tags: ["yes, no"], {} + Optional: + - text_a: STRING, {"multiline": True, dynamicPrompts": False} + - text_b: STRING, {"multiline": True, dynamicPrompts": False} + - text_c: STRING, {"multiline": True, dynamicPrompts": False} +Outputs: + - STRING +-------------------------------------------------- +Node: Yolov8DetectionNode: + def __init__ +Category: yolov8 +Inputs: + Required: + - image: IMAGE + - model_name: folder_paths.get_filename_list("yolov8 + Optional: +Outputs: + - IMAGE + - JSON +-------------------------------------------------- +Node: Yolov8SegNode: + def __init__ +Category: yolov8 +Inputs: + Required: + - image: IMAGE + - model_name: folder_paths.get_filename_list("yolov8 + - class_id: INT, {"default": 0} + Optional: +Outputs: + - IMAGE + - MASK +-------------------------------------------------- +Node: is 0 +Category: Unknown +Inputs: + Required: + Optional: +Outputs: +-------------------------------------------------- +Node: IFWhisperSpeech: + @classmethod + def INPUT_TYPES +Category: ImpactFrames💥🎞️ +Description: \ + Electromagnetism is a fundamental force of nature that encompasses the interaction between + electrically charged particles. It is described by Maxwell's equations, which unify electricity, magnetism, + and light into a single theory. In essence, electric charges produce electric fields that exert forces on + other charges, while moving charges (currents) generate magnetic fields. These magnetic fields, in turn, + can affect the motion of charges and currents. The interaction between electric and magnetic fields propagates + through space as electromagnetic waves, which include visible light, radio waves, and X-rays. Electromagnetic + forces are responsible for practically all the phenomena encountered in daily life, excluding gravity. +Inputs: + Required: + - text: STRING, {"multiline": True, default": node.sample_text} + - file_name: STRING, {"default": node.file_name} + - speaker: node.audio_files, {} + - torch_compile: BOOLEAN, {"default": False} + Optional: + - cps: FLOAT, {"default": node.cps, min": 10.0, max": 20.0, step": 0.25} + - overlap: FLOAT, {"default": node.overlap, min": 0.0, max": 200.0, step": 0.25} +Outputs: + - audios (AUDIO) + - wav_16k_path (STRING) + - output_audio (AUDIO) +-------------------------------------------------- +Node: FL_GradGenerator: + @classmethod + def INPUT_TYPES +Category: 🏵️Fill Nodes/experiments +Inputs: + Required: + - width: INT, {"default": 512, min": 64, max": 4096} + - height: INT, {"default": 512, min": 64, max": 4096} + - color_mode: ["RGB, HSV"] + - interpolation: ["Linear, Ease In, Ease Out, Ease In-Out"] + - gradient_colors: STRING, {"default": "[]"} + Optional: +Outputs: + - IMAGE +-------------------------------------------------- +Node: FL_SaveWebPImage +Category: 🏵️Fill Nodes/Image +Inputs: + Required: + - {"images: IMAGE + - filename_prefix: STRING, {"default": "ComfyUI"} + - quality: INT, {"default": 80, min": 1, max": 100, step": 1} + Optional: +Outputs: + - IMAGE + - STRING +-------------------------------------------------- +Node: EventHandler +Category: utils +Inputs: + Required: + - javascript: STRING, {"default": , multiline": True} + Optional: +Outputs: +-------------------------------------------------- +Node: DownloadAndLoadGIMMVFIModel: + @classmethod + def INPUT_TYPES +Category: GIMM-VFI +Inputs: + Required: + Optional: + - precision: ["fp32, bf16, fp16"], {"default": "fp32"} + - torch_compile: BOOLEAN, {"default": False, tooltip": "Compile part of the model with torch.compile, requires Triton"} +Outputs: + - gimmvfi_model (GIMMVIF_MODEL) +-------------------------------------------------- +Node: GIMMVFI_interpolate: + @classmethod + def INPUT_TYPES +Category: PyramidFlowWrapper +Inputs: + Required: + - gimmvfi_model: GIMMVIF_MODEL + - images: IMAGE, {"tooltip": "The images to interpolate between"} + - ds_factor: FLOAT, {"default": 1.0, min": 0.01, max": 1.0, step": 0.01} + - interpolation_factor: INT, {"default": 8, min": 1, max": 100, step": 1} + - seed: INT, {"default": 0, min": 0, max": 0xffffffffffffffff} + Optional: + - output_flows: BOOLEAN, {"default": False, tooltip": "Output the flow tensors"} +Outputs: + - images (IMAGE) + - flow_tensors (IMAGE) +-------------------------------------------------- +Node: Film: + + def __init__ +Category: 😺dzNodes/LayerFilter +Inputs: + Required: + - image: IMAGE + - center_x: FLOAT, {"default": 0.5, min": 0, max": 1, step": 0.01} + - center_y: FLOAT, {"default": 0.5, min": 0, max": 1, step": 0.01} + - saturation: FLOAT, {"default": 1, min": 0.01, max": 3, step": 0.01} + - vignette_intensity: FLOAT, {"default": 0.5, min": 0, max": 1, step": 0.01} + - grain_power: FLOAT, {"default": 0.15, min": 0, max": 1, step": 0.01} + - grain_scale: FLOAT, {"default": 1.0, min": 0.1, max": 10, step": 0.1} + - grain_sat: FLOAT, {"default": 0.5, min": 0, max": 1, step": 0.01} + - grain_shadows: FLOAT, {"default": 0.6, min": 0, max": 1, step": 0.01} + - grain_highs: FLOAT, {"default": 0.2, min": 0, max": 1, step": 0.01} + - blur_strength: INT, {"default": 90, min": 0, max": 256, step": 1} + - blur_focus_spread: FLOAT, {"default": 2.2, min": 0.1, max": 8, step": 0.1} + - focal_depth: FLOAT, {"default": 0.9, min": 0.0, max": 1, step": 0.01} + Optional: + - depth_map: IMAGE +Outputs: + - image (IMAGE) +-------------------------------------------------- +Node: ExtendCanvasV2: + + def __init__ +Category: 😺dzNodes/LayerUtility +Inputs: + Required: + - image: IMAGE + - invert_mask: BOOLEAN, {"default": True} + - top: INT, {"default": 0, min": -99999, max": 99999, step": 1} + - bottom: INT, {"default": 0, min": -99999, max": 99999, step": 1} + - left: INT, {"default": 0, min": -99999, max": 99999, step": 1} + - right: INT, {"default": 0, min": -99999, max": 99999, step": 1} + - color: STRING, {"default": "#000000"} + Optional: + - mask: MASK +Outputs: + - image (IMAGE) + - mask (MASK) +-------------------------------------------------- +Node: DropShadowV3: + + def __init__ +Category: 😺dzNodes/LayerStyle +Inputs: + Required: + - layer_image: IMAGE + - invert_mask: BOOLEAN, {"default": True} + - blend_mode: chop_mode_v2 + - opacity: INT, {"default": 50, min": 0, max": 100, step": 1} + - distance_x: INT, {"default": 25, min": -9999, max": 9999, step": 1} + - distance_y: INT, {"default": 25, min": -9999, max": 9999, step": 1} + - grow: INT, {"default": 6, min": -9999, max": 9999, step": 1} + - blur: INT, {"default": 18, min": 0, max": 1000, step": 1} + - shadow_color: STRING, {"default": "#000000"} + Optional: + - background_image: IMAGE + - layer_mask: MASK +Outputs: + - image (IMAGE) +-------------------------------------------------- +Node: ImageMaskScaleAs: + + def __init__ +Category: 😺dzNodes/LayerUtility +Inputs: + Required: + - scale_as: any, {} + - fit: fit_mode + - method: method_mode + Optional: + - image: IMAGE + - mask: MASK +Outputs: + - image (IMAGE) + - mask (MASK) + - original_size (BOX) + - widht (INT) + - height (INT) +-------------------------------------------------- +Node: LS_ImageMaskScaleAsV2: + + def __init__ +Category: 😺dzNodes/LayerUtility +Inputs: + Required: + - scale_as: any, {} + - fit: fit_mode + - method: method_mode + - background_color: STRING, {"default": "#FFFFFF"} + Optional: + - image: IMAGE + - mask: MASK +Outputs: + - image (IMAGE) + - mask (MASK) + - original_size (BOX) + - widht (INT) + - height (INT) +-------------------------------------------------- +Node: ColorAdapter: + + def __init__ +Category: 😺dzNodes/LayerColor +Inputs: + Required: + - image: IMAGE + - color_ref_image: IMAGE + - opacity: INT, {"default": 75, min": 0, max": 100, step": 1} + Optional: +Outputs: + - image (IMAGE) +-------------------------------------------------- +Node: ColorCorrectShadowAndHighlight: + + def __init__ +Category: 😺dzNodes/LayerColor +Inputs: + Required: + - image: IMAGE + - shadow_brightness: FLOAT, {"default": 1, min": 0.0, max": 3, step": 0.01} + - shadow_saturation: FLOAT, {"default": 1, min": 0.0, max": 3, step": 0.01} + - shadow_hue: INT, {"default": 0, min": -255, max": 255, step": 1} + - shadow_level_offset: INT, {"default": 0, min": -99, max": 99, step": 1} + - shadow_range: FLOAT, {"default": 0.25, min": 0.01, max": 0.99, step": 0.01} + - highlight_brightness: FLOAT, {"default": 1, min": 0.0, max": 3, step": 0.01} + - highlight_saturation: FLOAT, {"default": 1, min": 0.0, max": 3, step": 0.01} + - highlight_hue: INT, {"default": 0, min": -255, max": 255, step": 1} + - highlight_level_offset: INT, {"default": 0, min": -99, max": 99, step": 1} + - highlight_range: FLOAT, {"default": 0.25, min": 0.01, max": 0.99, step": 0.01} + Optional: + - mask: MASK +Outputs: + - image (IMAGE) +-------------------------------------------------- +Node: LS_ColorCorrectShadow_And_Highlight_V2: + + def __init__ +Category: 😺dzNodes/LayerColor +Inputs: + Required: + - image: IMAGE + - shadow_brightness: FLOAT, {"default": 1, min": 0.0, max": 3, step": 0.01} + - shadow_saturation: FLOAT, {"default": 1, min": 0.0, max": 3, step": 0.01} + - shadow_hue: INT, {"default": 0, min": -255, max": 255, step": 1} + - shadow_level_offset: INT, {"default": 0, min": -99, max": 99, step": 1} + - shadow_range: FLOAT, {"default": 0.25, min": 0.01, max": 0.99, step": 0.01} + - highlight_brightness: FLOAT, {"default": 1, min": 0.0, max": 3, step": 0.01} + - highlight_saturation: FLOAT, {"default": 1, min": 0.0, max": 3, step": 0.01} + - highlight_hue: INT, {"default": 0, min": -255, max": 255, step": 1} + - highlight_level_offset: INT, {"default": 0, min": -99, max": 99, step": 1} + - highlight_range: FLOAT, {"default": 0.25, min": 0.01, max": 0.99, step": 0.01} + Optional: + - mask: MASK +Outputs: + - image (IMAGE) +-------------------------------------------------- +Node: ColorImageV2: + + def __init__ +Category: 😺dzNodes/LayerUtility +Inputs: + Required: + - size: size_list + - custom_width: INT, {"default": 512, min": 4, max": 99999, step": 1} + - custom_height: INT, {"default": 512, min": 4, max": 99999, step": 1} + - color: STRING, {"default": "#000000"} + Optional: + - size_as: any, {} +Outputs: + - image (IMAGE) +-------------------------------------------------- +Node: GradientMap: + def __init__ +Category: 😺dzNodes/LayerStyle +Inputs: + Required: + - image: IMAGE + - start_color: STRING, {"default": "#015A52"} + - mid_color: STRING, {"default": "#02AF9F"} + - end_color: STRING, {"default": "#7FFFEC"} + - mid_point: FLOAT, {"default": 0.6, min": 0.0, max": 1.0, step": 0.01} + - opacity: INT, {"default": 100, min": 0, max": 100, step": 1} + Optional: + - layer_mask: MASK +Outputs: + - image (IMAGE) + - gradient (IMAGE) +-------------------------------------------------- +Node: ImageOpacity: + + def __init__ +Category: 😺dzNodes/LayerUtility +Inputs: + Required: + - image: IMAGE + - opacity: INT, {"default": 100, min": 0, max": 100, step": 1} + - invert_mask: BOOLEAN, {"default": True} + Optional: + - mask: MASK +Outputs: + - image (IMAGE) + - mask (MASK) +-------------------------------------------------- +Node: MaskGrain: + + def __init__ +Category: 😺dzNodes/LayerMask +Inputs: + Required: + - mask: MASK + - grain: INT, {"default": 6, min": 0, max": 127, step": 1} + - invert_mask: BOOLEAN, {"default": False} + Optional: +Outputs: + - mask (MASK) +-------------------------------------------------- +Node: ImageChannelSplit: + + def __init__ +Category: 😺dzNodes/LayerUtility +Inputs: + Required: + - image: IMAGE + - mode: channel_mode + Optional: +Outputs: + - channel_1 (IMAGE) + - channel_2 (IMAGE) + - channel_3 (IMAGE) + - channel_4 (IMAGE) +-------------------------------------------------- +Node: LayerImageTransform: + + def __init__ +Category: 😺dzNodes/LayerUtility +Inputs: + Required: + - image: IMAGE + - x: INT, {"default": 0, min": -99999, max": 99999, step": 1} + - y: INT, {"default": 0, min": -99999, max": 99999, step": 1} + - mirror: mirror_mode + - scale: FLOAT, {"default": 1, min": 0.01, max": 100, step": 0.01} + - aspect_ratio: FLOAT, {"default": 1, min": 0.01, max": 100, step": 0.01} + - rotate: FLOAT, {"default": 0, min": -999999, max": 999999, step": 0.01} + - transform_method: method_mode + - anti_aliasing: INT, {"default": 2, min": 0, max": 16, step": 1} + Optional: +Outputs: + - image (IMAGE) +-------------------------------------------------- +Node: ImageShift: + + def __init__ +Category: 😺dzNodes/LayerUtility +Inputs: + Required: + - image: IMAGE + - shift_x: INT, {"default": 256, min": -9999, max": 9999, step": 1} + - shift_y: INT, {"default": 256, min": -9999, max": 9999, step": 1} + - cyclic: BOOLEAN, {"default": True} + - background_color: STRING, {"default": "#000000"} + - border_mask_width: INT, {"default": 20, min": 0, max": 999, step": 1} + - border_mask_blur: INT, {"default": 12, min": 0, max": 999, step": 1} + Optional: + - mask: MASK +Outputs: + - image (IMAGE) + - mask (MASK) + - border_mask (MASK) +-------------------------------------------------- +Node: StrokeV2: + + def __init__ +Category: 😺dzNodes/LayerStyle +Inputs: + Required: + - background_image: IMAGE + - layer_image: IMAGE + - invert_mask: BOOLEAN, {"default": True} + - blend_mode: chop_mode_v2 + - opacity: INT, {"default": 100, min": 0, max": 100, step": 1} + - stroke_grow: INT, {"default": 0, min": -999, max": 999, step": 1} + - stroke_width: INT, {"default": 8, min": 0, max": 999, step": 1} + - blur: INT, {"default": 0, min": 0, max": 100, step": 1} + - stroke_color: STRING, {"default": "#FF0000"} + Optional: + - layer_mask: MASK +Outputs: + - image (IMAGE) +-------------------------------------------------- +Node: GaussianBlur: + + def __init__ +Category: 😺dzNodes/LayerFilter +Inputs: + Required: + - image: IMAGE + - blur: INT, {"default": 20, min": 1, max": 999, step": 1} + Optional: +Outputs: + - image (IMAGE) +-------------------------------------------------- +Node: LS_GaussianBlurV2: + + def __init__ +Category: 😺dzNodes/LayerFilter +Inputs: + Required: + - image: IMAGE + - blur: FLOAT, {"default": 20, min": 0, max": 1000, step": 0.05} + Optional: +Outputs: + - image (IMAGE) +-------------------------------------------------- +Node: SoftLight: + + def __init__ +Category: 😺dzNodes/LayerFilter +Inputs: + Required: + - image: IMAGE + - soft: FLOAT, {"default": 1, min": 0.2, max": 10, step": 0.01} + - threshold: INT, {"default": -10, min": -255, max": 255, step": 1} + - opacity: INT, {"default": 100, min": 0, max": 100, step": 1} + Optional: +Outputs: + - image (IMAGE) +-------------------------------------------------- +Node: ColorCorrectExposure: + + def __init__ +Category: 😺dzNodes/LayerColor +Inputs: + Required: + - image: IMAGE + - exposure: INT, {"default": 20, min": -100, max": 100, step": 1} + Optional: +Outputs: + - image (IMAGE) +-------------------------------------------------- +Node: ColorCorrectLUTapply: + + def __init__ +Category: 😺dzNodes/LayerColor +Inputs: + Required: + - image: IMAGE + - LUT: LUT_LIST + - color_space: color_space_list + - strength: INT, {"default": 100, min": 0, max": 100, step": 1} + Optional: +Outputs: + - image (IMAGE) +-------------------------------------------------- +Node: ColorCorrectYUV: + + def __init__ +Category: 😺dzNodes/LayerColor +Inputs: + Required: + - image: IMAGE + - Y: INT, {"default": 0, min": -255, max": 255, step": 1} + - U: INT, {"default": 0, min": -255, max": 255, step": 1} + - V: INT, {"default": 0, min": -255, max": 255, step": 1} + Optional: +Outputs: + - image (IMAGE) +-------------------------------------------------- +Node: ImageHub: + + def __init__ +Category: 😺dzNodes/LayerUtility +Inputs: + Required: + - output: INT, {"default": 1, min": 1, max": 9, step": 1} + - random_output: BOOLEAN, {"default": False} + Optional: + - input1_image: IMAGE + - input1_mask: MASK + - input2_image: IMAGE + - input2_mask: MASK + - input3_image: IMAGE + - input3_mask: MASK + - input4_image: IMAGE + - input4_mask: MASK + - input5_image: IMAGE + - input5_mask: MASK + - input6_image: IMAGE + - input6_mask: MASK + - input7_image: IMAGE + - input7_mask: MASK + - input8_image: IMAGE + - input8_mask: MASK + - input9_image: IMAGE + - input9_mask: MASK +Outputs: + - image (IMAGE) + - mask (MASK) +-------------------------------------------------- +Node: DropShadowV2: + + def __init__ +Category: 😺dzNodes/LayerStyle +Inputs: + Required: + - background_image: IMAGE + - layer_image: IMAGE + - invert_mask: BOOLEAN, {"default": True} + - blend_mode: chop_mode_v2 + - opacity: INT, {"default": 50, min": 0, max": 100, step": 1} + - distance_x: INT, {"default": 25, min": -9999, max": 9999, step": 1} + - distance_y: INT, {"default": 25, min": -9999, max": 9999, step": 1} + - grow: INT, {"default": 6, min": -9999, max": 9999, step": 1} + - blur: INT, {"default": 18, min": 0, max": 100, step": 1} + - shadow_color: STRING, {"default": "#000000"} + Optional: + - layer_mask: MASK +Outputs: + - image (IMAGE) +-------------------------------------------------- +Node: ColorOverlayV2: + + def __init__ +Category: 😺dzNodes/LayerStyle +Inputs: + Required: + - background_image: IMAGE + - layer_image: IMAGE + - invert_mask: BOOLEAN, {"default": True} + - blend_mode: chop_mode_v2 + - opacity: INT, {"default": 100, min": 0, max": 100, step": 1} + - color: STRING, {"default": "#FFBF30"} + Optional: + - layer_mask: MASK +Outputs: + - image (IMAGE) +-------------------------------------------------- +Node: MaskStroke: + + def __init__ +Category: 😺dzNodes/LayerMask +Inputs: + Required: + - mask: MASK + - invert_mask: BOOLEAN, {"default": True} + - stroke_grow: INT, {"default": 0, min": -999, max": 999, step": 1} + - stroke_width: INT, {"default": 20, min": 0, max": 999, step": 1} + - blur: INT, {"default": 6, min": 0, max": 100, step": 1} + Optional: +Outputs: + - mask (MASK) +-------------------------------------------------- +Node: AddGrain: + + def __init__ +Category: 😺dzNodes/LayerFilter +Inputs: + Required: + - image: IMAGE + - grain_power: FLOAT, {"default": 0.5, min": 0, max": 1, step": 0.01} + - grain_scale: FLOAT, {"default": 1, min": 0.1, max": 10, step": 0.1} + - grain_sat: FLOAT, {"default": 1, min": 0, max": 1, step": 0.01} + Optional: +Outputs: + - image (IMAGE) +-------------------------------------------------- +Node: AutoAdjustV2: + + def __init__ +Category: 😺dzNodes/LayerColor +Inputs: + Required: + - image: IMAGE + - strength: INT, {"default": 100, min": 0, max": 100, step": 1} + - brightness: INT, {"default": 0, min": -100, max": 100, step": 1} + - contrast: INT, {"default": 0, min": -100, max": 100, step": 1} + - saturation: INT, {"default": 0, min": -100, max": 100, step": 1} + - red: INT, {"default": 0, min": -100, max": 100, step": 1} + - green: INT, {"default": 0, min": -100, max": 100, step": 1} + - blue: INT, {"default": 0, min": -100, max": 100, step": 1} + - mode: mode_list + Optional: + - mask: MASK +Outputs: + - image (IMAGE) +-------------------------------------------------- +Node: RestoreCropBox: + + def __init__ +Category: 😺dzNodes/LayerUtility +Inputs: + Required: + - background_image: IMAGE + - croped_image: IMAGE + - invert_mask: BOOLEAN, {"default": False} + - crop_box: BOX + Optional: + - croped_mask: MASK +Outputs: + - image (IMAGE) + - mask (MASK) +-------------------------------------------------- +Node: ColorValuetoRGBValue: + + def __init__ +Category: 😺dzNodes/LayerUtility/Data +Inputs: + Required: + - color_value: any, {} + Optional: +Outputs: + - R (INT) + - G (INT) + - B (INT) +-------------------------------------------------- +Node: ICMask_Data: + def __init__ +Category: Unknown +Inputs: + Required: + Optional: +Outputs: +-------------------------------------------------- +Node: LS_ICMask: + def __init__ +Category: 😺dzNodes/LayerUtility +Inputs: + Required: + - first_image: IMAGE + - default: #FFFFFF + Optional: + - first_mask: MASK + - second_image: IMAGE + - second_mask: MASK +Outputs: + - image (IMAGE) + - mask (MASK) + - icmask_data (ICMASK_DATA) +-------------------------------------------------- +Node: LS_ICMask_CropBack: + + def __init__ +Category: 😺dzNodes/LayerUtility +Inputs: + Required: + - { "image: IMAGE + - icmask_data: ICMASK_DATA + Optional: +Outputs: + - IMAGE +-------------------------------------------------- +Node: PrintInfo: + + @classmethod + def INPUT_TYPES +Category: 😺dzNodes/LayerUtility/Data +Inputs: + Required: + - anything: any, {} + Optional: +Outputs: + - text (STRING) +-------------------------------------------------- +Node: ImageScaleByAspectRatioV2: + + def __init__ +Category: 😺dzNodes/LayerUtility +Inputs: + Required: + - aspect_ratio: ratio_list + - proportional_width: INT, {"default": 1, min": 1, max": 1e8, step": 1} + - proportional_height: INT, {"default": 1, min": 1, max": 1e8, step": 1} + - fit: fit_mode + - method: method_mode + - round_to_multiple: multiple_list + - scale_to_side: scale_to_list + - scale_to_length: INT, {"default": 1024, min": 4, max": 1e8, step": 1} + - background_color: STRING, {"default": "#000000"} + Optional: + - image: IMAGE + - mask: MASK +Outputs: + - image (IMAGE) + - mask (MASK) + - original_size (BOX) + - width (INT) + - height (INT) +-------------------------------------------------- +Node: MaskMotionBlur: + + def __init__ +Category: 😺dzNodes/LayerMask +Inputs: + Required: + - mask: MASK + - invert_mask: BOOLEAN, {"default": True} + - blur: INT, {"default": 20, min": 1, max": 9999, step": 1} + - angle: FLOAT, {"default": 0, min": -360, max": 360, step": 0.1} + Optional: +Outputs: + - mask (MASK) +-------------------------------------------------- +Node: CheckMask: + + def __init__ +Category: 😺dzNodes/LayerUtility +Inputs: + Required: + - mask: MASK + - white_point: INT, {"default": 1, min": 1, max": 254, step": 1} + - area_percent: INT, {"default": 1, min": 1, max": 99, step": 1} + Optional: +Outputs: + - bool (BOOLEAN) +-------------------------------------------------- +Node: FilmV2: + + def __init__ +Category: 😺dzNodes/LayerFilter +Inputs: + Required: + - image: IMAGE + - center_x: FLOAT, {"default": 0.5, min": 0, max": 1, step": 0.01} + - center_y: FLOAT, {"default": 0.5, min": 0, max": 1, step": 0.01} + - saturation: FLOAT, {"default": 1, min": 0.01, max": 3, step": 0.01} + - vignette_intensity: FLOAT, {"default": 0.5, min": 0, max": 1, step": 0.01} + - grain_method: grain_method_list + - grain_power: FLOAT, {"default": 0.15, min": 0, max": 1, step": 0.01} + - grain_scale: FLOAT, {"default": 1, min": 0.1, max": 10, step": 0.1} + - grain_sat: FLOAT, {"default": 0.5, min": 0, max": 1, step": 0.01} + - filmgrainer_shadows: FLOAT, {"default": 0.6, min": 0, max": 1, step": 0.01} + - filmgrainer_highs: FLOAT, {"default": 0.2, min": 0, max": 1, step": 0.01} + - blur_strength: INT, {"default": 90, min": 0, max": 256, step": 1} + - blur_focus_spread: FLOAT, {"default": 2.2, min": 0.1, max": 8, step": 0.1} + - focal_depth: FLOAT, {"default": 0.9, min": 0.0, max": 1, step": 0.01} + Optional: + - depth_map: IMAGE +Outputs: + - image (IMAGE) +-------------------------------------------------- +Node: ColorBalance: + + def __init__ +Category: 😺dzNodes/LayerColor +Inputs: + Required: + - image: IMAGE + - cyan_red: FLOAT, {"default": 0, min": -1.0, max": 1.0, step": 0.001} + - magenta_green: FLOAT, {"default": 0, min": -1.0, max": 1.0, step": 0.001} + - yellow_blue: FLOAT, {"default": 0, min": -1.0, max": 1.0, step": 0.001} + Optional: +Outputs: + - image (IMAGE) +-------------------------------------------------- +Node: ColorOverlay: + + def __init__ +Category: 😺dzNodes/LayerStyle +Inputs: + Required: + - background_image: IMAGE + - layer_image: IMAGE + - invert_mask: BOOLEAN, {"default": True} + - blend_mode: chop_mode + - opacity: INT, {"default": 100, min": 0, max": 100, step": 1} + - color: STRING, {"default": "#FFBF30"} + Optional: + - layer_mask: MASK +Outputs: + - image (IMAGE) +-------------------------------------------------- +Node: PixelSpread: + + def __init__ +Category: 😺dzNodes/LayerMask +Inputs: + Required: + - image: IMAGE + - invert_mask: BOOLEAN, {"default": False} + - mask_grow: INT, {"default": 0, min": -999, max": 999, step": 1} + Optional: + - mask: MASK +Outputs: + - image (IMAGE) +-------------------------------------------------- +Node: GradientOverlayV2: + + def __init__ +Category: 😺dzNodes/LayerStyle +Inputs: + Required: + - background_image: IMAGE + - layer_image: IMAGE + - invert_mask: BOOLEAN, {"default": True} + - blend_mode: chop_mode_v2 + - opacity: INT, {"default": 100, min": 0, max": 100, step": 1} + - start_color: STRING, {"default": "#FFBF30"} + - start_alpha: INT, {"default": 255, min": 0, max": 255, step": 1} + - end_color: STRING, {"default": "#FE0000"} + - end_alpha: INT, {"default": 255, min": 0, max": 255, step": 1} + - angle: INT, {"default": 0, min": -180, max": 180, step": 1} + Optional: + - layer_mask: MASK +Outputs: + - image (IMAGE) +-------------------------------------------------- +Node: SegformerPipeline: + def __init__ +Category: Unknown +Inputs: + Required: + Optional: +Outputs: +-------------------------------------------------- +Node: Segformer_B2_Clothes: + + def __init__ +Category: 😺dzNodes/LayerMask +Inputs: + Required: + - image: IMAGE + - face: BOOLEAN, {"default": False} + - hair: BOOLEAN, {"default": False} + - hat: BOOLEAN, {"default": False} + - sunglass: BOOLEAN, {"default": False} + - left_arm: BOOLEAN, {"default": False} + - right_arm: BOOLEAN, {"default": False} + - left_leg: BOOLEAN, {"default": False} + - right_leg: BOOLEAN, {"default": False} + - upper_clothes: BOOLEAN, {"default": False} + - skirt: BOOLEAN, {"default": False} + - pants: BOOLEAN, {"default": False} + - dress: BOOLEAN, {"default": False} + - belt: BOOLEAN, {"default": False} + - shoe: BOOLEAN, {"default": False} + - bag: BOOLEAN, {"default": False} + - scarf: BOOLEAN, {"default": False} + - detail_method: method_list + - detail_erode: INT, {"default": 12, min": 1, max": 255, step": 1} + - detail_dilate: INT, {"default": 6, min": 1, max": 255, step": 1} + - FLOAT", {"default: 0.99 + - process_detail: BOOLEAN, {"default": True} + - device: device_list + - max_megapixels: FLOAT, {"default": 2.0, min": 1, max": 999, step": 0.1} + Optional: +Outputs: + - image (IMAGE) + - mask (MASK) +-------------------------------------------------- +Node: SegformerClothesPipelineLoader: + + def __init__ +Category: 😺dzNodes/LayerMask +Inputs: + Required: + - { "model: model_list + - face: BOOLEAN, {"default": False, label_on": "enabled(脸 + - hair: BOOLEAN, {"default": False, label_on": "enabled(头发 + - hat: BOOLEAN, {"default": False, label_on": "enabled(帽子 + - sunglass: BOOLEAN, {"default": False, label_on": "enabled(墨镜 + - left_arm: BOOLEAN, {"default": False, label_on": "enabled(左臂 + - right_arm: BOOLEAN, {"default": False, label_on": "enabled(右臂 + - left_leg: BOOLEAN, {"default": False, label_on": "enabled(左腿 + - right_leg: BOOLEAN, {"default": False, label_on": "enabled(右腿 + - left_shoe: BOOLEAN, {"default": False, label_on": "enabled(左鞋 + - right_shoe: BOOLEAN, {"default": False, label_on": "enabled(右鞋 + - upper_clothes: BOOLEAN, {"default": False, label_on": "enabled(上衣 + - skirt: BOOLEAN, {"default": False, label_on": "enabled(短裙 + - pants: BOOLEAN, {"default": False, label_on": "enabled(裤子 + - dress: BOOLEAN, {"default": False, label_on": "enabled(连衣裙 + - belt: BOOLEAN, {"default": False, label_on": "enabled(腰带 + - bag: BOOLEAN, {"default": False, label_on": "enabled(背包 + - scarf: BOOLEAN, {"default": False, label_on": "enabled(围巾 + Optional: +Outputs: + - segformer_pipeline (SegPipeline) +-------------------------------------------------- +Node: SegformerFashionPipelineLoader: + + def __init__ +Category: 😺dzNodes/LayerMask +Inputs: + Required: + - { "model: model_list + - shirt: BOOLEAN, {"default": False, label_on": "enabled(衬衫、罩衫 + - top: BOOLEAN, {"default": False, label_on": "enabled(上衣、t恤 + - sweater: BOOLEAN, {"default": False, label_on": "enabled(毛衣 + - cardigan: BOOLEAN, {"default": False, label_on": "enabled(开襟毛衫 + - jacket: BOOLEAN, {"default": False, label_on": "enabled(夹克 + - vest: BOOLEAN, {"default": False, label_on": "enabled(背心 + - pants: BOOLEAN, {"default": False, label_on": "enabled(裤子 + - shorts: BOOLEAN, {"default": False, label_on": "enabled(短裤 + - skirt: BOOLEAN, {"default": False, label_on": "enabled(裙子 + - coat: BOOLEAN, {"default": False, label_on": "enabled(外套 + - dress: BOOLEAN, {"default": False, label_on": "enabled(连衣裙 + - jumpsuit: BOOLEAN, {"default": False, label_on": "enabled(连身裤 + - cape: BOOLEAN, {"default": False, label_on": "enabled(斗篷 + - glasses: BOOLEAN, {"default": False, label_on": "enabled(眼镜 + - hat: BOOLEAN, {"default": False, label_on": "enabled(帽子 + - hairaccessory: BOOLEAN, {"default": False, label_on": "enabled(头带 + - tie: BOOLEAN, {"default": False, label_on": "enabled(领带 + - glove: BOOLEAN, {"default": False, label_on": "enabled(手套 + - watch: BOOLEAN, {"default": False, label_on": "enabled(手表 + - belt: BOOLEAN, {"default": False, label_on": "enabled(皮带 + - legwarmer: BOOLEAN, {"default": False, label_on": "enabled(腿套 + - tights: BOOLEAN, {"default": False, label_on": "enabled(裤袜 + - sock: BOOLEAN, {"default": False, label_on": "enabled(袜子 + - shoe: BOOLEAN, {"default": False, label_on": "enabled(鞋子 + - bagwallet: BOOLEAN, {"default": False, label_on": "enabled(手包 + - scarf: BOOLEAN, {"default": False, label_on": "enabled(围巾 + - umbrella: BOOLEAN, {"default": False, label_on": "enabled(雨伞 + - hood: BOOLEAN, {"default": False, label_on": "enabled(兜帽 + - collar: BOOLEAN, {"default": False, label_on": "enabled(衣领 + - lapel: BOOLEAN, {"default": False, label_on": "enabled(翻领 + - epaulette: BOOLEAN, {"default": False, label_on": "enabled(肩章 + - sleeve: BOOLEAN, {"default": False, label_on": "enabled(袖子 + - pocket: BOOLEAN, {"default": False, label_on": "enabled(口袋 + - neckline: BOOLEAN, {"default": False, label_on": "enabled(领口 + - buckle: BOOLEAN, {"default": False, label_on": "enabled(带扣 + - zipper: BOOLEAN, {"default": False, label_on": "enabled(拉链 + - applique: BOOLEAN, {"default": False, label_on": "enabled(贴花 + - bead: BOOLEAN, {"default": False, label_on": "enabled(珠子 + - bow: BOOLEAN, {"default": False, label_on": "enabled(蝴蝶结 + - flower: BOOLEAN, {"default": False, label_on": "enabled(花 + - fringe: BOOLEAN, {"default": False, label_on": "enabled(刘海 + - ribbon: BOOLEAN, {"default": False, label_on": "enabled(丝带 + - rivet: BOOLEAN, {"default": False, label_on": "enabled(铆钉 + - ruffle: BOOLEAN, {"default": False, label_on": "enabled(褶饰 + - sequin: BOOLEAN, {"default": False, label_on": "enabled(亮片 + - tassel: BOOLEAN, {"default": False, label_on": "enabled(流苏 + Optional: +Outputs: + - segformer_pipeline (SegPipeline) +-------------------------------------------------- +Node: SegformerUltraV2: + + def __init__ +Category: 😺dzNodes/LayerMask +Inputs: + Required: + - image: IMAGE + - segformer_pipeline: SegPipeline + - detail_method: method_list + - detail_erode: INT, {"default": 8, min": 1, max": 255, step": 1} + - detail_dilate: INT, {"default": 6, min": 1, max": 255, step": 1} + - black_point: FLOAT, {"default": 0.01, min": 0.01, max": 0.98, step": 0.01, display": "slider"} + - white_point: FLOAT, {"default": 0.99, min": 0.02, max": 0.99, step": 0.01, display": "slider"} + - process_detail: BOOLEAN, {"default": True} + - device: device_list + - max_megapixels: FLOAT, {"default": 2.0, min": 1, max": 999, step": 0.1} + Optional: +Outputs: + - image (IMAGE) + - mask (MASK) +-------------------------------------------------- +Node: LS_HDREffects: + @classmethod + def INPUT_TYPES +Category: 😺dzNodes/LayerFilter +Inputs: + Required: + - {'image: IMAGE, {'default': None} + - hdr_intensity: FLOAT, {'default': 0.5, min': 0.0, max': 5.0, step': 0.01} + - shadow_intensity: FLOAT, {'default': 0.25, min': 0.0, max': 1.0, step': 0.01} + - highlight_intensity: FLOAT, {'default': 0.75, min': 0.0, max': 1.0, step': 0.01} + - gamma_intensity: FLOAT, {'default': 0.25, min': 0.0, max': 1.0, step': 0.01} + - contrast: FLOAT, {'default': 0.1, min': 0.0, max': 1.0, step': 0.01} + - enhance_color: FLOAT, {'default': 0.25, min': 0.0, max': 1.0, step': 0.01} + Optional: +Outputs: + - image (IMAGE) +-------------------------------------------------- +Node: TextImage: + + def __init__ +Category: 😺dzNodes/LayerUtility +Inputs: + Required: + - text: STRING, {"multiline": True, default": "Text"} + - font_file: FONT_LIST + - spacing: INT, {"default": 0, min": -9999, max": 9999, step": 1} + - leading: INT, {"default": 0, min": -9999, max": 9999, step": 1} + - horizontal_border: FLOAT, {"default": 5, min": -100, max": 100, step": 0.1} + - vertical_border: FLOAT, {"default": 5, min": -100, max": 100, step": 0.1} + - scale: FLOAT, {"default": 80, min": 0.1, max": 999, step": 0.01} + - variation_range: INT, {"default": 0, min": 0, max": 100, step": 1} + - variation_seed: INT, {"default": random_seed, min": 0, max": 999999999999, step": 1} + - layout: layout_list + - width: INT, {"default": 512, min": 4, max": 999999, step": 1} + - height: INT, {"default": 512, min": 4, max": 999999, step": 1} + - text_color: STRING, {"default": "#FFA000"} + - background_color: STRING, {"default": "#FFFFFF"} + Optional: + - size_as: any, {} +Outputs: + - image (IMAGE) + - mask (MASK) +-------------------------------------------------- +Node: TextJoin: + + def __init__ +Category: 😺dzNodes/LayerUtility/Data +Inputs: + Required: + - text_1: STRING, {"default": , multiline": False, forceInput":False} + Optional: + - text_2: STRING, {"default": , multiline": False, forceInput":False} + - text_3: STRING, {"default": , multiline": False, forceInput":False} + - text_4: STRING, {"default": , multiline": False, forceInput":False} +Outputs: + - text (STRING) +-------------------------------------------------- +Node: LS_TextJoinV2: + + def __init__ +Category: 😺dzNodes/LayerUtility/Data +Inputs: + Required: + - text_1: STRING, {"default": , multiline": False, forceInput":True} + - delimiter: STRING, {"default": , , multiline": False} + Optional: + - text_2: STRING, {"default": , multiline": False, forceInput":True} + - text_3: STRING, {"default": , multiline": False, forceInput":True} + - text_4: STRING, {"default": , multiline": False, forceInput":True} +Outputs: + - text (STRING) +-------------------------------------------------- +Node: ImageBlendAdvance: + + def __init__ +Category: 😺dzNodes/LayerUtility +Inputs: + Required: + - background_image: IMAGE + - layer_image: IMAGE + - invert_mask: BOOLEAN, {"default": True} + - blend_mode: chop_mode + - opacity: INT, {"default": 100, min": 0, max": 100, step": 1} + - x_percent: FLOAT, {"default": 50, min": -999, max": 999, step": 0.01} + - y_percent: FLOAT, {"default": 50, min": -999, max": 999, step": 0.01} + - mirror: mirror_mode + - scale: FLOAT, {"default": 1, min": 0.01, max": 100, step": 0.01} + - aspect_ratio: FLOAT, {"default": 1, min": 0.01, max": 100, step": 0.01} + - rotate: FLOAT, {"default": 0, min": -999999, max": 999999, step": 0.01} + - transform_method: method_mode + - anti_aliasing: INT, {"default": 0, min": 0, max": 16, step": 1} + Optional: + - layer_mask: MASK +Outputs: + - image (IMAGE) + - mask (MASK) +-------------------------------------------------- +Node: MaskEdgeUltraDetailV2: + def __init__ +Category: 😺dzNodes/LayerMask +Inputs: + Required: + - image: IMAGE + - mask: MASK + - method: method_list + - mask_grow: INT, {"default": 0, min": 0, max": 256, step": 1} + - fix_gap: INT, {"default": 0, min": 0, max": 32, step": 1} + - fix_threshold: FLOAT, {"default": 0.75, min": 0.01, max": 0.99, step": 0.01} + - edge_erode: INT, {"default": 6, min": 1, max": 255, step": 1} + - edte_dilate: INT, {"default": 6, min": 1, max": 255, step": 1} + - black_point: FLOAT, {"default": 0.01, min": 0.01, max": 0.98, step": 0.01, display": "slider"} + - white_point: FLOAT, {"default": 0.99, min": 0.02, max": 0.99, step": 0.01, display": "slider"} + - device: device_list + - max_megapixels: FLOAT, {"default": 2.0, min": 1, max": 999, step": 0.1} + Optional: +Outputs: + - image (IMAGE) + - mask (MASK) +-------------------------------------------------- +Node: WaterColor: + + def __init__ +Category: 😺dzNodes/LayerFilter +Inputs: + Required: + - image: IMAGE + - line_density: INT, {"default": 50, min": 1, max": 100, step": 1} + - opacity: INT, {"default": 100, min": 0, max": 100, step": 1} + Optional: +Outputs: + - image (IMAGE) +-------------------------------------------------- +Node: CropByMask: + + def __init__ +Category: 😺dzNodes/LayerUtility +Inputs: + Required: + - image: IMAGE + - mask_for_crop: MASK + - invert_mask: BOOLEAN, {"default": False} + - detect: detect_mode + - top_reserve: INT, {"default": 20, min": -9999, max": 9999, step": 1} + - bottom_reserve: INT, {"default": 20, min": -9999, max": 9999, step": 1} + - left_reserve: INT, {"default": 20, min": -9999, max": 9999, step": 1} + - right_reserve: INT, {"default": 20, min": -9999, max": 9999, step": 1} + Optional: +Outputs: + - croped_image (IMAGE) + - croped_mask (MASK) + - crop_box (BOX) + - box_preview (IMAGE) +-------------------------------------------------- +Node: OuterGlowV2: + + def __init__ +Category: 😺dzNodes/LayerStyle +Inputs: + Required: + - background_image: IMAGE + - layer_image: IMAGE + - invert_mask: BOOLEAN, {"default": True} + - blend_mode: chop_mode_list + - opacity: INT, {"default": 100, min": 0, max": 100, step": 1} + - brightness: INT, {"default": 5, min": 2, max": 20, step": 1} + - glow_range: INT, {"default": 48, min": -9999, max": 9999, step": 1} + - blur: INT, {"default": 25, min": 0, max": 9999, step": 1} + - light_color: STRING, {"default": "#FFBF30"} + - glow_color: STRING, {"default": "#FE0000"} + Optional: + - layer_mask: MASK +Outputs: + - image (IMAGE) +-------------------------------------------------- +Node: ChannelShake: + + def __init__ +Category: 😺dzNodes/LayerFilter +Inputs: + Required: + - image: IMAGE + - distance: INT, {"default": 20, min": 1, max": 999, step": 1} + - angle: FLOAT, {"default": 40, min": -360, max": 360, step": 0.1} + - mode: channel_mode + Optional: +Outputs: + - image (IMAGE) +-------------------------------------------------- +Node: InnerGlow: + + def __init__ +Category: 😺dzNodes/LayerStyle +Inputs: + Required: + - background_image: IMAGE + - layer_image: IMAGE + - invert_mask: BOOLEAN, {"default": True} + - blend_mode: chop_mode + - opacity: INT, {"default": 100, min": 0, max": 100, step": 1} + - brightness: INT, {"default": 5, min": 2, max": 20, step": 1} + - glow_range: INT, {"default": 48, min": -9999, max": 9999, step": 1} + - blur: INT, {"default": 25, min": 0, max": 9999, step": 1} + - light_color: STRING, {"default": "#FFBF30"} + - glow_color: STRING, {"default": "#FE0000"} + Optional: + - layer_mask: MASK +Outputs: + - image (IMAGE) +-------------------------------------------------- +Node: ImageRemoveAlpha: + + def __init__ +Category: 😺dzNodes/LayerUtility +Inputs: + Required: + - RGBA_image: IMAGE + - fill_background: BOOLEAN, {"default": False} + - background_color: STRING, {"default": "#000000"} + Optional: + - mask: MASK +Outputs: + - RGB_image (IMAGE) +-------------------------------------------------- +Node: MaskEdgeUltraDetail: + def __init__ +Category: 😺dzNodes/LayerMask +Inputs: + Required: + - image: IMAGE + - mask: MASK + - method: method_list + - mask_grow: INT, {"default": 0, min": -999, max": 999, step": 1} + - fix_gap: INT, {"default": 0, min": 0, max": 32, step": 1} + - fix_threshold: FLOAT, {"default": 0.75, min": 0.01, max": 0.99, step": 0.01} + - detail_range: INT, {"default": 12, min": 1, max": 256, step": 1} + - black_point: FLOAT, {"default": 0.01, min": 0.01, max": 0.98, step": 0.01} + - white_point: FLOAT, {"default": 0.99, min": 0.02, max": 0.99, step": 0.01} + Optional: +Outputs: + - image (IMAGE) + - mask (MASK) +-------------------------------------------------- +Node: Stroke: + + def __init__ +Category: 😺dzNodes/LayerStyle +Inputs: + Required: + - background_image: IMAGE + - layer_image: IMAGE + - invert_mask: BOOLEAN, {"default": True} + - blend_mode: chop_mode + - opacity: INT, {"default": 100, min": 0, max": 100, step": 1} + - stroke_grow: INT, {"default": 0, min": -999, max": 999, step": 1} + - stroke_width: INT, {"default": 8, min": 0, max": 999, step": 1} + - blur: INT, {"default": 0, min": 0, max": 100, step": 1} + - stroke_color: STRING, {"default": "#FF0000"} + Optional: + - layer_mask: MASK +Outputs: + - image (IMAGE) +-------------------------------------------------- +Node: MaskByColor: + + def __init__ +Category: 😺dzNodes/LayerMask +Inputs: + Required: + - image: IMAGE + - color: COLOR, {"default": "#FFFFFF"} + - color_in_HEX: STRING, {"default": ""} + - threshold: INT, { "default": 50, min": 0, max": 100, step": 1, } + - fix_gap: INT, {"default": 2, min": 0, max": 32, step": 1} + - fix_threshold: FLOAT, {"default": 0.75, min": 0.01, max": 0.99, step": 0.01} + - invert_mask: BOOLEAN, {"default": False} + Optional: + - mask: MASK +Outputs: + - mask (MASK) +-------------------------------------------------- +Node: ShadowAndHighlightMask: + + def __init__ +Category: 😺dzNodes/LayerMask +Inputs: + Required: + - image: IMAGE + - shadow_level_offset: INT, {"default": 0, min": -99, max": 99, step": 1} + - shadow_range: FLOAT, {"default": 0.25, min": 0.01, max": 0.99, step": 0.01} + - highlight_level_offset: INT, {"default": 0, min": -99, max": 99, step": 1} + - highlight_range: FLOAT, {"default": 0.25, min": 0.01, max": 0.99, step": 0.01} + Optional: + - mask: MASK +Outputs: + - shadow_mask (MASK) + - highlight_mask (MASK) +-------------------------------------------------- +Node: LS_ShadowAndHighlightMaskV2: + + def __init__ +Category: 😺dzNodes/LayerMask +Inputs: + Required: + - image: IMAGE + - shadow_level_offset: INT, {"default": 0, min": -99, max": 99, step": 1} + - shadow_range: FLOAT, {"default": 0.25, min": 0.01, max": 0.99, step": 0.01} + - highlight_level_offset: INT, {"default": 0, min": -99, max": 99, step": 1} + - highlight_range: FLOAT, {"default": 0.25, min": 0.01, max": 0.99, step": 0.01} + Optional: + - mask: MASK +Outputs: + - shadow_mask (MASK) + - highlight_mask (MASK) +-------------------------------------------------- +Node: MaskInvert: + + def __init__ +Category: 😺dzNodes/LayerMask +Inputs: + Required: + - mask: MASK + Optional: +Outputs: + - mask (MASK) +-------------------------------------------------- +Node: SimpleTextImage: + + def __init__ +Category: 😺dzNodes/LayerUtility +Inputs: + Required: + - font_file: FONT_LIST + - align: ["center, left, right"] + - char_per_line: INT, {"default": 80, min": 1, max": 8096, step": 1} + - leading: INT, {"default": 8, min": 0, max": 8096, step": 1} + - font_size: INT, {"default": 72, min": 1, max": 2500, step": 1} + - text_color: STRING, {"default": "#FFFFFF"} + - stroke_width: INT, {"default": 0, min": 0, max": 8096, step": 1} + - stroke_color: STRING, {"default": "#FF8000"} + - x_offset: INT, {"default": 0, min": 0, max": 8096, step": 1} + - y_offset: INT, {"default": 0, min": 0, max": 8096, step": 1} + - width: INT, {"default": 512, min": 1, max": 8096, step": 1} + - height: INT, {"default": 512, min": 1, max": 8096, step": 1} + Optional: + - size_as: any, {} +Outputs: + - image (IMAGE) + - mask (MASK) +-------------------------------------------------- +Node: ColorValuetoGrayValue: + + def __init__ +Category: 😺dzNodes/LayerUtility/Data +Inputs: + Required: + - color_value: any, {} + Optional: +Outputs: + - gray(256_level) (INT) + - gray(100_level) (INT) +-------------------------------------------------- +Node: ColorCorrectHSV: + + def __init__ +Category: 😺dzNodes/LayerColor +Inputs: + Required: + - image: IMAGE + - H: INT, {"default": 0, min": -255, max": 255, step": 1} + - S: INT, {"default": 0, min": -255, max": 255, step": 1} + - V: INT, {"default": 0, min": -255, max": 255, step": 1} + Optional: +Outputs: + - image (IMAGE) +-------------------------------------------------- +Node: AutoBrightness: + + def __init__ +Category: 😺dzNodes/LayerColor +Inputs: + Required: + - image: IMAGE + - strength: INT, {"default": 75, min": 0, max": 100, step": 1} + - saturation: INT, {"default": 8, min": -255, max": 255, step": 1} + Optional: + - mask: MASK +Outputs: + - image (IMAGE) +-------------------------------------------------- +Node: ColorPicker: + + def __init__ +Category: 😺dzNodes/LayerUtility +Inputs: + Required: + - color: COLOR, {"default": "#FFFFFF"} + - mode: mode_list + Optional: +Outputs: + - value (STRING) +-------------------------------------------------- +Node: GradientOverlay: + + def __init__ +Category: 😺dzNodes/LayerStyle +Inputs: + Required: + - background_image: IMAGE + - layer_image: IMAGE + - invert_mask: BOOLEAN, {"default": True} + - blend_mode: chop_mode + - opacity: INT, {"default": 100, min": 0, max": 100, step": 1} + - start_color: STRING, {"default": "#FFBF30"} + - start_alpha: INT, {"default": 255, min": 0, max": 255, step": 1} + - end_color: STRING, {"default": "#FE0000"} + - end_alpha: INT, {"default": 255, min": 0, max": 255, step": 1} + - angle: INT, {"default": 0, min": -180, max": 180, step": 1} + Optional: + - layer_mask: MASK +Outputs: + - image (IMAGE) +-------------------------------------------------- +Node: ImageScaleRestore: + + def __init__ +Category: 😺dzNodes/LayerUtility +Inputs: + Required: + - image: IMAGE + - scale: FLOAT, {"default": 1, min": 0.01, max": 100, step": 0.01} + - method: method_mode + - scale_by_longest_side: BOOLEAN, {"default": False} + - longest_side: INT, {"default": 1024, min": 4, max": 999999, step": 1} + Optional: + - mask: MASK + - original_size: BOX +Outputs: + - image (IMAGE) + - mask (MASK) + - original_size (BOX) + - width (INT) + - height (INT) +-------------------------------------------------- +Node: MaskBoxDetect: + + def __init__ +Category: 😺dzNodes/LayerMask +Inputs: + Required: + - mask: MASK + - detect: detect_mode + - x_adjust: INT, {"default": 0, min": -9999, max": 9999, step": 1} + - y_adjust: INT, {"default": 0, min": -9999, max": 9999, step": 1} + - scale_adjust: FLOAT, {"default": 1.0, min": 0.01, max": 100, step": 0.01} + Optional: +Outputs: + - box_preview (IMAGE) + - x_percent (FLOAT) + - y_percent (FLOAT) + - width (INT) + - height (INT) + - x (INT) + - y (INT) +-------------------------------------------------- +Node: SharpAndSoft: + + def __init__ +Category: 😺dzNodes/LayerFilter +Inputs: + Required: + - images: IMAGE + - enhance: enhance_list + Optional: +Outputs: + - image (IMAGE) +-------------------------------------------------- +Node: OuterGlow: + + def __init__ +Category: 😺dzNodes/LayerStyle +Inputs: + Required: + - background_image: IMAGE + - layer_image: IMAGE + - invert_mask: BOOLEAN, {"default": True} + - blend_mode: chop_mode + - opacity: INT, {"default": 100, min": 0, max": 100, step": 1} + - brightness: INT, {"default": 5, min": 2, max": 20, step": 1} + - glow_range: INT, {"default": 48, min": -9999, max": 9999, step": 1} + - blur: INT, {"default": 25, min": 0, max": 9999, step": 1} + - light_color: STRING, {"default": "#FFBF30"} + - glow_color: STRING, {"default": "#FE0000"} + Optional: + - layer_mask: MASK +Outputs: + - image (IMAGE) +-------------------------------------------------- +Node: ExtendCanvas: + + def __init__ +Category: 😺dzNodes/LayerUtility +Inputs: + Required: + - image: IMAGE + - invert_mask: BOOLEAN, {"default": True} + - top: INT, {"default": 0, min": 0, max": 99999, step": 1} + - bottom: INT, {"default": 0, min": 0, max": 99999, step": 1} + - left: INT, {"default": 0, min": 0, max": 99999, step": 1} + - right: INT, {"default": 0, min": 0, max": 99999, step": 1} + - color: COLOR, {"default": "#000000"} + Optional: + - mask: MASK +Outputs: + - image (IMAGE) + - mask (MASK) +-------------------------------------------------- +Node: ImageChannelMerge: + + def __init__ +Category: 😺dzNodes/LayerUtility +Inputs: + Required: + - channel_1: IMAGE + - channel_2: IMAGE + - channel_3: IMAGE + - mode: channel_mode + Optional: + - channel_4: IMAGE +Outputs: + - image (IMAGE) +-------------------------------------------------- +Node: ImageToMask: + def __init__ +Category: 😺dzNodes/LayerMask +Inputs: + Required: + - image: IMAGE + - channel: channel_list + - black_point: INT, {"default": 0, min": 0, max": 255, step": 1, display": "slider"} + - white_point: INT, {"default": 255, min": 0, max": 255, step": 1, display": "slider"} + - gray_point: FLOAT, {"default": 1.0, min": 0.01, max": 9.99, step": 0.01} + - invert_output_mask: BOOLEAN, {"default": False} + Optional: + - mask: MASK +Outputs: + - mask (MASK) +-------------------------------------------------- +Node: LightLeak: + + def __init__ +Category: 😺dzNodes/LayerFilter +Inputs: + Required: + - image: IMAGE + - light: light_list + - corner: corner_list + - hue: INT, {"default": 0, min": -255, max": 255, step": 1} + - saturation: INT, {"default": 0, min": -255, max": 255, step": 1} + - opacity: INT, {"default": 100, min": 0, max": 100, step": 1} + Optional: +Outputs: + - image (IMAGE) +-------------------------------------------------- +Node: ImageCombineAlpha: + + def __init__ +Category: 😺dzNodes/LayerUtility +Inputs: + Required: + - RGB_image: IMAGE + - mask: MASK + Optional: +Outputs: + - RGBA_image (IMAGE) +-------------------------------------------------- +Node: MaskGradient: + + def __init__ +Category: 😺dzNodes/LayerMask +Inputs: + Required: + - mask: MASK + - invert_mask: BOOLEAN, {"default": True} + - gradient_side: side + - gradient_scale: INT, {"default": 100, min": 1, max": 9999, step": 1} + - gradient_offset: INT, {"default": 0, min": -9999, max": 9999, step": 1} + - opacity: INT, {"default": 100, min": 0, max": 100, step": 1} + Optional: +Outputs: + - mask (MASK) +-------------------------------------------------- +Node: DropShadow: + + def __init__ +Category: 😺dzNodes/LayerStyle +Inputs: + Required: + - background_image: IMAGE + - layer_image: IMAGE + - invert_mask: BOOLEAN, {"default": True} + - blend_mode: chop_mode + - opacity: INT, {"default": 50, min": 0, max": 100, step": 1} + - distance_x: INT, {"default": 25, min": -9999, max": 9999, step": 1} + - distance_y: INT, {"default": 25, min": -9999, max": 9999, step": 1} + - grow: INT, {"default": 6, min": -9999, max": 9999, step": 1} + - blur: INT, {"default": 18, min": 0, max": 100, step": 1} + - shadow_color: STRING, {"default": "#000000"} + Optional: + - layer_mask: MASK +Outputs: + - image (IMAGE) +-------------------------------------------------- +Node: ImageBlend: + + def __init__ +Category: 😺dzNodes/LayerUtility +Inputs: + Required: + - background_image: IMAGE + - layer_image: IMAGE + - invert_mask: BOOLEAN, {"default": True} + - blend_mode: chop_mode + - opacity: INT, {"default": 100, min": 0, max": 100, step": 1} + Optional: + - layer_mask: MASK +Outputs: + - image (IMAGE) +-------------------------------------------------- +Node: BatchSelector: + + def __init__ +Category: 😺dzNodes/LayerUtility/SystemIO +Inputs: + Required: + - select: STRING, {"default": "0, } + Optional: + - images: IMAGE + - masks: MASK +Outputs: + - image (IMAGE) + - mask (MASK) +-------------------------------------------------- +Node: AutoAdjust: + + def __init__ +Category: 😺dzNodes/LayerColor +Inputs: + Required: + - image: IMAGE + - strength: INT, {"default": 100, min": 0, max": 100, step": 1} + - brightness: INT, {"default": 0, min": -100, max": 100, step": 1} + - contrast: INT, {"default": 0, min": -100, max": 100, step": 1} + - saturation: INT, {"default": 0, min": -100, max": 100, step": 1} + - red: INT, {"default": 0, min": -100, max": 100, step": 1} + - green: INT, {"default": 0, min": -100, max": 100, step": 1} + - blue: INT, {"default": 0, min": -100, max": 100, step": 1} + Optional: +Outputs: + - image (IMAGE) +-------------------------------------------------- +Node: ColorImage: + + def __init__ +Category: 😺dzNodes/LayerUtility +Inputs: + Required: + - width: INT, {"default": 512, min": 4, max": 99999, step": 1} + - height: INT, {"default": 512, min": 4, max": 99999, step": 1} + - color: STRING, {"default": "#000000"} + Optional: +Outputs: + - image (IMAGE) +-------------------------------------------------- +Node: TextImage_v2: + + def __init__ +Category: 😺dzNodes/LayerUtility +Inputs: + Required: + - text: STRING, {"multiline": True, default": "Text"} + - font_file: FONT_LIST + - spacing: INT, {"default": 0, min": -9999, max": 9999, step": 1} + - leading: INT, {"default": 0, min": -9999, max": 9999, step": 1} + - horizontal_border: FLOAT, {"default": 5, min": -100, max": 100, step": 0.1} + - vertical_border: FLOAT, {"default": 5, min": -100, max": 100, step": 0.1} + - scale: FLOAT, {"default": 80, min": 0.1, max": 999, step": 0.01} + - variation_range: INT, {"default": 0, min": 0, max": 100, step": 1} + - variation_seed: INT, {"default": random_seed, min": 0, max": 999999999999, step": 1} + - layout: layout_list + - width: INT, {"default": 512, min": 4, max": 999999, step": 1} + - height: INT, {"default": 512, min": 4, max": 999999, step": 1} + - text_color: STRING, {"default": "#FFA000"} + - background_color: STRING, {"default": "#FFFFFF"} + Optional: + - size_as: any, {} +Outputs: + - image (IMAGE) + - mask (MASK) +-------------------------------------------------- +Node: ColorCorrectLAB: + + def __init__ +Category: 😺dzNodes/LayerColor +Inputs: + Required: + - image: IMAGE + - L: INT, {"default": 0, min": -255, max": 255, step": 1} + - A: INT, {"default": 0, min": -255, max": 255, step": 1} + - B: INT, {"default": 0, min": -255, max": 255, step": 1} + Optional: +Outputs: + - image (IMAGE) +-------------------------------------------------- +Node: GradientImageV2: + + def __init__ +Category: 😺dzNodes/LayerUtility +Inputs: + Required: + - size: size_list + - custom_width: INT, {"default": 512, min": 4, max": 99999, step": 1} + - custom_height: INT, {"default": 512, min": 4, max": 99999, step": 1} + - angle: INT, {"default": 0, min": -360, max": 360, step": 1} + - start_color: STRING, {"default": "#FFFFFF"} + - end_color: STRING, {"default": "#000000"} + Optional: + - size_as: any, {} +Outputs: + - image (IMAGE) +-------------------------------------------------- +Node: LS_RoundedRectangle: + + def __init__ +Category: 😺dzNodes/LayerUtility +Inputs: + Required: + - image: IMAGE + - rounded_rect_radius: INT, {"default": 50, min": 0, max": 100, step": 1} + - anti_aliasing: INT, {"default": 2, min": 0, max": 16, step": 1} + - top: FLOAT, {"default": 8, min": -100, max": 100, step": 0.1} + - bottom: FLOAT, {"default": 8, min": -100, max": 100, step": 0.1} + - left: FLOAT, {"default": 8, min": -100, max": 100, step": 0.1} + - right: FLOAT, {"default": 8, min": -100, max": 100, step": 0.1} + - detect: detect_mode + - obj_ext_top: FLOAT, {"default": 8, min": -100, max": 100, step": 0.1} + - obj_ext_bottom: FLOAT, {"default": 8, min": -100, max": 100, step": 0.1} + - obj_ext_left: FLOAT, {"default": 8, min": -100, max": 100, step": 0.1} + - obj_ext_right: FLOAT, {"default": 8, min": -100, max": 100, step": 0.1} + Optional: + - object_mask: MASK + - crop_box: BOX +Outputs: + - image (IMAGE) + - mask (MASK) +-------------------------------------------------- +Node: ImageScaleByAspectRatio: + + def __init__ +Category: 😺dzNodes/LayerUtility +Inputs: + Required: + - aspect_ratio: ratio_list + - proportional_width: INT, {"default": 2, min": 1, max": 999, step": 1} + - proportional_height: INT, {"default": 1, min": 1, max": 999, step": 1} + - fit: fit_mode + - method: method_mode + - round_to_multiple: multiple_list + - scale_to_longest_side: BOOLEAN, {"default": False} + - longest_side: INT, {"default": 1024, min": 4, max": 999999, step": 1} + Optional: + - image: IMAGE + - mask: MASK +Outputs: + - image (IMAGE) + - mask (MASK) + - original_size (BOX) + - width (INT) + - height (INT) +-------------------------------------------------- +Node: InnerShadow: + + def __init__ +Category: 😺dzNodes/LayerStyle +Inputs: + Required: + - background_image: IMAGE + - layer_image: IMAGE + - invert_mask: BOOLEAN, {"default": True} + - blend_mode: chop_mode + - opacity: INT, {"default": 50, min": 0, max": 100, step": 1} + - distance_x: INT, {"default": 5, min": -9999, max": 9999, step": 1} + - distance_y: INT, {"default": 5, min": -9999, max": 9999, step": 1} + - grow: INT, {"default": 2, min": -9999, max": 9999, step": 1} + - blur: INT, {"default": 15, min": 0, max": 100, step": 1} + - shadow_color: STRING, {"default": "#000000"} + Optional: + - layer_mask: MASK +Outputs: + - image (IMAGE) +-------------------------------------------------- +Node: LayerMaskTransform: + + def __init__ +Category: 😺dzNodes/LayerUtility +Inputs: + Required: + - mask: MASK + - x: INT, {"default": 0, min": -99999, max": 99999, step": 1} + - y: INT, {"default": 0, min": -99999, max": 99999, step": 1} + - mirror: mirror_mode + - scale: FLOAT, {"default": 1, min": 0.01, max": 100, step": 0.01} + - aspect_ratio: FLOAT, {"default": 1, min": 0.01, max": 100, step": 0.01} + - rotate: FLOAT, {"default": 0, min": -999999, max": 999999, step": 0.01} + - transform_method: method_mode + - anti_aliasing: INT, {"default": 2, min": 0, max": 16, step": 1} + Optional: +Outputs: + - mask (MASK) +-------------------------------------------------- +Node: HLFrequencyDetailRestore: + + def __init__ +Category: 😺dzNodes/LayerUtility +Inputs: + Required: + - image: IMAGE + - detail_image: IMAGE + - keep_high_freq: INT, {"default": 64, min": 0, max": 1023} + - erase_low_freq: INT, {"default": 32, min": 0, max": 1023} + - mask_blur: INT, {"default": 16, min": 0, max": 1023} + Optional: + - mask: MASK +Outputs: + - image (IMAGE) +-------------------------------------------------- +Node: LSImageTaggerSave: + def __init__ +Category: 😺dzNodes/LayerUtility/SystemIO +Inputs: + Required: + - {"image: IMAGE + - tag_text: STRING, {"default": , forceInput":True} + - custom_path: STRING, {"default": ""} + - filename_prefix: STRING, {"default": "comfyui"} + - timestamp: ["None, second, millisecond"] + - format: ["png, jpg"] + - quality: INT, {"default": 80, min": 10, max": 100, step": 1} + - preview: BOOLEAN, {"default": True} + Optional: +Outputs: +-------------------------------------------------- +Node: ImageBlendV2: + + def __init__ +Category: 😺dzNodes/LayerUtility +Inputs: + Required: + - background_image: IMAGE + - layer_image: IMAGE + - invert_mask: BOOLEAN, {"default": True} + - blend_mode: chop_mode_v2 + - opacity: INT, {"default": 100, min": 0, max": 100, step": 1} + Optional: + - layer_mask: MASK +Outputs: + - image (IMAGE) +-------------------------------------------------- +Node: ImageReelPipeline: + def __init__ +Category: Unknown +Inputs: + Required: + Optional: +Outputs: +-------------------------------------------------- +Node: ImageReel: + + def __init__ +Category: 😺dzNodes/LayerUtility +Inputs: + Required: + - image1: IMAGE + - image1_text: STRING, {"multiline": False, default": "image1"} + - image2_text: STRING, {"multiline": False, default": "image2"} + - image3_text: STRING, {"multiline": False, default": "image3"} + - image4_text: STRING, {"multiline": False, default": "image4"} + - reel_height: INT, {"default": 512, min": 64, max": 2048} + - border: INT, {"default": 32, min": 8, max": 512} + Optional: + - image2: IMAGE + - image3: IMAGE + - image4: IMAGE +Outputs: + - reel (Reel) +-------------------------------------------------- +Node: ImageReelComposit: + + def __init__ +Category: 😺dzNodes/LayerUtility +Inputs: + Required: + - reel_1: Reel + - font_file: FONT_LIST + - font_size: INT, {"default": 40, min": 4, max": 1024} + - border: INT, {"default": 32, min": 8, max": 512} + - color_theme: color_theme_list + Optional: + - reel_2: Reel + - reel_3: Reel + - reel_4: Reel +Outputs: + - image1 (IMAGE) +-------------------------------------------------- +Node: LS_LoadVQAModel: + + def __init__ +Category: 😺dzNodes/LayerUtility +Inputs: + Required: + - model: model_list + - precision: precision_list + - device: device_list + Optional: +Outputs: + - vqa_model (VQA_MODEL) +-------------------------------------------------- +Node: LS_VQA_Prompt: + + def __init__ +Category: 😺dzNodes/LayerUtility +Inputs: + Required: + Optional: +Outputs: + - text (STRING) +-------------------------------------------------- +Node: ColorCorrectBrightnessAndContrast: + + def __init__ +Category: 😺dzNodes/LayerColor +Inputs: + Required: + - image: IMAGE + - brightness: FLOAT, {"default": 1, min": 0.0, max": 3, step": 0.01} + - contrast: FLOAT, {"default": 1, min": 0.0, max": 3, step": 0.01} + - saturation: FLOAT, {"default": 1, min": 0.0, max": 3, step": 0.01} + Optional: +Outputs: + - image (IMAGE) +-------------------------------------------------- +Node: LS_ColorCorrect_Brightness_And_Contrast_V2: + def __init__ +Category: 😺dzNodes/LayerColor +Inputs: + Required: + - image: IMAGE + - brightness: FLOAT, {"default": 1, min": 0.0, max": 3, step": 0.01} + - contrast: FLOAT, {"default": 1, min": 0.0, max": 3, step": 0.01} + - saturation: FLOAT, {"default": 1, min": 0.0, max": 3, step": 0.01} + Optional: +Outputs: + - image (IMAGE) +-------------------------------------------------- +Node: CheckMaskV2: + + def __init__ +Category: 😺dzNodes/LayerUtility +Inputs: + Required: + - mask: MASK + - method: method_list + - white_point: INT, {"default": 1, min": 1, max": 254, step": 1} + - area_percent: FLOAT, {"default": 0.01, min": 0, max": 100, step": 0.01} + Optional: +Outputs: + - bool (BOOLEAN) +-------------------------------------------------- +Node: CropByMaskV3: + + def __init__ +Category: 😺dzNodes/LayerUtility +Inputs: + Required: + - image: IMAGE + - mask: MASK + - invert_mask: BOOLEAN, {"default": False} + - detect: detect_mode + - top_reserve: INT, {"default": 20, min": -9999, max": 9999, step": 1} + - bottom_reserve: INT, {"default": 20, min": -9999, max": 9999, step": 1} + - left_reserve: INT, {"default": 20, min": -9999, max": 9999, step": 1} + - right_reserve: INT, {"default": 20, min": -9999, max": 9999, step": 1} + - round_to_multiple: multiple_list + Optional: + - crop_box: BOX +Outputs: + - croped_image (IMAGE) + - croped_mask (MASK) + - crop_box (BOX) + - box_preview (IMAGE) +-------------------------------------------------- +Node: ColorCorrectGamma: + + def __init__ +Category: 😺dzNodes/LayerColor +Inputs: + Required: + - image: IMAGE + - gamma: FLOAT, {"default": 1, min": 0.1, max": 10, step": 0.01} + Optional: +Outputs: + - image (IMAGE) +-------------------------------------------------- +Node: LS_ColorName: + + def __init__ +Category: 😺dzNodes/LayerColor +Inputs: + Required: + - color: STRING, {"default": "#000000, forceInput":False} + - palette: list(palettes.keys( + Optional: +Outputs: + - color_name (STRING) +-------------------------------------------------- +Node: LS_NameToColor: + + def __init__ +Category: 😺dzNodes/LayerColor +Inputs: + Required: + - color_name: STRING, {"default": "white, forceInput":False} + - palette: list(palettes.keys( + - in_palette_only: BOOLEAN, {"default": False} + - default_color: STRING, {"default": "#000000, forceInput": False} + - size: size_list + - custom_width: INT, {"default": 512, min": 4, max": 99999, step": 1} + - custom_height: INT, {"default": 512, min": 4, max": 99999, step": 1} + Optional: + - size_as: any, {} +Outputs: + - image (IMAGE) + - color (STRING) +-------------------------------------------------- +Node: ColorTemperature: + def __init__ +Category: 😺dzNodes/LayerColor +Inputs: + Required: + - image: IMAGE + - temperature: FLOAT, {"default": 0, min": -100, max": 100, step": 1} + Optional: +Outputs: + - image (IMAGE) +-------------------------------------------------- +Node: ColorValuetoHSVValue: + + def __init__ +Category: 😺dzNodes/LayerUtility/Data +Inputs: + Required: + - color_value: any, {} + Optional: +Outputs: + - H (INT) + - S (INT) + - V (INT) +-------------------------------------------------- +Node: ImageBlendAdvanceV2: + + def __init__ +Category: 😺dzNodes/LayerUtility +Inputs: + Required: + - background_image: IMAGE + - layer_image: IMAGE + - invert_mask: BOOLEAN, {"default": True} + - blend_mode: chop_mode_v2 + - opacity: INT, {"default": 100, min": 0, max": 100, step": 1} + - x_percent: FLOAT, {"default": 50, min": -999, max": 999, step": 0.01} + - y_percent: FLOAT, {"default": 50, min": -999, max": 999, step": 0.01} + - mirror: mirror_mode + - scale: FLOAT, {"default": 1, min": 0.01, max": 100, step": 0.01} + - aspect_ratio: FLOAT, {"default": 1, min": 0.01, max": 100, step": 0.01} + - rotate: FLOAT, {"default": 0, min": -999999, max": 999999, step": 0.01} + - transform_method: method_mode + - anti_aliasing: INT, {"default": 0, min": 0, max": 16, step": 1} + Optional: + - layer_mask: MASK +Outputs: + - image (IMAGE) + - mask (MASK) +-------------------------------------------------- +Node: LS_AnyRerouter +Category: 😺dzNodes/LayerUtility/Data +Inputs: + Required: + - any: anything, {} + Optional: +Outputs: + - any (anything) +-------------------------------------------------- +Node: CropBoxResolve: + + def __init__ +Category: 😺dzNodes/LayerUtility +Inputs: + Required: + - crop_box: BOX + Optional: +Outputs: + - x (INT) + - y (INT) + - width (INT) + - height (INT) +-------------------------------------------------- +Node: BlendIfMask: + + def __init__ +Category: 😺dzNodes/LayerMask +Inputs: + Required: + - image: IMAGE + - invert_mask: BOOLEAN, {"default": True} + - blend_if: blend_if_list + - black_point: INT, {"default": 0, min": 0, max": 254, step": 1, display": "slider"} + - black_range: INT, {"default": 0, min": 0, max": 255, step": 1} + - white_point: INT, {"default": 255, min": 1, max": 255, step": 1, display": "slider"} + - white_range: INT, {"default": 0, min": 0, max": 255, step": 1} + Optional: + - mask: MASK +Outputs: + - mask (MASK) +-------------------------------------------------- +Node: XYtoPercent: + + def __init__ +Category: 😺dzNodes/LayerUtility/Data +Inputs: + Required: + - background_image: IMAGE + - layer_image: IMAGE + - x: INT, {"default": 0, min": -99999, max": 99999, step": 1} + - y: INT, {"default": 0, min": -99999, max": 99999, step": 1} + Optional: +Outputs: + - x_percent (FLOAT) + - y_percent (FLOAT) +-------------------------------------------------- +Node: MotionBlur: + + def __init__ +Category: 😺dzNodes/LayerFilter +Inputs: + Required: + - image: IMAGE + - angle: INT, {"default": 0, min": -90, max": 90, step": 1} + - blur: INT, {"default": 20, min": 1, max": 999, step": 1} + Optional: +Outputs: + - image (IMAGE) +-------------------------------------------------- +Node: InnerGlowV2: + + def __init__ +Category: 😺dzNodes/LayerStyle +Inputs: + Required: + - background_image: IMAGE + - layer_image: IMAGE + - invert_mask: BOOLEAN, {"default": True} + - blend_mode: chop_mode_list + - opacity: INT, {"default": 100, min": 0, max": 100, step": 1} + - brightness: INT, {"default": 5, min": 2, max": 20, step": 1} + - glow_range: INT, {"default": 48, min": -9999, max": 9999, step": 1} + - blur: INT, {"default": 25, min": 0, max": 9999, step": 1} + - light_color: STRING, {"default": "#FFBF30"} + - glow_color: STRING, {"default": "#FE0000"} + Optional: + - layer_mask: MASK +Outputs: + - image (IMAGE) +-------------------------------------------------- +Node: SeedNode: + def __init__ +Category: 😺dzNodes/LayerUtility/Data +Inputs: + Required: + - seed: INT, {"default": 0, min": 0, max": 1e18, step": 1} + Optional: +Outputs: + - seed (INT) +-------------------------------------------------- +Node: BooleanOperator: + def __init__ +Category: 😺dzNodes/LayerUtility/Data +Inputs: + Required: + - a: any + - b: any + - operator: operator_list + Optional: +Outputs: + - output (BOOLEAN) +-------------------------------------------------- +Node: BooleanOperatorV2: + def __init__ +Category: 😺dzNodes/LayerUtility/Data +Inputs: + Required: + - a_value: STRING, {"default": , multiline": False} + - b_value: STRING, {"default": , multiline": False} + - operator: operator_list + Optional: + - a: any + - b: any +Outputs: + - output (BOOLEAN) + - string (STRING) +-------------------------------------------------- +Node: NumberCalculator: + def __init__ +Category: 😺dzNodes/LayerUtility/Data +Inputs: + Required: + - a: any, {} + - b: any, {} + - operator: operator_list + Optional: +Outputs: + - int (INT) + - float (FLOAT) +-------------------------------------------------- +Node: NumberCalculatorV2: + def __init__ +Category: 😺dzNodes/LayerUtility/Data +Inputs: + Required: + - a_value: STRING, {"default": , multiline": False} + - b_value: STRING, {"default": , multiline": False} + - operator: operator_list + Optional: + - a: any + - b: any +Outputs: + - int (INT) + - float (FLOAT) + - string (STRING) +-------------------------------------------------- +Node: StringCondition: + def __init__ +Category: 😺dzNodes/LayerUtility/Data +Inputs: + Required: + - text: STRING, {"multiline": False} + - condition: string_condition_list + - sub_string: STRING, {"multiline": False} + Optional: +Outputs: + - output (BOOLEAN) + - string (STRING) +-------------------------------------------------- +Node: TextBoxNode: + def __init__ +Category: 😺dzNodes/LayerUtility/Data +Inputs: + Required: + - text: STRING, {"multiline": True} + Optional: +Outputs: + - text (STRING) +-------------------------------------------------- +Node: StringNode: + def __init__ +Category: 😺dzNodes/LayerUtility/Data +Inputs: + Required: + - string: STRING, {"multiline": False} + Optional: +Outputs: + - string (STRING) +-------------------------------------------------- +Node: IntegerNode: + def __init__ +Category: 😺dzNodes/LayerUtility/Data +Inputs: + Required: + - int_value: INT, {"default": 0, min": -1e18, max": 1e18, step": 1} + Optional: +Outputs: + - int (INT) + - string (STRING) +-------------------------------------------------- +Node: FloatNode: + def __init__ +Category: 😺dzNodes/LayerUtility/Data +Inputs: + Required: + - float_value: FLOAT, {"default": 0, min": -1e18, max": 1e18, step": 0.00001} + Optional: +Outputs: + - float (FLOAT) + - string (STRING) +-------------------------------------------------- +Node: BooleanNode: + def __init__ +Category: 😺dzNodes/LayerUtility/Data +Inputs: + Required: + - bool_value: BOOLEAN, {"default": False} + Optional: +Outputs: + - boolean (BOOLEAN) + - string (STRING) +-------------------------------------------------- +Node: IfExecute: + + @classmethod + def INPUT_TYPES +Category: 😺dzNodes/LayerUtility/Data +Inputs: + Required: + - if_condition: any + - when_TRUE: any + - when_FALSE: any + Optional: +Outputs: + - ? (any) +-------------------------------------------------- +Node: SwitchCaseNode: + + @classmethod + def INPUT_TYPES +Category: 😺dzNodes/LayerUtility/Data +Inputs: + Required: + - switch_condition: STRING, {"default": , multiline": False} + - case_1: STRING, {"default": , multiline": False} + - case_2: STRING, {"default": , multiline": False} + - case_3: STRING, {"default": , multiline": False} + - input_default: any + Optional: + - input_1: any + - input_2: any + - input_3: any +Outputs: + - ? (any) +-------------------------------------------------- +Node: QueueStopNode +Category: 😺dzNodes/LayerUtility/SystemIO +Inputs: + Required: + - any: any + - mode: mode_list + - stop: BOOLEAN, {"default": True} + Optional: +Outputs: + - any (any) +-------------------------------------------------- +Node: RemBgUltra: + def __init__ +Category: 😺dzNodes/LayerMask +Inputs: + Required: + - image: IMAGE + - detail_range: INT, {"default": 8, min": 1, max": 256, step": 1} + - black_point: FLOAT, {"default": 0.01, min": 0.01, max": 0.98, step": 0.01} + - white_point: FLOAT, {"default": 0.99, min": 0.02, max": 0.99, step": 0.01} + - process_detail: BOOLEAN, {"default": True} + Optional: +Outputs: + - image (IMAGE) + - mask (MASK) +-------------------------------------------------- +Node: InnerShadowV2: + + def __init__ +Category: 😺dzNodes/LayerStyle +Inputs: + Required: + - background_image: IMAGE + - layer_image: IMAGE + - invert_mask: BOOLEAN, {"default": True} + - blend_mode: chop_mode_v2 + - opacity: INT, {"default": 50, min": 0, max": 100, step": 1} + - distance_x: INT, {"default": 5, min": -9999, max": 9999, step": 1} + - distance_y: INT, {"default": 5, min": -9999, max": 9999, step": 1} + - grow: INT, {"default": 2, min": -9999, max": 9999, step": 1} + - blur: INT, {"default": 15, min": 0, max": 100, step": 1} + - shadow_color: STRING, {"default": "#000000"} + Optional: + - layer_mask: MASK +Outputs: + - image (IMAGE) +-------------------------------------------------- +Node: SkinBeauty: + + def __init__ +Category: 😺dzNodes/LayerFilter +Inputs: + Required: + - image: IMAGE + - smooth: INT, {"default": 20, min": 1, max": 64, step": 1} + - threshold: INT, {"default": -10, min": -255, max": 255, step": 1} + - opacity: INT, {"default": 100, min": 0, max": 100, step": 1} + Optional: +Outputs: + - image (IMAGE) + - beauty_mask (MASK) +-------------------------------------------------- +Node: CreateGradientMask: + + def __init__ +Category: 😺dzNodes/LayerMask +Inputs: + Required: + - width: INT, {"default": 512, min": 4, max": 99999, step": 1} + - height: INT, {"default": 512, min": 4, max": 99999, step": 1} + - gradient_side: side + - gradient_scale: INT, {"default": 100, min": 1, max": 9999, step": 1} + - gradient_offset: INT, {"default": 0, min": -9999, max": 9999, step": 1} + - opacity: INT, {"default": 100, min": 0, max": 100, step": 1} + Optional: + - size_as: any, {} +Outputs: + - mask (MASK) +-------------------------------------------------- +Node: ColorMap: + + def __init__ +Category: 😺dzNodes/LayerFilter +Inputs: + Required: + - image: IMAGE + - color_map: colormap_list + - opacity: INT, {"default": 100, min": 0, max": 100, step": 1} + Optional: +Outputs: + - image (IMAGE) +-------------------------------------------------- +Node: LSRandomGenerator: + + def __init__ +Category: 😺dzNodes/LayerUtility/Data +Inputs: + Required: + - min_value: FLOAT, {"default": 0, min": -1.0e14, max": 1.0e14, step": 0.01} + - max_value: FLOAT, {"default": 10, min": -1.0e14, max": 1.0e14, step": 0.01} + - float_decimal_places: INT, {"default": 1, min": 1, max": 14, step": 1} + - fix_seed: BOOLEAN, {"default": False} + Optional: + - image: IMAGE +Outputs: + - int (INT) + - float (FLOAT) + - bool (BOOLEAN) +-------------------------------------------------- +Node: LS_RandomGeneratorV2: + + def __init__ +Category: 😺dzNodes/LayerUtility/Data +Inputs: + Required: + - min_value: FLOAT, {"default": 0, min": -1.0e14, max": 1.0e14, step": 0.01} + - max_value: FLOAT, {"default": 10, min": -1.0e14, max": 1.0e14, step": 0.01} + - least: FLOAT, {"default": 0, min": 0, max": 1.0e14, step": 0.01} + - float_decimal_places: INT, {"default": 1, min": 1, max": 14, step": 1} + - seed: INT, {"default": 0, min": 0, max": 1e14, step": 1} + Optional: + - image: IMAGE +Outputs: + - int (INT) + - float (FLOAT) + - bool (BOOLEAN) +-------------------------------------------------- +Node: RmBgUltraV2: + def __init__ +Category: 😺dzNodes/LayerMask +Inputs: + Required: + - image: IMAGE + - detail_method: method_list + - detail_erode: INT, {"default": 6, min": 1, max": 255, step": 1} + - detail_dilate: INT, {"default": 6, min": 1, max": 255, step": 1} + - black_point: FLOAT, {"default": 0.01, min": 0.01, max": 0.98, step": 0.01, display": "slider"} + - white_point: FLOAT, {"default": 0.99, min": 0.02, max": 0.99, step": 0.01, display": "slider"} + - process_detail: BOOLEAN, {"default": True} + - device: device_list + - max_megapixels: FLOAT, {"default": 2.0, min": 1, max": 999, step": 0.1} + Optional: +Outputs: + - image (IMAGE) + - mask (MASK) +-------------------------------------------------- +Node: ColorCorrectLevels: + + def __init__ +Category: 😺dzNodes/LayerColor +Inputs: + Required: + - image: IMAGE + - channel: channel_list + - black_point: INT, {"default": 0, min": 0, max": 255, step": 1, display": "slider"} + - white_point: INT, {"default": 255, min": 0, max": 255, step": 1, display": "slider"} + - gray_point: FLOAT, {"default": 1, min": 0.01, max": 9.99, step": 0.01} + - output_black_point: INT, {"default": 0, min": 0, max": 255, step": 1} + - output_white_point: INT, {"default": 255, min": 0, max": 255, step": 1} + Optional: +Outputs: + - image (IMAGE) +-------------------------------------------------- +Node: GetImageSize: + + def __init__ +Category: 😺dzNodes/LayerUtility +Inputs: + Required: + - image: IMAGE + Optional: +Outputs: + - width (INT) + - height (INT) + - original_size (BOX) +-------------------------------------------------- +Node: LS_TextPreseter: + def __init__ +Category: 😺dzNodes/LayerUtility/Data +Inputs: + Required: + - title: STRING, {"default": , multiline": False} + - content: STRING, {"default": , multiline": True} + Optional: + - text_preset: LS_TEXT_PRESET +Outputs: + - text_preset (LS_TEXT_PRESET) +-------------------------------------------------- +Node: LS_ChoiceTextPreset: + def __init__ +Category: 😺dzNodes/LayerUtility/Data +Inputs: + Required: + - { "text_preset: LS_TEXT_PRESET + - choice_title: STRING, {"default": , multiline": False} + - random_choice: BOOLEAN, {"default": False} + - default: INT, {"default": 0, min": 0, max": 1e4, step": 1} + - seed: INT, {"default": 0, min": 0, max": 1e18, step": 1} + Optional: +Outputs: + - title (STRING) + - content (STRING) +-------------------------------------------------- +Node: ImageScaleRestoreV2: + + def __init__ +Category: 😺dzNodes/LayerUtility +Inputs: + Required: + - image: IMAGE + - scale: FLOAT, {"default": 1, min": 0.01, max": 100, step": 0.01} + - method: method_mode + - scale_by: scale_by_list + - scale_by_length: INT, {"default": 1024, min": 4, max": 99999999, step": 1} + Optional: + - mask: MASK + - original_size: BOX +Outputs: + - image (IMAGE) + - mask (MASK) + - original_size (BOX) + - width (INT) + - height (INT) +-------------------------------------------------- +Node: MaskGrow: + + def __init__ +Category: 😺dzNodes/LayerMask +Inputs: + Required: + - mask: MASK + - invert_mask: BOOLEAN, {"default": True} + - grow: INT, {"default": 4, min": -999, max": 999, step": 1} + - blur: INT, {"default": 4, min": 0, max": 999, step": 1} + Optional: +Outputs: + - mask (MASK) +-------------------------------------------------- +Node: LS_GetMainColorsV2: + + def __init__ +Category: 😺dzNodes/LayerUtility +Inputs: + Required: + - image: IMAGE + - k_means_algorithm: k_means_algorithm_list + Optional: +Outputs: + - preview_image (IMAGE) + - color_1 (STRING) + - color_2 (STRING) + - color_3 (STRING) + - color_4 (STRING) + - color_5 (STRING) +-------------------------------------------------- +Node: LS_GetMainColors: + + def __init__ +Category: 😺dzNodes/LayerUtility +Inputs: + Required: + - image: IMAGE + - k_means_algorithm: k_means_algorithm_list + Optional: +Outputs: + - preview_image (IMAGE) + - color_1 (STRING) + - color_2 (STRING) + - color_3 (STRING) + - color_4 (STRING) + - color_5 (STRING) +-------------------------------------------------- +Node: MaskEdgeShrink: + + def __init__ +Category: 😺dzNodes/LayerMask +Inputs: + Required: + - mask: MASK + - invert_mask: BOOLEAN, {"default": True} + - shrink_level: INT, {"default": 4, min": 0, max": 16, step": 1} + - soft: INT, {"default": 6, min": 0, max": 64, step": 1} + - edge_shrink: INT, {"default": 1, min": 0, max": 999, step": 1} + - edge_reserve: INT, {"default": 25, min": 0, max": 100, step": 1} + Optional: +Outputs: + - mask (MASK) +-------------------------------------------------- +Node: ColorCorrectRGB: + + def __init__ +Category: 😺dzNodes/LayerColor +Inputs: + Required: + - image: IMAGE + - R: INT, {"default": 0, min": -255, max": 255, step": 1} + - G: INT, {"default": 0, min": -255, max": 255, step": 1} + - B: INT, {"default": 0, min": -255, max": 255, step": 1} + Optional: +Outputs: + - image (IMAGE) +-------------------------------------------------- +Node: GradientImage: + + def __init__ +Category: 😺dzNodes/LayerUtility +Inputs: + Required: + - width: INT, {"default": 512, min": 4, max": 99999, step": 1} + - height: INT, {"default": 512, min": 4, max": 99999, step": 1} + - angle: INT, {"default": 0, min": -360, max": 360, step": 1} + - start_color: STRING, {"default": "#FFFFFF"} + - end_color: STRING, {"default": "#000000"} + Optional: +Outputs: + - image (IMAGE) +-------------------------------------------------- +Node: CropByMaskV2: + + def __init__ +Category: 😺dzNodes/LayerUtility +Inputs: + Required: + - image: IMAGE + - mask: MASK + - invert_mask: BOOLEAN, {"default": False} + - detect: detect_mode + - top_reserve: INT, {"default": 20, min": -9999, max": 9999, step": 1} + - bottom_reserve: INT, {"default": 20, min": -9999, max": 9999, step": 1} + - left_reserve: INT, {"default": 20, min": -9999, max": 9999, step": 1} + - right_reserve: INT, {"default": 20, min": -9999, max": 9999, step": 1} + - round_to_multiple: multiple_list + Optional: + - crop_box: BOX +Outputs: + - croped_image (IMAGE) + - croped_mask (MASK) + - crop_box (BOX) + - box_preview (IMAGE) +-------------------------------------------------- +Node: MaskPreview +Category: 😺dzNodes/LayerMask +Inputs: + Required: + - {"mask: MASK + Optional: +Outputs: +-------------------------------------------------- +Node: ImageBlendAdvanceV3: + + def __init__ +Category: 😺dzNodes/LayerUtility +Inputs: + Required: + - layer_image: IMAGE + - invert_mask: BOOLEAN, {"default": True} + - blend_mode: chop_mode_v2 + - opacity: INT, {"default": 100, min": 0, max": 100, step": 1} + - x_percent: FLOAT, {"default": 50, min": -999, max": 999, step": 0.01} + - y_percent: FLOAT, {"default": 50, min": -999, max": 999, step": 0.01} + - mirror: mirror_mode + - scale: FLOAT, {"default": 1, min": 0.01, max": 100, step": 0.01} + - aspect_ratio: FLOAT, {"default": 1, min": 0.01, max": 100, step": 0.01} + - rotate: FLOAT, {"default": 0, min": -999999, max": 999999, step": 0.01} + - transform_method: method_mode + - anti_aliasing: INT, {"default": 0, min": 0, max": 16, step": 1} + Optional: + - background_image: IMAGE + - layer_mask: MASK +Outputs: + - image (IMAGE) + - mask (MASK) +-------------------------------------------------- +Node: PurgeVRAM: + + def __init__ +Category: 😺dzNodes/LayerUtility/SystemIO +Inputs: + Required: + - anything: any, {} + - purge_cache: BOOLEAN, {"default": True} + - purge_models: BOOLEAN, {"default": True} + Optional: +Outputs: +-------------------------------------------------- +Node: PurgeVRAM_V2: + + def __init__ +Category: 😺dzNodes/LayerUtility/SystemIO +Inputs: + Required: + - anything: any, {} + - purge_cache: BOOLEAN, {"default": True} + - purge_models: BOOLEAN, {"default": True} + Optional: +Outputs: + - any (any) +-------------------------------------------------- +Node: VideoCombine: + @classmethod + def INPUT_TYPES +Category: Video Helper Suite 🎥🅥🅗🅢 +Inputs: + Required: + Optional: +Outputs: + - Filenames (VHS_FILENAMES) +-------------------------------------------------- +Node: LoadAudio: + @classmethod + def INPUT_TYPES +Category: audio +Inputs: + Required: + - {"audio: sorted(files + Optional: +Outputs: + - AUDIO +-------------------------------------------------- +Node: LoadAudioUpload: + @classmethod + def INPUT_TYPES +Category: Video Helper Suite 🎥🅥🅗🅢/audio +Inputs: + Required: + - audio: sorted(files + - start_time: FLOAT, {"default": 0, min": 0, max": 10000000, step": 0.01} + - duration: FLOAT, {"default": 0, min": 0, max": 10000000, step": 0.01} + Optional: +Outputs: + - audio (AUDIO) +-------------------------------------------------- +Node: AudioToVHSAudio: + """Legacy method for external nodes that utilized VHS_AUDIO, + VHS_AUDIO is deprecated as a format and should no longer be used""" + @classmethod + def INPUT_TYPES +Category: Video Helper Suite 🎥🅥🅗🅢/audio +Description: Legacy method for external nodes that utilized VHS_AUDIO, + VHS_AUDIO is deprecated as a format and should no longer be used +Inputs: + Required: + - {"audio: AUDIO + Optional: +Outputs: + - vhs_audio (VHS_AUDIO) +-------------------------------------------------- +Node: VHSAudioToAudio: + """Legacy method for external nodes that utilized VHS_AUDIO, + VHS_AUDIO is deprecated as a format and should no longer be used""" + @classmethod + def INPUT_TYPES +Category: Video Helper Suite 🎥🅥🅗🅢/audio +Description: Legacy method for external nodes that utilized VHS_AUDIO, + VHS_AUDIO is deprecated as a format and should no longer be used +Inputs: + Required: + - {"vhs_audio: VHS_AUDIO + Optional: +Outputs: + - audio (AUDIO) +-------------------------------------------------- +Node: PruneOutputs: + @classmethod + def INPUT_TYPES +Category: Video Helper Suite 🎥🅥🅗🅢 +Inputs: + Required: + - filenames: VHS_FILENAMES + - options: ["Intermediate, Intermediate and Utility"] + Optional: +Outputs: +-------------------------------------------------- +Node: BatchManager: + def __init__ +Category: Video Helper Suite 🎥🅥🅗🅢 +Inputs: + Required: + - frames_per_batch: INT, {"default": 16, min": 1, max": BIGMAX, step": 1} + Optional: +Outputs: + - meta_batch (VHS_BatchManager) +-------------------------------------------------- +Node: VideoInfo: + @classmethod + def INPUT_TYPES +Category: Video Helper Suite 🎥🅥🅗🅢 +Inputs: + Required: + - video_info: VHS_VIDEOINFO + Optional: +Outputs: + - FLOAT + - INT + - FLOAT + - INT + - INT + - FLOAT + - INT + - FLOAT + - INT + - INT +-------------------------------------------------- +Node: VideoInfoSource: + @classmethod + def INPUT_TYPES +Category: Video Helper Suite 🎥🅥🅗🅢 +Inputs: + Required: + - video_info: VHS_VIDEOINFO + Optional: +Outputs: + - FLOAT + - INT + - FLOAT + - INT + - INT +-------------------------------------------------- +Node: VideoInfoLoaded: + @classmethod + def INPUT_TYPES +Category: Video Helper Suite 🎥🅥🅗🅢 +Inputs: + Required: + - video_info: VHS_VIDEOINFO + Optional: +Outputs: + - FLOAT + - INT + - FLOAT + - INT + - INT +-------------------------------------------------- +Node: SelectFilename: + @classmethod + def INPUT_TYPES +Category: Video Helper Suite 🎥🅥🅗🅢 +Inputs: + Required: + - {"filenames: VHS_FILENAMES + Optional: +Outputs: + - Filename (STRING) +-------------------------------------------------- +Node: Unbatch: +Category: Unknown +Inputs: + Required: + Optional: +Outputs: +-------------------------------------------------- +Node: Any +Category: Video Helper Suite 🎥🅥🅗🅢 +Inputs: + Required: + - {"batched: * + Optional: +Outputs: + - unbatched (Any('*')) +-------------------------------------------------- +Node: SelectLatest: + @classmethod + def INPUT_TYPES +Category: Video Helper Suite 🎥🅥🅗🅢 +Inputs: + Required: + - {"filename_prefix: STRING, {'default': 'output/AnimateDiff, vhs_path_extensions': []} + - filename_postfix: STRING, {"placeholder": ".webm"} + Optional: +Outputs: + - Filename (STRING) +-------------------------------------------------- +Node: VariableLineWidthEffectNode: + @classmethod + def INPUT_TYPES +Category: SyntaxNodes/Processing +Description: Convert mask to proper format and shape +Inputs: + Required: + - images: IMAGE + - line_spacing: INT, {"default": 5, min": 1, max": 20} + - displacement_strength: FLOAT, {"default": 30.0, min": 1.0, max": 100.0} + - line_thickness: INT, {"default": 1, min": 1, max": 5} + - invert: BOOLEAN, {"default": False} + - color_intensity: FLOAT, {"default": 3.0, min": 0.0, max": 5.0} + - start_color_r: INT, {"default": 0, min": 0, max": 255} + - start_color_g: INT, {"default": 0, min": 0, max": 255} + - start_color_b: INT, {"default": 255, min": 0, max": 255} + - end_color_r: INT, {"default": 255, min": 0, max": 255} + - end_color_g: INT, {"default": 0, min": 0, max": 255} + - end_color_b: INT, {"default": 0, min": 0, max": 255} + Optional: + - mask: MASK +Outputs: + - IMAGE +-------------------------------------------------- +Node: PaperCraftNode: + def __init__ +Category: 🎨 Image/Effects +Inputs: + Required: + - image: IMAGE + - default: 0.2 + - min: 0.0 + - max: 1.0 + - step: 0.05 + Optional: + - mask: MASK +Outputs: + - IMAGE +-------------------------------------------------- +Node: DepthToLidarEffectNode: + def __init__ +Category: SyntaxNodes/Processing +Description: Reset the previous frame memory for a new sequence. +Inputs: + Required: + - depth_map: IMAGE + - default: 1 + - min: 1 + - max: 5 + - step: 1 + Optional: +Outputs: + - IMAGE +-------------------------------------------------- +Node: RegionBoundaryNode: + @classmethod + def INPUT_TYPES +Category: SyntaxNodes/Processing +Inputs: + Required: + - image: IMAGE + - segments: INT, {"default": 100, min": 10, max": 1000, step": 10} + - compactness: FLOAT, {"default": 10.0, min": 1.0, max": 100.0, step": 1.0} + - line_color: INT, {"default": 0xFFFFFF, min": 0, max": 0xFFFFFF, step": 1} + Optional: +Outputs: + - IMAGE +-------------------------------------------------- +Node: LuminanceParticleNode: + def __init__ +Category: Unknown +Description: Create new particles at edge points with initial directions and lifespan. +Inputs: + Required: + - depth_map: IMAGE + - default: 50 + - min: 1 + - max: 100 + - step: 1 + Optional: +Outputs: + - IMAGE +-------------------------------------------------- +Node: EdgeTracingNode: + def __init__ +Category: Unknown +Description: Convert a tensor to a PIL image. +Inputs: + Required: + - input_image: IMAGE + - low_threshold: INT, {"default": 50, min": 0, max": 255} + - high_threshold: INT, {"default": 150, min": 0, max": 255} + - num_particles: INT, {"default": 1000, min": 1, max": 50000} + - speed: INT, {"default": 10, min": 1, max": 100} + - edge_opacity: FLOAT, {"default": 0.5, min": 0.0, max": 1.0} + - particle_size: INT, {"default": 1, min": 1, max": 10} + Optional: +Outputs: + - IMAGE +-------------------------------------------------- +Node: VoxelNode: + def __init__ +Category: SyntaxNodes/Processing +Inputs: + Required: + - image: IMAGE + - default: 0.2 + - min: 0.0 + - max: 1.0 + - step: 0.05 + Optional: + - mask: MASK +Outputs: + - IMAGE +-------------------------------------------------- +Node: GhostingNode: + def __init__ +Category: SyntaxNodes/Processing +Inputs: + Required: + - image: IMAGE + - default: 5 + - min: 1 + - max: 20 + - step: 1 + Optional: + - mask: MASK +Outputs: + - IMAGE +-------------------------------------------------- +Node: ImageListToImageBatch: + @classmethod + def INPUT_TYPES +Category: SyntaxNodes/Conversion +Inputs: + Required: + - images: IMAGE + Optional: +Outputs: + - IMAGE +-------------------------------------------------- +Node: ImageBatchToImageList: + @classmethod + def INPUT_TYPES +Category: SyntaxNodes/Conversion +Inputs: + Required: + - {"image: IMAGE + Optional: +Outputs: + - IMAGE +-------------------------------------------------- +Node: CyberpunkWindowNode: + def __init__ +Category: SyntaxNodes/Processing +Inputs: + Required: + - image: IMAGE + - custom_text: STRING, {"default": "MOVEMENT, multiline": False} + - default: 0 + - min: 0 + - max: 1 + - step: 1 + Optional: +Outputs: + - IMAGE +-------------------------------------------------- +Node: RGBStreakNode: + @classmethod + def INPUT_TYPES +Category: image/effects +Inputs: + Required: + - image: IMAGE + - default: 0.95 + - min: 0.1 + - max: 0.99 + - step: 0.01 + Optional: +Outputs: + - IMAGE +-------------------------------------------------- +Node: JigsawPuzzleNode: + @classmethod + def INPUT_TYPES +Category: 🖼️ Image/Effects +Description: Converts a ComfyUI tensor to a NumPy array (for OpenCV). +Inputs: + Required: + - image: IMAGE + - pieces: INT, {"default": 50, min": 10, max": 500, step": 10} + - piece_size: INT, {"default": 64, min": 32, max": 100, step": 1} + - background: IMAGE, {"optional": True} + - num_remove: INT, {"default": 3, min": 0, max": 100, step": 1} + Optional: + - {"default: 3 +Outputs: + - IMAGE +-------------------------------------------------- +Node: EdgeMeasurementOverlayNode: + def __init__ +Category: Unknown +Inputs: + Required: + - image: IMAGE + - default: 0.7 + - min: 0.0 + - max: 1.0 + - step: 0.1 + Optional: +Outputs: + - IMAGE +-------------------------------------------------- +Node: UpTrackNode: + def __init__ +Category: SyntaxNodes/Processing +Description: Normalize angle to -180 to 180 range +Inputs: + Required: + - image: IMAGE + - default: 5.0 + - min: 0.0 + - max: 45.0 + - step: 1.0 + - display: combo + - labels: Upright Lock, Follow Flip + Optional: +Outputs: + - IMAGE +-------------------------------------------------- +Node: LowPolyNode: + def __init__ +Category: Unknown +Inputs: + Required: + - image: IMAGE + - default: 5 + - min: 1 + - max: 20 + - step: 1 + Optional: +Outputs: + - IMAGE +-------------------------------------------------- +Node: if it can't be imported +Category: Unknown +Inputs: + Required: + Optional: +Outputs: +-------------------------------------------------- +Node: PngInfo: + def __init__ +Category: Unknown +Inputs: + Required: + Optional: +Outputs: +-------------------------------------------------- +Node: FrequencyBeatSyncNode: + def __init__ +Category: Video Processing +Description: Convert tensor to PIL Image +Inputs: + Required: + - video_folder: STRING, {"default": "videos"} + - audio_path: STRING, {"default": "audio.mp3"} + - width: INT, {"default": 512, min": 64, max": 2048} + - height: INT, {"default": 512, min": 64, max": 2048} + - fps: INT, {"default": 30, min": 1, max": 60} + - max_beats: INT, {"default": 0, min": 0, max": 1000, step": 1} + - max_frames: INT, {"default": 150, min": 0, max": 1000, step": 1} + - effect_intensity: FLOAT, {"default": 1.0, min": 0.1, max": 5.0, step": 0.1} + - output_mode: ["Frames for Editing, Direct Video Output"] + - filename_prefix: STRING, {"default": "BeatSync"} + Optional: +Outputs: + - frames (IMAGE) + - audio (AUDIO) +-------------------------------------------------- +Node: PointillismNode: + def __init__ +Category: Unknown +Inputs: + Required: + - image: IMAGE + - dot_radius: INT, {"default": 3, min": 1, max": 10} + - dot_density: INT, {"default": 20000, min": 1000, max": 200000} + Optional: +Outputs: + - IMAGE +-------------------------------------------------- +Node: LS_CollageGenerator: + """随机分割生成指定数量的不规则小矩形。""" + def __init__ +Category: Unknown +Description: 随机分割生成指定数量的不规则小矩形。 +Inputs: + Required: + Optional: +Outputs: +-------------------------------------------------- +Node: PIP_Collage: + def __init__ +Category: PIP 动漫人脸检测 +Inputs: + Required: + - images: IMAGE, {"description": "输入图像"} + - default: multi + - min: 0.0 + - max: 1.0 + - step: 0.01 + - display: 模式 + - description: 选择多人模式或单人模式 + Optional: +Outputs: + - 输出图像 (IMAGE) + - 遮罩 (MASK) +-------------------------------------------------- +Node: mappings +NODE_CLASS_MAPPINGS = { + "PIP_AnimeFaceDetect": PIP_AnimeFaceDetect, + "PIP_Collage": PIP_Collage, + "PIP_GridComic": PIP_GridComic +} + +# Node display name mappings +NODE_DISPLAY_NAME_MAPPINGS = { + "PIP_AnimeFaceDetect": "PIP 动漫人脸检测", + "PIP_Collage": "PIP 随机拼图", + "PIP_GridComic": "PIP 格漫拼图" +} +Category: Unknown +Inputs: + Required: + Optional: +Outputs: +-------------------------------------------------- +Node: PIP_AnimeFaceDetect: + @classmethod + def INPUT_TYPES +Category: PIP 动漫人脸检测 +Inputs: + Required: + - image_in: IMAGE, {} + - score_threshold: FLOAT, {"default": 0.25, min": 0.0, max": 1.0, step": 0.01, label": "置信度阈值"} + - iou_threshold: FLOAT, {"default": 0.7, min": 0.0, max": 1.0, step": 0.01, label": "IOU 阈值"} + - expand_ratio: FLOAT, {"default": 0.0, min": 0.0, max": 1.0, step": 0.01, label": "扩展比例"} + Optional: +Outputs: + - 带框图像 (IMAGE) + - 裁剪人脸 (IMAGE) + - 人脸遮罩 (MASK) + - 人脸检测结果 (STRING) +-------------------------------------------------- +Node: MangaStyleLayoutGenerator: + """创意漫画布局生成器，使用真实漫画的多样化布局风格""" + def __init__ +Category: Unknown +Description: 创意漫画布局生成器，使用真实漫画的多样化布局风格 +Inputs: + Required: + Optional: +Outputs: +-------------------------------------------------- +Node: PIP_GridComic: + def __init__ +Category: PIP 动漫人脸检测 +Description: 将图像调整到目标尺寸，根据图像类型优化裁剪，并可选择旋转 +Inputs: + Required: + - character_image: IMAGE, {"description": "角色图像 (1:2 + - expression_image: IMAGE, {"description": "表情图像 (2:1 + - scene_image: IMAGE, {"description": "场景图像 (1:1 + - item_image: IMAGE, {"description": "物品图像 (1:1 + - default: 0 + - min: 0 + - max: 1e18 + - step: 1 + - display: 随机种子 + Optional: +Outputs: + - 输出图像 (IMAGE) + - 遮罩 (MASK) +-------------------------------------------------- +Node: DebouncedHotReloader +Category: Unknown +Description: Hot reloader with debouncing mechanism to reload modules on file changes. +Inputs: + Required: + Optional: +Outputs: +-------------------------------------------------- +Node: HotReloaderService: + """Service to manage the hot reloading of modules.""" + + def __init__ +Category: Unknown +Description: Service to manage the hot reloading of modules. +Inputs: + Required: + Optional: +Outputs: +-------------------------------------------------- +Node: variables for help documentation +Category: Unknown +Inputs: + Required: + Optional: +Outputs: +-------------------------------------------------- +Node: RyanOnTheInside +Category: Unknown +Inputs: + Required: + Optional: +Outputs: +-------------------------------------------------- +Node: ProgressMixin: + def start_progress +Category: Unknown +Description: ██████╗ ██╗ ██╗ █████╗ ███╗ ██╗ ██████╗ ███╗ ██╗ + ██╔══██╗╚██╗ ██╔╝██╔══██╗████╗ ██║ ██╔═══██╗████╗ ██║ + ██████╔╝ ╚████╔╝ ███████║██╔██╗ ██║ ██║ ██║██╔██╗ ██║ + ██╔══██╗ ╚██╔╝ ██╔══██║██║╚██╗██║ ██║ ██║██║╚██╗██║ + ██║ ██║ ██║ ██║ ██║██║ ╚████║ ╚██████╔╝██║ ╚████║ + ╚═╝ ╚═╝ ╚═╝ ╚═╝ ╚═╝╚═╝ ╚═══╝ ╚═════╝ ╚═╝ ╚═══╝ +████████╗██╗ ██╗███████╗ ██╗███╗ ██╗███████╗██╗██████╗ ███████╗ +╚══██╔══╝██║ ██║██╔════╝ ██║████╗ ██║██╔════╝██║██╔══██╗██╔════╝ + ██║ ███████║█████╗ ██║██╔██╗ ██║███████╗██║██║ ██║█████╗ + ██║ ██╔══██║██╔══╝ ██║██║╚██╗██║╚════██║██║██║ ██║██╔══╝ + ██║ ██║ ██║███████╗ ██║██║ ╚████║███████║██║██████╔╝███████╗ + ╚═╝ ╚═╝ ╚═╝╚══════╝ ╚═╝╚═╝ ╚═══╝╚══════╝╚═╝╚═════╝ ╚══════╝ + + ⚡ R Y A N O N T H E I N S I D E ⚡ +Inputs: + Required: + Optional: +Outputs: +-------------------------------------------------- +Node: ShellAgentOutputText: + TYPE_STR = "text" + @classmethod + def INPUT_TYPES +Category: shellagent +Inputs: + Required: + - s.TYPE_STR: STRING, {"tooltip": f"The {s.TYPE_STR} to output."} + - output_name: STRING, {"multiline": False, default": f"output_{s.TYPE_STR}"} + Optional: +Outputs: +-------------------------------------------------- +Node: ShellAgentOutputFloat +Category: Unknown +Inputs: + Required: + - s.TYPE_STR: FLOAT, {"tooltip": f"The {s.TYPE_STR} to output."} + - output_name: STRING, {"multiline": False, default": f"output_{s.TYPE_STR}"} + Optional: +Outputs: +-------------------------------------------------- +Node: ShellAgentOutputInteger +Category: Unknown +Inputs: + Required: + - s.TYPE_STR: INT, {"tooltip": f"The {s.TYPE_STR} to output."} + - output_name: STRING, {"multiline": False, default": f"output_{s.TYPE_STR}"} + Optional: +Outputs: +-------------------------------------------------- +Node: ShellAgentOutputBoolean +Category: Unknown +Inputs: + Required: + - s.TYPE_STR: BOOLEAN, {"tooltip": f"The {s.TYPE_STR} to output."} + - output_name: STRING, {"multiline": False, default": f"output_{s.TYPE_STR}"} + Optional: +Outputs: +-------------------------------------------------- +Node: ShellAgentSaveImages +Category: shellagent +Inputs: + Required: + - images: IMAGE, {"tooltip": "The images to save."} + - output_name: STRING, {"multiline": False, default": "output_image"} + - filename_prefix: STRING, {"default": "ComfyUI, tooltip": "The prefix for the file to save. This may include formatting information such as %date:yyyy-MM-dd% or %Empty Latent Image.width% to include values from nodes."} + Optional: +Outputs: +-------------------------------------------------- +Node: ShellAgentSaveImage +Category: Unknown +Inputs: + Required: + Optional: +Outputs: +-------------------------------------------------- +Node: ShellAgentSaveVideoVHS: + @classmethod + def INPUT_TYPES +Category: shellagent +Inputs: + Required: + - filenames: VHS_FILENAMES, {"tooltip": "The filenames to save."} + - output_name: STRING, {"multiline": False, default": "output_video"} + Optional: +Outputs: +-------------------------------------------------- +Node: ShellAgentPluginInputText: + @classmethod + def INPUT_TYPES +Category: shellagent +Inputs: + Required: + - {"multiline: False + Optional: + - {"multiline: False +Outputs: + - text (STRING) +-------------------------------------------------- +Node: ShellAgentPluginInputFloat: + @classmethod + def INPUT_TYPES +Category: shellagent +Inputs: + Required: + - {"multiline: False + Optional: + - {"default: } + - {"multiline: False +Outputs: + - float (FLOAT) +-------------------------------------------------- +Node: ShellAgentPluginInputInteger: + @classmethod + def INPUT_TYPES +Category: shellagent +Inputs: + Required: + - {"multiline: False + Optional: + - {"default: 1 + - {"multiline: False +Outputs: + - int (INT) +-------------------------------------------------- +Node: ShellAgentPluginInputBoolean: + @classmethod + def INPUT_TYPES +Category: shellagent +Inputs: + Required: + - {"multiline: False + Optional: + - {"default: False} + - {"multiline: True +Outputs: + - boolean (BOOLEAN) +-------------------------------------------------- +Node: ShellAgentPluginInputImage: + @classmethod + def INPUT_TYPES +Category: shellagent +Inputs: + Required: + - {"multiline: False + - sorted(files), {"image_upload: files + Optional: + - {"multiline: False +Outputs: + - image (IMAGE) +-------------------------------------------------- +Node: ShellAgentPluginInputVideo: +# @classmethod +# def INPUT_TYPES +Category: shellagent +Inputs: + Required: + - # {"multiline: False + - # "STRING", {"video_upload: files + Optional: + - # {"multiline: True +Outputs: + - video (STRING) +-------------------------------------------------- +Node: ShellAgentPluginInputImage: +# @classmethod +# def INPUT_TYPES +Category: shellagent +Inputs: + Required: + - # {"multiline: False + - # "STRING", {"image_upload: files + Optional: + - # {"multiline: True +Outputs: + - image (IMAGE) +-------------------------------------------------- +Node: ShellAgentPluginInputVideo: + @classmethod + def INPUT_TYPES +Category: shellagent +Inputs: + Required: + - {"multiline: False + - { "video_upload: True } + - # "STRING", {"video_upload: files + Optional: + - {"multiline: True +Outputs: + - video (STRING) +-------------------------------------------------- +Node: ShellAgentPluginInputAudio: + @classmethod + def INPUT_TYPES +Category: shellagent +Inputs: + Required: + - {"multiline: False + - sorted(files), {"audio_upload: files + Optional: + - {"multiline: True +Outputs: + - AUDIO +-------------------------------------------------- +Node: ShellAgentSaveAudios +Category: shellagent +Inputs: + Required: + - {"audio: AUDIO + - output_name: STRING, {"multiline": False, default": "output_audio"} + - filename_prefix: STRING, {"default": "audio/ComfyUI"} + Optional: +Outputs: +-------------------------------------------------- +Node: ShellAgentSaveAudio +Category: Unknown +Inputs: + Required: + Optional: +Outputs: +-------------------------------------------------- \ No newline at end of file