bizyengine 0.4.2__py3-none-any.whl

bizyengine/bizyair_extras/nodes_janus_pro.py

@@ -0,0 +1,81 @@
+from bizyengine.core import BizyAirBaseNode
+
+
+class JanusModelLoader(BizyAirBaseNode):
+
+    @classmethod
+    def INPUT_TYPES(s):
+        return {
+            "required": {
+                "model_name": (
+                    ["deepseek-ai/Janus-Pro-7B"],
+                ),  # "deepseek-ai/Janus-Pro-1B",
+            },
+        }
+
+    RETURN_TYPES = ("BIZYAIR_JANUS_MODEL", "BIZYAIR_JANUS_PROCESSOR")
+    RETURN_NAMES = ("model", "processor")
+    # FUNCTION = "load_model"
+    CATEGORY = "Janus-Pro"
+
+
+class JanusImageUnderstanding(BizyAirBaseNode):
+    @classmethod
+    def INPUT_TYPES(s):
+        return {
+            "required": {
+                "model": ("BIZYAIR_JANUS_MODEL",),
+                "processor": ("BIZYAIR_JANUS_PROCESSOR",),
+                "image": ("IMAGE",),
+                "question": (
+                    "STRING",
+                    {"multiline": True, "default": "Describe this image in detail."},
+                ),
+                "seed": (
+                    "INT",
+                    {"default": 666666666666666, "min": 0, "max": 0xFFFFFFFFFFFFFFFF},
+                ),
+                "temperature": ("FLOAT", {"default": 0.1, "min": 0.0, "max": 1.0}),
+                "top_p": ("FLOAT", {"default": 0.95, "min": 0.0, "max": 1.0}),
+                "max_new_tokens": ("INT", {"default": 512, "min": 1, "max": 2048}),
+            },
+        }
+
+    RETURN_TYPES = ("STRING",)
+    RETURN_NAMES = ("text",)
+    # FUNCTION = "analyze_image"
+    CATEGORY = "Janus-Pro"
+
+
+class JanusImageGeneration(BizyAirBaseNode):
+    @classmethod
+    def INPUT_TYPES(s):
+        return {
+            "required": {
+                "model": ("BIZYAIR_JANUS_MODEL",),
+                "processor": ("BIZYAIR_JANUS_PROCESSOR",),
+                "prompt": (
+                    "STRING",
+                    {"multiline": True, "default": "A beautiful photo of"},
+                ),
+                "seed": (
+                    "INT",
+                    {"default": 666666666666666, "min": 0, "max": 0xFFFFFFFFFFFFFFFF},
+                ),
+                "batch_size": ("INT", {"default": 4, "min": 4, "max": 9}),
+                "cfg_weight": (
+                    "FLOAT",
+                    {"default": 5.0, "min": 1.0, "max": 10.0, "step": 0.5},
+                ),
+                "temperature": (
+                    "FLOAT",
+                    {"default": 1.0, "min": 0.1, "max": 2.0, "step": 0.1},
+                ),
+                "top_p": ("FLOAT", {"default": 0.95, "min": 0.0, "max": 1.0}),
+            },
+        }
+
+    RETURN_TYPES = ("IMAGE",)
+    RETURN_NAMES = ("images",)
+    # FUNCTION = "generate_images"
+    CATEGORY = "Janus-Pro"

bizyengine/bizyair_extras/nodes_kolors_mz/__init__.py

@@ -0,0 +1,86 @@
+import os
+
+from bizyengine.core import BizyAirBaseNode, BizyAirNodeIO, create_node_data
+from bizyengine.core import path_utils as folder_paths
+from bizyengine.core.data_types import CLIP, CONDITIONING, CONTROL_NET, MODEL
+
+AUTHOR_NAME = "MinusZone"
+CATEGORY_NAME = f"Kolors"
+
+
+class MZ_KolorsUNETLoaderV2(BizyAirBaseNode):
+    @classmethod
+    def INPUT_TYPES(s):
+        return {
+            "required": {
+                "unet_name": (folder_paths.get_filename_list("unet"),),
+            }
+        }
+
+    RETURN_TYPES = (MODEL,)
+    RETURN_NAMES = ("model",)
+
+    FUNCTION = "load_unet"
+
+    CATEGORY = CATEGORY_NAME
+    NODE_DISPLAY_NAME = f"{AUTHOR_NAME} - KolorsUNETLoaderV2"
+
+    def load_unet(self, **kwargs):
+
+        node_data = create_node_data(
+            class_type="MZ_KolorsUNETLoaderV2",
+            inputs=kwargs,
+            outputs={"slot_index": 0},
+        )
+        config_file = folder_paths.guess_config(unet_name=kwargs["unet_name"])
+        out = BizyAirNodeIO(
+            self.assigned_id, {self.assigned_id: node_data}, config_file=config_file
+        )
+        return (out,)
+
+
+WEIGHT_TYPES = [
+    "linear",
+    "ease in",
+    "ease out",
+    "ease in-out",
+    "reverse in-out",
+    "weak input",
+    "weak output",
+    "weak middle",
+    "strong middle",
+    "style transfer",
+    "composition",
+    "strong style transfer",
+    "style and composition",
+    "style transfer precise",
+    "composition precise",
+]
+
+
+class MZ_KolorsControlNetLoader(BizyAirBaseNode):
+    @classmethod
+    def INPUT_TYPES(s):
+        return {
+            "required": {
+                "control_net_name": (folder_paths.get_filename_list("controlnet"),),
+                # "seed": ("INT", {"default": 0, "min": 0, "max": 1000000}),
+            }
+        }
+
+    RETURN_TYPES = (CONTROL_NET,)
+    RETURN_NAMES = ("ControlNet",)
+    FUNCTION = "load_controlnet"
+
+    CATEGORY = CATEGORY_NAME
+    NODE_DISPLAY_NAME = f"{AUTHOR_NAME} - KolorsControlNetLoader"
+
+    def load_controlnet(self, **kwargs):
+        node_data = create_node_data(
+            class_type="MZ_KolorsControlNetLoader",
+            inputs=kwargs,
+            outputs={"slot_index": 0},
+        )
+        assigned_id = self.assigned_id
+        node = BizyAirNodeIO(assigned_id, {assigned_id: node_data})
+        return (node,)

bizyengine/bizyair_extras/nodes_model_advanced.py

@@ -0,0 +1,62 @@
+# ComfyUI/comfy_extras/nodes_model_advanced.py
+import nodes
+from bizyengine.core import BizyAirBaseNode, BizyAirNodeIO, data_types
+
+
+class ModelSamplingSD3(BizyAirBaseNode):
+    @classmethod
+    def INPUT_TYPES(s):
+        return {
+            "required": {
+                "model": (data_types.MODEL,),
+                "shift": (
+                    "FLOAT",
+                    {"default": 3.0, "min": 0.0, "max": 100.0, "step": 0.01},
+                ),
+            }
+        }
+
+    RETURN_TYPES = (data_types.MODEL,)
+    # FUNCTION = "patch"
+
+    CATEGORY = "advanced/model"
+
+
+class ModelSamplingFlux(BizyAirBaseNode):
+    @classmethod
+    def INPUT_TYPES(s):
+        return {
+            "required": {
+                "model": (data_types.MODEL,),
+                "max_shift": (
+                    "FLOAT",
+                    {"default": 1.15, "min": 0.0, "max": 100.0, "step": 0.01},
+                ),
+                "base_shift": (
+                    "FLOAT",
+                    {"default": 0.5, "min": 0.0, "max": 100.0, "step": 0.01},
+                ),
+                "width": (
+                    "INT",
+                    {
+                        "default": 1024,
+                        "min": 16,
+                        "max": nodes.MAX_RESOLUTION,
+                        "step": 8,
+                    },
+                ),
+                "height": (
+                    "INT",
+                    {
+                        "default": 1024,
+                        "min": 16,
+                        "max": nodes.MAX_RESOLUTION,
+                        "step": 8,
+                    },
+                ),
+            }
+        }
+
+    RETURN_TYPES = (data_types.MODEL,)
+    # FUNCTION = "patch"
+    CATEGORY = "advanced/model"

bizyengine/bizyair_extras/nodes_sd3.py

@@ -0,0 +1,52 @@
+# sd3.5
+from bizyengine.core import BizyAirBaseNode, BizyAirNodeIO, data_types
+from bizyengine.core.path_utils import path_manager as folder_paths
+
+
+class TripleCLIPLoader(BizyAirBaseNode):
+    @classmethod
+    def INPUT_TYPES(s):
+        return {
+            "required": {
+                "clip_name1": (folder_paths.get_filename_list("clip"),),
+                "clip_name2": (folder_paths.get_filename_list("clip"),),
+                "clip_name3": (folder_paths.get_filename_list("clip"),),
+            }
+        }
+
+    RETURN_TYPES = (data_types.CLIP,)
+    # FUNCTION = "load_clip"
+
+    CATEGORY = "advanced/loaders"
+
+
+class ControlNetApplySD3(BizyAirBaseNode):
+    @classmethod
+    def INPUT_TYPES(s):
+        return {
+            "required": {
+                "positive": (data_types.CONDITIONING,),
+                "negative": (data_types.CONDITIONING,),
+                "control_net": (data_types.CONTROL_NET,),
+                "vae": (data_types.VAE,),
+                "image": ("IMAGE",),
+                "strength": (
+                    "FLOAT",
+                    {"default": 1.0, "min": 0.0, "max": 10.0, "step": 0.01},
+                ),
+                "start_percent": (
+                    "FLOAT",
+                    {"default": 0.0, "min": 0.0, "max": 1.0, "step": 0.001},
+                ),
+                "end_percent": (
+                    "FLOAT",
+                    {"default": 1.0, "min": 0.0, "max": 1.0, "step": 0.001},
+                ),
+            }
+        }
+
+    CATEGORY = "conditioning/controlnet"
+    # DEPRECATED = True
+    NODE_DISPLAY_NAME = "Apply Controlnet with VAE"
+    RETURN_TYPES = (data_types.CONDITIONING, data_types.CONDITIONING)
+    RETURN_NAMES = ("positive", "negative")

bizyengine/bizyair_extras/nodes_segment_anything.py

@@ -0,0 +1,256 @@
+from bizyengine.core import BizyAirBaseNode
+
+from .nodes_segment_anything_utils import *
+
+
+class BizyAir_SAMModelLoader(BizyAirBaseNode):
+    @classmethod
+    def INPUT_TYPES(cls):
+        return {
+            "required": {
+                "model_name": (list_sam_model(),),
+            }
+        }
+
+    CATEGORY = "☁️BizyAir/segment-anything"
+    # FUNCTION = "main"
+    RETURN_TYPES = ("SAM_PREDICTOR",)
+    NODE_DISPLAY_NAME = "☁️BizyAir Load SAM Model"
+
+
+class BizyAir_GroundingDinoModelLoader(BizyAirBaseNode):
+    @classmethod
+    def INPUT_TYPES(cls):
+        return {
+            "required": {
+                "model_name": (list_groundingdino_model(),),
+            }
+        }
+
+    CATEGORY = "☁️BizyAir/segment-anything"
+    # FUNCTION = "main"
+    RETURN_TYPES = ("GROUNDING_DINO_MODEL",)
+    NODE_DISPLAY_NAME = "☁️BizyAir Load GroundingDino Model"
+
+
+class BizyAir_VITMatteModelLoader(BizyAirBaseNode):
+    @classmethod
+    def INPUT_TYPES(cls):
+        method_list = [
+            "VITMatte",
+            "VITMatte(local)",
+        ]
+        return {
+            "required": {
+                "detail_method": (method_list,),
+            }
+        }
+
+    CATEGORY = "☁️BizyAir/segment-anything"
+    # FUNCTION = "main"
+    RETURN_TYPES = (
+        "VitMatte_MODEL",
+        "VitMatte_predictor",
+    )
+    NODE_DISPLAY_NAME = "☁️BizyAir Load VITMatte Model"
+
+
+class BizyAir_GroundingDinoSAMSegment(BizyAirBaseNode):
+    @classmethod
+    def INPUT_TYPES(cls):
+        return {
+            "required": {
+                "grounding_dino_model": ("GROUNDING_DINO_MODEL", {}),
+                "sam_predictor": ("SAM_PREDICTOR", {}),
+                "image": ("IMAGE", {}),
+                "prompt": ("STRING", {}),
+                "box_threshold": (
+                    "FLOAT",
+                    {"default": 0.3, "min": 0, "max": 1.0, "step": 0.01},
+                ),
+                "text_threshold": (
+                    "FLOAT",
+                    {"default": 0.3, "min": 0, "max": 1.0, "step": 0.01},
+                ),
+            }
+        }
+
+    CATEGORY = "☁️BizyAir/segment-anything"
+    # FUNCTION = "main"
+    RETURN_TYPES = ("IMAGE", "MASK")
+    NODE_DISPLAY_NAME = "☁️BizyAir GroundingDinoSAMSegment"
+
+
+class BizyAir_TrimapGenerate(BizyAirBaseNode):
+    @classmethod
+    def INPUT_TYPES(cls):
+        return {
+            "required": {
+                "mask": ("MASK",),
+                "detail_erode": (
+                    "INT",
+                    {"default": 6, "min": 1, "max": 255, "step": 1},
+                ),
+                "detail_dilate": (
+                    "INT",
+                    {"default": 6, "min": 1, "max": 255, "step": 1},
+                ),
+            }
+        }
+
+    CATEGORY = "☁️BizyAir/segment-anything"
+    # FUNCTION = "main"
+    RETURN_TYPES = ("MASK",)
+    RETURN_NAMES = ("trimap",)
+    NODE_DISPLAY_NAME = "☁️BizyAir Trimap Generate"
+
+
+class BizyAir_VITMattePredict(BizyAirBaseNode):
+    @classmethod
+    def INPUT_TYPES(cls):
+        return {
+            "required": {
+                "image": ("IMAGE", {}),
+                "trimap": ("MASK",),
+                "vitmatte_model": ("VitMatte_MODEL", {}),
+                "vitmatte_predictor": ("VitMatte_predictor", {}),
+                "black_point": (
+                    "FLOAT",
+                    {
+                        "default": 0.15,
+                        "min": 0.01,
+                        "max": 0.98,
+                        "step": 0.01,
+                        "display": "slider",
+                    },
+                ),
+                "white_point": (
+                    "FLOAT",
+                    {
+                        "default": 0.99,
+                        "min": 0.02,
+                        "max": 0.99,
+                        "step": 0.01,
+                        "display": "slider",
+                    },
+                ),
+                "max_megapixels": (
+                    "FLOAT",
+                    {"default": 2.0, "min": 1, "max": 999, "step": 0.1},
+                ),
+            }
+        }
+
+    CATEGORY = "☁️BizyAir/segment-anything"
+    # FUNCTION = "main"
+    RETURN_TYPES = (
+        "IMAGE",
+        "MASK",
+    )
+    RETURN_NAMES = (
+        "image",
+        "mask",
+    )
+    NODE_DISPLAY_NAME = "☁️BizyAir VITMatte Predict"
+
+
+class BizyAirDetailMethodPredict(BizyAirBaseNode):
+    NODE_DISPLAY_NAME = "☁️BizyAir DetailMethod Predict"
+
+    @classmethod
+    def INPUT_TYPES(cls):
+
+        method_list = [
+            "PyMatting",
+        ]
+        return {
+            "required": {
+                "image": ("IMAGE", {}),
+                "mask": ("MASK",),
+                "detail_method": (method_list,),
+                "detail_erode": (
+                    "INT",
+                    {"default": 6, "min": 1, "max": 255, "step": 1},
+                ),
+                "detail_dilate": (
+                    "INT",
+                    {"default": 6, "min": 1, "max": 255, "step": 1},
+                ),
+                "black_point": (
+                    "FLOAT",
+                    {
+                        "default": 0.15,
+                        "min": 0.01,
+                        "max": 0.98,
+                        "step": 0.01,
+                        "display": "slider",
+                    },
+                ),
+                "white_point": (
+                    "FLOAT",
+                    {
+                        "default": 0.99,
+                        "min": 0.02,
+                        "max": 0.99,
+                        "step": 0.01,
+                        "display": "slider",
+                    },
+                ),
+            }
+        }
+
+    CATEGORY = "☁️BizyAir/segment-anything"
+    FUNCTION = "main"
+    RETURN_TYPES = (
+        "IMAGE",
+        "MASK",
+    )
+    RETURN_NAMES = (
+        "image",
+        "mask",
+    )
+
+    def main(
+        self,
+        image,
+        mask,
+        detail_method,
+        detail_erode,
+        detail_dilate,
+        black_point,
+        white_point,
+    ):
+
+        ret_images = []
+        ret_masks = []
+        # device = comfy.model_management.get_torch_device()
+
+        for i in range(image.shape[0]):
+            img = torch.unsqueeze(image[i], 0)
+            img = pil2tensor(tensor2pil(img).convert("RGB"))
+            _image = tensor2pil(img).convert("RGBA")
+
+            detail_range = detail_erode + detail_dilate
+
+            if detail_method == "PyMatting":
+                _mask = tensor2pil(
+                    mask_edge_detail(
+                        img, mask[i], detail_range // 8 + 1, black_point, white_point
+                    )
+                )
+
+            _image = RGB2RGBA(tensor2pil(img).convert("RGB"), _mask.convert("L"))
+
+            ret_images.append(pil2tensor(_image))
+            ret_masks.append(image2mask(_mask))
+        if len(ret_masks) == 0:
+            _, height, width, _ = image.size()
+            empty_mask = torch.zeros(
+                (1, height, width), dtype=torch.uint8, device="cpu"
+            )
+            return (empty_mask, empty_mask)
+
+        return (
+            torch.cat(ret_images, dim=0),
+            torch.cat(ret_masks, dim=0),
+        )

bizyengine/bizyair_extras/nodes_segment_anything_utils.py

@@ -0,0 +1,134 @@
+import copy
+from typing import List
+
+import numpy as np
+import torch
+from PIL import Image
+from scipy.ndimage import gaussian_filter
+
+sam_model_dir_name = "sams"
+sam_model_list = {
+    "sam_vit_h (2.56GB)": {
+        "model_url": "https://dl.fbaipublicfiles.com/segment_anything/sam_vit_h_4b8939.pth"
+    },
+    # "sam_vit_l (1.25GB)": {
+    #     "model_url": "https://dl.fbaipublicfiles.com/segment_anything/sam_vit_l_0b3195.pth"
+    # },
+    # "sam_vit_b (375MB)": {
+    #     "model_url": "https://dl.fbaipublicfiles.com/segment_anything/sam_vit_b_01ec64.pth"
+    # },
+    # "sam_hq_vit_h (2.57GB)": {
+    #     "model_url": "https://huggingface.co/lkeab/hq-sam/resolve/main/sam_hq_vit_h.pth"
+    # },
+    # "sam_hq_vit_l (1.25GB)": {
+    #     "model_url": "https://huggingface.co/lkeab/hq-sam/resolve/main/sam_hq_vit_l.pth"
+    # },
+    # "sam_hq_vit_b (379MB)": {
+    #     "model_url": "https://huggingface.co/lkeab/hq-sam/resolve/main/sam_hq_vit_b.pth"
+    # },
+    # "mobile_sam(39MB)": {
+    #     "model_url": "https://github.com/ChaoningZhang/MobileSAM/blob/master/weights/mobile_sam.pt"
+    # },
+}
+
+groundingdino_model_dir_name = "grounding-dino"
+groundingdino_model_list = {
+    "GroundingDINO_SwinT_OGC (694MB)": {
+        "config_url": "https://huggingface.co/ShilongLiu/GroundingDINO/resolve/main/GroundingDINO_SwinT_OGC.cfg.py",
+        "model_url": "https://huggingface.co/ShilongLiu/GroundingDINO/resolve/main/groundingdino_swint_ogc.pth",
+    },
+    # "GroundingDINO_SwinB (938MB)": {
+    #     "config_url": "https://huggingface.co/ShilongLiu/GroundingDINO/resolve/main/GroundingDINO_SwinB.cfg.py",
+    #     "model_url": "https://huggingface.co/ShilongLiu/GroundingDINO/resolve/main/groundingdino_swinb_cogcoor.pth",
+    # },
+}
+
+
+def list_sam_model():
+    return list(sam_model_list.keys())
+
+
+def list_groundingdino_model():
+    return list(groundingdino_model_list.keys())
+
+
+def histogram_remap(
+    image: torch.Tensor, blackpoint: float, whitepoint: float
+) -> torch.Tensor:
+    bp = min(blackpoint, whitepoint - 0.001)
+    scale = 1 / (whitepoint - bp)
+    i_dup = copy.deepcopy(image.cpu().numpy())
+    i_dup = np.clip((i_dup - bp) * scale, 0.0, 1.0)
+    return torch.from_numpy(i_dup)
+
+
+def mask_edge_detail(
+    image: torch.Tensor,
+    mask: torch.Tensor,
+    detail_range: int = 8,
+    black_point: float = 0.01,
+    white_point: float = 0.99,
+) -> torch.Tensor:
+    from pymatting import estimate_alpha_cf, fix_trimap
+
+    d = detail_range * 5 + 1
+    mask = pil2tensor(tensor2pil(mask).convert("RGB"))
+    if not bool(d % 2):
+        d += 1
+    i_dup = copy.deepcopy(image.cpu().numpy().astype(np.float64))
+    a_dup = copy.deepcopy(mask.cpu().numpy().astype(np.float64))
+    for index, img in enumerate(i_dup):
+        trimap = a_dup[index][:, :, 0]  # convert to single channel
+        if detail_range > 0:
+            # trimap = cv2.GaussianBlur(trimap, (d, d), 0)
+            trimap = gaussian_filter(trimap, sigma=d / 2)
+        trimap = fix_trimap(trimap, black_point, white_point)
+        alpha = estimate_alpha_cf(
+            img, trimap, laplacian_kwargs={"epsilon": 1e-6}, cg_kwargs={"maxiter": 500}
+        )
+        a_dup[index] = np.stack([alpha, alpha, alpha], axis=-1)  # convert back to rgb
+    return torch.from_numpy(a_dup.astype(np.float32))
+
+
+def pil2tensor(image: Image) -> torch.Tensor:
+    return torch.from_numpy(np.array(image).astype(np.float32) / 255.0).unsqueeze(0)
+
+
+def tensor2pil(t_image: torch.Tensor) -> Image:
+    return Image.fromarray(
+        np.clip(255.0 * t_image.cpu().numpy().squeeze(), 0, 255).astype(np.uint8)
+    )
+
+
+def tensor2np(tensor: torch.Tensor) -> List[np.ndarray]:
+    if len(tensor.shape) == 3:  # Single image
+        return np.clip(255.0 * tensor.cpu().numpy(), 0, 255).astype(np.uint8)
+    else:  # Batch of images
+        return [
+            np.clip(255.0 * t.cpu().numpy(), 0, 255).astype(np.uint8) for t in tensor
+        ]
+
+
+def mask2image(mask: torch.Tensor) -> Image:
+    masks = tensor2np(mask)
+    for m in masks:
+        _mask = Image.fromarray(m).convert("L")
+        _image = Image.new("RGBA", _mask.size, color="white")
+        _image = Image.composite(
+            _image, Image.new("RGBA", _mask.size, color="black"), _mask
+        )
+    return _image
+
+
+def image2mask(image: Image) -> torch.Tensor:
+    _image = image.convert("RGBA")
+    alpha = _image.split()[0]
+    bg = Image.new("L", _image.size)
+    _image = Image.merge("RGBA", (bg, bg, bg, alpha))
+    ret_mask = torch.tensor([pil2tensor(_image)[0, :, :, 3].tolist()])
+    return ret_mask
+
+
+def RGB2RGBA(image: Image, mask: Image) -> Image:
+    (R, G, B) = image.convert("RGB").split()
+    return Image.merge("RGBA", (R, G, B, mask.convert("L")))