@classmethod

def INPUT_TYPES(s):

return {"required": {"text": ("STRING", {"multiline": True}), "clip": ("CLIP", )}}

RETURN_TYPES = ("CONDITIONING",)

FUNCTION = "encode"

CATEGORY = "conditioning"

def encode(self, clip, text):

tokens = clip.tokenize(text)

cond, pooled = clip.encode_from_tokens(tokens, return_pooled=True)

@classmethod

def INPUT_TYPES(s):

return {"required": {"conditioning_1": ("CONDITIONING", ), "conditioning_2": ("CONDITIONING", )}}

RETURN_TYPES = ("CONDITIONING",)

FUNCTION = "combine"

CATEGORY = "conditioning"

def combine(self, conditioning_1, conditioning_2):

@classmethod

def INPUT_TYPES(s):

return {"required": {"conditioning_to": ("CONDITIONING", ), "conditioning_from": ("CONDITIONING", ),

"conditioning_to_strength": ("FLOAT", {"default": 1.0, "min": 0.0, "max": 1.0, "step": 0.01})

}}

RETURN_TYPES = ("CONDITIONING",)

FUNCTION = "addWeighted"

CATEGORY = "conditioning"

def addWeighted(self, conditioning_to, conditioning_from, conditioning_to_strength):

out = []

if len(conditioning_from) > 1:

print("Warning: ConditioningAverage conditioning_from contains more than 1 cond, only the first one will actually be applied to conditioning_to.")

cond_from = conditioning_from[0][0]

pooled_output_from = conditioning_from[0][1].get("pooled_output", None)

for i in range(len(conditioning_to)):

t1 = conditioning_to[i][0]

pooled_output_to = conditioning_to[i][1].get("pooled_output", pooled_output_from)

t0 = cond_from[:,:t1.shape[1]]

if t0.shape[1] < t1.shape[1]:

t0 = torch.cat([t0] + [torch.zeros((1, (t1.shape[1] - t0.shape[1]), t1.shape[2]))], dim=1)

tw = torch.mul(t1, conditioning_to_strength) + torch.mul(t0, (1.0 - conditioning_to_strength))

t_to = conditioning_to[i][1].copy()

if pooled_output_from is not None and pooled_output_to is not None:

t_to["pooled_output"] = torch.mul(pooled_output_to, conditioning_to_strength) + torch.mul(pooled_output_from, (1.0 - conditioning_to_strength))

elif pooled_output_from is not None:

t_to["pooled_output"] = pooled_output_from

n = [tw, t_to]

out.append(n)

@classmethod

def INPUT_TYPES(s):

return {"required": {

"conditioning_to": ("CONDITIONING",),

"conditioning_from": ("CONDITIONING",),

}}

RETURN_TYPES = ("CONDITIONING",)

FUNCTION = "concat"

CATEGORY = "conditioning"

def concat(self, conditioning_to, conditioning_from):

out = []

if len(conditioning_from) > 1:

print("Warning: ConditioningConcat conditioning_from contains more than 1 cond, only the first one will actually be applied to conditioning_to.")

cond_from = conditioning_from[0][0]

for i in range(len(conditioning_to)):

t1 = conditioning_to[i][0]

tw = torch.cat((t1, cond_from),1)

n = [tw, conditioning_to[i][1].copy()]

out.append(n)

@classmethod

def INPUT_TYPES(s):

return {"required": {"conditioning": ("CONDITIONING", ),

"width": ("INT", {"default": 64, "min": 64, "max": MAX_RESOLUTION, "step": 8}),

"height": ("INT", {"default": 64, "min": 64, "max": MAX_RESOLUTION, "step": 8}),

"x": ("INT", {"default": 0, "min": 0, "max": MAX_RESOLUTION, "step": 8}),

"y": ("INT", {"default": 0, "min": 0, "max": MAX_RESOLUTION, "step": 8}),

"strength": ("FLOAT", {"default": 1.0, "min": 0.0, "max": 10.0, "step": 0.01}),

}}

RETURN_TYPES = ("CONDITIONING",)

FUNCTION = "append"

CATEGORY = "conditioning"

def append(self, conditioning, width, height, x, y, strength):

c = []

for t in conditioning:

n = [t[0], t[1].copy()]

n[1]['area'] = (height // 8, width // 8, y // 8, x // 8)

n[1]['strength'] = strength

n[1]['set_area_to_bounds'] = False

c.append(n)

@classmethod

def INPUT_TYPES(s):

return {"required": {"conditioning": ("CONDITIONING", ),

"mask": ("MASK", ),

"strength": ("FLOAT", {"default": 1.0, "min": 0.0, "max": 10.0, "step": 0.01}),

"set_cond_area": (["default", "mask bounds"],),

}}

RETURN_TYPES = ("CONDITIONING",)

FUNCTION = "append"

CATEGORY = "conditioning"

def append(self, conditioning, mask, set_cond_area, strength):

c = []

set_area_to_bounds = False

if set_cond_area != "default":

set_area_to_bounds = True

if len(mask.shape) < 3:

mask = mask.unsqueeze(0)

for t in conditioning:

n = [t[0], t[1].copy()]

_, h, w = mask.shape

n[1]['mask'] = mask

n[1]['set_area_to_bounds'] = set_area_to_bounds

n[1]['mask_strength'] = strength

c.append(n)

@classmethod

def INPUT_TYPES(s):

return {"required": {"conditioning": ("CONDITIONING", )}}

RETURN_TYPES = ("CONDITIONING",)

FUNCTION = "zero_out"

CATEGORY = "advanced/conditioning"

def zero_out(self, conditioning):

c = []

for t in conditioning:

d = t[1].copy()

if "pooled_output" in d:

d["pooled_output"] = torch.zeros_like(d["pooled_output"])

n = [torch.zeros_like(t[0]), d]

c.append(n)

@classmethod

def INPUT_TYPES(s):

return {"required": {"conditioning": ("CONDITIONING", ),

"start": ("FLOAT", {"default": 1.0, "min": 0.0, "max": 1.0, "step": 0.001}),

"end": ("FLOAT", {"default": 0.0, "min": 0.0, "max": 1.0, "step": 0.001})

}}

RETURN_TYPES = ("CONDITIONING",)

FUNCTION = "set_range"

CATEGORY = "advanced/conditioning"

def set_range(self, conditioning, start, end):

c = []

for t in conditioning:

d = t[1].copy()

d['start_percent'] = start

d['end_percent'] = end

n = [t[0], d]

c.append(n)

@classmethod

def INPUT_TYPES(s):

return {"required": { "samples": ("LATENT", ), "vae": ("VAE", )}}

RETURN_TYPES = ("IMAGE",)

FUNCTION = "decode"

CATEGORY = "latent"

def decode(self, vae, samples):

@classmethod

def INPUT_TYPES(s):

return {"required": { "samples": ("LATENT", ), "vae": ("VAE", )}}

RETURN_TYPES = ("IMAGE",)

FUNCTION = "decode"

CATEGORY = "_for_testing"

def decode(self, vae, samples):

@classmethod

def INPUT_TYPES(s):

return {"required": { "pixels": ("IMAGE", ), "vae": ("VAE", )}}

RETURN_TYPES = ("LATENT",)

FUNCTION = "encode"

CATEGORY = "latent"

@staticmethod

def vae_encode_crop_pixels(pixels):

x = (pixels.shape[1] // 8) * 8

y = (pixels.shape[2] // 8) * 8

if pixels.shape[1] != x or pixels.shape[2] != y:

x_offset = (pixels.shape[1] % 8) // 2

y_offset = (pixels.shape[2] % 8) // 2

pixels = pixels[:, x_offset:x + x_offset, y_offset:y + y_offset, :]

return pixels

def encode(self, vae, pixels):

pixels = self.vae_encode_crop_pixels(pixels)

t = vae.encode(pixels[:,:,:,:3])

@classmethod

def INPUT_TYPES(s):

return {"required": { "pixels": ("IMAGE", ), "vae": ("VAE", )}}

RETURN_TYPES = ("LATENT",)

FUNCTION = "encode"

CATEGORY = "_for_testing"

def encode(self, vae, pixels):

pixels = VAEEncode.vae_encode_crop_pixels(pixels)

t = vae.encode_tiled(pixels[:,:,:,:3])

@classmethod

def INPUT_TYPES(s):

return {"required": { "pixels": ("IMAGE", ), "vae": ("VAE", ), "mask": ("MASK", ), "grow_mask_by": ("INT", {"default": 6, "min": 0, "max": 64, "step": 1}),}}

RETURN_TYPES = ("LATENT",)

FUNCTION = "encode"

CATEGORY = "latent/inpaint"

def encode(self, vae, pixels, mask, grow_mask_by=6):

x = (pixels.shape[1] // 8) * 8

y = (pixels.shape[2] // 8) * 8

mask = torch.nn.functional.interpolate(mask.reshape((-1, 1, mask.shape[-2], mask.shape[-1])), size=(pixels.shape[1], pixels.shape[2]), mode="bilinear")

pixels = pixels.clone()

if pixels.shape[1] != x or pixels.shape[2] != y:

x_offset = (pixels.shape[1] % 8) // 2

y_offset = (pixels.shape[2] % 8) // 2

pixels = pixels[:,x_offset:x + x_offset, y_offset:y + y_offset,:]

mask = mask[:,:,x_offset:x + x_offset, y_offset:y + y_offset]

#grow mask by a few pixels to keep things seamless in latent space

if grow_mask_by == 0:

mask_erosion = mask

else:

kernel_tensor = torch.ones((1, 1, grow_mask_by, grow_mask_by))

padding = math.ceil((grow_mask_by - 1) / 2)

mask_erosion = torch.clamp(torch.nn.functional.conv2d(mask.round(), kernel_tensor, padding=padding), 0, 1)

m = (1.0 - mask.round()).squeeze(1)

for i in range(3):

pixels[:,:,:,i] -= 0.5

pixels[:,:,:,i] *= m

pixels[:,:,:,i] += 0.5

t = vae.encode(pixels)

def __init__(self):

self.output_dir = folder_paths.get_output_directory()

@classmethod

def INPUT_TYPES(s):

return {"required": { "samples": ("LATENT", ),

"filename_prefix": ("STRING", {"default": "latents/ComfyUI"})},

"hidden": {"prompt": "PROMPT", "extra_pnginfo": "EXTRA_PNGINFO"},

}

RETURN_TYPES = ()

FUNCTION = "save"

OUTPUT_NODE = True

CATEGORY = "_for_testing"

def save(self, samples, filename_prefix="ComfyUI", prompt=None, extra_pnginfo=None):

full_output_folder, filename, counter, subfolder, filename_prefix = folder_paths.get_save_image_path(filename_prefix, self.output_dir)

# support save metadata for latent sharing

prompt_info = ""

if prompt is not None:

prompt_info = json.dumps(prompt)

metadata = {"prompt": prompt_info}

if extra_pnginfo is not None:

for x in extra_pnginfo:

metadata[x] = json.dumps(extra_pnginfo[x])

file = f"{filename}_{counter:05}_.latent"

file = os.path.join(full_output_folder, file)

output = {}

output["latent_tensor"] = samples["samples"]

output["latent_format_version_0"] = torch.tensor([])

comfy.utils.save_torch_file(output, file, metadata=metadata)

@classmethod

def INPUT_TYPES(s):

input_dir = folder_paths.get_input_directory()

files = [f for f in os.listdir(input_dir) if os.path.isfile(os.path.join(input_dir, f)) and f.endswith(".latent")]

return {"required": {"latent": [sorted(files), ]}, }

CATEGORY = "_for_testing"

RETURN_TYPES = ("LATENT", )

FUNCTION = "load"

def load(self, latent):

latent_path = folder_paths.get_annotated_filepath(latent)

latent = safetensors.torch.load_file(latent_path, device="cpu")

multiplier = 1.0

if "latent_format_version_0" not in latent:

multiplier = 1.0 / 0.18215

samples = {"samples": latent["latent_tensor"].float() * multiplier}

return (samples, )

@classmethod

def IS_CHANGED(s, latent):

image_path = folder_paths.get_annotated_filepath(latent)

m = hashlib.sha256()

with open(image_path, 'rb') as f:

m.update(f.read())

return m.digest().hex()

@classmethod

def VALIDATE_INPUTS(s, latent):

if not folder_paths.exists_annotated_filepath(latent):

return "Invalid latent file: {}".format(latent)

@classmethod

def INPUT_TYPES(s):

return {"required": { "config_name": (folder_paths.get_filename_list("configs"), ),

"ckpt_name": (folder_paths.get_filename_list("checkpoints"), )}}

RETURN_TYPES = ("MODEL", "CLIP", "VAE")

FUNCTION = "load_checkpoint"

CATEGORY = "advanced/loaders"

def load_checkpoint(self, config_name, ckpt_name, output_vae=True, output_clip=True):

config_path = folder_paths.get_full_path("configs", config_name)

ckpt_path = folder_paths.get_full_path("checkpoints", ckpt_name)

@classmethod

def INPUT_TYPES(s):

return {"required": { "ckpt_name": (folder_paths.get_filename_list("checkpoints"), ),

}}

RETURN_TYPES = ("MODEL", "CLIP", "VAE")

FUNCTION = "load_checkpoint"

CATEGORY = "loaders"

def load_checkpoint(self, ckpt_name, output_vae=True, output_clip=True):

ckpt_path = folder_paths.get_full_path("checkpoints", ckpt_name)

out = comfy.sd.load_checkpoint_guess_config(ckpt_path, output_vae=True, output_clip=True, embedding_directory=folder_paths.get_folder_paths("embeddings"))

@classmethod

def INPUT_TYPES(cls):

paths = []

for search_path in folder_paths.get_folder_paths("diffusers"):

if os.path.exists(search_path):

for root, subdir, files in os.walk(search_path, followlinks=True):

if "model_index.json" in files:

paths.append(os.path.relpath(root, start=search_path))

return {"required": {"model_path": (paths,), }}

RETURN_TYPES = ("MODEL", "CLIP", "VAE")

FUNCTION = "load_checkpoint"

CATEGORY = "advanced/loaders/deprecated"

def load_checkpoint(self, model_path, output_vae=True, output_clip=True):

for search_path in folder_paths.get_folder_paths("diffusers"):

if os.path.exists(search_path):

path = os.path.join(search_path, model_path)

if os.path.exists(path):

model_path = path

break

@classmethod

def INPUT_TYPES(s):

return {"required": { "ckpt_name": (folder_paths.get_filename_list("checkpoints"), ),

}}

RETURN_TYPES = ("MODEL", "CLIP", "VAE", "CLIP_VISION")

FUNCTION = "load_checkpoint"

CATEGORY = "loaders"

def load_checkpoint(self, ckpt_name, output_vae=True, output_clip=True):

ckpt_path = folder_paths.get_full_path("checkpoints", ckpt_name)

out = comfy.sd.load_checkpoint_guess_config(ckpt_path, output_vae=True, output_clip=True, output_clipvision=True, embedding_directory=folder_paths.get_folder_paths("embeddings"))

@classmethod

def INPUT_TYPES(s):

return {"required": { "clip": ("CLIP", ),

"stop_at_clip_layer": ("INT", {"default": -1, "min": -24, "max": -1, "step": 1}),

}}

RETURN_TYPES = ("CLIP",)

FUNCTION = "set_last_layer"

CATEGORY = "conditioning"

def set_last_layer(self, clip, stop_at_clip_layer):

clip = clip.clone()

clip.clip_layer(stop_at_clip_layer)

def __init__(self):

self.loaded_lora = None

@classmethod

def INPUT_TYPES(s):

return {"required": { "model": ("MODEL",),

"clip": ("CLIP", ),

"lora_name": (folder_paths.get_filename_list("loras"), ),

"strength_model": ("FLOAT", {"default": 1.0, "min": -10.0, "max": 10.0, "step": 0.01}),

"strength_clip": ("FLOAT", {"default": 1.0, "min": -10.0, "max": 10.0, "step": 0.01}),

}}

RETURN_TYPES = ("MODEL", "CLIP")

FUNCTION = "load_lora"

CATEGORY = "loaders"

def load_lora(self, model, clip, lora_name, strength_model, strength_clip):

if strength_model == 0 and strength_clip == 0:

return (model, clip)

lora_path = folder_paths.get_full_path("loras", lora_name)

lora = None

if self.loaded_lora is not None:

if self.loaded_lora[0] == lora_path:

lora = self.loaded_lora[1]

else:

temp = self.loaded_lora

self.loaded_lora = None

del temp

if lora is None:

lora = comfy.utils.load_torch_file(lora_path, safe_load=True)

self.loaded_lora = (lora_path, lora)

model_lora, clip_lora = comfy.sd.load_lora_for_models(model, clip, lora, strength_model, strength_clip)

@classmethod

def INPUT_TYPES(s):

return {"required": { "vae_name": (folder_paths.get_filename_list("vae"), )}}

RETURN_TYPES = ("VAE",)

FUNCTION = "load_vae"

CATEGORY = "loaders"

#TODO: scale factor?

def load_vae(self, vae_name):

vae_path = folder_paths.get_full_path("vae", vae_name)

vae = comfy.sd.VAE(ckpt_path=vae_path)

@classmethod

def INPUT_TYPES(s):

return {"required": { "control_net_name": (folder_paths.get_filename_list("controlnet"), )}}

RETURN_TYPES = ("CONTROL_NET",)

FUNCTION = "load_controlnet"

CATEGORY = "loaders"

def load_controlnet(self, control_net_name):

controlnet_path = folder_paths.get_full_path("controlnet", control_net_name)

controlnet = comfy.sd.load_controlnet(controlnet_path)

@classmethod

def INPUT_TYPES(s):

return {"required": { "model": ("MODEL",),

"control_net_name": (folder_paths.get_filename_list("controlnet"), )}}

RETURN_TYPES = ("CONTROL_NET",)

FUNCTION = "load_controlnet"

CATEGORY = "loaders"

def load_controlnet(self, model, control_net_name):

controlnet_path = folder_paths.get_full_path("controlnet", control_net_name)

controlnet = comfy.sd.load_controlnet(controlnet_path, model)

@classmethod

def INPUT_TYPES(s):

return {"required": {"conditioning": ("CONDITIONING", ),

"control_net": ("CONTROL_NET", ),

"image": ("IMAGE", ),

"strength": ("FLOAT", {"default": 1.0, "min": 0.0, "max": 10.0, "step": 0.01})

}}

RETURN_TYPES = ("CONDITIONING",)

FUNCTION = "apply_controlnet"

CATEGORY = "conditioning"

def apply_controlnet(self, conditioning, control_net, image, strength):

if strength == 0:

return (conditioning, )

c = []

control_hint = image.movedim(-1,1)

for t in conditioning:

n = [t[0], t[1].copy()]

c_net = control_net.copy().set_cond_hint(control_hint, strength)

if 'control' in t[1]:

c_net.set_previous_controlnet(t[1]['control'])

n[1]['control'] = c_net

n[1]['control_apply_to_uncond'] = True

c.append(n)

@classmethod

def INPUT_TYPES(s):

return {"required": {"positive": ("CONDITIONING", ),

"negative": ("CONDITIONING", ),

"control_net": ("CONTROL_NET", ),

"image": ("IMAGE", ),

"strength": ("FLOAT", {"default": 1.0, "min": 0.0, "max": 10.0, "step": 0.01}),

}}

RETURN_TYPES = ("CONDITIONING","CONDITIONING")

RETURN_NAMES = ("positive", "negative")

FUNCTION = "apply_controlnet"

CATEGORY = "conditioning"

def apply_controlnet(self, positive, negative, control_net, image, strength):

if strength == 0:

return (positive, negative)

control_hint = image.movedim(-1,1)

cnets = {}

out = []

for conditioning in [positive, negative]:

c = []

for t in conditioning:

d = t[1].copy()

prev_cnet = d.get('control', None)

if prev_cnet in cnets:

c_net = cnets[prev_cnet]

else:

c_net = control_net.copy().set_cond_hint(control_hint, strength)

c_net.set_previous_controlnet(prev_cnet)

cnets[prev_cnet] = c_net

d['control'] = c_net

d['control_apply_to_uncond'] = False

n = [t[0], d]

c.append(n)

out.append(c)

@classmethod

def INPUT_TYPES(s):

return {"required": { "unet_name": (folder_paths.get_filename_list("unet"), ),

}}

RETURN_TYPES = ("MODEL",)

FUNCTION = "load_unet"

CATEGORY = "advanced/loaders"

def load_unet(self, unet_name):

unet_path = folder_paths.get_full_path("unet", unet_name)

model = comfy.sd.load_unet(unet_path)

@classmethod

def INPUT_TYPES(s):

return {"required": { "clip_name": (folder_paths.get_filename_list("clip"), ),

}}

RETURN_TYPES = ("CLIP",)

FUNCTION = "load_clip"

CATEGORY = "advanced/loaders"

def load_clip(self, clip_name):

clip_path = folder_paths.get_full_path("clip", clip_name)

clip = comfy.sd.load_clip(ckpt_paths=[clip_path], embedding_directory=folder_paths.get_folder_paths("embeddings"))

@classmethod

def INPUT_TYPES(s):

return {"required": { "clip_name1": (folder_paths.get_filename_list("clip"), ), "clip_name2": (folder_paths.get_filename_list("clip"), ),

}}

RETURN_TYPES = ("CLIP",)

FUNCTION = "load_clip"

CATEGORY = "advanced/loaders"

def load_clip(self, clip_name1, clip_name2):

clip_path1 = folder_paths.get_full_path("clip", clip_name1)

clip_path2 = folder_paths.get_full_path("clip", clip_name2)

clip = comfy.sd.load_clip(ckpt_paths=[clip_path1, clip_path2], embedding_directory=folder_paths.get_folder_paths("embeddings"))

@classmethod

def INPUT_TYPES(s):

return {"required": { "clip_name": (folder_paths.get_filename_list("clip_vision"), ),

}}

RETURN_TYPES = ("CLIP_VISION",)

FUNCTION = "load_clip"

CATEGORY = "loaders"

def load_clip(self, clip_name):

clip_path = folder_paths.get_full_path("clip_vision", clip_name)

clip_vision = comfy.clip_vision.load(clip_path)

@classmethod

def INPUT_TYPES(s):

return {"required": { "clip_vision": ("CLIP_VISION",),

"image": ("IMAGE",)

}}

RETURN_TYPES = ("CLIP_VISION_OUTPUT",)

FUNCTION = "encode"

CATEGORY = "conditioning"

def encode(self, clip_vision, image):

output = clip_vision.encode_image(image)

@classmethod

def INPUT_TYPES(s):

return {"required": { "style_model_name": (folder_paths.get_filename_list("style_models"), )}}

RETURN_TYPES = ("STYLE_MODEL",)

FUNCTION = "load_style_model"

CATEGORY = "loaders"

def load_style_model(self, style_model_name):

style_model_path = folder_paths.get_full_path("style_models", style_model_name)

style_model = comfy.sd.load_style_model(style_model_path)

@classmethod

def INPUT_TYPES(s):

return {"required": {"conditioning": ("CONDITIONING", ),

"style_model": ("STYLE_MODEL", ),

"clip_vision_output": ("CLIP_VISION_OUTPUT", ),

}}

RETURN_TYPES = ("CONDITIONING",)

FUNCTION = "apply_stylemodel"

CATEGORY = "conditioning/style_model"

def apply_stylemodel(self, clip_vision_output, style_model, conditioning):

cond = style_model.get_cond(clip_vision_output)

c = []

for t in conditioning:

n = [torch.cat((t[0], cond), dim=1), t[1].copy()]

c.append(n)

@classmethod

def INPUT_TYPES(s):

return {"required": {"conditioning": ("CONDITIONING", ),

"clip_vision_output": ("CLIP_VISION_OUTPUT", ),

"strength": ("FLOAT", {"default": 1.0, "min": -10.0, "max": 10.0, "step": 0.01}),

"noise_augmentation": ("FLOAT", {"default": 0.0, "min": 0.0, "max": 1.0, "step": 0.01}),

}}

RETURN_TYPES = ("CONDITIONING",)

FUNCTION = "apply_adm"

CATEGORY = "conditioning"

def apply_adm(self, conditioning, clip_vision_output, strength, noise_augmentation):

if strength == 0:

return (conditioning, )

c = []

for t in conditioning:

o = t[1].copy()

x = {"clip_vision_output": clip_vision_output, "strength": strength, "noise_augmentation": noise_augmentation}

if "unclip_conditioning" in o:

o["unclip_conditioning"] = o["unclip_conditioning"][:] + [x]

else:

o["unclip_conditioning"] = [x]

n = [t[0], o]

c.append(n)

@classmethod

def INPUT_TYPES(s):

return {"required": { "gligen_name": (folder_paths.get_filename_list("gligen"), )}}

RETURN_TYPES = ("GLIGEN",)

FUNCTION = "load_gligen"

CATEGORY = "loaders"

def load_gligen(self, gligen_name):

gligen_path = folder_paths.get_full_path("gligen", gligen_name)

gligen = comfy.sd.load_gligen(gligen_path)

@classmethod

def INPUT_TYPES(s):

return {"required": {"conditioning_to": ("CONDITIONING", ),

"clip": ("CLIP", ),

"gligen_textbox_model": ("GLIGEN", ),

"text": ("STRING", {"multiline": True}),

"width": ("INT", {"default": 64, "min": 8, "max": MAX_RESOLUTION, "step": 8}),

"height": ("INT", {"default": 64, "min": 8, "max": MAX_RESOLUTION, "step": 8}),

"x": ("INT", {"default": 0, "min": 0, "max": MAX_RESOLUTION, "step": 8}),

"y": ("INT", {"default": 0, "min": 0, "max": MAX_RESOLUTION, "step": 8}),

}}

RETURN_TYPES = ("CONDITIONING",)

FUNCTION = "append"

CATEGORY = "conditioning/gligen"

def append(self, conditioning_to, clip, gligen_textbox_model, text, width, height, x, y):

c = []

cond, cond_pooled = clip.encode_from_tokens(clip.tokenize(text), return_pooled=True)

for t in conditioning_to:

n = [t[0], t[1].copy()]

position_params = [(cond_pooled, height // 8, width // 8, y // 8, x // 8)]

prev = []

if "gligen" in n[1]:

prev = n[1]['gligen'][2]

n[1]['gligen'] = ("position", gligen_textbox_model, prev + position_params)

c.append(n)

def __init__(self, device="cpu"):

self.device = device

@classmethod

def INPUT_TYPES(s):

return {"required": { "width": ("INT", {"default": 512, "min": 64, "max": MAX_RESOLUTION, "step": 8}),

"height": ("INT", {"default": 512, "min": 64, "max": MAX_RESOLUTION, "step": 8}),

"batch_size": ("INT", {"default": 1, "min": 1, "max": 64})}}

RETURN_TYPES = ("LATENT",)

FUNCTION = "generate"

CATEGORY = "latent"

def generate(self, width, height, batch_size=1):

latent = torch.zeros([batch_size, 4, height // 8, width // 8])

@classmethod

def INPUT_TYPES(s):

return {"required": { "samples": ("LATENT",),

"batch_index": ("INT", {"default": 0, "min": 0, "max": 63}),

"length": ("INT", {"default": 1, "min": 1, "max": 64}),

}}

RETURN_TYPES = ("LATENT",)

FUNCTION = "frombatch"

CATEGORY = "latent/batch"

def frombatch(self, samples, batch_index, length):

s = samples.copy()

s_in = samples["samples"]

batch_index = min(s_in.shape[0] - 1, batch_index)

length = min(s_in.shape[0] - batch_index, length)

s["samples"] = s_in[batch_index:batch_index + length].clone()

if "noise_mask" in samples:

masks = samples["noise_mask"]

if masks.shape[0] == 1:

s["noise_mask"] = masks.clone()

else:

if masks.shape[0] < s_in.shape[0]:

masks = masks.repeat(math.ceil(s_in.shape[0] / masks.shape[0]), 1, 1, 1)[:s_in.shape[0]]

s["noise_mask"] = masks[batch_index:batch_index + length].clone()

if "batch_index" not in s:

s["batch_index"] = [x for x in range(batch_index, batch_index+length)]

else:

s["batch_index"] = samples["batch_index"][batch_index:batch_index + length]

@classmethod

def INPUT_TYPES(s):

return {"required": { "samples": ("LATENT",),

"amount": ("INT", {"default": 1, "min": 1, "max": 64}),

}}

RETURN_TYPES = ("LATENT",)

FUNCTION = "repeat"

CATEGORY = "latent/batch"

def repeat(self, samples, amount):

s = samples.copy()

s_in = samples["samples"]

s["samples"] = s_in.repeat((amount, 1,1,1))

if "noise_mask" in samples and samples["noise_mask"].shape[0] > 1:

masks = samples["noise_mask"]

if masks.shape[0] < s_in.shape[0]:

masks = masks.repeat(math.ceil(s_in.shape[0] / masks.shape[0]), 1, 1, 1)[:s_in.shape[0]]

s["noise_mask"] = samples["noise_mask"].repeat((amount, 1,1,1))

if "batch_index" in s:

offset = max(s["batch_index"]) - min(s["batch_index"]) + 1

s["batch_index"] = s["batch_index"] + [x + (i * offset) for i in range(1, amount) for x in s["batch_index"]]

upscale_methods = ["nearest-exact", "bilinear", "area", "bicubic", "bislerp"]

crop_methods = ["disabled", "center"]

@classmethod

def INPUT_TYPES(s):

return {"required": { "samples": ("LATENT",), "upscale_method": (s.upscale_methods,),

"width": ("INT", {"default": 512, "min": 64, "max": MAX_RESOLUTION, "step": 8}),

"height": ("INT", {"default": 512, "min": 64, "max": MAX_RESOLUTION, "step": 8}),

"crop": (s.crop_methods,)}}

RETURN_TYPES = ("LATENT",)

FUNCTION = "upscale"

CATEGORY = "latent"

def upscale(self, samples, upscale_method, width, height, crop):

s = samples.copy()

s["samples"] = comfy.utils.common_upscale(samples["samples"], width // 8, height // 8, upscale_method, crop)

upscale_methods = ["nearest-exact", "bilinear", "area", "bicubic", "bislerp"]

@classmethod

def INPUT_TYPES(s):

return {"required": { "samples": ("LATENT",), "upscale_method": (s.upscale_methods,),

"scale_by": ("FLOAT", {"default": 1.5, "min": 0.01, "max": 8.0, "step": 0.01}),}}

RETURN_TYPES = ("LATENT",)

FUNCTION = "upscale"

CATEGORY = "latent"

def upscale(self, samples, upscale_method, scale_by):

s = samples.copy()

width = round(samples["samples"].shape[3] * scale_by)

height = round(samples["samples"].shape[2] * scale_by)

s["samples"] = comfy.utils.common_upscale(samples["samples"], width, height, upscale_method, "disabled")

@classmethod

def INPUT_TYPES(s):

return {"required": { "samples": ("LATENT",),

"rotation": (["none", "90 degrees", "180 degrees", "270 degrees"],),

}}

RETURN_TYPES = ("LATENT",)