Upload folder using huggingface_hub

app.py

@@ -106,6 +106,13 @@ def main():
 
     check_all_model_urls_on_startup()
     
+    print("--- Building ControlNet preprocessor maps ---")
+    from core.generation_logic import build_reverse_map
+    build_reverse_map()
+    build_preprocessor_model_map()
+    build_preprocessor_parameter_map()
+    print("--- ✅ ControlNet preprocessor setup complete. ---")
+
     print("--- Environment configured. Proceeding with module imports. ---")
     from ui.layout import build_ui
     from ui.events import attach_event_handlers

chain_injectors/diffsynth_controlnet_injector.py

@@ -0,0 +1,75 @@
+def inject(assembler, chain_definition, chain_items):
+    if not chain_items:
+        return
+
+    model_sampler_name = chain_definition.get('model_sampler_node')
+    ksampler_name = chain_definition.get('ksampler_node', 'ksampler')
+    
+    target_node_id = None
+    target_input_name = 'model'
+    
+    if model_sampler_name and model_sampler_name in assembler.node_map:
+        model_sampler_id = assembler.node_map[model_sampler_name]
+        if target_input_name in assembler.workflow[model_sampler_id]['inputs']:
+            target_node_id = model_sampler_id
+            print(f"ControlNet Model Patch injector targeting ModelSamplingAuraFlow node '{model_sampler_name}'.")
+
+    if not target_node_id:
+        if ksampler_name in assembler.node_map:
+            ksampler_id = assembler.node_map[ksampler_name]
+            if target_input_name in assembler.workflow[ksampler_id]['inputs']:
+                target_node_id = ksampler_id
+                print(f"ControlNet Model Patch injector targeting KSampler node '{ksampler_name}'.")
+        else:
+            print(f"Warning: Neither ModelSamplingAuraFlow node '{model_sampler_name}' nor KSampler node '{ksampler_name}' found for ControlNet patch chain. Skipping.")
+            return
+            
+    if not target_node_id:
+        print(f"Warning: Could not find a valid 'model' input on target nodes. Skipping ControlNet patch chain.")
+        return
+
+    current_model_connection = assembler.workflow[target_node_id]['inputs'][target_input_name]
+    
+    vae_source_str = chain_definition.get('vae_source')
+    vae_connection = None
+    if vae_source_str:
+        try:
+            vae_node_name, vae_idx_str = vae_source_str.split(':')
+            if vae_node_name in assembler.node_map:
+                vae_connection = [assembler.node_map[vae_node_name], int(vae_idx_str)]
+            else:
+                print(f"Warning: VAE source node '{vae_node_name}' not found for ControlNet patch chain. VAE will not be connected.")
+        except ValueError:
+            print(f"Warning: Invalid 'vae_source' format '{vae_source_str}' for ControlNet patch chain. Expected 'node_name:index'. VAE will not be connected.")
+    else:
+        print(f"Warning: 'vae_source' not defined for ControlNet patch chain definition. VAE may not be connected.")
+
+    for item_data in chain_items:
+        patch_loader_id = assembler._get_unique_id()
+        patch_loader_node = assembler._get_node_template("ModelPatchLoader")
+        patch_loader_node['inputs']['name'] = item_data['control_net_name']
+        assembler.workflow[patch_loader_id] = patch_loader_node
+
+        image_loader_id = assembler._get_unique_id()
+        image_loader_node = assembler._get_node_template("LoadImage")
+        image_loader_node['inputs']['image'] = item_data['image']
+        assembler.workflow[image_loader_id] = image_loader_node
+
+        apply_cn_id = assembler._get_unique_id()
+        apply_cn_node = assembler._get_node_template(chain_definition['template'])
+        
+        apply_cn_node['inputs']['strength'] = item_data.get('strength', 1.0)
+        apply_cn_node['inputs']['model'] = current_model_connection
+        apply_cn_node['inputs']['model_patch'] = [patch_loader_id, 0]
+        apply_cn_node['inputs']['image'] = [image_loader_id, 0]
+        
+        if 'vae' in apply_cn_node['inputs'] and vae_connection:
+            apply_cn_node['inputs']['vae'] = vae_connection
+        
+        assembler.workflow[apply_cn_id] = apply_cn_node
+
+        current_model_connection = [apply_cn_id, 0]
+
+    assembler.workflow[target_node_id]['inputs'][target_input_name] = current_model_connection
+    
+    print(f"ControlNet Model Patch injector applied. Target 'model' input re-routed through {len(chain_items)} patch(es).")

comfy_integration/setup.py

@@ -39,6 +39,14 @@ def initialize_comfyui():
     except OSError as e:
         print(f"⚠️ Could not remove temporary directory '{COMFYUI_TEMP_DIR}': {e}")
 
+    print("--- Cloning third-party extensions for ComfyUI ---")
+    controlnet_aux_path = os.path.join(APP_DIR, "custom_nodes", "comfyui_controlnet_aux")
+    if not os.path.exists(controlnet_aux_path):
+        os.system(f"git clone https://github.com/Fannovel16/comfyui_controlnet_aux.git {controlnet_aux_path}")
+        print("✅ comfyui_controlnet_aux extension cloned.")
+    else:
+        print("✅ comfyui_controlnet_aux extension already exists.")
+
 
     print(f"✅ Current working directory is: {os.getcwd()}")
     
@@ -51,6 +59,7 @@ def initialize_comfyui():
     os.makedirs(os.path.join(APP_DIR, LORA_DIR), exist_ok=True)
     os.makedirs(os.path.join(APP_DIR, EMBEDDING_DIR), exist_ok=True)
     os.makedirs(os.path.join(APP_DIR, CONTROLNET_DIR), exist_ok=True)
+    os.makedirs(os.path.join(APP_DIR, MODEL_PATCHES_DIR), exist_ok=True)
     os.makedirs(os.path.join(APP_DIR, DIFFUSION_MODELS_DIR), exist_ok=True)
     os.makedirs(os.path.join(APP_DIR, VAE_DIR), exist_ok=True)
     os.makedirs(os.path.join(APP_DIR, TEXT_ENCODERS_DIR), exist_ok=True)

core/generation_logic.py

@@ -1,8 +1,10 @@
 from typing import Any, Dict
 import gradio as gr
 
+from core.pipelines.controlnet_preprocessor import ControlNetPreprocessorPipeline
 from core.pipelines.sd_image_pipeline import SdImagePipeline
 
+controlnet_preprocessor_pipeline = ControlNetPreprocessorPipeline()
 sd_image_pipeline = SdImagePipeline()
 
 
@@ -16,5 +18,8 @@ def build_reverse_map():
              cn_module.REVERSE_DISPLAY_NAME_MAP["Semantic Segmentor (legacy, alias for UniFormer)"] = "SemSegPreprocessor"
 
 
+def run_cn_preprocessor_entry(*args, **kwargs):
+    return controlnet_preprocessor_pipeline.run(*args, **kwargs)
+
 def generate_image_wrapper(ui_inputs: dict, progress=gr.Progress(track_tqdm=True)):
     return sd_image_pipeline.run(ui_inputs=ui_inputs, progress=progress)

core/pipelines/controlnet_preprocessor.py

@@ -0,0 +1,143 @@
+from typing import Dict, Any, List
+import imageio
+import tempfile
+import numpy as np
+import torch
+import gradio as gr
+from PIL import Image
+import spaces
+
+from .base_pipeline import BasePipeline
+from comfy_integration.nodes import NODE_CLASS_MAPPINGS
+from nodes import NODE_DISPLAY_NAME_MAPPINGS
+from utils.app_utils import get_value_at_index
+
+REVERSE_DISPLAY_NAME_MAP = None
+CPU_ONLY_PREPROCESSORS = {
+    "Binary Lines", "Canny Edge", "Color Pallete", "Fake Scribble Lines (aka scribble_hed)",
+    "Image Intensity", "Image Luminance", "Inpaint Preprocessor", "PyraCanny", "Scribble Lines",
+    "Scribble XDoG Lines", "Standard Lineart", "Content Shuffle", "Tile"
+}
+
+def run_node_by_function_name(node_instance: Any, **kwargs) -> Any:
+    node_class = type(node_instance)
+    function_name = getattr(node_class, 'FUNCTION', None)
+    if not function_name:
+        raise AttributeError(f"Node class '{node_class.__name__}' is missing the required 'FUNCTION' attribute.")
+    execution_method = getattr(node_instance, function_name, None)
+    if not callable(execution_method):
+        raise AttributeError(f"Method '{function_name}' not found or not callable on node '{node_class.__name__}'.")
+    return execution_method(**kwargs)
+
+class ControlNetPreprocessorPipeline(BasePipeline):
+    def get_required_models(self, **kwargs) -> List[str]:
+        return []
+
+    def _gpu_logic(
+        self, pil_images: List[Image.Image], preprocessor_name: str, model_name: str,
+        params: Dict[str, Any], progress=gr.Progress(track_tqdm=True)
+    ) -> List[Image.Image]:
+        global REVERSE_DISPLAY_NAME_MAP
+        if REVERSE_DISPLAY_NAME_MAP is None:
+            raise RuntimeError("REVERSE_DISPLAY_NAME_MAP has not been initialized. `build_reverse_map` must be called on startup.")
+            
+        class_name = REVERSE_DISPLAY_NAME_MAP.get(preprocessor_name)
+        if not class_name or class_name not in NODE_CLASS_MAPPINGS:
+            raise ValueError(f"Preprocessor '{preprocessor_name}' not found.")
+            
+        preprocessor_instance = NODE_CLASS_MAPPINGS[class_name]()
+        call_args = {**params, 'ckpt_name': model_name}
+        
+        processed_pil_images = []
+        total_frames = len(pil_images)
+
+        for i, frame_pil in enumerate(pil_images):
+            progress(i / total_frames, desc=f"Processing frame {i+1}/{total_frames} with {preprocessor_name}...")
+            
+            frame_tensor = torch.from_numpy(np.array(frame_pil).astype(np.float32) / 255.0).unsqueeze(0)
+            
+            resolution_arg = {'resolution': max(frame_tensor.shape[2], frame_tensor.shape[3])}
+
+            result_tuple = run_node_by_function_name(
+                preprocessor_instance, 
+                image=frame_tensor, 
+                **resolution_arg,
+                **call_args
+            )
+            
+            processed_tensor = get_value_at_index(result_tuple, 0)
+            processed_np = (processed_tensor.squeeze(0).cpu().numpy().clip(0, 1) * 255.0).astype(np.uint8)
+            processed_pil_images.append(Image.fromarray(processed_np))
+            
+        return processed_pil_images
+
+    def run(self, input_type, image_input, video_input, preprocessor_name, model_name, zero_gpu_duration, *args, progress=gr.Progress(track_tqdm=True)):
+        from utils import app_utils
+        pil_images, is_video, fps = [], False, 30
+        
+        progress(0, desc="Reading input file...")
+        if input_type == "Image":
+            if image_input is None: raise gr.Error("Please provide an input image.")
+            pil_images = [image_input]
+        elif input_type == "Video":
+            if video_input is None: raise gr.Error("Please provide an input video.")
+            try:
+                video_reader = imageio.get_reader(video_input)
+                meta = video_reader.get_meta_data()
+                fps = meta.get('fps', 30)
+                pil_images = [Image.fromarray(frame) for frame in video_reader]
+                is_video = True
+                video_reader.close()
+            except Exception as e: raise gr.Error(f"Failed to read video file: {e}")
+        else:
+            raise gr.Error("Invalid input type selected.")
+
+        if not pil_images: raise gr.Error("Could not extract any frames from the input.")
+        
+        if app_utils.PREPROCESSOR_PARAMETER_MAP is None:
+            raise RuntimeError("Preprocessor parameter map is not built. Check startup logs.")
+            
+        params_config = app_utils.PREPROCESSOR_PARAMETER_MAP.get(preprocessor_name, [])
+        sliders_params = [p for p in params_config if p['type'] in ["INT", "FLOAT"]]
+        dropdown_params = [p for p in params_config if isinstance(p['type'], list)]
+        checkbox_params = [p for p in params_config if p['type'] == "BOOLEAN"]
+        ordered_params_config = sliders_params + dropdown_params + checkbox_params
+        param_names = [p['name'] for p in ordered_params_config]
+        provided_params = {param_names[i]: args[i] for i in range(len(param_names))}
+        
+        if preprocessor_name not in CPU_ONLY_PREPROCESSORS:
+            print(f"--- '{preprocessor_name}' requires GPU, requesting ZeroGPU. ---")
+            try:
+                processed_pil_images = self._execute_gpu_logic(
+                    self._gpu_logic,
+                    duration=zero_gpu_duration,
+                    default_duration=60,
+                    task_name=f"Preprocessor '{preprocessor_name}'",
+                    pil_images=pil_images,
+                    preprocessor_name=preprocessor_name,
+                    model_name=model_name,
+                    params=provided_params,
+                    progress=progress
+                )
+            except Exception as e:
+                import traceback; traceback.print_exc()
+                raise gr.Error(f"Failed to run preprocessor '{preprocessor_name}' on GPU: {e}")
+        else:
+            print(f"--- Running '{preprocessor_name}' on CPU, no ZeroGPU requested. ---")
+            try:
+                processed_pil_images = self._gpu_logic(pil_images, preprocessor_name, model_name, provided_params, progress=progress)
+            except Exception as e:
+                import traceback; traceback.print_exc()
+                raise gr.Error(f"Failed to run preprocessor '{preprocessor_name}' on CPU: {e}")
+
+        if not processed_pil_images: raise gr.Error("Processing returned no frames.")
+        
+        progress(0.9, desc="Finalizing output...")
+        if is_video:
+            frames_np = [np.array(img) for img in processed_pil_images]
+            frames_tensor = torch.from_numpy(np.stack(frames_np)).to(torch.float32) / 255.0
+            video_path = self._encode_video_from_frames(frames_tensor, fps, progress)
+            return [video_path]
+        else:
+            progress(1.0, desc="Done!")
+            return processed_pil_images

core/pipelines/sd_image_pipeline.py

@@ -289,6 +289,23 @@ class SdImagePipeline(BasePipeline):
                     "start_percent": 0.0, "end_percent": 1.0, "control_net_name": cn_filepaths[i]
                 })
         
+        diffsynth_controlnet_data = ui_inputs.get('diffsynth_controlnet_data', [])
+        active_diffsynth_controlnets = []
+        if diffsynth_controlnet_data:
+            (cn_images, _, _, cn_strengths, cn_filepaths) = [diffsynth_controlnet_data[i::5] for i in range(5)]
+            for i in range(len(cn_images)):
+                if cn_images[i] and cn_strengths[i] > 0 and cn_filepaths[i] and cn_filepaths[i] != "None":
+                    ensure_controlnet_model_downloaded(cn_filepaths[i], progress)
+
+                    if not os.path.exists(INPUT_DIR): os.makedirs(INPUT_DIR)
+                    cn_temp_path = os.path.join(INPUT_DIR, f"temp_diffsynth_cn_{i}_{random.randint(1000, 9999)}.png")
+                    cn_images[i].save(cn_temp_path, "PNG")
+                    temp_files_to_clean.append(cn_temp_path)
+                    active_diffsynth_controlnets.append({
+                        "image": os.path.basename(cn_temp_path), "strength": cn_strengths[i],
+                        "control_net_name": cn_filepaths[i]
+                    })
+
         from utils.app_utils import get_vae_path
         vae_source = ui_inputs.get('vae_source')
         vae_id = ui_inputs.get('vae_id')
@@ -362,6 +379,7 @@ class SdImagePipeline(BasePipeline):
             "clip_name": components['clip'],
             "vae_name": ui_inputs.get('vae_name', components['vae']),
             "controlnet_chain": active_controlnets,
+            "diffsynth_controlnet_chain": active_diffsynth_controlnets,
             "conditioning_chain": active_conditioning,
         }
         

core/pipelines/workflow_recipes/_partials/conditioning/z-image.yaml

@@ -45,10 +45,12 @@ connections:
   - from: "vae_loader:0"
     to: "vae_encode:vae"
 
-dynamic_controlnet_chains:
-  controlnet_chain:
-    template: "ControlNetApplyAdvanced"
+dynamic_diffsynth_controlnet_chains:
+  diffsynth_controlnet_chain:
+    template: "QwenImageDiffsynthControlnet"
+    model_sampler_node: "model_sampler"
     ksampler_node: "ksampler"
+    vae_source: "vae_loader:0"
 
 dynamic_conditioning_chains:
   conditioning_chain:

core/settings.py

@@ -6,6 +6,7 @@ CHECKPOINT_DIR = "models/checkpoints"
 LORA_DIR = "models/loras"
 EMBEDDING_DIR = "models/embeddings" 
 CONTROLNET_DIR = "models/controlnet"
+MODEL_PATCHES_DIR = "models/model_patches"
 DIFFUSION_MODELS_DIR = "models/diffusion_models"
 VAE_DIR = "models/vae"
 TEXT_ENCODERS_DIR = "models/text_encoders"

ui/events.py

@@ -8,7 +8,8 @@ from utils.app_utils import *
 from core.generation_logic import *
 from comfy_integration.nodes import SAMPLER_CHOICES, SCHEDULER_CHOICES
 
-from utils.app_utils import save_uploaded_file_with_hash
+from core.pipelines.controlnet_preprocessor import CPU_ONLY_PREPROCESSORS
+from utils.app_utils import PREPROCESSOR_MODEL_MAP, PREPROCESSOR_PARAMETER_MAP, save_uploaded_file_with_hash
 from ui.shared.ui_components import RESOLUTION_MAP, MAX_CONTROLNETS, MAX_EMBEDDINGS, MAX_CONDITIONINGS, MAX_LORAS
 
 
@@ -26,8 +27,131 @@ def load_controlnet_config():
         print(f"Error loading controlnet_models.yaml: {e}")
         return []
 
+@lru_cache(maxsize=1)
+def load_diffsynth_controlnet_config():
+    _PROJECT_ROOT = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+    _CN_MODEL_LIST_PATH = os.path.join(_PROJECT_ROOT, 'yaml', 'diffsynth_controlnet_models.yaml')
+    try:
+        print("--- Loading diffsynth_controlnet_models.yaml ---")
+        with open(_CN_MODEL_LIST_PATH, 'r', encoding='utf-8') as f:
+            config = yaml.safe_load(f)
+        print("--- ✅ diffsynth_controlnet_models.yaml loaded successfully ---")
+        return config.get("DiffSynth_ControlNet", {}).get("Z-Image", [])
+    except Exception as e:
+        print(f"Error loading diffsynth_controlnet_models.yaml: {e}")
+        return []
+
 
 def attach_event_handlers(ui_components, demo):
+    def update_cn_input_visibility(choice):
+        return {
+            ui_components["cn_image_input"]: gr.update(visible=choice == "Image"),
+            ui_components["cn_video_input"]: gr.update(visible=choice == "Video")
+        }
+    ui_components["cn_input_type"].change(
+        fn=update_cn_input_visibility,
+        inputs=[ui_components["cn_input_type"]],
+        outputs=[ui_components["cn_image_input"], ui_components["cn_video_input"]]
+    )
+    
+    def update_preprocessor_models_dropdown(preprocessor_name):
+        models = PREPROCESSOR_MODEL_MAP.get(preprocessor_name)
+        if models:
+            model_filenames = [m[1] for m in models]
+            return gr.update(choices=model_filenames, value=model_filenames[0], visible=True)
+        else:
+            return gr.update(choices=[], value=None, visible=False)
+
+    def update_preprocessor_settings_ui(preprocessor_name):
+        from ui.layout import MAX_DYNAMIC_CONTROLS
+        params = PREPROCESSOR_PARAMETER_MAP.get(preprocessor_name, [])
+        
+        slider_updates, dropdown_updates, checkbox_updates = [], [], []
+        
+        s_idx, d_idx, c_idx = 0, 0, 0
+
+        for param in params:
+            if s_idx + d_idx + c_idx >= MAX_DYNAMIC_CONTROLS: break
+            
+            name = param["name"]
+            ptype = param["type"]
+            config = param["config"]
+            label = name.replace('_', ' ').title()
+
+            if ptype == "INT" or ptype == "FLOAT":
+                if s_idx < MAX_DYNAMIC_CONTROLS:
+                    slider_updates.append(gr.update(
+                        label=label,
+                        minimum=config.get('min', 0),
+                        maximum=config.get('max', 255),
+                        step=config.get('step', 0.1 if ptype == "FLOAT" else 1),
+                        value=config.get('default', 0),
+                        visible=True
+                    ))
+                    s_idx += 1
+            elif isinstance(ptype, list):
+                if d_idx < MAX_DYNAMIC_CONTROLS:
+                    dropdown_updates.append(gr.update(
+                        label=label,
+                        choices=ptype,
+                        value=config.get('default', ptype[0] if ptype else None),
+                        visible=True
+                    ))
+                    d_idx += 1
+            elif ptype == "BOOLEAN":
+                if c_idx < MAX_DYNAMIC_CONTROLS:
+                    checkbox_updates.append(gr.update(
+                        label=label,
+                        value=config.get('default', False),
+                        visible=True
+                    ))
+                    c_idx += 1
+
+        for _ in range(s_idx, MAX_DYNAMIC_CONTROLS): slider_updates.append(gr.update(visible=False))
+        for _ in range(d_idx, MAX_DYNAMIC_CONTROLS): dropdown_updates.append(gr.update(visible=False))
+        for _ in range(c_idx, MAX_DYNAMIC_CONTROLS): checkbox_updates.append(gr.update(visible=False))
+
+        return slider_updates + dropdown_updates + checkbox_updates
+
+    def update_run_button_for_cpu(preprocessor_name):
+        if preprocessor_name in CPU_ONLY_PREPROCESSORS:
+            return gr.update(value="Run Preprocessor CPU Only", variant="primary"), gr.update(visible=False)
+        else:
+            return gr.update(value="Run Preprocessor", variant="primary"), gr.update(visible=True)
+
+    ui_components["preprocessor_cn"].change(
+        fn=update_preprocessor_models_dropdown,
+        inputs=[ui_components["preprocessor_cn"]],
+        outputs=[ui_components["preprocessor_model_cn"]]
+    ).then(
+        fn=update_preprocessor_settings_ui,
+        inputs=[ui_components["preprocessor_cn"]],
+        outputs=ui_components["cn_sliders"] + ui_components["cn_dropdowns"] + ui_components["cn_checkboxes"]
+    ).then(
+        fn=update_run_button_for_cpu,
+        inputs=[ui_components["preprocessor_cn"]],
+        outputs=[ui_components["run_cn"], ui_components["zero_gpu_cn"]]
+    )
+
+    all_dynamic_inputs = (
+        ui_components["cn_sliders"] + 
+        ui_components["cn_dropdowns"] + 
+        ui_components["cn_checkboxes"]
+    )
+
+    ui_components["run_cn"].click(
+        fn=run_cn_preprocessor_entry,
+        inputs=[
+            ui_components["cn_input_type"],
+            ui_components["cn_image_input"],
+            ui_components["cn_video_input"],
+            ui_components["preprocessor_cn"],
+            ui_components["preprocessor_model_cn"],
+            ui_components["zero_gpu_cn"],
+        ] + all_dynamic_inputs,
+        outputs=[ui_components["output_gallery_cn"]]
+    )
+
     def create_lora_event_handlers(prefix):
         lora_rows = ui_components[f'lora_rows_{prefix}']
         lora_ids = ui_components[f'lora_ids_{prefix}']
@@ -159,6 +283,98 @@ def attach_event_handlers(ui_components, demo):
             show_progress=False
         )
 
+    def create_diffsynth_controlnet_event_handlers(prefix):
+        cn_rows = ui_components[f'diffsynth_controlnet_rows_{prefix}']
+        cn_types = ui_components[f'diffsynth_controlnet_types_{prefix}']
+        cn_series = ui_components[f'diffsynth_controlnet_series_{prefix}']
+        cn_filepaths = ui_components[f'diffsynth_controlnet_filepaths_{prefix}']
+        cn_images = ui_components[f'diffsynth_controlnet_images_{prefix}']
+        cn_strengths = ui_components[f'diffsynth_controlnet_strengths_{prefix}']
+        
+        count_state = ui_components[f'diffsynth_controlnet_count_state_{prefix}']
+        add_button = ui_components[f'add_diffsynth_controlnet_button_{prefix}']
+        del_button = ui_components[f'delete_diffsynth_controlnet_button_{prefix}']
+        accordion = ui_components[f'diffsynth_controlnet_accordion_{prefix}']
+
+        def add_cn_row(c):
+            c += 1
+            updates = {
+                count_state: c,
+                cn_rows[c-1]: gr.update(visible=True),
+                add_button: gr.update(visible=c < MAX_CONTROLNETS),
+                del_button: gr.update(visible=True)
+            }
+            return updates
+
+        def del_cn_row(c):
+            c -= 1
+            updates = {
+                count_state: c,
+                cn_rows[c]: gr.update(visible=False),
+                cn_images[c]: None,
+                cn_strengths[c]: 1.0,
+                add_button: gr.update(visible=True),
+                del_button: gr.update(visible=c > 0)
+            }
+            return updates
+            
+        add_outputs = [count_state, add_button, del_button] + cn_rows
+        del_outputs = [count_state, add_button, del_button] + cn_rows + cn_images + cn_strengths
+        add_button.click(fn=add_cn_row, inputs=[count_state], outputs=add_outputs, show_progress=False)
+        del_button.click(fn=del_cn_row, inputs=[count_state], outputs=del_outputs, show_progress=False)
+        
+        def on_cn_type_change(selected_type):
+            cn_config = load_diffsynth_controlnet_config()
+            series_choices = []
+            if selected_type:
+                series_choices = sorted(list(set(
+                    model.get("Series", "Default") for model in cn_config
+                    if selected_type in model.get("Type", [])
+                )))
+            default_series = series_choices[0] if series_choices else None
+            filepath = "None"
+            if default_series:
+                for model in cn_config:
+                    if model.get("Series") == default_series and selected_type in model.get("Type", []):
+                        filepath = model.get("Filepath")
+                        break
+            return gr.update(choices=series_choices, value=default_series), filepath
+
+        def on_cn_series_change(selected_series, selected_type):
+            cn_config = load_diffsynth_controlnet_config()
+            filepath = "None"
+            if selected_series and selected_type:
+                for model in cn_config:
+                    if model.get("Series") == selected_series and selected_type in model.get("Type", []):
+                        filepath = model.get("Filepath")
+                        break
+            return filepath
+            
+        for i in range(MAX_CONTROLNETS):
+            cn_types[i].change(
+                fn=on_cn_type_change,
+                inputs=[cn_types[i]],
+                outputs=[cn_series[i], cn_filepaths[i]],
+                show_progress=False
+            )
+            cn_series[i].change(
+                fn=on_cn_series_change,
+                inputs=[cn_series[i], cn_types[i]],
+                outputs=[cn_filepaths[i]],
+                show_progress=False
+            )
+
+        def on_accordion_expand(*images):
+            return [gr.update() for _ in images]
+        
+        accordion.expand(
+            fn=on_accordion_expand,
+            inputs=cn_images,
+            outputs=cn_images,
+            show_progress=False
+        )
+
+
     def create_embedding_event_handlers(prefix):
         rows = ui_components[f'embedding_rows_{prefix}']
         ids = ui_components[f'embeddings_ids_{prefix}']
@@ -277,6 +493,7 @@ def attach_event_handlers(ui_components, demo):
         
         lora_data_components = ui_components.get(f'all_lora_components_flat_{prefix}', [])
         controlnet_data_components = ui_components.get(f'all_controlnet_components_flat_{prefix}', [])
+        diffsynth_controlnet_data_components = ui_components.get(f'all_diffsynth_controlnet_components_flat_{prefix}', [])
         embedding_data_components = ui_components.get(f'all_embedding_components_flat_{prefix}', [])
         conditioning_data_components = ui_components.get(f'all_conditioning_components_flat_{prefix}', [])
         
@@ -286,7 +503,7 @@ def attach_event_handlers(ui_components, demo):
 
         input_keys = list(run_inputs_map.keys())
         input_list_flat = [v for v in run_inputs_map.values() if v is not None]
-        input_list_flat += lora_data_components + controlnet_data_components + embedding_data_components + conditioning_data_components
+        input_list_flat += lora_data_components + controlnet_data_components + diffsynth_controlnet_data_components + embedding_data_components + conditioning_data_components
 
         def create_ui_inputs_dict(*args):
             valid_keys = [k for k in input_keys if run_inputs_map[k] is not None]
@@ -297,6 +514,8 @@ def attach_event_handlers(ui_components, demo):
             arg_idx += len(lora_data_components)
             ui_dict['controlnet_data'] = list(args[arg_idx : arg_idx + len(controlnet_data_components)])
             arg_idx += len(controlnet_data_components)
+            ui_dict['diffsynth_controlnet_data'] = list(args[arg_idx : arg_idx + len(diffsynth_controlnet_data_components)])
+            arg_idx += len(diffsynth_controlnet_data_components)
             ui_dict['embedding_data'] = list(args[arg_idx : arg_idx + len(embedding_data_components)])
             arg_idx += len(embedding_data_components)
             ui_dict['conditioning_data'] = list(args[arg_idx : arg_idx + len(conditioning_data_components)])
@@ -327,6 +546,7 @@ def attach_event_handlers(ui_components, demo):
                     show_progress=False
                 )
         if f'add_controlnet_button_{prefix}' in ui_components: create_controlnet_event_handlers(prefix)
+        if f'add_diffsynth_controlnet_button_{prefix}' in ui_components: create_diffsynth_controlnet_event_handlers(prefix)
         if f'add_embedding_button_{prefix}' in ui_components: 
             create_embedding_event_handlers(prefix)
             if f'embeddings_uploads_{prefix}' in ui_components:
@@ -392,38 +612,70 @@ def attach_event_handlers(ui_components, demo):
         ui_components['view_mode_inpaint'].change(fn=toggle_inpaint_fullscreen_view, inputs=[ui_components['view_mode_inpaint']], outputs=output_components, show_progress=False)
 
     def initialize_all_cn_dropdowns():
+        # Standard ControlNet
         cn_config = load_controlnet_config()
-        if not cn_config: return {}
-
-        all_types = sorted(list(set(t for model in cn_config for t in model.get("Type", []))))
-        default_type = all_types[0] if all_types else None
-        
-        series_choices = []
-        if default_type:
-            series_choices = sorted(list(set(model.get("Series", "Default") for model in cn_config if default_type in model.get("Type", []))))
-        default_series = series_choices[0] if series_choices else None
+        cn_updates = {}
+        if cn_config:
+            all_types = sorted(list(set(t for model in cn_config for t in model.get("Type", []))))
+            default_type = all_types[0] if all_types else None
+            series_choices = []
+            if default_type:
+                series_choices = sorted(list(set(model.get("Series", "Default") for model in cn_config if default_type in model.get("Type", []))))
+            default_series = series_choices[0] if series_choices else None
+            filepath = "None"
+            if default_series and default_type:
+                for model in cn_config:
+                    if model.get("Series") == default_series and default_type in model.get("Type", []):
+                        filepath = model.get("Filepath")
+                        break
+            for prefix in ["txt2img", "img2img", "inpaint", "outpaint", "hires_fix"]:
+                if f'controlnet_types_{prefix}' in ui_components:
+                    for type_dd in ui_components[f'controlnet_types_{prefix}']: cn_updates[type_dd] = gr.update(choices=all_types, value=default_type)
+                    for series_dd in ui_components[f'controlnet_series_{prefix}']: cn_updates[series_dd] = gr.update(choices=series_choices, value=default_series)
+                    for filepath_state in ui_components[f'controlnet_filepaths_{prefix}']: cn_updates[filepath_state] = filepath
         
-        filepath = "None"
-        if default_series and default_type:
-            for model in cn_config:
-                if model.get("Series") == default_series and default_type in model.get("Type", []):
-                    filepath = model.get("Filepath")
-                    break
-
-        updates = {}
-        for prefix in ["txt2img", "img2img", "inpaint", "outpaint", "hires_fix"]:
-            if f'controlnet_types_{prefix}' in ui_components:
-                for type_dd in ui_components[f'controlnet_types_{prefix}']:
-                    updates[type_dd] = gr.update(choices=all_types, value=default_type)
-                for series_dd in ui_components[f'controlnet_series_{prefix}']:
-                    updates[series_dd] = gr.update(choices=series_choices, value=default_series)
-                for filepath_state in ui_components[f'controlnet_filepaths_{prefix}']:
-                    updates[filepath_state] = filepath
-        return updates
+        # DiffSynth ControlNet
+        diffsynth_cn_config = load_diffsynth_controlnet_config()
+        diffsynth_updates = {}
+        if diffsynth_cn_config:
+            all_types = sorted(list(set(t for model in diffsynth_cn_config for t in model.get("Type", []))))
+            default_type = all_types[0] if all_types else None
+            series_choices = []
+            if default_type:
+                series_choices = sorted(list(set(model.get("Series", "Default") for model in diffsynth_cn_config if default_type in model.get("Type", []))))
+            default_series = series_choices[0] if series_choices else None
+            filepath = "None"
+            if default_series and default_type:
+                for model in diffsynth_cn_config:
+                    if model.get("Series") == default_series and default_type in model.get("Type", []):
+                        filepath = model.get("Filepath")
+                        break
+            for prefix in ["txt2img", "img2img", "inpaint", "outpaint", "hires_fix"]:
+                if f'diffsynth_controlnet_types_{prefix}' in ui_components:
+                    for type_dd in ui_components[f'diffsynth_controlnet_types_{prefix}']: diffsynth_updates[type_dd] = gr.update(choices=all_types, value=default_type)
+                    for series_dd in ui_components[f'diffsynth_controlnet_series_{prefix}']: diffsynth_updates[series_dd] = gr.update(choices=series_choices, value=default_series)
+                    for filepath_state in ui_components[f'diffsynth_controlnet_filepaths_{prefix}']: diffsynth_updates[filepath_state] = filepath
+
+        return {**cn_updates, **diffsynth_updates}
+
 
     def run_on_load():
-        cn_updates = initialize_all_cn_dropdowns()
-        return cn_updates
+        all_updates = initialize_all_cn_dropdowns()
+        
+        default_preprocessor = "Canny Edge" 
+        model_update = update_preprocessor_models_dropdown(default_preprocessor)
+        all_updates[ui_components["preprocessor_model_cn"]] = model_update
+        
+        settings_outputs = update_preprocessor_settings_ui(default_preprocessor)
+        dynamic_outputs = ui_components["cn_sliders"] + ui_components["cn_dropdowns"] + ui_components["cn_checkboxes"]
+        for i, comp in enumerate(dynamic_outputs):
+            all_updates[comp] = settings_outputs[i]
+
+        run_button_update, zero_gpu_update = update_run_button_for_cpu(default_preprocessor)
+        all_updates[ui_components["run_cn"]] = run_button_update
+        all_updates[ui_components["zero_gpu_cn"]] = zero_gpu_update
+        
+        return all_updates
     
     all_load_outputs = []
     for prefix in ["txt2img", "img2img", "inpaint", "outpaint", "hires_fix"]:
@@ -431,6 +683,19 @@ def attach_event_handlers(ui_components, demo):
             all_load_outputs.extend(ui_components[f'controlnet_types_{prefix}'])
             all_load_outputs.extend(ui_components[f'controlnet_series_{prefix}'])
             all_load_outputs.extend(ui_components[f'controlnet_filepaths_{prefix}'])
+        if f'diffsynth_controlnet_types_{prefix}' in ui_components:
+            all_load_outputs.extend(ui_components[f'diffsynth_controlnet_types_{prefix}'])
+            all_load_outputs.extend(ui_components[f'diffsynth_controlnet_series_{prefix}'])
+            all_load_outputs.extend(ui_components[f'diffsynth_controlnet_filepaths_{prefix}'])
+
+    all_load_outputs.extend([
+        ui_components["preprocessor_model_cn"],
+        *ui_components["cn_sliders"],
+        *ui_components["cn_dropdowns"],
+        *ui_components["cn_checkboxes"],
+        ui_components["run_cn"],
+        ui_components["zero_gpu_cn"]
+    ])
 
     if all_load_outputs:
         demo.load(

ui/layout.py

@@ -6,6 +6,17 @@ from .shared import txt2img_ui, img2img_ui, inpaint_ui, outpaint_ui, hires_fix_u
 
 MAX_DYNAMIC_CONTROLS = 10
 
+def get_preprocessor_choices():
+    from nodes import NODE_DISPLAY_NAME_MAPPINGS
+    
+    preprocessor_names = [
+        display_name for class_name, display_name in NODE_DISPLAY_NAME_MAPPINGS.items()
+        if "Preprocessor" in class_name or "Segmentor" in class_name or 
+           "Estimator" in class_name or "Detector" in class_name
+    ]
+    return sorted(list(set(preprocessor_names)))
+
+
 def build_ui(event_handler_function):
     ui_components = {}
 
@@ -21,23 +32,56 @@ def build_ui(event_handler_function):
             "[SDXL](https://huggingface.co/spaces/RioShiina/ImageGen-SDXL), "
             "[SD1.5](https://huggingface.co/spaces/RioShiina/ImageGen-SD15)"
         )
-        with gr.Tabs(elem_id="image_gen_tabs") as image_gen_tabs:
-            with gr.TabItem("Txt2Img", id=0):
-                ui_components.update(txt2img_ui.create_ui())
-            
-            with gr.TabItem("Img2Img", id=1):
-                ui_components.update(img2img_ui.create_ui())
+        with gr.Tabs(elem_id="tabs_container") as tabs:
+            with gr.TabItem("Z-Image", id=0):
+                with gr.Tabs(elem_id="image_gen_tabs") as image_gen_tabs:
+                    with gr.TabItem("Txt2Img", id=0):
+                        ui_components.update(txt2img_ui.create_ui())
+                    
+                    with gr.TabItem("Img2Img", id=1):
+                        ui_components.update(img2img_ui.create_ui())
 
-            with gr.TabItem("Inpaint", id=2):
-                ui_components.update(inpaint_ui.create_ui())
+                    with gr.TabItem("Inpaint", id=2):
+                        ui_components.update(inpaint_ui.create_ui())
 
-            with gr.TabItem("Outpaint", id=3):
-                ui_components.update(outpaint_ui.create_ui())
+                    with gr.TabItem("Outpaint", id=3):
+                        ui_components.update(outpaint_ui.create_ui())
 
-            with gr.TabItem("Hires. Fix", id=4):
-                ui_components.update(hires_fix_ui.create_ui())
-        
-        ui_components['image_gen_tabs'] = image_gen_tabs
+                    with gr.TabItem("Hires. Fix", id=4):
+                        ui_components.update(hires_fix_ui.create_ui())
+                
+                ui_components['image_gen_tabs'] = image_gen_tabs
+
+            with gr.TabItem("Controlnet Preprocessors", id=1):
+                gr.Markdown("## ControlNet Auxiliary Preprocessors")
+                gr.Markdown("Powered by [Fannovel16/comfyui_controlnet_aux](https://github.com/Fannovel16/comfyui_controlnet_aux).")
+                gr.Markdown("Upload an image or video to process it with a ControlNet preprocessor.")
+                with gr.Row():
+                    with gr.Column(scale=1):
+                        cn_input_type = gr.Radio(["Image", "Video"], label="Input Type", value="Image")
+                        cn_image_input = gr.Image(type="pil", label="Input Image", visible=True, height=384)
+                        cn_video_input = gr.Video(label="Input Video", visible=False)
+                        preprocessor_cn = gr.Dropdown(label="Preprocessor", choices=get_preprocessor_choices(), value="Canny Edge")
+                        preprocessor_model_cn = gr.Dropdown(label="Preprocessor Model", choices=[], value=None, visible=False)
+                        with gr.Column() as preprocessor_settings_ui:
+                            cn_sliders, cn_dropdowns, cn_checkboxes = [], [], []
+                            for i in range(MAX_DYNAMIC_CONTROLS):
+                                cn_sliders.append(gr.Slider(visible=False, label=f"dyn_slider_{i}"))
+                                cn_dropdowns.append(gr.Dropdown(visible=False, label=f"dyn_dropdown_{i}"))
+                                cn_checkboxes.append(gr.Checkbox(visible=False, label=f"dyn_checkbox_{i}"))
+                        run_cn = gr.Button("Run Preprocessor", variant="primary")
+                    with gr.Column(scale=1):
+                        output_gallery_cn = gr.Gallery(label="Output", show_label=False, object_fit="contain", height=512)
+                        zero_gpu_cn = gr.Number(label="ZeroGPU Duration (s)", value=None, placeholder="Default: 60s, Max: 120s", info="Optional")
+                ui_components.update({
+                    "cn_input_type": cn_input_type, "cn_image_input": cn_image_input, "cn_video_input": cn_video_input,
+                    "preprocessor_cn": preprocessor_cn, "preprocessor_model_cn": preprocessor_model_cn, "run_cn": run_cn,
+                    "zero_gpu_cn": zero_gpu_cn, "output_gallery_cn": output_gallery_cn,
+                    "preprocessor_settings_ui": preprocessor_settings_ui, "cn_sliders": cn_sliders,
+                    "cn_dropdowns": cn_dropdowns, "cn_checkboxes": cn_checkboxes
+                })
+            
+            ui_components["tabs"] = tabs
         
         gr.Markdown("<div style='text-align: center; margin-top: 20px;'>Made by RioShiina with ❤️<br><a href='https://github.com/RioShiina47' target='_blank'>GitHub</a> | <a href='https://huggingface.co/RioShiina' target='_blank'>Hugging Face</a> | <a href='https://civitai.com/user/RioShiina' target='_blank'>Civitai</a></div>")
         

ui/shared/hires_fix_ui.py

@@ -3,7 +3,7 @@ from core.settings import MODEL_MAP_CHECKPOINT
 from comfy_integration.nodes import SAMPLER_CHOICES, SCHEDULER_CHOICES
 from .ui_components import (
     create_lora_settings_ui,
-    create_controlnet_ui, create_embedding_ui,
+    create_controlnet_ui, create_diffsynth_controlnet_ui, create_embedding_ui,
     create_conditioning_ui, create_vae_override_ui, create_api_key_ui
 )
 
@@ -65,6 +65,7 @@ def create_ui():
 
         components.update(create_api_key_ui(prefix))
         components.update(create_lora_settings_ui(prefix))
+        components.update(create_diffsynth_controlnet_ui(prefix))
         # components.update(create_controlnet_ui(prefix))
         # components.update(create_embedding_ui(prefix))
         components.update(create_conditioning_ui(prefix))

ui/shared/img2img_ui.py

@@ -3,7 +3,7 @@ from core.settings import MODEL_MAP_CHECKPOINT
 from comfy_integration.nodes import SAMPLER_CHOICES, SCHEDULER_CHOICES
 from .ui_components import (
     create_lora_settings_ui,
-    create_controlnet_ui, create_embedding_ui,
+    create_controlnet_ui, create_diffsynth_controlnet_ui, create_embedding_ui,
     create_conditioning_ui, create_vae_override_ui, create_api_key_ui
 )
 
@@ -48,6 +48,7 @@ def create_ui():
         
         components.update(create_api_key_ui(prefix))
         components.update(create_lora_settings_ui(prefix))
+        components.update(create_diffsynth_controlnet_ui(prefix))
         # components.update(create_controlnet_ui(prefix))
         # components.update(create_embedding_ui(prefix))
         components.update(create_conditioning_ui(prefix))

ui/shared/inpaint_ui.py

@@ -2,7 +2,7 @@ import gradio as gr
 from core.settings import MODEL_MAP_CHECKPOINT
 from .ui_components import (
     create_base_parameter_ui, create_lora_settings_ui,
-    create_controlnet_ui, create_embedding_ui,
+    create_controlnet_ui, create_diffsynth_controlnet_ui, create_embedding_ui,
     create_conditioning_ui, create_vae_override_ui, create_api_key_ui
 )
 
@@ -71,6 +71,7 @@ def create_ui():
         with gr.Column() as accordion_wrapper:
             components.update(create_api_key_ui(prefix))
             components.update(create_lora_settings_ui(prefix))
+            components.update(create_diffsynth_controlnet_ui(prefix))
             # components.update(create_controlnet_ui(prefix))
             # components.update(create_embedding_ui(prefix))
             components.update(create_conditioning_ui(prefix))

ui/shared/outpaint_ui.py

@@ -3,7 +3,7 @@ from core.settings import MODEL_MAP_CHECKPOINT
 from comfy_integration.nodes import SAMPLER_CHOICES, SCHEDULER_CHOICES
 from .ui_components import (
     create_lora_settings_ui,
-    create_controlnet_ui, create_embedding_ui,
+    create_controlnet_ui, create_diffsynth_controlnet_ui, create_embedding_ui,
     create_conditioning_ui, create_vae_override_ui, create_api_key_ui
 )
 
@@ -59,6 +59,7 @@ def create_ui():
         
         components.update(create_api_key_ui(prefix))
         components.update(create_lora_settings_ui(prefix))
+        components.update(create_diffsynth_controlnet_ui(prefix))
         # components.update(create_controlnet_ui(prefix))
         # components.update(create_embedding_ui(prefix))
         components.update(create_conditioning_ui(prefix))

ui/shared/txt2img_ui.py

@@ -2,7 +2,7 @@ import gradio as gr
 from core.settings import MODEL_MAP_CHECKPOINT
 from .ui_components import (
     create_base_parameter_ui, create_lora_settings_ui,
-    create_controlnet_ui, create_embedding_ui,
+    create_controlnet_ui, create_diffsynth_controlnet_ui, create_embedding_ui,
     create_conditioning_ui, create_vae_override_ui, create_api_key_ui
 )
 
@@ -29,6 +29,7 @@ def create_ui():
         
         components.update(create_api_key_ui(prefix))
         components.update(create_lora_settings_ui(prefix))
+        components.update(create_diffsynth_controlnet_ui(prefix))
         # components.update(create_controlnet_ui(prefix))
         # components.update(create_embedding_ui(prefix))
         components.update(create_conditioning_ui(prefix))

ui/shared/ui_components.py

@@ -137,6 +137,48 @@ def create_controlnet_ui(prefix: str, max_units=MAX_CONTROLNETS):
 
     return components
 
+def create_diffsynth_controlnet_ui(prefix: str, max_units=MAX_CONTROLNETS):
+    components = {}
+    key = lambda name: f"{name}_{prefix}"
+
+    with gr.Accordion("DiffSynth ControlNet Settings", open=False) as accordion:
+        components[key('diffsynth_controlnet_accordion')] = accordion
+        
+        cn_rows, images, series, types, strengths, filepaths = [], [], [], [], [], []
+        components.update({
+            key('diffsynth_controlnet_rows'): cn_rows,
+            key('diffsynth_controlnet_images'): images,
+            key('diffsynth_controlnet_series'): series,
+            key('diffsynth_controlnet_types'): types,
+            key('diffsynth_controlnet_strengths'): strengths,
+            key('diffsynth_controlnet_filepaths'): filepaths
+        })
+        
+        for i in range(max_units):
+            with gr.Row(visible=(i < 1)) as row:
+                with gr.Column(scale=1):
+                    images.append(gr.Image(label=f"Control Image {i+1}", type="pil", sources=["upload"], height=256))
+                with gr.Column(scale=2):
+                    types.append(gr.Dropdown(label="Type", choices=[], interactive=True))
+                    series.append(gr.Dropdown(label="Series", choices=[], interactive=True))
+                    strengths.append(gr.Slider(label="Strength", minimum=0.0, maximum=2.0, step=0.05, value=1.0, interactive=True))
+                    filepaths.append(gr.State(None))
+                cn_rows.append(row)
+
+        with gr.Row():
+            components[key('add_diffsynth_controlnet_button')] = gr.Button("✚ Add DiffSynth ControlNet")
+            components[key('delete_diffsynth_controlnet_button')] = gr.Button("➖ Delete DiffSynth ControlNet", visible=False)
+        components[key('diffsynth_controlnet_count_state')] = gr.State(1)
+        
+        all_cn_components_flat = []
+        for i in range(max_units):
+            all_cn_components_flat.extend([
+                images[i], types[i], series[i], strengths[i], filepaths[i]
+            ])
+        components[key('all_diffsynth_controlnet_components_flat')] = all_cn_components_flat
+
+    return components
+
 def create_embedding_ui(prefix: str):
     components = {}
     key = lambda name: f"{name}_{prefix}"

utils/app_utils.py

@@ -313,6 +313,7 @@ def _ensure_model_downloaded(filename: str, progress=gr.Progress()):
         "checkpoints": CHECKPOINT_DIR,
         "loras": LORA_DIR,
         "controlnet": CONTROLNET_DIR,
+        "model_patches": MODEL_PATCHES_DIR,
         "clip_vision": os.path.join(os.path.dirname(LORA_DIR), "clip_vision")
     }
     
@@ -383,15 +384,63 @@ def build_preprocessor_model_map():
     global PREPROCESSOR_MODEL_MAP
     if PREPROCESSOR_MODEL_MAP is not None: return PREPROCESSOR_MODEL_MAP
     print("--- Building ControlNet Preprocessor model map ---")
-    PREPROCESSOR_MODEL_MAP = {}
-    print("✅ ControlNet Preprocessor model map build skipped as feature is disabled."); return PREPROCESSOR_MODEL_MAP
+    manual_map = {
+        "dwpose": [("yzd-v/DWPose", "yolox_l.onnx"), ("yzd-v/DWPose", "dw-ll_ucoco_384.onnx"), ("hr16/UnJIT-DWPose", "dw-ll_ucoco.onnx"), ("hr16/DWPose-TorchScript-BatchSize5", "dw-ll_ucoco_384_bs5.torchscript.pt"), ("hr16/DWPose-TorchScript-BatchSize5", "rtmpose-m_ap10k_256_bs5.torchscript.pt"), ("hr16/yolo-nas-fp16", "yolo_nas_l_fp16.onnx"), ("hr16/yolo-nas-fp16", "yolo_nas_m_fp16.onnx"), ("hr16/yolo-nas-fp16", "yolo_nas_s_fp16.onnx")],
+        "densepose": [("LayerNorm/DensePose-TorchScript-with-hint-image", "densepose_r50_fpn_dl.torchscript"), ("LayerNorm/DensePose-TorchScript-with-hint-image", "densepose_r101_fpn_dl.torchscript")]
+    }
+    temp_map = {}
+    from nodes import NODE_DISPLAY_NAME_MAPPINGS
+    wrappers_dir = Path("./custom_nodes/comfyui_controlnet_aux/node_wrappers/")
+    if not wrappers_dir.exists():
+        print("⚠️ ControlNet AUX wrappers directory not found. Cannot build model map.")
+        PREPROCESSOR_MODEL_MAP = {}; return PREPROCESSOR_MODEL_MAP
+    for wrapper_file in wrappers_dir.glob("*.py"):
+        if wrapper_file.name == "__init__.py": continue
+        with open(wrapper_file, 'r', encoding='utf-8') as f:
+            content = f.read()
+            display_name_matches = re.findall(r'NODE_DISPLAY_NAME_MAPPINGS\s*=\s*{(?:.|\n)*?["\'](.*?)["\']\s*:\s*["\'](.*?)["\']', content)
+            for _, display_name in display_name_matches:
+                if display_name not in temp_map: temp_map[display_name] = []
+                manual_key = wrapper_file.stem
+                if manual_key in manual_map: temp_map[display_name].extend(manual_map[manual_key])
+                matches = re.findall(r"from_pretrained\s*\(\s*(?:filename=)?\s*f?[\"']([^\"']+)[\"']", content)
+                for model_filename in matches:
+                    repo_id = "lllyasviel/Annotators"
+                    if "depth_anything" in model_filename and "v2" in model_filename: repo_id = "LiheYoung/Depth-Anything-V2"
+                    elif "depth_anything" in model_filename: repo_id = "LiheYoung/Depth-Anything"
+                    elif "diffusion_edge" in model_filename: repo_id = "hr16/Diffusion-Edge"
+                    temp_map[display_name].append((repo_id, model_filename))
+    final_map = {name: sorted(list(set(models))) for name, models in temp_map.items() if models}
+    PREPROCESSOR_MODEL_MAP = final_map
+    print("✅ ControlNet Preprocessor model map built."); return PREPROCESSOR_MODEL_MAP
 
 def build_preprocessor_parameter_map():
     global PREPROCESSOR_PARAMETER_MAP
     if PREPROCESSOR_PARAMETER_MAP is not None: return
     print("--- Building ControlNet Preprocessor parameter map ---")
-    PREPROCESSOR_PARAMETER_MAP = {}
-    print("✅ ControlNet Preprocessor parameter map build skipped as feature is disabled.")
+    param_map = {}
+    from nodes import NODE_CLASS_MAPPINGS, NODE_DISPLAY_NAME_MAPPINGS
+    for class_name, node_class in NODE_CLASS_MAPPINGS.items():
+        if not hasattr(node_class, "INPUT_TYPES"): continue
+        if hasattr(node_class, '__module__') and 'comfyui_controlnet_aux.node_wrappers' not in node_class.__module__: continue
+        display_name = NODE_DISPLAY_NAME_MAPPINGS.get(class_name)
+        if not display_name: continue
+        try:
+            input_types = node_class.INPUT_TYPES()
+            all_inputs = {**input_types.get('required', {}), **input_types.get('optional', {})}
+            params = []
+            for name, details in all_inputs.items():
+                if name in ['image', 'resolution', 'pose_kps']: continue
+                if not isinstance(details, (list, tuple)) or not details: continue
+                param_type = details[0]
+                param_config = details[1] if len(details) > 1 and isinstance(details[1], dict) else {}
+                param_info = {"name": name, "type": param_type, "config": param_config}
+                params.append(param_info)
+            if params: param_map[display_name] = params
+        except Exception as e:
+            print(f"⚠️ Could not parse parameters for {display_name}: {e}")
+    PREPROCESSOR_PARAMETER_MAP = param_map
+    print("✅ ControlNet Preprocessor parameter map built.")
 
 def print_welcome_message():
     author_name = "RioShiina"

yaml/diffsynth_controlnet_models.yaml

@@ -0,0 +1,5 @@
+DiffSynth_ControlNet:
+  Z-Image:
+    - Filepath: "Z-Image-Turbo-Fun-Controlnet-Union.safetensors"
+      Series: "alibaba-pai Controlnet Union"
+      Type: ["Pose", "Canny", "HED", "Depth", "MLSD"]

yaml/file_list.yaml

@@ -17,7 +17,7 @@ file:
       repo_id: "Comfy-Org/z_image_turbo"
       repository_file_path: "split_files/vae/ae.safetensors"
 
-  controlnet:
+  model_patches:
     - filename: "Z-Image-Turbo-Fun-Controlnet-Union.safetensors"
       source: "hf"
       repo_id: "alibaba-pai/Z-Image-Turbo-Fun-Controlnet-Union"

yaml/injectors.yaml

@@ -1,9 +1,12 @@
 injector_definitions:
   dynamic_controlnet_chains: 
     module: "chain_injectors.controlnet_injector"
+  dynamic_diffsynth_controlnet_chains:
+    module: "chain_injectors.diffsynth_controlnet_injector"
   dynamic_conditioning_chains:
     module: "chain_injectors.conditioning_injector"
   
 injector_order:
   - dynamic_conditioning_chains
+  - dynamic_diffsynth_controlnet_chains
   - dynamic_controlnet_chains