added Comfy UI Impact Pack

ComfyUI-Impact-Pack/.gitignore

@@ -0,0 +1,2 @@
+__pycache__
+*.ini

ComfyUI-Impact-Pack/README.md

@@ -0,0 +1,205 @@
+# ComfyUI-Impact-Pack
+
+This custom node helps to conveniently enhance images through Detector, Detailer, Upscaler, Pipe, and more.
+
+## Custom nodes pack for ComfyUI
+
+# Custom Nodes
+* SAMLoader - Load SAM model
+* MMDetDetectorProvider - Load MMDet model to provide BBOX_DETECTOR, SEGM_DETECTOR
+* ONNXDetectorProvider - Load ONNX model to provide SEGM_DETECTOR
+* CLIPSegDetectorProvider - CLIPSeg wrapper to provide BBOX_DETECTOR
+  * You need to install the [ComfyUI-CLIPSeg](https://github.com/biegert/ComfyUI-CLIPSeg) node extension. 
+* SEGM Detector (combined) - Detect segmentation and return mask from input image.
+* BBOX Detector (combined) - Detect bbox(bounding box) and return mask from input image.
+* SAMDetector (combined) - Using the technology of SAM, extract the segment at the location indicated by the input SEGS on the input image, and output it as a unified mask. 
+* Bitwise(SEGS & SEGS) - Perform 'bitwise and' operations between 2 SEGS.
+* Bitwise(SEGS - SEGS) - Perform subtract operations between 2 SEGS.
+* Bitwise(SEGS & MASK) - Perform a bitwise AND operation on SEGS and MASK.
+* Bitwise(MASK & MASK) - Perform 'bitwise and' operations between 2 masks
+* Bitwise(MASK - MASK) - Perform subtract operations between 2 masks
+* SEGM Detector (SEGS) - Detect segmentation and return SEGS from input image.
+* BBOX Detector (SEGS) - Detect bbox(bounding box) and return SEGS from input image.
+* ONNX Detector (SEGS) - Using the ONNX model, identify the bbox and retrieve the SEGS from the input image
+* Detailer (SEGS) - Refine image rely on SEGS.
+* DetailerDebug (SEGS) - Refine image rely on SEGS. Additionally, you can monitor cropped image and refined image of cropped image.
+   * To prevent the regeneration caused by the seed that does not change every time when using 'external_seed', please disable the 'seed random generate' option in the 'Detailer...' node
+* MASK to SEGS - This node generates SEGS based on the mask. 
+* ToBinaryMask - This node separates the mask generated with alpha values between 0 and 255 into 0 and 255. The non-zero parts are always set to 255.
+* EmptySEGS - This node provides a empty SEGS.
+* MaskPainter - This node provides a feature to draw masks.
+* FaceDetailer - This is a node that can easily detect faces and improve them.
+* FaceDetailer (pipe) - This is a node that can easily detect faces and improve them. (for multipass)
+* Pipe nodes
+   * ToDetailerPipe, FromDetailerPipe - These nodes are used to bundle multiple inputs used in the detailer, such as models and vae, ..., into a single DETAILER_PIPE or extract the elements that are bundled in the DETAILER_PIPE.
+   * ToBasicPipe, FromBasicPipe - These nodes are used to bundle model, clip, vae, positive conditioning, and negative conditioning into a single BASIC_PIPE, or extract each element from the BASIC_PIPE.
+   * EditBasicPipe, EditDetailerPipe - These nodes are used to replace some elements in BASIC_PIPE or DETAILER_PIPE.
+* Latent Scale (on Pixel Space) - This node converts latent to pixel space, upscales it, and then converts it back to latent.
+   * If upscale_model_opt is provided, it uses the model to upscale the pixel and then downscales it using the interpolation method provided in scale_method to the target resolution.
+* PixelKSampleUpscalerProvider - An upscaler is provided that converts latent to pixels using VAEDecode, performs upscaling, converts back to latent using VAEEncode, and then performs k-sampling. This upscaler can be attached to nodes such as 'Iterative Upscale' for use.
+  * Similar to 'Latent Scale (on Pixel Space)', if upscale_model_opt is provided, it performs pixel upscaling using the model.
+* PixelTiledKSampleUpscalerProvider - It is similar to PixelKSampleUpscalerProvider, but it uses ComfyUI_TiledKSampler and Tiled VAE Decoder/Encoder to avoid GPU VRAM issues at high resolutions.
+  * You need to install the [ComfyUI_TiledKSampler](https://github.com/BlenderNeko/ComfyUI_TiledKSampler) node extension.
+
+* DenoiseScheduleHookProvider - IterativeUpscale provides a hook that gradually changes the denoise to target_denoise as the step progresses.
+* CfgScheduleHookProvider - IterativeUpscale provides a hook that gradually changes the cfg to target_cfg as the step progresses.
+* PixelKSampleHookCombine - This is used to connect two PK_HOOKs. hook1 is executed first and then hook2 is executed.
+  * If you want to simultaneously change cfg and denoise, you can combine the PK_HOOKs of CfgScheduleHookProvider and PixelKSampleHookCombine.
+
+* Iterative Upscale (Latent) - The upscaler takes the input upscaler and splits the scale_factor into steps, then iteratively performs upscaling. 
+This takes latent as input and outputs latent as the result.
+* Iterative Upscale (Image) - The upscaler takes the input upscaler and splits the scale_factor into steps, then iteratively performs upscaling. This takes image as input and outputs image as the result.
+  * Internally, this node uses 'Iterative Upscale (Latent)'.
+
+* TwoSamplersForMask - This node can apply two samplers depending on the mask area. The base_sampler is applied to the area where the mask is 0, while the mask_sampler is applied to the area where the mask is 1.
+  * Note: The latent encoded through VAEEncodeForInpaint cannot be used.
+* KSamplerProvider - This is a wrapper that enables KSampler to be used in TwoSamplersForMask TwoSamplersForMaskUpscalerProvider.
+* TiledKSamplerProvider - ComfyUI_TiledKSampler is a wrapper that provides KSAMPLER.
+  * You need to install the [ComfyUI_TiledKSampler](https://github.com/BlenderNeko/ComfyUI_TiledKSampler) node extension.
+  
+* TwoSamplersForMaskUpscalerProvider - This is an Upscaler that extends TwoSamplersForMask to be used in Iterative Upscale.
+  * TwoSamplersForMaskUpscalerProviderPipe - pipe version of TwoSamplersForMaskUpscalerProvider.
+
+* PreviewBridge - This custom node can be used with a bridge when using the MaskEditor feature of Clipspace.
+
+# Feature
+* Interactive SAM Detector (Clipspace) - When you right-click on a node that has 'MASK' and 'IMAGE' outputs, a context menu will open. From this menu, you can either open a dialog to create a SAM Mask using 'Open in SAM Detector', or copy the content (likely mask data) using 'Copy (Clipspace)' and generate a mask using 'Impact SAM Detector' from the clipspace menu, and then paste it using 'Paste (Clipspace)'.
+
+
+# Deprecated
+* The following nodes have been kept only for compatibility with existing workflows, and are no longer supported. Please replace them with new nodes.
+   * MMDetLoader -> MMDetDetectorProvider
+   * SegsMaskCombine -> SEGS to MASK (combined)
+   * BboxDetectorForEach -> BBOX Detector (SEGS)
+   * SegmDetectorForEach -> SEGM Detector (SEGS)
+   * BboxDetectorCombined -> BBOX Detector (combined)
+   * SegmDetectorCombined -> SEGM Detector (combined)
+   * MaskPainter -> PreviewBridge
+
+# Installation
+
+1. cd custom_nodes
+1. git clone https://github.com/ltdrdata/ComfyUI-Impact-Pack.git
+3. cd ComfyUI-Impact-Pack
+4. (optional) python install.py
+   * Impact Pack will automatically install its dependencies during its initial launch.
+5. Restart ComfyUI
+
+* You can use this colab notebook [colab notebook](https://colab.research.google.com/github/ltdrdata/ComfyUI-Impact-Pack/blob/Main/notebook/comfyui_colab_impact_pack.ipynb) to launch it. This notebook automatically downloads the impact pack to the custom_nodes directory, installs the tested dependencies, and runs it.
+
+# Package Dependencies (If you need to manual setup.)
+
+* pip install
+   * openmim
+   * segment-anything
+   * pycocotools
+   * onnxruntime
+   
+* mim install
+   * mmcv==2.0.0, mmdet==3.0.0, mmengine==0.7.2
+
+* linux packages (ubuntu)
+  * libgl1-mesa-glx
+  * libglib2.0-0
+
+# Other Materials (auto-download on initial startup)
+
+* ComfyUI/models/mmdets/bbox <= https://huggingface.co/dustysys/ddetailer/resolve/main/mmdet/bbox/mmdet_anime-face_yolov3.pth
+* ComfyUI/models/mmdets/bbox <= https://raw.githubusercontent.com/Bing-su/dddetailer/master/config/mmdet_anime-face_yolov3.py
+* ComfyUI/models/sams <= https://dl.fbaipublicfiles.com/segment_anything/sam_vit_b_01ec64.pth
+
+# Troubleshooting page
+* [Troubleshooting Page](troubleshooting/TROUBLESHOOTING.md)
+
+
+# How to use (DDetailer feature)
+
+#### 1. Basic auto face detection and refine exapmle.
+![simple](https://github.com/ltdrdata/ComfyUI-extension-tutorials/raw/Main/ComfyUI-Impact-Pack/images/simple.png)
+* The face that has been damaged due to low resolution is restored with high resolution by generating and synthesizing it, in order to restore the details.
+* The FaceDetailer node is a combination of a Detector node for face detection and a Detailer node for image enhancement. See the [Advanced Tutorial](https://github.com/ltdrdata/ComfyUI-extension-tutorials/raw/Main/ComfyUI-Impact-Pack/tutorial/advanced.md) for a more detailed explanation.
+* Pass the MMDetLoader 's bbox model and the detection model loaded by SAMLoader to FaceDetailer . Since it performs the function of KSampler for image enhancement, it overlaps with KSampler's options.
+* The MASK output of FaceDetailer provides a visualization of where the detected and enhanced areas are.
+
+![simple-orig](https://github.com/ltdrdata/ComfyUI-extension-tutorials/raw/Main/ComfyUI-Impact-Pack/images/simple-original.png) ![simple-refined](https://github.com/ltdrdata/ComfyUI-extension-tutorials/raw/Main/ComfyUI-Impact-Pack/images/simple-refined.png)
+* You can see that the face in the image on the left has increased detail as in the image on the right.
+
+#### 2. 2Pass refine (restore a severely damaged face)
+![2pass-workflow-example](https://github.com/ltdrdata/ComfyUI-extension-tutorials/raw/Main/ComfyUI-Impact-Pack/images/2pass-simple.png)
+* Although two FaceDetailers can be attached together for a 2-pass configuration, various common inputs used in KSampler can be passed through DETAILER_PIPE, so FaceDetailerPipe can be used to configure easily.
+* In 1pass, only rough outline recovery is required, so restore with a reasonable resolution and low options. However, if you increase the dilation at this time, not only the face but also the surrounding parts are included in the recovery range, so it is useful when you need to reshape the face other than the facial part.
+
+![2pass-example-original](https://github.com/ltdrdata/ComfyUI-extension-tutorials/raw/Main/ComfyUI-Impact-Pack/images/2pass-original.png) ![2pass-example-middle](https://github.com/ltdrdata/ComfyUI-extension-tutorials/raw/Main/ComfyUI-Impact-Pack/images/2pass-1pass.png) ![2pass-example-result](https://github.com/ltdrdata/ComfyUI-extension-tutorials/raw/Main/ComfyUI-Impact-Pack/images/2pass-2pass.png)
+* In the first stage, the severely damaged face is restored to some extent, and in the second stage, the details are restored
+
+#### 3. Face Bbox(bounding box) + Person silhouette segmentation (prevent distortion of the background.)
+![combination-workflow-example](https://github.com/ltdrdata/ComfyUI-extension-tutorials/raw/Main/ComfyUI-Impact-Pack/images/combination.png)
+![combination-example-original](https://github.com/ltdrdata/ComfyUI-extension-tutorials/raw/Main/ComfyUI-Impact-Pack/images/combination-original.png) ![combination-example-refined](https://github.com/ltdrdata/ComfyUI-extension-tutorials/raw/Main/ComfyUI-Impact-Pack/images/combination-refined.png)
+
+* Facial synthesis that emphasizes details is delicately aligned with the contours of the face, and it can be observed that it does not affect the image outside of the face.
+
+* The BBoxDetectorForEach node is used to detect faces, and the SAMDetectorCombined node is used to find the segment related to the detected face. By using the Segs & Mask node with the two masks obtained in this way, an accurate mask that intersects based on segs can be generated. If this generated mask is input to the DetailerForEach node, only the target area can be created in high resolution from the image and then composited.
+
+#### 4. Iterative Upscale
+![upscale-workflow-example](https://github.com/ltdrdata/ComfyUI-extension-tutorials/raw/Main/ComfyUI-Impact-Pack/images/upscale-workflow.png)
+ 
+* The IterativeUpscale node is a node that enlarges an image/latent by a scale_factor. In this process, the upscale is carried out progressively by dividing it into steps.
+* IterativeUpscale takes an Upscaler as an input, similar to a plugin, and uses it during each iteration. PixelKSampleUpscalerProvider is an Upscaler that converts the latent representation to pixel space and applies ksampling.
+  * The upscale_model_opt is an optional parameter that determines whether to use the upscale function of the model base if available. Using the upscale function of the model base can significantly reduce the number of iterative steps required. If an x2 upscaler is used, the image/latent is first upscaled by a factor of 2 and then downscaled to the target scale at each step before further processing is done.
+
+* The following image is an image of 304x512 pixels and the same image scaled up to three times its original size using IterativeUpscale.
+
+![combination-example-original](https://github.com/ltdrdata/ComfyUI-extension-tutorials/raw/Main/ComfyUI-Impact-Pack/images/upscale-original.png) ![combination-example-refined](https://github.com/ltdrdata/ComfyUI-extension-tutorials/raw/Main/ComfyUI-Impact-Pack/images/upscale-3x.png)
+
+
+#### 5. Interactive SAM Detector (Clipspace)
+
+* When you right-click on the node that outputs 'MASK' and 'IMAGE', a menu called "Open in SAM Detector" appears, as shown in the following picture. Clicking on the menu opens a dialog in SAM's functionality, allowing you to generate a segment mask.
+![samdetector-menu](https://github.com/ltdrdata/ComfyUI-extension-tutorials/raw/Main/ComfyUI-Impact-Pack/images/SAMDetector-menu.png)
+
+* By clicking the left mouse button on a coordinate, a positive prompt in blue color is entered, indicating the area that should be included. Clicking the right mouse button on a coordinate enters a negative prompt in red color, indicating the area that should be excluded. Positive prompts represent the areas that should be included, while negative prompts represent the areas that should be excluded.
+* You can remove the points that were added by using the "undo" button. After selecting the points, pressing the "detect" button generates the mask. Additionally, you can adjust the fidelity slider to determine the extent to which the mask belongs to the confidence region.
+
+![samdetector-dialog](https://github.com/ltdrdata/ComfyUI-extension-tutorials/raw/Main/ComfyUI-Impact-Pack/images/SAMDetector-dialog.png)
+
+* If you opened the dialog through "Open in SAM Detector" from the node, you can directly apply the changes by clicking the "Save to node" button. However, if you opened the dialog through the "clipspace" menu, you can save it to clipspace by clicking the "Save" button.
+
+![samdetector-result](https://github.com/ltdrdata/ComfyUI-extension-tutorials/raw/Main/ComfyUI-Impact-Pack/images/SAMDetector-result.png)
+
+* When you execute using the reflected mask in the node, you can observe that the image and mask are displayed separately.
+
+# Others Tutorials
+* [ComfyUI-extension-tutorials/ComfyUI-Impact-Pack](https://github.com/ltdrdata/ComfyUI-extension-tutorials/tree/Main/ComfyUI-Impact-Pack) - You can find various tutorials and workflows on this page.
+* [Advanced Tutorial](https://github.com/ltdrdata/ComfyUI-extension-tutorials/blob/Main/ComfyUI-Impact-Pack/tutorial/advanced.md)
+* [SAM Application](https://github.com/ltdrdata/ComfyUI-extension-tutorials/blob/Main/ComfyUI-Impact-Pack/tutorial/sam.md)
+* [PreviewBridge](https://github.com/ltdrdata/ComfyUI-extension-tutorials/blob/Main/ComfyUI-Impact-Pack/tutorial/previewbridge.md)
+* [Mask Pointer](https://github.com/ltdrdata/ComfyUI-extension-tutorials/blob/Main/ComfyUI-Impact-Pack/tutorial/maskpointer.md)
+* [ONNX Tutorial](https://github.com/ltdrdata/ComfyUI-extension-tutorials/blob/Main/ComfyUI-Impact-Pack/tutorial/ONNX.md)
+* [CLIPSeg Tutorial](https://github.com/ltdrdata/ComfyUI-extension-tutorials/blob/Main/ComfyUI-Impact-Pack/tutorial/clipseg.md)
+* [Extreme Highresolution Upscale](https://github.com/ltdrdata/ComfyUI-extension-tutorials/blob/Main/ComfyUI-Impact-Pack/tutorial/extreme-upscale.md)
+* [TwoSamplersForMask](https://github.com/ltdrdata/ComfyUI-extension-tutorials/blob/Main/ComfyUI-Impact-Pack/tutorial/TwoSamplers.md)
+* [Advanced Iterative Upscale: PK_HOOK](https://github.com/ltdrdata/ComfyUI-extension-tutorials/blob/Main/ComfyUI-Impact-Pack/tutorial/pk_hook.md)
+* [Advanced Iterative Upscale: TwoSamplersForMask Upscale Provider](https://github.com/ltdrdata/ComfyUI-extension-tutorials/blob/Main/ComfyUI-Impact-Pack/tutorial/TwoSamplersUpscale.md)
+
+* [Interactive SAM + PreviewBridge](https://github.com/ltdrdata/ComfyUI-extension-tutorials/blob/Main/ComfyUI-Impact-Pack/tutorial/sam_with_preview_bridge.md)
+
+# Credits
+
+ComfyUI/[ComfyUI](https://github.com/comfyanonymous/ComfyUI) - A powerful and modular stable diffusion GUI.
+
+dustysys/[ddetailer](https://github.com/dustysys/ddetailer) - DDetailer for Stable-diffusion-webUI extension.
+
+Bing-su/[dddetailer](https://github.com/Bing-su/dddetailer) - The anime-face-detector used in ddetailer has been updated to be compatible with mmdet 3.0.0, and we have also applied a patch to the pycocotools dependency for Windows environment in ddetailer.
+
+facebook/[segment-anything](https://github.com/facebookresearch/segment-anything) - Segmentation Anything!
+
+hysts/[anime-face-detector](https://github.com/hysts/anime-face-detector) - Creator of `anime-face_yolov3`, which has impressive performance on a variety of art styles.
+
+open-mmlab/[mmdetection](https://github.com/open-mmlab/mmdetection) - Object detection toolset. `dd-person_mask2former` was trained via transfer learning using their [R-50 Mask2Former instance segmentation model](https://github.com/open-mmlab/mmdetection/tree/master/configs/mask2former#instance-segmentation) as a base.
+
+biegert/[ComfyUI-CLIPSeg](https://github.com/biegert/ComfyUI-CLIPSeg) - This is a custom node that enables the use of CLIPSeg technology, which can find segments through prompts, in ComfyUI.
+
+BlenderNeok/[ComfyUI-TiledKSampler](https://github.com/BlenderNeko/ComfyUI_TiledKSampler) - 
+The tile sampler allows high-resolution sampling even in places with low GPU VRAM.
+
+WASasquatch/[was-node-suite-comfyui](https://github.com/WASasquatch/was-node-suite-comfyui) - A powerful custom node extensions of ComfyUI.

ComfyUI-Impact-Pack/__init__.py

@@ -0,0 +1,177 @@
+import shutil
+import folder_paths
+import os
+import sys
+
+comfy_path = os.path.dirname(folder_paths.__file__)
+impact_path = os.path.dirname(__file__)
+
+sys.path.append(impact_path)
+
+import impact_config
+print(f"### Loading: ComfyUI-Impact-Pack ({impact_config.version})")
+
+# ensure dependency
+if impact_config.read_config()[1] < impact_config.dependency_version:
+    import install  # to install dependencies
+# Core
+# recheck dependencies for colab
+try:
+    import folder_paths
+    import torch
+    import cv2
+    import mmcv
+    import numpy as np
+    from mmdet.apis import (inference_detector, init_detector)
+    import comfy.samplers
+    import comfy.sd
+    import warnings
+    from PIL import Image, ImageFilter
+    from mmdet.evaluation import get_classes
+    from skimage.measure import label, regionprops
+    from collections import namedtuple
+except:
+    print("### ComfyUI-Impact-Pack: Reinstall dependencies (several dependencies are missing.)")
+    import install
+
+import impact_server  # to load server api
+
+def setup_js():
+    # remove garbage
+    old_js_path = os.path.join(comfy_path, "web", "extensions", "core", "impact-pack.js")
+    if os.path.exists(old_js_path):
+        os.remove(old_js_path)
+
+    # setup js
+    js_dest_path = os.path.join(comfy_path, "web", "extensions", "impact-pack")
+    if not os.path.exists(js_dest_path):
+        os.makedirs(js_dest_path)
+
+    js_src_path = os.path.join(impact_path, "js", "impact-pack.js")
+    shutil.copy(js_src_path, js_dest_path)
+
+    js_src_path = os.path.join(impact_path, "js", "impact-sam-editor.js")
+    shutil.copy(js_src_path, js_dest_path)
+    
+setup_js()
+
+import legacy_nodes
+from impact_pack import *
+from detectors import *
+from impact_pipe import *
+
+NODE_CLASS_MAPPINGS = {
+    "SAMLoader": SAMLoader,
+    "MMDetDetectorProvider": MMDetDetectorProvider,
+    "CLIPSegDetectorProvider": CLIPSegDetectorProvider,
+    "ONNXDetectorProvider": ONNXDetectorProvider,
+
+    "BitwiseAndMaskForEach": BitwiseAndMaskForEach,
+    "SubtractMaskForEach": SubtractMaskForEach,
+
+    "DetailerForEach": DetailerForEach,
+    "DetailerForEachDebug": DetailerForEachTest,
+    "DetailerForEachPipe": DetailerForEachPipe,
+    "DetailerForEachDebugPipe": DetailerForEachTestPipe,
+
+    "SAMDetectorCombined": SAMDetectorCombined,
+
+    "FaceDetailer": FaceDetailer,
+    "FaceDetailerPipe": FaceDetailerPipe,
+
+    "ToDetailerPipe": ToDetailerPipe ,
+    "FromDetailerPipe": FromDetailerPipe,
+    "ToBasicPipe": ToBasicPipe,
+    "FromBasicPipe": FromBasicPipe,
+    "BasicPipeToDetailerPipe": BasicPipeToDetailerPipe,
+    "DetailerPipeToBasicPipe": DetailerPipeToBasicPipe,
+    "EditBasicPipe": EditBasicPipe,
+    "EditDetailerPipe": EditDetailerPipe,
+
+    "LatentPixelScale": LatentPixelScale,
+    "PixelKSampleUpscalerProvider": PixelKSampleUpscalerProvider,
+    "PixelKSampleUpscalerProviderPipe": PixelKSampleUpscalerProviderPipe,
+    "IterativeLatentUpscale": IterativeLatentUpscale,
+    "IterativeImageUpscale": IterativeImageUpscale,
+    "PixelTiledKSampleUpscalerProvider": PixelTiledKSampleUpscalerProvider,
+    "PixelTiledKSampleUpscalerProviderPipe": PixelTiledKSampleUpscalerProviderPipe,
+    "TwoSamplersForMaskUpscalerProvider": TwoSamplersForMaskUpscalerProvider,
+    "TwoSamplersForMaskUpscalerProviderPipe": TwoSamplersForMaskUpscalerProviderPipe,
+
+    "PixelKSampleHookCombine": PixelKSampleHookCombine,
+    "DenoiseScheduleHookProvider": DenoiseScheduleHookProvider,
+    "CfgScheduleHookProvider": CfgScheduleHookProvider,
+
+    "BitwiseAndMask": BitwiseAndMask,
+    "SubtractMask": SubtractMask,
+    "Segs & Mask": SegsBitwiseAndMask,
+    "EmptySegs": EmptySEGS,
+
+    "MaskToSEGS": MaskToSEGS,
+    "ToBinaryMask": ToBinaryMask,
+
+    "BboxDetectorSEGS": BboxDetectorForEach,
+    "SegmDetectorSEGS": SegmDetectorForEach,
+    "ONNXDetectorSEGS": ONNXDetectorForEach,
+
+    "BboxDetectorCombined": BboxDetectorCombined,
+    "SegmDetectorCombined": SegmDetectorCombined,
+    "SegsToCombinedMask": SegsToCombinedMask,
+
+    "KSamplerProvider": KSamplerProvider,
+    "TwoSamplersForMask": TwoSamplersForMask,
+    "TiledKSamplerProvider": TiledKSamplerProvider,
+
+    "PreviewBridge": PreviewBridge,
+
+    "MaskPainter": legacy_nodes.MaskPainter,
+    "MMDetLoader": legacy_nodes.MMDetLoader,
+    "SegsMaskCombine": legacy_nodes.SegsMaskCombine,
+    "BboxDetectorForEach": legacy_nodes.BboxDetectorForEach,
+    "SegmDetectorForEach": legacy_nodes.SegmDetectorForEach,
+    "BboxDetectorCombined": legacy_nodes.BboxDetectorCombined,
+    "SegmDetectorCombined": legacy_nodes.SegmDetectorCombined,
+}
+
+NODE_DISPLAY_NAME_MAPPINGS = {
+    "BboxDetectorSEGS": "BBOX Detector (SEGS)",
+    "SegmDetectorSEGS": "SEGM Detector (SEGS)",
+    "ONNXDetectorSEGS": "ONNX Detector (SEGS)",
+    "BboxDetectorCombined": "BBOX Detector (combined)",
+    "SegmDetectorCombined": "SEGM Detector (combined)",
+    "SegsToCombinedMask": "SEGS to MASK (combined)",
+    "MaskToSEGS": "MASK to SEGS",
+    "BitwiseAndMaskForEach": "Bitwise(SEGS & SEGS)",
+    "SubtractMaskForEach": "Bitwise(SEGS - SEGS)",
+    "Segs & Mask": "Bitwise(SEGS & MASK)",
+    "BitwiseAndMask": "Bitwise(MASK & MASK)",
+    "SubtractMask": "Bitwise(MASK - MASK)",
+    "DetailerForEach": "Detailer (SEGS)",
+    "DetailerForEachPipe": "Detailer (SEGS/pipe)",
+    "DetailerForEachDebug": "DetailerDebug (SEGS)",
+    "DetailerForEachDebugPipe": "DetailerDebug (SEGS/pipe)",
+    "SAMDetectorCombined": "SAMDetector (combined)",
+    "FaceDetailerPipe": "FaceDetailer (pipe)",
+
+    "BasicPipeToDetailerPipe": "BasicPipe -> DetailerPipe",
+    "DetailerPipeToBasicPipe": "DetailerPipe -> BasicPipe",
+    "EditBasicPipe": "Edit BasicPipe",
+    "EditDetailerPipe": "Edit DetailerPipe",
+
+    "LatentPixelScale": "Latent Scale (on Pixel Space)",
+    "IterativeLatentUpscale": "Iterative Upscale (Latent)",
+    "IterativeImageUpscale": "Iterative Upscale (Image)",
+
+    "TwoSamplersForMaskUpscalerProvider": "TwoSamplersForMask Upscaler Provider",
+    "TwoSamplersForMaskUpscalerProviderPipe": "TwoSamplersForMask Upscaler Provider (pipe)",
+
+    "MaskPainter": "MaskPainter (Deprecated)",
+    "MMDetLoader": "MMDetLoader (Legacy)",
+    "SegsMaskCombine": "SegsMaskCombine (Legacy)",
+    "BboxDetectorForEach": "BboxDetectorForEach (Legacy)",
+    "SegmDetectorForEach": "SegmDetectorForEach (Legacy)",
+    "BboxDetectorCombined": "BboxDetectorCombined (Legacy)",
+    "SegmDetectorCombined": "SegmDetectorCombined (Legacy)",
+}
+
+__all__ = ['NODE_CLASS_MAPPINGS', 'NODE_DISPLAY_NAME_MAPPINGS']

ComfyUI-Impact-Pack/additional_dependencies.py

@@ -0,0 +1,12 @@
+import sys
+import subprocess
+
+
+def ensure_onnx_package():
+    try:
+        import onnxruntime
+    except Exception:
+        if "python_embeded" in sys.executable or "python_embedded" in sys.executable:
+            subprocess.check_call([sys.executable, '-s', '-m', 'pip', 'install', '--user', 'onnxruntime'])
+        else:
+            subprocess.check_call([sys.executable, '-s', '-m', 'pip', 'install', 'onnxruntime'])

ComfyUI-Impact-Pack/detectors.py

@@ -0,0 +1,112 @@
+import impact_core as core
+from impact_config import MAX_RESOLUTION
+
+
+class SAMDetectorCombined:
+    @classmethod
+    def INPUT_TYPES(s):
+        return {"required": {
+                        "sam_model": ("SAM_MODEL", ),
+                        "segs": ("SEGS", ),
+                        "image": ("IMAGE", ),
+                        "detection_hint": (["center-1", "horizontal-2", "vertical-2", "rect-4", "diamond-4", "mask-area",
+                                            "mask-points", "mask-point-bbox", "none"],),
+                        "dilation": ("INT", {"default": 0, "min": 0, "max": 255, "step": 1}),
+                        "threshold": ("FLOAT", {"default": 0.93, "min": 0.0, "max": 1.0, "step": 0.01}),
+                        "bbox_expansion": ("INT", {"default": 0, "min": 0, "max": 1000, "step": 1}),
+                        "mask_hint_threshold": ("FLOAT", {"default": 0.7, "min": 0.0, "max": 1.0, "step": 0.01}),
+                        "mask_hint_use_negative": (["False", "Small", "Outter"], )
+                      }
+                }
+
+    RETURN_TYPES = ("MASK",)
+    FUNCTION = "doit"
+
+    CATEGORY = "ImpactPack/Detector"
+
+    def doit(self, sam_model, segs, image, detection_hint, dilation,
+             threshold, bbox_expansion, mask_hint_threshold, mask_hint_use_negative):
+        return (core.make_sam_mask(sam_model, segs, image, detection_hint, dilation,
+                                   threshold, bbox_expansion, mask_hint_threshold, mask_hint_use_negative), )
+
+class BboxDetectorForEach:
+    @classmethod
+    def INPUT_TYPES(s):
+        return {"required": {
+                        "bbox_detector": ("BBOX_DETECTOR", ),
+                        "image": ("IMAGE", ),
+                        "threshold": ("FLOAT", {"default": 0.5, "min": 0.0, "max": 1.0, "step": 0.01}),
+                        "dilation": ("INT", {"default": 10, "min": 0, "max": 255, "step": 1}),
+                        "crop_factor": ("FLOAT", {"default": 3.0, "min": 1.0, "max": 10, "step": 0.1}),
+                        "drop_size": ("INT", {"min": 1, "max": MAX_RESOLUTION, "step": 1, "default": 10}),
+                      }
+                }
+
+    RETURN_TYPES = ("SEGS", )
+    FUNCTION = "doit"
+
+    CATEGORY = "ImpactPack/Detector"
+
+    def doit(self, bbox_detector, image, threshold, dilation, crop_factor, drop_size):
+        segs = bbox_detector.detect(image, threshold, dilation, crop_factor, drop_size)
+        return (segs, )
+
+
+class SegmDetectorForEach:
+    @classmethod
+    def INPUT_TYPES(s):
+        return {"required": {
+                        "segm_detector": ("SEGM_DETECTOR", ),
+                        "image": ("IMAGE", ),
+                        "threshold": ("FLOAT", {"default": 0.5, "min": 0.0, "max": 1.0, "step": 0.01}),
+                        "dilation": ("INT", {"default": 10, "min": 0, "max": 255, "step": 1}),
+                        "crop_factor": ("FLOAT", {"default": 3.0, "min": 1.0, "max": 10, "step": 0.1}),
+                        "drop_size": ("INT", {"min": 1, "max": MAX_RESOLUTION, "step": 1, "default": 10}),
+                      }
+                }
+
+    RETURN_TYPES = ("SEGS", )
+    FUNCTION = "doit"
+
+    CATEGORY = "ImpactPack/Detector"
+
+    def doit(self, segm_detector, image, threshold, dilation, crop_factor, drop_size):
+        segs = segm_detector.detect(image, threshold, dilation, crop_factor, drop_size)
+        return (segs, )
+
+
+class SegmDetectorCombined:
+    @classmethod
+    def INPUT_TYPES(s):
+        return {"required": {
+                        "segm_detector": ("SEGM_DETECTOR", ),
+                        "image": ("IMAGE", ),
+                        "threshold": ("FLOAT", {"default": 0.5, "min": 0.0, "max": 1.0, "step": 0.01}),
+                        "dilation": ("INT", {"default": 0, "min": 0, "max": 255, "step": 1}),
+                      }
+                }
+
+    RETURN_TYPES = ("MASK",)
+    FUNCTION = "doit"
+
+    CATEGORY = "ImpactPack/Detector"
+
+    def doit(self, segm_detector, image, threshold, dilation):
+        mask = segm_detector.detect_combined(image, threshold, dilation)
+        return (mask,)
+
+
+class BboxDetectorCombined(SegmDetectorCombined):
+    @classmethod
+    def INPUT_TYPES(s):
+        return {"required": {
+                        "bbox_detector": ("BBOX_DETECTOR", ),
+                        "image": ("IMAGE", ),
+                        "threshold": ("FLOAT", {"default": 0.5, "min": 0.0, "max": 1.0, "step": 0.01}),
+                        "dilation": ("INT", {"default": 4, "min": 0, "max": 255, "step": 1}),
+                      }
+                }
+
+    def doit(self, bbox_detector, image, threshold, dilation):
+        mask = bbox_detector.detect_combined(image, threshold, dilation)
+        return (mask,)

ComfyUI-Impact-Pack/impact_config.py

@@ -0,0 +1,30 @@
+import configparser
+import os
+
+version = "V2.7.5"
+
+dependency_version = 1
+
+my_path = os.path.dirname(__file__)
+config_path = os.path.join(my_path, "impact-pack.ini")
+MAX_RESOLUTION = 8192
+
+def write_config(comfy_path):
+    config = configparser.ConfigParser()
+    config['default'] = {
+        'dependency_version': dependency_version,
+        'comfy_path': comfy_path
+    }
+    with open(config_path, 'w') as configfile:
+        config.write(configfile)
+
+
+def read_config():
+    try:
+        config = configparser.ConfigParser()
+        config.read(config_path)
+        default_conf = config['default']
+
+        return default_conf['comfy_path'], int(default_conf['dependency_version'])
+    except Exception:
+        return "", 0

ComfyUI-Impact-Pack/impact_core.py

@@ -0,0 +1,1160 @@
+import os
+import sys
+import mmcv
+from mmdet.apis import (inference_detector, init_detector)
+from mmdet.evaluation import get_classes
+from segment_anything import SamPredictor
+import torch.nn.functional as F
+
+from impact_utils import *
+from collections import namedtuple
+import numpy as np
+from skimage.measure import label, regionprops
+
+main_dir = os.path.dirname(os.path.abspath(sys.argv[0]))
+sys.path.append(os.path.dirname(__file__))
+sys.path.append(main_dir)
+
+import nodes
+import comfy_extras.nodes_upscale_model as model_upscale
+
+SEG = namedtuple("SEG", ['cropped_image', 'cropped_mask', 'confidence', 'crop_region', 'bbox', 'label'],
+                 defaults=[None])
+
+
+class NO_BBOX_DETECTOR:
+    pass
+
+
+class NO_SEGM_DETECTOR:
+    pass
+
+
+def load_mmdet(model_path):
+    model_config = os.path.splitext(model_path)[0] + ".py"
+    model = init_detector(model_config, model_path, device="cpu")
+    return model
+
+
+def create_segmasks(results):
+    bboxs = results[1]
+    segms = results[2]
+    confidence = results[3]
+
+    results = []
+    for i in range(len(segms)):
+        item = (bboxs[i], segms[i].astype(np.float32), confidence[i])
+        results.append(item)
+    return results
+
+
+def inference_segm_old(model, image, conf_threshold):
+    image = image.numpy()[0] * 255
+    mmdet_results = inference_detector(model, image)
+
+    bbox_results, segm_results = mmdet_results
+    label = "A"
+
+    classes = get_classes("coco")
+    labels = [
+        np.full(bbox.shape[0], i, dtype=np.int32)
+        for i, bbox in enumerate(bbox_results)
+    ]
+    n, m = bbox_results[0].shape
+    if n == 0:
+        return [[], [], []]
+    labels = np.concatenate(labels)
+    bboxes = np.vstack(bbox_results)
+    segms = mmcv.concat_list(segm_results)
+    filter_idxs = np.where(bboxes[:, -1] > conf_threshold)[0]
+    results = [[], [], []]
+    for i in filter_idxs:
+        results[0].append(label + "-" + classes[labels[i]])
+        results[1].append(bboxes[i])
+        results[2].append(segms[i])
+
+    return results
+
+
+def inference_segm(image, modelname, conf_thres, lab="A"):
+    image = image.numpy()[0] * 255
+    mmdet_results = inference_detector(modelname, image).pred_instances
+    bboxes = mmdet_results.bboxes.numpy()
+    segms = mmdet_results.masks.numpy()
+    scores = mmdet_results.scores.numpy()
+
+    classes = get_classes("coco")
+
+    n, m = bboxes.shape
+    if n == 0:
+        return [[], [], [], []]
+    labels = mmdet_results.labels
+    filter_inds = np.where(mmdet_results.scores > conf_thres)[0]
+    results = [[], [], [], []]
+    for i in filter_inds:
+        results[0].append(lab + "-" + classes[labels[i]])
+        results[1].append(bboxes[i])
+        results[2].append(segms[i])
+        results[3].append(scores[i])
+
+    return results
+
+
+def inference_bbox(modelname, image, conf_threshold):
+    image = image.numpy()[0] * 255
+    label = "A"
+    output = inference_detector(modelname, image).pred_instances
+    cv2_image = np.array(image)
+    cv2_image = cv2_image[:, :, ::-1].copy()
+    cv2_gray = cv2.cvtColor(cv2_image, cv2.COLOR_BGR2GRAY)
+
+    segms = []
+    for x0, y0, x1, y1 in output.bboxes:
+        cv2_mask = np.zeros(cv2_gray.shape, np.uint8)
+        cv2.rectangle(cv2_mask, (int(x0), int(y0)), (int(x1), int(y1)), 255, -1)
+        cv2_mask_bool = cv2_mask.astype(bool)
+        segms.append(cv2_mask_bool)
+
+    n, m = output.bboxes.shape
+    if n == 0:
+        return [[], [], [], []]
+
+    bboxes = output.bboxes.numpy()
+    scores = output.scores.numpy()
+    filter_idxs = np.where(scores > conf_threshold)[0]
+    results = [[], [], [], []]
+    for i in filter_idxs:
+        results[0].append(label)
+        results[1].append(bboxes[i])
+        results[2].append(segms[i])
+        results[3].append(scores[i])
+
+    return results
+
+
+def gen_detection_hints_from_mask_area(x, y, mask, threshold, use_negative):
+    points = []
+    plabs = []
+
+    # minimum sampling step >= 3
+    y_step = max(3, int(mask.shape[0]/20))
+    x_step = max(3, int(mask.shape[1]/20))
+    
+    for i in range(0, len(mask), y_step):
+        for j in range(0, len(mask[i]), x_step):
+            if mask[i][j] > threshold:
+                points.append((x+j, y+i))
+                plabs.append(1)
+            elif use_negative and mask[i][j] == 0:
+                points.append((x+j, y+i))
+                plabs.append(0)
+    
+    return points, plabs
+
+
+def gen_negative_hints(w, h, x1, y1, x2, y2):
+    npoints = []
+    nplabs = []
+
+    # minimum sampling step >= 3
+    y_step = max(3, int(w/20))
+    x_step = max(3, int(h/20))
+    
+    for i in range(10, h-10, y_step):
+        for j in range(10, w-10, x_step):
+            if not (x1-10 <= j and j <= x2+10 and y1-10 <= i and i <= y2+10):
+                npoints.append((j, i))
+                nplabs.append(0)
+
+    return npoints, nplabs
+
+
+def enhance_detail(image, model, vae, guide_size, guide_size_for, bbox, seed, steps, cfg, sampler_name, scheduler,
+                   positive, negative, denoise, noise_mask, force_inpaint):
+    h = image.shape[1]
+    w = image.shape[2]
+
+    bbox_h = bbox[3] - bbox[1]
+    bbox_w = bbox[2] - bbox[0]
+
+    # Skip processing if the detected bbox is already larger than the guide_size
+    if bbox_h >= guide_size and bbox_w >= guide_size:
+        print(f"Detailer: segment skip")
+        None
+
+    if guide_size_for == "bbox":
+        # Scale up based on the smaller dimension between width and height.
+        upscale = guide_size / min(bbox_w, bbox_h)
+    else:
+        # for cropped_size
+        upscale = guide_size / min(w, h)
+
+    new_w = int(w * upscale)
+    new_h = int(h * upscale)
+
+    if not force_inpaint:
+        if upscale <= 1.0:
+            print(f"Detailer: segment skip [determined upscale factor={upscale}]")
+            return None
+
+        if new_w == 0 or new_h == 0:
+            print(f"Detailer: segment skip [zero size={new_w, new_h}]")
+            return None
+    else:
+        if upscale <= 1.0 or new_w == 0 or new_h == 0:
+            print(f"Detailer: force inpaint")
+            upscale = 1.0
+            new_w = w
+            new_h = h
+
+    print(f"Detailer: segment upscale for ({bbox_w, bbox_h}) | crop region {w, h} x {upscale} -> {new_w, new_h}")
+
+    # upscale
+    upscaled_image = scale_tensor(new_w, new_h, torch.from_numpy(image))
+
+    # ksampler
+    latent_image = to_latent_image(upscaled_image, vae)
+
+    if noise_mask is not None:
+        # upscale the mask tensor by a factor of 2 using bilinear interpolation
+        noise_mask = torch.from_numpy(noise_mask)
+        upscaled_mask = torch.nn.functional.interpolate(noise_mask.unsqueeze(0).unsqueeze(0), size=(new_h, new_w),
+                                                        mode='bilinear', align_corners=False)
+
+        # remove the extra dimensions added by unsqueeze
+        upscaled_mask = upscaled_mask.squeeze().squeeze()
+        latent_image['noise_mask'] = upscaled_mask
+
+    sampler = nodes.KSampler()
+    refined_latent = sampler.sample(model, seed, steps, cfg, sampler_name, scheduler,
+                                    positive, negative, latent_image, denoise)
+    refined_latent = refined_latent[0]
+
+    # non-latent downscale - latent downscale cause bad quality
+    refined_image = vae.decode(refined_latent['samples'])
+
+    # downscale
+    refined_image = scale_tensor_and_to_pil(w, h, refined_image)
+
+    # don't convert to latent - latent break image
+    # preserving pil is much better
+    return refined_image
+
+
+def composite_to(dest_latent, crop_region, src_latent):
+    x1 = crop_region[0]
+    y1 = crop_region[1]
+
+    # composite to original latent
+    lc = nodes.LatentComposite()
+
+    # 현재 mask 를 고려한 composite 가 없음... 이거 처리 필요.
+
+    orig_image = lc.composite(dest_latent, src_latent, x1, y1)
+
+    return orig_image[0]
+
+
+def sam_predict(predictor, points, plabs, bbox, threshold):
+    point_coords = None if not points else np.array(points)
+    point_labels = None if not plabs else np.array(plabs)
+
+    box = np.array([bbox]) if bbox is not None else None
+
+    cur_masks, scores, _ = predictor.predict(point_coords=point_coords, point_labels=point_labels, box=box)
+
+    total_masks = []
+
+    selected = False
+    max_score = 0
+    for idx in range(len(scores)):
+        if scores[idx] > max_score:
+            max_score = scores[idx]
+            max_mask = cur_masks[idx]
+
+        if scores[idx] >= threshold:
+            selected = True
+            total_masks.append(cur_masks[idx])
+        else:
+            pass
+
+    if not selected:
+        total_masks.append(max_mask)
+
+    return total_masks
+
+
+def make_sam_mask(sam_model, segs, image, detection_hint, dilation,
+              threshold, bbox_expansion, mask_hint_threshold, mask_hint_use_negative):
+    predictor = SamPredictor(sam_model)
+    image = np.clip(255. * image.cpu().numpy().squeeze(), 0, 255).astype(np.uint8)
+
+    predictor.set_image(image, "RGB")
+
+    total_masks = []
+
+    use_small_negative = mask_hint_use_negative == "Small"
+
+    # seg_shape = segs[0]
+    segs = segs[1]
+    if detection_hint == "mask-points":
+        points = []
+        plabs = []
+
+        for i in range(len(segs)):
+            bbox = segs[i].bbox
+            center = center_of_bbox(segs[i].bbox)
+            points.append(center)
+
+            # small point is background, big point is foreground
+            if use_small_negative and bbox[2] - bbox[0] < 10:
+                plabs.append(0)
+            else:
+                plabs.append(1)
+
+        detected_masks = sam_predict(predictor, points, plabs, None, threshold)
+        total_masks += detected_masks
+
+    else:
+        for i in range(len(segs)):
+            bbox = segs[i].bbox
+            center = center_of_bbox(bbox)
+
+            x1 = max(bbox[0] - bbox_expansion, 0)
+            y1 = max(bbox[1] - bbox_expansion, 0)
+            x2 = min(bbox[2] + bbox_expansion, image.shape[1])
+            y2 = min(bbox[3] + bbox_expansion, image.shape[0])
+
+            dilated_bbox = [x1, y1, x2, y2]
+
+            points = []
+            plabs = []
+            if detection_hint == "center-1":
+                points.append(center)
+                plabs = [1]  # 1 = foreground point, 0 = background point
+
+            elif detection_hint == "horizontal-2":
+                gap = (x2 - x1) / 3
+                points.append((x1 + gap, center[1]))
+                points.append((x1 + gap * 2, center[1]))
+                plabs = [1, 1]
+
+            elif detection_hint == "vertical-2":
+                gap = (y2 - y1) / 3
+                points.append((center[0], y1 + gap))
+                points.append((center[0], y1 + gap * 2))
+                plabs = [1, 1]
+
+            elif detection_hint == "rect-4":
+                x_gap = (x2 - x1) / 3
+                y_gap = (y2 - y1) / 3
+                points.append((x1 + x_gap, center[1]))
+                points.append((x1 + x_gap * 2, center[1]))
+                points.append((center[0], y1 + y_gap))
+                points.append((center[0], y1 + y_gap * 2))
+                plabs = [1, 1, 1, 1]
+
+            elif detection_hint == "diamond-4":
+                x_gap = (x2 - x1) / 3
+                y_gap = (y2 - y1) / 3
+                points.append((x1 + x_gap, y1 + y_gap))
+                points.append((x1 + x_gap * 2, y1 + y_gap))
+                points.append((x1 + x_gap, y1 + y_gap * 2))
+                points.append((x1 + x_gap * 2, y1 + y_gap * 2))
+                plabs = [1, 1, 1, 1]
+
+            elif detection_hint == "mask-point-bbox":
+                center = center_of_bbox(segs[i].bbox)
+                points.append(center)
+                plabs = [1]
+
+            elif detection_hint == "mask-area":
+                points, plabs = gen_detection_hints_from_mask_area(segs[i].crop_region[0], segs[i].crop_region[1],
+                                                                   segs[i].cropped_mask,
+                                                                   mask_hint_threshold, use_small_negative)
+
+            if mask_hint_use_negative == "Outter":
+                npoints, nplabs = gen_negative_hints(image.shape[0], image.shape[1],
+                                                     segs[i].crop_region[0], segs[i].crop_region[1],
+                                                     segs[i].crop_region[2], segs[i].crop_region[3])
+
+                points += npoints
+                plabs += nplabs
+
+            detected_masks = sam_predict(predictor, points, plabs, dilated_bbox, threshold)
+            total_masks += detected_masks
+
+    # merge every collected masks
+    mask = combine_masks2(total_masks)
+
+    if mask is not None:
+        mask = mask.float()
+        mask = dilate_mask(mask.cpu().numpy(), dilation)
+        mask = torch.from_numpy(mask)
+    else:
+        mask = torch.zeros((8, 8), dtype=torch.float32, device="cpu")  # empty mask
+
+    return mask
+
+
+def segs_bitwise_and_mask(segs, mask):
+    if mask is None:
+        print("[SegsBitwiseAndMask] Cannot operate: MASK is empty.")
+        return ([], )
+
+    items = []
+
+    mask = (mask.cpu().numpy() * 255).astype(np.uint8)
+
+    for seg in segs[1]:
+        cropped_mask = (seg.cropped_mask * 255).astype(np.uint8)
+        crop_region = seg.crop_region
+
+        cropped_mask2 = mask[crop_region[1]:crop_region[3], crop_region[0]:crop_region[2]]
+
+        new_mask = np.bitwise_and(cropped_mask.astype(np.uint8), cropped_mask2)
+        new_mask = new_mask.astype(np.float32) / 255.0
+
+        item = SEG(seg.cropped_image, new_mask, seg.confidence, seg.crop_region, seg.bbox, seg.label)
+        items.append(item)
+
+    return segs[0], items
+
+
+class BBoxDetector:
+    bbox_model = None
+
+    def __init__(self, bbox_model):
+        self.bbox_model = bbox_model
+
+    def detect(self, image, threshold, dilation, crop_factor, drop_size=1):
+        drop_size = max(drop_size, 1)
+        mmdet_results = inference_bbox(self.bbox_model, image, threshold)
+        segmasks = create_segmasks(mmdet_results)
+
+        if dilation > 0:
+            segmasks = dilate_masks(segmasks, dilation)
+
+        items = []
+        h = image.shape[1]
+        w = image.shape[2]
+
+        for x in segmasks:
+            item_bbox = x[0]
+            item_mask = x[1]
+
+            y1, x1, y2, x2 = item_bbox
+
+            if x2 - x1 > drop_size and y2 - y1 > drop_size:  # minimum dimension must be (2,2) to avoid squeeze issue
+                crop_region = make_crop_region(w, h, item_bbox, crop_factor)
+                cropped_image = crop_image(image, crop_region)
+                cropped_mask = crop_ndarray2(item_mask, crop_region)
+                confidence = x[2]
+                # bbox_size = (item_bbox[2]-item_bbox[0],item_bbox[3]-item_bbox[1]) # (w,h)
+
+                item = SEG(cropped_image, cropped_mask, confidence, crop_region, item_bbox)
+
+                items.append(item)
+
+        shape = image.shape[1], image.shape[2]
+        return shape, items
+
+    def detect_combined(self, image, threshold, dilation):
+        mmdet_results = inference_bbox(self.bbox_model, image, threshold)
+        segmasks = create_segmasks(mmdet_results)
+        if dilation > 0:
+            segmasks = dilate_masks(segmasks, dilation)
+
+        return combine_masks(segmasks)
+
+    def setAux(self, x):
+        pass
+
+
+class ONNXDetector(BBoxDetector):
+    onnx_model = None
+
+    def __init__(self, onnx_model):
+        self.onnx_model = onnx_model
+
+    def detect(self, image, threshold, dilation, crop_factor, drop_size=1):
+        drop_size = max(drop_size, 1)
+        try:
+            import onnx
+
+            h = image.shape[1]
+            w = image.shape[2]
+
+            labels, scores, boxes = onnx.onnx_inference(image, self.onnx_model)
+
+            # collect feasible item
+            result = []
+
+            for i in range(len(labels)):
+                if scores[i] > threshold:
+                    item_bbox = boxes[i]
+                    x1, y1, x2, y2 = item_bbox
+
+                    if x2 - x1 > drop_size and y2 - y1 > drop_size:  # minimum dimension must be (2,2) to avoid squeeze issue
+                        crop_region = make_crop_region(w, h, item_bbox, crop_factor)
+                        crop_x1, crop_y1, crop_x2, crop_y2, = crop_region
+
+                        # prepare cropped mask
+                        cropped_mask = np.zeros((crop_y2-crop_y1,crop_x2-crop_x1))
+                        inner_mask = np.ones((y2-y1, x2-x1))
+                        cropped_mask[y1-crop_y1:y2-crop_y1, x1-crop_x1:x2-crop_x1] = inner_mask
+
+                        # make items
+                        item = SEG(None, cropped_mask, scores[i], crop_region, item_bbox)
+                        result.append(item)
+
+            shape = h, w
+            return shape, result
+        except Exception as e:
+            print(f"ONNXDetector: unable to execute.\n{e}")
+            pass
+
+    def detect_combined(self, image, threshold, dilation):
+        return segs_to_combined_mask(self.detect(image, threshold, dilation, 1))
+
+    def setAux(self, x):
+        pass
+
+
+class SegmDetector(BBoxDetector):
+    segm_model = None
+
+    def __init__(self, segm_model):
+        self.segm_model = segm_model
+
+    def detect(self, image, threshold, dilation, crop_factor, drop_size=1):
+        drop_size = max(drop_size, 1)
+        mmdet_results = inference_segm(image, self.segm_model, threshold)
+        segmasks = create_segmasks(mmdet_results)
+
+        if dilation > 0:
+            segmasks = dilate_masks(segmasks, dilation)
+
+        items = []
+        h = image.shape[1]
+        w = image.shape[2]
+        for x in segmasks:
+            item_bbox = x[0]
+            item_mask = x[1]
+
+            y1, x1, y2, x2 = item_bbox
+
+            if x2 - x1 > drop_size and y2 - y1 > drop_size:  # minimum dimension must be (2,2) to avoid squeeze issue
+                crop_region = make_crop_region(w, h, item_bbox, crop_factor)
+                cropped_image = crop_image(image, crop_region)
+                cropped_mask = crop_ndarray2(item_mask, crop_region)
+                confidence = x[2]
+
+                item = SEG(cropped_image, cropped_mask, confidence, crop_region, item_bbox)
+                items.append(item)
+
+        return image.shape, items
+
+    def detect_combined(self, image, threshold, dilation):
+        mmdet_results = inference_bbox(self.bbox_model, image, threshold)
+        segmasks = create_segmasks(mmdet_results)
+        if dilation > 0:
+            segmasks = dilate_masks(segmasks, dilation)
+
+        return combine_masks(segmasks)
+
+    def setAux(self, x):
+        pass
+
+
+def mask_to_segs(mask, combined, crop_factor, bbox_fill, drop_size=1):
+    drop_size = max(drop_size, 1)
+    if mask is None:
+        print("[mask_to_segs] Cannot operate: MASK is empty.")
+        return ([], )
+
+    mask = mask.cpu().numpy()
+
+    result = []
+    if combined == "True":
+        # Find the indices of the non-zero elements
+        indices = np.nonzero(mask)
+
+        if len(indices[0]) > 0 and len(indices[1]) > 0:
+            # Determine the bounding box of the non-zero elements
+            bbox = np.min(indices[1]), np.min(indices[0]), np.max(indices[1]), np.max(indices[0])
+            crop_region = make_crop_region(mask.shape[1], mask.shape[0], bbox, crop_factor)
+            x1, y1, x2, y2 = crop_region
+
+            if x2 - x1 > 0 and y2 - y1 > 0:
+                cropped_mask = mask[y1:y2, x1:x2]
+                item = SEG(None, cropped_mask, 1.0, crop_region, bbox, 'A')
+                result.append(item)
+
+    else:
+        # label the connected components
+        labelled_mask = label(mask)
+
+        # get the region properties for each connected component
+        regions = regionprops(labelled_mask)
+
+        # iterate over the regions and print their bounding boxes
+        for region in regions:
+            y1, x1, y2, x2 = region.bbox
+            bbox = x1, y1, x2, y2
+            crop_region = make_crop_region(mask.shape[1], mask.shape[0], bbox, crop_factor)
+
+            if x2 - x1 > drop_size and y2 - y1 > drop_size:  # minimum dimension must be (2,2) to avoid squeeze issue
+                cropped_mask = np.array(mask[crop_region[1]:crop_region[3], crop_region[0]:crop_region[2]])
+
+                if bbox_fill:
+                    cropped_mask.fill(1.0)
+
+                item = SEG(None, cropped_mask, 1.0, crop_region, bbox, 'A')
+
+                result.append(item)
+
+    if not result:
+        print(f"[mask_to_segs] Empty mask.")
+
+    print(f"# of Detected SEGS: {len(result)}")
+    # for r in result:
+    #     print(f"\tbbox={r.bbox}, crop={r.crop_region}, label={r.label}")
+
+    return mask.shape, result
+
+
+def segs_to_combined_mask(segs):
+    shape = segs[0]
+    h = shape[0]
+    w = shape[1]
+
+    mask = np.zeros((h, w), dtype=np.uint8)
+
+    for seg in segs[1]:
+        cropped_mask = seg.cropped_mask
+        crop_region = seg.crop_region
+        mask[crop_region[1]:crop_region[3], crop_region[0]:crop_region[2]] |= (cropped_mask * 255).astype(np.uint8)
+
+    return torch.from_numpy(mask.astype(np.float32) / 255.0)
+
+
+def vae_decode(vae, samples, use_tile, hook):
+    if use_tile:
+        pixels = nodes.VAEDecodeTiled().decode(vae, samples)[0]
+    else:
+        pixels = nodes.VAEDecode().decode(vae, samples)[0]
+
+    if hook is not None:
+        hook.post_decode(pixels)
+
+    return pixels
+
+
+def vae_encode(vae, pixels, use_tile, hook):
+    if use_tile:
+        samples = nodes.VAEEncodeTiled().encode(vae, pixels[0])[0]
+    else:
+        samples = nodes.VAEEncode().encode(vae, pixels[0])[0]
+
+    if hook is not None:
+        hook.post_encode(samples)
+
+    return samples
+
+
+class KSamplerWrapper:
+    params = None
+
+    def __init__(self, model, seed, steps, cfg, sampler_name, scheduler, positive, negative, denoise):
+        self.params = model, seed, steps, cfg, sampler_name, scheduler, positive, negative, denoise
+
+    def sample(self, latent_image, hook):
+        model, seed, steps, cfg, sampler_name, scheduler, positive, negative, denoise = self.params
+
+        if hook is not None:
+            model, seed, steps, cfg, sampler_name, scheduler, positive, negative, upscaled_latent, denoise = \
+                hook.pre_ksample(model, seed, steps, cfg, sampler_name, scheduler, positive, negative, latent_image, denoise)
+
+        return nodes.common_ksampler(model, seed, steps, cfg, sampler_name, scheduler, positive, negative, latent_image, denoise=denoise)[0]
+
+
+class PixelKSampleHook:
+    cur_step = 0
+    total_step = 0
+
+    def __init__(self):
+        pass
+        
+    def set_steps(self, info):
+        self.cur_step, self.total_step = info
+
+    def post_decode(self, pixels):
+        return pixels
+
+    def post_upscale(self, pixels):
+        return pixels
+
+    def post_encode(self, samples):
+        return samples
+
+    def pre_ksample(self, model, seed, steps, cfg, sampler_name, scheduler, positive, negative, upscaled_latent, denoise):
+         return model, seed, steps, cfg, sampler_name, scheduler, positive, negative, upscaled_latent, denoise
+
+
+class PixelKSampleHookCombine(PixelKSampleHook):
+    hook1 = None
+    hook2 = None
+    
+    def __init__(self, hook1, hook2):
+        super().__init__()
+        self.hook1 = hook1
+        self.hook2 = hook2
+
+    def set_steps(self, info):
+        self.hook1.set_steps(info)
+        self.hook2.set_steps(info)
+
+    def post_decode(self, pixels):
+        return self.hook2.post_decode(self.hook1.post_decode(pixels))
+
+    def post_upscale(self, pixels):
+        return self.hook2.post_upscale(self.hook1.post_upscale(pixels))
+
+    def post_encode(self, samples):
+        return self.hook2.post_encode(self.hook1.post_encode(samples))
+
+    def pre_ksample(self, model, seed, steps, cfg, sampler_name, scheduler, positive, negative, upscaled_latent,
+                    denoise):
+        model, seed, steps, cfg, sampler_name, scheduler, positive, negative, upscaled_latent, denoise = \
+            self.hook1.pre_ksample(model, seed, steps, cfg, sampler_name, scheduler, positive, negative, upscaled_latent, denoise)
+
+        return self.hook2.pre_ksample(model, seed, steps, cfg, sampler_name, scheduler, positive, negative, upscaled_latent, denoise)
+
+
+class SimpleCfgScheduleHook(PixelKSampleHook):
+    target_cfg = 0
+
+    def __init__(self, target_cfg):
+        super().__init__()
+        self.target_cfg = target_cfg
+    
+    def pre_ksample(self, model, seed, steps, cfg, sampler_name, scheduler, positive, negative, upscaled_latent, denoise):
+        progress = self.cur_step/self.total_step
+        gap = self.target_cfg - cfg
+        current_cfg = cfg + gap*progress
+        return model, seed, steps, current_cfg, sampler_name, scheduler, positive, negative, upscaled_latent, denoise
+
+
+class SimpleDenoiseScheduleHook(PixelKSampleHook):
+    target_denoise = 0
+
+    def __init__(self, target_denoise):
+        super().__init__()
+        self.target_denoise = target_denoise
+
+    def pre_ksample(self, model, seed, steps, cfg, sampler_name, scheduler, positive, negative, upscaled_latent, denoise):
+        progress = self.cur_step / self.total_step
+        gap = self.target_denoise - denoise
+        current_denoise = denoise + gap * progress
+        return model, seed, steps, cfg, sampler_name, scheduler, positive, negative, upscaled_latent, current_denoise
+
+
+def latent_upscale_on_pixel_space_shape(samples, scale_method, w, h, vae, use_tile=False, save_temp_prefix=None, hook=None):
+    pixels = vae_decode(vae, samples, use_tile, hook)
+
+    if save_temp_prefix is not None:
+        nodes.PreviewImage().save_images(pixels, filename_prefix=save_temp_prefix)
+
+    pixels = nodes.ImageScale().upscale(pixels, scale_method, int(w), int(h), False)
+
+    if hook is not None:
+        pixels = hook.post_upscale(pixels)
+
+    return vae_encode(vae, pixels, use_tile, hook)
+
+
+def latent_upscale_on_pixel_space(samples, scale_method, scale_factor, vae, use_tile=False, save_temp_prefix=None, hook=None):
+    pixels = vae_decode(vae, samples, use_tile, hook)
+
+    if save_temp_prefix is not None:
+        nodes.PreviewImage().save_images(pixels, filename_prefix=save_temp_prefix)
+
+    w = pixels.shape[2] * scale_factor
+    h = pixels.shape[1] * scale_factor
+    pixels = nodes.ImageScale().upscale(pixels, scale_method, int(w), int(h), False)
+
+    if hook is not None:
+        pixels = hook.post_upscale(pixels)
+
+    return vae_encode(vae, pixels, use_tile, hook)
+
+
+def latent_upscale_on_pixel_space_with_model_shape(samples, scale_method, upscale_model, new_w, new_h, vae, use_tile=False, save_temp_prefix=None, hook=None):
+    pixels = vae_decode(vae, samples, use_tile, hook)
+
+    if save_temp_prefix is not None:
+        nodes.PreviewImage().save_images(pixels, filename_prefix=save_temp_prefix)
+
+    w = pixels.shape[2]
+
+    # upscale by model upscaler
+    current_w = w
+    while current_w < new_w:
+        pixels = model_upscale.ImageUpscaleWithModel().upscale(upscale_model, pixels)[0]
+        current_w = pixels.shape[2]
+
+    # downscale to target scale
+    pixels = nodes.ImageScale().upscale(pixels, scale_method, int(new_w), int(new_h), False)
+
+    if hook is not None:
+        pixels = hook.post_upscale(pixels)
+
+    return vae_encode(vae, pixels, use_tile, hook)
+
+
+def latent_upscale_on_pixel_space_with_model(samples, scale_method, upscale_model, scale_factor, vae, use_tile=False, save_temp_prefix=None, hook=None):
+    pixels = vae_decode(vae, samples, use_tile, hook)
+
+    if save_temp_prefix is not None:
+        nodes.PreviewImage().save_images(pixels, filename_prefix=save_temp_prefix)
+
+    w = pixels.shape[2]
+    h = pixels.shape[1]
+
+    new_w = w * scale_factor
+    new_h = h * scale_factor
+
+    # upscale by model upscaler
+    current_w = w
+    while current_w < new_w:
+        pixels = model_upscale.ImageUpscaleWithModel().upscale(upscale_model, pixels)[0]
+        current_w = pixels.shape[2]
+
+    # downscale to target scale
+    pixels = nodes.ImageScale().upscale(pixels, scale_method, int(new_w), int(new_h), False)
+
+    if hook is not None:
+        pixels = hook.post_upscale(pixels)
+
+    return vae_encode(vae, pixels, use_tile, hook)
+
+
+class TwoSamplersForMaskUpscaler:
+    params = None
+    upscale_model = None
+    hook_base = None
+    hook_mask = None
+    hook_full = None
+    use_tiled_vae = False
+    is_tiled = False
+
+    def __init__(self, scale_method, sample_schedule, use_tiled_vae, base_sampler, mask_sampler, mask, vae,
+                 full_sampler_opt=None, upscale_model_opt=None, hook_base_opt=None, hook_mask_opt=None, hook_full_opt=None):
+        mask = mask.reshape((-1, 1, mask.shape[-2], mask.shape[-1]))
+
+        self.params = scale_method, sample_schedule, use_tiled_vae, base_sampler, mask_sampler, mask, vae
+        self.upscale_model = upscale_model_opt
+        self.full_sampler = full_sampler_opt
+        self.hook_base = hook_base_opt
+        self.hook_mask = hook_mask_opt
+        self.hook_full = hook_full_opt
+        self.use_tiled_vae = use_tiled_vae
+
+    def upscale(self, step_info, samples, upscale_factor, save_temp_prefix=None):
+        scale_method, sample_schedule, use_tiled_vae, base_sampler, mask_sampler, mask, vae = self.params
+
+        self.prepare_hook(step_info)
+
+        # upscale latent
+        if self.upscale_model is None:
+            upscaled_latent = latent_upscale_on_pixel_space(samples, scale_method, upscale_factor, vae,
+                                                            use_tile=self.use_tiled_vae,
+                                                            save_temp_prefix=save_temp_prefix, hook=self.hook_base)
+        else:
+            upscaled_latent = latent_upscale_on_pixel_space_with_model(samples, scale_method, self.upscale_model, upscale_factor, vae,
+                                                                       save_temp_prefix=save_temp_prefix, hook=self.hook_mask)
+
+        return self.do_samples(step_info, base_sampler, mask_sampler, sample_schedule, mask, upscaled_latent)
+
+    def prepare_hook(self, step_info):
+        if self.hook_base is not None:
+            self.hook_base.set_steps(step_info)
+        if self.hook_mask is not None:
+            self.hook_mask.set_steps(step_info)
+        if self.hook_full is not None:
+            self.hook_full.set_steps(step_info)
+
+    def upscale_shape(self, step_info, samples, w, h, save_temp_prefix=None):
+        scale_method, sample_schedule, use_tiled_vae, base_sampler, mask_sampler, mask, vae = self.params
+
+        self.prepare_hook(step_info)
+
+        # upscale latent
+        if self.upscale_model is None:
+            upscaled_latent = latent_upscale_on_pixel_space_shape(samples, scale_method, w, h, vae,
+                                                                  use_tile=self.use_tiled_vae,
+                                                                  save_temp_prefix=save_temp_prefix, hook=self.hook_base)
+        else:
+            upscaled_latent = latent_upscale_on_pixel_space_with_model_shape(samples, scale_method, self.upscale_model, w, h, vae,
+                                                                             save_temp_prefix=save_temp_prefix, hook=self.hook_mask)
+
+        return self.do_samples(step_info, base_sampler, mask_sampler, sample_schedule, mask, upscaled_latent)
+
+    def is_full_sample_time(self, step_info, sample_schedule):
+        cur_step, total_step = step_info
+
+        # make start from 1 instead of zero
+        cur_step += 1
+        total_step += 1
+
+        if sample_schedule == "none":
+            return False
+
+        elif sample_schedule == "interleave1":
+            return cur_step % 2 == 0
+
+        elif sample_schedule == "interleave2":
+            return cur_step % 3 == 0
+
+        elif sample_schedule == "interleave3":
+            return cur_step % 4 == 0
+
+        elif sample_schedule == "last1":
+            return cur_step == total_step
+
+        elif sample_schedule == "last2":
+            return cur_step >= total_step-1
+
+        elif sample_schedule == "interleave1+last1":
+            return cur_step % 2 == 0 or cur_step >= total_step-1
+
+        elif sample_schedule == "interleave2+last1":
+            return cur_step % 2 == 0 or cur_step >= total_step-1
+
+        elif sample_schedule == "interleave3+last1":
+            return cur_step % 2 == 0 or cur_step >= total_step-1
+
+    def do_samples(self, step_info, base_sampler, mask_sampler, sample_schedule, mask, upscaled_latent):
+        if self.is_full_sample_time(step_info, sample_schedule):
+            print(f"step_info={step_info} / full time")
+
+            upscaled_latent = base_sampler.sample(upscaled_latent, self.hook_base)
+            sampler = self.full_sampler if self.full_sampler is not None else base_sampler
+            return sampler.sample(upscaled_latent, self.hook_full)
+
+        else:
+            print(f"step_info={step_info} / non-full time")
+            # upscale mask
+            upscaled_mask = F.interpolate(mask, size=(upscaled_latent['samples'].shape[2], upscaled_latent['samples'].shape[3]),
+                                          mode='bilinear', align_corners=True)
+            upscaled_mask = upscaled_mask[:, :, :upscaled_latent['samples'].shape[2], :upscaled_latent['samples'].shape[3]]
+
+            # base sampler
+            upscaled_inv_mask = torch.where(upscaled_mask != 1.0, torch.tensor(1.0), torch.tensor(0.0))
+            upscaled_latent['noise_mask'] = upscaled_inv_mask
+            upscaled_latent = base_sampler.sample(upscaled_latent, self.hook_base)
+
+            # mask sampler
+            upscaled_latent['noise_mask'] = upscaled_mask
+            upscaled_latent = mask_sampler.sample(upscaled_latent, self.hook_mask)
+
+            # remove mask
+            del upscaled_latent['noise_mask']
+            return upscaled_latent
+
+
+class PixelKSampleUpscaler:
+    params = None
+    upscale_model = None
+    hook = None
+    use_tiled_vae = False
+    is_tiled = False
+
+    def __init__(self, scale_method, model, vae, seed, steps, cfg, sampler_name, scheduler, positive, negative, denoise,
+                 use_tiled_vae, upscale_model_opt=None, hook_opt=None):
+        self.params = scale_method, model, vae, seed, steps, cfg, sampler_name, scheduler, positive, negative, denoise
+        self.upscale_model = upscale_model_opt
+        self.hook = hook_opt
+        self.use_tiled_vae = use_tiled_vae
+
+    def upscale(self, step_info, samples, upscale_factor, save_temp_prefix=None):
+        scale_method, model, vae, seed, steps, cfg, sampler_name, scheduler, positive, negative, denoise = self.params
+
+        if self.hook is not None:
+            self.hook.set_steps(step_info)
+
+        if self.upscale_model is None:
+            upscaled_latent = latent_upscale_on_pixel_space(samples, scale_method, upscale_factor, vae,
+                                                            use_tile=self.use_tiled_vae,
+                                                            save_temp_prefix=save_temp_prefix, hook=self.hook)
+        else:
+            upscaled_latent = latent_upscale_on_pixel_space_with_model(samples, scale_method, self.upscale_model, upscale_factor, vae,
+                                                                       save_temp_prefix=save_temp_prefix, hook=self.hook)
+
+        if self.hook is not None:
+            model, seed, steps, cfg, sampler_name, scheduler, positive, negative, upscaled_latent, denoise = \
+                self.hook.pre_ksample(model, seed, steps, cfg, sampler_name, scheduler, positive, negative, upscaled_latent, denoise)
+
+        refined_latent = nodes.KSampler().sample(model, seed, steps, cfg, sampler_name, scheduler,
+                                                 positive, negative, upscaled_latent, denoise)
+        return refined_latent[0]
+
+    def upscale_shape(self, step_info, samples, w, h, save_temp_prefix=None):
+        scale_method, model, vae, seed, steps, cfg, sampler_name, scheduler, positive, negative, denoise = self.params
+
+        if self.hook is not None:
+            self.hook.set_steps(step_info)
+
+        if self.upscale_model is None:
+            upscaled_latent = latent_upscale_on_pixel_space_shape(samples, scale_method, w, h, vae,
+                                                                  use_tile=self.use_tiled_vae,
+                                                                  save_temp_prefix=save_temp_prefix, hook=self.hook)
+        else:
+            upscaled_latent = latent_upscale_on_pixel_space_with_model_shape(samples, scale_method, self.upscale_model, w, h, vae,
+                                                                             use_tile=self.use_tiled_vae,
+                                                                             save_temp_prefix=save_temp_prefix, hook=self.hook)
+
+        if self.hook is not None:
+            model, seed, steps, cfg, sampler_name, scheduler, positive, negative, upscaled_latent, denoise = \
+                self.hook.pre_ksample(model, seed, steps, cfg, sampler_name, scheduler, positive, negative, upscaled_latent, denoise)
+
+        refined_latent = nodes.KSampler().sample(model, seed, steps, cfg, sampler_name, scheduler,
+                                                 positive, negative, upscaled_latent, denoise)
+        return refined_latent[0]
+
+
+# REQUIREMENTS: BlenderNeko/ComfyUI_TiledKSampler
+try:
+    class TiledKSamplerWrapper:
+        params = None
+
+        def __init__(self, model, seed, steps, cfg, sampler_name, scheduler, positive, negative, denoise,
+                     tile_width, tile_height, tiling_strategy):
+            self.params = model, seed, steps, cfg, sampler_name, scheduler, positive, negative, denoise, tile_width, tile_height, tiling_strategy
+
+        def sample(self, latent_image, hook):
+            from custom_nodes.ComfyUI_TiledKSampler.nodes import TiledKSamplerAdvanced
+
+            model, seed, steps, cfg, sampler_name, scheduler, positive, negative, denoise, tile_width, tile_height, tiling_strategy = self.params
+
+            steps = int(steps/denoise)
+            start_at_step = int(steps*(1.0 - denoise))
+            end_at_step = steps
+
+            if hook is not None:
+                model, seed, steps, cfg, sampler_name, scheduler, positive, negative, upscaled_latent, denoise = \
+                    hook.pre_ksample(model, seed, steps, cfg, sampler_name, scheduler, positive, negative, latent_image, denoise)
+
+            return TiledKSamplerAdvanced().sample(model, "enable", seed, tile_width, tile_height, tiling_strategy, steps, cfg, sampler_name, scheduler,
+                                                  positive, negative, latent_image, start_at_step, end_at_step, "disable")[0]
+
+    class PixelTiledKSampleUpscaler:
+        params = None
+        upscale_model = None
+        tile_params = None
+        hook = None
+        is_tiled = True
+
+        def __init__(self, scale_method, model, vae, seed, steps, cfg, sampler_name, scheduler, positive, negative, denoise, 
+                     tile_width, tile_height, tiling_strategy,
+                     upscale_model_opt=None, hook_opt=None):
+            self.params = scale_method, model, vae, seed, steps, cfg, sampler_name, scheduler, positive, negative, denoise
+            self.tile_params = tile_width, tile_height, tiling_strategy
+            self.upscale_model = upscale_model_opt
+            self.hook = hook_opt
+
+        def emulate_non_advanced(self, latent):
+            from custom_nodes.ComfyUI_TiledKSampler.nodes import TiledKSamplerAdvanced
+
+            scale_method, model, vae, seed, steps, cfg, sampler_name, scheduler, positive, negative, denoise = self.params
+            tile_width, tile_height, tiling_strategy = self.tile_params
+
+            steps = int(steps/denoise)
+            start_at_step = int(steps*(1.0 - denoise))
+            end_at_step = steps
+
+            #print(f"steps={steps}, start_at_step={start_at_step}, end_at_step={end_at_step}")
+            return TiledKSamplerAdvanced().sample(model, "enable", seed, tile_width, tile_height, tiling_strategy, steps, cfg, sampler_name, scheduler,
+                                                  positive, negative, latent, start_at_step, end_at_step, "disable")[0]
+
+        def upscale(self, step_info, samples, upscale_factor, save_temp_prefix=None):
+            scale_method, model, vae, seed, steps, cfg, sampler_name, scheduler, positive, negative, denoise = self.params
+
+            if self.hook is not None:
+                self.hook.set_steps(step_info)
+
+            if self.upscale_model is None:
+                upscaled_latent = latent_upscale_on_pixel_space(samples, scale_method, upscale_factor, vae, True,
+                                                                save_temp_prefix=save_temp_prefix, hook=self.hook)
+            else:
+                upscaled_latent = latent_upscale_on_pixel_space_with_model(samples, scale_method, self.upscale_model, upscale_factor, vae, True,
+                                                                           save_temp_prefix=save_temp_prefix, hook=self.hook)
+
+            refined_latent = self.emulate_non_advanced(upscaled_latent)
+
+            return refined_latent
+
+        def upscale_shape(self, step_info, samples, w, h, save_temp_prefix=None):
+            scale_method, model, vae, seed, steps, cfg, sampler_name, scheduler, positive, negative, denoise = self.params
+
+            if self.hook is not None:
+                self.hook.set_steps(step_info)
+
+            if self.upscale_model is None:
+                upscaled_latent = latent_upscale_on_pixel_space_shape(samples, scale_method, w, h, vae, True,
+                                                                      save_temp_prefix=save_temp_prefix, hook=self.hook)
+            else:
+                upscaled_latent = latent_upscale_on_pixel_space_with_model_shape(samples, scale_method, self.upscale_model, w, h, vae, True,
+                                                                                 save_temp_prefix=save_temp_prefix, hook=self.hook)
+
+            refined_latent = self.emulate_non_advanced(upscaled_latent)
+
+            return refined_latent
+except:
+    pass
+
+
+# REQUIREMENTS: biegert/ComfyUI-CLIPSeg
+try:
+    class BBoxDetectorBasedOnCLIPSeg(BBoxDetector):
+        prompt = None
+        blur = None
+        threshold = None
+        dilation_factor = None
+        aux = None
+
+        def __init__(self, prompt, blur, threshold, dilation_factor):
+            self.prompt = prompt
+            self.blur = blur
+            self.threshold = threshold
+            self.dilation_factor = dilation_factor
+
+        def detect(self, image, bbox_threshold, bbox_dilation, bbox_crop_factor, drop_size=1):
+            mask = self.detect_combined(image, bbox_threshold, bbox_dilation)
+            segs = mask_to_segs(mask, False, bbox_crop_factor, True, drop_size)
+            return segs
+
+        def detect_combined(self, image, bbox_threshold, bbox_dilation):
+            from custom_nodes.clipseg import CLIPSeg
+
+            if self.threshold is None:
+                threshold = bbox_threshold
+            else:
+                threshold = self.threshold
+
+            if self.dilation_factor is None:
+                dilation_factor = bbox_dilation
+            else:
+                dilation_factor = self.dilation_factor
+
+            prompt = self.aux if self.prompt == '' and self.aux is not None else self.prompt
+
+            mask, _, _ = CLIPSeg().segment_image(image, prompt, self.blur, threshold, dilation_factor)
+            mask = to_binary_mask(mask)
+            return mask
+
+        def setAux(self, x):
+            self.aux = x
+except:
+    pass

ComfyUI-Impact-Pack/impact_pack.py

@@ -0,0 +1,1321 @@
+import os
+import folder_paths
+import comfy.samplers
+import comfy.sd
+import warnings
+from segment_anything import sam_model_registry
+
+from impact_utils import *
+import impact_core as core
+from impact_core import SEG, NO_BBOX_DETECTOR, NO_SEGM_DETECTOR
+from impact_config import MAX_RESOLUTION
+
+warnings.filterwarnings('ignore', category=UserWarning, message='TypedStorage is deprecated')
+
+model_path = folder_paths.models_dir
+
+
+# Nodes
+# folder_paths.supported_pt_extensions
+folder_paths.folder_names_and_paths["mmdets_bbox"] = ([os.path.join(model_path, "mmdets", "bbox")], folder_paths.supported_pt_extensions)
+folder_paths.folder_names_and_paths["mmdets_segm"] = ([os.path.join(model_path, "mmdets", "segm")], folder_paths.supported_pt_extensions)
+folder_paths.folder_names_and_paths["mmdets"] = ([os.path.join(model_path, "mmdets")], folder_paths.supported_pt_extensions)
+folder_paths.folder_names_and_paths["sams"] = ([os.path.join(model_path, "sams")], folder_paths.supported_pt_extensions)
+folder_paths.folder_names_and_paths["onnx"] = ([os.path.join(model_path, "onnx")], {'.onnx'})
+
+
+class ONNXDetectorProvider:
+    @classmethod
+    def INPUT_TYPES(s):
+        return {"required": {"model_name": (folder_paths.get_filename_list("onnx"), )}}
+
+    RETURN_TYPES = ("ONNX_DETECTOR", )
+    FUNCTION = "load_onnx"
+
+    CATEGORY = "ImpactPack"
+
+    def load_onnx(self, model_name):
+        model = folder_paths.get_full_path("onnx", model_name)
+        return (core.ONNXDetector(model), )
+
+
+class MMDetDetectorProvider:
+    @classmethod
+    def INPUT_TYPES(s):
+        bboxs = ["bbox/"+x for x in folder_paths.get_filename_list("mmdets_bbox")]
+        segms = ["segm/"+x for x in folder_paths.get_filename_list("mmdets_segm")]
+        return {"required": {"model_name": (bboxs + segms, )}}
+    RETURN_TYPES = ("BBOX_DETECTOR", "SEGM_DETECTOR")
+    FUNCTION = "load_mmdet"
+
+    CATEGORY = "ImpactPack"
+
+    def load_mmdet(self, model_name):
+        mmdet_path = folder_paths.get_full_path("mmdets", model_name)
+        model = core.load_mmdet(mmdet_path)
+
+        if model_name.startswith("bbox"):
+            return core.BBoxDetector(model), NO_SEGM_DETECTOR()
+        else:
+            return NO_BBOX_DETECTOR(), model
+
+
+class CLIPSegDetectorProvider:
+    @classmethod
+    def INPUT_TYPES(s):
+        return {"required": {
+                        "text": ("STRING", {"multiline": False}),
+                        "blur": ("FLOAT", {"min": 0, "max": 15, "step": 0.1, "default": 7}),
+                        "threshold": ("FLOAT", {"min": 0, "max": 1, "step": 0.05, "default": 0.4}),
+                        "dilation_factor": ("INT", {"min": 0, "max": 10, "step": 1, "default": 4}),
+                    }
+                }
+
+    RETURN_TYPES = ("BBOX_DETECTOR", )
+    FUNCTION = "doit"
+
+    CATEGORY = "ImpactPack/Util"
+
+    def doit(self, text, blur, threshold, dilation_factor):
+        try:
+            import custom_nodes.clipseg
+            return (core.BBoxDetectorBasedOnCLIPSeg(text, blur, threshold, dilation_factor), )
+        except Exception as e:
+            print("[ERROR] CLIPSegToBboxDetector: CLIPSeg custom node isn't installed. You must install biegert/ComfyUI-CLIPSeg extension to use this node.")
+            print(f"\t{e}")
+            pass
+
+
+class SAMLoader:
+    @classmethod
+    def INPUT_TYPES(s):
+        return {"required": {"model_name": (folder_paths.get_filename_list("sams"), )}}
+
+    RETURN_TYPES = ("SAM_MODEL", )
+    FUNCTION = "load_model"
+
+    CATEGORY = "ImpactPack"
+
+    def load_model(self, model_name):
+        modelname = folder_paths.get_full_path("sams", model_name)
+
+        if 'vit_h' in model_name:
+            model_kind = 'vit_h'
+        elif 'vit_l' in model_name:
+            model_kind = 'vit_l'
+        else:
+            model_kind = 'vit_b'
+
+        sam = sam_model_registry[model_kind](checkpoint=modelname)
+        print(f"Loads SAM model: {modelname}")
+        return (sam, )
+
+
+class ONNXDetectorForEach:
+    @classmethod
+    def INPUT_TYPES(s):
+        return {"required": {
+                    "onnx_detector": ("ONNX_DETECTOR",),
+                    "image": ("IMAGE",),
+                    "threshold": ("FLOAT", {"default": 0.8, "min": 0.0, "max": 1.0, "step": 0.01}),
+                    "dilation": ("INT", {"default": 10, "min": 0, "max": 255, "step": 1}),
+                    "crop_factor": ("FLOAT", {"default": 1.0, "min": 0.5, "max": 10, "step": 0.1}),
+                    "drop_size": ("INT", {"min": 1, "max": MAX_RESOLUTION, "step": 1, "default": 10}),
+                    }
+                }
+
+    RETURN_TYPES = ("SEGS", )
+    FUNCTION = "doit"
+
+    CATEGORY = "ImpactPack/Detector"
+
+    OUTPUT_NODE = True
+
+    def doit(self, onnx_detector, image, threshold, dilation, crop_factor, drop_size):
+        segs = onnx_detector.detect(image, threshold, dilation, crop_factor, drop_size)
+        return (segs, )
+
+
+class DetailerForEach:
+    @classmethod
+    def INPUT_TYPES(s):
+        return {"required": {
+                     "image": ("IMAGE", ),
+                     "segs": ("SEGS", ),
+                     "model": ("MODEL",),
+                     "vae": ("VAE",),
+                     "guide_size": ("FLOAT", {"default": 256, "min": 64, "max": nodes.MAX_RESOLUTION, "step": 8}),
+                     "guide_size_for": (["bbox", "crop_region"],),
+                     "seed": ("INT", {"default": 0, "min": 0, "max": 0xffffffffffffffff}),
+                     "steps": ("INT", {"default": 20, "min": 1, "max": 10000}),
+                     "cfg": ("FLOAT", {"default": 8.0, "min": 0.0, "max": 100.0}),
+                     "sampler_name": (comfy.samplers.KSampler.SAMPLERS,),
+                     "scheduler": (comfy.samplers.KSampler.SCHEDULERS,),
+                     "positive": ("CONDITIONING",),
+                     "negative": ("CONDITIONING",),
+                     "denoise": ("FLOAT", {"default": 0.5, "min": 0.0001, "max": 1.0, "step": 0.01}),
+                     "feather": ("INT", {"default": 5, "min": 0, "max": 100, "step": 1}),
+                     "noise_mask": (["enabled", "disabled"], ),
+                     "force_inpaint": (["disabled", "enabled"], ),
+                     },
+                }
+
+    RETURN_TYPES = ("IMAGE", )
+    FUNCTION = "doit"
+
+    CATEGORY = "ImpactPack/Detailer"
+
+    @staticmethod
+    def do_detail(image, segs, model, vae, guide_size, guide_size_for, seed, steps, cfg, sampler_name, scheduler,
+                  positive, negative, denoise, feather, noise_mask, force_inpaint):
+
+        image_pil = tensor2pil(image).convert('RGBA')
+
+        for seg in segs[1]:
+            cropped_image = seg.cropped_image if seg.cropped_image is not None \
+                                              else crop_ndarray4(image.numpy(), seg.crop_region)
+
+            mask_pil = feather_mask(seg.cropped_mask, feather)
+
+            if noise_mask == "enabled":
+                cropped_mask = seg.cropped_mask
+            else:
+                cropped_mask = None
+
+            enhanced_pil = core.enhance_detail(cropped_image, model, vae, guide_size, guide_size_for, seg.bbox,
+                                          seed, steps, cfg, sampler_name, scheduler,
+                                          positive, negative, denoise, cropped_mask, force_inpaint == "enabled")
+
+            if not (enhanced_pil is None):
+                # don't latent composite-> converting to latent caused poor quality
+                # use image paste
+                image_pil.paste(enhanced_pil, (seg.crop_region[0], seg.crop_region[1]), mask_pil)
+
+        image_tensor = pil2tensor(image_pil.convert('RGB'))
+
+        if len(segs[1]) > 0:
+            enhanced_tensor = pil2tensor(enhanced_pil) if enhanced_pil is not None else None
+            return image_tensor, torch.from_numpy(cropped_image), enhanced_tensor,
+        else:
+            return image_tensor, None, None,
+
+    def doit(self, image, segs, model, vae, guide_size, guide_size_for, seed, steps, cfg, sampler_name, scheduler,
+             positive, negative, denoise, feather, noise_mask, force_inpaint):
+
+        enhanced_img, cropped, cropped_enhanced = \
+            DetailerForEach.do_detail(image, segs, model, vae, guide_size, guide_size_for, seed, steps, cfg,
+                                      sampler_name, scheduler, positive, negative, denoise, feather, noise_mask,
+                                      force_inpaint)
+
+        return (enhanced_img, )
+
+
+class DetailerForEachPipe:
+    @classmethod
+    def INPUT_TYPES(s):
+        return {"required": {
+                     "image": ("IMAGE", ),
+                     "segs": ("SEGS", ),
+                     "guide_size": ("FLOAT", {"default": 256, "min": 64, "max": nodes.MAX_RESOLUTION, "step": 8}),
+                     "guide_size_for": (["bbox", "crop_region"],),
+                     "seed": ("INT", {"default": 0, "min": 0, "max": 0xffffffffffffffff}),
+                     "steps": ("INT", {"default": 20, "min": 1, "max": 10000}),
+                     "cfg": ("FLOAT", {"default": 8.0, "min": 0.0, "max": 100.0}),
+                     "sampler_name": (comfy.samplers.KSampler.SAMPLERS,),
+                     "scheduler": (comfy.samplers.KSampler.SCHEDULERS,),
+                     "denoise": ("FLOAT", {"default": 0.5, "min": 0.0001, "max": 1.0, "step": 0.01}),
+                     "feather": ("INT", {"default": 5, "min": 0, "max": 100, "step": 1}),
+                     "noise_mask": (["enabled", "disabled"], ),
+                     "force_inpaint": (["disabled", "enabled"], ),
+                     "basic_pipe": ("BASIC_PIPE", )
+                     },
+                }
+
+    RETURN_TYPES = ("IMAGE", )
+    FUNCTION = "doit"
+
+    CATEGORY = "ImpactPack/Detailer"
+
+    def doit(self, image, segs, guide_size, guide_size_for, seed, steps, cfg, sampler_name, scheduler,
+             denoise, feather, noise_mask, force_inpaint, basic_pipe):
+
+        model, _, vae, positive, negative = basic_pipe
+        enhanced_img, cropped, cropped_enhanced = \
+            DetailerForEach.do_detail(image, segs, model, vae, guide_size, guide_size_for, seed, steps, cfg,
+                                      sampler_name, scheduler, positive, negative, denoise, feather, noise_mask,
+                                      force_inpaint)
+
+        return (enhanced_img, )
+
+
+class KSamplerProvider:
+    @classmethod
+    def INPUT_TYPES(s):
+        return {"required": {
+                                "seed": ("INT", {"default": 0, "min": 0, "max": 0xffffffffffffffff}),
+                                "steps": ("INT", {"default": 20, "min": 1, "max": 10000}),
+                                "cfg": ("FLOAT", {"default": 8.0, "min": 0.0, "max": 100.0}),
+                                "sampler_name": (comfy.samplers.KSampler.SAMPLERS, ),
+                                "scheduler": (comfy.samplers.KSampler.SCHEDULERS, ),
+                                "denoise": ("FLOAT", {"default": 1.0, "min": 0.0, "max": 1.0, "step": 0.01}),
+                                "basic_pipe": ("BASIC_PIPE", )
+                             },
+                }
+
+    RETURN_TYPES = ("KSAMPLER",)
+    FUNCTION = "doit"
+
+    CATEGORY = "ImpactPack/Sampler"
+
+    def doit(self, seed, steps, cfg, sampler_name, scheduler, denoise, basic_pipe):
+        model, _, _, positive, negative = basic_pipe
+        sampler = core.KSamplerWrapper(model, seed, steps, cfg, sampler_name, scheduler, positive, negative, denoise)
+        return (sampler, )
+
+
+class TwoSamplersForMask:
+    @classmethod
+    def INPUT_TYPES(s):
+        return {"required": {
+                     "latent_image": ("LATENT", ),
+                     "base_sampler": ("KSAMPLER", ),
+                     "mask_sampler": ("KSAMPLER", ),
+                     "mask": ("MASK", )
+                     },
+                }
+
+    RETURN_TYPES = ("LATENT", )
+    FUNCTION = "doit"
+
+    CATEGORY = "ImpactPack/Sampler"
+
+    def doit(self, latent_image, base_sampler, mask_sampler, mask):
+        inv_mask = torch.where(mask != 1.0, torch.tensor(1.0), torch.tensor(0.0))
+
+        latent_image['noise_mask'] = inv_mask
+        new_latent_image = base_sampler.sample(latent_image)[0]
+
+        new_latent_image['noise_mask'] = mask
+        new_latent_image = mask_sampler.sample(new_latent_image)[0]
+
+        del new_latent_image['noise_mask']
+
+        return (new_latent_image, )
+
+
+class FaceDetailer:
+    @classmethod
+    def INPUT_TYPES(s):
+        return {"required": {
+                     "image": ("IMAGE", ),
+                     "model": ("MODEL",),
+                     "vae": ("VAE",),
+                     "guide_size": ("FLOAT", {"default": 256, "min": 64, "max": nodes.MAX_RESOLUTION, "step": 8}),
+                     "guide_size_for": (["bbox", "crop_region"],),
+                     "seed": ("INT", {"default": 0, "min": 0, "max": 0xffffffffffffffff}),
+                     "steps": ("INT", {"default": 20, "min": 1, "max": 10000}),
+                     "cfg": ("FLOAT", {"default": 8.0, "min": 0.0, "max": 100.0}),
+                     "sampler_name": (comfy.samplers.KSampler.SAMPLERS,),
+                     "scheduler": (comfy.samplers.KSampler.SCHEDULERS,),
+                     "positive": ("CONDITIONING",),
+                     "negative": ("CONDITIONING",),
+                     "denoise": ("FLOAT", {"default": 0.5, "min": 0.0001, "max": 1.0, "step": 0.01}),
+                     "feather": ("INT", {"default": 5, "min": 0, "max": 100, "step": 1}),
+                     "noise_mask": (["enabled", "disabled"], ),
+                     "force_inpaint": (["disabled", "enabled"], ),
+
+                     "bbox_threshold": ("FLOAT", {"default": 0.5, "min": 0.0, "max": 1.0, "step": 0.01}),
+                     "bbox_dilation": ("INT", {"default": 10, "min": 0, "max": 255, "step": 1}),
+                     "bbox_crop_factor": ("FLOAT", {"default": 3.0, "min": 1.0, "max": 10, "step": 0.1}),
+
+                     "sam_detection_hint": (["center-1", "horizontal-2", "vertical-2", "rect-4", "diamond-4", "mask-area", "mask-points", "mask-point-bbox", "none"],),
+                     "sam_dilation": ("INT", {"default": 0, "min": 0, "max": 255, "step": 1}),
+                     "sam_threshold": ("FLOAT", {"default": 0.93, "min": 0.0, "max": 1.0, "step": 0.01}),
+                     "sam_bbox_expansion": ("INT", {"default": 0, "min": 0, "max": 1000, "step": 1}),
+                     "sam_mask_hint_threshold": ("FLOAT", {"default": 0.7, "min": 0.0, "max": 1.0, "step": 0.01}),
+                     "sam_mask_hint_use_negative": (["False", "Small", "Outter"],),
+
+                     "drop_size": ("INT", {"min": 1, "max": MAX_RESOLUTION, "step": 1, "default": 10}),
+
+                     "bbox_detector": ("BBOX_DETECTOR", ),
+                     },
+                "optional": {
+                    "sam_model_opt": ("SAM_MODEL", ),
+                }}
+
+    RETURN_TYPES = ("IMAGE", "IMAGE", "MASK", "DETAILER_PIPE", )
+    RETURN_NAMES = ("image", "cropped_refined", "mask", "detailer_pipe")
+    FUNCTION = "doit"
+
+    CATEGORY = "ImpactPack/Simple"
+
+    @staticmethod
+    def enhance_face(image, model, vae, guide_size, guide_size_for, seed, steps, cfg, sampler_name, scheduler,
+                     positive, negative, denoise, feather, noise_mask, force_inpaint,
+                     bbox_threshold, bbox_dilation, bbox_crop_factor,
+                     sam_detection_hint, sam_dilation, sam_threshold, sam_bbox_expansion, sam_mask_hint_threshold,
+                     sam_mask_hint_use_negative, drop_size,
+                     bbox_detector, sam_model_opt=None):
+        # make default prompt as 'face' if empty prompt for CLIPSeg
+        bbox_detector.setAux('face')
+        segs = bbox_detector.detect(image, bbox_threshold, bbox_dilation, bbox_crop_factor, drop_size)
+        bbox_detector.setAux(None)
+
+        # bbox + sam combination
+        if sam_model_opt is not None:
+            sam_mask = core.make_sam_mask(sam_model_opt, segs, image, sam_detection_hint, sam_dilation,
+                                     sam_threshold, sam_bbox_expansion, sam_mask_hint_threshold,
+                                     sam_mask_hint_use_negative, )
+            segs = core.segs_bitwise_and_mask(segs, sam_mask)
+
+        enhanced_img, _, cropped_enhanced = \
+            DetailerForEach.do_detail(image, segs, model, vae, guide_size, guide_size_for, seed, steps, cfg,
+                                      sampler_name, scheduler, positive, negative, denoise, feather, noise_mask,
+                                      force_inpaint)
+
+        # Mask Generator
+        mask = core.segs_to_combined_mask(segs)
+
+        return enhanced_img, cropped_enhanced, mask
+
+    def doit(self, image, model, vae, guide_size, guide_size_for, seed, steps, cfg, sampler_name, scheduler,
+             positive, negative, denoise, feather, noise_mask, force_inpaint,
+             bbox_threshold, bbox_dilation, bbox_crop_factor,
+             sam_detection_hint, sam_dilation, sam_threshold, sam_bbox_expansion, sam_mask_hint_threshold,
+             sam_mask_hint_use_negative, drop_size, bbox_detector, sam_model_opt=None):
+
+        enhanced_img, cropped_enhanced, mask = FaceDetailer.enhance_face(
+            image, model, vae, guide_size, guide_size_for, seed, steps, cfg, sampler_name, scheduler,
+            positive, negative, denoise, feather, noise_mask, force_inpaint,
+            bbox_threshold, bbox_dilation, bbox_crop_factor,
+            sam_detection_hint, sam_dilation, sam_threshold, sam_bbox_expansion, sam_mask_hint_threshold,
+            sam_mask_hint_use_negative, drop_size, bbox_detector, sam_model_opt)
+
+        pipe = (model, vae, positive, negative, bbox_detector, sam_model_opt)
+        return enhanced_img, cropped_enhanced, mask, pipe
+
+
+class LatentPixelScale:
+    upscale_methods = ["nearest-exact", "bilinear", "area"]
+
+    @classmethod
+    def INPUT_TYPES(s):
+        return {"required": {
+                     "samples": ("LATENT", ),
+                     "scale_method": (s.upscale_methods,),
+                     "scale_factor": ("FLOAT", {"default": 1.5, "min": 0.1, "max": 10000, "step": 0.1}),
+                     "vae": ("VAE", ),
+                    },
+                "optional": {
+                        "upscale_model_opt": ("UPSCALE_MODEL", ),
+                    }
+                }
+
+    RETURN_TYPES = ("LATENT",)
+    FUNCTION = "doit"
+
+    CATEGORY = "ImpactPack/Upscale"
+
+    def doit(self, samples, scale_method, scale_factor, vae, upscale_model_opt=None):
+        if upscale_model_opt is None:
+            latent = core.latent_upscale_on_pixel_space(samples, scale_method, scale_factor, vae)
+        else:
+            latent = core.latent_upscale_on_pixel_space_with_model(samples, scale_method, upscale_model_opt, scale_factor, vae)
+        return (latent,)
+
+
+class CfgScheduleHookProvider:
+    schedules = ["simple"]
+
+    @classmethod
+    def INPUT_TYPES(s):
+        return {"required": {
+                     "schedule_for_iteration": (s.schedules,),
+                     "target_cfg": ("FLOAT", {"default": 3.0, "min": 0.0, "max": 100.0}),
+                    },
+                }
+
+    RETURN_TYPES = ("PK_HOOK",)
+    FUNCTION = "doit"
+
+    CATEGORY = "ImpactPack/Upscale"
+
+    def doit(self, schedule_for_iteration, target_cfg):
+        hook = None
+        if schedule_for_iteration == "simple":
+            hook = core.SimpleCfgScheduleHook(target_cfg)
+
+        return (hook, )
+
+
+class DenoiseScheduleHookProvider:
+    schedules = ["simple"]
+
+    @classmethod
+    def INPUT_TYPES(s):
+        return {"required": {
+                     "schedule_for_iteration": (s.schedules,),
+                     "target_denoise": ("FLOAT", {"default": 0.2, "min": 0.0, "max": 100.0}),
+                    },
+                }
+
+    RETURN_TYPES = ("PK_HOOK",)
+    FUNCTION = "doit"
+
+    CATEGORY = "ImpactPack/Upscale"
+
+    def doit(self, schedule_for_iteration, target_denoise):
+        hook = None
+        if schedule_for_iteration == "simple":
+            hook = core.SimpleDenoiseScheduleHook(target_denoise)
+
+        return (hook, )
+
+
+class PixelKSampleHookCombine:
+    @classmethod
+    def INPUT_TYPES(s):
+        return {"required": {
+                     "hook1": ("PK_HOOK",),
+                     "hook2": ("PK_HOOK",),
+                    },
+                }
+
+    RETURN_TYPES = ("PK_HOOK",)
+    FUNCTION = "doit"
+
+    CATEGORY = "ImpactPack/Upscale"
+
+    def doit(self, hook1, hook2):
+        hook = core.PixelKSampleHookCombine(hook1, hook2)
+        return (hook, )
+
+
+class TiledKSamplerProvider:
+    @classmethod
+    def INPUT_TYPES(s):
+        return {"required": {
+                    "seed": ("INT", {"default": 0, "min": 0, "max": 0xffffffffffffffff}),
+                    "steps": ("INT", {"default": 20, "min": 1, "max": 10000}),
+                    "cfg": ("FLOAT", {"default": 8.0, "min": 0.0, "max": 100.0}),
+                    "sampler_name": (comfy.samplers.KSampler.SAMPLERS, ),
+                    "scheduler": (comfy.samplers.KSampler.SCHEDULERS, ),
+                    "denoise": ("FLOAT", {"default": 1.0, "min": 0.0, "max": 1.0, "step": 0.01}),
+                    "tile_width": ("INT", {"default": 512, "min": 256, "max": MAX_RESOLUTION, "step": 64}),
+                    "tile_height": ("INT", {"default": 512, "min": 256, "max": MAX_RESOLUTION, "step": 64}),
+                    "tiling_strategy": (["random", "padded", 'simple'], ),
+                    "basic_pipe": ("BASIC_PIPE", )
+                    }}
+
+    RETURN_TYPES = ("KSAMPLER",)
+    FUNCTION = "doit"
+
+    CATEGORY = "ImpactPack/Sampler"
+
+    def doit(self, seed, steps, cfg, sampler_name, scheduler, denoise,
+             tile_width, tile_height, tiling_strategy, basic_pipe):
+        model, _, _, positive, negative = basic_pipe
+        sampler = core.TiledKSamplerWrapper(model, seed, steps, cfg, sampler_name, scheduler, positive, negative, denoise,
+                                            tile_width, tile_height, tiling_strategy)
+        return (sampler, )
+
+
+class PixelTiledKSampleUpscalerProvider:
+    upscale_methods = ["nearest-exact", "bilinear", "area"]
+
+    @classmethod
+    def INPUT_TYPES(s):
+        return {"required": {
+                    "scale_method": (s.upscale_methods,),
+                    "model": ("MODEL",),
+                    "vae": ("VAE",),
+                    "seed": ("INT", {"default": 0, "min": 0, "max": 0xffffffffffffffff}),
+                    "steps": ("INT", {"default": 20, "min": 1, "max": 10000}),
+                    "cfg": ("FLOAT", {"default": 8.0, "min": 0.0, "max": 100.0}),
+                    "sampler_name": (comfy.samplers.KSampler.SAMPLERS, ),
+                    "scheduler": (comfy.samplers.KSampler.SCHEDULERS, ),
+                    "positive": ("CONDITIONING", ),
+                    "negative": ("CONDITIONING", ),
+                    "denoise": ("FLOAT", {"default": 1.0, "min": 0.0, "max": 1.0, "step": 0.01}),
+                    "tile_width": ("INT", {"default": 512, "min": 256, "max": MAX_RESOLUTION, "step": 64}),
+                    "tile_height": ("INT", {"default": 512, "min": 256, "max": MAX_RESOLUTION, "step": 64}),
+                    "tiling_strategy": (["random", "padded", 'simple'], ),
+                    },
+                "optional": {
+                        "upscale_model_opt": ("UPSCALE_MODEL", ),
+                        "pk_hook_opt": ("PK_HOOK", ),
+                    }
+                }
+
+    RETURN_TYPES = ("UPSCALER",)
+    FUNCTION = "doit"
+
+    CATEGORY = "ImpactPack/Upscale"
+
+    def doit(self, scale_method, model, vae, seed, steps, cfg, sampler_name, scheduler, positive, negative, denoise, tile_width, tile_height, tiling_strategy, upscale_model_opt=None, pk_hook_opt=None):
+        try:
+            import custom_nodes.ComfyUI_TiledKSampler.nodes
+            upscaler = core.PixelTiledKSampleUpscaler(scale_method, model, vae, seed, steps, cfg, sampler_name, scheduler, positive, negative, denoise, tile_width, tile_height, tiling_strategy, upscale_model_opt, pk_hook_opt)
+            return (upscaler, )
+        except Exception as e:
+            print("[ERROR] PixelTiledKSampleUpscalerProvider: ComfyUI_TiledKSampler custom node isn't installed. You must install BlenderNeko/ComfyUI_TiledKSampler extension to use this node.")
+            print(f"\t{e}")
+            pass
+
+
+class PixelTiledKSampleUpscalerProviderPipe:
+    upscale_methods = ["nearest-exact", "bilinear", "area"]
+
+    @classmethod
+    def INPUT_TYPES(s):
+        return {"required": {
+                    "scale_method": (s.upscale_methods,),
+                    "seed": ("INT", {"default": 0, "min": 0, "max": 0xffffffffffffffff}),
+                    "steps": ("INT", {"default": 20, "min": 1, "max": 10000}),
+                    "cfg": ("FLOAT", {"default": 8.0, "min": 0.0, "max": 100.0}),
+                    "sampler_name": (comfy.samplers.KSampler.SAMPLERS, ),
+                    "scheduler": (comfy.samplers.KSampler.SCHEDULERS, ),
+                    "denoise": ("FLOAT", {"default": 1.0, "min": 0.0, "max": 1.0, "step": 0.01}),
+                    "tile_width": ("INT", {"default": 512, "min": 256, "max": MAX_RESOLUTION, "step": 64}),
+                    "tile_height": ("INT", {"default": 512, "min": 256, "max": MAX_RESOLUTION, "step": 64}),
+                    "tiling_strategy": (["random", "padded", 'simple'], ),
+                    "basic_pipe": ("BASIC_PIPE",)
+                    },
+                "optional": {
+                        "upscale_model_opt": ("UPSCALE_MODEL", ),
+                        "pk_hook_opt": ("PK_HOOK", ),
+                    }
+                }
+
+    RETURN_TYPES = ("UPSCALER",)
+    FUNCTION = "doit"
+
+    CATEGORY = "ImpactPack/Upscale"
+
+    def doit(self, scale_method, seed, steps, cfg, sampler_name, scheduler, denoise, tile_width, tile_height, tiling_strategy, basic_pipe, upscale_model_opt=None, pk_hook_opt=None):
+        try:
+            import custom_nodes.ComfyUI_TiledKSampler.nodes
+            model, _, vae, positive, negative = basic_pipe
+            upscaler = core.PixelTiledKSampleUpscaler(scale_method, model, vae, seed, steps, cfg, sampler_name, scheduler, positive, negative, denoise, tile_width, tile_height, tiling_strategy, upscale_model_opt, pk_hook_opt)
+            return (upscaler, )
+        except Exception as e:
+            print("[ERROR] PixelTiledKSampleUpscalerProviderPipe: ComfyUI_TiledKSampler custom node isn't installed. You must install BlenderNeko/ComfyUI_TiledKSampler extension to use this node.")
+            print(f"\t{e}")
+            pass
+
+
+class PixelKSampleUpscalerProvider:
+    upscale_methods = ["nearest-exact", "bilinear", "area"]
+
+    @classmethod
+    def INPUT_TYPES(s):
+        return {"required": {
+                    "scale_method": (s.upscale_methods,),
+                    "model": ("MODEL",),
+                    "vae": ("VAE",),
+                    "seed": ("INT", {"default": 0, "min": 0, "max": 0xffffffffffffffff}),
+                    "steps": ("INT", {"default": 20, "min": 1, "max": 10000}),
+                    "cfg": ("FLOAT", {"default": 8.0, "min": 0.0, "max": 100.0}),
+                    "sampler_name": (comfy.samplers.KSampler.SAMPLERS, ),
+                    "scheduler": (comfy.samplers.KSampler.SCHEDULERS, ),
+                    "positive": ("CONDITIONING", ),
+                    "negative": ("CONDITIONING", ),
+                    "denoise": ("FLOAT", {"default": 1.0, "min": 0.0, "max": 1.0, "step": 0.01}),
+                    "use_tiled_vae": (["disabled", "enabled"],),
+                    },
+                "optional": {
+                        "upscale_model_opt": ("UPSCALE_MODEL", ),
+                        "pk_hook_opt": ("PK_HOOK", ),
+                    }
+                }
+
+    RETURN_TYPES = ("UPSCALER",)
+    FUNCTION = "doit"
+
+    CATEGORY = "ImpactPack/Upscale"
+
+    def doit(self, scale_method, model, vae, seed, steps, cfg, sampler_name, scheduler, positive, negative, denoise,
+             use_tiled_vae, upscale_model_opt=None, pk_hook_opt=None):
+        upscaler = core.PixelKSampleUpscaler(scale_method, model, vae, seed, steps, cfg, sampler_name, scheduler,
+                                             positive, negative, denoise, use_tiled_vae == "enabled", upscale_model_opt, pk_hook_opt)
+        return (upscaler, )
+
+
+class PixelKSampleUpscalerProviderPipe(PixelKSampleUpscalerProvider):
+    upscale_methods = ["nearest-exact", "bilinear", "area"]
+
+    @classmethod
+    def INPUT_TYPES(s):
+        return {"required": {
+                    "scale_method": (s.upscale_methods,),
+                    "seed": ("INT", {"default": 0, "min": 0, "max": 0xffffffffffffffff}),
+                    "steps": ("INT", {"default": 20, "min": 1, "max": 10000}),
+                    "cfg": ("FLOAT", {"default": 8.0, "min": 0.0, "max": 100.0}),
+                    "sampler_name": (comfy.samplers.KSampler.SAMPLERS, ),
+                    "scheduler": (comfy.samplers.KSampler.SCHEDULERS, ),
+                    "denoise": ("FLOAT", {"default": 1.0, "min": 0.0, "max": 1.0, "step": 0.01}),
+                    "use_tiled_vae": (["disabled", "enabled"],),
+                    "basic_pipe": ("BASIC_PIPE",)
+                    },
+                "optional": {
+                        "upscale_model_opt": ("UPSCALE_MODEL", ),
+                        "pk_hook_opt": ("PK_HOOK", ),
+                    }
+                }
+
+    RETURN_TYPES = ("UPSCALER",)
+    FUNCTION = "doit_pipe"
+
+    CATEGORY = "ImpactPack/Upscale"
+
+    def doit_pipe(self, scale_method, seed, steps, cfg, sampler_name, scheduler, denoise,
+                  use_tiled_vae, basic_pipe, upscale_model_opt=None, pk_hook_opt=None):
+        model, _, vae, positive, negative = basic_pipe
+        upscaler = core.PixelKSampleUpscaler(scale_method, model, vae, seed, steps, cfg, sampler_name, scheduler,
+                                             positive, negative, denoise, use_tiled_vae == "enabled", upscale_model_opt, pk_hook_opt)
+        return (upscaler, )
+
+
+class TwoSamplersForMaskUpscalerProvider:
+    upscale_methods = ["nearest-exact", "bilinear", "area"]
+
+    @classmethod
+    def INPUT_TYPES(s):
+        return {"required": {
+                     "scale_method": (s.upscale_methods,),
+                     "full_sample_schedule": (
+                         ["none", "interleave1", "interleave2", "interleave3",
+                          "last1", "last2",
+                          "interleave1+last1", "interleave2+last1", "interleave3+last1",
+                          ],),
+                     "use_tiled_vae": (["disabled", "enabled"],),
+                     "base_sampler": ("KSAMPLER", ),
+                     "mask_sampler": ("KSAMPLER", ),
+                     "mask": ("MASK", ),
+                     "vae": ("VAE",),
+                     },
+                "optional": {
+                        "full_sampler_opt": ("KSAMPLER",),
+                        "upscale_model_opt": ("UPSCALE_MODEL", ),
+                        "pk_hook_base_opt": ("PK_HOOK", ),
+                        "pk_hook_mask_opt": ("PK_HOOK", ),
+                        "pk_hook_full_opt": ("PK_HOOK", ),
+                    }
+                }
+
+    RETURN_TYPES = ("UPSCALER", )
+    FUNCTION = "doit"
+
+    CATEGORY = "ImpactPack/Upscale"
+
+    def doit(self, scale_method, full_sample_schedule, use_tiled_vae, base_sampler, mask_sampler, mask, vae,
+             full_sampler_opt=None, upscale_model_opt=None,
+             pk_hook_base_opt=None, pk_hook_mask_opt=None, pk_hook_full_opt=None):
+        upscaler = core.TwoSamplersForMaskUpscaler(scale_method, full_sample_schedule, use_tiled_vae == "enabled",
+                                                   base_sampler, mask_sampler, mask, vae, full_sampler_opt, upscale_model_opt,
+                                                   pk_hook_base_opt, pk_hook_mask_opt, pk_hook_full_opt)
+        return (upscaler, )
+
+
+class TwoSamplersForMaskUpscalerProviderPipe:
+    upscale_methods = ["nearest-exact", "bilinear", "area"]
+
+    @classmethod
+    def INPUT_TYPES(s):
+        return {"required": {
+                     "scale_method": (s.upscale_methods,),
+                     "full_sample_schedule": (
+                         ["none", "interleave1", "interleave2", "interleave3",
+                          "last1", "last2",
+                          "interleave1+last1", "interleave2+last1", "interleave3+last1",
+                          ],),
+                     "use_tiled_vae": (["disabled", "enabled"],),
+                     "base_sampler": ("KSAMPLER", ),
+                     "mask_sampler": ("KSAMPLER", ),
+                     "mask": ("MASK", ),
+                     "basic_pipe": ("BASIC_PIPE",),
+                     },
+                "optional": {
+                        "full_sampler_opt": ("KSAMPLER",),
+                        "upscale_model_opt": ("UPSCALE_MODEL", ),
+                        "pk_hook_base_opt": ("PK_HOOK", ),
+                        "pk_hook_mask_opt": ("PK_HOOK", ),
+                        "pk_hook_full_opt": ("PK_HOOK", ),
+                    }
+                }
+
+    RETURN_TYPES = ("UPSCALER", )
+    FUNCTION = "doit"
+
+    CATEGORY = "ImpactPack/Upscale"
+
+    def doit(self, scale_method, full_sample_schedule, use_tiled_vae, base_sampler, mask_sampler, mask, basic_pipe,
+             full_sampler_opt=None, upscale_model_opt=None,
+             pk_hook_base_opt=None, pk_hook_mask_opt=None, pk_hook_full_opt=None):
+        _, _, vae, _, _ = basic_pipe
+        upscaler = core.TwoSamplersForMaskUpscaler(scale_method, full_sample_schedule, use_tiled_vae == "enabled",
+                                                   base_sampler, mask_sampler, mask, vae, full_sampler_opt, upscale_model_opt,
+                                                   pk_hook_base_opt, pk_hook_mask_opt, pk_hook_full_opt)
+        return (upscaler, )
+
+
+class IterativeLatentUpscale:
+    @classmethod
+    def INPUT_TYPES(s):
+        return {"required": {
+                     "samples": ("LATENT", ),
+                     "upscale_factor": ("FLOAT", {"default": 1.5, "min": 1, "max": 10000, "step": 0.1}),
+                     "steps": ("INT", {"default": 3, "min": 1, "max": 10000, "step": 1}),
+                     "temp_prefix": ("STRING", {"default": ""}),
+                     "upscaler": ("UPSCALER",)
+                }}
+
+    RETURN_TYPES = ("LATENT",)
+    RETURN_NAMES = ("latent",)
+    FUNCTION = "doit"
+
+    CATEGORY = "ImpactPack/Upscale"
+
+    def doit(self, samples, upscale_factor, steps, temp_prefix, upscaler):
+        w = samples['samples'].shape[3]*8  # image width
+        h = samples['samples'].shape[2]*8  # image height
+
+        if temp_prefix == "":
+            temp_prefix = None
+
+        upscale_factor_unit = max(0, (upscale_factor-1.0)/steps)
+        current_latent = samples
+        scale = 1
+
+        for i in range(steps-1):
+            scale += upscale_factor_unit
+            new_w = w*scale
+            new_h = h*scale
+            print(f"IterativeLatentUpscale[{i+1}/{steps}]: {new_w:.1f}x{new_h:.1f} (scale:{scale:.2f}) ")
+            step_info = i, steps
+            current_latent = upscaler.upscale_shape(step_info, current_latent, new_w, new_h, temp_prefix)
+
+        if scale < upscale_factor:
+            new_w = w*upscale_factor
+            new_h = h*upscale_factor
+            print(f"IterativeLatentUpscale[Final]: {new_w:.1f}x{new_h:.1f} (scale:{upscale_factor:.2f}) ")
+            step_info = steps, steps
+            current_latent = upscaler.upscale_shape(step_info, current_latent, new_w, new_h, temp_prefix)
+
+        return (current_latent, )
+
+
+class IterativeImageUpscale:
+    @classmethod
+    def INPUT_TYPES(s):
+        return {"required": {
+                     "pixels": ("IMAGE", ),
+                     "upscale_factor": ("FLOAT", {"default": 1.5, "min": 1, "max": 10000, "step": 0.1}),
+                     "steps": ("INT", {"default": 3, "min": 1, "max": 10000, "step": 1}),
+                     "temp_prefix": ("STRING", {"default": ""}),
+                     "upscaler": ("UPSCALER",),
+                     "vae": ("VAE",),
+                }}
+
+    RETURN_TYPES = ("IMAGE",)
+    RETURN_NAMES = ("image",)
+    FUNCTION = "doit"
+
+    CATEGORY = "ImpactPack/Upscale"
+
+    def doit(self, pixels, upscale_factor, steps, temp_prefix, upscaler, vae):
+        if temp_prefix == "":
+            temp_prefix = None
+
+        if upscaler.is_tiled:
+            latent = nodes.VAEEncodeTiled().encode(vae, pixels)[0]
+        else:
+            latent = nodes.VAEEncode().encode(vae, pixels)[0]
+
+        refined_latent = IterativeLatentUpscale().doit(latent, upscale_factor, steps, temp_prefix, upscaler)
+
+        if upscaler.is_tiled:
+            pixels = nodes.VAEDecodeTiled().decode(vae, refined_latent[0])[0]
+        else:
+            pixels = nodes.VAEDecode().decode(vae, refined_latent[0])[0]
+
+        return (pixels, )
+
+
+class FaceDetailerPipe:
+    @classmethod
+    def INPUT_TYPES(s):
+        return {"required": {
+                     "image": ("IMAGE", ),
+                     "detailer_pipe": ("DETAILER_PIPE",),
+                     "guide_size": ("FLOAT", {"default": 256, "min": 64, "max": nodes.MAX_RESOLUTION, "step": 8}),
+                     "guide_size_for": (["bbox", "crop_region"],),
+                     "seed": ("INT", {"default": 0, "min": 0, "max": 0xffffffffffffffff}),
+                     "steps": ("INT", {"default": 20, "min": 1, "max": 10000}),
+                     "cfg": ("FLOAT", {"default": 8.0, "min": 0.0, "max": 100.0}),
+                     "sampler_name": (comfy.samplers.KSampler.SAMPLERS,),
+                     "scheduler": (comfy.samplers.KSampler.SCHEDULERS,),
+                     "denoise": ("FLOAT", {"default": 0.5, "min": 0.0001, "max": 1.0, "step": 0.01}),
+                     "feather": ("INT", {"default": 5, "min": 0, "max": 100, "step": 1}),
+                     "noise_mask": (["enabled", "disabled"], ),
+                     "force_inpaint": (["disabled", "enabled"], ),
+
+                     "bbox_threshold": ("FLOAT", {"default": 0.5, "min": 0.0, "max": 1.0, "step": 0.01}),
+                     "bbox_dilation": ("INT", {"default": 10, "min": 0, "max": 255, "step": 1}),
+                     "bbox_crop_factor": ("FLOAT", {"default": 3.0, "min": 1.0, "max": 10, "step": 0.1}),
+
+                     "sam_detection_hint": (["center-1", "horizontal-2", "vertical-2", "rect-4", "diamond-4", "mask-area", "mask-points", "mask-point-bbox", "none"],),
+                     "sam_dilation": ("INT", {"default": 0, "min": 0, "max": 255, "step": 1}),
+                     "sam_threshold": ("FLOAT", {"default": 0.93, "min": 0.0, "max": 1.0, "step": 0.01}),
+                     "sam_bbox_expansion": ("INT", {"default": 0, "min": 0, "max": 1000, "step": 1}),
+                     "sam_mask_hint_threshold": ("FLOAT", {"default": 0.7, "min": 0.0, "max": 1.0, "step": 0.01}),
+                     "sam_mask_hint_use_negative": (["False", "Small", "Outter"],),
+
+                     "drop_size": ("INT", {"min": 1, "max": MAX_RESOLUTION, "step": 1, "default": 10}),
+                     },
+                }
+
+    RETURN_TYPES = ("IMAGE", "IMAGE", "MASK", "DETAILER_PIPE", )
+    RETURN_NAMES = ("image", "cropped_refined", "mask", "detailer_pipe")
+    FUNCTION = "doit"
+
+    CATEGORY = "ImpactPack/Simple"
+
+    def doit(self, image, detailer_pipe, guide_size, guide_size_for, seed, steps, cfg, sampler_name, scheduler,
+             denoise, feather, noise_mask, force_inpaint, bbox_threshold, bbox_dilation, bbox_crop_factor,
+             sam_detection_hint, sam_dilation, sam_threshold, sam_bbox_expansion,
+             sam_mask_hint_threshold, sam_mask_hint_use_negative, drop_size):
+
+        model, vae, positive, negative, bbox_detector, sam_model_opt = detailer_pipe
+
+        enhanced_img, cropped_enhanced, mask = FaceDetailer.enhance_face(
+            image, model, vae, guide_size, guide_size_for, seed, steps, cfg, sampler_name, scheduler,
+            positive, negative, denoise, feather, noise_mask, force_inpaint,
+            bbox_threshold, bbox_dilation, bbox_crop_factor,
+            sam_detection_hint, sam_dilation, sam_threshold, sam_bbox_expansion, sam_mask_hint_threshold,
+            sam_mask_hint_use_negative, drop_size, bbox_detector, sam_model_opt)
+
+        return enhanced_img, cropped_enhanced, mask, detailer_pipe
+
+
+class DetailerForEachTest(DetailerForEach):
+    RETURN_TYPES = ("IMAGE", "IMAGE", "IMAGE", )
+    RETURN_NAMES = ("image", "cropped", "cropped_refined")
+    FUNCTION = "doit"
+
+    CATEGORY = "ImpactPack/Detailer"
+
+    def doit(self, image, segs, model, vae, guide_size, guide_size_for, seed, steps, cfg, sampler_name, scheduler,
+             positive, negative, denoise, feather, noise_mask, force_inpaint):
+
+        enhanced_img, cropped, cropped_enhanced = \
+            DetailerForEach.do_detail(image, segs, model, vae, guide_size, guide_size_for, seed, steps, cfg,
+                                      sampler_name, scheduler, positive, negative, denoise, feather, noise_mask,
+                                      force_inpaint)
+
+        # set fallback image
+        if cropped is None:
+            cropped = enhanced_img
+
+        if cropped_enhanced is None:
+            cropped_enhanced = enhanced_img
+
+        return enhanced_img, cropped, cropped_enhanced,
+
+
+class DetailerForEachTestPipe(DetailerForEachPipe):
+    RETURN_TYPES = ("IMAGE", "IMAGE", "IMAGE", )
+    RETURN_NAMES = ("image", "cropped", "cropped_refined")
+    FUNCTION = "doit"
+
+    CATEGORY = "ImpactPack/Detailer"
+
+    def doit(self, image, segs, guide_size, guide_size_for, seed, steps, cfg, sampler_name, scheduler,
+             denoise, feather, noise_mask, force_inpaint, basic_pipe):
+
+        model, _, vae, positive, negative = basic_pipe
+        enhanced_img, cropped, cropped_enhanced = \
+            DetailerForEach.do_detail(image, segs, model, vae, guide_size, guide_size_for, seed, steps, cfg,
+                                      sampler_name, scheduler, positive, negative, denoise, feather, noise_mask,
+                                      force_inpaint)
+
+        # set fallback image
+        if cropped is None:
+            cropped = enhanced_img
+
+        if cropped_enhanced is None:
+            cropped_enhanced = enhanced_img
+
+        return enhanced_img, cropped, cropped_enhanced,
+
+
+class EmptySEGS:
+    @classmethod
+    def INPUT_TYPES(s):
+        return {"required": {},}
+    
+    RETURN_TYPES = ("SEGS",)
+    FUNCTION = "doit"
+
+    CATEGORY = "ImpactPack/Util"
+
+    def doit(self):
+        shape = 0, 0
+        return ((shape, []),)
+
+
+class SegsToCombinedMask:
+    @classmethod
+    def INPUT_TYPES(s):
+        return {"required": {
+                        "segs": ("SEGS", ),
+                      }
+                }
+
+    RETURN_TYPES = ("MASK",)
+    FUNCTION = "doit"
+
+    CATEGORY = "ImpactPack/Operation"
+
+    def doit(self, segs):
+        return (core.segs_to_combined_mask(segs), )
+
+
+class SegsBitwiseAndMask:
+    @classmethod
+    def INPUT_TYPES(s):
+        return {"required": {
+                        "segs": ("SEGS",),
+                        "mask": ("MASK",),
+                    }
+                }
+
+    RETURN_TYPES = ("SEGS",)
+    FUNCTION = "doit"
+
+    CATEGORY = "ImpactPack/Operation"
+
+    def doit(self, segs, mask):
+        return (core.segs_bitwise_and_mask(segs, mask), )
+
+
+class BitwiseAndMaskForEach:
+    @classmethod
+    def INPUT_TYPES(s):
+        return {"required":
+            {
+                "base_segs": ("SEGS",),
+                "mask_segs": ("SEGS",),
+            }
+        }
+
+    RETURN_TYPES = ("SEGS",)
+    FUNCTION = "doit"
+
+    CATEGORY = "ImpactPack/Operation"
+
+    def doit(self, base_segs, mask_segs):
+
+        result = []
+
+        for bseg in base_segs[1]:
+            cropped_mask1 = bseg.cropped_mask.copy()
+            crop_region1 = bseg.crop_region
+
+            for mseg in mask_segs[1]:
+                cropped_mask2 = mseg.cropped_mask
+                crop_region2 = mseg.crop_region
+
+                # compute the intersection of the two crop regions
+                intersect_region = (max(crop_region1[0], crop_region2[0]),
+                                    max(crop_region1[1], crop_region2[1]),
+                                    min(crop_region1[2], crop_region2[2]),
+                                    min(crop_region1[3], crop_region2[3]))
+
+                overlapped = False
+
+                # set all pixels in cropped_mask1 to 0 except for those that overlap with cropped_mask2
+                for i in range(intersect_region[0], intersect_region[2]):
+                    for j in range(intersect_region[1], intersect_region[3]):
+                        if cropped_mask1[j - crop_region1[1], i - crop_region1[0]] == 1 and \
+                                cropped_mask2[j - crop_region2[1], i - crop_region2[0]] == 1:
+                            # pixel overlaps with both masks, keep it as 1
+                            overlapped = True
+                            pass
+                        else:
+                            # pixel does not overlap with both masks, set it to 0
+                            cropped_mask1[j - crop_region1[1], i - crop_region1[0]] = 0
+
+                if overlapped:
+                    item = SEG(bseg.cropped_image, cropped_mask1, bseg.confidence, bseg.crop_region, bseg.bbox, bseg.label)
+                    result.append(item)
+
+        return ((base_segs[0], result),)
+
+
+class SubtractMaskForEach:
+    @classmethod
+    def INPUT_TYPES(s):
+        return {"required": {
+                        "base_segs": ("SEGS",),
+                        "mask_segs": ("SEGS",),
+                    }
+                }
+
+    RETURN_TYPES = ("SEGS",)
+    FUNCTION = "doit"
+
+    CATEGORY = "ImpactPack/Operation"
+
+    def doit(self, base_segs, mask_segs):
+
+        result = []
+
+        for bseg in base_segs[1]:
+            cropped_mask1 = bseg.cropped_mask.copy()
+            crop_region1 = bseg.crop_region
+
+            for mseg in mask_segs[1]:
+                cropped_mask2 = mseg.cropped_mask
+                crop_region2 = mseg.crop_region
+
+                # compute the intersection of the two crop regions
+                intersect_region = (max(crop_region1[0], crop_region2[0]),
+                                    max(crop_region1[1], crop_region2[1]),
+                                    min(crop_region1[2], crop_region2[2]),
+                                    min(crop_region1[3], crop_region2[3]))
+
+                changed = False
+
+                # subtract operation
+                for i in range(intersect_region[0], intersect_region[2]):
+                    for j in range(intersect_region[1], intersect_region[3]):
+                        if cropped_mask1[j - crop_region1[1], i - crop_region1[0]] == 1 and \
+                                cropped_mask2[j - crop_region2[1], i - crop_region2[0]] == 1:
+                            # pixel overlaps with both masks, set it as 0
+                            changed = True
+                            cropped_mask1[j - crop_region1[1], i - crop_region1[0]] = 0
+                        else:
+                            # pixel does not overlap with both masks, don't care
+                            pass
+
+                if changed:
+                    item = SEG(bseg.cropped_image, cropped_mask1, bseg.confidence, bseg.crop_region, bseg.bbox, bseg.label)
+                    result.append(item)
+                else:
+                    result.append(base_segs)
+
+        return ((base_segs[0], result),)
+
+
+class MaskToSEGS:
+    @classmethod
+    def INPUT_TYPES(s):
+        return {"required": {
+                                "mask": ("MASK",),
+                                "combined": (["False", "True"], ),
+                                "crop_factor": ("FLOAT", {"default": 3.0, "min": 1.0, "max": 10, "step": 0.1}),
+                                "bbox_fill": (["disabled", "enabled"], ),
+                                "drop_size": ("INT", {"min": 1, "max": MAX_RESOLUTION, "step": 1, "default": 10}),
+                             }
+                }
+
+    RETURN_TYPES = ("SEGS",)
+    FUNCTION = "doit"
+
+    CATEGORY = "ImpactPack/Operation"
+
+    def doit(self, mask, combined, crop_factor, bbox_fill, drop_size):
+        result = core.mask_to_segs(mask, combined, crop_factor, bbox_fill == "enabled", drop_size)
+        return (result, )
+
+
+class ToBinaryMask:
+    @classmethod
+    def INPUT_TYPES(s):
+        return {"required": {
+                      "mask": ("MASK",),
+                    }
+                }
+
+    RETURN_TYPES = ("MASK",)
+    FUNCTION = "doit"
+
+    CATEGORY = "ImpactPack/Operation"
+
+    def doit(self, mask,):
+        mask = to_binary_mask(mask)
+        return (mask,)
+
+
+class BitwiseAndMask:
+    @classmethod
+    def INPUT_TYPES(s):
+        return {"required": {
+                        "mask1": ("MASK",),
+                        "mask2": ("MASK",),
+                    }
+                }
+
+    RETURN_TYPES = ("MASK",)
+    FUNCTION = "doit"
+
+    CATEGORY = "ImpactPack/Operation"
+
+    def doit(self, mask1, mask2):
+        mask = bitwise_and_masks(mask1, mask2)
+        return (mask,)
+
+
+class SubtractMask:
+    @classmethod
+    def INPUT_TYPES(s):
+        return {"required": {
+                        "mask1": ("MASK", ),
+                        "mask2": ("MASK", ),
+                      }
+                }
+    
+    RETURN_TYPES = ("MASK",)
+    FUNCTION = "doit"
+
+    CATEGORY = "ImpactPack/Operation"
+
+    def doit(self, mask1, mask2):
+        mask = subtract_masks(mask1, mask2)
+        return (mask,)
+
+
+import nodes
+
+class PreviewBridge(nodes.PreviewImage):
+    @classmethod
+    def INPUT_TYPES(s):
+        return {"required": {"images": ("IMAGE",), },
+                "hidden": {"prompt": "PROMPT", "extra_pnginfo": "EXTRA_PNGINFO", },
+                "optional": {"image": (["#placeholder"], )},
+                }
+
+    RETURN_TYPES = ("IMAGE", "MASK", )
+
+    FUNCTION = "doit"
+
+    CATEGORY = "ImpactPack/Util"
+
+    def doit(self, images, image, filename_prefix="ComfyUI", prompt=None, extra_pnginfo=None):
+        if image == "#placeholder" or image['image_hash'] != id(images):
+            # new input image
+            res = self.save_images(images, filename_prefix, prompt, extra_pnginfo)
+
+            item = res['ui']['images'][0]
+
+            if not item['filename'].endswith(']'):
+                filepath = f"{item['filename']} [{item['type']}]"
+            else:
+                filepath = item['filename']
+
+            image, mask = nodes.LoadImage().load_image(filepath)
+
+            res['ui']['aux'] = [id(images), res['ui']['images']]
+            res['result'] = (image, mask, )
+
+            return res
+
+        else:
+            # new mask
+            forward = {'filename': image['forward_filename'],
+                       'subfolder': image['forward_subfolder'],
+                       'type': image['forward_type'], }
+
+            res = {'ui': {'images': [forward]}}
+
+            imgpath = ""
+            if 'subfolder' in image and image['subfolder'] != "":
+                imgpath = image['subfolder'] + "/"
+
+            imgpath += f"{image['filename']}"
+
+            if 'type' in image and image['type'] != "":
+                imgpath += f" [{image['type']}]"
+
+            res['ui']['aux'] = [id(images), [forward]]
+            res['result'] = nodes.LoadImage().load_image(imgpath)
+
+            return res
+
+
+class DetailerForEach:
+    @classmethod
+    def INPUT_TYPES(s):
+        return {"required": {
+            "image": ("IMAGE",),
+            "segs": ("SEGS",),
+            "model": ("MODEL",),
+            "vae": ("VAE",),
+            "guide_size": ("FLOAT", {"default": 256, "min": 64, "max": nodes.MAX_RESOLUTION, "step": 8}),
+            "guide_size_for": (["bbox", "crop_region"],),
+            "seed": ("INT", {"default": 0, "min": 0, "max": 0xffffffffffffffff}),
+            "steps": ("INT", {"default": 20, "min": 1, "max": 10000}),
+            "cfg": ("FLOAT", {"default": 8.0, "min": 0.0, "max": 100.0}),
+            "sampler_name": (comfy.samplers.KSampler.SAMPLERS,),
+            "scheduler": (comfy.samplers.KSampler.SCHEDULERS,),
+            "positive": ("CONDITIONING",),
+            "negative": ("CONDITIONING",),
+            "denoise": ("FLOAT", {"default": 0.5, "min": 0.0001, "max": 1.0, "step": 0.01}),
+            "feather": ("INT", {"default": 5, "min": 0, "max": 100, "step": 1}),
+            "noise_mask": (["enabled", "disabled"],),
+            "force_inpaint": (["disabled", "enabled"],),
+        },
+        }
+
+    RETURN_TYPES = ("IMAGE",)
+    FUNCTION = "doit"
+
+    CATEGORY = "ImpactPack/Detailer"
+
+    @staticmethod
+    def do_detail(image, segs, model, vae, guide_size, guide_size_for, seed, steps, cfg, sampler_name, scheduler,
+                  positive, negative, denoise, feather, noise_mask, force_inpaint):
+
+        image_pil = tensor2pil(image).convert('RGBA')
+
+        # shape = segs[0]
+        segs = segs[1]
+        for seg in segs:
+            cropped_image = seg.cropped_image if seg.cropped_image is not None \
+                else crop_ndarray4(image.numpy(), seg.crop_region)
+
+            mask_pil = feather_mask(seg.cropped_mask, feather)
+
+            if noise_mask == "enabled":
+                cropped_mask = seg.cropped_mask
+            else:
+                cropped_mask = None
+
+            enhanced_pil = core.enhance_detail(cropped_image, model, vae, guide_size, guide_size_for, seg.bbox,
+                                               seed, steps, cfg, sampler_name, scheduler,
+                                               positive, negative, denoise, cropped_mask, force_inpaint == "enabled")
+
+            if not (enhanced_pil is None):
+                # don't latent composite-> converting to latent caused poor quality
+                # use image paste
+                image_pil.paste(enhanced_pil, (seg.crop_region[0], seg.crop_region[1]), mask_pil)
+
+        image_tensor = pil2tensor(image_pil.convert('RGB'))
+
+        if len(segs) > 0:
+            enhanced_tensor = pil2tensor(enhanced_pil) if enhanced_pil is not None else None
+            return image_tensor, torch.from_numpy(cropped_image), enhanced_tensor,
+        else:
+            return image_tensor, None, None,
+
+    def doit(self, image, segs, model, vae, guide_size, guide_size_for, seed, steps, cfg, sampler_name, scheduler,
+             positive, negative, denoise, feather, noise_mask, force_inpaint):
+
+        enhanced_img, cropped, cropped_enhanced = \
+            DetailerForEach.do_detail(image, segs, model, vae, guide_size, guide_size_for, seed, steps, cfg,
+                                      sampler_name, scheduler, positive, negative, denoise, feather, noise_mask,
+                                      force_inpaint)
+
+        return (enhanced_img,)
+

ComfyUI-Impact-Pack/impact_pipe.py

@@ -0,0 +1,205 @@
+class ToDetailerPipe:
+    @classmethod
+    def INPUT_TYPES(s):
+        return {"required": {
+                     "model": ("MODEL",),
+                     "vae": ("VAE",),
+                     "positive": ("CONDITIONING",),
+                     "negative": ("CONDITIONING",),
+                     "bbox_detector": ("BBOX_DETECTOR", ),
+                     },
+                "optional": {
+                    "sam_model_opt": ("SAM_MODEL", ),
+                }}
+
+    RETURN_TYPES = ("DETAILER_PIPE", )
+    RETURN_NAMES = ("detailer_pipe", )
+    FUNCTION = "doit"
+
+    CATEGORY = "ImpactPack/Pipe"
+
+    def doit(self, model, vae, positive, negative, bbox_detector, sam_model_opt=None):
+        pipe = (model, vae, positive, negative, bbox_detector, sam_model_opt)
+        return (pipe, )
+
+
+class FromDetailerPipe:
+    @classmethod
+    def INPUT_TYPES(s):
+        return {"required": {"detailer_pipe": ("DETAILER_PIPE",), }, }
+
+    RETURN_TYPES = ("MODEL", "VAE", "CONDITIONING", "CONDITIONING", "BBOX_DETECTOR", "SAM_MODEL")
+    RETURN_NAMES = ("model", "vae", "positive", "negative", "bbox_detector", "sam_model_opt")
+    FUNCTION = "doit"
+
+    CATEGORY = "ImpactPack/Pipe"
+
+    def doit(self, detailer_pipe):
+        model, vae, positive, negative, bbox_detector, sam_model_opt = detailer_pipe
+        return model, vae, positive, negative, bbox_detector, sam_model_opt
+
+
+class ToBasicPipe:
+    @classmethod
+    def INPUT_TYPES(s):
+        return {"required": {
+                     "model": ("MODEL",),
+                     "clip": ("CLIP",),
+                     "vae": ("VAE",),
+                     "positive": ("CONDITIONING",),
+                     "negative": ("CONDITIONING",),
+                     },
+                }
+
+    RETURN_TYPES = ("BASIC_PIPE", )
+    RETURN_NAMES = ("basic_pipe", )
+    FUNCTION = "doit"
+
+    CATEGORY = "ImpactPack/Pipe"
+
+    def doit(self, model, clip, vae, positive, negative):
+        pipe = (model, clip, vae, positive, negative)
+        return (pipe, )
+
+
+class FromBasicPipe:
+    @classmethod
+    def INPUT_TYPES(s):
+        return {"required": {"basic_pipe": ("BASIC_PIPE",), }, }
+
+    RETURN_TYPES = ("MODEL", "CLIP", "VAE", "CONDITIONING", "CONDITIONING")
+    RETURN_NAMES = ("model", "clip", "vae", "positive", "negative")
+    FUNCTION = "doit"
+
+    CATEGORY = "ImpactPack/Pipe"
+
+    def doit(self, basic_pipe):
+        model, clip, vae, positive, negative = basic_pipe
+        return model, clip, vae, positive, negative
+
+
+class BasicPipeToDetailerPipe:
+    @classmethod
+    def INPUT_TYPES(s):
+        return {"required": {"basic_pipe": ("BASIC_PIPE",),
+                             "bbox_detector": ("BBOX_DETECTOR", ), },
+                "optional": {"sam_model_opt": ("SAM_MODEL", ), },
+                }
+
+    RETURN_TYPES = ("DETAILER_PIPE", )
+    RETURN_NAMES = ("detailer_pipe", )
+    FUNCTION = "doit"
+
+    CATEGORY = "ImpactPack/Pipe"
+
+    def doit(self, basic_pipe, bbox_detector, sam_model_opt=None):
+        model, _, vae, positive, negative = basic_pipe
+        pipe = model, vae, positive, negative, bbox_detector, sam_model_opt
+        return (pipe, )
+
+
+class DetailerPipeToBasicPipe:
+    @classmethod
+    def INPUT_TYPES(s):
+        return {"required": {"detailer_pipe": ("DETAILER_PIPE",),
+                             "clip": ("CLIP",), }, }
+
+    RETURN_TYPES = ("BASIC_PIPE", )
+    RETURN_NAMES = ("basic_pipe", )
+    FUNCTION = "doit"
+
+    CATEGORY = "ImpactPack/Pipe"
+
+    def doit(self, detailer_pipe, clip):
+        model, vae, positive, negative, _, _ = detailer_pipe
+        pipe = model, clip, vae, positive, negative
+        return (pipe, )
+
+
+class EditBasicPipe:
+    @classmethod
+    def INPUT_TYPES(s):
+        return {
+                "required": {"basic_pipe": ("BASIC_PIPE",), },
+                "optional": {
+                     "model": ("MODEL",),
+                     "clip": ("CLIP",),
+                     "vae": ("VAE",),
+                     "positive": ("CONDITIONING",),
+                     "negative": ("CONDITIONING",),
+                     },
+                }
+
+    RETURN_TYPES = ("BASIC_PIPE", )
+    RETURN_NAMES = ("basic_pipe", )
+    FUNCTION = "doit"
+
+    CATEGORY = "ImpactPack/Pipe"
+
+    def doit(self, basic_pipe, model=None, clip=None, vae=None, positive=None, negative=None):
+        res_model, res_clip, res_vae, res_positive, res_negative = basic_pipe
+
+        if model is not None:
+            res_model = model
+
+        if clip is not None:
+            res_clip = clip
+
+        if vae is not None:
+            res_vae = vae
+
+        if positive is not None:
+            res_positive = positive
+
+        if negative is not None:
+            res_negative = negative
+
+        pipe = res_model, res_clip, res_vae, res_positive, res_negative
+
+        return (pipe, )
+
+
+class EditDetailerPipe:
+    @classmethod
+    def INPUT_TYPES(s):
+        return {
+            "required": {"detailer_pipe": ("DETAILER_PIPE",), },
+            "optional": {
+                "model": ("MODEL",),
+                "vae": ("VAE",),
+                "positive": ("CONDITIONING",),
+                "negative": ("CONDITIONING",),
+                "bbox_detector": ("BBOX_DETECTOR",),
+                "sam_model": ("SAM_MODEL",), },
+        }
+
+    RETURN_TYPES = ("DETAILER_PIPE",)
+    RETURN_NAMES = ("detailer_pipe",)
+    FUNCTION = "doit"
+
+    CATEGORY = "ImpactPack/Pipe"
+
+    def doit(self, detailer_pipe, model=None, vae=None, positive=None, negative=None, bbox_detector=None, sam_model=None):
+        res_model, res_vae, res_positive, res_negative, res_bbox_detector, res_sam_model = detailer_pipe
+
+        if model is not None:
+            res_model = model
+
+        if vae is not None:
+            res_vae = vae
+
+        if positive is not None:
+            res_positive = positive
+
+        if negative is not None:
+            res_negative = negative
+
+        if bbox_detector is not None:
+            res_bbox_detector = bbox_detector
+
+        if sam_model is not None:
+            res_sam_model = sam_model
+
+        pipe = res_model, res_vae, res_positive, res_negative, res_bbox_detector, res_sam_model
+
+        return (pipe, )

ComfyUI-Impact-Pack/impact_server.py

@@ -0,0 +1,148 @@
+import os
+import threading
+
+from aiohttp import web
+import server
+import folder_paths
+
+import impact_core as core
+import impact_pack
+from segment_anything import SamPredictor, sam_model_registry
+import numpy as np
+import nodes
+from PIL import Image
+import io
+
+@server.PromptServer.instance.routes.post("/upload/temp")
+async def upload_image(request):
+    upload_dir = folder_paths.get_temp_directory()
+
+    if not os.path.exists(upload_dir):
+        os.makedirs(upload_dir)
+    
+    post = await request.post()
+    image = post.get("image")
+
+    if image and image.file:
+        filename = image.filename
+        if not filename:
+            return web.Response(status=400)
+
+        split = os.path.splitext(filename)
+        i = 1
+        while os.path.exists(os.path.join(upload_dir, filename)):
+            filename = f"{split[0]} ({i}){split[1]}"
+            i += 1
+
+        filepath = os.path.join(upload_dir, filename)
+
+        with open(filepath, "wb") as f:
+            f.write(image.file.read())
+        
+        return web.json_response({"name": filename})
+    else:
+        return web.Response(status=400)
+
+
+sam_predictor = None
+default_sam_model_name = os.path.join(impact_pack.model_path, "sams", "sam_vit_b_01ec64.pth")
+
+sam_lock = threading.Condition()
+
+last_prepare_data = None
+
+@server.PromptServer.instance.routes.post("/sam/prepare")
+async def load_sam_model(request):
+    global sam_predictor
+    global last_prepare_data
+    data = await request.json()
+
+    with sam_lock:
+        if last_prepare_data is not None and last_prepare_data == data:
+            # already loaded: skip -- prevent redundant loading
+            return web.Response(status=200)
+
+        last_prepare_data = data
+
+        model_name = os.path.join(impact_pack.model_path, "sams", data['sam_model_name'])
+
+        print(f"ComfyUI-Impact-Pack: Loading SAM model '{impact_pack.model_path}'")
+
+        filename, image_dir = folder_paths.annotated_filepath(data["filename"])
+
+        if image_dir is None:
+            typ = data['type'] if data['type'] != '' else 'output'
+            image_dir = folder_paths.get_directory_by_type(typ)
+
+        if image_dir is None:
+            return web.Response(status=400)
+
+        if 'vit_h' in model_name:
+            model_kind = 'vit_h'
+        elif 'vit_l' in model_name:
+            model_kind = 'vit_l'
+        else:
+            model_kind = 'vit_b'
+
+        sam_model = sam_model_registry[model_kind](checkpoint=model_name)
+        sam_predictor = SamPredictor(sam_model)
+
+        image_path = os.path.join(image_dir, filename)
+        image = nodes.LoadImage().load_image(image_path)[0]
+        image = np.clip(255. * image.cpu().numpy().squeeze(), 0, 255).astype(np.uint8)
+
+        sam_predictor.set_image(image, "RGB")
+
+
+@server.PromptServer.instance.routes.post("/sam/release")
+async def release_sam(request):
+    global sam_predictor
+
+    with sam_lock:
+        sam_predictor = None
+
+    print(f"ComfyUI-Impact-Pack: unloading SAM model")
+
+
+@server.PromptServer.instance.routes.post("/sam/detect")
+async def sam_detect(request):
+    global sam_predictor
+    with sam_lock:
+        if sam_predictor is not None:
+            data = await request.json()
+
+            positive_points = data['positive_points']
+            negative_points = data['negative_points']
+            threshold = data['threshold']
+
+            points = []
+            plabs = []
+
+            for p in positive_points:
+                points.append(p)
+                plabs.append(1)
+
+            for p in negative_points:
+                points.append(p)
+                plabs.append(0)
+
+            detected_masks = core.sam_predict(sam_predictor, points, plabs, None, threshold)
+            mask = core.combine_masks2(detected_masks)
+
+            if mask is None:
+                return web.Response(status=400)
+
+            image = mask.reshape((-1, 1, mask.shape[-2], mask.shape[-1])).movedim(1, -1).expand(-1, -1, -1, 3)
+            i = 255. * image.cpu().numpy()
+
+            img = Image.fromarray(np.clip(i[0], 0, 255).astype(np.uint8))
+
+            img_buffer = io.BytesIO()
+            img.save(img_buffer, format='png')
+
+            headers = {'Content-Type': 'image/png'}
+
+            return web.Response(body=img_buffer.getvalue(), headers=headers)
+
+        else:
+            return web.Response(status=400)

ComfyUI-Impact-Pack/impact_utils.py

@@ -0,0 +1,193 @@
+import torch
+import cv2
+import numpy as np
+from PIL import Image, ImageFilter
+
+LANCZOS = (Image.Resampling.LANCZOS if hasattr(Image, 'Resampling') else Image.LANCZOS)
+
+def pil2tensor(image):
+    return torch.from_numpy(np.array(image).astype(np.float32) / 255.0).unsqueeze(0)
+
+
+def tensor2pil(image):
+    return Image.fromarray(np.clip(255. * image.cpu().numpy().squeeze(), 0, 255).astype(np.uint8))
+
+
+def center_of_bbox(bbox):
+    w, h = bbox[2] - bbox[0], bbox[3] - bbox[1]
+    return bbox[0] + w/2, bbox[1] + h/2
+
+
+def combine_masks(masks):
+    if len(masks) == 0:
+        return None
+    else:
+        initial_cv2_mask = np.array(masks[0][1])
+        combined_cv2_mask = initial_cv2_mask
+
+        for i in range(1, len(masks)):
+            cv2_mask = np.array(masks[i][1])
+            combined_cv2_mask = cv2.bitwise_or(combined_cv2_mask, cv2_mask)
+
+        mask = torch.from_numpy(combined_cv2_mask)
+        return mask
+
+
+def combine_masks2(masks):
+    if len(masks) == 0:
+        return None
+    else:
+        initial_cv2_mask = np.array(masks[0]).astype(np.uint8)
+        combined_cv2_mask = initial_cv2_mask
+
+        for i in range(1, len(masks)):
+            cv2_mask = np.array(masks[i]).astype(np.uint8)
+            combined_cv2_mask = cv2.bitwise_or(combined_cv2_mask, cv2_mask)
+
+        mask = torch.from_numpy(combined_cv2_mask)
+        return mask
+
+
+def bitwise_and_masks(mask1, mask2):
+    mask1 = mask1.cpu()
+    mask2 = mask2.cpu()
+    cv2_mask1 = np.array(mask1)
+    cv2_mask2 = np.array(mask2)
+    cv2_mask = cv2.bitwise_and(cv2_mask1, cv2_mask2)
+    mask = torch.from_numpy(cv2_mask)
+    return mask
+
+
+def to_binary_mask(mask):
+    mask = mask.clone().cpu()
+    mask[mask != 0] = 1.
+    return mask
+
+
+def dilate_mask(mask, dilation_factor, iter=1):
+    if dilation_factor == 0:
+        return mask
+
+    kernel = np.ones((dilation_factor,dilation_factor), np.uint8)
+    return cv2.dilate(mask, kernel, iter)
+
+
+def dilate_masks(segmasks, dilation_factor, iter=1):
+    if dilation_factor == 0:
+        return segmasks
+
+    dilated_masks = []
+    kernel = np.ones((dilation_factor,dilation_factor), np.uint8)
+    for i in range(len(segmasks)):
+        cv2_mask = segmasks[i][1]
+        dilated_mask = cv2.dilate(cv2_mask, kernel, iter)
+        item = (segmasks[i][0], dilated_mask, segmasks[i][2])
+        dilated_masks.append(item)
+    return dilated_masks
+
+
+def feather_mask(mask, thickness):
+    pil_mask = Image.fromarray(np.uint8(mask * 255))
+
+    # Create a feathered mask by applying a Gaussian blur to the mask
+    blurred_mask = pil_mask.filter(ImageFilter.GaussianBlur(thickness))
+    feathered_mask = Image.new("L", pil_mask.size, 0)
+    feathered_mask.paste(blurred_mask, (0, 0), blurred_mask)
+    return feathered_mask
+
+
+def subtract_masks(mask1, mask2):
+    mask1 = mask1.cpu()
+    mask2 = mask2.cpu()
+    cv2_mask1 = np.array(mask1) * 255
+    cv2_mask2 = np.array(mask2) * 255
+    cv2_mask = cv2.subtract(cv2_mask1, cv2_mask2)
+    mask = torch.from_numpy(cv2_mask) / 255.0
+    return mask
+
+
+def normalize_region(limit, startp, size):
+    if startp < 0:
+        new_endp = min(limit, size)
+        new_startp = 0
+    elif startp + size > limit:
+        new_startp = max(0, limit - size)
+        new_endp = limit
+    else:
+        new_startp = startp
+        new_endp = min(limit, startp+size)
+
+    return int(new_startp), int(new_endp)
+
+
+def make_crop_region(w, h, bbox, crop_factor):
+    x1 = bbox[0]
+    y1 = bbox[1]
+    x2 = bbox[2]
+    y2 = bbox[3]
+
+    bbox_w = x2 - x1
+    bbox_h = y2 - y1
+
+    crop_w = bbox_w * crop_factor
+    crop_h = bbox_h * crop_factor
+
+    kernel_x = x1 + bbox_w / 2
+    kernel_y = y1 + bbox_h / 2
+
+    new_x1 = int(kernel_x - crop_w / 2)
+    new_y1 = int(kernel_y - crop_h / 2)
+
+    # make sure position in (w,h)
+    new_x1, new_x2 = normalize_region(w, new_x1, crop_w)
+    new_y1, new_y2 = normalize_region(h, new_y1, crop_h)
+
+    return [new_x1, new_y1, new_x2, new_y2]
+
+
+def crop_ndarray4(npimg, crop_region):
+    x1 = crop_region[0]
+    y1 = crop_region[1]
+    x2 = crop_region[2]
+    y2 = crop_region[3]
+
+    cropped = npimg[:, y1:y2, x1:x2, :]
+
+    return cropped
+
+
+def crop_ndarray2(npimg, crop_region):
+    x1 = crop_region[0]
+    y1 = crop_region[1]
+    x2 = crop_region[2]
+    y2 = crop_region[3]
+
+    cropped = npimg[y1:y2, x1:x2]
+
+    return cropped
+
+
+def crop_image(image, crop_region):
+    return crop_ndarray4(np.array(image), crop_region)
+
+
+def to_latent_image(pixels, vae):
+    x = pixels.shape[1]
+    y = pixels.shape[2]
+    if pixels.shape[1] != x or pixels.shape[2] != y:
+        pixels = pixels[:, :x, :y, :]
+    t = vae.encode(pixels[:, :, :, :3])
+    return {"samples": t}
+
+
+def scale_tensor(w, h, image):
+    image = tensor2pil(image)
+    scaled_image = image.resize((w, h), resample=LANCZOS)
+    return pil2tensor(scaled_image)
+
+
+def scale_tensor_and_to_pil(w,h, image):
+    image = tensor2pil(image)
+    return image.resize((w, h), resample=LANCZOS)
+
+

ComfyUI-Impact-Pack/install.py

@@ -0,0 +1,124 @@
+import os
+import sys
+import subprocess
+
+
+comfy_path = '../..'
+
+sys.path.insert(0, os.path.join(os.path.dirname(os.path.realpath(__file__)), "comfy"))
+sys.path.append('.')   # for portable version
+sys.path.append(comfy_path)
+
+
+import platform
+import folder_paths
+from torchvision.datasets.utils import download_url
+import impact_config
+
+
+print("### ComfyUI-Impact-Pack: Check dependencies")
+
+if "python_embeded" in sys.executable or "python_embedded" in sys.executable:
+    pip_install = [sys.executable, '-s', '-m', 'pip', 'install', '--user']
+    mim_install = [sys.executable, '-s', '-m', 'mim', 'install', '--user']
+else:
+    pip_install = [sys.executable, '-s', '-m', 'pip', 'install']
+    mim_install = [sys.executable, '-s', '-m', 'mim', 'install']
+
+
+def remove_olds():
+    comfy_path = os.path.dirname(folder_paths.__file__)
+    custom_nodes_path = os.path.join(comfy_path, "custom_nodes")
+    old_ini_path = os.path.join(custom_nodes_path, "impact-pack.ini")
+    old_py_path = os.path.join(custom_nodes_path, "comfyui-impact-pack.py")
+
+    if os.path.exists(old_ini_path):
+        print(f"Delete legacy file: {old_ini_path}")
+        os.remove(old_ini_path)
+    
+    if os.path.exists(old_py_path):
+        print(f"Delete legacy file: {old_py_path}")
+        os.remove(old_py_path)
+
+
+def ensure_pip_packages():
+    try:
+        import cv2
+    except Exception:
+        try:
+            subprocess.check_call(pip_install + ['opencv-python'])
+        except:
+            print(f"ComfyUI-Impact-Pack: failed to install 'opencv-python'. Please, install manually.")
+
+    try:
+        import segment_anything
+        from skimage.measure import label, regionprops
+    except Exception:
+        my_path = os.path.dirname(__file__)
+        requirements_path = os.path.join(my_path, "requirements.txt")
+        subprocess.check_call(pip_install + ['-r', requirements_path])
+
+    try:
+        import pycocotools
+    except Exception:
+        if platform.system() not in ["Windows"] or platform.machine() not in ["AMD64", "x86_64"]:
+            print(f"Your system is {platform.system()}; !! You need to install 'libpython3-dev' for this step. !!")
+
+            subprocess.check_call(pip_install + ['pycocotools'])
+        else:
+            pycocotools = {
+                (3, 8): "https://github.com/Bing-su/dddetailer/releases/download/pycocotools/pycocotools-2.0.6-cp38-cp38-win_amd64.whl",
+                (3, 9): "https://github.com/Bing-su/dddetailer/releases/download/pycocotools/pycocotools-2.0.6-cp39-cp39-win_amd64.whl",
+                (3, 10): "https://github.com/Bing-su/dddetailer/releases/download/pycocotools/pycocotools-2.0.6-cp310-cp310-win_amd64.whl",
+                (3, 11): "https://github.com/Bing-su/dddetailer/releases/download/pycocotools/pycocotools-2.0.6-cp311-cp311-win_amd64.whl",
+            }
+
+            version = sys.version_info[:2]
+            url = pycocotools[version]
+            subprocess.check_call(pip_install + [url])
+
+
+def ensure_mmdet_package():
+    try:
+        import mmcv
+        import mmdet
+        from mmdet.evaluation import get_classes
+    except Exception:
+        subprocess.check_call(pip_install + ['-U', 'openmim'])
+        subprocess.check_call(mim_install + ['mmcv==2.0.0'])
+        subprocess.check_call(mim_install + ['mmdet==3.0.0'])
+        subprocess.check_call(mim_install + ['mmengine==0.7.3'])
+
+
+def install():
+    remove_olds()
+    ensure_pip_packages()
+    ensure_mmdet_package()
+
+    # Download model
+    print("### ComfyUI-Impact-Pack: Check basic models")
+
+    model_path = folder_paths.models_dir
+
+    bbox_path = os.path.join(model_path, "mmdets", "bbox")
+    #segm_path = os.path.join(model_path, "mmdets", "segm") -- deprecated
+    sam_path = os.path.join(model_path, "sams")
+    onnx_path = os.path.join(model_path, "onnx")
+
+    if not os.path.exists(os.path.join(bbox_path, "mmdet_anime-face_yolov3.pth")):
+        download_url("https://huggingface.co/dustysys/ddetailer/resolve/main/mmdet/bbox/mmdet_anime-face_yolov3.pth", bbox_path)
+
+    if not os.path.exists(os.path.join(bbox_path, "mmdet_anime-face_yolov3.py")):
+        download_url("https://raw.githubusercontent.com/Bing-su/dddetailer/master/config/mmdet_anime-face_yolov3.py", bbox_path)
+
+    if not os.path.exists(os.path.join(sam_path, "sam_vit_b_01ec64.pth")):
+        download_url("https://dl.fbaipublicfiles.com/segment_anything/sam_vit_b_01ec64.pth", sam_path)
+
+    if not os.path.exists(onnx_path):
+        print(f"### ComfyUI-Impact-Pack: onnx model directory created ({onnx_path})")
+        os.mkdir(onnx_path)
+
+    impact_config.write_config(comfy_path)
+
+
+install()

ComfyUI-Impact-Pack/js/impact-pack.js

@@ -0,0 +1,356 @@
+import { app } from "/scripts/app.js";
+import { ComfyDialog, $el } from "/scripts/ui.js";
+import { api } from "/scripts/api.js";
+
+// Helper function to convert a data URL to a Blob object
+function dataURLToBlob(dataURL) {
+  const parts = dataURL.split(';base64,');
+  const contentType = parts[0].split(':')[1];
+  const byteString = atob(parts[1]);
+  const arrayBuffer = new ArrayBuffer(byteString.length);
+  const uint8Array = new Uint8Array(arrayBuffer);
+  for (let i = 0; i < byteString.length; i++) {
+    uint8Array[i] = byteString.charCodeAt(i);
+  }
+  return new Blob([arrayBuffer], { type: contentType });
+}
+
+async function invalidateImage(node, formData) {
+  const filepath = node.images[0];
+
+  await fetch('/upload/temp', {
+    method: 'POST',
+    body: formData
+  }).then(response => {
+  }).catch(error => {
+    console.error('Error:', error);
+  });
+
+  const img = new Image();
+  img.onload = () => {
+    node.imgs = [img];
+    app.graph.setDirtyCanvas(true);
+  };
+
+  img.src = `view?filename=${filepath.filename}&type=${filepath.type}`;;
+}
+
+class ImpactInpaintDialog extends ComfyDialog {
+  constructor() {
+    super();
+		this.element = $el("div.comfy-modal", { parent: document.body }, 
+    [
+			$el("div.comfy-modal-content", 
+        [
+          ...this.createButtons()]),
+		]);
+	}
+
+	createButtons() {
+		return [
+			$el("button", {
+				type: "button",
+				textContent: "Save",
+				onclick: () => {          
+          const backupCtx = this.backupCanvas.getContext('2d', {transparent: true});
+          backupCtx.clearRect(0,0,this.backupCanvas.width,this.backupCanvas.height);
+          backupCtx.drawImage(this.maskCanvas, 
+              0, 0, this.maskCanvas.width, this.maskCanvas.height, 
+              0, 0, this.backupCanvas.width, this.backupCanvas.height);
+              
+          // paste mask data into alpha channel
+          const backupData = backupCtx.getImageData(0, 0, this.backupCanvas.width, this.backupCanvas.height);
+
+          for (let i = 0; i < backupData.data.length; i += 4) {
+            if(backupData.data[i+3] == 255)
+              backupData.data[i+3] = 0;
+            else
+              backupData.data[i+3] = 255;
+              
+            backupData.data[i] = 0;
+            backupData.data[i+1] = 0;
+            backupData.data[i+2] = 0;
+          }
+
+          backupCtx.globalCompositeOperation = 'source-over';
+          backupCtx.putImageData(backupData, 0, 0);
+
+          const dataURL = this.backupCanvas.toDataURL();
+          const blob = dataURLToBlob(dataURL);
+
+          const formData = new FormData();
+          const filename = "impact-mask-" + performance.now() + ".png";
+
+          const item =
+            {
+              "filename": filename,
+              "subfolder": "",
+              "type": "temp",
+            };
+
+          this.node.images[0] = item;
+          this.node.widgets[1].value = item;
+
+          formData.append('image', blob, filename);
+          invalidateImage(this.node, formData);
+          this.close();
+        }
+			}),
+			$el("button", {
+				type: "button",
+				textContent: "Cancel",
+				onclick: () => this.close(),
+			}),
+			$el("button", {
+				type: "button",
+				textContent: "Clear",
+				onclick: () => { 
+          this.maskCtx.clearRect(0, 0, this.maskCanvas.width, this.maskCanvas.height);
+        },
+			}),
+		];
+	}
+
+	show() {
+    const imgCanvas = document.createElement('canvas');
+    const maskCanvas = document.createElement('canvas');
+    const backupCanvas = document.createElement('canvas');
+    imgCanvas.id = "imageCanvas";
+    maskCanvas.id = "maskCanvas";
+    backupCanvas.id = "backupCanvas";
+
+    this.element.appendChild(imgCanvas);
+    this.element.appendChild(maskCanvas);
+
+    this.node.widgets[1].value = null;
+
+    this.element.style.display = "block";
+    imgCanvas.style.position = "relative";
+    imgCanvas.style.top = "200";
+    imgCanvas.style.left = "0";
+
+    maskCanvas.style.position = "absolute";
+    
+    const imgCtx = imgCanvas.getContext('2d');
+    const maskCtx = maskCanvas.getContext('2d');
+    const backupCtx = backupCanvas.getContext('2d');
+
+    this.maskCanvas = maskCanvas;
+    this.maskCtx = maskCtx;
+    this.backupCanvas = backupCanvas;
+    
+    window.addEventListener("resize", () => {
+      // repositioning 
+      imgCanvas.width = window.innerWidth - 250;
+      imgCanvas.height = window.innerHeight - 300;
+      
+      // redraw image
+      let drawWidth = image.width;
+      let drawHeight = image.height;
+      if (image.width > imgCanvas.width) {
+        drawWidth = imgCanvas.width;
+        drawHeight = (drawWidth / image.width) * image.height;
+      }
+      if (drawHeight > imgCanvas.height) {
+        drawHeight = imgCanvas.height;
+        drawWidth = (drawHeight / image.height) * image.width;
+      }
+
+      imgCtx.drawImage(image, 0, 0, drawWidth, drawHeight);
+
+      // update mask
+      backupCtx.drawImage(maskCanvas, 0, 0, maskCanvas.width, maskCanvas.height, 0, 0, backupCanvas.width, backupCanvas.height);
+      
+      maskCanvas.width = drawWidth; 
+      maskCanvas.height = drawHeight;
+      maskCanvas.style.top = imgCanvas.offsetTop + "px";
+      maskCanvas.style.left = imgCanvas.offsetLeft + "px";
+
+      maskCtx.drawImage(backupCanvas, 0, 0, backupCanvas.width, backupCanvas.height, 0, 0, maskCanvas.width, maskCanvas.height);
+    });
+    
+
+    // image load
+    const image = new Image();
+    image.onload = function() {
+        backupCanvas.width = image.width;
+        backupCanvas.height = image.height; 
+        window.dispatchEvent(new Event('resize'));
+    };
+    
+    const filepath = this.node.images[0];
+    image.src = this.node.imgs[0].src;
+    this.image = image;
+
+    
+    // event handler for user drawing ------
+    let brush_size = 10;
+
+    function mouse_down(event) {
+      if (event.buttons === 1) { 
+        const maskRect = maskCanvas.getBoundingClientRect();
+        const x = event.offsetX || event.targetTouches[0].clientX - maskRect.left;
+        const y = event.offsetY || event.targetTouches[0].clientY - maskRect.top;
+
+        maskCtx.beginPath();
+        maskCtx.fillStyle = "rgb(0,0,0)";
+        maskCtx.globalCompositeOperation = "source-over";
+        maskCtx.arc(x, y, brush_size, 0, Math.PI * 2, false);
+        maskCtx.fill();
+      }
+    }
+
+    function mouse_move(event) {
+      if (event.buttons === 1) { 
+        event.preventDefault();
+        const maskRect = maskCanvas.getBoundingClientRect();
+        const x = event.offsetX || event.targetTouches[0].clientX - maskRect.left;
+        const y = event.offsetY || event.targetTouches[0].clientY - maskRect.top;
+
+        maskCtx.beginPath();
+        maskCtx.fillStyle = "rgb(0,0,0)";
+        maskCtx.globalCompositeOperation = "source-over";
+        maskCtx.arc(x, y, brush_size, 0, Math.PI * 2, false);
+        maskCtx.fill();
+      }
+      else if(event.buttons === 2) {
+        event.preventDefault();
+        const maskRect = maskCanvas.getBoundingClientRect();
+        const x = event.offsetX || event.targetTouches[0].clientX - maskRect.left;
+        const y = event.offsetY || event.targetTouches[0].clientY - maskRect.top;
+
+        maskCtx.beginPath();
+        maskCtx.globalCompositeOperation = "destination-out";
+        maskCtx.arc(x, y, brush_size, 0, Math.PI * 2, false);
+        maskCtx.fill();
+      }
+    }
+
+    function touch_move(event) {
+      event.preventDefault();
+      const maskRect = maskCanvas.getBoundingClientRect();
+      const x = event.offsetX || event.targetTouches[0].clientX - maskRect.left;
+      const y = event.offsetY || event.targetTouches[0].clientY - maskRect.top;
+
+      maskCtx.beginPath();
+      maskCtx.fillStyle = "rgb(0,0,0)";
+      maskCtx.globalCompositeOperation = "source-over";
+      maskCtx.arc(x, y, brush_size, 0, Math.PI * 2, false);
+      maskCtx.fill();
+    }
+
+    function handleWheelEvent(event) {
+
+      if(event.deltaY < 0)
+        brush_size = Math.min(brush_size+2, 100);
+      else
+        brush_size = Math.max(brush_size-2, 1);
+    }
+
+    maskCanvas.addEventListener("contextmenu", (event) => {
+      event.preventDefault();
+    });
+    maskCanvas.addEventListener('wheel', handleWheelEvent);
+    maskCanvas.addEventListener('mousedown', mouse_down);
+    maskCanvas.addEventListener('mousemove', mouse_move);
+    maskCanvas.addEventListener('touchmove', touch_move);
+	}
+}
+
+const input_tracking = {};
+const input_dirty = {};
+const output_tracking = {};
+
+function executeHandler(event) {
+	if(event.detail.output.aux){
+		const id = event.detail.node;
+		if(input_tracking.hasOwnProperty(id)) {
+			if(input_tracking.hasOwnProperty(id) && input_tracking[id][0] != event.detail.output.aux[0]) {
+				input_dirty[id] = true;
+			}
+			else{
+
+			}
+		}
+
+		input_tracking[id] = event.detail.output.aux;
+	}
+}
+
+var eventRegistered = false;
+
+app.registerExtension({
+	name: "Comfy.Impack",
+	loadedGraphNode(node, app) {
+		if (node.comfyClass == "PreviewBridge") {
+			if (!eventRegistered) {
+				api.addEventListener("executed", executeHandler);
+				eventRegistered = true;
+			}
+
+			input_dirty[node.id + ""] = false;
+		}
+	},
+	nodeCreated(node, app) {
+		if(node.comfyClass == "MaskPainter") {
+			node.addWidget("button", "Edit mask", null, () => {
+				this.dlg = new ImpactInpaintDialog(app);
+				this.dlg.node = node;
+
+				if('images' in node) {
+					this.dlg.show();
+				}
+			});
+
+			node.addWidget("hidden", "mask_image", null, null);
+		}
+		else if (node.comfyClass == "PreviewBridge") {
+			Object.defineProperty(node, "images", {
+				set: function(value) {
+					node._images = value;
+				},
+				get: function() {
+					const id = node.id+"";
+					if(node.widgets[0].value != '#placeholder') {
+						var need_invalidate = false;
+
+						if(input_dirty.hasOwnProperty(id) && input_dirty[id]) {
+							node.widgets[0].value = {...input_tracking[id][1]};
+							input_dirty[id] = false;
+							need_invalidate = true
+						}
+
+						node.widgets[0].value['image_hash'] = app.nodeOutputs[id]['aux'][0];
+						node.widgets[0].value['forward_filename'] = app.nodeOutputs[id]['aux'][1][0]['filename'];
+						node.widgets[0].value['forward_subfolder'] = app.nodeOutputs[id]['aux'][1][0]['subfolder'];
+						node.widgets[0].value['forward_type'] = app.nodeOutputs[id]['aux'][1][0]['type'];
+						app.nodeOutputs[id].images = [node.widgets[0].value];
+
+						if(need_invalidate) {
+							Promise.all(
+								app.nodeOutputs[id].images.map((src) => {
+									return new Promise((r) => {
+										const img = new Image();
+										img.onload = () => r(img);
+										img.onerror = () => r(null);
+										img.src = "/view?" + new URLSearchParams(src[0]).toString();
+										console.log(`new img => ${img.src}`);
+									});
+								})
+							).then((imgs) => {
+								this.imgs = imgs.filter(Boolean);
+								this.setSizeForImage?.();
+								app.graph.setDirtyCanvas(true);
+							});
+						}
+
+						return app.nodeOutputs[id].images;
+					}
+					else {
+						return node._images;
+					}
+				}
+			});
+		}
+	}
+});

ComfyUI-Impact-Pack/js/impact-sam-editor.js

@@ -0,0 +1,626 @@
+import { app } from "/scripts/app.js";
+import { ComfyDialog, $el } from "/scripts/ui.js";
+import { ComfyApp } from "/scripts/app.js";
+import { ClipspaceDialog } from "/extensions/core/clipspace.js";
+
+function addMenuHandler(nodeType, cb) {
+	const getOpts = nodeType.prototype.getExtraMenuOptions;
+	nodeType.prototype.getExtraMenuOptions = function () {
+		const r = getOpts.apply(this, arguments);
+		cb.apply(this, arguments);
+		return r;
+	};
+}
+
+// Helper function to convert a data URL to a Blob object
+function dataURLToBlob(dataURL) {
+	const parts = dataURL.split(';base64,');
+	const contentType = parts[0].split(':')[1];
+	const byteString = atob(parts[1]);
+	const arrayBuffer = new ArrayBuffer(byteString.length);
+	const uint8Array = new Uint8Array(arrayBuffer);
+	for (let i = 0; i < byteString.length; i++) {
+		uint8Array[i] = byteString.charCodeAt(i);
+	}
+	return new Blob([arrayBuffer], { type: contentType });
+}
+
+function loadedImageToBlob(image) {
+	const canvas = document.createElement('canvas');
+
+	canvas.width = image.width;
+	canvas.height = image.height;
+
+	const ctx = canvas.getContext('2d');
+
+	ctx.drawImage(image, 0, 0);
+
+	const dataURL = canvas.toDataURL('image/png', 1);
+	const blob = dataURLToBlob(dataURL);
+
+	return blob;
+}
+
+async function uploadMask(filepath, formData) {
+	await fetch('/upload/mask', {
+		method: 'POST',
+		body: formData
+	}).then(response => {}).catch(error => {
+		console.error('Error:', error);
+	});
+
+	ComfyApp.clipspace.imgs[ComfyApp.clipspace['selectedIndex']] = new Image();
+	ComfyApp.clipspace.imgs[ComfyApp.clipspace['selectedIndex']].src = `view?filename=${filepath.filename}&type=${filepath.type}`;
+
+	if(ComfyApp.clipspace.images)
+		ComfyApp.clipspace.images[ComfyApp.clipspace['selectedIndex']] = filepath;
+
+	ClipspaceDialog.invalidatePreview();
+}
+
+class ImpactSamEditorDialog extends ComfyDialog {
+	static instance = null;
+
+	static getInstance() {
+		if(!ImpactSamEditorDialog.instance) {
+			ImpactSamEditorDialog.instance = new ImpactSamEditorDialog();
+		}
+
+		return ImpactSamEditorDialog.instance;
+	}
+
+	constructor() {
+		super();
+		this.element = $el("div.comfy-modal", { parent: document.body }, 
+			[ $el("div.comfy-modal-content", 
+				[...this.createButtons()]),
+			]);
+	}
+
+	createButtons() {
+		return [];
+	}
+
+	createButton(name, callback) {
+		var button = document.createElement("button");
+		button.innerText = name;
+		button.addEventListener("click", callback);
+		return button;
+	}
+
+	createLeftButton(name, callback) {
+		var button = this.createButton(name, callback);
+		button.style.cssFloat = "left";
+		button.style.marginRight = "4px";
+		return button;
+	}
+
+	createRightButton(name, callback) {
+		var button = this.createButton(name, callback);
+		button.style.cssFloat = "right";
+		button.style.marginLeft = "4px";
+		return button;
+	}
+
+	createLeftSlider(self, name, callback) {
+		const divElement = document.createElement('div');
+		divElement.id = "sam-confidence-slider";
+		divElement.style.cssFloat = "left";
+		divElement.style.fontFamily = "sans-serif";
+		divElement.style.marginRight = "4px";
+		divElement.style.color = "var(--input-text)";
+		divElement.style.backgroundColor = "var(--comfy-input-bg)";
+		divElement.style.borderRadius = "8px";
+		divElement.style.borderColor = "var(--border-color)";
+		divElement.style.borderStyle = "solid";
+		divElement.style.fontSize = "15px";
+		divElement.style.height = "21px";
+		divElement.style.padding = "1px 6px";
+		divElement.style.display = "flex";
+		divElement.style.position = "relative";
+		divElement.style.top = "2px";
+		self.confidence_slider_input = document.createElement('input');
+		self.confidence_slider_input.setAttribute('type', 'range');
+		self.confidence_slider_input.setAttribute('min', '0');
+		self.confidence_slider_input.setAttribute('max', '100');
+		self.confidence_slider_input.setAttribute('value', '70');
+		const labelElement = document.createElement("label");
+		labelElement.textContent = name;
+
+		divElement.appendChild(labelElement);
+		divElement.appendChild(self.confidence_slider_input);
+
+		self.confidence_slider_input.addEventListener("change", callback);
+
+		return divElement;
+	}
+
+	async detect_and_invalidate_mask_canvas(self) {
+		const mask_img = await self.detect(self);
+
+		const canvas = self.maskCtx.canvas;
+		const ctx = self.maskCtx;
+
+		ctx.clearRect(0, 0, canvas.width, canvas.height);
+
+		await new Promise((resolve, reject) => {
+						self.mask_image = new Image();
+						self.mask_image.onload = function() {
+							ctx.drawImage(self.mask_image, 0, 0, canvas.width, canvas.height);
+							resolve();
+						};
+						self.mask_image.onerror = reject;
+						self.mask_image.src = mask_img.src;
+				});
+	}
+
+	setlayout(imgCanvas, maskCanvas, pointsCanvas) {
+		const self = this;
+
+		// If it is specified as relative, using it only as a hidden placeholder for padding is recommended
+		// to prevent anomalies where it exceeds a certain size and goes outside of the window.
+		var placeholder = document.createElement("div");
+		placeholder.style.position = "relative";
+		placeholder.style.height = "50px";
+
+		var bottom_panel = document.createElement("div");
+		bottom_panel.style.position = "absolute";
+		bottom_panel.style.bottom = "0px";
+		bottom_panel.style.left = "20px";
+		bottom_panel.style.right = "20px";
+		bottom_panel.style.height = "50px";
+
+		var brush = document.createElement("div");
+		brush.id = "sam-brush";
+		brush.style.backgroundColor = "blue";
+		brush.style.outline = "2px solid pink";
+		brush.style.borderRadius = "50%";
+		brush.style.MozBorderRadius = "50%";
+		brush.style.WebkitBorderRadius = "50%";
+		brush.style.position = "absolute";
+		brush.style.zIndex = 100;
+		brush.style.pointerEvents = "none";
+		this.brush = brush;
+		this.element.appendChild(imgCanvas);
+		this.element.appendChild(maskCanvas);
+		this.element.appendChild(pointsCanvas);
+		this.element.appendChild(placeholder); // must below z-index than bottom_panel to avoid covering button
+		this.element.appendChild(bottom_panel);
+		document.body.appendChild(brush);
+		this.brush_size = 5;
+
+		var confidence_slider = this.createLeftSlider(self, "Confidence", (event) => {
+			self.confidence = event.target.value;
+		});
+
+		var clearButton = this.createLeftButton("Clear", () => {
+				self.maskCtx.clearRect(0, 0, self.maskCanvas.width, self.maskCanvas.height);
+				self.pointsCtx.clearRect(0, 0, self.pointsCanvas.width, self.pointsCanvas.height);
+
+				self.prompt_points = [];
+
+				self.invalidatePointsCanvas(self);
+			});
+
+		var detectButton = this.createLeftButton("Detect", () => self.detect_and_invalidate_mask_canvas(self));
+		
+		var cancelButton = this.createRightButton("Cancel", () => {
+				document.removeEventListener("mouseup", ImpactSamEditorDialog.handleMouseUp);
+				document.removeEventListener("keydown", ImpactSamEditorDialog.handleKeyDown);
+				self.close();
+			});
+
+		self.saveButton = this.createRightButton("Save", () => {
+				document.removeEventListener("mouseup", ImpactSamEditorDialog.handleMouseUp);
+				document.removeEventListener("keydown", ImpactSamEditorDialog.handleKeyDown);
+				self.save(self);
+			});
+
+		var undoButton = this.createLeftButton("Undo", () => {
+				if(self.prompt_points.length > 0) {
+					self.prompt_points.pop();
+					self.pointsCtx.clearRect(0, 0, self.pointsCanvas.width, self.pointsCanvas.height);
+					self.invalidatePointsCanvas(self);
+				}
+			});
+
+		bottom_panel.appendChild(clearButton);
+		bottom_panel.appendChild(detectButton);
+		bottom_panel.appendChild(self.saveButton);
+		bottom_panel.appendChild(cancelButton);
+		bottom_panel.appendChild(confidence_slider);
+		bottom_panel.appendChild(undoButton);
+
+		imgCanvas.style.position = "relative";
+		imgCanvas.style.top = "200";
+		imgCanvas.style.left = "0";
+
+		maskCanvas.style.position = "absolute";
+		maskCanvas.style.opacity = 0.5;
+		pointsCanvas.style.position = "absolute";
+	}
+
+	show() {
+		this.mask_image = null;
+		self.prompt_points = [];
+
+		this.message_box = $el("p", ["Please wait a moment while the SAM model and the image are being loaded."]);
+		this.element.appendChild(this.message_box);
+
+		if(self.imgCtx) {
+			self.imgCtx.clearRect(0, 0, self.imageCanvas.width, self.imageCanvas.height);
+		}
+
+		const target_image_path = ComfyApp.clipspace.imgs[ComfyApp.clipspace['selectedIndex']].src;
+		this.load_sam(target_image_path);
+
+		if(!this.is_layout_created) {
+			// layout
+			const imgCanvas = document.createElement('canvas');
+			const maskCanvas = document.createElement('canvas');
+			const pointsCanvas = document.createElement('canvas');
+
+			imgCanvas.id = "imageCanvas";
+			maskCanvas.id = "maskCanvas";
+			pointsCanvas.id = "pointsCanvas";
+
+			this.setlayout(imgCanvas, maskCanvas, pointsCanvas);
+
+			// prepare content
+			this.imgCanvas = imgCanvas;
+			this.maskCanvas = maskCanvas;
+			this.pointsCanvas = pointsCanvas;
+			this.maskCtx = maskCanvas.getContext('2d');
+			this.pointsCtx = pointsCanvas.getContext('2d');
+
+			this.is_layout_created = true;
+
+			// replacement of onClose hook since close is not real close
+			const self = this;
+			const observer = new MutationObserver(function(mutations) {
+			mutations.forEach(function(mutation) {
+					if (mutation.type === 'attributes' && mutation.attributeName === 'style') {
+						if(self.last_display_style && self.last_display_style != 'none' && self.element.style.display == 'none') {
+							ComfyApp.onClipspaceEditorClosed();
+						}
+
+						self.last_display_style = self.element.style.display;
+					}
+				});
+			});
+
+			const config = { attributes: true };
+			observer.observe(this.element, config);
+		}
+
+		this.setImages(target_image_path, this.imgCanvas, this.pointsCanvas);
+
+		if(ComfyApp.clipspace_return_node) {
+			this.saveButton.innerText = "Save to node";
+		}
+		else {
+			this.saveButton.innerText = "Save";
+		}
+		this.saveButton.disabled = true;
+
+		this.element.style.display = "block";
+		this.element.style.zIndex = 8888; // NOTE: alert dialog must be high priority.
+	}
+
+	updateBrushPreview(self, event) {
+		event.preventDefault();
+
+		const centerX = event.pageX;
+		const centerY = event.pageY;
+
+		const brush = self.brush;
+
+		brush.style.width = self.brush_size * 2 + "px";
+		brush.style.height = self.brush_size * 2 + "px";
+		brush.style.left = (centerX - self.brush_size) + "px";
+		brush.style.top = (centerY - self.brush_size) + "px";
+	}
+
+	setImages(target_image_path, imgCanvas, pointsCanvas) {
+		const imgCtx = imgCanvas.getContext('2d');
+		const maskCtx = this.maskCtx;
+		const maskCanvas = this.maskCanvas;
+
+		const self = this;
+
+		// image load
+		const orig_image = new Image();
+		window.addEventListener("resize", () => {
+			// repositioning
+			imgCanvas.width = window.innerWidth - 250;
+			imgCanvas.height = window.innerHeight - 200;
+
+			// redraw image
+			let drawWidth = orig_image.width;
+			let drawHeight = orig_image.height;
+
+			if (orig_image.width > imgCanvas.width) {
+				drawWidth = imgCanvas.width;
+				drawHeight = (drawWidth / orig_image.width) * orig_image.height;
+			}
+
+			if (drawHeight > imgCanvas.height) {
+				drawHeight = imgCanvas.height;
+				drawWidth = (drawHeight / orig_image.height) * orig_image.width;
+			}
+
+			imgCtx.drawImage(orig_image, 0, 0, drawWidth, drawHeight);
+
+			// update mask
+			pointsCanvas.width = drawWidth;
+			pointsCanvas.height = drawHeight;
+			pointsCanvas.style.top = imgCanvas.offsetTop + "px";
+			pointsCanvas.style.left = imgCanvas.offsetLeft + "px";
+
+			maskCanvas.width = drawWidth;
+			maskCanvas.height = drawHeight;
+			maskCanvas.style.top = imgCanvas.offsetTop + "px";
+			maskCanvas.style.left = imgCanvas.offsetLeft + "px";
+
+			self.invalidateMaskCanvas(self);
+			self.invalidatePointsCanvas(self);
+		});
+
+		// original image load
+		orig_image.onload = () => self.onLoaded(self);
+		const rgb_url = new URL(target_image_path);
+		rgb_url.searchParams.delete('channel');
+		rgb_url.searchParams.set('channel', 'rgb');
+		orig_image.src = rgb_url;
+		self.image = orig_image;
+	}
+
+	onLoaded(self) {
+		if(self.message_box) {
+			self.element.removeChild(self.message_box);
+			self.message_box = null;
+		}
+
+		window.dispatchEvent(new Event('resize'));
+
+		self.setEventHandler(pointsCanvas);
+		self.saveButton.disabled = false;
+	}
+
+	setEventHandler(targetCanvas) {
+		targetCanvas.addEventListener("contextmenu", (event) => {
+			event.preventDefault();
+		});
+
+		const self = this;
+		targetCanvas.addEventListener('pointermove', (event) => this.updateBrushPreview(self,event));
+		targetCanvas.addEventListener('pointerdown', (event) => this.handlePointerDown(self,event));
+		targetCanvas.addEventListener('pointerover', (event) => { this.brush.style.display = "block"; });
+		targetCanvas.addEventListener('pointerleave', (event) => { this.brush.style.display = "none"; });
+		document.addEventListener('keydown', ImpactSamEditorDialog.handleKeyDown);
+	}
+
+	static handleKeyDown(event) {
+		const self = ImpactSamEditorDialog.instance;
+		if (event.key === '=') { // positive
+			brush.style.backgroundColor = "blue";
+			brush.style.outline = "2px solid pink";
+			self.is_positive_mode = true;
+		} else if (event.key === '-') { // negative
+			brush.style.backgroundColor = "red";
+			brush.style.outline = "2px solid skyblue";
+			self.is_positive_mode = false;
+		}
+	}
+
+	is_positive_mode = true;
+	prompt_points = [];
+	confidence = 70;
+
+	invalidatePointsCanvas(self) {
+		const ctx = self.pointsCtx;
+
+		for (const i in self.prompt_points) {
+			const [is_positive, x, y] = self.prompt_points[i];
+
+			const scaledX = x * ctx.canvas.width / self.image.width;
+			const scaledY = y * ctx.canvas.height / self.image.height;
+
+			if(is_positive)
+				ctx.fillStyle = "blue";
+			else
+				ctx.fillStyle = "red";
+			ctx.beginPath();
+			ctx.arc(scaledX, scaledY, 3, 0, 3 * Math.PI);
+			ctx.fill();
+		}
+	}줘
+
+	invalidateMaskCanvas(self) {
+		if(self.mask_image) {
+			self.maskCtx.clearRect(0, 0, self.maskCanvas.width, self.maskCanvas.height);
+			self.maskCtx.drawImage(self.mask_image, 0, 0, self.maskCanvas.width, self.maskCanvas.height);
+		}
+	}
+
+	async load_sam(url) {
+		const parsedUrl = new URL(url);
+		const searchParams = new URLSearchParams(parsedUrl.search);
+
+		const filename = searchParams.get("filename") || "";
+		const fileType = searchParams.get("type") || "";
+		const subfolder = searchParams.get("subfolder") || "";
+
+		const data = {
+				sam_model_name: "sam_vit_b_01ec64.pth",
+				filename: filename,
+				type: fileType,
+				subfolder: subfolder
+			};
+
+		fetch('/sam/prepare', {
+			method: 'POST',
+			headers: { 'Content-Type': 'application/json' },
+			body: JSON.stringify(data)
+		});
+	}
+
+	async detect(self) {
+		const positive_points = [];
+		const negative_points = [];
+
+		for(const i in self.prompt_points) {
+			const [is_positive, x, y] = self.prompt_points[i];
+			const point = [x,y];
+			if(is_positive)
+				positive_points.push(point);
+			else
+				negative_points.push(point);
+		}
+
+		const data = {
+			positive_points: positive_points,
+			negative_points: negative_points,
+			threshold: self.confidence/100
+		};
+		
+		const response = await fetch('/sam/detect', {
+			method: 'POST',
+			headers: { 'Content-Type': 'image/png' },
+			body: JSON.stringify(data)
+		});
+		
+		const blob = await response.blob();
+		const url = URL.createObjectURL(blob);
+
+		return new Promise((resolve, reject) => {
+			const image = new Image();
+			image.onload = () => resolve(image);
+			image.onerror = reject;
+			image.src = url;
+		});
+	}
+
+	handlePointerDown(self, event) {
+		if ([0, 2, 5].includes(event.button)) {
+			event.preventDefault();
+			const x = event.offsetX || event.targetTouches[0].clientX - maskRect.left;
+			const y = event.offsetY || event.targetTouches[0].clientY - maskRect.top;
+
+			const originalX = x * self.image.width / self.pointsCanvas.width;
+			const originalY = y * self.image.height / self.pointsCanvas.height;
+
+			var point = null;
+			if (event.button == 0) {
+				// positive
+				point = [true, originalX, originalY];
+			} else {
+				// negative
+				point = [false, originalX, originalY];
+			}
+
+			self.prompt_points.push(point);
+
+			self.invalidatePointsCanvas(self);
+		}
+	}
+
+	async save(self) {
+		if(!self.mask_image) {
+			this.close();
+			return;
+		}
+
+		const save_canvas = document.createElement('canvas');
+
+		const save_ctx = save_canvas.getContext('2d', {willReadFrequently:true});
+		save_canvas.width = self.mask_image.width;
+		save_canvas.height = self.mask_image.height;
+
+		save_ctx.drawImage(self.mask_image, 0, 0, save_canvas.width, save_canvas.height);
+
+		const save_data = save_ctx.getImageData(0, 0, save_canvas.width, save_canvas.height);
+
+		// refine mask image
+		for (let i = 0; i < save_data.data.length; i += 4) {
+			if(save_data.data[i]) {
+				save_data.data[i+3] = 0;
+			}
+			else {
+				save_data.data[i+3] = 255;
+			}
+
+			save_data.data[i] = 0;
+			save_data.data[i+1] = 0;
+			save_data.data[i+2] = 0;
+		}
+
+		save_ctx.globalCompositeOperation = 'source-over';
+		save_ctx.putImageData(save_data, 0, 0);
+
+		const formData = new FormData();
+		const filename = "clipspace-mask-" + performance.now() + ".png";
+
+		const item =
+			{
+				"filename": filename,
+				"subfolder": "",
+				"type": "temp",
+			};
+
+		if(ComfyApp.clipspace.images)
+			ComfyApp.clipspace.images[0] = item;
+
+		if(ComfyApp.clipspace.widgets) {
+			const index = ComfyApp.clipspace.widgets.findIndex(obj => obj.name === 'image');
+
+			if(index >= 0)
+				ComfyApp.clipspace.widgets[index].value = item;
+		}
+
+		const dataURL = save_canvas.toDataURL();
+		const blob = dataURLToBlob(dataURL);
+
+		const original_blob = loadedImageToBlob(this.image);
+
+		formData.append('image', blob, filename);
+		formData.append('original_image', original_blob);
+		formData.append('type', "temp");
+
+		await uploadMask(item, formData);
+		ComfyApp.onClipspaceEditorSave();
+		this.close();
+	}
+}
+
+app.registerExtension({
+	name: "Comfy.Impact.SAMEditor",
+	init(app) {
+		const callback =
+			function () {
+				let dlg = ImpactSamEditorDialog.getInstance();
+				dlg.show();
+			};
+
+		const context_predicate = () => ComfyApp.clipspace && ComfyApp.clipspace.imgs && ComfyApp.clipspace.imgs.length > 0
+		ClipspaceDialog.registerButton("Impact SAM Detector", context_predicate, callback);
+	},
+
+	async beforeRegisterNodeDef(nodeType, nodeData, app) {
+		if (nodeData.output.includes("MASK") && nodeData.output.includes("IMAGE")) {
+			addMenuHandler(nodeType, function (_, options) {
+				options.unshift({
+					content: "Open in SAM Detector",
+					callback: () => {
+						ComfyApp.copyToClipspace(this);
+						ComfyApp.clipspace_return_node = this;
+
+						let dlg = ImpactSamEditorDialog.getInstance();
+						dlg.show();
+					},
+				});
+			});
+		}
+	}
+});
+

ComfyUI-Impact-Pack/legacy_nodes.py

@@ -0,0 +1,258 @@
+import folder_paths
+import impact_core as core
+from impact_utils import *
+from impact_core import SEG
+import nodes
+import os
+
+class NO_BBOX_MODEL:
+    pass
+
+
+class NO_SEGM_MODEL:
+    pass
+
+
+class MMDetLoader:
+    @classmethod
+    def INPUT_TYPES(s):
+        bboxs = ["bbox/"+x for x in folder_paths.get_filename_list("mmdets_bbox")]
+        segms = ["segm/"+x for x in folder_paths.get_filename_list("mmdets_segm")]
+        return {"required": {"model_name": (bboxs + segms, )}}
+    RETURN_TYPES = ("BBOX_MODEL", "SEGM_MODEL")
+    FUNCTION = "load_mmdet"
+
+    CATEGORY = "ImpactPack/Legacy"
+
+    def load_mmdet(self, model_name):
+        mmdet_path = folder_paths.get_full_path("mmdets", model_name)
+        model = core.load_mmdet(mmdet_path)
+
+        if model_name.startswith("bbox"):
+            return model, NO_SEGM_MODEL()
+        else:
+            return NO_BBOX_MODEL(), model
+
+
+class BboxDetectorForEach:
+    @classmethod
+    def INPUT_TYPES(s):
+        return {"required": {
+                        "bbox_model": ("BBOX_MODEL", ),
+                        "image": ("IMAGE", ),
+                        "threshold": ("FLOAT", {"default": 0.5, "min": 0.0, "max": 1.0, "step": 0.01}),
+                        "dilation": ("INT", {"default": 10, "min": 0, "max": 255, "step": 1}),
+                        "crop_factor": ("FLOAT", {"default": 3.0, "min": 1.0, "max": 10, "step": 0.1}),
+                      }
+                }
+
+    RETURN_TYPES = ("SEGS", )
+    FUNCTION = "doit"
+
+    CATEGORY = "ImpactPack/Legacy"
+
+    @staticmethod
+    def detect(bbox_model, image, threshold, dilation, crop_factor, drop_size=1):
+        mmdet_results = core.inference_bbox(bbox_model, image, threshold)
+        segmasks = core.create_segmasks(mmdet_results)
+
+        if dilation > 0:
+            segmasks = dilate_masks(segmasks, dilation)
+
+        items = []
+        h = image.shape[1]
+        w = image.shape[2]
+        for x in segmasks:
+            item_bbox = x[0]
+            item_mask = x[1]
+
+            y1, x1, y2, x2 = item_bbox
+
+            if x2 - x1 > drop_size and y2 - y1 > drop_size:
+                crop_region = make_crop_region(w, h, item_bbox, crop_factor)
+                cropped_image = crop_image(image, crop_region)
+                cropped_mask = crop_ndarray2(item_mask, crop_region)
+                confidence = x[2]
+                # bbox_size = (item_bbox[2]-item_bbox[0],item_bbox[3]-item_bbox[1]) # (w,h)
+
+                item = SEG(cropped_image, cropped_mask, confidence, crop_region, item_bbox)
+                items.append(item)
+
+        shape = h, w
+        return shape, items
+
+    def doit(self, bbox_model, image, threshold, dilation, crop_factor):
+        return (BboxDetectorForEach.detect(bbox_model, image, threshold, dilation, crop_factor), )
+
+
+class SegmDetectorCombined:
+    @classmethod
+    def INPUT_TYPES(s):
+        return {"required": {
+                        "segm_model": ("SEGM_MODEL", ),
+                        "image": ("IMAGE", ),
+                        "threshold": ("FLOAT", {"default": 0.5, "min": 0.0, "max": 1.0, "step": 0.01}),
+                        "dilation": ("INT", {"default": 0, "min": 0, "max": 255, "step": 1}),
+                      }
+                }
+
+    RETURN_TYPES = ("MASK",)
+    FUNCTION = "doit"
+
+    CATEGORY = "ImpactPack/Legacy"
+
+    def doit(self, segm_model, image, threshold, dilation):
+        mmdet_results = core.inference_segm(image, segm_model, threshold)
+        segmasks = core.create_segmasks(mmdet_results)
+        if dilation > 0:
+            segmasks = dilate_masks(segmasks, dilation)
+
+        mask = combine_masks(segmasks)
+        return (mask,)
+
+
+class BboxDetectorCombined(SegmDetectorCombined):
+    @classmethod
+    def INPUT_TYPES(s):
+        return {"required": {
+                        "bbox_model": ("BBOX_MODEL", ),
+                        "image": ("IMAGE", ),
+                        "threshold": ("FLOAT", {"default": 0.5, "min": 0.0, "max": 1.0, "step": 0.01}),
+                        "dilation": ("INT", {"default": 4, "min": 0, "max": 255, "step": 1}),
+                      }
+                }
+
+    def doit(self, bbox_model, image, threshold, dilation):
+        mmdet_results = core.inference_bbox(bbox_model, image, threshold)
+        segmasks = core.create_segmasks(mmdet_results)
+        if dilation > 0:
+            segmasks = dilate_masks(segmasks, dilation)
+
+        mask = combine_masks(segmasks)
+        return (mask,)
+
+
+class SegmDetectorForEach:
+    @classmethod
+    def INPUT_TYPES(s):
+        return {"required": {
+                        "segm_model": ("SEGM_MODEL", ),
+                        "image": ("IMAGE", ),
+                        "threshold": ("FLOAT", {"default": 0.5, "min": 0.0, "max": 1.0, "step": 0.01}),
+                        "dilation": ("INT", {"default": 10, "min": 0, "max": 255, "step": 1}),
+                        "crop_factor": ("FLOAT", {"default": 3.0, "min": 1.0, "max": 10, "step": 0.1}),
+                      }
+                }
+
+    RETURN_TYPES = ("SEGS", )
+    FUNCTION = "doit"
+
+    CATEGORY = "ImpactPack/Legacy"
+
+    def doit(self, segm_model, image, threshold, dilation, crop_factor):
+        mmdet_results = core.inference_segm(image, segm_model, threshold)
+        segmasks = core.create_segmasks(mmdet_results)
+
+        if dilation > 0:
+            segmasks = dilate_masks(segmasks, dilation)
+
+        items = []
+        h = image.shape[1]
+        w = image.shape[2]
+        for x in segmasks:
+            item_bbox = x[0]
+            item_mask = x[1]
+
+            crop_region = make_crop_region(w, h, item_bbox, crop_factor)
+            cropped_image = crop_image(image, crop_region)
+            cropped_mask = crop_ndarray2(item_mask, crop_region)
+            confidence = x[2]
+
+            item = SEG(cropped_image, cropped_mask, confidence, crop_region, item_bbox)
+            items.append(item)
+
+        shape = h,w
+        return ((shape, items), )
+
+
+class SegsMaskCombine:
+    @classmethod
+    def INPUT_TYPES(s):
+        return {"required": {
+                        "segs": ("SEGS", ),
+                        "image": ("IMAGE", ),
+                      }
+                }
+
+    RETURN_TYPES = ("MASK",)
+    FUNCTION = "doit"
+
+    CATEGORY = "ImpactPack/Legacy"
+
+    @staticmethod
+    def combine(segs, image):
+        h = image.shape[1]
+        w = image.shape[2]
+
+        mask = np.zeros((h, w), dtype=np.uint8)
+
+        for seg in segs[1]:
+            cropped_mask = seg.cropped_mask
+            crop_region = seg.crop_region
+            mask[crop_region[1]:crop_region[3], crop_region[0]:crop_region[2]] |= (cropped_mask * 255).astype(np.uint8)
+
+        return torch.from_numpy(mask.astype(np.float32) / 255.0)
+
+    def doit(self, segs, image):
+        return (SegsMaskCombine.combine(segs, image), )
+
+
+class MaskPainter(nodes.PreviewImage):
+    @classmethod
+    def INPUT_TYPES(s):
+        return {"required": {"images": ("IMAGE",), },
+                "hidden": {
+                    "prompt": "PROMPT",
+                    "extra_pnginfo": "EXTRA_PNGINFO",
+                },
+                "optional": {"mask_image": ("IMAGE_PATH",), },
+                }
+
+    RETURN_TYPES = ("MASK",)
+
+    FUNCTION = "save_painted_images"
+
+    CATEGORY = "ImpactPack/Legacy"
+
+    def load_mask(self, imagepath):
+        if imagepath['type'] == "temp":
+            input_dir = folder_paths.get_temp_directory()
+        else:
+            input_dir = folder_paths.get_input_directory()
+
+        image_path = os.path.join(input_dir, imagepath['filename'])
+
+        if os.path.exists(image_path):
+            i = Image.open(image_path)
+
+            if 'A' in i.getbands():
+                mask = np.array(i.getchannel('A')).astype(np.float32) / 255.0
+                mask = 1. - torch.from_numpy(mask)
+            else:
+                mask = torch.zeros((8, 8), dtype=torch.float32, device="cpu")
+        else:
+            mask = torch.zeros((8, 8), dtype=torch.float32, device="cpu")
+
+        return (mask,)
+
+    def save_painted_images(self, images, filename_prefix="impact-mask",
+                            prompt=None, extra_pnginfo=None, mask_image=None):
+        res = self.save_images(images, filename_prefix, prompt, extra_pnginfo)
+
+        if mask_image is not None:
+            res['result'] = self.load_mask(mask_image)
+        else:
+            mask = torch.zeros((8, 8), dtype=torch.float32, device="cpu")
+            res['result'] = (mask,)
+
+        return res

ComfyUI-Impact-Pack/notebook/comfyui_colab_impact_pack.ipynb

@@ -0,0 +1,172 @@
+{
+  "cells": [
+    {
+      "attachments": {},
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "aaaaaaaaaa"
+      },
+      "source": [
+        "Git clone the repo and install the requirements. (ignore the pip errors about protobuf)"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "bbbbbbbbbb"
+      },
+      "outputs": [],
+      "source": [
+        "#@title Environment Setup\n",
+        "\n",
+        "from pathlib import Path\n",
+        "\n",
+        "OPTIONS = {}\n",
+        "\n",
+        "WORKSPACE = 'ComfyUI'\n",
+        "USE_GOOGLE_DRIVE = True  #@param {type:\"boolean\"}\n",
+        "UPDATE_COMFY_UI = True  #@param {type:\"boolean\"}\n",
+        "\n",
+        "OPTIONS['USE_GOOGLE_DRIVE'] = USE_GOOGLE_DRIVE\n",
+        "OPTIONS['UPDATE_COMFY_UI'] = UPDATE_COMFY_UI\n",
+        "\n",
+        "if OPTIONS['USE_GOOGLE_DRIVE']:\n",
+        "    !echo \"Mounting Google Drive...\"\n",
+        "    %cd /\n",
+        "    \n",
+        "    from google.colab import drive\n",
+        "    drive.mount('/content/drive')\n",
+        "\n",
+        "    WORKSPACE = \"/content/drive/MyDrive/ComfyUI\"\n",
+        "    \n",
+        "    %cd /content/drive/MyDrive\n",
+        "\n",
+        "![ ! -d $WORKSPACE ] && echo \"-= Initial setup ComfyUI (Original)=-\" && git clone https://github.com/comfyanonymous/ComfyUI\n",
+        "%cd $WORKSPACE\n",
+        "\n",
+        "if OPTIONS['UPDATE_COMFY_UI']:\n",
+        "  !echo \"-= Updating ComfyUI =-\"\n",
+        "  !git pull\n",
+        "  !rm \"/content/drive/MyDrive/ComfyUI/custom_nodes/comfyui-impact-pack.py\"\n",
+        "\n",
+        "%cd custom_nodes\n",
+        "!git clone https://github.com/ltdrdata/ComfyUI-Impact-Pack\n",
+        "%cd $WORKSPACE\n",
+        "\n",
+        "!echo -= Install dependencies =-\n",
+        "!pip -q install xformers -r requirements.txt\n"
+      ]
+    },
+    {
+      "attachments": {},
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "kkkkkkkkkkkkkk"
+      },
+      "source": [
+        "### Run ComfyUI with localtunnel (Recommended Way)\n",
+        "\n",
+        "\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "jjjjjjjjjjjjj",
+        "outputId": "83be9411-d939-4813-e6c1-80e75bf8e80d"
+      },
+      "outputs": [],
+      "source": [
+        "!npm install -g localtunnel\n",
+        "\n",
+        "import subprocess\n",
+        "import threading\n",
+        "import time\n",
+        "import socket\n",
+        "def iframe_thread(port):\n",
+        "  while True:\n",
+        "      time.sleep(0.5)\n",
+        "      sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)\n",
+        "      result = sock.connect_ex(('127.0.0.1', port))\n",
+        "      if result == 0:\n",
+        "        break\n",
+        "      sock.close()\n",
+        "  print(\"\\nComfyUI finished loading, trying to launch localtunnel (if it gets stuck here localtunnel is having issues)\")\n",
+        "  p = subprocess.Popen([\"lt\", \"--port\", \"{}\".format(port)], stdout=subprocess.PIPE)\n",
+        "  for line in p.stdout:\n",
+        "    print(line.decode(), end='')\n",
+        "\n",
+        "\n",
+        "threading.Thread(target=iframe_thread, daemon=True, args=(8188,)).start()\n",
+        "\n",
+        "!python main.py --dont-print-server"
+      ]
+    },
+    {
+      "attachments": {},
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "gggggggggg"
+      },
+      "source": [
+        "### Run ComfyUI with colab iframe (use only in case the previous way with localtunnel doesn't work)\n",
+        "\n",
+        "You should see the ui appear in an iframe. If you get a 403 error, it's your firefox settings or an extension that's messing things up.\n",
+        "\n",
+        "If you want to open it in another window use the link.\n",
+        "\n",
+        "Note that some UI features like live image previews won't work because the colab iframe blocks websockets."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "hhhhhhhhhh"
+      },
+      "outputs": [],
+      "source": [
+        "import threading\n",
+        "import time\n",
+        "import socket\n",
+        "def iframe_thread(port):\n",
+        "  while True:\n",
+        "      time.sleep(0.5)\n",
+        "      sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)\n",
+        "      result = sock.connect_ex(('127.0.0.1', port))\n",
+        "      if result == 0:\n",
+        "        break\n",
+        "      sock.close()\n",
+        "  from google.colab import output\n",
+        "  output.serve_kernel_port_as_iframe(port, height=1024)\n",
+        "  print(\"to open it in a window you can open this link here:\")\n",
+        "  output.serve_kernel_port_as_window(port)\n",
+        "\n",
+        "threading.Thread(target=iframe_thread, daemon=True, args=(8188,)).start()\n",
+        "\n",
+        "!python main.py --dont-print-server"
+      ]
+    }
+  ],
+  "metadata": {
+    "accelerator": "GPU",
+    "colab": {
+      "provenance": []
+    },
+    "gpuClass": "standard",
+    "kernelspec": {
+      "display_name": "Python 3",
+      "name": "python3"
+    },
+    "language_info": {
+      "name": "python"
+    }
+  },
+  "nbformat": 4,
+  "nbformat_minor": 0
+}

ComfyUI-Impact-Pack/onnx.py

@@ -0,0 +1,38 @@
+import additional_dependencies
+from impact_utils import *
+
+additional_dependencies.ensure_onnx_package()
+
+try:
+    import onnxruntime
+
+    def onnx_inference(image, onnx_model):
+        # prepare image
+        pil = tensor2pil(image)
+        image = np.ascontiguousarray(pil)
+        image = image[:, :, ::-1]  # to BGR image
+        image = image.astype(np.float32)
+        image -= [103.939, 116.779, 123.68]  # 'caffe' mode image preprocessing
+
+        # do detection
+        onnx_model = onnxruntime.InferenceSession(onnx_model)
+        outputs = onnx_model.run(
+            [s_i.name for s_i in onnx_model.get_outputs()],
+            {onnx_model.get_inputs()[0].name: np.expand_dims(image, axis=0)},
+        )
+
+        labels = [op for op in outputs if op.dtype == "int32"][0]
+        scores = [op for op in outputs if isinstance(op[0][0], np.float32)][0]
+        boxes = [op for op in outputs if isinstance(op[0][0], np.ndarray)][0]
+
+        # filter-out useless item
+        idx = np.where(labels[0] == -1)[0][0]
+
+        labels = labels[0][:idx]
+        scores = scores[0][:idx]
+        boxes = boxes[0][:idx].astype(np.uint32)
+
+        return labels, scores, boxes
+except Exception as e:
+    print("[ERROR] ComfyUI-Impact-Pack: 'onnxruntime' package doesn't support 'python 3.11', yet.")
+    print(f"\t{e}")

ComfyUI-Impact-Pack/requirements.txt

@@ -0,0 +1,3 @@
+openmim
+segment-anything
+scikit-image

ComfyUI-Impact-Pack/troubleshooting/TROUBLESHOOTING.md

@@ -0,0 +1,8 @@
+## Destortion on Detailer
+
+* Please also note that this issue may be caused by a bug in xformers 0.0.18. If you encounter this problem, please try adjusting the guide_size parameter.
+
+![example](black1.png)
+
+![example](black2.png)
+* guide_size changed from 256 -> 192