Upload 56 files

LatentUpscaleMultiply_Omar92.py

@@ -0,0 +1,72 @@
+# Developed by Omar - https://github.com/omar92
+# https://civitai.com/user/omar92
+# discord: Omar92#3374
+
+# This node provides an alterntive scaling node buy multiplying previous width and height by a factor
+import os
+import sys
+
+sys.path.insert(0, os.path.join(os.path.dirname(os.path.realpath(__file__)), "comfy"))
+import comfy.samplers
+import comfy.sd
+import comfy.utils
+import model_management
+
+
+def before_node_execution():
+    model_management.throw_exception_if_processing_interrupted()
+
+
+def interrupt_processing(value=True):
+    model_management.interrupt_current_processing(value)
+
+
+class LatentUpscaleMultiply:
+    upscale_methods = ["nearest-exact", "bilinear", "area"]
+    crop_methods = ["disabled", "center"]
+
+    @classmethod
+    def INPUT_TYPES(s):
+        return {
+            "required": {
+                "samples": ("LATENT",),
+                "upscale_method": (s.upscale_methods,),
+                "WidthMul": (
+                    "FLOAT",
+                    {"default": 1.25, "min": 0.0, "max": 10.0, "step": 0.1},
+                ),
+                "HeightMul": (
+                    "FLOAT",
+                    {"default": 1.25, "min": 0.0, "max": 10.0, "step": 0.1},
+                ),
+                "crop": (s.crop_methods,),
+            }
+        }
+
+    RETURN_TYPES = ("LATENT",)
+    FUNCTION = "upscale"
+
+    CATEGORY = "O/latent"
+
+    def upscale(self, samples, upscale_method, WidthMul, HeightMul, crop):
+        s = samples.copy()
+        x = samples["samples"].shape[3]
+        y = samples["samples"].shape[2]
+
+        new_x = int(x * WidthMul)
+        new_y = int(y * HeightMul)
+        print("upscale from ("+ str(x * 8)+ ","+ str(y * 8)+ ") to ("+ str(new_x * 8)+ ","+ str(new_y * 8)+ ")")
+
+        def enforce_mul_of_64(d):
+            leftover = d % 8
+            if leftover != 0:
+                d += 8 - leftover
+            return d
+
+        s["samples"] = comfy.utils.common_upscale(
+            samples["samples"], enforce_mul_of_64(new_x), enforce_mul_of_64(new_y), upscale_method, crop
+        )
+        return (s,)
+
+
+NODE_CLASS_MAPPINGS = {"LatentUpscaleMultiply": LatentUpscaleMultiply}

comfyuiDerfuuMathAnd_derfuuNodes02/Derfuu_Nodes/debugNodes.py

@@ -0,0 +1,51 @@
+import custom_nodes.Derfuu_Nodes.types as type
+import custom_nodes.Derfuu_Nodes.fields as field
+from custom_nodes.Derfuu_Nodes.tree import TREE_DEBUG
+
+class baseDebugNode:
+    def __init__(self):
+        pass
+
+    @classmethod
+    def INPUT_TYPES(cls):
+        return {
+            "required": {
+                "FLOAT": (type.FLOAT,),
+                "INTEGER": (type.INT,),
+                "TUPLE": (type.TUPLE,),
+            }
+        }
+
+    RETURN_TYPES = ()
+    CATEGORY = TREE_DEBUG
+    FUNCTION = "print_values"
+    OUTPUT_NODE = True
+
+    def print_values(self, FLOAT=0, INTEGER=0, TUPLE=(0, 0)):
+        print(FLOAT, INTEGER, TUPLE, sep="\n")
+        return (None,)
+
+
+class extendedDebugNode:
+    def __init__(self):
+        pass
+
+    @classmethod
+    def INPUT_TYPES(cls):
+        return {
+            "required": {
+                "FLOAT": (type.FLOAT,),
+                "INTEGER": (type.INT,),
+                "TUPLE": (type.TUPLE,),
+                # "ABS": (type.ABS,),
+            }
+        }
+
+    RETURN_TYPES = ()
+    CATEGORY = TREE_DEBUG
+    FUNCTION = "print_values"
+    OUTPUT_NODE = True
+
+    def print_values(self, FLOAT=0, INTEGER=0, TUPLE=(0, 0)):
+        print(FLOAT, INTEGER, TUPLE, sep="\n")
+        return (None,)

comfyuiDerfuuMathAnd_derfuuNodes02/Derfuu_Nodes/fields.py

@@ -0,0 +1,7 @@
+import sys
+
+FLOAT = ("FLOAT", {"default": 1.00, "min": sys.float_info.min, "max": sys.float_info.max, "step": 0.01})
+# BOOL = ("BOOL", {"default": False})
+INT = ("INT", {"default": 1, "min": -sys.maxsize, "max": sys.maxsize, "step": 1})
+STRING = ("STRING", {"default": ""})
+STRING_ML = ("STRING", {"multiline": True})

comfyuiDerfuuMathAnd_derfuuNodes02/Derfuu_Nodes/functionsNodes.py

@@ -0,0 +1,166 @@
+import comfy.utils
+import custom_nodes.Derfuu_Nodes.types as type
+import custom_nodes.Derfuu_Nodes.fields as field
+
+import math
+
+from custom_nodes.Derfuu_Nodes.tree import TREE_FUNCTIONS
+
+
+class Int2Float:
+    def __init__(self):
+        pass
+
+    @classmethod
+    def INPUT_TYPES(cls):
+        return {
+            "required": {
+                "INT": (type.INT,),
+            }
+        }
+
+    RETURN_TYPES = (type.FLOAT,)
+    FUNCTION = "get_value"
+    CATEGORY = TREE_FUNCTIONS
+
+    def get_value(self, INT):
+        return (float(INT),)
+
+
+class CeilNode:
+    def __init__(self) -> None:
+        pass
+
+    @classmethod
+    def INPUT_TYPES(cls):
+        return {
+            "required": {
+                "FLOAT": (type.FLOAT,),
+            }
+        }
+
+    RETURN_TYPES = (type.INT,)
+    FUNCTION = "get_value"
+    CATEGORY = TREE_FUNCTIONS
+
+    def get_value(self, FLOAT):
+        total = int(math.ceil(FLOAT))
+        return (total,)
+
+
+class FloorNode:
+    def __init__(self) -> None:
+        pass
+
+    @classmethod
+    def INPUT_TYPES(cls):
+        return {
+            "required": {
+                "FLOAT": (type.FLOAT,),
+            }
+        }
+
+    RETURN_TYPES = (type.INT,)
+    FUNCTION = "get_value"
+    CATEGORY = TREE_FUNCTIONS
+
+    def get_value(self, FLOAT):
+        total = int(math.floor(FLOAT))
+        return (total,)
+
+
+class Float2Tuple:
+    def __init__(self) -> None:
+        pass
+
+    @classmethod
+    def INPUT_TYPES(cls):
+        return {
+            "required": {
+                "FLOAT_A": (type.FLOAT,),
+                "FLOAT_B": (type.FLOAT,),
+                "Ceil2Int": ([False, True],),
+            }
+        }
+
+    RETURN_TYPES = (type.TUPLE,)
+    CATEGORY = TREE_FUNCTIONS
+
+    FUNCTION = 'get_tuple'
+
+    def get_tuple(self, FLOAT_A=0, FLOAT_B=0, Ceil2Int="false"):
+        if Ceil2Int == "true":
+            FLOAT_A = math.ceil(FLOAT_A)
+            FLOAT_B = math.ceil(FLOAT_B)
+        return ((FLOAT_A, FLOAT_B),)
+
+
+class Tuple2Float:
+    def __init__(self) -> None:
+        pass
+
+    @classmethod
+    def INPUT_TYPES(cls):
+        return {
+            "required": {
+                "TUPLE": (type.TUPLE,),
+            }
+        }
+
+    RETURN_TYPES = (type.FLOAT, type.FLOAT,)
+    CATEGORY = TREE_FUNCTIONS
+
+    FUNCTION = 'get_tuple'
+
+    def get_tuple(self, TUPLE):
+        return (TUPLE[0], TUPLE[1],)
+
+
+class GetLatentSize:
+    def __init__(self) -> None:
+        pass
+
+    @classmethod
+    def INPUT_TYPES(cls):
+        return {
+            "required": {
+                "LATENT": (type.LATENT,),
+                "ORIGINAL_VALUES": ([False, True],),
+            }
+        }
+
+    RETURN_TYPES = (type.TUPLE,)
+    CATEGORY = TREE_FUNCTIONS
+
+    FUNCTION = 'get_size'
+
+    def get_size(self, LATENT, ORIGINAL_VALUES=False):
+        lc = LATENT.copy()
+        size = lc["samples"].shape[3], lc["samples"].shape[2]
+        if ORIGINAL_VALUES == False:
+            size = size[0] * 8, size[1] * 8
+        return (size,)
+
+
+class GetImageSize:
+    def __init__(self) -> None:
+        pass
+
+    @classmethod
+    def INPUT_TYPES(cls):
+        return {
+            "required": {
+                "IMAGE": (type.IMAGE,),
+            }
+        }
+
+    RETURN_TYPES = (type.TUPLE,)
+    CATEGORY = TREE_FUNCTIONS
+
+    FUNCTION = 'get_size'
+
+    def get_size(self, IMAGE):
+        samples = IMAGE.movedim(-1, 1)
+        size = samples.shape[3], samples.shape[2]
+        # size = size.movedim(1, -1)
+        return (size,)

comfyuiDerfuuMathAnd_derfuuNodes02/Derfuu_Nodes/mathNodes.py

@@ -0,0 +1,137 @@
+import math
+
+import numpy
+
+import custom_nodes.Derfuu_Nodes.types as type
+from custom_nodes.Derfuu_Nodes.tree import TREE_MATH
+
+
+class MultiplyNode:
+    def __init__(self) -> None:
+        pass
+
+    @classmethod
+    def INPUT_TYPES(cls):
+        return {
+            "required": {
+                "FLOAT_A": (type.FLOAT,),
+                "FLOAT_B": (type.FLOAT,),
+            },
+        }
+
+    RETURN_TYPES = (type.FLOAT,)
+    FUNCTION = "multiply"
+    CATEGORY = TREE_MATH
+
+    def multiply(self, FLOAT_A, FLOAT_B):
+        total = float(FLOAT_A * FLOAT_B)
+        return (total,)
+
+
+class DivideNode:
+    def __init__(self) -> None:
+        pass
+
+    @classmethod
+    def INPUT_TYPES(cls):
+        return {
+            "required": {
+                "FLOAT_A": (type.FLOAT,),
+                "FLOAT_B": (type.FLOAT,),
+            },
+        }
+
+    RETURN_TYPES = (type.FLOAT,)
+    FUNCTION = "divide"
+    CATEGORY = TREE_MATH
+
+    def divide(self, FLOAT_A, FLOAT_B):
+        total = float(FLOAT_A / FLOAT_B)
+        return (total,)
+
+
+class SumNode:
+    def __init__(self) -> None:
+        pass
+
+    @classmethod
+    def INPUT_TYPES(cls):
+        return {
+            "required": {
+                "FLOAT_A": (type.FLOAT,),
+                "FLOAT_B": (type.FLOAT,),
+            },
+        }
+
+    RETURN_TYPES = (type.FLOAT,)
+    FUNCTION = "sum"
+    CATEGORY = TREE_MATH
+
+    def sum(self, FLOAT_A, FLOAT_B):
+        total = float(FLOAT_A + FLOAT_B)
+        return (total,)
+
+
+class SubtractNode:
+    def __init__(self) -> None:
+        pass
+
+    @classmethod
+    def INPUT_TYPES(cls):
+        return {
+            "required": {
+                "FLOAT_A": (type.FLOAT,),
+                "FLOAT_B": (type.FLOAT,),
+            },
+        }
+
+    RETURN_TYPES = (type.FLOAT,)
+    FUNCTION = "sub"
+    CATEGORY = TREE_MATH
+
+    def sub(self, FLOAT_A, FLOAT_B):
+        total = float(FLOAT_A + FLOAT_B)
+        return (total,)
+
+
+class PowNode:
+    def __init__(self) -> None:
+        pass
+
+    @classmethod
+    def INPUT_TYPES(cls):
+        return {
+            "required": {
+                "FLOAT_A": (type.FLOAT,),
+                "FLOAT_B": (type.FLOAT,),
+            },
+        }
+
+    RETURN_TYPES = (type.FLOAT,)
+    FUNCTION = "sub"
+    CATEGORY = TREE_MATH
+
+    def sub(self, FLOAT_A, FLOAT_B=2):
+        total = math.pow(FLOAT_A, FLOAT_B)
+        return (total,)
+
+
+class SquareRootNode:
+    def __init__(self) -> None:
+        pass
+
+    @classmethod
+    def INPUT_TYPES(cls):
+        return {
+            "required": {
+                "FLOAT": (type.FLOAT,),
+            },
+        }
+
+    RETURN_TYPES = (type.FLOAT,)
+    FUNCTION = "sub"
+    CATEGORY = TREE_MATH
+
+    def sub(self, FLOAT):
+        total = math.sqrt(FLOAT)
+        return (total,)

comfyuiDerfuuMathAnd_derfuuNodes02/Derfuu_Nodes/moddedNodes.py

@@ -0,0 +1,194 @@
+import custom_nodes.Derfuu_Nodes.types as type
+import custom_nodes.Derfuu_Nodes.fields as field
+from custom_nodes.Derfuu_Nodes.tree import TREE_LATENTS, TREE_IMAGES
+
+import math
+import torch
+
+import comfy.utils
+
+
+class EmptyLatentImage:
+    def __init__(self, device="cpu"):
+        self.device = device
+
+    @classmethod
+    def INPUT_TYPES(cls):
+        return {
+            "required": {
+                "TUPLE": (type.TUPLE,),
+                "batch_size": field.INT,
+            }
+        }
+
+    RETURN_TYPES = (type.LATENT,)
+    FUNCTION = "generate"
+    CATEGORY = TREE_LATENTS
+
+    def generate(self, TUPLE, batch_size=1):
+        width = int(TUPLE[0])
+        height = int(TUPLE[1])
+
+        latent = torch.zeros([batch_size, 4, height // 8, width // 8])
+        return ({"samples": latent},)
+
+
+class ImageScale_Ratio:
+    upscale_methods = ["nearest-exact", "bilinear", "area"]
+    crop_methods = ["disabled", "center"]
+
+    @classmethod
+    def INPUT_TYPES(cls):
+        return {
+            "required": {
+                "IMAGE": (type.IMAGE,),
+                "TUPLE": (type.TUPLE,),
+                "modifier": field.FLOAT,
+                "upscale_method": (cls.upscale_methods,),
+                "crop": (cls.crop_methods,)}}
+
+    RETURN_TYPES = (type.IMAGE, type.TUPLE,)
+    FUNCTION = "upscale"
+
+    CATEGORY = TREE_IMAGES
+
+    def upscale(self, IMAGE, upscale_method, TUPLE, modifier, crop):
+        samples = IMAGE.movedim(-1, 1)
+
+        width_B = int(TUPLE[0])
+        height_B = int(TUPLE[1])
+
+        height = math.ceil(height_B * modifier)
+        width = math.ceil(width_B * modifier)
+        cls = comfy.utils.common_upscale(samples, width, height, upscale_method, crop)
+        cls = cls.movedim(1, -1)
+        return (cls, (width, height),)
+
+
+class ImageScale_Side:
+    upscale_methods = ["nearest-exact", "bilinear", "area"]
+    crop_methods = ["disabled", "center"]
+
+    def __init__(self) -> None:
+        pass
+
+    @classmethod
+    def INPUT_TYPES(cls):
+        return {
+            "required": {
+                "IMAGE": (type.IMAGE,),
+                "TUPLE": (type.TUPLE,),
+                "side_length": field.INT,
+                "side": (["Width", "Height"],),
+                "upscale_method": (cls.upscale_methods,),
+                "crop": (cls.crop_methods,)}}
+
+    RETURN_TYPES = (type.IMAGE, type.TUPLE,)
+    FUNCTION = "upscale"
+
+    CATEGORY = TREE_IMAGES
+
+    def upscale(self, IMAGE, upscale_method, TUPLE, side_length, side, crop):
+        samples = IMAGE.movedim(-1, 1)
+
+        width_B = int(TUPLE[0])
+        height_B = int(TUPLE[1])
+
+        width = width_B
+        height = height_B
+
+        if side == "Width":
+            heigh_ratio = height_B / width_B
+            width = side_length
+            height = heigh_ratio * width
+        elif side == "Height":
+            width_ratio = width_B / height_B
+            height = side_length
+            width = width_ratio * height
+
+        width = math.ceil(width)
+        height = math.ceil(height)
+
+        cls = comfy.utils.common_upscale(samples, width, height, upscale_method, crop)
+        cls = cls.movedim(1, -1)
+        return (cls, (width, height), )
+
+
+class LatentScale_Ratio:
+    scale_methods = (["nearest-exact", "bilinear", "area"],)
+    crop_methods = (["disabled", "center"],)
+
+    def __init__(self):
+        pass
+
+    @classmethod
+    def INPUT_TYPES(cls):
+        return {
+            "required": {
+                "LATENT": (type.LATENT,),
+                "TUPLE": (type.TUPLE,),
+                "modifier": field.FLOAT,
+                "scale_method": cls.scale_methods,
+                "crop": cls.crop_methods,
+            }
+        }
+
+    RETURN_TYPES = (type.LATENT, type.TUPLE,)
+    FUNCTION = "scale"
+    CATEGORY = TREE_LATENTS
+
+    def scale(self, LATENT, scale_method, crop, modifier, TUPLE):
+
+        width = int(TUPLE[0] * modifier)
+        height = int(TUPLE[1] * modifier)
+
+        cls = LATENT.copy()
+        cls["samples"] = comfy.utils.common_upscale(LATENT["samples"], width // 8, height // 8, scale_method, crop)
+        return (cls, (width, height),)
+
+
+class LatentScale_Side:
+    upscale_methods = ["nearest-exact", "bilinear", "area"]
+    crop_methods = ["disabled", "center"]
+
+    def __init__(self) -> None:
+        pass
+
+    @classmethod
+    def INPUT_TYPES(cls):
+        return {
+            "required": {
+                "LATENT": (type.LATENT,),
+                "TUPLE": (type.TUPLE,),
+                "side_length": field.INT,
+                "side": (["Width", "Height"],),
+                "scale_method": (cls.upscale_methods,),
+                "crop": (cls.crop_methods,)}}
+
+    RETURN_TYPES = (type.LATENT, type.TUPLE,)
+    FUNCTION = "upscale"
+
+    CATEGORY = TREE_LATENTS
+
+    def upscale(self, LATENT, scale_method, TUPLE, side_length, side, crop):
+        width_B = int(TUPLE[0])
+        height_B = int(TUPLE[1])
+
+        width = width_B
+        height = height_B
+
+        if side == "Width":
+            heigh_ratio = height_B / width_B
+            width = side_length
+            height = heigh_ratio * width
+        elif side == "Height":
+            width_ratio = width_B / height_B
+            height = side_length
+            width = width_ratio * height
+
+        width = math.ceil(width)
+        height = math.ceil(height)
+
+        cls = LATENT.copy()
+        cls["samples"] = comfy.utils.common_upscale(LATENT["samples"], width // 8, height // 8, scale_method, crop)
+        return (cls, (width, height),)

comfyuiDerfuuMathAnd_derfuuNodes02/Derfuu_Nodes/tree.py

@@ -0,0 +1,13 @@
+TREE_MAIN = "Derfuu_Nodes"
+
+TREE_VARIABLE = TREE_MAIN + "/Variables"
+TREE_TUPLES = TREE_MAIN + "/Tuples"
+TREE_MATH = TREE_MAIN + "/Math"
+TREE_FUNCTIONS = TREE_MAIN + "/Functions"
+TREE_TRIGONOMETRY = TREE_MATH + "/Trigonometry"
+TREE_MODDED = TREE_MAIN + "/Modded nodes"
+
+TREE_IMAGES = TREE_MODDED + "/Image"
+TREE_LATENTS = TREE_MODDED + "/Latent"
+
+TREE_DEBUG = TREE_MAIN + "/Debug"

comfyuiDerfuuMathAnd_derfuuNodes02/Derfuu_Nodes/trigonNodes.py

@@ -0,0 +1,87 @@
+import custom_nodes.Derfuu_Nodes.types as type
+from custom_nodes.Derfuu_Nodes.tree import TREE_TRIGONOMETRY
+
+import math
+
+class SinNode:
+    def __init__(self):
+        pass
+
+    @classmethod
+    def INPUT_TYPES(self):
+        return {
+            "required": {
+                "FLOAT": (type.FLOAT,),
+                "INPUT_TYPE": (["RAD", "DEG"],),
+                "arcSin": ([False, True],)
+            }
+        }
+
+    RETURN_TYPES = (type.FLOAT,)
+    FUNCTION = "get_value"
+    CATEGORY = TREE_TRIGONOMETRY
+
+    def get_value(self, FLOAT, INPUT_TYPE="RAD", arcSin=False):
+        if INPUT_TYPE == "DEG":
+            FLOAT = math.radians(FLOAT)
+        if arcSin == True:
+            FLOAT = math.asin(FLOAT)
+        else:
+            FLOAT = math.sin(FLOAT)
+        return (FLOAT,)
+
+
+class CosNode:
+    def __init__(self):
+        pass
+
+    @classmethod
+    def INPUT_TYPES(self):
+        return {
+            "required": {
+                "FLOAT": (type.FLOAT,),
+                "INPUT_TYPE": (["RAD", "DEG"],),
+                "arcCos": ([False, True],)
+            }
+        }
+
+    RETURN_TYPES = (type.FLOAT,)
+    FUNCTION = "get_value"
+    CATEGORY = TREE_TRIGONOMETRY
+
+    def get_value(self, FLOAT, INPUT_TYPE="RAD", arcCos=False):
+        if INPUT_TYPE == "DEG":
+            FLOAT = math.radians(FLOAT)
+        if arcCos == True:
+            FLOAT = math.acos(FLOAT)
+        else:
+            FLOAT = math.cos(FLOAT)
+        return (FLOAT,)
+
+
+class tgNode:
+    def __init__(self):
+        pass
+
+    @classmethod
+    def INPUT_TYPES(self):
+        return {
+            "required": {
+                "FLOAT": (type.FLOAT,),
+                "INPUT_TYPE": (["RAD", "DEG"],),
+                "arcTan": ([False, True],)
+            }
+        }
+
+    RETURN_TYPES = (type.FLOAT,)
+    FUNCTION = "get_value"
+    CATEGORY = TREE_TRIGONOMETRY
+
+    def get_value(self, FLOAT, INPUT_TYPE="RAD", arcTan=False):
+        if INPUT_TYPE == "DEG":
+            FLOAT = math.radians(FLOAT)
+        if arcTan == True:
+            FLOAT = math.atan(FLOAT)
+        else:
+            FLOAT = math.tan(FLOAT)
+        return (FLOAT,)

comfyuiDerfuuMathAnd_derfuuNodes02/Derfuu_Nodes/typeNodes.py

@@ -0,0 +1,130 @@
+import math
+import custom_nodes.Derfuu_Nodes.types as type
+import custom_nodes.Derfuu_Nodes.fields as field
+from custom_nodes.Derfuu_Nodes.tree import TREE_VARIABLE
+
+class FloatNode:
+    def __init__(self) -> None:
+        pass
+
+    @classmethod
+    def INPUT_TYPES(cls):
+        return {
+            "required": {
+                "VALUE": field.FLOAT,
+            },
+        }
+
+    RETURN_TYPES = (type.FLOAT,)
+    CATEGORY = TREE_VARIABLE
+    FUNCTION = "get_value"
+
+    def get_value(self, VALUE):
+        return (VALUE,)
+
+
+class IntegerNode:
+    def __init__(self) -> None:
+        pass
+
+    @classmethod
+    def INPUT_TYPES(cls):
+        return {
+            "required": {
+                "VALUE": field.INT,
+            },
+        }
+
+    RETURN_TYPES = (type.INT,)
+    CATEGORY = TREE_VARIABLE
+    FUNCTION = "get_value"
+
+    def get_value(self, VALUE):
+        return (VALUE,)
+
+
+class TupleNode:
+    def __init__(self):
+        pass
+
+    @classmethod
+    def INPUT_TYPES(cls):
+        return {
+            "required": {
+                "FLOAT_A": field.FLOAT,
+                "FLOAT_B": field.FLOAT,
+                "Ceil2Int": ([False, True],),
+            }
+        }
+
+    RETURN_TYPES = (type.TUPLE,)
+    CATEGORY = TREE_VARIABLE
+
+    FUNCTION = 'get_value'
+
+    def get_value(self, FLOAT_A, FLOAT_B, Ceil2Int="false"):
+        if Ceil2Int == "true":
+            FLOAT_A = math.ceil(FLOAT_A)
+            FLOAT_B = math.ceil(FLOAT_B)
+        return ((FLOAT_A, FLOAT_B),)
+
+
+class StringNode:
+    def __init__(self):
+        pass
+
+    @classmethod
+    def INPUT_TYPES(cls):
+        return {
+            "required": {
+                "VALUE": field.STRING,
+            }
+        }
+
+    RETURN_TYPES = (type.STRING,)
+    FUNCTION = "get_value"
+    CATEGORY = TREE_VARIABLE
+
+    def get_value(self, VALUE):
+        return (VALUE,)
+
+
+class MultilineStringNode:
+    def __init__(self):
+        pass
+
+    @classmethod
+    def INPUT_TYPES(cls):
+        return {
+            "required": {
+                "VALUE": field.STRING_ML,
+            }
+        }
+
+    RETURN_TYPES = (type.STRING,)
+    FUNCTION = "get_value"
+    CATEGORY = TREE_VARIABLE
+
+    def get_value(self, VALUE):
+        return (VALUE,)
+
+
+# class Any:
+#     def __init__(self):
+#         pass
+#
+#     @classmethod
+#     def INPUT_TYPES(cls):
+#         return {
+#             "required": {
+#                 "VALUE": (type.STRING,),
+#             }
+#         }
+#
+#     RETURN_TYPES = (type.ABS,)
+#     CATEGORY = TREE_VARIABLE
+#
+#     FUNCTION = 'get_value'
+#
+#     def get_value(self, VALUE):
+#         return (VALUE,)

comfyuiDerfuuMathAnd_derfuuNodes02/Derfuu_Nodes/types.py

@@ -0,0 +1,7 @@
+FLOAT = "FlOAT"
+INT = "INTEGER"
+TUPLE = "TUPLE"
+STRING = "STRING"
+LATENT = "LATENT"
+IMAGE = "IMAGE"
+ABS = "ANY"

comfyuiDerfuuMathAnd_derfuuNodes02/Derfuu_Nodes_02.py

@@ -0,0 +1,64 @@
+import custom_nodes.Derfuu_Nodes.typeNodes as TypeNodes
+import custom_nodes.Derfuu_Nodes.mathNodes as MathNodes
+import custom_nodes.Derfuu_Nodes.functionsNodes as FunctionNodes
+import custom_nodes.Derfuu_Nodes.moddedNodes as ModdedNodes
+import custom_nodes.Derfuu_Nodes.debugNodes as Debug
+import custom_nodes.Derfuu_Nodes.trigonNodes as TrigYNodes
+
+
+class emptyNode:
+    def __init__(self):
+        pass
+
+    @classmethod
+    def INPUT_TYPES(self):
+        return {
+            "required": {
+
+            }
+        }
+
+    RETURN_TYPES = 0
+    FUNCTION = "get_value"
+    CATEGORY = "ABS"
+
+    def get_value(self, ):
+        return (None,)
+
+
+NODE_CLASS_MAPPINGS = {
+    "FloatNode_DF": TypeNodes.FloatNode,
+    "IntegerNode_DF": TypeNodes.IntegerNode,
+    "StringNode_DF": TypeNodes.StringNode,
+    "TupleNode_DF": TypeNodes.TupleNode,
+    "MultilineStringNode_DF": TypeNodes.MultilineStringNode,
+    # "ABS_DF": TypeNodes.Any,
+
+    "Float2Tuple_DF": FunctionNodes.Float2Tuple,
+    "Tuple2Float_DF": FunctionNodes.Tuple2Float,
+    "Int2Float_DF": FunctionNodes.Int2Float,
+    "CeilNode_DF": FunctionNodes.CeilNode,
+    "FloorNode_DF": FunctionNodes.FloorNode,
+    "GetLatentSize_DF": FunctionNodes.GetLatentSize,
+    "GetImageSize_DF": FunctionNodes.GetImageSize,
+
+    "SumNode_DF": MathNodes.SumNode,
+    "SubtractNode_DF": MathNodes.SubtractNode,
+    "MultiplyNode_DF": MathNodes.MultiplyNode,
+    "DivideNode_DF": MathNodes.DivideNode,
+    "PowNode_DF": MathNodes.PowNode,
+    "SquareRootNode_DF": MathNodes.SquareRootNode,
+
+    "sin_DF": TrigYNodes.SinNode,
+    "cos_DF": TrigYNodes.CosNode,
+    "tg_DF": TrigYNodes.tgNode,
+
+    "EmptyLatentImage_DF": ModdedNodes.EmptyLatentImage,
+    "LatentScale_Ratio_DF": ModdedNodes.LatentScale_Ratio,
+    "LatentScale_Side_DF": ModdedNodes.LatentScale_Side,
+    "ImageScale_Ratio_DF": ModdedNodes.ImageScale_Ratio,
+    "ImageScale_Side_DF": ModdedNodes.ImageScale_Side,
+
+    # "DebugPrint_DF": Debug.baseDebugNode,
+    # "ExtDebugPrint_DF": Debug.extendedDebugNode,
+}

wasNodeSuitesComfyui_externalSeedKsampler/Samplers_WAS.py

@@ -0,0 +1,64 @@
+ # By WASasquatch (Discord: WAS#0263)
+
+import sys, os
+import numpy as np
+
+sys.path.insert(0, os.path.join(os.path.dirname(os.path.realpath(__file__)), "comfy"))
+sys.path.append('../ComfyUI')
+
+import comfy.samplers
+import comfy.sd
+import comfy.utils
+
+import comfy_extras.clip_vision
+
+import model_management
+import importlib
+
+import nodes
+
+class WAS_KSampler:
+    @classmethod
+    def INPUT_TYPES(s):
+        return {"required":
+                    {"model": ("MODEL",),
+                    "seed": ("SEED",),
+                    "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"
+
+    CATEGORY = "sampling"
+
+    def sample(self, model, seed, steps, cfg, sampler_name, scheduler, positive, negative, latent_image, denoise=1.0):
+        return nodes.common_ksampler(model, seed['seed'], steps, cfg, sampler_name, scheduler, positive, negative, latent_image, denoise=denoise)
+        
+class WAS_Seed:
+    @classmethod
+    def INPUT_TYPES(s):
+        return {"required":
+                    {"seed": ("INT", {"default": 0, "min": 0, "max": 0xffffffffffffffff})}
+                }
+
+
+    RETURN_TYPES = ("SEED",)
+    FUNCTION = "seed"
+
+    CATEGORY = "constant"
+
+    def seed(self, seed):
+        return ( {"seed": seed,}, )
+
+NODE_CLASS_MAPPINGS = {
+    "KSampler (WAS)": WAS_KSampler,
+    "Seed": WAS_Seed
+}

wasNodeSuitesComfyui_externalSeedKsampler/WAS_License.txt

@@ -0,0 +1,7 @@
+Copyright 2023 Jordan Thompson (WASasquatch)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the “Software”), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

wasNodeSuitesComfyui_filtersSuiteV1/Canny_Filter_WAS.py

@@ -0,0 +1,147 @@
+# By WASasquatch (Discord: WAS#0263)
+
+import torch, os
+import numpy as np
+
+class WAS_Canny_Filter:
+    def __init__(self):
+        pass
+
+    @classmethod
+    def INPUT_TYPES(cls):
+        return {
+            "required": {
+                "image": ("IMAGE",),
+                "enable_threshold": (['false', 'true'],),
+                "threshold_low": ("FLOAT", {"default": 0.0, "min": 0.0, "max": 1.0, "step": 0.01}),
+                "threshold_high": ("FLOAT", {"default": 1.0, "min": 0.0, "max": 1.0, "step": 0.01}),
+            },
+        }
+
+    RETURN_TYPES = ("IMAGE",)
+    FUNCTION = "canny_filter"
+
+    CATEGORY = "WAS"
+
+    def canny_filter(self, image, threshold_low, threshold_high, enable_threshold):
+
+        self.install_opencv()
+        
+        if enable_threshold == 'false':
+            threshold_low = None
+            threshold_high = None
+
+        image_canny = self.Canny_detector(255. * image.cpu().numpy().squeeze(), threshold_low, threshold_high)
+
+        return ( torch.from_numpy( image_canny )[None,], )
+        
+    # Defining the Canny Detector function
+    # From: https://www.geeksforgeeks.org/implement-canny-edge-detector-in-python-using-opencv/
+       
+    # here weak_th and strong_th are thresholds for
+    # double thresholding step
+    def Canny_detector(self, img, weak_th = None, strong_th = None):
+        
+        import cv2
+          
+        # conversion of image to grayscale
+        img = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
+           
+        # Noise reduction step
+        img = cv2.GaussianBlur(img, (5, 5), 1.4)
+           
+        # Calculating the gradients
+        gx = cv2.Sobel(np.float32(img), cv2.CV_64F, 1, 0, 3)
+        gy = cv2.Sobel(np.float32(img), cv2.CV_64F, 0, 1, 3)
+          
+        # Conversion of Cartesian coordinates to polar 
+        mag, ang = cv2.cartToPolar(gx, gy, angleInDegrees = True)
+           
+        # setting the minimum and maximum thresholds 
+        # for double thresholding
+        mag_max = np.max(mag)
+        if not weak_th:weak_th = mag_max * 0.1
+        if not strong_th:strong_th = mag_max * 0.5
+          
+        # getting the dimensions of the input image  
+        height, width = img.shape
+           
+        # Looping through every pixel of the grayscale 
+        # image
+        for i_x in range(width):
+            for i_y in range(height):
+                   
+                grad_ang = ang[i_y, i_x]
+                grad_ang = abs(grad_ang-180) if abs(grad_ang)>180 else abs(grad_ang)
+                   
+                # selecting the neighbours of the target pixel
+                # according to the gradient direction
+                # In the x axis direction
+                if grad_ang<= 22.5:
+                    neighb_1_x, neighb_1_y = i_x-1, i_y
+                    neighb_2_x, neighb_2_y = i_x + 1, i_y
+                  
+                # top right (diagonal-1) direction
+                elif grad_ang>22.5 and grad_ang<=(22.5 + 45):
+                    neighb_1_x, neighb_1_y = i_x-1, i_y-1
+                    neighb_2_x, neighb_2_y = i_x + 1, i_y + 1
+                  
+                # In y-axis direction
+                elif grad_ang>(22.5 + 45) and grad_ang<=(22.5 + 90):
+                    neighb_1_x, neighb_1_y = i_x, i_y-1
+                    neighb_2_x, neighb_2_y = i_x, i_y + 1
+                  
+                # top left (diagonal-2) direction
+                elif grad_ang>(22.5 + 90) and grad_ang<=(22.5 + 135):
+                    neighb_1_x, neighb_1_y = i_x-1, i_y + 1
+                    neighb_2_x, neighb_2_y = i_x + 1, i_y-1
+                  
+                # Now it restarts the cycle
+                elif grad_ang>(22.5 + 135) and grad_ang<=(22.5 + 180):
+                    neighb_1_x, neighb_1_y = i_x-1, i_y
+                    neighb_2_x, neighb_2_y = i_x + 1, i_y
+                   
+                # Non-maximum suppression step
+                if width>neighb_1_x>= 0 and height>neighb_1_y>= 0:
+                    if mag[i_y, i_x]<mag[neighb_1_y, neighb_1_x]:
+                        mag[i_y, i_x]= 0
+                        continue
+       
+                if width>neighb_2_x>= 0 and height>neighb_2_y>= 0:
+                    if mag[i_y, i_x]<mag[neighb_2_y, neighb_2_x]:
+                        mag[i_y, i_x]= 0
+       
+        weak_ids = np.zeros_like(img)
+        strong_ids = np.zeros_like(img)              
+        ids = np.zeros_like(img)
+           
+        # double thresholding step
+        for i_x in range(width):
+            for i_y in range(height):
+                  
+                grad_mag = mag[i_y, i_x]
+                  
+                if grad_mag<weak_th:
+                    mag[i_y, i_x]= 0
+                elif strong_th>grad_mag>= weak_th:
+                    ids[i_y, i_x]= 1
+                else:
+                    ids[i_y, i_x]= 2
+           
+           
+        # finally returning the magnitude of
+        # gradients of edges
+        return mag
+        
+    def install_opencv(self):
+        if 'opencv-python' not in self.packages():
+            print("Installing CV2...")
+            subprocess.check_call([sys.executable, '-m', 'pip', '-q', 'install', 'opencv-python'])
+        
+    def packages(self):
+        import sys, subprocess
+        return [r.decode().split('==')[0] for r in subprocess.check_output([sys.executable, '-m', 'pip', 'freeze']).split()]
+
+NODE_CLASS_MAPPINGS = {
+    "Canny Filter": WAS_Canny_Filter
+}

wasNodeSuitesComfyui_filtersSuiteV1/Image_Filters_WAS.py

@@ -0,0 +1,78 @@
+# By WASasquatch (Discord: WAS#0263)
+
+import torch
+import numpy as np
+from PIL import Image, ImageFilter, ImageEnhance
+
+class WAS_Image_Filters:
+    def __init__(self):
+        pass
+
+    @classmethod
+    def INPUT_TYPES(cls):
+        return {
+            "required": {
+                "image": ("IMAGE",),
+                "brightness": ("FLOAT", {"default": 0.0, "min": -1.0, "max": 1.0, "step": 0.01}),
+                "contrast": ("FLOAT", {"default": 1.0, "min": -1.0, "max": 2.0, "step": 0.01}),
+                "saturation": ("FLOAT", {"default": 1.0, "min": -1.0, "max": 5.0, "step": 0.01}),
+                "sharpness": ("FLOAT", {"default": 1.0, "min": -1.0, "max": 5.0, "step": 0.01}),
+                "edge_enhance": ("FLOAT", {"default": 0.0, "min": 0.0, "max": 1.0, "step": 0.01}),
+            },
+        }
+
+    RETURN_TYPES = ("IMAGE",)
+    FUNCTION = "image_filters"
+
+    CATEGORY = "WAS"
+
+    def image_filters(self, image, brightness, contrast, saturation, sharpness, edge_enhance):
+        
+        pil_image = None
+        
+        # Apply NP Adjustments
+        if brightness > 0.0 or brightness < 0.0:
+            # Apply brightness
+            image = np.clip(image + brightness, 0.0, 1.0)
+            
+        if contrast > 1.0 or contrast < 1.0:
+            # Apply contrast
+            image = np.clip(image * contrast, 0.0, 1.0)
+            
+        # Apply PIL Adjustments
+        if saturation > 1.0 or saturation < 1.0:
+            #PIL Image
+            pil_image = self.tensor2pil(image)
+            # Apply saturation
+            pil_image = ImageEnhance.Color(pil_image).enhance(saturation)
+            
+        if sharpness > 1.0 or sharpness < 1.0:
+            # Assign or create PIL Image
+            pil_image = pil_image if pil_image else self.tensor2pil(image)
+            # Apply sharpness
+            pil_image = ImageEnhance.Sharpness(pil_image).enhance(sharpness)
+            
+        if edge_enhance > 0.0:
+            # Assign or create PIL Image
+            pil_image = pil_image if pil_image else self.tensor2pil(image)
+            # Edge Enhancement
+            edge_enhanced_img = pil_image.filter(ImageFilter.EDGE_ENHANCE_MORE)
+            # Blend Mask
+            blend_mask = Image.new(mode = "L", size = pil_image.size, color = (round(edge_enhance * 255)))
+            # Composite Original and Enhanced Version
+            pil_image = Image.composite(pil_image, edge_enhanced_img, blend_mask)
+            # Clean-up
+            del blend_mask, edge_enhanced_img
+            
+        # Output image
+        out_image = ( torch.from_numpy(np.array(pil_image).astype(np.float32) / 255.0).unsqueeze(0)
+            if pil_image else image )
+
+        return ( out_image, )
+        
+    def tensor2pil(self, image):
+            return Image.fromarray(np.clip(255. * image.cpu().numpy().squeeze(), 0, 255).astype(np.uint8))
+
+NODE_CLASS_MAPPINGS = {
+    "Image Filters": WAS_Image_Filters
+}

wasNodeSuitesComfyui_filtersSuiteV1/WAS_License.txt

@@ -0,0 +1,7 @@
+Copyright 2023 Jordan Thompson (WASasquatch)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the “Software”), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

wasNodeSuitesComfyui_filtersSuiteV2/Canny_Filter_WAS.py

@@ -0,0 +1,147 @@
+# By WASasquatch (Discord: WAS#0263)
+
+import torch, os
+import numpy as np
+
+class WAS_Canny_Filter:
+    def __init__(self):
+        pass
+
+    @classmethod
+    def INPUT_TYPES(cls):
+        return {
+            "required": {
+                "image": ("IMAGE",),
+                "enable_threshold": (['false', 'true'],),
+                "threshold_low": ("FLOAT", {"default": 0.0, "min": 0.0, "max": 1.0, "step": 0.01}),
+                "threshold_high": ("FLOAT", {"default": 1.0, "min": 0.0, "max": 1.0, "step": 0.01}),
+            },
+        }
+
+    RETURN_TYPES = ("IMAGE",)
+    FUNCTION = "canny_filter"
+
+    CATEGORY = "WAS"
+
+    def canny_filter(self, image, threshold_low, threshold_high, enable_threshold):
+
+        self.install_opencv()
+        
+        if enable_threshold == 'false':
+            threshold_low = None
+            threshold_high = None
+
+        image_canny = self.Canny_detector(255. * image.cpu().numpy().squeeze(), threshold_low, threshold_high)
+
+        return ( torch.from_numpy( image_canny )[None,], )
+        
+    # Defining the Canny Detector function
+    # From: https://www.geeksforgeeks.org/implement-canny-edge-detector-in-python-using-opencv/
+       
+    # here weak_th and strong_th are thresholds for
+    # double thresholding step
+    def Canny_detector(self, img, weak_th = None, strong_th = None):
+        
+        import cv2
+          
+        # conversion of image to grayscale
+        img = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
+           
+        # Noise reduction step
+        img = cv2.GaussianBlur(img, (5, 5), 1.4)
+           
+        # Calculating the gradients
+        gx = cv2.Sobel(np.float32(img), cv2.CV_64F, 1, 0, 3)
+        gy = cv2.Sobel(np.float32(img), cv2.CV_64F, 0, 1, 3)
+          
+        # Conversion of Cartesian coordinates to polar 
+        mag, ang = cv2.cartToPolar(gx, gy, angleInDegrees = True)
+           
+        # setting the minimum and maximum thresholds 
+        # for double thresholding
+        mag_max = np.max(mag)
+        if not weak_th:weak_th = mag_max * 0.1
+        if not strong_th:strong_th = mag_max * 0.5
+          
+        # getting the dimensions of the input image  
+        height, width = img.shape
+           
+        # Looping through every pixel of the grayscale 
+        # image
+        for i_x in range(width):
+            for i_y in range(height):
+                   
+                grad_ang = ang[i_y, i_x]
+                grad_ang = abs(grad_ang-180) if abs(grad_ang)>180 else abs(grad_ang)
+                   
+                # selecting the neighbours of the target pixel
+                # according to the gradient direction
+                # In the x axis direction
+                if grad_ang<= 22.5:
+                    neighb_1_x, neighb_1_y = i_x-1, i_y
+                    neighb_2_x, neighb_2_y = i_x + 1, i_y
+                  
+                # top right (diagonal-1) direction
+                elif grad_ang>22.5 and grad_ang<=(22.5 + 45):
+                    neighb_1_x, neighb_1_y = i_x-1, i_y-1
+                    neighb_2_x, neighb_2_y = i_x + 1, i_y + 1
+                  
+                # In y-axis direction
+                elif grad_ang>(22.5 + 45) and grad_ang<=(22.5 + 90):
+                    neighb_1_x, neighb_1_y = i_x, i_y-1
+                    neighb_2_x, neighb_2_y = i_x, i_y + 1
+                  
+                # top left (diagonal-2) direction
+                elif grad_ang>(22.5 + 90) and grad_ang<=(22.5 + 135):
+                    neighb_1_x, neighb_1_y = i_x-1, i_y + 1
+                    neighb_2_x, neighb_2_y = i_x + 1, i_y-1
+                  
+                # Now it restarts the cycle
+                elif grad_ang>(22.5 + 135) and grad_ang<=(22.5 + 180):
+                    neighb_1_x, neighb_1_y = i_x-1, i_y
+                    neighb_2_x, neighb_2_y = i_x + 1, i_y
+                   
+                # Non-maximum suppression step
+                if width>neighb_1_x>= 0 and height>neighb_1_y>= 0:
+                    if mag[i_y, i_x]<mag[neighb_1_y, neighb_1_x]:
+                        mag[i_y, i_x]= 0
+                        continue
+       
+                if width>neighb_2_x>= 0 and height>neighb_2_y>= 0:
+                    if mag[i_y, i_x]<mag[neighb_2_y, neighb_2_x]:
+                        mag[i_y, i_x]= 0
+       
+        weak_ids = np.zeros_like(img)
+        strong_ids = np.zeros_like(img)              
+        ids = np.zeros_like(img)
+           
+        # double thresholding step
+        for i_x in range(width):
+            for i_y in range(height):
+                  
+                grad_mag = mag[i_y, i_x]
+                  
+                if grad_mag<weak_th:
+                    mag[i_y, i_x]= 0
+                elif strong_th>grad_mag>= weak_th:
+                    ids[i_y, i_x]= 1
+                else:
+                    ids[i_y, i_x]= 2
+           
+           
+        # finally returning the magnitude of
+        # gradients of edges
+        return mag
+        
+    def install_opencv(self):
+        if 'opencv-python' not in self.packages():
+            print("Installing CV2...")
+            subprocess.check_call([sys.executable, '-m', 'pip', '-q', 'install', 'opencv-python'])
+        
+    def packages(self):
+        import sys, subprocess
+        return [r.decode().split('==')[0] for r in subprocess.check_output([sys.executable, '-m', 'pip', 'freeze']).split()]
+
+NODE_CLASS_MAPPINGS = {
+    "Canny Filter": WAS_Canny_Filter
+}

wasNodeSuitesComfyui_filtersSuiteV2/Image_Blend_WAS.py

@@ -0,0 +1,51 @@
+# By WASasquatch (Discord: WAS#0263)
+
+import torch, sys, subprocess
+import numpy as np
+from PIL import Image
+
+class WAS_Image_Blend:
+    def __init__(self):
+        pass
+
+    @classmethod
+    def INPUT_TYPES(cls):
+        return {
+            "required": {
+                "image_a": ("IMAGE",),
+                "image_b": ("IMAGE",),
+                "blend_percentage": ("FLOAT", {"default": 0.5, "min": 0.0, "max": 1.0, "step": 0.01}),
+            },
+        }
+
+    RETURN_TYPES = ("IMAGE",)
+    FUNCTION = "image_blend"
+
+    CATEGORY = "WAS"
+
+    def image_blend(self, image_a, image_b, blend_percentage):
+    
+        # Convert images to PIL
+        img_a = self.tensor2pil(image_a)
+        img_b = self.tensor2pil(image_b)
+
+        # Blend image
+        blend_mask = Image.new(mode = "L", size = img_a.size, color = (round(blend_percentage * 255)))
+        img_result = Image.composite(img_a, img_b, blend_mask)
+        
+        del img_a, img_b, blend_mask
+
+        return ( torch.from_numpy(np.array(img_result).astype(np.float32) / 255.0).unsqueeze(0), )
+     
+    # Convert tesnor to PIL image
+    def tensor2pil(self, image):
+            return Image.fromarray(np.clip(255. * image.cpu().numpy().squeeze(), 0, 255).astype(np.uint8))
+            
+    # Freeze packages
+    def packages(self):
+        import sys, subprocess
+        return [r.decode().split('==')[0] for r in subprocess.check_output([sys.executable, '-m', 'pip', 'freeze']).split()]
+
+NODE_CLASS_MAPPINGS = {
+    "Image Blend": WAS_Image_Blend
+}

wasNodeSuitesComfyui_filtersSuiteV2/Image_Combine_WAS.py

@@ -0,0 +1,103 @@
+# By WASasquatch (Discord: WAS#0263)
+
+import torch, sys, subprocess
+import numpy as np
+from PIL import Image
+
+class WAS_Image_Combine:
+    def __init__(self):
+        pass
+
+    @classmethod
+    def INPUT_TYPES(cls):
+        return {
+            "required": {
+                "image_a": ("IMAGE",),
+                "image_b": ("IMAGE",),
+                "mode": ([
+                    "add",
+                    "color",
+                    "color_burn",
+                    "color_dodge",
+                    "darken",
+                    #"difference",
+                    #"exclusion",
+                    "hard_light",
+                    "hue",
+                    "lighten",
+                    "multiply",
+                    "overlay",
+                    "screen",
+                    "soft_light"
+                ],),
+            },
+        }
+
+    RETURN_TYPES = ("IMAGE",)
+    FUNCTION = "image_combine"
+
+    CATEGORY = "WAS"
+
+    def image_combine(self, image_a, image_b, mode):
+    
+        # Install Pilgram
+        if 'pilgram' not in self.packages():
+            print("Installing Pilgram...")
+            subprocess.check_call([sys.executable, '-m', 'pip', '-q', 'install', 'pilgram'])
+            
+        # Import Pilgram module
+        import pilgram
+        
+        # Convert images to PIL
+        img_a = self.tensor2pil(image_a)
+        img_b = self.tensor2pil(image_b)
+        
+        # Apply blending
+        match mode:
+            case "color":
+                out_image = pilgram.css.blending.color(img_a, img_b)
+            case "color_burn":
+                out_image = pilgram.css.blending.color_burn(img_a, img_b)
+            case "color_dodge":
+                out_image = pilgram.css.blending.color_dodge(img_a, img_b)
+            case "darken":
+                out_image = pilgram.css.blending.darken(img_a, img_b)
+            case "difference":
+                out_image = pilgram.css.blending.difference(img_a, img_b)
+            case "exclusion":
+                out_image = pilgram.css.blending.exclusion(img_a, img_b)
+            case "hard_light":
+                out_image = pilgram.css.blending.hard_light(img_a, img_b)
+            case "hue":
+                out_image = pilgram.css.blending.hue(img_a, img_b)
+            case "lighten":
+                out_image = pilgram.css.blending.lighten(img_a, img_b)
+            case "multiply":
+                out_image = pilgram.css.blending.multiply(img_a, img_b)
+            case "add":
+                out_image = pilgram.css.blending.normal(img_a, img_b)
+            case "overlay":
+                out_image = pilgram.css.blending.overlay(img_a, img_b)
+            case "screen":
+                out_image = pilgram.css.blending.screen(img_a, img_b)
+            case "soft_light":
+                out_image = pilgram.css.blending.soft_light(img_a, img_b)
+            case _:
+                out_image = img_a
+                
+        out_image = out_image.convert("RGB")
+
+        return ( torch.from_numpy(np.array(out_image).astype(np.float32) / 255.0).unsqueeze(0), )
+     
+    # Convert tesnro to PIL image
+    def tensor2pil(self, image):
+            return Image.fromarray(np.clip(255. * image.cpu().numpy().squeeze(), 0, 255).astype(np.uint8))
+            
+    # Freeze packages
+    def packages(self):
+        import sys, subprocess
+        return [r.decode().split('==')[0] for r in subprocess.check_output([sys.executable, '-m', 'pip', 'freeze']).split()]
+
+NODE_CLASS_MAPPINGS = {
+    "Image Combine": WAS_Image_Combine
+}

wasNodeSuitesComfyui_filtersSuiteV2/Image_Filters_WAS.py

@@ -0,0 +1,93 @@
+# By WASasquatch (Discord: WAS#0263)
+
+import torch
+import numpy as np
+from PIL import Image, ImageFilter, ImageEnhance
+
+class WAS_Image_Filters:
+    def __init__(self):
+        pass
+
+    @classmethod
+    def INPUT_TYPES(cls):
+        return {
+            "required": {
+                "image": ("IMAGE",),
+                "brightness": ("FLOAT", {"default": 0.0, "min": -1.0, "max": 1.0, "step": 0.01}),
+                "contrast": ("FLOAT", {"default": 1.0, "min": -1.0, "max": 2.0, "step": 0.01}),
+                "saturation": ("FLOAT", {"default": 1.0, "min": -1.0, "max": 5.0, "step": 0.01}),
+                "sharpness": ("FLOAT", {"default": 1.0, "min": -5.0, "max": 5.0, "step": 0.01}),
+                "blur": ("INT", {"default": 0, "min": 0, "max": 16, "step": 1}),
+                "gaussian_blur": ("FLOAT", {"default": 0.0, "min": 0.0, "max": 255.0, "step": 0.1}),
+                "edge_enhance": ("FLOAT", {"default": 0.0, "min": 0.0, "max": 1.0, "step": 0.01}),
+            },
+        }
+
+    RETURN_TYPES = ("IMAGE",)
+    FUNCTION = "image_filters"
+
+    CATEGORY = "WAS"
+
+    def image_filters(self, image, brightness, contrast, saturation, sharpness, blur, gaussian_blur, edge_enhance):
+        
+        pil_image = None
+        
+        # Apply NP Adjustments
+        if brightness > 0.0 or brightness < 0.0:
+            # Apply brightness
+            image = np.clip(image + brightness, 0.0, 1.0)
+            
+        if contrast > 1.0 or contrast < 1.0:
+            # Apply contrast
+            image = np.clip(image * contrast, 0.0, 1.0)
+            
+        # Apply PIL Adjustments
+        if saturation > 1.0 or saturation < 1.0:
+            #PIL Image
+            pil_image = self.tensor2pil(image)
+            # Apply saturation
+            pil_image = ImageEnhance.Color(pil_image).enhance(saturation)
+            
+        if sharpness > 1.0 or sharpness < 1.0:
+            # Assign or create PIL Image
+            pil_image = pil_image if pil_image else self.tensor2pil(image)
+            # Apply sharpness
+            pil_image = ImageEnhance.Sharpness(pil_image).enhance(sharpness)
+            
+        if blur > 0:
+            # Assign or create PIL Image
+            pil_image = pil_image if pil_image else self.tensor2pil(image)
+            # Apply blur
+            for _ in range(blur):
+                pil_image = pil_image.filter(ImageFilter.BLUR)
+                
+        if gaussian_blur > 0.0:
+            # Assign or create PIL Image
+            pil_image = pil_image if pil_image else self.tensor2pil(image)
+            # Apply Gaussian blur
+            pil_image = pil_image.filter(ImageFilter.GaussianBlur(radius = gaussian_blur))
+            
+        if edge_enhance > 0.0:
+            # Assign or create PIL Image
+            pil_image = pil_image if pil_image else self.tensor2pil(image)
+            # Edge Enhancement
+            edge_enhanced_img = pil_image.filter(ImageFilter.EDGE_ENHANCE_MORE)
+            # Blend Mask
+            blend_mask = Image.new(mode = "L", size = pil_image.size, color = (round(edge_enhance * 255)))
+            # Composite Original and Enhanced Version
+            pil_image = Image.composite(pil_image, edge_enhanced_img, blend_mask)
+            # Clean-up
+            del blend_mask, edge_enhanced_img
+            
+        # Output image
+        out_image = ( torch.from_numpy(np.array(pil_image).astype(np.float32) / 255.0).unsqueeze(0)
+            if pil_image else image )
+
+        return ( out_image, )
+        
+    def tensor2pil(self, image):
+            return Image.fromarray(np.clip(255. * image.cpu().numpy().squeeze(), 0, 255).astype(np.uint8))
+
+NODE_CLASS_MAPPINGS = {
+    "Image Filters": WAS_Image_Filters
+}

wasNodeSuitesComfyui_filtersSuiteV2/WAS_License.txt

@@ -0,0 +1,7 @@
+Copyright 2023 Jordan Thompson (WASasquatch)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the “Software”), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

wasNodeSuitesComfyui_filtersSuiteV3/Canny_Filter_WAS.py

@@ -0,0 +1,147 @@
+# By WASasquatch (Discord: WAS#0263)
+
+import torch, os
+import numpy as np
+
+class WAS_Canny_Filter:
+    def __init__(self):
+        pass
+
+    @classmethod
+    def INPUT_TYPES(cls):
+        return {
+            "required": {
+                "image": ("IMAGE",),
+                "enable_threshold": (['false', 'true'],),
+                "threshold_low": ("FLOAT", {"default": 0.0, "min": 0.0, "max": 1.0, "step": 0.01}),
+                "threshold_high": ("FLOAT", {"default": 1.0, "min": 0.0, "max": 1.0, "step": 0.01}),
+            },
+        }
+
+    RETURN_TYPES = ("IMAGE",)
+    FUNCTION = "canny_filter"
+
+    CATEGORY = "WAS"
+
+    def canny_filter(self, image, threshold_low, threshold_high, enable_threshold):
+
+        self.install_opencv()
+        
+        if enable_threshold == 'false':
+            threshold_low = None
+            threshold_high = None
+
+        image_canny = self.Canny_detector(255. * image.cpu().numpy().squeeze(), threshold_low, threshold_high)
+
+        return ( torch.from_numpy( image_canny )[None,], )
+        
+    # Defining the Canny Detector function
+    # From: https://www.geeksforgeeks.org/implement-canny-edge-detector-in-python-using-opencv/
+       
+    # here weak_th and strong_th are thresholds for
+    # double thresholding step
+    def Canny_detector(self, img, weak_th = None, strong_th = None):
+        
+        import cv2
+          
+        # conversion of image to grayscale
+        img = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
+           
+        # Noise reduction step
+        img = cv2.GaussianBlur(img, (5, 5), 1.4)
+           
+        # Calculating the gradients
+        gx = cv2.Sobel(np.float32(img), cv2.CV_64F, 1, 0, 3)
+        gy = cv2.Sobel(np.float32(img), cv2.CV_64F, 0, 1, 3)
+          
+        # Conversion of Cartesian coordinates to polar 
+        mag, ang = cv2.cartToPolar(gx, gy, angleInDegrees = True)
+           
+        # setting the minimum and maximum thresholds 
+        # for double thresholding
+        mag_max = np.max(mag)
+        if not weak_th:weak_th = mag_max * 0.1
+        if not strong_th:strong_th = mag_max * 0.5
+          
+        # getting the dimensions of the input image  
+        height, width = img.shape
+           
+        # Looping through every pixel of the grayscale 
+        # image
+        for i_x in range(width):
+            for i_y in range(height):
+                   
+                grad_ang = ang[i_y, i_x]
+                grad_ang = abs(grad_ang-180) if abs(grad_ang)>180 else abs(grad_ang)
+                   
+                # selecting the neighbours of the target pixel
+                # according to the gradient direction
+                # In the x axis direction
+                if grad_ang<= 22.5:
+                    neighb_1_x, neighb_1_y = i_x-1, i_y
+                    neighb_2_x, neighb_2_y = i_x + 1, i_y
+                  
+                # top right (diagonal-1) direction
+                elif grad_ang>22.5 and grad_ang<=(22.5 + 45):
+                    neighb_1_x, neighb_1_y = i_x-1, i_y-1
+                    neighb_2_x, neighb_2_y = i_x + 1, i_y + 1
+                  
+                # In y-axis direction
+                elif grad_ang>(22.5 + 45) and grad_ang<=(22.5 + 90):
+                    neighb_1_x, neighb_1_y = i_x, i_y-1
+                    neighb_2_x, neighb_2_y = i_x, i_y + 1
+                  
+                # top left (diagonal-2) direction
+                elif grad_ang>(22.5 + 90) and grad_ang<=(22.5 + 135):
+                    neighb_1_x, neighb_1_y = i_x-1, i_y + 1
+                    neighb_2_x, neighb_2_y = i_x + 1, i_y-1
+                  
+                # Now it restarts the cycle
+                elif grad_ang>(22.5 + 135) and grad_ang<=(22.5 + 180):
+                    neighb_1_x, neighb_1_y = i_x-1, i_y
+                    neighb_2_x, neighb_2_y = i_x + 1, i_y
+                   
+                # Non-maximum suppression step
+                if width>neighb_1_x>= 0 and height>neighb_1_y>= 0:
+                    if mag[i_y, i_x]<mag[neighb_1_y, neighb_1_x]:
+                        mag[i_y, i_x]= 0
+                        continue
+       
+                if width>neighb_2_x>= 0 and height>neighb_2_y>= 0:
+                    if mag[i_y, i_x]<mag[neighb_2_y, neighb_2_x]:
+                        mag[i_y, i_x]= 0
+       
+        weak_ids = np.zeros_like(img)
+        strong_ids = np.zeros_like(img)              
+        ids = np.zeros_like(img)
+           
+        # double thresholding step
+        for i_x in range(width):
+            for i_y in range(height):
+                  
+                grad_mag = mag[i_y, i_x]
+                  
+                if grad_mag<weak_th:
+                    mag[i_y, i_x]= 0
+                elif strong_th>grad_mag>= weak_th:
+                    ids[i_y, i_x]= 1
+                else:
+                    ids[i_y, i_x]= 2
+           
+           
+        # finally returning the magnitude of
+        # gradients of edges
+        return mag
+        
+    def install_opencv(self):
+        if 'opencv-python' not in self.packages():
+            print("Installing CV2...")
+            subprocess.check_call([sys.executable, '-m', 'pip', '-q', 'install', 'opencv-python'])
+        
+    def packages(self):
+        import sys, subprocess
+        return [r.decode().split('==')[0] for r in subprocess.check_output([sys.executable, '-m', 'pip', 'freeze']).split()]
+
+NODE_CLASS_MAPPINGS = {
+    "Canny Filter": WAS_Canny_Filter
+}

wasNodeSuitesComfyui_filtersSuiteV3/Image_Blend_WAS.py

@@ -0,0 +1,51 @@
+# By WASasquatch (Discord: WAS#0263)
+
+import torch, sys, subprocess
+import numpy as np
+from PIL import Image
+
+class WAS_Image_Blend:
+    def __init__(self):
+        pass
+
+    @classmethod
+    def INPUT_TYPES(cls):
+        return {
+            "required": {
+                "image_a": ("IMAGE",),
+                "image_b": ("IMAGE",),
+                "blend_percentage": ("FLOAT", {"default": 0.5, "min": 0.0, "max": 1.0, "step": 0.01}),
+            },
+        }
+
+    RETURN_TYPES = ("IMAGE",)
+    FUNCTION = "image_blend"
+
+    CATEGORY = "WAS"
+
+    def image_blend(self, image_a, image_b, blend_percentage):
+    
+        # Convert images to PIL
+        img_a = self.tensor2pil(image_a)
+        img_b = self.tensor2pil(image_b)
+
+        # Blend image
+        blend_mask = Image.new(mode = "L", size = img_a.size, color = (round(blend_percentage * 255)))
+        img_result = Image.composite(img_a, img_b, blend_mask)
+        
+        del img_a, img_b, blend_mask
+
+        return ( torch.from_numpy(np.array(img_result).astype(np.float32) / 255.0).unsqueeze(0), )
+     
+    # Convert tesnor to PIL image
+    def tensor2pil(self, image):
+            return Image.fromarray(np.clip(255. * image.cpu().numpy().squeeze(), 0, 255).astype(np.uint8))
+            
+    # Freeze packages
+    def packages(self):
+        import sys, subprocess
+        return [r.decode().split('==')[0] for r in subprocess.check_output([sys.executable, '-m', 'pip', 'freeze']).split()]
+
+NODE_CLASS_MAPPINGS = {
+    "Image Blend": WAS_Image_Blend
+}

wasNodeSuitesComfyui_filtersSuiteV3/Image_Combine_WAS.py

@@ -0,0 +1,103 @@
+# By WASasquatch (Discord: WAS#0263)
+
+import torch, sys, subprocess
+import numpy as np
+from PIL import Image
+
+class WAS_Image_Combine:
+    def __init__(self):
+        pass
+
+    @classmethod
+    def INPUT_TYPES(cls):
+        return {
+            "required": {
+                "image_a": ("IMAGE",),
+                "image_b": ("IMAGE",),
+                "mode": ([
+                    "add",
+                    "color",
+                    "color_burn",
+                    "color_dodge",
+                    "darken",
+                    #"difference",
+                    #"exclusion",
+                    "hard_light",
+                    "hue",
+                    "lighten",
+                    "multiply",
+                    "overlay",
+                    "screen",
+                    "soft_light"
+                ],),
+            },
+        }
+
+    RETURN_TYPES = ("IMAGE",)
+    FUNCTION = "image_combine"
+
+    CATEGORY = "WAS"
+
+    def image_combine(self, image_a, image_b, mode):
+    
+        # Install Pilgram
+        if 'pilgram' not in self.packages():
+            print("Installing Pilgram...")
+            subprocess.check_call([sys.executable, '-m', 'pip', '-q', 'install', 'pilgram'])
+            
+        # Import Pilgram module
+        import pilgram
+        
+        # Convert images to PIL
+        img_a = self.tensor2pil(image_a)
+        img_b = self.tensor2pil(image_b)
+        
+        # Apply blending
+        match mode:
+            case "color":
+                out_image = pilgram.css.blending.color(img_a, img_b)
+            case "color_burn":
+                out_image = pilgram.css.blending.color_burn(img_a, img_b)
+            case "color_dodge":
+                out_image = pilgram.css.blending.color_dodge(img_a, img_b)
+            case "darken":
+                out_image = pilgram.css.blending.darken(img_a, img_b)
+            case "difference":
+                out_image = pilgram.css.blending.difference(img_a, img_b)
+            case "exclusion":
+                out_image = pilgram.css.blending.exclusion(img_a, img_b)
+            case "hard_light":
+                out_image = pilgram.css.blending.hard_light(img_a, img_b)
+            case "hue":
+                out_image = pilgram.css.blending.hue(img_a, img_b)
+            case "lighten":
+                out_image = pilgram.css.blending.lighten(img_a, img_b)
+            case "multiply":
+                out_image = pilgram.css.blending.multiply(img_a, img_b)
+            case "add":
+                out_image = pilgram.css.blending.normal(img_a, img_b)
+            case "overlay":
+                out_image = pilgram.css.blending.overlay(img_a, img_b)
+            case "screen":
+                out_image = pilgram.css.blending.screen(img_a, img_b)
+            case "soft_light":
+                out_image = pilgram.css.blending.soft_light(img_a, img_b)
+            case _:
+                out_image = img_a
+                
+        out_image = out_image.convert("RGB")
+
+        return ( torch.from_numpy(np.array(out_image).astype(np.float32) / 255.0).unsqueeze(0), )
+     
+    # Convert tesnro to PIL image
+    def tensor2pil(self, image):
+            return Image.fromarray(np.clip(255. * image.cpu().numpy().squeeze(), 0, 255).astype(np.uint8))
+            
+    # Freeze packages
+    def packages(self):
+        import sys, subprocess
+        return [r.decode().split('==')[0] for r in subprocess.check_output([sys.executable, '-m', 'pip', 'freeze']).split()]
+
+NODE_CLASS_MAPPINGS = {
+    "Image Combine": WAS_Image_Combine
+}

wasNodeSuitesComfyui_filtersSuiteV3/Image_Edge_Detection_WAS.py

@@ -0,0 +1,48 @@
+# By WASasquatch (Discord: WAS#0263)
+
+import torch
+import numpy as np
+from PIL import Image, ImageFilter
+
+class WAS_Image_Edge:
+    def __init__(self):
+        pass
+
+    @classmethod
+    def INPUT_TYPES(cls):
+        return {
+            "required": {
+                "image": ("IMAGE",),
+                "mode": (["normal", "laplacian"],),
+            },
+        }
+
+    RETURN_TYPES = ("IMAGE",)
+    FUNCTION = "image_edges"
+
+    CATEGORY = "WAS"
+
+    def image_edges(self, image, mode):
+    
+        # Convert image to PIL
+        image = self.tensor2pil(image)
+
+        # Detect edges
+        match mode:
+            case "normal":
+                image = image.filter(ImageFilter.FIND_EDGES)
+            case "laplacian":
+                image = image.filter(ImageFilter.Kernel((3, 3), (-1, -1, -1, -1, 8,
+                                              -1, -1, -1, -1), 1, 0))
+            case _:
+                image = image
+
+        return ( torch.from_numpy(np.array(image).astype(np.float32) / 255.0).unsqueeze(0), )
+     
+    # Convert tesnor to PIL image
+    def tensor2pil(self, image):
+            return Image.fromarray(np.clip(255. * image.cpu().numpy().squeeze(), 0, 255).astype(np.uint8))
+
+NODE_CLASS_MAPPINGS = {
+    "Image Detect Edges": WAS_Image_Edge
+}

wasNodeSuitesComfyui_filtersSuiteV3/Image_Filters_WAS.py

@@ -0,0 +1,93 @@
+# By WASasquatch (Discord: WAS#0263)
+
+import torch
+import numpy as np
+from PIL import Image, ImageFilter, ImageEnhance
+
+class WAS_Image_Filters:
+    def __init__(self):
+        pass
+
+    @classmethod
+    def INPUT_TYPES(cls):
+        return {
+            "required": {
+                "image": ("IMAGE",),
+                "brightness": ("FLOAT", {"default": 0.0, "min": -1.0, "max": 1.0, "step": 0.01}),
+                "contrast": ("FLOAT", {"default": 1.0, "min": -1.0, "max": 2.0, "step": 0.01}),
+                "saturation": ("FLOAT", {"default": 1.0, "min": -1.0, "max": 5.0, "step": 0.01}),
+                "sharpness": ("FLOAT", {"default": 1.0, "min": -5.0, "max": 5.0, "step": 0.01}),
+                "blur": ("INT", {"default": 0, "min": 0, "max": 16, "step": 1}),
+                "gaussian_blur": ("FLOAT", {"default": 0.0, "min": 0.0, "max": 255.0, "step": 0.1}),
+                "edge_enhance": ("FLOAT", {"default": 0.0, "min": 0.0, "max": 1.0, "step": 0.01}),
+            },
+        }
+
+    RETURN_TYPES = ("IMAGE",)
+    FUNCTION = "image_filters"
+
+    CATEGORY = "WAS"
+
+    def image_filters(self, image, brightness, contrast, saturation, sharpness, blur, gaussian_blur, edge_enhance):
+        
+        pil_image = None
+        
+        # Apply NP Adjustments
+        if brightness > 0.0 or brightness < 0.0:
+            # Apply brightness
+            image = np.clip(image + brightness, 0.0, 1.0)
+            
+        if contrast > 1.0 or contrast < 1.0:
+            # Apply contrast
+            image = np.clip(image * contrast, 0.0, 1.0)
+            
+        # Apply PIL Adjustments
+        if saturation > 1.0 or saturation < 1.0:
+            #PIL Image
+            pil_image = self.tensor2pil(image)
+            # Apply saturation
+            pil_image = ImageEnhance.Color(pil_image).enhance(saturation)
+            
+        if sharpness > 1.0 or sharpness < 1.0:
+            # Assign or create PIL Image
+            pil_image = pil_image if pil_image else self.tensor2pil(image)
+            # Apply sharpness
+            pil_image = ImageEnhance.Sharpness(pil_image).enhance(sharpness)
+            
+        if blur > 0:
+            # Assign or create PIL Image
+            pil_image = pil_image if pil_image else self.tensor2pil(image)
+            # Apply blur
+            for _ in range(blur):
+                pil_image = pil_image.filter(ImageFilter.BLUR)
+                
+        if gaussian_blur > 0.0:
+            # Assign or create PIL Image
+            pil_image = pil_image if pil_image else self.tensor2pil(image)
+            # Apply Gaussian blur
+            pil_image = pil_image.filter(ImageFilter.GaussianBlur(radius = gaussian_blur))
+            
+        if edge_enhance > 0.0:
+            # Assign or create PIL Image
+            pil_image = pil_image if pil_image else self.tensor2pil(image)
+            # Edge Enhancement
+            edge_enhanced_img = pil_image.filter(ImageFilter.EDGE_ENHANCE_MORE)
+            # Blend Mask
+            blend_mask = Image.new(mode = "L", size = pil_image.size, color = (round(edge_enhance * 255)))
+            # Composite Original and Enhanced Version
+            pil_image = Image.composite(pil_image, edge_enhanced_img, blend_mask)
+            # Clean-up
+            del blend_mask, edge_enhanced_img
+            
+        # Output image
+        out_image = ( torch.from_numpy(np.array(pil_image).astype(np.float32) / 255.0).unsqueeze(0)
+            if pil_image else image )
+
+        return ( out_image, )
+        
+    def tensor2pil(self, image):
+            return Image.fromarray(np.clip(255. * image.cpu().numpy().squeeze(), 0, 255).astype(np.uint8))
+
+NODE_CLASS_MAPPINGS = {
+    "Image Filters": WAS_Image_Filters
+}

wasNodeSuitesComfyui_filtersSuiteV3/Image_Style_Filter_WAS.py

@@ -0,0 +1,137 @@
+# By WASasquatch (Discord: WAS#0263)
+
+import torch, sys, subprocess
+import numpy as np
+from PIL import Image
+
+class WAS_Image_Style_Filter:
+    def __init__(self):
+        pass
+
+    @classmethod
+    def INPUT_TYPES(cls):
+        return {
+            "required": {
+                "image": ("IMAGE",),
+                "style": ([
+                    "1977",
+                    "aden",
+                    "brannan",
+                    "brooklyn",
+                    "clarendon",
+                    "earlybird",
+                    "gingham",
+                    "hudson",
+                    "inkwell",
+                    "kelvin",
+                    "lark",
+                    "lofi",
+                    "maven",
+                    "mayfair",
+                    "moon",
+                    "nashville",
+                    "perpetua",
+                    "reyes",
+                    "rise",
+                    "slumber",
+                    "stinson",
+                    "toaster",
+                    "valencia",
+                    "walden",
+                    "willow",
+                    "xpro2"
+                ],),
+            },
+        }
+
+    RETURN_TYPES = ("IMAGE",)
+    FUNCTION = "image_style_filter"
+
+    CATEGORY = "WAS"
+
+    def image_style_filter(self, image, style):
+    
+        # Install Pilgram
+        if 'pilgram' not in self.packages():
+            print("Installing Pilgram...")
+            subprocess.check_call([sys.executable, '-m', 'pip', '-q', 'install', 'pilgram'])
+            
+        # Import Pilgram module
+        import pilgram
+        
+        # Convert image to PIL
+        image = self.tensor2pil(image)
+        
+        # Apply blending
+        match style:
+            case "1977":
+                out_image = pilgram._1977(image)
+            case "aden":
+                out_image = pilgram.aden(image)
+            case "brannan":
+                out_image = pilgram.brannan(image)
+            case "brooklyn":
+                out_image = pilgram.brooklyn(image)
+            case "clarendon":
+                out_image = pilgram.clarendon(image)
+            case "earlybird":
+                out_image = pilgram.earlybird(image)
+            case "gingham":
+                out_image = pilgram.gingham(image)
+            case "hudson":
+                out_image = pilgram.hudson(image)
+            case "inkwell":
+                out_image = pilgram.inkwell(image)
+            case "kelvin":
+                out_image = pilgram.kelvin(image)
+            case "lark":
+                out_image = pilgram.lark(image)
+            case "lofi":
+                out_image = pilgram.lofi(image)
+            case "maven":
+                out_image = pilgram.maven(image)
+            case "mayfair":
+                out_image = pilgram.mayfair(image)
+            case "moon":
+                out_image = pilgram.moon(image)
+            case "nashville":
+                out_image = pilgram.nashville(image)
+            case "perpetua":
+                out_image = pilgram.perpetua(image)
+            case "reyes":
+                out_image = pilgram.reyes(image)
+            case "rise":
+                out_image = pilgram.rise(image)
+            case "slumber":
+                out_image = pilgram.slumber(image)
+            case "stinson":
+                out_image = pilgram.stinson(image)
+            case "toaster":
+                out_image = pilgram.toaster(image)
+            case "valencia":
+                out_image = pilgram.valencia(image)
+            case "walden":
+                out_image = pilgram.walden(image)
+            case "willow":
+                out_image = pilgram.willow(image)
+            case "xpro2":
+                out_image = pilgram.xpro2(image)
+            case _:
+                out_image = image
+                
+        out_image = out_image.convert("RGB")
+
+        return ( torch.from_numpy(np.array(out_image).astype(np.float32) / 255.0).unsqueeze(0), )
+     
+    # Convert tesnro to PIL image
+    def tensor2pil(self, image):
+            return Image.fromarray(np.clip(255. * image.cpu().numpy().squeeze(), 0, 255).astype(np.uint8))
+            
+    # Freeze packages
+    def packages(self):
+        import sys, subprocess
+        return [r.decode().split('==')[0] for r in subprocess.check_output([sys.executable, '-m', 'pip', 'freeze']).split()]
+
+NODE_CLASS_MAPPINGS = {
+    "Image Style Filter": WAS_Image_Style_Filter
+}

wasNodeSuitesComfyui_filtersSuiteV3/WAS_License.txt

@@ -0,0 +1,7 @@
+Copyright 2023 Jordan Thompson (WASasquatch)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the “Software”), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

wasNodeSuitesComfyui_filtersSuiteV42/Image_Blank_WAS.py

@@ -0,0 +1,45 @@
+# By WASasquatch (Discord: WAS#0263)
+
+import torch
+import numpy as np
+from PIL import Image, ImageOps
+import random
+
+class WAS_Image_Blank:
+    def __init__(self):
+        pass
+
+    @classmethod
+    def INPUT_TYPES(s):
+        return {
+                    "required": { 
+                        "width": ("INT", {"default": 512, "min": 8, "max": 4096, "step": 1}),
+                        "height": ("INT", {"default": 512, "min": 8, "max": 4096, "step": 1}),
+                        "red": ("INT", {"default": 255, "min": 0, "max": 255, "step": 1}),
+                        "green": ("INT", {"default": 255, "min": 0, "max": 255, "step": 1}),
+                        "blue": ("INT", {"default": 255, "min": 0, "max": 255, "step": 1}),
+                    }
+                }
+    RETURN_TYPES = ("IMAGE",)
+    FUNCTION = "blank_image"
+
+    CATEGORY = "WAS"
+
+    def blank_image(self, width, height, red, green, blue): 
+    
+        # Ensure multiples
+        width = ( width // 8 ) * 8
+        height = ( height // 8 ) * 8
+
+        # Blend image
+        blank = Image.new(mode = "RGB", size = (width, height), color = (red, green, blue))
+
+        return ( self.pil2tensor(blank), )
+        
+    # Convert PIL to Tensor
+    def pil2tensor(self, image):
+        return torch.from_numpy(np.array(image).astype(np.float32) / 255.0).unsqueeze(0)
+
+NODE_CLASS_MAPPINGS = {
+    "Image Blank": WAS_Image_Blank
+}

wasNodeSuitesComfyui_filtersSuiteV42/Image_Blend_WAS.py

@@ -0,0 +1,52 @@
+# By WASasquatch (Discord: WAS#0263)
+
+import torch, sys, subprocess
+import numpy as np
+from PIL import Image, ImageOps
+
+class WAS_Image_Blend:
+    def __init__(self):
+        pass
+
+    @classmethod
+    def INPUT_TYPES(cls):
+        return {
+            "required": {
+                "image_a": ("IMAGE",),
+                "image_b": ("IMAGE",),
+                "blend_percentage": ("FLOAT", {"default": 0.5, "min": 0.0, "max": 1.0, "step": 0.01}),
+            },
+        }
+
+    RETURN_TYPES = ("IMAGE",)
+    FUNCTION = "image_blend"
+
+    CATEGORY = "WAS"
+
+    def image_blend(self, image_a, image_b, blend_percentage):
+    
+        # Convert images to PIL
+        img_a = self.tensor2pil(image_a)
+        img_b = self.tensor2pil(image_b)
+
+        # Blend image
+        blend_mask = Image.new(mode = "L", size = img_a.size, color = (round(blend_percentage * 255)))
+        blend_mask = ImageOps.invert(blend_mask)
+        img_result = Image.composite(img_a, img_b, blend_mask)
+        
+        del img_a, img_b, blend_mask
+
+        return ( torch.from_numpy(np.array(img_result).astype(np.float32) / 255.0).unsqueeze(0), )
+     
+    # Convert tesnor to PIL image
+    def tensor2pil(self, image):
+            return Image.fromarray(np.clip(255. * image.cpu().numpy().squeeze(), 0, 255).astype(np.uint8))
+            
+    # Freeze packages
+    def packages(self):
+        import sys, subprocess
+        return [r.decode().split('==')[0] for r in subprocess.check_output([sys.executable, '-m', 'pip', 'freeze']).split()]
+
+NODE_CLASS_MAPPINGS = {
+    "Image Blend": WAS_Image_Blend
+}

wasNodeSuitesComfyui_filtersSuiteV42/Image_Canny_Filter_WAS.py

@@ -0,0 +1,147 @@
+# By WASasquatch (Discord: WAS#0263)
+
+import torch, os
+import numpy as np
+
+class WAS_Canny_Filter:
+    def __init__(self):
+        pass
+
+    @classmethod
+    def INPUT_TYPES(cls):
+        return {
+            "required": {
+                "image": ("IMAGE",),
+                "enable_threshold": (['false', 'true'],),
+                "threshold_low": ("FLOAT", {"default": 0.0, "min": 0.0, "max": 1.0, "step": 0.01}),
+                "threshold_high": ("FLOAT", {"default": 1.0, "min": 0.0, "max": 1.0, "step": 0.01}),
+            },
+        }
+
+    RETURN_TYPES = ("IMAGE",)
+    FUNCTION = "canny_filter"
+
+    CATEGORY = "WAS"
+
+    def canny_filter(self, image, threshold_low, threshold_high, enable_threshold):
+
+        self.install_opencv()
+        
+        if enable_threshold == 'false':
+            threshold_low = None
+            threshold_high = None
+
+        image_canny = self.Canny_detector(255. * image.cpu().numpy().squeeze(), threshold_low, threshold_high)
+
+        return ( torch.from_numpy( image_canny )[None,], )
+        
+    # Defining the Canny Detector function
+    # From: https://www.geeksforgeeks.org/implement-canny-edge-detector-in-python-using-opencv/
+       
+    # here weak_th and strong_th are thresholds for
+    # double thresholding step
+    def Canny_detector(self, img, weak_th = None, strong_th = None):
+        
+        import cv2
+          
+        # conversion of image to grayscale
+        img = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
+           
+        # Noise reduction step
+        img = cv2.GaussianBlur(img, (5, 5), 1.4)
+           
+        # Calculating the gradients
+        gx = cv2.Sobel(np.float32(img), cv2.CV_64F, 1, 0, 3)
+        gy = cv2.Sobel(np.float32(img), cv2.CV_64F, 0, 1, 3)
+          
+        # Conversion of Cartesian coordinates to polar 
+        mag, ang = cv2.cartToPolar(gx, gy, angleInDegrees = True)
+           
+        # setting the minimum and maximum thresholds 
+        # for double thresholding
+        mag_max = np.max(mag)
+        if not weak_th:weak_th = mag_max * 0.1
+        if not strong_th:strong_th = mag_max * 0.5
+          
+        # getting the dimensions of the input image  
+        height, width = img.shape
+           
+        # Looping through every pixel of the grayscale 
+        # image
+        for i_x in range(width):
+            for i_y in range(height):
+                   
+                grad_ang = ang[i_y, i_x]
+                grad_ang = abs(grad_ang-180) if abs(grad_ang)>180 else abs(grad_ang)
+                   
+                # selecting the neighbours of the target pixel
+                # according to the gradient direction
+                # In the x axis direction
+                if grad_ang<= 22.5:
+                    neighb_1_x, neighb_1_y = i_x-1, i_y
+                    neighb_2_x, neighb_2_y = i_x + 1, i_y
+                  
+                # top right (diagonal-1) direction
+                elif grad_ang>22.5 and grad_ang<=(22.5 + 45):
+                    neighb_1_x, neighb_1_y = i_x-1, i_y-1
+                    neighb_2_x, neighb_2_y = i_x + 1, i_y + 1
+                  
+                # In y-axis direction
+                elif grad_ang>(22.5 + 45) and grad_ang<=(22.5 + 90):
+                    neighb_1_x, neighb_1_y = i_x, i_y-1
+                    neighb_2_x, neighb_2_y = i_x, i_y + 1
+                  
+                # top left (diagonal-2) direction
+                elif grad_ang>(22.5 + 90) and grad_ang<=(22.5 + 135):
+                    neighb_1_x, neighb_1_y = i_x-1, i_y + 1
+                    neighb_2_x, neighb_2_y = i_x + 1, i_y-1
+                  
+                # Now it restarts the cycle
+                elif grad_ang>(22.5 + 135) and grad_ang<=(22.5 + 180):
+                    neighb_1_x, neighb_1_y = i_x-1, i_y
+                    neighb_2_x, neighb_2_y = i_x + 1, i_y
+                   
+                # Non-maximum suppression step
+                if width>neighb_1_x>= 0 and height>neighb_1_y>= 0:
+                    if mag[i_y, i_x]<mag[neighb_1_y, neighb_1_x]:
+                        mag[i_y, i_x]= 0
+                        continue
+       
+                if width>neighb_2_x>= 0 and height>neighb_2_y>= 0:
+                    if mag[i_y, i_x]<mag[neighb_2_y, neighb_2_x]:
+                        mag[i_y, i_x]= 0
+       
+        weak_ids = np.zeros_like(img)
+        strong_ids = np.zeros_like(img)              
+        ids = np.zeros_like(img)
+           
+        # double thresholding step
+        for i_x in range(width):
+            for i_y in range(height):
+                  
+                grad_mag = mag[i_y, i_x]
+                  
+                if grad_mag<weak_th:
+                    mag[i_y, i_x]= 0
+                elif strong_th>grad_mag>= weak_th:
+                    ids[i_y, i_x]= 1
+                else:
+                    ids[i_y, i_x]= 2
+           
+           
+        # finally returning the magnitude of
+        # gradients of edges
+        return mag
+        
+    def install_opencv(self):
+        if 'opencv-python' not in self.packages():
+            print("Installing CV2...")
+            subprocess.check_call([sys.executable, '-m', 'pip', '-q', 'install', 'opencv-python'])
+        
+    def packages(self):
+        import sys, subprocess
+        return [r.decode().split('==')[0] for r in subprocess.check_output([sys.executable, '-m', 'pip', 'freeze']).split()]
+
+NODE_CLASS_MAPPINGS = {
+    "Canny Filter": WAS_Canny_Filter
+}

wasNodeSuitesComfyui_filtersSuiteV42/Image_Combine_WAS.py

@@ -0,0 +1,103 @@
+# By WASasquatch (Discord: WAS#0263)
+
+import torch, sys, subprocess
+import numpy as np
+from PIL import Image
+
+class WAS_Image_Combine:
+    def __init__(self):
+        pass
+
+    @classmethod
+    def INPUT_TYPES(cls):
+        return {
+            "required": {
+                "image_a": ("IMAGE",),
+                "image_b": ("IMAGE",),
+                "mode": ([
+                    "add",
+                    "color",
+                    "color_burn",
+                    "color_dodge",
+                    "darken",
+                    #"difference",
+                    #"exclusion",
+                    "hard_light",
+                    "hue",
+                    "lighten",
+                    "multiply",
+                    "overlay",
+                    "screen",
+                    "soft_light"
+                ],),
+            },
+        }
+
+    RETURN_TYPES = ("IMAGE",)
+    FUNCTION = "image_combine"
+
+    CATEGORY = "WAS"
+
+    def image_combine(self, image_a, image_b, mode):
+    
+        # Install Pilgram
+        if 'pilgram' not in self.packages():
+            print("Installing Pilgram...")
+            subprocess.check_call([sys.executable, '-m', 'pip', '-q', 'install', 'pilgram'])
+            
+        # Import Pilgram module
+        import pilgram
+        
+        # Convert images to PIL
+        img_a = self.tensor2pil(image_a)
+        img_b = self.tensor2pil(image_b)
+        
+        # Apply blending
+        match mode:
+            case "color":
+                out_image = pilgram.css.blending.color(img_a, img_b)
+            case "color_burn":
+                out_image = pilgram.css.blending.color_burn(img_a, img_b)
+            case "color_dodge":
+                out_image = pilgram.css.blending.color_dodge(img_a, img_b)
+            case "darken":
+                out_image = pilgram.css.blending.darken(img_a, img_b)
+            case "difference":
+                out_image = pilgram.css.blending.difference(img_a, img_b)
+            case "exclusion":
+                out_image = pilgram.css.blending.exclusion(img_a, img_b)
+            case "hard_light":
+                out_image = pilgram.css.blending.hard_light(img_a, img_b)
+            case "hue":
+                out_image = pilgram.css.blending.hue(img_a, img_b)
+            case "lighten":
+                out_image = pilgram.css.blending.lighten(img_a, img_b)
+            case "multiply":
+                out_image = pilgram.css.blending.multiply(img_a, img_b)
+            case "add":
+                out_image = pilgram.css.blending.normal(img_a, img_b)
+            case "overlay":
+                out_image = pilgram.css.blending.overlay(img_a, img_b)
+            case "screen":
+                out_image = pilgram.css.blending.screen(img_a, img_b)
+            case "soft_light":
+                out_image = pilgram.css.blending.soft_light(img_a, img_b)
+            case _:
+                out_image = img_a
+                
+        out_image = out_image.convert("RGB")
+
+        return ( torch.from_numpy(np.array(out_image).astype(np.float32) / 255.0).unsqueeze(0), )
+     
+    # Convert tesnro to PIL image
+    def tensor2pil(self, image):
+            return Image.fromarray(np.clip(255. * image.cpu().numpy().squeeze(), 0, 255).astype(np.uint8))
+            
+    # Freeze packages
+    def packages(self):
+        import sys, subprocess
+        return [r.decode().split('==')[0] for r in subprocess.check_output([sys.executable, '-m', 'pip', 'freeze']).split()]
+
+NODE_CLASS_MAPPINGS = {
+    "Image Combine": WAS_Image_Combine
+}

wasNodeSuitesComfyui_filtersSuiteV42/Image_Edge_Detection_WAS.py

@@ -0,0 +1,48 @@
+# By WASasquatch (Discord: WAS#0263)
+
+import torch
+import numpy as np
+from PIL import Image, ImageFilter
+
+class WAS_Image_Edge:
+    def __init__(self):
+        pass
+
+    @classmethod
+    def INPUT_TYPES(cls):
+        return {
+            "required": {
+                "image": ("IMAGE",),
+                "mode": (["normal", "laplacian"],),
+            },
+        }
+
+    RETURN_TYPES = ("IMAGE",)
+    FUNCTION = "image_edges"
+
+    CATEGORY = "WAS"
+
+    def image_edges(self, image, mode):
+    
+        # Convert image to PIL
+        image = self.tensor2pil(image)
+
+        # Detect edges
+        match mode:
+            case "normal":
+                image = image.filter(ImageFilter.FIND_EDGES)
+            case "laplacian":
+                image = image.filter(ImageFilter.Kernel((3, 3), (-1, -1, -1, -1, 8,
+                                              -1, -1, -1, -1), 1, 0))
+            case _:
+                image = image
+
+        return ( torch.from_numpy(np.array(image).astype(np.float32) / 255.0).unsqueeze(0), )
+     
+    # Convert tesnor to PIL image
+    def tensor2pil(self, image):
+            return Image.fromarray(np.clip(255. * image.cpu().numpy().squeeze(), 0, 255).astype(np.uint8))
+
+NODE_CLASS_MAPPINGS = {
+    "Image Detect Edges": WAS_Image_Edge
+}

wasNodeSuitesComfyui_filtersSuiteV42/Image_Film_Grain_WAS.py

@@ -0,0 +1,89 @@
+# By WASasquatch (Discord: WAS#0263)
+
+import torch
+import numpy as np
+from PIL import Image, ImageFilter, ImageEnhance
+import random
+
+class WAS_Film_Grain:
+    def __init__(self):
+        pass
+
+    @classmethod
+    def INPUT_TYPES(s):
+        return {
+                    "required": { 
+                        "image": ("IMAGE",),
+                        "density": ("FLOAT", {"default": 1.0, "min": 0.01, "max": 1.0, "step": 0.01}),
+                        "intensity": ("FLOAT", {"default": 1.0, "min": 0.01, "max": 1.0, "step": 0.01}),
+                        "highlights": ("FLOAT", {"default": 1.0, "min": 0.01, "max": 255.0, "step": 0.01}),
+                        "supersample_factor": ("INT", {"default": 4, "min": 1, "max": 8, "step": 1})
+                    }
+                }
+    RETURN_TYPES = ("IMAGE",)
+    FUNCTION = "film_grain"
+
+    CATEGORY = "WAS"
+
+    def film_grain(self, image, density, intensity, highlights, supersample_factor): 
+        return ( self.pil2tensor(self.apply_film_grain(self.tensor2pil(image), density, intensity, highlights, supersample_factor)), )
+
+    def apply_film_grain(self, img, density=0.1, intensity=1.0, highlights=1.0, supersample_factor = 4):
+        """
+        Apply grayscale noise with specified density, intensity, and highlights to a PIL image.
+        """
+        # Convert the image to grayscale
+        img_gray = img.convert('L')
+        
+        # Super Resolution noise image
+        original_size = img.size
+        img_gray = img_gray.resize(((img.size[0] * supersample_factor), (img.size[1] * supersample_factor)), Image.Resampling(2))
+        
+        # Calculate the number of noise pixels to add
+        num_pixels = int(density * img_gray.size[0] * img_gray.size[1])
+
+        # Create a list of noise pixel positions
+        noise_pixels = []
+        for i in range(num_pixels):
+            x = random.randint(0, img_gray.size[0]-1)
+            y = random.randint(0, img_gray.size[1]-1)
+            noise_pixels.append((x, y))
+
+        # Apply the noise to the grayscale image
+        for x, y in noise_pixels:
+            value = random.randint(0, 255)
+            img_gray.putpixel((x, y), value)
+
+        # Convert the grayscale image back to RGB
+        img_noise = img_gray.convert('RGB')
+        
+        # Blur noise image
+        img_noise = img_noise.filter(ImageFilter.GaussianBlur(radius = 0.125))
+        
+        # Downsize noise image
+        img_noise = img_noise.resize(original_size, Image.Resampling(1))
+        
+        # Sharpen super resolution result
+        img_noise = img_noise.filter(ImageFilter.EDGE_ENHANCE_MORE)
+
+        # Blend the noisy color image with the original color image
+        img_final = Image.blend(img, img_noise, intensity)
+
+        # Adjust the highlights
+        enhancer = ImageEnhance.Brightness(img_final)
+        img_highlights = enhancer.enhance(highlights)
+
+        # Return the final image
+        return img_highlights
+        
+    # Convert PIL to Tensor
+    def pil2tensor(self, image):
+        return torch.from_numpy(np.array(image).astype(np.float32) / 255.0).unsqueeze(0)
+        
+    # Convert Tensor to PIL image
+    def tensor2pil(self, image):
+        return Image.fromarray(np.clip(255. * image.cpu().numpy().squeeze(), 0, 255).astype(np.uint8))
+
+NODE_CLASS_MAPPINGS = {
+    "Image Film Grain": WAS_Film_Grain
+}

wasNodeSuitesComfyui_filtersSuiteV42/Image_Filters_WAS.py

@@ -0,0 +1,103 @@
+# By WASasquatch (Discord: WAS#0263)
+
+import torch
+import numpy as np
+from PIL import Image, ImageFilter, ImageEnhance, ImageOps
+
+class WAS_Image_Filters:
+    def __init__(self):
+        pass
+
+    @classmethod
+    def INPUT_TYPES(cls):
+        return {
+            "required": {
+                "image": ("IMAGE",),
+                "brightness": ("FLOAT", {"default": 0.0, "min": -1.0, "max": 1.0, "step": 0.01}),
+                "contrast": ("FLOAT", {"default": 1.0, "min": -1.0, "max": 2.0, "step": 0.01}),
+                "saturation": ("FLOAT", {"default": 1.0, "min": 0.0, "max": 5.0, "step": 0.01}),
+                "sharpness": ("FLOAT", {"default": 1.0, "min": -5.0, "max": 5.0, "step": 0.01}),
+                "blur": ("INT", {"default": 0, "min": 0, "max": 16, "step": 1}),
+                "gaussian_blur": ("FLOAT", {"default": 0.0, "min": 0.0, "max": 255.0, "step": 0.1}),
+                "edge_enhance": ("FLOAT", {"default": 0.0, "min": 0.0, "max": 1.0, "step": 0.01}),
+            },
+        }
+
+    RETURN_TYPES = ("IMAGE",)
+    FUNCTION = "image_filters"
+
+    CATEGORY = "WAS"
+
+    def image_filters(self, image, brightness, contrast, saturation, sharpness, blur, gaussian_blur, edge_enhance):
+        
+        pil_image = None
+        
+        # Apply NP Adjustments
+        if brightness > 0.0 or brightness < 0.0:
+            # Apply brightness
+            image = np.clip(image + brightness, 0.0, 1.0)
+            
+        if contrast > 1.0 or contrast < 1.0:
+            # Apply contrast
+            image = np.clip(image * contrast, 0.0, 1.0)
+            
+        # Apply PIL Adjustments
+        if saturation > 1.0 or saturation < 1.0:
+            #PIL Image
+            pil_image = self.tensor2pil(image)
+            # Apply saturation
+            pil_image = ImageEnhance.Color(pil_image).enhance(saturation)
+           
+        if sharpness > 1.0 or sharpness < 1.0:
+            # Assign or create PIL Image
+            pil_image = pil_image if pil_image else self.tensor2pil(image)
+            # Apply sharpness
+            pil_image = ImageEnhance.Sharpness(pil_image).enhance(sharpness)
+            
+        if blur > 0:
+            # Assign or create PIL Image
+            pil_image = pil_image if pil_image else self.tensor2pil(image)
+            # Apply blur
+            for _ in range(blur):
+                pil_image = pil_image.filter(ImageFilter.BLUR)
+                
+        if gaussian_blur > 0.0:
+            # Assign or create PIL Image
+            pil_image = pil_image if pil_image else self.tensor2pil(image)
+            # Apply Gaussian blur
+            pil_image = pil_image.filter(ImageFilter.GaussianBlur(radius = gaussian_blur))
+            
+        if edge_enhance > 0.0:
+            # Assign or create PIL Image
+            pil_image = pil_image if pil_image else self.tensor2pil(image)
+            # Edge Enhancement
+            edge_enhanced_img = pil_image.filter(ImageFilter.EDGE_ENHANCE_MORE)
+            # Blend Mask
+            blend_mask = Image.new(mode = "L", size = pil_image.size, color = (round(edge_enhance * 255)))
+            blend_mask = ImageOps.invert(blend_maskk)
+            # Composite Original and Enhanced Version
+            pil_image = Image.composite(edge_enhanced_img, pil_image, blend_mask)
+            # Clean-up
+            del blend_mask, edge_enhanced_img
+            
+        # Output image
+        out_image = ( self.pil2tensor(pil_image) if pil_image else image )
+
+        return ( out_image, )
+        
+    # Tensor to PIL
+    def tensor2pil(self, image):
+            return Image.fromarray(np.clip(255. * image.cpu().numpy().squeeze(), 0, 255).astype(np.uint8))
+            
+    # Convert PIL to Tensor
+    def pil2tensor(self, image):
+        return torch.from_numpy(np.array(image).astype(np.float32) / 255.0).unsqueeze(0)
+            
+    # Freeze packages
+    def packages(self):
+        import sys, subprocess
+        return [r.decode().split('==')[0] for r in subprocess.check_output([sys.executable, '-m', 'pip', 'freeze']).split()]
+
+NODE_CLASS_MAPPINGS = {
+    "Image Filters": WAS_Image_Filters
+}

wasNodeSuitesComfyui_filtersSuiteV42/Image_Flip_WAS.py

@@ -0,0 +1,50 @@
+# By WASasquatch (Discord: WAS#0263)
+
+import torch
+import numpy as np
+import PIL
+from PIL import Image
+
+class WAS_Image_Flip:
+    def __init__(self):
+        pass
+
+    @classmethod
+    def INPUT_TYPES(cls):
+        return {
+            "required": {
+                "image": ("IMAGE",),
+                "mode": (["horizontal", "vertical",],),
+            },
+        }
+
+    RETURN_TYPES = ("IMAGE",)
+    FUNCTION = "image_flip"
+
+    CATEGORY = "WAS"
+
+    def image_flip(self, image, mode):
+        
+        # PIL Image
+        image = self.tensor2pil(image)
+        
+        # Rotate Image
+        if mode == 'horizontal':
+            image = image.transpose(0)
+        if mode == 'vertical':
+            image = image.transpose(1)
+        
+        return ( torch.from_numpy(np.array(image).astype(np.float32) / 255.0).unsqueeze(0), )
+        
+    # Tensor to PIL
+    def tensor2pil(self, image):
+            return Image.fromarray(np.clip(255. * image.cpu().numpy().squeeze(), 0, 255).astype(np.uint8))
+       
+    # Freeze packages
+    def packages(self):
+        import sys, subprocess
+        return [r.decode().split('==')[0] for r in subprocess.check_output([sys.executable, '-m', 'pip', 'freeze']).split()]
+
+NODE_CLASS_MAPPINGS = {
+    "Image Flip": WAS_Image_Flip
+}

wasNodeSuitesComfyui_filtersSuiteV42/Image_Nova_Filter_WAS.py

@@ -0,0 +1,73 @@
+# By WASasquatch (Discord: WAS#0263)
+
+import torch
+import numpy as np
+from PIL import Image
+
+class WAS_Image_Nova_Filter:
+    def __init__(self):
+        pass
+
+    @classmethod
+    def INPUT_TYPES(cls):
+        return {
+            "required": {
+                "image": ("IMAGE",),
+                "amplitude": ("FLOAT", {"default": 0.1, "min": 0.0, "max": 1.0, "step": 0.001}),
+                "frequency": ("FLOAT", {"default": 3.14, "min": 0.0, "max": 100.0, "step": 0.001}),
+            },
+        }
+
+    RETURN_TYPES = ("IMAGE",)
+    FUNCTION = "nova_sine"
+
+    CATEGORY = "WAS"
+
+    def nova_sine(self, image, amplitude, frequency):
+        
+        # Convert image to numpy
+        img = self.tensor2pil(image)
+        
+        # Convert the image to a numpy array
+        img_array = np.array(img)
+
+        # Define a sine wave function
+        def sine(x, freq, amp):
+            return amp * np.sin(2 * np.pi * freq * x)
+
+        # Calculate the sampling frequency of the image
+        resolution = img.info.get('dpi')  # PPI
+        physical_size = img.size  # pixels
+
+        if resolution is not None:
+            # Convert PPI to pixels per millimeter (PPM)
+            ppm = 25.4 / resolution
+            physical_size = tuple(int(pix * ppm) for pix in physical_size)
+
+        # Set the maximum frequency for the sine wave
+        max_freq = img.width / 2
+        
+        # Ensure frequency isn't outside visual representable range
+        if frequency > max_freq:
+            frequency = max_freq
+
+        # Apply levels to the image using the sine function
+        for i in range(img_array.shape[0]):
+            for j in range(img_array.shape[1]):
+                for k in range(img_array.shape[2]):
+                    img_array[i,j,k] = int(sine(img_array[i,j,k]/255, frequency, amplitude) * 255)
+
+        return ( torch.from_numpy(img_array.astype(np.float32) / 255.0).unsqueeze(0), )
+        
+    # Convert tesnro to PIL image
+    def tensor2pil(self, image):
+            return Image.fromarray(np.clip(255. * image.cpu().numpy().squeeze(), 0, 255).astype(np.uint8))
+        
+    # Freeze installed pip modules
+    def packages(self):
+        import sys, subprocess
+        return [r.decode().split('==')[0] for r in subprocess.check_output([sys.executable, '-m', 'pip', 'freeze']).split()]
+
+NODE_CLASS_MAPPINGS = {
+    "Image Nova Filter": WAS_Image_Nova_Filter
+}

wasNodeSuitesComfyui_filtersSuiteV42/Image_Rotate_WAS.py

@@ -0,0 +1,69 @@
+# By WASasquatch (Discord: WAS#0263)
+
+import torch
+import numpy as np
+import PIL
+from PIL import Image
+
+class WAS_Image_Rotate:
+    def __init__(self):
+        pass
+
+    @classmethod
+    def INPUT_TYPES(cls):
+        return {
+            "required": {
+                "image": ("IMAGE",),
+                "mode": (["transpose", "internal",],),
+                "rotation": ("INT", {"default": 0, "min": 0, "max": 360, "step": 90}),
+                "sampler": (["nearest", "bilinear", "bicubic"],),
+            },
+        }
+
+    RETURN_TYPES = ("IMAGE",)
+    FUNCTION = "image_rotate"
+
+    CATEGORY = "WAS"
+
+    def image_rotate(self, image, mode, rotation, sampler):
+        
+        # PIL Image
+        image = self.tensor2pil(image)
+        
+        # Check rotation
+        if rotation > 360:
+            rotation = int(360)
+        if (rotation % 90 != 0):
+            rotation = int((rotation//90)*90);
+            
+        # Set Sampler
+        match sampler:
+            case 'nearest':
+                sampler = PIL.Image.NEAREST
+            case 'bicubic':
+                sampler = PIL.Image.BICUBIC
+            case 'bilinear':
+                sampler = PIL.Image.BILINEAR
+        
+        # Rotate Image
+        if mode == 'internal':
+            image = image.rotate(rotation, sampler)
+        else:
+            rot = int(rotation / 90)
+            for _ in range(rot):
+                image = image.transpose(2)
+        
+        return ( torch.from_numpy(np.array(image).astype(np.float32) / 255.0).unsqueeze(0), )
+        
+    # Tensor to PIL
+    def tensor2pil(self, image):
+            return Image.fromarray(np.clip(255. * image.cpu().numpy().squeeze(), 0, 255).astype(np.uint8))
+       
+    # Freeze packages
+    def packages(self):
+        import sys, subprocess
+        return [r.decode().split('==')[0] for r in subprocess.check_output([sys.executable, '-m', 'pip', 'freeze']).split()]
+
+NODE_CLASS_MAPPINGS = {
+    "Image Rotate": WAS_Image_Rotate
+}

wasNodeSuitesComfyui_filtersSuiteV42/Image_Style_Filter_WAS.py

@@ -0,0 +1,137 @@
+# By WASasquatch (Discord: WAS#0263)
+
+import torch, sys, subprocess
+import numpy as np
+from PIL import Image
+
+class WAS_Image_Style_Filter:
+    def __init__(self):
+        pass
+
+    @classmethod
+    def INPUT_TYPES(cls):
+        return {
+            "required": {
+                "image": ("IMAGE",),
+                "style": ([
+                    "1977",
+                    "aden",
+                    "brannan",
+                    "brooklyn",
+                    "clarendon",
+                    "earlybird",
+                    "gingham",
+                    "hudson",
+                    "inkwell",
+                    "kelvin",
+                    "lark",
+                    "lofi",
+                    "maven",
+                    "mayfair",
+                    "moon",
+                    "nashville",
+                    "perpetua",
+                    "reyes",
+                    "rise",
+                    "slumber",
+                    "stinson",
+                    "toaster",
+                    "valencia",
+                    "walden",
+                    "willow",
+                    "xpro2"
+                ],),
+            },
+        }
+
+    RETURN_TYPES = ("IMAGE",)
+    FUNCTION = "image_style_filter"
+
+    CATEGORY = "WAS"
+
+    def image_style_filter(self, image, style):
+    
+        # Install Pilgram
+        if 'pilgram' not in self.packages():
+            print("Installing Pilgram...")
+            subprocess.check_call([sys.executable, '-m', 'pip', '-q', 'install', 'pilgram'])
+            
+        # Import Pilgram module
+        import pilgram
+        
+        # Convert image to PIL
+        image = self.tensor2pil(image)
+        
+        # Apply blending
+        match style:
+            case "1977":
+                out_image = pilgram._1977(image)
+            case "aden":
+                out_image = pilgram.aden(image)
+            case "brannan":
+                out_image = pilgram.brannan(image)
+            case "brooklyn":
+                out_image = pilgram.brooklyn(image)
+            case "clarendon":
+                out_image = pilgram.clarendon(image)
+            case "earlybird":
+                out_image = pilgram.earlybird(image)
+            case "gingham":
+                out_image = pilgram.gingham(image)
+            case "hudson":
+                out_image = pilgram.hudson(image)
+            case "inkwell":
+                out_image = pilgram.inkwell(image)
+            case "kelvin":
+                out_image = pilgram.kelvin(image)
+            case "lark":
+                out_image = pilgram.lark(image)
+            case "lofi":
+                out_image = pilgram.lofi(image)
+            case "maven":
+                out_image = pilgram.maven(image)
+            case "mayfair":
+                out_image = pilgram.mayfair(image)
+            case "moon":
+                out_image = pilgram.moon(image)
+            case "nashville":
+                out_image = pilgram.nashville(image)
+            case "perpetua":
+                out_image = pilgram.perpetua(image)
+            case "reyes":
+                out_image = pilgram.reyes(image)
+            case "rise":
+                out_image = pilgram.rise(image)
+            case "slumber":
+                out_image = pilgram.slumber(image)
+            case "stinson":
+                out_image = pilgram.stinson(image)
+            case "toaster":
+                out_image = pilgram.toaster(image)
+            case "valencia":
+                out_image = pilgram.valencia(image)
+            case "walden":
+                out_image = pilgram.walden(image)
+            case "willow":
+                out_image = pilgram.willow(image)
+            case "xpro2":
+                out_image = pilgram.xpro2(image)
+            case _:
+                out_image = image
+                
+        out_image = out_image.convert("RGB")
+
+        return ( torch.from_numpy(np.array(out_image).astype(np.float32) / 255.0).unsqueeze(0), )
+     
+    # Convert tesnro to PIL image
+    def tensor2pil(self, image):
+            return Image.fromarray(np.clip(255. * image.cpu().numpy().squeeze(), 0, 255).astype(np.uint8))
+            
+    # Freeze packages
+    def packages(self):
+        import sys, subprocess
+        return [r.decode().split('==')[0] for r in subprocess.check_output([sys.executable, '-m', 'pip', 'freeze']).split()]
+
+NODE_CLASS_MAPPINGS = {
+    "Image Style Filter": WAS_Image_Style_Filter
+}

wasNodeSuitesComfyui_filtersSuiteV42/WAS_License.txt

@@ -0,0 +1,7 @@
+Copyright 2023 Jordan Thompson (WASasquatch)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the “Software”), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.