alphard/efficiency-nodes-comfyui
1
0
Fork 0
mirror of https://github.com/jags111/efficiency-nodes-comfyui.git synced 2026-03-21 21:22:13 -03:00
Code Issues Packages Projects Releases Wiki Activity

ControlNet Fixes (XY Input+StackApplications)

Browse Source 
1) Fixed issue where Control Net Stacks would not get applied
2) Fixed issue where XY Input Control Net was not coded whatsoever.
This commit is contained in:
TSC
2023-09-07 20:41:20 -05:00
committed by GitHub
parent 1c8a6268ea
commit 8cb207b539
1 changed files with 78 additions and 63 deletions
Download Patch File Download Diff File Expand all files Collapse all files

141
efficiency_nodes.py
View File

@@ -28,7 +28,8 @@ font_path = os.path.join(my_dir, 'arial.ttf')
# Append comfy_dir to sys.path & import files # Append comfy_dir to sys.path & import files
sys.path.append(comfy_dir) sys.path.append(comfy_dir)
from nodes import LatentUpscaleBy, KSampler, KSamplerAdvanced, VAEDecode, VAEDecodeTiled, CLIPSetLastLayer, CLIPTextEncode, ControlNetApplyAdvanced from nodes import LatentUpscaleBy, KSampler, KSamplerAdvanced, VAEDecode, VAEDecodeTiled, VAEEncode, VAEEncodeTiled, \
ImageScaleBy, CLIPSetLastLayer, CLIPTextEncode, ControlNetLoader, ControlNetApply, ControlNetApplyAdvanced
from comfy_extras.nodes_clip_sdxl import CLIPTextEncodeSDXL, CLIPTextEncodeSDXLRefiner from comfy_extras.nodes_clip_sdxl import CLIPTextEncodeSDXL, CLIPTextEncodeSDXLRefiner
import comfy.samplers import comfy.samplers
import comfy.sd import comfy.sd
@@ -370,10 +371,11 @@ class TSC_Apply_ControlNet_Stack:
def apply_cnet_stack(self, positive, negative, cnet_stack): def apply_cnet_stack(self, positive, negative, cnet_stack):
for control_net_tuple in cnet_stack: for control_net_tuple in cnet_stack:
control_net, image, strength, start_percent, end_percent = control_net_tuple control_net, image, strength, start_percent, end_percent = control_net_tuple
controlnet_conditioning = ControlNetApplyAdvanced().apply_controlnet(positive, negative, controlnet_conditioning = ControlNetApplyAdvanced().apply_controlnet(positive, negative, control_net, image,
control_net, image, strength, strength, start_percent, end_percent)
start_percent, end_percent) positive, negative = controlnet_conditioning[0], controlnet_conditioning[1]
return controlnet_conditioning
return (positive, negative, )
######################################################################################################################## ########################################################################################################################
# TSC KSampler (Efficient) # TSC KSampler (Efficient)
@@ -388,7 +390,7 @@ class TSC_KSampler:
@classmethod @classmethod
def INPUT_TYPES(cls): def INPUT_TYPES(cls):
return {"required": return {"required":
{"sampler_state": (["Sample", "Hold", "Script"], ), {"sampler_state": (["Sample", "Script", "Hold"], ),
"model": ("MODEL",), "model": ("MODEL",),
"seed": ("INT", {"default": 0, "min": 0, "max": 0xffffffffffffffff}), "seed": ("INT", {"default": 0, "min": 0, "max": 0xffffffffffffffff}),
"steps": ("INT", {"default": 20, "min": 1, "max": 10000}), "steps": ("INT", {"default": 20, "min": 1, "max": 10000}),
@@ -529,36 +531,23 @@ class TSC_KSampler:
def vae_decode_latent(vae, samples, vae_decode): def vae_decode_latent(vae, samples, vae_decode):
return VAEDecodeTiled().decode(vae,samples,512)[0] if "tiled" in vae_decode else VAEDecode().decode(vae,samples)[0] return VAEDecodeTiled().decode(vae,samples,512)[0] if "tiled" in vae_decode else VAEDecode().decode(vae,samples)[0]
def vae_encode_image(vae, pixels, vae_decode):
return VAEEncodeTiled().encode(vae,pixels,512)[0] if "tiled" in vae_decode else VAEEncode().encode(vae,pixels)[0]
# --------------------------------------------------------------------------------------------------------------- # ---------------------------------------------------------------------------------------------------------------
def sample_latent_image(model, seed, steps, cfg, sampler_name, scheduler, positive, negative, latent_image, def sample_latent_image(model, seed, steps, cfg, sampler_name, scheduler, positive, negative, latent_image,
denoise, sampler_type, add_noise, start_at_step, end_at_step, return_with_leftover_noise, denoise, sampler_type, add_noise, start_at_step, end_at_step, return_with_leftover_noise,
refiner_model=None, refiner_positive=None, refiner_negative=None): refiner_model, refiner_positive, refiner_negative, vae, vae_decode, sampler_state):
if keys_exist_in_script("tile"):
tile_width, tile_height, tiling_strategy, blenderneko_tiled_nodes = script["tile"]
TSampler = blenderneko_tiled_nodes.TiledKSampler
TSamplerAdvanced = blenderneko_tiled_nodes.TiledKSamplerAdvanced
# Sample the latent_image(s) using the Comfy KSampler nodes # Sample the latent_image(s) using the Comfy KSampler nodes
if sampler_type == "regular": if sampler_type == "regular":
if keys_exist_in_script("tile"): samples = KSampler().sample(model, seed, steps, cfg, sampler_name, scheduler, positive, negative,
samples = TSampler().sample(model, seed, tile_width, tile_height, tiling_strategy, steps, cfg, latent_image, denoise=denoise)[0]
sampler_name, scheduler, positive, negative,
latent_image, denoise=denoise)[0]
else:
samples = KSampler().sample(model, seed, steps, cfg, sampler_name, scheduler, positive, negative,
latent_image, denoise=denoise)[0]
elif sampler_type == "advanced": elif sampler_type == "advanced":
if keys_exist_in_script("tile"): samples = KSamplerAdvanced().sample(model, add_noise, seed, steps, cfg, sampler_name, scheduler,
samples = TSamplerAdvanced().sample(model, add_noise, seed, tile_width, tile_height, tiling_strategy, positive, negative, latent_image, start_at_step, end_at_step,
steps, cfg, sampler_name, scheduler, return_with_leftover_noise, denoise=1.0)[0]
positive, negative, latent_image, start_at_step, end_at_step,
return_with_leftover_noise, "disabled", denoise=1.0)[0]
else:
samples = KSamplerAdvanced().sample(model, add_noise, seed, steps, cfg, sampler_name, scheduler,
positive, negative, latent_image, start_at_step, end_at_step,
return_with_leftover_noise, denoise=1.0)[0]
elif sampler_type == "sdxl": elif sampler_type == "sdxl":
# Disable refiner if refine_at_step is -1 # Disable refiner if refine_at_step is -1
@@ -579,24 +568,35 @@ class TSC_KSampler:
samples, end_at_step, steps, samples, end_at_step, steps,
return_with_leftover_noise, denoise=1.0)[0] return_with_leftover_noise, denoise=1.0)[0]
# Check if "hiresfix" exists in the script after main sampling has taken place if sampler_state == "Script":
if keys_exist_in_script("hiresfix"):
# Unpack the tuple from the script's "hiresfix" key # Check if "hiresfix" exists in the script after main sampling has taken place
latent_upscale_method, upscale_by, hires_steps, hires_denoise, iterations, upscale_function = script["hiresfix"] if keys_exist_in_script("hiresfix"):
# Unpack the tuple from the script's "hiresfix" key
# Iterate for the given number of iterations latent_upscale_method, upscale_by, hires_steps, hires_denoise, iterations, upscale_function = script["hiresfix"]
for _ in range(iterations): # Iterate for the given number of iterations
upscaled_latent_image = upscale_function().upscale(samples, latent_upscale_method, upscale_by)[0] for _ in range(iterations):
# Use the regular KSampler for each iteration upscaled_latent_image = upscale_function().upscale(samples, latent_upscale_method, upscale_by)[0]
if False: #if keys_exist_in_script("tile"): # Disabled for HiResFix
samples = TSampler().sample(model, seed, tile_width, tile_height, tiling_strategy, steps, cfg,
sampler_name, scheduler,
positive, negative, upscaled_latent_image, denoise=hires_denoise)[0]
else:
samples = KSampler().sample(model, seed, hires_steps, cfg, sampler_name, scheduler, samples = KSampler().sample(model, seed, hires_steps, cfg, sampler_name, scheduler,
positive, negative, upscaled_latent_image, denoise=hires_denoise)[0] positive, negative, upscaled_latent_image, denoise=hires_denoise)[0]
# Check if "tile" exists in the script after main sampling has taken place
if keys_exist_in_script("tile"):
# Unpack the tuple from the script's "tile" key
upscale_by, tile_controlnet, tile_size, tiling_strategy, tiling_steps, tiled_denoise,\
blenderneko_tiled_nodes = script["tile"]
# VAE Decode samples
image = vae_decode_latent(vae, samples, vae_decode)
# Upscale image
upscaled_image = ImageScaleBy().upscale(image, "nearest-exact", upscale_by)[0]
upscaled_latent = vae_encode_image(vae, upscaled_image, vae_decode)
# Apply Control Net using upscaled_image and loaded control_net
positive = ControlNetApply().apply_controlnet(positive, tile_controlnet, upscaled_image, 1)[0]
# Sample latent
TSampler = blenderneko_tiled_nodes.TiledKSampler
samples = TSampler().sample(model, seed-1, tile_size, tile_size, tiling_strategy, tiling_steps, cfg,
sampler_name, scheduler, positive, negative, upscaled_latent,
denoise=tiled_denoise)[0]
return samples return samples
# --------------------------------------------------------------------------------------------------------------- # ---------------------------------------------------------------------------------------------------------------
@@ -640,8 +640,9 @@ class TSC_KSampler:
send_command_to_frontend(startListening=True, maxCount=steps-1, sendBlob=False) send_command_to_frontend(startListening=True, maxCount=steps-1, sendBlob=False)
samples = sample_latent_image(model, seed, steps, cfg, sampler_name, scheduler, positive, negative, samples = sample_latent_image(model, seed, steps, cfg, sampler_name, scheduler, positive, negative,
latent_image, denoise, sampler_type, add_noise, start_at_step, end_at_step, latent_image, denoise, sampler_type, add_noise, start_at_step, end_at_step,
return_with_leftover_noise, refiner_model, refiner_positive, refiner_negative) return_with_leftover_noise, refiner_model, refiner_positive, refiner_negative,
vae, vae_decode, sampler_state)
# Cache samples in the 'last_helds' dictionary "latent" # Cache samples in the 'last_helds' dictionary "latent"
update_value_by_id("latent", my_unique_id, samples) update_value_by_id("latent", my_unique_id, samples)
@@ -1421,7 +1422,8 @@ class TSC_KSampler:
samples = sample_latent_image(model, seed, steps, cfg, sampler_name, scheduler, positive, negative, samples = sample_latent_image(model, seed, steps, cfg, sampler_name, scheduler, positive, negative,
latent_image, denoise, sampler_type, add_noise, start_at_step, end_at_step, latent_image, denoise, sampler_type, add_noise, start_at_step, end_at_step,
return_with_leftover_noise, refiner_model, refiner_positive, refiner_negative) return_with_leftover_noise, refiner_model, refiner_positive, refiner_negative,
vae, vae_decode, sampler_state)
# Add the latent tensor to the tensors list # Add the latent tensor to the tensors list
latent_list.append(samples) latent_list.append(samples)
@@ -1491,7 +1493,6 @@ class TSC_KSampler:
ckpt_name, clip_skip, refiner_name, refiner_clip_skip, positive_prompt, ckpt_name, clip_skip, refiner_name, refiner_clip_skip, positive_prompt,
negative_prompt, ascore, lora_stack, cnet_stack, X_label, len(X_value)) negative_prompt, ascore, lora_stack, cnet_stack, X_label, len(X_value))
if X_type != "Nothing" and Y_type == "Nothing": if X_type != "Nothing" and Y_type == "Nothing":
if X_type == "XY_Capsule": if X_type == "XY_Capsule":
model, clip, refiner_model, refiner_clip = \ model, clip, refiner_model, refiner_clip = \
@@ -3309,7 +3310,7 @@ class TSC_XYplot_Control_Net_End:
# ======================================================================================================================= # =======================================================================================================================
# TSC XY Plot: Control Net # TSC XY Plot: Control Net
class TSC_XYplot_Control_Net: class TSC_XYplot_Control_Net(TSC_XYplot_Control_Net_Strength, TSC_XYplot_Control_Net_Start, TSC_XYplot_Control_Net_End):
parameters = ["strength", "start_percent", "end_percent"] parameters = ["strength", "start_percent", "end_percent"]
@classmethod @classmethod
def INPUT_TYPES(cls): def INPUT_TYPES(cls):
@@ -3326,7 +3327,7 @@ class TSC_XYplot_Control_Net:
"first_end_percent": ("FLOAT", {"default": 0.0, "min": 0.00, "max": 1.0, "step": 0.01}), "first_end_percent": ("FLOAT", {"default": 0.0, "min": 0.00, "max": 1.0, "step": 0.01}),
"last_end_percent": ("FLOAT", {"default": 1.0, "min": 0.00, "max": 1.0, "step": 0.01}), "last_end_percent": ("FLOAT", {"default": 1.0, "min": 0.00, "max": 1.0, "step": 0.01}),
"strength": ("FLOAT", {"default": 1.0, "min": 0.00, "max": 10.0, "step": 0.01}), "strength": ("FLOAT", {"default": 1.0, "min": 0.00, "max": 10.0, "step": 0.01}),
"start_percent": ("FLOAT", {"default": 1.0, "min": 0.00, "max": 1.0, "step": 0.01}), "start_percent": ("FLOAT", {"default": 0.0, "min": 0.00, "max": 1.0, "step": 0.01}),
"end_percent": ("FLOAT", {"default": 1.0, "min": 0.00, "max": 1.0, "step": 0.01}), "end_percent": ("FLOAT", {"default": 1.0, "min": 0.00, "max": 1.0, "step": 0.01}),
}, },
"optional": {"cnet_stack": ("CONTROL_NET_STACK",)}, "optional": {"cnet_stack": ("CONTROL_NET_STACK",)},
@@ -3338,10 +3339,17 @@ class TSC_XYplot_Control_Net:
CATEGORY = "Efficiency Nodes/XY Inputs" CATEGORY = "Efficiency Nodes/XY Inputs"
def xy_value(self, control_net, image, target_parameter, batch_count, first_strength, last_strength, first_start_percent, def xy_value(self, control_net, image, target_parameter, batch_count, first_strength, last_strength, first_start_percent,
last_start_percent, first_end_percent, last_end_percent, strength, start_percent, cnet_stack=None): last_start_percent, first_end_percent, last_end_percent, strength, start_percent, end_percent, cnet_stack=None):
if target_parameter == "strength":
return ((xy_type, xy_value),) return TSC_XYplot_Control_Net_Strength.xy_value(self, control_net, image, batch_count, first_strength,
last_strength, start_percent, end_percent, cnet_stack=cnet_stack)
elif target_parameter == "start_percent":
return TSC_XYplot_Control_Net_Start.xy_value(self, control_net, image, batch_count, first_start_percent,
last_start_percent, strength, end_percent, cnet_stack=cnet_stack)
elif target_parameter == "end_percent":
return TSC_XYplot_Control_Net_End.xy_value(self, control_net, image, batch_count, first_end_percent,
last_end_percent, strength, start_percent, cnet_stack=cnet_stack)
#======================================================================================================================= #=======================================================================================================================
# TSC XY Plot: Control Net Plot # TSC XY Plot: Control Net Plot
@@ -4007,8 +4015,8 @@ NODE_CLASS_MAPPINGS = {
"XY Input: LoRA Stacks": TSC_XYplot_LoRA_Stacks, "XY Input: LoRA Stacks": TSC_XYplot_LoRA_Stacks,
"XY Input: Control Net": TSC_XYplot_Control_Net, "XY Input: Control Net": TSC_XYplot_Control_Net,
"XY Input: Control Net Plot": TSC_XYplot_Control_Net_Plot, "XY Input: Control Net Plot": TSC_XYplot_Control_Net_Plot,
"XY Input: Manual XY Entry": TSC_XYplot_Manual_XY_Entry, # DISABLED, NEEDS UPDATE "XY Input: Manual XY Entry": TSC_XYplot_Manual_XY_Entry,
"Manual XY Entry Info": TSC_XYplot_Manual_XY_Entry_Info, # DISABLED, NEEDS UPDATE "Manual XY Entry Info": TSC_XYplot_Manual_XY_Entry_Info,
"Join XY Inputs of Same Type": TSC_XYplot_JoinInputs, "Join XY Inputs of Same Type": TSC_XYplot_JoinInputs,
"Image Overlay": TSC_ImageOverlay "Image Overlay": TSC_ImageOverlay
} }
@@ -4107,7 +4115,7 @@ class TSC_HighRes_Fix:
NODE_CLASS_MAPPINGS.update({"HighRes-Fix Script": TSC_HighRes_Fix}) NODE_CLASS_MAPPINGS.update({"HighRes-Fix Script": TSC_HighRes_Fix})
######################################################################################################################## ########################################################################################################################
'''# FUTURE '''
# Tiled Sampling KSamplers (https://github.com/BlenderNeko/ComfyUI_TiledKSampler) # Tiled Sampling KSamplers (https://github.com/BlenderNeko/ComfyUI_TiledKSampler)
blenderneko_tiled_ksampler_path = os.path.join(custom_nodes_dir, "ComfyUI_TiledKSampler") blenderneko_tiled_ksampler_path = os.path.join(custom_nodes_dir, "ComfyUI_TiledKSampler")
if os.path.exists(blenderneko_tiled_ksampler_path): if os.path.exists(blenderneko_tiled_ksampler_path):
@@ -4117,14 +4125,20 @@ if os.path.exists(blenderneko_tiled_ksampler_path):
blenderneko_tiled_nodes = import_module("ComfyUI_TiledKSampler.nodes") blenderneko_tiled_nodes = import_module("ComfyUI_TiledKSampler.nodes")
print(f"\r{message('Efficiency Nodes:')} {printout}{success('Success!')}") print(f"\r{message('Efficiency Nodes:')} {printout}{success('Success!')}")
# TSC Tiled Sampling # TSC Tiled Upscaler
class TSC_Tiled_Sampling: class TSC_Tiled_Upscaler:
@classmethod @classmethod
def INPUT_TYPES(cls): def INPUT_TYPES(cls):
return {"required": {"tile_width": ("INT", {"default": 512, "min": 256, "max": MAX_RESOLUTION, "step": 64}), # Split the list based on the keyword "tile"
"tile_height": ("INT", {"default": 512, "min": 256, "max": MAX_RESOLUTION, "step": 64}), cnet_tile_filenames = [name for name in folder_paths.get_filename_list("controlnet") if "tile" in name]
cnet_other_filenames = [name for name in folder_paths.get_filename_list("controlnet") if "tile" not in name]
return {"required": {"tile_controlnet": (cnet_tile_filenames + cnet_other_filenames,),
"upscale_by": ("FLOAT", {"default": 1.25, "min": 0.01, "max": 8.0, "step": 0.25}),
"tile_size": ("INT", {"default": 512, "min": 256, "max": MAX_RESOLUTION, "step": 64}),
"tiling_strategy": (["random", "random strict", "padded", 'simple', 'none'],), "tiling_strategy": (["random", "random strict", "padded", 'simple', 'none'],),
"tiling_steps": ("INT", {"default": 30, "min": 1, "max": 10000}),
"denoise": ("FLOAT", {"default": .56, "min": 0.0, "max": 1.0, "step": 0.01}),
}, },
"optional": {"script": ("SCRIPT",)}} "optional": {"script": ("SCRIPT",)}}
@@ -4132,13 +4146,14 @@ if os.path.exists(blenderneko_tiled_ksampler_path):
FUNCTION = "tiled_sampling" FUNCTION = "tiled_sampling"
CATEGORY = "Efficiency Nodes/Scripts" CATEGORY = "Efficiency Nodes/Scripts"
def tiled_sampling(self, tile_width, tile_height, tiling_strategy, script=None): def tiled_sampling(self, upscale_by, tile_controlnet, tile_size, tiling_strategy, tiling_steps, denoise, script=None):
if tiling_strategy != 'none': if tiling_strategy != 'none':
script = script or {} script = script or {}
script["tile"] = (tile_width, tile_height, tiling_strategy, blenderneko_tiled_nodes) script["tile"] = (upscale_by, ControlNetLoader().load_controlnet(tile_controlnet)[0],
tile_size, tiling_strategy, tiling_steps, denoise, blenderneko_tiled_nodes)
return (script,) return (script,)
NODE_CLASS_MAPPINGS.update({"Tiled Sampling Script": TSC_Tiled_Sampling}) NODE_CLASS_MAPPINGS.update({"Tiled Upscaler Script": TSC_Tiled_Upscaler})
except ImportError: except ImportError:
print(f"\r{message('Efficiency Nodes:')} {printout}{error('Failed!')}") print(f"\r{message('Efficiency Nodes:')} {printout}{error('Failed!')}")