nodes.py 47.2 KB
Newer Older
comfyanonymous's avatar
comfyanonymous committed
1
2
3
4
5
import torch

import os
import sys
import json
6
import hashlib
7
import traceback
8
import math
comfyanonymous's avatar
comfyanonymous committed
9
10
11
12
13

from PIL import Image
from PIL.PngImagePlugin import PngInfo
import numpy as np

sALTaccount's avatar
sALTaccount committed
14

comfyanonymous's avatar
comfyanonymous committed
15
sys.path.insert(0, os.path.join(os.path.dirname(os.path.realpath(__file__)), "comfy"))
comfyanonymous's avatar
comfyanonymous committed
16
17


comfyanonymous's avatar
comfyanonymous committed
18
import comfy.diffusers_convert
comfyanonymous's avatar
comfyanonymous committed
19
import comfy.samplers
20
import comfy.sample
comfyanonymous's avatar
comfyanonymous committed
21
import comfy.sd
comfyanonymous's avatar
comfyanonymous committed
22
23
import comfy.utils

24
import comfy.clip_vision
25

26
import comfy.model_management
27
import importlib
comfyanonymous's avatar
comfyanonymous committed
28

29
import folder_paths
30
31

def before_node_execution():
32
    comfy.model_management.throw_exception_if_processing_interrupted()
33

34
def interrupt_processing(value=True):
35
    comfy.model_management.interrupt_current_processing(value)
36

37
38
MAX_RESOLUTION=8192

comfyanonymous's avatar
comfyanonymous committed
39
40
41
class CLIPTextEncode:
    @classmethod
    def INPUT_TYPES(s):
42
        return {"required": {"text": ("STRING", {"multiline": True}), "clip": ("CLIP", )}}
comfyanonymous's avatar
comfyanonymous committed
43
44
45
    RETURN_TYPES = ("CONDITIONING",)
    FUNCTION = "encode"

46
47
    CATEGORY = "conditioning"

comfyanonymous's avatar
comfyanonymous committed
48
    def encode(self, clip, text):
comfyanonymous's avatar
comfyanonymous committed
49
50
51
52
53
54
55
56
57
        return ([[clip.encode(text), {}]], )

class ConditioningCombine:
    @classmethod
    def INPUT_TYPES(s):
        return {"required": {"conditioning_1": ("CONDITIONING", ), "conditioning_2": ("CONDITIONING", )}}
    RETURN_TYPES = ("CONDITIONING",)
    FUNCTION = "combine"

58
59
    CATEGORY = "conditioning"

comfyanonymous's avatar
comfyanonymous committed
60
61
62
    def combine(self, conditioning_1, conditioning_2):
        return (conditioning_1 + conditioning_2, )

FizzleDorf's avatar
FizzleDorf committed
63
64
65
class ConditioningAverage :
    @classmethod
    def INPUT_TYPES(s):
comfyanonymous's avatar
comfyanonymous committed
66
67
        return {"required": {"conditioning_to": ("CONDITIONING", ), "conditioning_from": ("CONDITIONING", ),
                              "conditioning_to_strength": ("FLOAT", {"default": 1.0, "min": 0.0, "max": 1.0, "step": 0.01})
FizzleDorf's avatar
FizzleDorf committed
68
69
70
71
72
73
                             }}
    RETURN_TYPES = ("CONDITIONING",)
    FUNCTION = "addWeighted"

    CATEGORY = "conditioning"

comfyanonymous's avatar
comfyanonymous committed
74
    def addWeighted(self, conditioning_to, conditioning_from, conditioning_to_strength):
FizzleDorf's avatar
FizzleDorf committed
75
        out = []
comfyanonymous's avatar
comfyanonymous committed
76
77
78
79
80
81
82
83
84
85
86
87
88
89

        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]

        for i in range(len(conditioning_to)):
            t1 = conditioning_to[i][0]
            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))
            n = [tw, conditioning_to[i][1].copy()]
FizzleDorf's avatar
FizzleDorf committed
90
91
92
            out.append(n)
        return (out, )

comfyanonymous's avatar
comfyanonymous committed
93
94
95
96
class ConditioningSetArea:
    @classmethod
    def INPUT_TYPES(s):
        return {"required": {"conditioning": ("CONDITIONING", ),
97
98
99
100
                              "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}),
comfyanonymous's avatar
comfyanonymous committed
101
102
103
104
105
                              "strength": ("FLOAT", {"default": 1.0, "min": 0.0, "max": 10.0, "step": 0.01}),
                             }}
    RETURN_TYPES = ("CONDITIONING",)
    FUNCTION = "append"

106
107
    CATEGORY = "conditioning"

comfyanonymous's avatar
comfyanonymous committed
108
    def append(self, conditioning, width, height, x, y, strength, min_sigma=0.0, max_sigma=99.0):
comfyanonymous's avatar
comfyanonymous committed
109
110
111
112
113
        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
114
            n[1]['set_area_to_bounds'] = False
comfyanonymous's avatar
comfyanonymous committed
115
116
117
            n[1]['min_sigma'] = min_sigma
            n[1]['max_sigma'] = max_sigma
            c.append(n)
comfyanonymous's avatar
comfyanonymous committed
118
        return (c, )
comfyanonymous's avatar
comfyanonymous committed
119

Jacob Segal's avatar
Jacob Segal committed
120
121
122
123
124
125
class ConditioningSetMask:
    @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}),
126
                              "set_cond_area": (["default", "mask bounds"],),
Jacob Segal's avatar
Jacob Segal committed
127
128
129
130
131
132
                             }}
    RETURN_TYPES = ("CONDITIONING",)
    FUNCTION = "append"

    CATEGORY = "conditioning"

133
    def append(self, conditioning, mask, set_cond_area, strength):
Jacob Segal's avatar
Jacob Segal committed
134
        c = []
135
136
137
        set_area_to_bounds = False
        if set_cond_area != "default":
            set_area_to_bounds = True
Jacob Segal's avatar
Jacob Segal committed
138
139
140
141
142
143
        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
Jacob Segal's avatar
Jacob Segal committed
144
            n[1]['set_area_to_bounds'] = set_area_to_bounds
145
            n[1]['mask_strength'] = strength
Jacob Segal's avatar
Jacob Segal committed
146
147
148
            c.append(n)
        return (c, )

comfyanonymous's avatar
comfyanonymous committed
149
150
151
152
153
154
155
156
157
158
class VAEDecode:
    def __init__(self, device="cpu"):
        self.device = device

    @classmethod
    def INPUT_TYPES(s):
        return {"required": { "samples": ("LATENT", ), "vae": ("VAE", )}}
    RETURN_TYPES = ("IMAGE",)
    FUNCTION = "decode"

159
160
    CATEGORY = "latent"

comfyanonymous's avatar
comfyanonymous committed
161
    def decode(self, vae, samples):
162
        return (vae.decode(samples["samples"]), )
comfyanonymous's avatar
comfyanonymous committed
163

164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
class VAEDecodeTiled:
    def __init__(self, device="cpu"):
        self.device = device

    @classmethod
    def INPUT_TYPES(s):
        return {"required": { "samples": ("LATENT", ), "vae": ("VAE", )}}
    RETURN_TYPES = ("IMAGE",)
    FUNCTION = "decode"

    CATEGORY = "_for_testing"

    def decode(self, vae, samples):
        return (vae.decode_tiled(samples["samples"]), )

comfyanonymous's avatar
comfyanonymous committed
179
180
181
182
183
184
185
186
187
188
class VAEEncode:
    def __init__(self, device="cpu"):
        self.device = device

    @classmethod
    def INPUT_TYPES(s):
        return {"required": { "pixels": ("IMAGE", ), "vae": ("VAE", )}}
    RETURN_TYPES = ("LATENT",)
    FUNCTION = "encode"

189
190
    CATEGORY = "latent"

191
192
193
194
    @staticmethod
    def vae_encode_crop_pixels(pixels):
        x = (pixels.shape[1] // 8) * 8
        y = (pixels.shape[2] // 8) * 8
195
        if pixels.shape[1] != x or pixels.shape[2] != y:
196
197
198
199
            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
200

201
202
203
    def encode(self, vae, pixels):
        pixels = self.vae_encode_crop_pixels(pixels)
        t = vae.encode(pixels[:,:,:,:3])
204
        return ({"samples":t}, )
comfyanonymous's avatar
comfyanonymous committed
205

comfyanonymous's avatar
comfyanonymous committed
206
207
208
209
210
211
212
213
214
215
216
217
218
class VAEEncodeTiled:
    def __init__(self, device="cpu"):
        self.device = device

    @classmethod
    def INPUT_TYPES(s):
        return {"required": { "pixels": ("IMAGE", ), "vae": ("VAE", )}}
    RETURN_TYPES = ("LATENT",)
    FUNCTION = "encode"

    CATEGORY = "_for_testing"

    def encode(self, vae, pixels):
219
        pixels = VAEEncode.vae_encode_crop_pixels(pixels)
comfyanonymous's avatar
comfyanonymous committed
220
221
        t = vae.encode_tiled(pixels[:,:,:,:3])
        return ({"samples":t}, )
222

223
224
225
226
227
228
class VAEEncodeForInpaint:
    def __init__(self, device="cpu"):
        self.device = device

    @classmethod
    def INPUT_TYPES(s):
229
        return {"required": { "pixels": ("IMAGE", ), "vae": ("VAE", ), "mask": ("MASK", ), "grow_mask_by": ("INT", {"default": 6, "min": 0, "max": 64, "step": 1}),}}
230
231
232
233
234
    RETURN_TYPES = ("LATENT",)
    FUNCTION = "encode"

    CATEGORY = "latent/inpaint"

235
    def encode(self, vae, pixels, mask, grow_mask_by=6):
236
237
        x = (pixels.shape[1] // 8) * 8
        y = (pixels.shape[2] // 8) * 8
238
        mask = torch.nn.functional.interpolate(mask.reshape((-1, 1, mask.shape[-2], mask.shape[-1])), size=(pixels.shape[1], pixels.shape[2]), mode="bilinear")
239

240
        pixels = pixels.clone()
241
        if pixels.shape[1] != x or pixels.shape[2] != y:
242
243
244
245
            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]
246

247
        #grow mask by a few pixels to keep things seamless in latent space
248
249
250
251
252
253
254
255
        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)

256
        m = (1.0 - mask.round()).squeeze(1)
257
258
        for i in range(3):
            pixels[:,:,:,i] -= 0.5
259
            pixels[:,:,:,i] *= m
260
261
262
            pixels[:,:,:,i] += 0.5
        t = vae.encode(pixels)

263
        return ({"samples":t, "noise_mask": (mask_erosion[:,:,:x,:y].round())}, )
comfyanonymous's avatar
comfyanonymous committed
264
265
266
267

class CheckpointLoader:
    @classmethod
    def INPUT_TYPES(s):
268
269
        return {"required": { "config_name": (folder_paths.get_filename_list("configs"), ),
                              "ckpt_name": (folder_paths.get_filename_list("checkpoints"), )}}
comfyanonymous's avatar
comfyanonymous committed
270
271
272
    RETURN_TYPES = ("MODEL", "CLIP", "VAE")
    FUNCTION = "load_checkpoint"

273
    CATEGORY = "advanced/loaders"
274

comfyanonymous's avatar
comfyanonymous committed
275
    def load_checkpoint(self, config_name, ckpt_name, output_vae=True, output_clip=True):
276
277
        config_path = folder_paths.get_full_path("configs", config_name)
        ckpt_path = folder_paths.get_full_path("checkpoints", ckpt_name)
278
        return comfy.sd.load_checkpoint(config_path, ckpt_path, output_vae=True, output_clip=True, embedding_directory=folder_paths.get_folder_paths("embeddings"))
comfyanonymous's avatar
comfyanonymous committed
279

280
281
282
class CheckpointLoaderSimple:
    @classmethod
    def INPUT_TYPES(s):
283
        return {"required": { "ckpt_name": (folder_paths.get_filename_list("checkpoints"), ),
284
285
286
287
                             }}
    RETURN_TYPES = ("MODEL", "CLIP", "VAE")
    FUNCTION = "load_checkpoint"

288
    CATEGORY = "loaders"
289

290
    def load_checkpoint(self, ckpt_name, output_vae=True, output_clip=True):
291
        ckpt_path = folder_paths.get_full_path("checkpoints", ckpt_name)
292
        out = comfy.sd.load_checkpoint_guess_config(ckpt_path, output_vae=True, output_clip=True, embedding_directory=folder_paths.get_folder_paths("embeddings"))
293
294
        return out

sALTaccount's avatar
sALTaccount committed
295
296
297
class DiffusersLoader:
    @classmethod
    def INPUT_TYPES(cls):
298
        paths = []
sALTaccount's avatar
sALTaccount committed
299
        for search_path in folder_paths.get_folder_paths("diffusers"):
300
            if os.path.exists(search_path):
sALTaccount's avatar
sALTaccount committed
301
                paths += next(os.walk(search_path))[1]
302
        return {"required": {"model_path": (paths,), }}
sALTaccount's avatar
sALTaccount committed
303
304
305
    RETURN_TYPES = ("MODEL", "CLIP", "VAE")
    FUNCTION = "load_checkpoint"

306
    CATEGORY = "advanced/loaders"
sALTaccount's avatar
sALTaccount committed
307
308

    def load_checkpoint(self, model_path, output_vae=True, output_clip=True):
sALTaccount's avatar
sALTaccount committed
309
310
311
312
313
314
        for search_path in folder_paths.get_folder_paths("diffusers"):
            if os.path.exists(search_path):
                paths = next(os.walk(search_path))[1]
                if model_path in paths:
                    model_path = os.path.join(search_path, model_path)
                    break
315

316
        return comfy.diffusers_convert.load_diffusers(model_path, fp16=comfy.model_management.should_use_fp16(), output_vae=output_vae, output_clip=output_clip, embedding_directory=folder_paths.get_folder_paths("embeddings"))
sALTaccount's avatar
sALTaccount committed
317
318


319
320
321
322
323
324
325
326
class unCLIPCheckpointLoader:
    @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"

327
    CATEGORY = "loaders"
328
329
330
331
332
333

    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"))
        return out

comfyanonymous's avatar
comfyanonymous committed
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
class CLIPSetLastLayer:
    @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)
        return (clip,)

350
351
352
353
354
class LoraLoader:
    @classmethod
    def INPUT_TYPES(s):
        return {"required": { "model": ("MODEL",),
                              "clip": ("CLIP", ),
355
                              "lora_name": (folder_paths.get_filename_list("loras"), ),
356
357
                              "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}),
358
359
360
361
362
363
364
                              }}
    RETURN_TYPES = ("MODEL", "CLIP")
    FUNCTION = "load_lora"

    CATEGORY = "loaders"

    def load_lora(self, model, clip, lora_name, strength_model, strength_clip):
365
        lora_path = folder_paths.get_full_path("loras", lora_name)
366
367
368
        model_lora, clip_lora = comfy.sd.load_lora_for_models(model, clip, lora_path, strength_model, strength_clip)
        return (model_lora, clip_lora)

369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
class TomePatchModel:
    @classmethod
    def INPUT_TYPES(s):
        return {"required": { "model": ("MODEL",),
                              "ratio": ("FLOAT", {"default": 0.3, "min": 0.0, "max": 1.0, "step": 0.01}),
                              }}
    RETURN_TYPES = ("MODEL",)
    FUNCTION = "patch"

    CATEGORY = "_for_testing"

    def patch(self, model, ratio):
        m = model.clone()
        m.set_model_tomesd(ratio)
        return (m, )

comfyanonymous's avatar
comfyanonymous committed
385
386
387
class VAELoader:
    @classmethod
    def INPUT_TYPES(s):
388
        return {"required": { "vae_name": (folder_paths.get_filename_list("vae"), )}}
comfyanonymous's avatar
comfyanonymous committed
389
390
391
    RETURN_TYPES = ("VAE",)
    FUNCTION = "load_vae"

392
393
    CATEGORY = "loaders"

comfyanonymous's avatar
comfyanonymous committed
394
395
    #TODO: scale factor?
    def load_vae(self, vae_name):
396
        vae_path = folder_paths.get_full_path("vae", vae_name)
comfyanonymous's avatar
comfyanonymous committed
397
398
399
        vae = comfy.sd.VAE(ckpt_path=vae_path)
        return (vae,)

comfyanonymous's avatar
comfyanonymous committed
400
401
402
class ControlNetLoader:
    @classmethod
    def INPUT_TYPES(s):
403
        return {"required": { "control_net_name": (folder_paths.get_filename_list("controlnet"), )}}
comfyanonymous's avatar
comfyanonymous committed
404
405
406
407
408
409
410

    RETURN_TYPES = ("CONTROL_NET",)
    FUNCTION = "load_controlnet"

    CATEGORY = "loaders"

    def load_controlnet(self, control_net_name):
411
        controlnet_path = folder_paths.get_full_path("controlnet", control_net_name)
comfyanonymous's avatar
comfyanonymous committed
412
413
414
        controlnet = comfy.sd.load_controlnet(controlnet_path)
        return (controlnet,)

415
416
417
418
class DiffControlNetLoader:
    @classmethod
    def INPUT_TYPES(s):
        return {"required": { "model": ("MODEL",),
419
                              "control_net_name": (folder_paths.get_filename_list("controlnet"), )}}
420
421
422
423
424
425
426

    RETURN_TYPES = ("CONTROL_NET",)
    FUNCTION = "load_controlnet"

    CATEGORY = "loaders"

    def load_controlnet(self, model, control_net_name):
427
        controlnet_path = folder_paths.get_full_path("controlnet", control_net_name)
428
429
430
        controlnet = comfy.sd.load_controlnet(controlnet_path, model)
        return (controlnet,)

comfyanonymous's avatar
comfyanonymous committed
431
432
433
434

class ControlNetApply:
    @classmethod
    def INPUT_TYPES(s):
435
436
437
438
439
        return {"required": {"conditioning": ("CONDITIONING", ),
                             "control_net": ("CONTROL_NET", ),
                             "image": ("IMAGE", ),
                             "strength": ("FLOAT", {"default": 1.0, "min": 0.0, "max": 10.0, "step": 0.01})
                             }}
comfyanonymous's avatar
comfyanonymous committed
440
441
442
443
444
    RETURN_TYPES = ("CONDITIONING",)
    FUNCTION = "apply_controlnet"

    CATEGORY = "conditioning"

445
    def apply_controlnet(self, conditioning, control_net, image, strength):
comfyanonymous's avatar
comfyanonymous committed
446
447
448
449
450
        c = []
        control_hint = image.movedim(-1,1)
        print(control_hint.shape)
        for t in conditioning:
            n = [t[0], t[1].copy()]
comfyanonymous's avatar
comfyanonymous committed
451
452
453
454
            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
comfyanonymous's avatar
comfyanonymous committed
455
456
457
            c.append(n)
        return (c, )

458
459
460
class CLIPLoader:
    @classmethod
    def INPUT_TYPES(s):
461
        return {"required": { "clip_name": (folder_paths.get_filename_list("clip"), ),
462
463
464
465
466
467
                             }}
    RETURN_TYPES = ("CLIP",)
    FUNCTION = "load_clip"

    CATEGORY = "loaders"

468
    def load_clip(self, clip_name):
469
        clip_path = folder_paths.get_full_path("clip", clip_name)
comfyanonymous's avatar
comfyanonymous committed
470
        clip = comfy.sd.load_clip(ckpt_path=clip_path, embedding_directory=folder_paths.get_folder_paths("embeddings"))
471
472
        return (clip,)

473
474
475
class CLIPVisionLoader:
    @classmethod
    def INPUT_TYPES(s):
476
        return {"required": { "clip_name": (folder_paths.get_filename_list("clip_vision"), ),
477
478
479
480
481
482
483
                             }}
    RETURN_TYPES = ("CLIP_VISION",)
    FUNCTION = "load_clip"

    CATEGORY = "loaders"

    def load_clip(self, clip_name):
484
        clip_path = folder_paths.get_full_path("clip_vision", clip_name)
485
        clip_vision = comfy.clip_vision.load(clip_path)
486
487
488
489
490
491
492
493
        return (clip_vision,)

class CLIPVisionEncode:
    @classmethod
    def INPUT_TYPES(s):
        return {"required": { "clip_vision": ("CLIP_VISION",),
                              "image": ("IMAGE",)
                             }}
comfyanonymous's avatar
comfyanonymous committed
494
    RETURN_TYPES = ("CLIP_VISION_OUTPUT",)
495
496
    FUNCTION = "encode"

497
    CATEGORY = "conditioning"
498
499
500
501
502
503
504
505

    def encode(self, clip_vision, image):
        output = clip_vision.encode_image(image)
        return (output,)

class StyleModelLoader:
    @classmethod
    def INPUT_TYPES(s):
506
        return {"required": { "style_model_name": (folder_paths.get_filename_list("style_models"), )}}
507
508
509
510
511
512
513

    RETURN_TYPES = ("STYLE_MODEL",)
    FUNCTION = "load_style_model"

    CATEGORY = "loaders"

    def load_style_model(self, style_model_name):
514
        style_model_path = folder_paths.get_full_path("style_models", style_model_name)
515
516
517
518
519
520
521
        style_model = comfy.sd.load_style_model(style_model_path)
        return (style_model,)


class StyleModelApply:
    @classmethod
    def INPUT_TYPES(s):
522
523
524
        return {"required": {"conditioning": ("CONDITIONING", ),
                             "style_model": ("STYLE_MODEL", ),
                             "clip_vision_output": ("CLIP_VISION_OUTPUT", ),
525
526
527
528
                             }}
    RETURN_TYPES = ("CONDITIONING",)
    FUNCTION = "apply_stylemodel"

comfyanonymous's avatar
comfyanonymous committed
529
    CATEGORY = "conditioning/style_model"
530

531
532
    def apply_stylemodel(self, clip_vision_output, style_model, conditioning):
        cond = style_model.get_cond(clip_vision_output)
533
        c = []
534
535
        for t in conditioning:
            n = [torch.cat((t[0], cond), dim=1), t[1].copy()]
536
537
538
            c.append(n)
        return (c, )

539
540
541
542
543
544
class unCLIPConditioning:
    @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}),
545
                             "noise_augmentation": ("FLOAT", {"default": 0.0, "min": 0.0, "max": 1.0, "step": 0.01}),
546
547
548
549
                             }}
    RETURN_TYPES = ("CONDITIONING",)
    FUNCTION = "apply_adm"

550
    CATEGORY = "conditioning"
551

552
    def apply_adm(self, conditioning, clip_vision_output, strength, noise_augmentation):
553
554
555
        c = []
        for t in conditioning:
            o = t[1].copy()
556
            x = (clip_vision_output, strength, noise_augmentation)
557
558
559
560
561
562
563
564
            if "adm" in o:
                o["adm"] = o["adm"][:] + [x]
            else:
                o["adm"] = [x]
            n = [t[0], o]
            c.append(n)
        return (c, )

565
566
567
568
569
570
571
572
class GLIGENLoader:
    @classmethod
    def INPUT_TYPES(s):
        return {"required": { "gligen_name": (folder_paths.get_filename_list("gligen"), )}}

    RETURN_TYPES = ("GLIGEN",)
    FUNCTION = "load_gligen"

comfyanonymous's avatar
comfyanonymous committed
573
    CATEGORY = "loaders"
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594

    def load_gligen(self, gligen_name):
        gligen_path = folder_paths.get_full_path("gligen", gligen_name)
        gligen = comfy.sd.load_gligen(gligen_path)
        return (gligen,)

class GLIGENTextBoxApply:
    @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"

comfyanonymous's avatar
comfyanonymous committed
595
    CATEGORY = "conditioning/gligen"
596
597
598
599
600
601
602
603
604
605
606
607
608
609

    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)
        return (c, )
610

comfyanonymous's avatar
comfyanonymous committed
611
612
613
614
615
616
class EmptyLatentImage:
    def __init__(self, device="cpu"):
        self.device = device

    @classmethod
    def INPUT_TYPES(s):
617
618
        return {"required": { "width": ("INT", {"default": 512, "min": 64, "max": MAX_RESOLUTION, "step": 8}),
                              "height": ("INT", {"default": 512, "min": 64, "max": MAX_RESOLUTION, "step": 8}),
comfyanonymous's avatar
comfyanonymous committed
619
620
621
622
                              "batch_size": ("INT", {"default": 1, "min": 1, "max": 64})}}
    RETURN_TYPES = ("LATENT",)
    FUNCTION = "generate"

623
624
    CATEGORY = "latent"

comfyanonymous's avatar
comfyanonymous committed
625
626
    def generate(self, width, height, batch_size=1):
        latent = torch.zeros([batch_size, 4, height // 8, width // 8])
627
        return ({"samples":latent}, )
comfyanonymous's avatar
comfyanonymous committed
628

comfyanonymous's avatar
comfyanonymous committed
629

630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
class LatentFromBatch:
    @classmethod
    def INPUT_TYPES(s):
        return {"required": { "samples": ("LATENT",),
                              "batch_index": ("INT", {"default": 0, "min": 0, "max": 63}),
                              }}
    RETURN_TYPES = ("LATENT",)
    FUNCTION = "rotate"

    CATEGORY = "latent"

    def rotate(self, samples, batch_index):
        s = samples.copy()
        s_in = samples["samples"]
        batch_index = min(s_in.shape[0] - 1, batch_index)
        s["samples"] = s_in[batch_index:batch_index + 1].clone()
        s["batch_index"] = batch_index
        return (s,)
comfyanonymous's avatar
comfyanonymous committed
648

comfyanonymous's avatar
comfyanonymous committed
649
650
class LatentUpscale:
    upscale_methods = ["nearest-exact", "bilinear", "area"]
651
    crop_methods = ["disabled", "center"]
comfyanonymous's avatar
comfyanonymous committed
652
653
654
655

    @classmethod
    def INPUT_TYPES(s):
        return {"required": { "samples": ("LATENT",), "upscale_method": (s.upscale_methods,),
656
657
                              "width": ("INT", {"default": 512, "min": 64, "max": MAX_RESOLUTION, "step": 8}),
                              "height": ("INT", {"default": 512, "min": 64, "max": MAX_RESOLUTION, "step": 8}),
658
                              "crop": (s.crop_methods,)}}
comfyanonymous's avatar
comfyanonymous committed
659
660
661
    RETURN_TYPES = ("LATENT",)
    FUNCTION = "upscale"

662
663
    CATEGORY = "latent"

664
    def upscale(self, samples, upscale_method, width, height, crop):
665
        s = samples.copy()
comfyanonymous's avatar
comfyanonymous committed
666
        s["samples"] = comfy.utils.common_upscale(samples["samples"], width // 8, height // 8, upscale_method, crop)
comfyanonymous's avatar
comfyanonymous committed
667
668
        return (s,)

comfyanonymous's avatar
comfyanonymous committed
669
670
671
672
673
674
675
676
677
class LatentRotate:
    @classmethod
    def INPUT_TYPES(s):
        return {"required": { "samples": ("LATENT",),
                              "rotation": (["none", "90 degrees", "180 degrees", "270 degrees"],),
                              }}
    RETURN_TYPES = ("LATENT",)
    FUNCTION = "rotate"

comfyanonymous's avatar
comfyanonymous committed
678
    CATEGORY = "latent/transform"
comfyanonymous's avatar
comfyanonymous committed
679
680

    def rotate(self, samples, rotation):
681
        s = samples.copy()
comfyanonymous's avatar
comfyanonymous committed
682
683
684
685
686
687
688
689
        rotate_by = 0
        if rotation.startswith("90"):
            rotate_by = 1
        elif rotation.startswith("180"):
            rotate_by = 2
        elif rotation.startswith("270"):
            rotate_by = 3

690
        s["samples"] = torch.rot90(samples["samples"], k=rotate_by, dims=[3, 2])
comfyanonymous's avatar
comfyanonymous committed
691
        return (s,)
comfyanonymous's avatar
comfyanonymous committed
692
693
694
695
696
697
698
699
700
701

class LatentFlip:
    @classmethod
    def INPUT_TYPES(s):
        return {"required": { "samples": ("LATENT",),
                              "flip_method": (["x-axis: vertically", "y-axis: horizontally"],),
                              }}
    RETURN_TYPES = ("LATENT",)
    FUNCTION = "flip"

comfyanonymous's avatar
comfyanonymous committed
702
    CATEGORY = "latent/transform"
comfyanonymous's avatar
comfyanonymous committed
703
704

    def flip(self, samples, flip_method):
705
        s = samples.copy()
comfyanonymous's avatar
comfyanonymous committed
706
        if flip_method.startswith("x"):
707
            s["samples"] = torch.flip(samples["samples"], dims=[2])
comfyanonymous's avatar
comfyanonymous committed
708
        elif flip_method.startswith("y"):
709
            s["samples"] = torch.flip(samples["samples"], dims=[3])
comfyanonymous's avatar
comfyanonymous committed
710
711

        return (s,)
comfyanonymous's avatar
comfyanonymous committed
712
713
714
715

class LatentComposite:
    @classmethod
    def INPUT_TYPES(s):
comfyanonymous's avatar
comfyanonymous committed
716
717
718
719
720
721
        return {"required": { "samples_to": ("LATENT",),
                              "samples_from": ("LATENT",),
                              "x": ("INT", {"default": 0, "min": 0, "max": MAX_RESOLUTION, "step": 8}),
                              "y": ("INT", {"default": 0, "min": 0, "max": MAX_RESOLUTION, "step": 8}),
                              "feather": ("INT", {"default": 0, "min": 0, "max": MAX_RESOLUTION, "step": 8}),
                              }}
comfyanonymous's avatar
comfyanonymous committed
722
723
724
725
726
    RETURN_TYPES = ("LATENT",)
    FUNCTION = "composite"

    CATEGORY = "latent"

comfyanonymous's avatar
comfyanonymous committed
727
728
729
    def composite(self, samples_to, samples_from, x, y, composite_method="normal", feather=0):
        x =  x // 8
        y = y // 8
730
        feather = feather // 8
comfyanonymous's avatar
comfyanonymous committed
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
        samples_out = samples_to.copy()
        s = samples_to["samples"].clone()
        samples_to = samples_to["samples"]
        samples_from = samples_from["samples"]
        if feather == 0:
            s[:,:,y:y+samples_from.shape[2],x:x+samples_from.shape[3]] = samples_from[:,:,:samples_to.shape[2] - y, :samples_to.shape[3] - x]
        else:
            samples_from = samples_from[:,:,:samples_to.shape[2] - y, :samples_to.shape[3] - x]
            mask = torch.ones_like(samples_from)
            for t in range(feather):
                if y != 0:
                    mask[:,:,t:1+t,:] *= ((1.0/feather) * (t + 1))

                if y + samples_from.shape[2] < samples_to.shape[2]:
                    mask[:,:,mask.shape[2] -1 -t: mask.shape[2]-t,:] *= ((1.0/feather) * (t + 1))
                if x != 0:
                    mask[:,:,:,t:1+t] *= ((1.0/feather) * (t + 1))
                if x + samples_from.shape[3] < samples_to.shape[3]:
                    mask[:,:,:,mask.shape[3]- 1 - t: mask.shape[3]- t] *= ((1.0/feather) * (t + 1))
            rev_mask = torch.ones_like(mask) - mask
            s[:,:,y:y+samples_from.shape[2],x:x+samples_from.shape[3]] = samples_from[:,:,:samples_to.shape[2] - y, :samples_to.shape[3] - x] * mask + s[:,:,y:y+samples_from.shape[2],x:x+samples_from.shape[3]] * rev_mask
        samples_out["samples"] = s
        return (samples_out,)
comfyanonymous's avatar
comfyanonymous committed
754

comfyanonymous's avatar
comfyanonymous committed
755
756
757
758
class LatentCrop:
    @classmethod
    def INPUT_TYPES(s):
        return {"required": { "samples": ("LATENT",),
759
760
                              "width": ("INT", {"default": 512, "min": 64, "max": MAX_RESOLUTION, "step": 8}),
                              "height": ("INT", {"default": 512, "min": 64, "max": MAX_RESOLUTION, "step": 8}),
761
762
                              "x": ("INT", {"default": 0, "min": 0, "max": MAX_RESOLUTION, "step": 8}),
                              "y": ("INT", {"default": 0, "min": 0, "max": MAX_RESOLUTION, "step": 8}),
comfyanonymous's avatar
comfyanonymous committed
763
764
765
766
                              }}
    RETURN_TYPES = ("LATENT",)
    FUNCTION = "crop"

comfyanonymous's avatar
comfyanonymous committed
767
    CATEGORY = "latent/transform"
comfyanonymous's avatar
comfyanonymous committed
768
769

    def crop(self, samples, width, height, x, y):
770
771
        s = samples.copy()
        samples = samples['samples']
comfyanonymous's avatar
comfyanonymous committed
772
773
774
775
776
777
778
779
780
781
782
783
784
        x =  x // 8
        y = y // 8

        #enfonce minimum size of 64
        if x > (samples.shape[3] - 8):
            x = samples.shape[3] - 8
        if y > (samples.shape[2] - 8):
            y = samples.shape[2] - 8

        new_height = height // 8
        new_width = width // 8
        to_x = new_width + x
        to_y = new_height + y
785
        s['samples'] = samples[:,:,y:to_y, x:to_x]
comfyanonymous's avatar
comfyanonymous committed
786
787
        return (s,)

788
789
790
791
792
793
794
795
796
class SetLatentNoiseMask:
    @classmethod
    def INPUT_TYPES(s):
        return {"required": { "samples": ("LATENT",),
                              "mask": ("MASK",),
                              }}
    RETURN_TYPES = ("LATENT",)
    FUNCTION = "set_mask"

797
    CATEGORY = "latent/inpaint"
798
799
800
801
802
803

    def set_mask(self, samples, mask):
        s = samples.copy()
        s["noise_mask"] = mask
        return (s,)

804
def common_ksampler(model, seed, steps, cfg, sampler_name, scheduler, positive, negative, latent, denoise=1.0, disable_noise=False, start_step=None, last_step=None, force_full_denoise=False):
805
    device = comfy.model_management.get_torch_device()
806
    latent_image = latent["samples"]
807

comfyanonymous's avatar
comfyanonymous committed
808
809
810
    if disable_noise:
        noise = torch.zeros(latent_image.size(), dtype=latent_image.dtype, layout=latent_image.layout, device="cpu")
    else:
811
812
        skip = latent["batch_index"] if "batch_index" in latent else 0
        noise = comfy.sample.prepare_noise(latent_image, seed, skip)
comfyanonymous's avatar
comfyanonymous committed
813

814
    noise_mask = None
815
    if "noise_mask" in latent:
816
        noise_mask = latent["noise_mask"]
comfyanonymous's avatar
comfyanonymous committed
817

818
819
820
821
    pbar = comfy.utils.ProgressBar(steps)
    def callback(step, x0, x):
        pbar.update_absolute(step + 1)

822
823
    samples = comfy.sample.sample(model, noise, steps, cfg, sampler_name, scheduler, positive, negative, latent_image,
                                  denoise=denoise, disable_noise=disable_noise, start_step=start_step, last_step=last_step,
824
                                  force_full_denoise=force_full_denoise, noise_mask=noise_mask, callback=callback)
825
826
827
    out = latent.copy()
    out["samples"] = samples
    return (out, )
comfyanonymous's avatar
comfyanonymous committed
828

comfyanonymous's avatar
comfyanonymous committed
829
830
831
class KSampler:
    @classmethod
    def INPUT_TYPES(s):
comfyanonymous's avatar
comfyanonymous committed
832
        return {"required":
comfyanonymous's avatar
comfyanonymous committed
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
                    {"model": ("MODEL",),
                    "seed": ("INT", {"default": 0, "min": 0, "max": 0xffffffffffffffff}),
                    "steps": ("INT", {"default": 20, "min": 1, "max": 10000}),
                    "cfg": ("FLOAT", {"default": 8.0, "min": 0.0, "max": 100.0}),
                    "sampler_name": (comfy.samplers.KSampler.SAMPLERS, ),
                    "scheduler": (comfy.samplers.KSampler.SCHEDULERS, ),
                    "positive": ("CONDITIONING", ),
                    "negative": ("CONDITIONING", ),
                    "latent_image": ("LATENT", ),
                    "denoise": ("FLOAT", {"default": 1.0, "min": 0.0, "max": 1.0, "step": 0.01}),
                    }}

    RETURN_TYPES = ("LATENT",)
    FUNCTION = "sample"

848
849
    CATEGORY = "sampling"

comfyanonymous's avatar
comfyanonymous committed
850
    def sample(self, model, seed, steps, cfg, sampler_name, scheduler, positive, negative, latent_image, denoise=1.0):
851
        return common_ksampler(model, seed, steps, cfg, sampler_name, scheduler, positive, negative, latent_image, denoise=denoise)
comfyanonymous's avatar
comfyanonymous committed
852

comfyanonymous's avatar
comfyanonymous committed
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
class KSamplerAdvanced:
    @classmethod
    def INPUT_TYPES(s):
        return {"required":
                    {"model": ("MODEL",),
                    "add_noise": (["enable", "disable"], ),
                    "noise_seed": ("INT", {"default": 0, "min": 0, "max": 0xffffffffffffffff}),
                    "steps": ("INT", {"default": 20, "min": 1, "max": 10000}),
                    "cfg": ("FLOAT", {"default": 8.0, "min": 0.0, "max": 100.0}),
                    "sampler_name": (comfy.samplers.KSampler.SAMPLERS, ),
                    "scheduler": (comfy.samplers.KSampler.SCHEDULERS, ),
                    "positive": ("CONDITIONING", ),
                    "negative": ("CONDITIONING", ),
                    "latent_image": ("LATENT", ),
                    "start_at_step": ("INT", {"default": 0, "min": 0, "max": 10000}),
                    "end_at_step": ("INT", {"default": 10000, "min": 0, "max": 10000}),
                    "return_with_leftover_noise": (["disable", "enable"], ),
                    }}

    RETURN_TYPES = ("LATENT",)
    FUNCTION = "sample"

    CATEGORY = "sampling"
comfyanonymous's avatar
comfyanonymous committed
876

comfyanonymous's avatar
comfyanonymous committed
877
878
879
880
881
882
883
    def sample(self, model, add_noise, noise_seed, steps, cfg, sampler_name, scheduler, positive, negative, latent_image, start_at_step, end_at_step, return_with_leftover_noise, denoise=1.0):
        force_full_denoise = True
        if return_with_leftover_noise == "enable":
            force_full_denoise = False
        disable_noise = False
        if add_noise == "disable":
            disable_noise = True
884
        return common_ksampler(model, noise_seed, steps, cfg, sampler_name, scheduler, positive, negative, latent_image, denoise=denoise, disable_noise=disable_noise, start_step=start_at_step, last_step=end_at_step, force_full_denoise=force_full_denoise)
comfyanonymous's avatar
comfyanonymous committed
885
886
887

class SaveImage:
    def __init__(self):
888
        self.output_dir = folder_paths.get_output_directory()
m957ymj75urz's avatar
m957ymj75urz committed
889
        self.type = "output"
comfyanonymous's avatar
comfyanonymous committed
890
891
892
893

    @classmethod
    def INPUT_TYPES(s):
        return {"required": 
894
                    {"images": ("IMAGE", ),
pythongosssss's avatar
tidy  
pythongosssss committed
895
                     "filename_prefix": ("STRING", {"default": "ComfyUI"})},
pythongosssss's avatar
pythongosssss committed
896
                "hidden": {"prompt": "PROMPT", "extra_pnginfo": "EXTRA_PNGINFO"},
comfyanonymous's avatar
comfyanonymous committed
897
898
899
900
901
902
903
                }

    RETURN_TYPES = ()
    FUNCTION = "save_images"

    OUTPUT_NODE = True

904
905
    CATEGORY = "image"

pythongosssss's avatar
tidy  
pythongosssss committed
906
    def save_images(self, images, filename_prefix="ComfyUI", prompt=None, extra_pnginfo=None):
907
        def map_filename(filename):
908
            prefix_len = len(os.path.basename(filename_prefix))
909
910
911
912
913
914
            prefix = filename[:prefix_len + 1]
            try:
                digits = int(filename[prefix_len + 1:].split('_')[0])
            except:
                digits = 0
            return (digits, prefix)
comfyanonymous's avatar
Style.  
comfyanonymous committed
915

916
917
918
919
        def compute_vars(input):
            input = input.replace("%width%", str(images[0].shape[1]))
            input = input.replace("%height%", str(images[0].shape[0]))
            return input
comfyanonymous's avatar
Style.  
comfyanonymous committed
920

921
        filename_prefix = compute_vars(filename_prefix)
comfyanonymous's avatar
comfyanonymous committed
922

m957ymj75urz's avatar
m957ymj75urz committed
923
924
925
        subfolder = os.path.dirname(os.path.normpath(filename_prefix))
        filename = os.path.basename(os.path.normpath(filename_prefix))

comfyanonymous's avatar
comfyanonymous committed
926
        full_output_folder = os.path.join(self.output_dir, subfolder)
927

928
        if os.path.commonpath((self.output_dir, os.path.abspath(full_output_folder))) != self.output_dir:
929
            print("Saving image outside the output folder is not allowed.")
comfyanonymous's avatar
comfyanonymous committed
930
931
            return {}

932
        try:
933
            counter = max(filter(lambda a: a[1][:-1] == filename and a[1][-1] == "_", map(map_filename, os.listdir(full_output_folder))))[0] + 1
934
935
        except ValueError:
            counter = 1
936
        except FileNotFoundError:
937
            os.makedirs(full_output_folder, exist_ok=True)
938
            counter = 1
pythongosssss's avatar
pythongosssss committed
939

m957ymj75urz's avatar
m957ymj75urz committed
940
        results = list()
comfyanonymous's avatar
comfyanonymous committed
941
942
        for image in images:
            i = 255. * image.cpu().numpy()
943
            img = Image.fromarray(np.clip(i, 0, 255).astype(np.uint8))
comfyanonymous's avatar
comfyanonymous committed
944
945
946
947
948
949
            metadata = PngInfo()
            if prompt is not None:
                metadata.add_text("prompt", json.dumps(prompt))
            if extra_pnginfo is not None:
                for x in extra_pnginfo:
                    metadata.add_text(x, json.dumps(extra_pnginfo[x]))
950

951
            file = f"{filename}_{counter:05}_.png"
952
            img.save(os.path.join(full_output_folder, file), pnginfo=metadata, compress_level=4)
m957ymj75urz's avatar
m957ymj75urz committed
953
954
955
956
            results.append({
                "filename": file,
                "subfolder": subfolder,
                "type": self.type
Gavroche CryptoRUSH's avatar
Gavroche CryptoRUSH committed
957
            })
958
            counter += 1
comfyanonymous's avatar
comfyanonymous committed
959

m957ymj75urz's avatar
m957ymj75urz committed
960
        return { "ui": { "images": results } }
comfyanonymous's avatar
comfyanonymous committed
961

pythongosssss's avatar
pythongosssss committed
962
963
class PreviewImage(SaveImage):
    def __init__(self):
964
        self.output_dir = folder_paths.get_temp_directory()
m957ymj75urz's avatar
m957ymj75urz committed
965
        self.type = "temp"
pythongosssss's avatar
pythongosssss committed
966
967
968

    @classmethod
    def INPUT_TYPES(s):
969
        return {"required":
pythongosssss's avatar
pythongosssss committed
970
971
972
                    {"images": ("IMAGE", ), },
                "hidden": {"prompt": "PROMPT", "extra_pnginfo": "EXTRA_PNGINFO"},
                }
973

974
975
976
class LoadImage:
    @classmethod
    def INPUT_TYPES(s):
977
        input_dir = folder_paths.get_input_directory()
978
        return {"required":
979
                    {"image": (sorted(os.listdir(input_dir)), )},
980
                }
981
982

    CATEGORY = "image"
983

984
    RETURN_TYPES = ("IMAGE", "MASK")
985
986
    FUNCTION = "load_image"
    def load_image(self, image):
987
        image_path = folder_paths.get_annotated_filepath(image)
988
989
        i = Image.open(image_path)
        image = i.convert("RGB")
990
        image = np.array(image).astype(np.float32) / 255.0
991
        image = torch.from_numpy(image)[None,]
992
993
994
995
996
997
        if 'A' in i.getbands():
            mask = np.array(i.getchannel('A')).astype(np.float32) / 255.0
            mask = 1. - torch.from_numpy(mask)
        else:
            mask = torch.zeros((64,64), dtype=torch.float32, device="cpu")
        return (image, mask)
998

999
1000
    @classmethod
    def IS_CHANGED(s, image):
1001
        image_path = folder_paths.get_annotated_filepath(image)
1002
1003
1004
1005
        m = hashlib.sha256()
        with open(image_path, 'rb') as f:
            m.update(f.read())
        return m.digest().hex()
pythongosssss's avatar
pythongosssss committed
1006

1007
1008
1009
1010
1011
1012
1013
    @classmethod
    def VALIDATE_INPUTS(s, image):
        if not folder_paths.exists_annotated_filepath(image):
            return "Invalid image file: {}".format(image)

        return True

1014
class LoadImageMask:
1015
    _color_channels = ["alpha", "red", "green", "blue"]
1016
1017
    @classmethod
    def INPUT_TYPES(s):
1018
        input_dir = folder_paths.get_input_directory()
1019
        return {"required":
1020
                    {"image": (sorted(os.listdir(input_dir)), ),
1021
                    "channel": (s._color_channels, ),}
1022
1023
                }

1024
    CATEGORY = "mask"
1025
1026
1027
1028

    RETURN_TYPES = ("MASK",)
    FUNCTION = "load_image"
    def load_image(self, image, channel):
1029
        image_path = folder_paths.get_annotated_filepath(image)
1030
        i = Image.open(image_path)
1031
1032
        if i.getbands() != ("R", "G", "B", "A"):
            i = i.convert("RGBA")
1033
1034
1035
1036
1037
1038
1039
1040
1041
1042
1043
1044
1045
        mask = None
        c = channel[0].upper()
        if c in i.getbands():
            mask = np.array(i.getchannel(c)).astype(np.float32) / 255.0
            mask = torch.from_numpy(mask)
            if c == 'A':
                mask = 1. - mask
        else:
            mask = torch.zeros((64,64), dtype=torch.float32, device="cpu")
        return (mask,)

    @classmethod
    def IS_CHANGED(s, image, channel):
1046
        image_path = folder_paths.get_annotated_filepath(image)
1047
1048
1049
1050
        m = hashlib.sha256()
        with open(image_path, 'rb') as f:
            m.update(f.read())
        return m.digest().hex()
pythongosssss's avatar
pythongosssss committed
1051

1052
1053
1054
1055
1056
1057
1058
1059
1060
1061
    @classmethod
    def VALIDATE_INPUTS(s, image, channel):
        if not folder_paths.exists_annotated_filepath(image):
            return "Invalid image file: {}".format(image)

        if channel not in s._color_channels:
            return "Invalid color channel: {}".format(channel)

        return True

comfyanonymous's avatar
comfyanonymous committed
1062
1063
1064
1065
1066
1067
1068
class ImageScale:
    upscale_methods = ["nearest-exact", "bilinear", "area"]
    crop_methods = ["disabled", "center"]

    @classmethod
    def INPUT_TYPES(s):
        return {"required": { "image": ("IMAGE",), "upscale_method": (s.upscale_methods,),
1069
1070
                              "width": ("INT", {"default": 512, "min": 1, "max": MAX_RESOLUTION, "step": 1}),
                              "height": ("INT", {"default": 512, "min": 1, "max": MAX_RESOLUTION, "step": 1}),
comfyanonymous's avatar
comfyanonymous committed
1071
1072
1073
1074
                              "crop": (s.crop_methods,)}}
    RETURN_TYPES = ("IMAGE",)
    FUNCTION = "upscale"

1075
    CATEGORY = "image/upscaling"
1076

comfyanonymous's avatar
comfyanonymous committed
1077
1078
    def upscale(self, image, upscale_method, width, height, crop):
        samples = image.movedim(-1,1)
comfyanonymous's avatar
comfyanonymous committed
1079
        s = comfy.utils.common_upscale(samples, width, height, upscale_method, crop)
comfyanonymous's avatar
comfyanonymous committed
1080
1081
        s = s.movedim(1,-1)
        return (s,)
comfyanonymous's avatar
comfyanonymous committed
1082

1083
1084
1085
1086
1087
1088
1089
1090
1091
1092
1093
1094
1095
1096
1097
1098
class ImageInvert:

    @classmethod
    def INPUT_TYPES(s):
        return {"required": { "image": ("IMAGE",)}}

    RETURN_TYPES = ("IMAGE",)
    FUNCTION = "invert"

    CATEGORY = "image"

    def invert(self, image):
        s = 1.0 - image
        return (s,)


Guo Y.K's avatar
Guo Y.K committed
1099
1100
1101
1102
1103
1104
1105
class ImagePadForOutpaint:

    @classmethod
    def INPUT_TYPES(s):
        return {
            "required": {
                "image": ("IMAGE",),
1106
1107
1108
1109
                "left": ("INT", {"default": 0, "min": 0, "max": MAX_RESOLUTION, "step": 8}),
                "top": ("INT", {"default": 0, "min": 0, "max": MAX_RESOLUTION, "step": 8}),
                "right": ("INT", {"default": 0, "min": 0, "max": MAX_RESOLUTION, "step": 8}),
                "bottom": ("INT", {"default": 0, "min": 0, "max": MAX_RESOLUTION, "step": 8}),
1110
                "feathering": ("INT", {"default": 40, "min": 0, "max": MAX_RESOLUTION, "step": 1}),
Guo Y.K's avatar
Guo Y.K committed
1111
1112
1113
1114
1115
1116
1117
1118
            }
        }

    RETURN_TYPES = ("IMAGE", "MASK")
    FUNCTION = "expand_image"

    CATEGORY = "image"

1119
    def expand_image(self, image, left, top, right, bottom, feathering):
Guo Y.K's avatar
Guo Y.K committed
1120
1121
1122
1123
1124
1125
1126
1127
1128
1129
1130
1131
        d1, d2, d3, d4 = image.size()

        new_image = torch.zeros(
            (d1, d2 + top + bottom, d3 + left + right, d4),
            dtype=torch.float32,
        )
        new_image[:, top:top + d2, left:left + d3, :] = image

        mask = torch.ones(
            (d2 + top + bottom, d3 + left + right),
            dtype=torch.float32,
        )
1132

1133
1134
1135
1136
1137
        t = torch.zeros(
            (d2, d3),
            dtype=torch.float32
        )

1138
        if feathering > 0 and feathering * 2 < d2 and feathering * 2 < d3:
1139
1140
1141
1142
1143
1144
1145
1146
1147
1148
1149
1150
1151
1152
1153
1154
1155
1156
1157

            for i in range(d2):
                for j in range(d3):
                    dt = i if top != 0 else d2
                    db = d2 - i if bottom != 0 else d2

                    dl = j if left != 0 else d3
                    dr = d3 - j if right != 0 else d3

                    d = min(dt, db, dl, dr)

                    if d >= feathering:
                        continue

                    v = (feathering - d) / feathering

                    t[i, j] = v * v

        mask[top:top + d2, left:left + d3] = t
1158

Guo Y.K's avatar
Guo Y.K committed
1159
1160
1161
        return (new_image, mask)


comfyanonymous's avatar
comfyanonymous committed
1162
1163
NODE_CLASS_MAPPINGS = {
    "KSampler": KSampler,
1164
    "CheckpointLoaderSimple": CheckpointLoaderSimple,
comfyanonymous's avatar
comfyanonymous committed
1165
    "CLIPTextEncode": CLIPTextEncode,
comfyanonymous's avatar
comfyanonymous committed
1166
    "CLIPSetLastLayer": CLIPSetLastLayer,
comfyanonymous's avatar
comfyanonymous committed
1167
1168
    "VAEDecode": VAEDecode,
    "VAEEncode": VAEEncode,
1169
    "VAEEncodeForInpaint": VAEEncodeForInpaint,
comfyanonymous's avatar
comfyanonymous committed
1170
1171
1172
    "VAELoader": VAELoader,
    "EmptyLatentImage": EmptyLatentImage,
    "LatentUpscale": LatentUpscale,
1173
    "LatentFromBatch": LatentFromBatch,
comfyanonymous's avatar
comfyanonymous committed
1174
    "SaveImage": SaveImage,
pythongosssss's avatar
pythongosssss committed
1175
    "PreviewImage": PreviewImage,
comfyanonymous's avatar
comfyanonymous committed
1176
    "LoadImage": LoadImage,
1177
    "LoadImageMask": LoadImageMask,
comfyanonymous's avatar
comfyanonymous committed
1178
    "ImageScale": ImageScale,
1179
    "ImageInvert": ImageInvert,
Guo Y.K's avatar
Guo Y.K committed
1180
    "ImagePadForOutpaint": ImagePadForOutpaint,
FizzleDorf's avatar
FizzleDorf committed
1181
    "ConditioningAverage ": ConditioningAverage ,
comfyanonymous's avatar
comfyanonymous committed
1182
1183
    "ConditioningCombine": ConditioningCombine,
    "ConditioningSetArea": ConditioningSetArea,
Jacob Segal's avatar
Jacob Segal committed
1184
    "ConditioningSetMask": ConditioningSetMask,
comfyanonymous's avatar
comfyanonymous committed
1185
    "KSamplerAdvanced": KSamplerAdvanced,
1186
    "SetLatentNoiseMask": SetLatentNoiseMask,
comfyanonymous's avatar
comfyanonymous committed
1187
    "LatentComposite": LatentComposite,
comfyanonymous's avatar
comfyanonymous committed
1188
    "LatentRotate": LatentRotate,
comfyanonymous's avatar
comfyanonymous committed
1189
    "LatentFlip": LatentFlip,
comfyanonymous's avatar
comfyanonymous committed
1190
    "LatentCrop": LatentCrop,
1191
    "LoraLoader": LoraLoader,
1192
    "CLIPLoader": CLIPLoader,
1193
    "CLIPVisionEncode": CLIPVisionEncode,
1194
    "StyleModelApply": StyleModelApply,
1195
    "unCLIPConditioning": unCLIPConditioning,
comfyanonymous's avatar
comfyanonymous committed
1196
1197
    "ControlNetApply": ControlNetApply,
    "ControlNetLoader": ControlNetLoader,
1198
    "DiffControlNetLoader": DiffControlNetLoader,
comfyanonymous's avatar
comfyanonymous committed
1199
1200
    "StyleModelLoader": StyleModelLoader,
    "CLIPVisionLoader": CLIPVisionLoader,
1201
    "VAEDecodeTiled": VAEDecodeTiled,
comfyanonymous's avatar
comfyanonymous committed
1202
    "VAEEncodeTiled": VAEEncodeTiled,
1203
    "TomePatchModel": TomePatchModel,
1204
    "unCLIPCheckpointLoader": unCLIPCheckpointLoader,
1205
1206
1207
    "GLIGENLoader": GLIGENLoader,
    "GLIGENTextBoxApply": GLIGENTextBoxApply,

1208
    "CheckpointLoader": CheckpointLoader,
sALTaccount's avatar
sALTaccount committed
1209
    "DiffusersLoader": DiffusersLoader,
comfyanonymous's avatar
comfyanonymous committed
1210
1211
}

City's avatar
City committed
1212
1213
1214
1215
1216
NODE_DISPLAY_NAME_MAPPINGS = {
    # Sampling
    "KSampler": "KSampler",
    "KSamplerAdvanced": "KSampler (Advanced)",
    # Loaders
comfyanonymous's avatar
Rename.  
comfyanonymous committed
1217
1218
    "CheckpointLoader": "Load Checkpoint (With Config)",
    "CheckpointLoaderSimple": "Load Checkpoint",
City's avatar
City committed
1219
1220
1221
1222
1223
1224
1225
1226
1227
1228
1229
1230
1231
1232
    "VAELoader": "Load VAE",
    "LoraLoader": "Load LoRA",
    "CLIPLoader": "Load CLIP",
    "ControlNetLoader": "Load ControlNet Model",
    "DiffControlNetLoader": "Load ControlNet Model (diff)",
    "StyleModelLoader": "Load Style Model",
    "CLIPVisionLoader": "Load CLIP Vision",
    "UpscaleModelLoader": "Load Upscale Model",
    # Conditioning
    "CLIPVisionEncode": "CLIP Vision Encode",
    "StyleModelApply": "Apply Style Model",
    "CLIPTextEncode": "CLIP Text Encode (Prompt)",
    "CLIPSetLastLayer": "CLIP Set Last Layer",
    "ConditioningCombine": "Conditioning (Combine)",
FizzleDorf's avatar
FizzleDorf committed
1233
    "ConditioningAverage ": "Conditioning (Average)",
City's avatar
City committed
1234
    "ConditioningSetArea": "Conditioning (Set Area)",
Jacob Segal's avatar
Jacob Segal committed
1235
    "ConditioningSetMask": "Conditioning (Set Mask)",
City's avatar
City committed
1236
1237
1238
1239
1240
1241
1242
1243
1244
1245
1246
1247
1248
1249
1250
1251
1252
1253
1254
1255
1256
1257
1258
1259
1260
1261
    "ControlNetApply": "Apply ControlNet",
    # Latent
    "VAEEncodeForInpaint": "VAE Encode (for Inpainting)",
    "SetLatentNoiseMask": "Set Latent Noise Mask",
    "VAEDecode": "VAE Decode",
    "VAEEncode": "VAE Encode",
    "LatentRotate": "Rotate Latent",
    "LatentFlip": "Flip Latent",
    "LatentCrop": "Crop Latent",
    "EmptyLatentImage": "Empty Latent Image",
    "LatentUpscale": "Upscale Latent",
    "LatentComposite": "Latent Composite",
    # Image
    "SaveImage": "Save Image",
    "PreviewImage": "Preview Image",
    "LoadImage": "Load Image",
    "LoadImageMask": "Load Image (as Mask)",
    "ImageScale": "Upscale Image",
    "ImageUpscaleWithModel": "Upscale Image (using Model)",
    "ImageInvert": "Invert Image",
    "ImagePadForOutpaint": "Pad Image for Outpainting",
    # _for_testing
    "VAEDecodeTiled": "VAE Decode (Tiled)",
    "VAEEncodeTiled": "VAE Encode (Tiled)",
}

1262
1263
1264
1265
1266
1267
1268
1269
1270
1271
1272
1273
1274
1275
1276
def load_custom_node(module_path):
    module_name = os.path.basename(module_path)
    if os.path.isfile(module_path):
        sp = os.path.splitext(module_path)
        module_name = sp[0]
    try:
        if os.path.isfile(module_path):
            module_spec = importlib.util.spec_from_file_location(module_name, module_path)
        else:
            module_spec = importlib.util.spec_from_file_location(module_name, os.path.join(module_path, "__init__.py"))
        module = importlib.util.module_from_spec(module_spec)
        sys.modules[module_name] = module
        module_spec.loader.exec_module(module)
        if hasattr(module, "NODE_CLASS_MAPPINGS") and getattr(module, "NODE_CLASS_MAPPINGS") is not None:
            NODE_CLASS_MAPPINGS.update(module.NODE_CLASS_MAPPINGS)
1277
1278
            if hasattr(module, "NODE_DISPLAY_NAME_MAPPINGS") and getattr(module, "NODE_DISPLAY_NAME_MAPPINGS") is not None:
                NODE_DISPLAY_NAME_MAPPINGS.update(module.NODE_DISPLAY_NAME_MAPPINGS)
1279
1280
1281
1282
1283
1284
        else:
            print(f"Skip {module_path} module for custom nodes due to the lack of NODE_CLASS_MAPPINGS.")
    except Exception as e:
        print(traceback.format_exc())
        print(f"Cannot import {module_path} module for custom nodes:", e)

Hacker 17082006's avatar
Hacker 17082006 committed
1285
def load_custom_nodes():
1286
1287
1288
1289
1290
1291
1292
1293
1294
1295
    node_paths = folder_paths.get_folder_paths("custom_nodes")
    for custom_node_path in node_paths:
        possible_modules = os.listdir(custom_node_path)
        if "__pycache__" in possible_modules:
            possible_modules.remove("__pycache__")

        for possible_module in possible_modules:
            module_path = os.path.join(custom_node_path, possible_module)
            if os.path.isfile(module_path) and os.path.splitext(module_path)[1] != ".py": continue
            load_custom_node(module_path)
1296

1297
1298
def init_custom_nodes():
    load_custom_nodes()
1299
    load_custom_node(os.path.join(os.path.join(os.path.dirname(os.path.realpath(__file__)), "comfy_extras"), "nodes_hypernetwork.py"))
1300
1301
    load_custom_node(os.path.join(os.path.join(os.path.dirname(os.path.realpath(__file__)), "comfy_extras"), "nodes_upscale_model.py"))
    load_custom_node(os.path.join(os.path.join(os.path.dirname(os.path.realpath(__file__)), "comfy_extras"), "nodes_post_processing.py"))
1302
    load_custom_node(os.path.join(os.path.join(os.path.dirname(os.path.realpath(__file__)), "comfy_extras"), "nodes_mask.py"))