[
  {
    "path": ".gitignore",
    "content": "# Byte-compiled / optimized / DLL files\n__pycache__/\n*.py[cod]\n*$py.class\n\n# models\nmodels/\n\n# C extensions\n*.so\n\n# Distribution / packaging\n.Python\nbuild/\ndevelop-eggs/\ndist/\ndownloads/\neggs/\n.eggs/\nlib/\nlib64/\nparts/\nsdist/\nvar/\nwheels/\nshare/python-wheels/\n*.egg-info/\n.installed.cfg\n*.egg\nMANIFEST\n\n# PyInstaller\n#  Usually these files are written by a python script from a template\n#  before PyInstaller builds the exe, so as to inject date/other infos into it.\n*.manifest\n*.spec\n\n# Installer logs\npip-log.txt\npip-delete-this-directory.txt\n\n# Unit test / coverage reports\nhtmlcov/\n.tox/\n.nox/\n.coverage\n.coverage.*\n.cache\nnosetests.xml\ncoverage.xml\n*.cover\n*.py,cover\n.hypothesis/\n.pytest_cache/\ncover/\n\n# Translations\n*.mo\n*.pot\n\n# Django stuff:\n*.log\nlocal_settings.py\ndb.sqlite3\ndb.sqlite3-journal\n\n# Flask stuff:\ninstance/\n.webassets-cache\n\n# Scrapy stuff:\n.scrapy\n\n# Sphinx documentation\ndocs/_build/\n\n# PyBuilder\n.pybuilder/\ntarget/\n\n# Jupyter Notebook\n.ipynb_checkpoints\n\n# IPython\nprofile_default/\nipython_config.py\n\n# pyenv\n#   For a library or package, you might want to ignore these files since the code is\n#   intended to run in multiple environments; otherwise, check them in:\n# .python-version\n\n# pipenv\n#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.\n#   However, in case of collaboration, if having platform-specific dependencies or dependencies\n#   having no cross-platform support, pipenv may install dependencies that don't work, or not\n#   install all needed dependencies.\n#Pipfile.lock\n\n# poetry\n#   Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control.\n#   This is especially recommended for binary packages to ensure reproducibility, and is more\n#   commonly ignored for libraries.\n#   https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control\n#poetry.lock\n\n# pdm\n#   Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control.\n#pdm.lock\n#   pdm stores project-wide configurations in .pdm.toml, but it is recommended to not include it\n#   in version control.\n#   https://pdm.fming.dev/#use-with-ide\n.pdm.toml\n\n# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm\n__pypackages__/\n\n# Celery stuff\ncelerybeat-schedule\ncelerybeat.pid\n\n# SageMath parsed files\n*.sage.py\n\n# Environments\n.env\n.venv\nenv/\nvenv/\nENV/\nenv.bak/\nvenv.bak/\n\n# Spyder project settings\n.spyderproject\n.spyproject\n\n# Rope project settings\n.ropeproject\n\n# mkdocs documentation\n/site\n\n# mypy\n.mypy_cache/\n.dmypy.json\ndmypy.json\n\n# Pyre type checker\n.pyre/\n\n# pytype static type analyzer\n.pytype/\n\n# Cython debug symbols\ncython_debug/\n\n# PyCharm\n#  JetBrains specific template is maintained in a separate JetBrains.gitignore that can\n#  be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore\n#  and can be added to the global gitignore or merged into this file.  For a more nuclear\n#  option (not recommended) you can uncomment the following to ignore the entire idea folder.\n#.idea/\n"
  },
  {
    "path": "LICENSE",
    "content": "MIT License\n\nCopyright (c) 2023 spacepxl\n\nPermission is hereby granted, free of charge, to any person obtaining a copy\nof this software and associated documentation files (the \"Software\"), to deal\nin the Software without restriction, including without limitation the rights\nto use, copy, modify, merge, publish, distribute, sublicense, and/or sell\ncopies of the Software, and to permit persons to whom the Software is\nfurnished to do so, subject to the following conditions:\n\nThe above copyright notice and this permission notice shall be included in all\ncopies or substantial portions of the Software.\n\nTHE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\nIMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\nFITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\nAUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\nLIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\nOUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\nSOFTWARE.\n"
  },
  {
    "path": "README.md",
    "content": "## ComfyUI-Image-Filters\n\nStarted as just some image processing nodes, but now more of a kitchen sink nodepack\n\nTwo install batch files are provided, `install.bat` which only installs requirements, and `import_error_install.bat`, which uninstalls all versions of opencv then reinstalls all 4 variants with matching version (use this if you get import errors relating to opencv or cv2, which are caused by manager or other node packs installing different variants and/or versions.)\n\nOr if you want to manage requirements manually, the only opencv variant you actually need is `opencv-contrib-python`, it covers all opencv requirements.\n\n## Nodes\n\n<details><summary>Latent</summary>\n\n### AdaIN Latent\n\nNormalizes latents to the mean and std dev of a reference input. Useful for getting rid of color shift from high denoise strength, or matching color to a reference in general.\n\n### AdaIN Filter Latent\n\nSame as AdaIN Latent, but with a spatial filter instead of the full frame, works like a latent color match.\n\n### Batch Normalize Latent\n\nNormalizes each frame in a batch to the overall mean and std dev, good for removing overall brightness flickering.\n\n### Clamp Outliers\n\nClamps latents that are more than n standard deviations away from the mean. Could help with fireflies or stray noise that disrupt the VAE decode.\n\n### Upscale Hunyuan3Dv2 Latent By\n\nNearest Neighbor upscaling for Hy3D latents, might be useful for hires fix.\n\n### Latent Normalize/Shuffle\n\nCan help break up residual image information in inversion noise.\n\n### RandnLikeLatent\n\nCreate random noise in the same shape as the input latent, works with any latent. Useful for noise injection or other times when you just want to control noise manually.\n\n### Offset Latent Image\n\nCreate an empty latent image with custom values, for offset noise with per-channel control. Can be combined with Latent Stats to get channel values.\n\n### Sharpen Filter (Latent)\n\nIncreases local contrast between latent \"pixels\" with an image sharpening filter.\n\n</details>\n\n<details><summary>Image</summary>\n\n### AdaIN Image\n\nNormalizes images to the mean and std dev of a reference input. Useful for getting rid of color shift from high denoise strength, or matching color to a reference in general.\n\n### Batch Align (RAFT)\n\nUse RAFT motion vectors to warp align images\n\n### Batch Average Image\n\nReturns the single average image of a batch.\n\n### Batch Normalize Image\n\nNormalizes each frame in a batch to the overall mean and std dev, good for removing overall brightness flickering.\n\n### BetterFilmGrain\n\nYet another film grain node, but this one looks better (realistic grain structure, no pixel-perfect RGB glitter, natural luminance/intensity response) and is 10x faster than the next best option (ProPostFilmGrain).\n\n### Bilateral Filter Image\n\nApplies a bilateral filter, can be used to remove noise or high frequency details while preserving edges\n\n### Blur Image (Fast)\n\nBlurs images using opencv gaussian blur, which is >100x faster than comfy image blur. Supports larger blur radius, and separate x/y controls.\n\n### Clamp Image\n\nClamps image values outside of blackpoint/whitepoint range\n\n### Color Match Image\n\nMatch image color to reference image, using overall mean or blurred image (frequency separation)\n\n### Convert Normals\n\nTranslate between different normal map color spaces, with optional normalization fix and black region fix.\n\n### Depth to Normals\n\nConverts depthmap to normal map\n\n### Difference Checker\n\nAbsolute value of the difference between inputs, with a multiplier to boost dark values for easier viewing. Alternative to the vanilla merge difference node, which is only subtraction without the abs()\n\n### Enhance Detail\n\nIncrease or decrease details in an image or batch of images using a guided filter (as opposed to the typical gaussian blur used by most sharpening filters)\n\n### Exposure Adjust\n\nLinear exposure adjustment in f-stops, with optional tonemap.\n\n### Frequency Separate/Combine\n\nFor manual frequency separation workflows\n\n### Game of Life\n\nRuns the Game of Life simulation with optional mask input for starting condition\n\n### Guided Filter Image\n\nUse a guided filter to blur an image or mask based on RGB color similarity. Works best with a strong color separation between FG and BG.\n\n### Image Constant Color (RGB/HSV)\n\nCreate images of any solid color, from either RGB or HSV values\n\n### Image Matting\n\nTakes an image and trimap/mask, and refines the matte edges with [closed-form matting](https://github.com/pymatting/pymatting). Optionally extracts the foreground and background colors as well. Good for cleaning up SAM segments or hand drawn masks.\n\n### Keyer\n\nBasic image keyer with luma/sat/channel/greenscreen/etc options\n\n### Median Filter Image\n\nApplies a median filter to remove high frequency information from images, useful for frequency separation workflows\n\n### Normal Map (Simple)\n\nSimple high-frequency normal map from Scharr operator\n\n### Relight (Simple)\n\nBasic dot product (Lambertian) relighting from a normal map\n\n### Remap Range\n\nFits the color range of an image to a new blackpoint and whitepoint (clamped)\n\n### Restore Detail\n\nTransfers details from one image to another using frequency separation. Useful for restoring the lost details from IC-Light or other img2img workflows. Has options for add/subtract method (fewer artifacts, but mostly ignores highlights) or divide/multiply (more natural but can create artifacts in areas that go from dark to bright), and either gaussian blur or guided filter (prevents oversharpened edges)\n\n### Shuffle Channels\n\nMove channels around at will.\n\n### Tonemap / UnTonemap\n\nApply or remove a log + contrast curve tonemap\n\nApply tonemap:\n```\npower = 1.7\nSLog3R = clamp((log10((r + 0.01)/0.19) * 261.5 + 420) / 1023, 0, 1)\nSLog3G = clamp((log10((g + 0.01)/0.19) * 261.5 + 420) / 1023, 0, 1)\nSLog3B = clamp((log10((b + 0.01)/0.19) * 261.5 + 420) / 1023, 0, 1)\n\nr = r > 0.06 ? pow(1 / (1 + (1 / pow(SLog3R / (1 - SLog3R), power))), power) : r\ng = g > 0.06 ? pow(1 / (1 + (1 / pow(SLog3G / (1 - SLog3G), power))), power) : g\nb = b > 0.06 ? pow(1 / (1 + (1 / pow(SLog3B / (1 - SLog3B), power))), power) : b\n```\n\nRemove tonemap:\n```\npower = 1.7\nSR = 1 / (1 + pow((-1/pow(r, 1/power)) * (pow(r, 1/power) - 1), 1/power))\nSG = 1 / (1 + pow((-1/pow(g, 1/power)) * (pow(g, 1/power) - 1), 1/power))\nSB = 1 / (1 + pow((-1/pow(b, 1/power)) * (pow(b, 1/power) - 1), 1/power))\n\nr = r > 0.06 ? pow(10, (SR * 1023 - 420)/261.5) * 0.19 - 0.01 : r\ng = g > 0.06 ? pow(10, (SG * 1023 - 420)/261.5) * 0.19 - 0.01 : g\nb = b > 0.06 ? pow(10, (SB * 1023 - 420)/261.5) * 0.19 - 0.01 : b\n```\n\n### JitterImage, UnJitterImage, BatchAverageUnJittered\n\nFor supersampling/antialiasing workflows.\n\n### Extract N Frames, Merge Frames By Index\n\nFor processing a smaller number of frames evenly distributed across a larger batch/video, then merging them back into the full batch\n\n</details>\n\n<details><summary>Mask</summary>\n\n### Blur Mask (Fast)\n\nSame as Blur Image (Fast) but for masks instead of images.\n\n### Dilate/Erode Mask\n\nDilate or erode masks, with either a box or circle filter.\n\n### Mask Clean\n\nClean up holes and near-solid areas in a matte.\n\n### Pack Video Mask\n\nCompresses the frames of a video mask to match video VAE latent frames, to work around comfyui's naive temporal resizing of masks.\n\n</details>\n\n<details><summary>Conditioning</summary>\n\n### Conditioning Subtract\n\nTakes the difference of two text conditions, can have interesting effects that are different from negative prompts.\n\n### Inpaint Condition Encode/Apply\n\nSeparates the VAE encode from the conditioning so you don't have to re-encode latents every time you change a prompt.\n\n### IP2P Conditioning Advanced\n\nSeparates the VAE encode from the conditioning so you don't have to re-encode latents every time you change a prompt.\n\n</details>\n\n<details><summary>Sampling</summary>\n\n### Custom Noise\n\nUse any latent as the noise for SamplerCustomAdvanced.\n\n</details>\n\n<details><summary>Utils</summary>\n\n### Latent Stats\n\nGet/print some stats about the latents (dimensions, and per-channel mean, std dev, min, and max)\n\n### Model Test\n\nDebugging node for examining model structure\n\n### Print Sigmas\n\nPrints the noise schedule sigma values to see what a scheduler is doing\n\n### Visualize Latents\n\nShows the latent channels as a grid image\n\n</details>\n"
  },
  {
    "path": "__init__.py",
    "content": "# from .nodes import NODE_CLASS_MAPPINGS, NODE_DISPLAY_NAME_MAPPINGS\r\nfrom .nodes import COMBINED_MAPPINGS\r\n\r\nNODE_CLASS_MAPPINGS = {}\r\nNODE_DISPLAY_NAME_MAPPINGS = {}\r\nfor k, v in COMBINED_MAPPINGS.items():\r\n    NODE_CLASS_MAPPINGS[k] = v[0]\r\n    NODE_DISPLAY_NAME_MAPPINGS[k] = v[1]\r\n\r\n__all__ = ['NODE_CLASS_MAPPINGS', 'NODE_DISPLAY_NAME_MAPPINGS']"
  },
  {
    "path": "download_all_models.py",
    "content": "from raft import load_raft\n\nload_raft()"
  },
  {
    "path": "import_error_install.bat",
    "content": "@echo off\r\n\r\nset \"requirements_txt=%~dp0\\requirements.txt\"\r\nset \"python_exec=..\\..\\..\\python_embeded\\python.exe\"\r\n\r\necho installing requirements...\r\n\r\nif exist \"%python_exec%\" (\r\n    echo Installing with ComfyUI Portable\r\n\t%python_exec% -s -m pip uninstall -y opencv-python opencv-contrib-python opencv-python-headless opencv-contrib-python-headless\r\n    for /f \"delims=\" %%i in (%requirements_txt%) do (\r\n        %python_exec% -s -m pip install \"%%i\"\r\n    )\r\n) else (\r\n    echo Installing with system Python\r\n\tpip uninstall -y opencv-python opencv-contrib-python opencv-python-headless opencv-contrib-python-headless\r\n    for /f \"delims=\" %%i in (%requirements_txt%) do (\r\n        pip install \"%%i\"\r\n    )\r\n)\r\n\r\npause"
  },
  {
    "path": "install.bat",
    "content": "@echo off\r\n\r\nset \"requirements_txt=%~dp0\\requirements.txt\"\r\nset \"python_exec=..\\..\\..\\python_embeded\\python.exe\"\r\n\r\necho installing requirements...\r\n\r\nif exist \"%python_exec%\" (\r\n    echo Installing with ComfyUI Portable\r\n    for /f \"delims=\" %%i in (%requirements_txt%) do (\r\n        %python_exec% -s -m pip install \"%%i\"\r\n    )\r\n) else (\r\n    echo Installing with system Python\r\n    for /f \"delims=\" %%i in (%requirements_txt%) do (\r\n        pip install \"%%i\"\r\n    )\r\n)\r\n\r\npause"
  },
  {
    "path": "nodes.py",
    "content": "import math\r\nimport copy\r\nimport torch\r\nimport torch.nn.functional as F\r\nimport numpy as np\r\nimport cv2\r\nfrom pymatting import estimate_alpha_cf, estimate_foreground_ml, fix_trimap\r\nfrom tqdm import trange\r\n\r\ntry:\r\n    from cv2.ximgproc import guidedFilter\r\nexcept ImportError:\r\n    print(\"\\033[33mUnable to import guidedFilter, make sure you have only opencv-contrib-python or run the import_error_install.bat script\\033[m\")\r\n\r\nimport comfy.model_management\r\nimport node_helpers\r\nfrom server import PromptServer\r\nfrom comfy.utils import ProgressBar\r\nfrom comfy_extras.nodes_post_processing import gaussian_kernel\r\nfrom .raft import *\r\n\r\nMAX_RESOLUTION=8192\r\n\r\n# gaussian blur a tensor image batch in format [B x H x W x C] on H/W (spatial, per-image, per-channel)\r\ndef cv_blur_tensor(images, dx, dy):\r\n    if min(dx, dy) > 100:\r\n        np_img = F.interpolate(images.detach().clone().movedim(-1,1), scale_factor=0.1, mode='bilinear').movedim(1,-1).cpu().numpy()\r\n        for index, image in enumerate(np_img):\r\n            np_img[index] = cv2.GaussianBlur(image, (dx // 20 * 2 + 1, dy // 20 * 2 + 1), 0)\r\n        return F.interpolate(torch.from_numpy(np_img).movedim(-1,1), size=(images.shape[1], images.shape[2]), mode='bilinear').movedim(1,-1)\r\n    else:\r\n        np_img = images.detach().clone().cpu().numpy()\r\n        for index, image in enumerate(np_img):\r\n            np_img[index] = cv2.GaussianBlur(image, (dx, dy), 0)\r\n        return torch.from_numpy(np_img)\r\n\r\n# guided filter a tensor image batch in format [B x H x W x C] on H/W (spatial, per-image, per-channel)\r\ndef guided_filter_tensor(ref, images, d, s):\r\n    if d > 100:\r\n        np_img = F.interpolate(images.detach().clone().movedim(-1,1), scale_factor=0.1, mode='bilinear').movedim(1,-1).cpu().numpy()\r\n        np_ref = F.interpolate(ref.detach().clone().movedim(-1,1), scale_factor=0.1, mode='bilinear').movedim(1,-1).cpu().numpy()\r\n        for index, image in enumerate(np_img):\r\n            np_img[index] = guidedFilter(np_ref[index], image, d // 20 * 2 + 1, s)\r\n        return F.interpolate(torch.from_numpy(np_img).movedim(-1,1), size=(images.shape[1], images.shape[2]), mode='bilinear').movedim(1,-1)\r\n    else:\r\n        np_img = images.detach().clone().cpu().numpy()\r\n        np_ref = ref.cpu().numpy()\r\n        for index, image in enumerate(np_img):\r\n            np_img[index] = guidedFilter(np_ref[index], image, d, s)\r\n        return torch.from_numpy(np_img)\r\n\r\n# std_dev and mean of tensor t within local spatial filter size d, per-image, per-channel [B x H x W x C]\r\ndef std_mean_filter(t, d):\r\n    t_mean = cv_blur_tensor(t, d, d)\r\n    t_diff_squared = (t - t_mean) ** 2\r\n    t_std = torch.sqrt(cv_blur_tensor(t_diff_squared, d, d))\r\n    return t_std, t_mean\r\n\r\ndef RGB2YCbCr(t):\r\n    YCbCr = t.detach().clone()\r\n    YCbCr[:,:,:,0] = 0.2123 * t[:,:,:,0] + 0.7152 * t[:,:,:,1] + 0.0722 * t[:,:,:,2]\r\n    YCbCr[:,:,:,1] = 0 - 0.1146 * t[:,:,:,0] - 0.3854 * t[:,:,:,1] + 0.5 * t[:,:,:,2]\r\n    YCbCr[:,:,:,2] = 0.5 * t[:,:,:,0] - 0.4542 * t[:,:,:,1] - 0.0458 * t[:,:,:,2]\r\n    return YCbCr\r\n\r\ndef YCbCr2RGB(t):\r\n    RGB = t.detach().clone()\r\n    RGB[:,:,:,0] = t[:,:,:,0] + 1.5748 * t[:,:,:,2]\r\n    RGB[:,:,:,1] = t[:,:,:,0] - 0.1873 * t[:,:,:,1] - 0.4681 * t[:,:,:,2]\r\n    RGB[:,:,:,2] = t[:,:,:,0] + 1.8556 * t[:,:,:,1]\r\n    return RGB\r\n\r\ndef hsv_to_rgb(h, s, v):\r\n    if s:\r\n        if h == 1.0: h = 0.0\r\n        i = int(h*6.0)\r\n        f = h*6.0 - i\r\n        \r\n        w = v * (1.0 - s)\r\n        q = v * (1.0 - s * f)\r\n        t = v * (1.0 - s * (1.0 - f))\r\n        \r\n        if i==0: return (v, t, w)\r\n        if i==1: return (q, v, w)\r\n        if i==2: return (w, v, t)\r\n        if i==3: return (w, q, v)\r\n        if i==4: return (t, w, v)\r\n        if i==5: return (v, w, q)\r\n    else: return (v, v, v)\r\n\r\ndef sRGBtoLinear(npArray):\r\n    less = npArray <= 0.0404482362771082\r\n    npArray[less] = npArray[less] / 12.92\r\n    npArray[~less] = np.power((npArray[~less] + 0.055) / 1.055, 2.4)\r\n\r\ndef linearToSRGB(npArray):\r\n    less = npArray <= 0.0031308\r\n    npArray[less] = npArray[less] * 12.92\r\n    npArray[~less] = np.power(npArray[~less], 1/2.4) * 1.055 - 0.055\r\n\r\ndef sRGBtoLinear_pt(t: torch.Tensor):\r\n    less = t <= 0.0404482362771082\r\n    t[less] = t[less] / 12.92\r\n    t[~less] = torch.pow((t[~less] + 0.055) / 1.055, 2.4)\r\n    return t\r\n\r\ndef linearToSRGB_pt(t: torch.Tensor):\r\n    less = t <= 0.0031308\r\n    t[less] = t[less] * 12.92\r\n    t[~less] = torch.pow(t[~less], 1 / 2.4) * 1.055 - 0.055\r\n    return t\r\n\r\ndef linearToTonemap(npArray, tonemap_scale):\r\n    npArray /= tonemap_scale\r\n    more = npArray > 0.06\r\n    SLog3 = np.clip((np.log10((npArray + 0.01)/0.19) * 261.5 + 420) / 1023, 0, 1)\r\n    npArray[more] = np.power(1 / (1 + (1 / np.power(SLog3[more] / (1 - SLog3[more]), 1.7))), 1.7)\r\n    npArray *= tonemap_scale\r\n\r\ndef tonemapToLinear(npArray, tonemap_scale):\r\n    npArray /= tonemap_scale\r\n    more = npArray > 0.06\r\n    x = np.power(np.clip(npArray, 0.000001, 1), 1/1.7)\r\n    ut = 1 / (1 + np.power((-1 / x) * (x - 1), 1/1.7))\r\n    npArray[more] = np.power(10, (ut[more] * 1023 - 420)/261.5) * 0.19 - 0.01\r\n    npArray *= tonemap_scale\r\n\r\ndef exposure(npArray, stops):\r\n    more = npArray > 0\r\n    npArray[more] *= pow(2, stops)\r\n\r\ndef randn_like_g(x, generator=None):\r\n    device = generator.device if generator is not None else x.device\r\n    r = torch.randn(x.size(), generator=generator, dtype=x.dtype, layout=x.layout, device=device)\r\n    return r.to(x.device)\r\n\r\n\r\nclass AlphaClean:\r\n    @classmethod\r\n    def INPUT_TYPES(s):\r\n        return {\r\n            \"required\": {\r\n                \"images\": (\"IMAGE\",),\r\n                \"radius\": (\"INT\", {\"default\": 8, \"min\": 1, \"max\": 64, \"step\": 1}),\r\n                \"fill_holes\": (\"INT\", {\"default\": 1, \"min\": 0, \"max\": 16, \"step\": 1}),\r\n                \"white_threshold\": (\"FLOAT\", {\"default\": 0.9, \"min\": 0.01, \"max\": 1.0, \"step\": 0.01}),\r\n                \"extra_clip\": (\"FLOAT\", {\"default\": 0.98, \"min\": 0.01, \"max\": 1.0, \"step\": 0.01}),\r\n            },\r\n        }\r\n\r\n    RETURN_TYPES = (\"IMAGE\",)\r\n    FUNCTION = \"alpha_clean\"\r\n    CATEGORY = \"Image-Filters/image\"\r\n    DEPRECATED = True\r\n\r\n    def alpha_clean(self, images: torch.Tensor, radius: int, fill_holes: int, white_threshold: float, extra_clip: float):\r\n        d = radius * 2 + 1\r\n        i_dup = copy.deepcopy(images.cpu().numpy())\r\n        \r\n        for index, image in enumerate(i_dup):\r\n            \r\n            cleaned = cv2.bilateralFilter(image, 9, 0.05, 8)\r\n            \r\n            alpha = np.clip((image - white_threshold) / (1 - white_threshold), 0, 1)\r\n            rgb = image * alpha\r\n            \r\n            alpha = cv2.GaussianBlur(alpha, (d,d), 0) * 0.99 + np.average(alpha) * 0.01\r\n            rgb = cv2.GaussianBlur(rgb, (d,d), 0) * 0.99 + np.average(rgb) * 0.01\r\n            \r\n            rgb = rgb / np.clip(alpha, 0.00001, 1)\r\n            rgb = rgb * extra_clip\r\n            \r\n            cleaned = np.clip(cleaned / rgb, 0, 1)\r\n            \r\n            if fill_holes > 0:\r\n                fD = fill_holes * 2 + 1\r\n                gamma = cleaned * cleaned\r\n                kD = np.ones((fD, fD), np.uint8)\r\n                kE = np.ones((fD + 2, fD + 2), np.uint8)\r\n                gamma = cv2.dilate(gamma, kD, iterations=1)\r\n                gamma = cv2.erode(gamma, kE, iterations=1)\r\n                gamma = cv2.GaussianBlur(gamma, (fD, fD), 0)\r\n                cleaned = np.maximum(cleaned, gamma)\r\n\r\n            i_dup[index] = cleaned\r\n        \r\n        return (torch.from_numpy(i_dup),)\r\n\r\n\r\nclass MaskClean:\r\n    @classmethod\r\n    def INPUT_TYPES(s):\r\n        return {\r\n            \"required\": {\r\n                \"mask\": (\"MASK\",),\r\n                \"radius\": (\"INT\", {\"default\": 8, \"min\": 1, \"max\": 64, \"step\": 1}),\r\n                \"fill_holes\": (\"INT\", {\"default\": 1, \"min\": 0, \"max\": 16, \"step\": 1}),\r\n                \"white_threshold\": (\"FLOAT\", {\"default\": 0.9, \"min\": 0.001, \"max\": 1.0, \"step\": 0.001}),\r\n                \"extra_clip\": (\"FLOAT\", {\"default\": 0.98, \"min\": 0.001, \"max\": 1.0, \"step\": 0.001}),\r\n            },\r\n        }\r\n\r\n    RETURN_TYPES = (\"MASK\",)\r\n    FUNCTION = \"alpha_clean\"\r\n    CATEGORY = \"Image-Filters/mask\"\r\n\r\n    def alpha_clean(self, mask, radius, fill_holes, white_threshold, extra_clip):\r\n        d = radius * 2 + 1\r\n        i_dup = mask.cpu().numpy()\r\n        \r\n        for index, image in enumerate(i_dup):\r\n            cleaned = cv2.bilateralFilter(image, 9, 0.05, 8)\r\n            \r\n            alpha = np.clip((image - white_threshold) / (1 - white_threshold), 0, 1)\r\n            rgb = image * alpha\r\n            \r\n            alpha = cv2.GaussianBlur(alpha, (d,d), 0) * 0.99 + np.average(alpha) * 0.01\r\n            rgb = cv2.GaussianBlur(rgb, (d,d), 0) * 0.99 + np.average(rgb) * 0.01\r\n            \r\n            rgb = rgb / np.clip(alpha, 0.00001, 1)\r\n            rgb = rgb * extra_clip\r\n            \r\n            cleaned = np.clip(cleaned / rgb, 0, 1)\r\n            \r\n            if fill_holes > 0:\r\n                fD = fill_holes * 2 + 1\r\n                gamma = cleaned * cleaned\r\n                kD = np.ones((fD, fD), np.uint8)\r\n                kE = np.ones((fD + 2, fD + 2), np.uint8)\r\n                gamma = cv2.dilate(gamma, kD, iterations=1)\r\n                gamma = cv2.erode(gamma, kE, iterations=1)\r\n                gamma = cv2.GaussianBlur(gamma, (fD, fD), 0)\r\n                cleaned = np.maximum(cleaned, gamma)\r\n\r\n            i_dup[index] = cleaned\r\n        \r\n        return (torch.from_numpy(i_dup),)\r\n\r\n\r\nclass AlphaMatte:\r\n    @classmethod\r\n    def INPUT_TYPES(s):\r\n        return {\r\n            \"required\": {\r\n                \"images\": (\"IMAGE\",),\r\n                \"alpha_trimap\": (\"IMAGE\",),\r\n                \"preblur\": (\"INT\", {\"default\": 8, \"min\": 0, \"max\": 256, \"step\": 1}),\r\n                \"blackpoint\": (\"FLOAT\", {\"default\": 0.01, \"min\": 0.0, \"max\": 0.99, \"step\": 0.01}),\r\n                \"whitepoint\": (\"FLOAT\", {\"default\": 0.99, \"min\": 0.01, \"max\": 1.0, \"step\": 0.01}),\r\n                \"max_iterations\": (\"INT\", {\"default\": 1000, \"min\": 100, \"max\": 10000, \"step\": 100}),\r\n                \"estimate_fg\": ([\"true\", \"false\"],),\r\n            },\r\n        }\r\n\r\n    RETURN_TYPES = (\"IMAGE\", \"IMAGE\", \"IMAGE\",)\r\n    RETURN_NAMES = (\"alpha\", \"fg\", \"bg\",)\r\n    FUNCTION = \"alpha_matte\"\r\n    CATEGORY = \"Image-Filters/image\"\r\n    DEPRECATED = True\r\n\r\n    def alpha_matte(self, images, alpha_trimap, preblur, blackpoint, whitepoint, max_iterations, estimate_fg):\r\n        d = preblur * 2 + 1\r\n        \r\n        i_dup = images.cpu().numpy().astype(np.float64)\r\n        a_dup = alpha_trimap.cpu().numpy().astype(np.float64)\r\n        fg = images.cpu().numpy().astype(np.float64)\r\n        bg = images.cpu().numpy().astype(np.float64)\r\n        \r\n        \r\n        for index, image in enumerate(i_dup):\r\n            trimap = a_dup[index][:,:,0] # convert to single channel\r\n            if preblur > 0:\r\n                trimap = cv2.GaussianBlur(trimap, (d, d), 0)\r\n            trimap = fix_trimap(trimap, blackpoint, whitepoint)\r\n            \r\n            alpha = estimate_alpha_cf(image, trimap, laplacian_kwargs={\"epsilon\": 1e-6}, cg_kwargs={\"maxiter\":max_iterations})\r\n            \r\n            if estimate_fg == \"true\":\r\n                fg[index], bg[index] = estimate_foreground_ml(image, alpha, return_background=True)\r\n            \r\n            a_dup[index] = np.stack([alpha, alpha, alpha], axis = -1) # convert back to rgb\r\n        \r\n        return (\r\n            torch.from_numpy(a_dup.astype(np.float32)), # alpha\r\n            torch.from_numpy(fg.astype(np.float32)), # fg\r\n            torch.from_numpy(bg.astype(np.float32)), # bg\r\n            )\r\n\r\n\r\nclass ImageMatting:\r\n    @classmethod\r\n    def INPUT_TYPES(s):\r\n        return {\r\n            \"required\": {\r\n                \"images\": (\"IMAGE\",),\r\n                \"trimap\": (\"MASK\",),\r\n                \"preblur\": (\"INT\", {\"default\": 8, \"min\": 0, \"max\": 256, \"step\": 1}),\r\n                \"blackpoint\": (\"FLOAT\", {\"default\": 0.01, \"min\": 0.0, \"max\": 0.99, \"step\": 0.01}),\r\n                \"whitepoint\": (\"FLOAT\", {\"default\": 0.99, \"min\": 0.01, \"max\": 1.0, \"step\": 0.01}),\r\n                \"max_iterations\": (\"INT\", {\"default\": 1000, \"min\": 10, \"max\": 10000, \"step\": 10}),\r\n                \"estimate_fg\": (\"BOOLEAN\", {\"default\": True}),\r\n            },\r\n        }\r\n\r\n    RETURN_TYPES = (\"MASK\", \"IMAGE\", \"IMAGE\",)\r\n    RETURN_NAMES = (\"matte\", \"fg\", \"bg\",)\r\n    FUNCTION = \"alpha_matte\"\r\n    CATEGORY = \"Image-Filters/image\"\r\n\r\n    def alpha_matte(self, images, trimap, preblur, blackpoint, whitepoint, max_iterations, estimate_fg):\r\n        d = preblur * 2 + 1\r\n        \r\n        i_dup = images.cpu().numpy().astype(np.float64)\r\n        a_dup = trimap.cpu().numpy().astype(np.float64)\r\n        fg = copy.deepcopy(i_dup)\r\n        bg = copy.deepcopy(i_dup)\r\n        \r\n        \r\n        for index, image in enumerate(i_dup):\r\n            trimap = a_dup[index]\r\n            if preblur > 0:\r\n                trimap = cv2.GaussianBlur(trimap, (d, d), 0)\r\n            trimap = fix_trimap(trimap, blackpoint, whitepoint)\r\n            \r\n            alpha = estimate_alpha_cf(image, trimap, laplacian_kwargs={\"epsilon\": 1e-6}, cg_kwargs={\"maxiter\":max_iterations})\r\n            \r\n            if estimate_fg:\r\n                fg[index], bg[index] = estimate_foreground_ml(image, alpha, return_background=True)\r\n            \r\n            a_dup[index] = alpha\r\n        \r\n        return (\r\n            torch.from_numpy(a_dup.astype(np.float32)), # matte\r\n            torch.from_numpy(fg.astype(np.float32)), # fg\r\n            torch.from_numpy(bg.astype(np.float32)), # bg\r\n            )\r\n\r\n\r\nclass BetterFilmGrain:\r\n    @classmethod\r\n    def INPUT_TYPES(s):\r\n        return {\r\n            \"required\": {\r\n                \"image\": (\"IMAGE\",),\r\n                \"scale\": (\"FLOAT\", {\"default\": 0.5, \"min\": 0.25, \"max\": 2.0, \"step\": 0.05}),\r\n                \"strength\": (\"FLOAT\", {\"default\": 0.5, \"min\": 0.0, \"max\": 10.0, \"step\": 0.01}),\r\n                \"saturation\": (\"FLOAT\", {\"default\": 0.7, \"min\": 0.0, \"max\": 2.0, \"step\": 0.01}),\r\n                \"toe\": (\"FLOAT\", {\"default\": 0.0, \"min\": -0.2, \"max\": 0.5, \"step\": 0.001}),\r\n                \"seed\": (\"INT\", {\"default\": 0, \"min\": 0, \"max\": 0xffffffffffffffff}),\r\n            },\r\n        }\r\n\r\n    RETURN_TYPES = (\"IMAGE\",)\r\n    FUNCTION = \"grain\"\r\n    CATEGORY = \"Image-Filters/image\"\r\n\r\n    def grain(self, image, scale, strength, saturation, toe, seed):\r\n        t = image.detach().clone()\r\n        torch.manual_seed(seed)\r\n        grain = torch.rand(t.shape[0], int(t.shape[1] // scale), int(t.shape[2] // scale), 3)\r\n        \r\n        YCbCr = RGB2YCbCr(grain)\r\n        YCbCr[:,:,:,0] = cv_blur_tensor(YCbCr[:,:,:,0], 3, 3)\r\n        YCbCr[:,:,:,1] = cv_blur_tensor(YCbCr[:,:,:,1], 15, 15)\r\n        YCbCr[:,:,:,2] = cv_blur_tensor(YCbCr[:,:,:,2], 11, 11)\r\n        \r\n        grain = (YCbCr2RGB(YCbCr) - 0.5) * strength\r\n        grain[:,:,:,0] *= 2\r\n        grain[:,:,:,2] *= 3\r\n        grain += 1\r\n        grain = grain * saturation + grain[:,:,:,1].unsqueeze(3).repeat(1,1,1,3) * (1 - saturation)\r\n        \r\n        grain = F.interpolate(grain.movedim(-1,1), size=(t.shape[1], t.shape[2]), mode='bilinear').movedim(1,-1)\r\n        t[:,:,:,:3] = torch.clip((1 - (1 - t[:,:,:,:3]) * grain) * (1 - toe) + toe, 0, 1)\r\n        return(t,)\r\n\r\n\r\nclass BlurImageFast:\r\n    @classmethod\r\n    def INPUT_TYPES(s):\r\n        return {\r\n            \"required\": {\r\n                \"images\": (\"IMAGE\",),\r\n                \"radius_x\": (\"INT\", {\"default\": 1, \"min\": 0, \"max\": 1023, \"step\": 1}),\r\n                \"radius_y\": (\"INT\", {\"default\": 1, \"min\": 0, \"max\": 1023, \"step\": 1}),\r\n            },\r\n        }\r\n\r\n    RETURN_TYPES = (\"IMAGE\",)\r\n    FUNCTION = \"blur_image\"\r\n    CATEGORY = \"Image-Filters/image\"\r\n\r\n    def blur_image(self, images, radius_x, radius_y):\r\n        if radius_x + radius_y == 0:\r\n            return (images,)\r\n        \r\n        dx = radius_x * 2 + 1\r\n        dy = radius_y * 2 + 1\r\n        \r\n        dup = copy.deepcopy(images.cpu().numpy())\r\n        \r\n        for index, image in enumerate(dup):\r\n            dup[index] = cv2.GaussianBlur(image, (dx, dy), 0)\r\n        \r\n        return (torch.from_numpy(dup),)\r\n\r\n\r\nclass BlurMaskFast:\r\n    @classmethod\r\n    def INPUT_TYPES(s):\r\n        return {\r\n            \"required\": {\r\n                \"masks\": (\"MASK\",),\r\n                \"radius_x\": (\"INT\", {\"default\": 1, \"min\": 0, \"max\": 1023, \"step\": 1}),\r\n                \"radius_y\": (\"INT\", {\"default\": 1, \"min\": 0, \"max\": 1023, \"step\": 1}),\r\n            },\r\n        }\r\n\r\n    RETURN_TYPES = (\"MASK\",)\r\n    FUNCTION = \"blur_mask\"\r\n    CATEGORY = \"Image-Filters/mask\"\r\n\r\n    def blur_mask(self, masks, radius_x, radius_y):\r\n        if radius_x + radius_y == 0:\r\n            return (masks,)\r\n        \r\n        dx = radius_x * 2 + 1\r\n        dy = radius_y * 2 + 1\r\n        \r\n        dup = copy.deepcopy(masks.cpu().numpy())\r\n        \r\n        for index, mask in enumerate(dup):\r\n            dup[index] = cv2.GaussianBlur(mask, (dx, dy), 0)\r\n        \r\n        return (torch.from_numpy(dup),)\r\n\r\n\r\nclass ColorMatchImage:\r\n    @classmethod\r\n    def INPUT_TYPES(s):\r\n        return {\r\n            \"required\": {\r\n                \"images\": (\"IMAGE\", ),\r\n                \"reference\": (\"IMAGE\", ),\r\n                \"blur_type\": ([\"blur\", \"guidedFilter\"],),\r\n                \"blur_size\": (\"INT\", {\"default\": 0, \"min\": 0, \"max\": 1023}),\r\n                \"factor\": (\"FLOAT\", {\"default\": 1.0, \"min\": -10.0, \"max\": 10.0, \"step\": 0.01,  \"round\": 0.01}),\r\n            },\r\n        }\r\n\r\n    RETURN_TYPES = (\"IMAGE\",)\r\n    FUNCTION = \"batch_normalize\"\r\n    CATEGORY = \"Image-Filters/image\"\r\n\r\n    def batch_normalize(self, images, reference, blur_type, blur_size, factor):\r\n        t = images.detach().clone() + 0.1\r\n        ref = reference.detach().clone() + 0.1\r\n        \r\n        if ref.shape[0] < t.shape[0]:\r\n            ref = ref[0].unsqueeze(0).repeat(t.shape[0], 1, 1, 1)\r\n        \r\n        if blur_size == 0:\r\n            mean = torch.mean(t, (1,2), keepdim=True)\r\n            mean_ref = torch.mean(ref, (1,2), keepdim=True)\r\n            \r\n            for i in range(t.shape[0]):\r\n                for c in range(3):\r\n                    t[i,:,:,c] /= mean[i,0,0,c]\r\n                    t[i,:,:,c] *= mean_ref[i,0,0,c]\r\n        else:\r\n            d = blur_size * 2 + 1\r\n            \r\n            if blur_type == \"blur\":\r\n                blurred = cv_blur_tensor(t, d, d)\r\n                blurred_ref = cv_blur_tensor(ref, d, d)\r\n            elif blur_type == \"guidedFilter\":\r\n                blurred = guided_filter_tensor(t, t, d, 0.01)\r\n                blurred_ref = guided_filter_tensor(ref, ref, d, 0.01)\r\n            \r\n            for i in range(t.shape[0]):\r\n                for c in range(3):\r\n                    t[i,:,:,c] /= blurred[i,:,:,c]\r\n                    t[i,:,:,c] *= blurred_ref[i,:,:,c]\r\n        \r\n        t = t - 0.1\r\n        torch.clamp(torch.lerp(images, t, factor), 0, 1)\r\n        return (t,)\r\n\r\n\r\nclass RestoreDetail:\r\n    @classmethod\r\n    def INPUT_TYPES(s):\r\n        return {\r\n            \"required\": {\r\n                \"images\": (\"IMAGE\", ),\r\n                \"detail\": (\"IMAGE\", ),\r\n                \"mode\": ([\"add\", \"multiply\"],),\r\n                \"blur_type\": ([\"blur\", \"guidedFilter\"],),\r\n                \"blur_size\": (\"INT\", {\"default\": 1, \"min\": 1, \"max\": 1023}),\r\n                \"factor\": (\"FLOAT\", {\"default\": 1.0, \"min\": -10.0, \"max\": 10.0, \"step\": 0.01,  \"round\": 0.01}),\r\n            },\r\n        }\r\n\r\n    RETURN_TYPES = (\"IMAGE\",)\r\n    FUNCTION = \"batch_normalize\"\r\n    CATEGORY = \"Image-Filters/image\"\r\n\r\n    def batch_normalize(self, images, detail, mode, blur_type, blur_size, factor):\r\n        t = images.detach().clone() + 0.1\r\n        ref = detail.detach().clone() + 0.1\r\n        \r\n        if ref.shape[0] < t.shape[0]:\r\n            ref = ref[0].unsqueeze(0).repeat(t.shape[0], 1, 1, 1)\r\n        \r\n        d = blur_size * 2 + 1\r\n        \r\n        if blur_type == \"blur\":\r\n            blurred = cv_blur_tensor(t, d, d)\r\n            blurred_ref = cv_blur_tensor(ref, d, d)\r\n        elif blur_type == \"guidedFilter\":\r\n            blurred = guided_filter_tensor(t, t, d, 0.01)\r\n            blurred_ref = guided_filter_tensor(ref, ref, d, 0.01)\r\n        \r\n        if mode == \"multiply\":\r\n            t = (ref / blurred_ref) * blurred\r\n        else:\r\n            t = (ref - blurred_ref) + blurred\r\n        \r\n        t = t - 0.1\r\n        t = torch.clamp(torch.lerp(images, t, factor), 0, 1)\r\n        return (t,)\r\n\r\n\r\nclass DilateErodeMask:\r\n    @classmethod\r\n    def INPUT_TYPES(s):\r\n        return {\r\n            \"required\": {\r\n                \"masks\": (\"MASK\",),\r\n                \"radius\": (\"INT\", {\"default\": 0, \"min\": -1023, \"max\": 1023, \"step\": 1}),\r\n                \"shape\": ([\"box\", \"circle\"],),\r\n            },\r\n        }\r\n\r\n    RETURN_TYPES = (\"MASK\",)\r\n    FUNCTION = \"dilate_mask\"\r\n    CATEGORY = \"Image-Filters/mask\"\r\n\r\n    def dilate_mask(self, masks, radius, shape):\r\n        if radius == 0:\r\n            return (masks,)\r\n        \r\n        s = abs(radius)\r\n        d = s * 2 + 1\r\n        k = np.zeros((d, d), np.uint8)\r\n        if shape == \"circle\":\r\n            k = cv2.circle(k, (s,s), s, 1, -1)\r\n        else:\r\n            k += 1\r\n        \r\n        dup = copy.deepcopy(masks.cpu().numpy())\r\n        \r\n        for index, mask in enumerate(dup):\r\n            if radius > 0:\r\n                dup[index] = cv2.dilate(mask, k, iterations=1)\r\n            else:\r\n                dup[index] = cv2.erode(mask, k, iterations=1)\r\n        \r\n        return (torch.from_numpy(dup),)\r\n\r\n\r\nclass EnhanceDetail:\r\n    @classmethod\r\n    def INPUT_TYPES(s):\r\n        return {\r\n            \"required\": {\r\n                \"images\": (\"IMAGE\",),\r\n                \"filter_radius\": (\"INT\", {\"default\": 2, \"min\": 1, \"max\": 64, \"step\": 1}),\r\n                \"sigma\": (\"FLOAT\", {\"default\": 0.1, \"min\": 0.01, \"max\": 100.0, \"step\": 0.01}),\r\n                \"denoise\": (\"FLOAT\", {\"default\": 0.1, \"min\": 0.0, \"max\": 10.0, \"step\": 0.01}),\r\n                \"detail_mult\": (\"FLOAT\", {\"default\": 2.0, \"step\": 0.01}),\r\n            },\r\n        }\r\n\r\n    RETURN_TYPES = (\"IMAGE\",)\r\n    FUNCTION = \"enhance\"\r\n    CATEGORY = \"Image-Filters/image\"\r\n\r\n    def enhance(self, images: torch.Tensor, filter_radius: int, sigma: float, denoise: float, detail_mult: float):\r\n        if filter_radius == 0:\r\n            return (images,)\r\n        \r\n        d = filter_radius * 2 + 1\r\n        s = sigma / 10\r\n        n = denoise / 10\r\n        \r\n        dup = copy.deepcopy(images.cpu().numpy())\r\n        \r\n        for index, image in enumerate(dup):\r\n            imgB = image\r\n            if denoise > 0.0:\r\n                imgB = cv2.bilateralFilter(image, d, n, d)\r\n            \r\n            imgG = np.clip(guidedFilter(image, image, d, s), 0.001, 1)\r\n            \r\n            details = (imgB/imgG - 1) * detail_mult + 1\r\n            dup[index] = np.clip(details*imgG - imgB + image, 0, 1)\r\n        \r\n        return (torch.from_numpy(dup),)\r\n\r\n\r\nclass GuidedFilterImage:\r\n    @classmethod\r\n    def INPUT_TYPES(s):\r\n        return {\r\n            \"required\": {\r\n                \"images\": (\"IMAGE\", ),\r\n                \"guide\": (\"IMAGE\", ),\r\n                \"size\": (\"INT\", {\"default\": 4, \"min\": 0, \"max\": 1023}),\r\n                \"sigma\": (\"FLOAT\", {\"default\": 0.1, \"min\": 0.01, \"max\": 100.0, \"step\": 0.01}),\r\n            },\r\n        }\r\n\r\n    RETURN_TYPES = (\"IMAGE\",)\r\n    FUNCTION = \"filter_image\"\r\n    CATEGORY = \"Image-Filters/image\"\r\n\r\n    def filter_image(self, images, guide, size, sigma):\r\n        d = size * 2 + 1\r\n        s = sigma / 10\r\n        filtered = guided_filter_tensor(guide, images, d, s)\r\n        return (filtered,)\r\n\r\n\r\nclass MedianFilterImage:\r\n    @classmethod\r\n    def INPUT_TYPES(s):\r\n        return {\r\n            \"required\": {\r\n                \"images\": (\"IMAGE\", ),\r\n                \"size\": (\"INT\", {\"default\": 1, \"min\": 1, \"max\": 1023}),\r\n            },\r\n        }\r\n\r\n    RETURN_TYPES = (\"IMAGE\",)\r\n    FUNCTION = \"filter_image\"\r\n    CATEGORY = \"Image-Filters/image\"\r\n\r\n    def filter_image(self, images, size):\r\n        np_images = images.detach().clone().cpu().numpy()\r\n        d = size * 2 + 1\r\n        for index, image in enumerate(np_images):\r\n            if d > 5:\r\n                work_image = image * 255\r\n                work_image = cv2.medianBlur(work_image.astype(np.uint8), d)\r\n                np_images[index] = work_image.astype(np.float32) / 255\r\n            else:\r\n                np_images[index] = cv2.medianBlur(image, d)\r\n        return (torch.from_numpy(np_images),)\r\n\r\n\r\nclass BilateralFilterImage:\r\n    @classmethod\r\n    def INPUT_TYPES(s):\r\n        return {\r\n            \"required\": {\r\n                \"images\": (\"IMAGE\", ),\r\n                \"size\": (\"INT\", {\"default\": 8, \"min\": 1, \"max\": 64}),\r\n                \"sigma_color\": (\"FLOAT\", {\"default\": 0.5, \"min\": 0.01, \"max\": 1000.0, \"step\": 0.01}),\r\n                \"sigma_space\": (\"FLOAT\", {\"default\": 100.0, \"min\": 0.01, \"max\": 1000.0, \"step\": 0.01}),\r\n            },\r\n        }\r\n\r\n    RETURN_TYPES = (\"IMAGE\",)\r\n    FUNCTION = \"filter_image\"\r\n    CATEGORY = \"Image-Filters/image\"\r\n\r\n    def filter_image(self, images, size, sigma_color, sigma_space):\r\n        np_images = images.detach().clone().cpu().numpy()\r\n        d = size * 2 + 1\r\n        for index, image in enumerate(np_images):\r\n            np_images[index] = cv2.bilateralFilter(image, d, sigma_color, sigma_space)\r\n        return (torch.from_numpy(np_images),)\r\n\r\n\r\nclass FrequencyCombine:\r\n    @classmethod\r\n    def INPUT_TYPES(s):\r\n        return {\r\n            \"required\": {\r\n                \"high_frequency\": (\"IMAGE\", ),\r\n                \"low_frequency\": (\"IMAGE\", ),\r\n                \"mode\": ([\"subtract\", \"divide\"],),\r\n                \"eps\": (\"FLOAT\", {\"default\": 0.1, \"min\": 0.01, \"max\": 0.99, \"step\": 0.01}),\r\n            },\r\n        }\r\n\r\n    RETURN_TYPES = (\"IMAGE\",)\r\n    FUNCTION = \"filter_image\"\r\n    CATEGORY = \"Image-Filters/image\"\r\n\r\n    def filter_image(self, high_frequency, low_frequency, mode, eps):\r\n        t = low_frequency.detach().clone()\r\n        if mode == \"subtract\":\r\n            t = t + high_frequency - 0.5\r\n        else:\r\n            t = (high_frequency * 2) * (t + eps) - eps\r\n        return (torch.clamp(t, 0, 1),)\r\n\r\n\r\nclass FrequencySeparate:\r\n    @classmethod\r\n    def INPUT_TYPES(s):\r\n        return {\r\n            \"required\": {\r\n                \"original\": (\"IMAGE\", ),\r\n                \"low_frequency\": (\"IMAGE\", ),\r\n                \"mode\": ([\"subtract\", \"divide\"],),\r\n                \"eps\": (\"FLOAT\", {\"default\": 0.1, \"min\": 0.01, \"max\": 0.99, \"step\": 0.01}),\r\n            },\r\n        }\r\n\r\n    RETURN_TYPES = (\"IMAGE\",)\r\n    RETURN_NAMES = (\"high_frequency\",)\r\n    FUNCTION = \"filter_image\"\r\n    CATEGORY = \"Image-Filters/image\"\r\n\r\n    def filter_image(self, original, low_frequency, mode, eps):\r\n        t = original.detach().clone()\r\n        if mode == \"subtract\":\r\n            t = t - low_frequency + 0.5\r\n        else:\r\n            t = ((t + eps) / (low_frequency + eps)) * 0.5\r\n        return (t,)\r\n\r\n\r\nclass RemapRange:\r\n    @classmethod\r\n    def INPUT_TYPES(s):\r\n        return {\r\n            \"required\": {\r\n                \"image\": (\"IMAGE\",),\r\n                \"blackpoint\": (\"FLOAT\", {\"default\": 0.0, \"min\": 0.0, \"max\": 1.0, \"step\": 0.01}),\r\n                \"whitepoint\": (\"FLOAT\", {\"default\": 1.0, \"min\": 0.01, \"max\": 1.0, \"step\": 0.01}),\r\n            },\r\n        }\r\n\r\n    RETURN_TYPES = (\"IMAGE\",)\r\n    FUNCTION = \"remap\"\r\n    CATEGORY = \"Image-Filters/image\"\r\n\r\n    def remap(self, image: torch.Tensor, blackpoint: float, whitepoint: float):\r\n        bp = min(blackpoint, whitepoint - 0.001)\r\n        scale = 1 / (whitepoint - bp)\r\n        \r\n        i_dup = copy.deepcopy(image.cpu().numpy())\r\n        i_dup = np.clip((i_dup - bp) * scale, 0.0, 1.0)\r\n        \r\n        return (torch.from_numpy(i_dup),)\r\n\r\n\r\nclass ClampImage:\r\n    @classmethod\r\n    def INPUT_TYPES(s):\r\n        return {\r\n            \"required\": {\r\n                \"image\": (\"IMAGE\",),\r\n                \"blackpoint\": (\"FLOAT\", {\"default\": 0.0, \"min\": 0.0, \"max\": 1.0, \"step\": 0.001}),\r\n                \"whitepoint\": (\"FLOAT\", {\"default\": 1.0, \"min\": 0.0, \"max\": 1.0, \"step\": 0.001}),\r\n            },\r\n        }\r\n\r\n    RETURN_TYPES = (\"IMAGE\",)\r\n    FUNCTION = \"clamp_image\"\r\n    CATEGORY = \"Image-Filters/image\"\r\n\r\n    def clamp_image(self, image: torch.Tensor, blackpoint: float, whitepoint: float):\r\n        clamped_image = torch.clamp(torch.nan_to_num(image.detach().clone()), min=blackpoint, max=whitepoint)\r\n        return (clamped_image,)\r\n\r\n\r\nChannel_List = [\"red\", \"green\", \"blue\", \"alpha\", \"white\", \"black\"]\r\nAlpha_List = [\"red\", \"green\", \"blue\", \"alpha\", \"white\", \"black\", \"none\"]\r\n\r\nclass ShuffleChannels:\r\n    @classmethod\r\n    def INPUT_TYPES(s):\r\n        return {\r\n            \"required\": {\r\n                \"image\": (\"IMAGE\",),\r\n                \"red\": (Channel_List, {\"default\": \"red\"}),\r\n                \"green\": (Channel_List, {\"default\": \"green\"}),\r\n                \"blue\": (Channel_List, {\"default\": \"blue\"}),\r\n                \"alpha\": (Alpha_List, {\"default\": \"none\"}),\r\n            },\r\n        }\r\n\r\n    RETURN_TYPES = (\"IMAGE\",)\r\n    FUNCTION = \"shuffle\"\r\n    CATEGORY = \"Image-Filters/image\"\r\n\r\n    def shuffle(self, image, red, green, blue, alpha):\r\n        ch = 3 if alpha == \"none\" else 4\r\n        t = torch.zeros((image.shape[0], image.shape[1], image.shape[2], ch), dtype=image.dtype, device=image.device)\r\n        image_copy = image.detach().clone()\r\n        \r\n        ch_key = [red, green, blue, alpha]\r\n        for i in range(ch):\r\n            if ch_key[i] == \"white\":\r\n                t[:,:,:,i] = 1\r\n            elif ch_key[i] == \"red\":\r\n                t[:,:,:,i] = image_copy[:,:,:,0]\r\n            elif ch_key[i] == \"green\":\r\n                t[:,:,:,i] = image_copy[:,:,:,1]\r\n            elif ch_key[i] == \"blue\":\r\n                t[:,:,:,i] = image_copy[:,:,:,2]\r\n            elif ch_key[i] == \"alpha\":\r\n                if image.shape[3] > 3:\r\n                    t[:,:,:,i] = image_copy[:,:,:,3]\r\n                else:\r\n                    t[:,:,:,i] = 1\r\n        \r\n        return(t,)\r\n\r\n\r\nclass ClampOutliers:\r\n    @classmethod\r\n    def INPUT_TYPES(s):\r\n        return {\r\n            \"required\": {\r\n                \"latents\": (\"LATENT\", ),\r\n                \"std_dev\": (\"FLOAT\", {\"default\": 3.0, \"min\": 0.1, \"max\": 100.0, \"step\": 0.1,  \"round\": 0.1}),\r\n            },\r\n        }\r\n\r\n    RETURN_TYPES = (\"LATENT\",)\r\n    FUNCTION = \"clamp_outliers\"\r\n    CATEGORY = \"Image-Filters/latent\"\r\n\r\n    def clamp_outliers(self, latents, std_dev):\r\n        latents_copy = copy.deepcopy(latents)\r\n        t = latents_copy[\"samples\"]\r\n        \r\n        for i, latent in enumerate(t):\r\n            for j, channel in enumerate(latent):\r\n                sd, mean = torch.std_mean(channel, dim=None)\r\n                t[i,j] = torch.clamp(channel, min = -sd * std_dev + mean, max = sd * std_dev + mean)\r\n        \r\n        latents_copy[\"samples\"] = t\r\n        return (latents_copy,)\r\n\r\n\r\nclass AdainLatent:\r\n    @classmethod\r\n    def INPUT_TYPES(s):\r\n        return {\r\n            \"required\": {\r\n                \"latents\": (\"LATENT\", ),\r\n                \"reference\": (\"LATENT\", ),\r\n                \"factor\": (\"FLOAT\", {\"default\": 1.0, \"min\": -10.0, \"max\": 10.0, \"step\": 0.01,  \"round\": 0.01}),\r\n            },\r\n        }\r\n\r\n    RETURN_TYPES = (\"LATENT\",)\r\n    FUNCTION = \"batch_normalize\"\r\n    CATEGORY = \"Image-Filters/latent\"\r\n\r\n    def batch_normalize(self, latents, reference, factor):\r\n        latents_copy = copy.deepcopy(latents)\r\n        t = latents_copy[\"samples\"]\r\n        \r\n        t_std, t_mean = torch.std_mean(t, dim=(-2, -1), keepdim=True)\r\n        ref_std, ref_mean = torch.std_mean(reference[\"samples\"], dim=(-2, -1), keepdim=True)\r\n        t = (t - t_mean) / t_std\r\n        t = t * ref_std + ref_mean\r\n        \r\n        latents_copy[\"samples\"] = torch.lerp(latents[\"samples\"], t, factor)\r\n        return (latents_copy,)\r\n\r\n\r\nclass AdainFilterLatent:\r\n    @classmethod\r\n    def INPUT_TYPES(s):\r\n        return {\r\n            \"required\": {\r\n                \"latents\": (\"LATENT\", ),\r\n                \"reference\": (\"LATENT\", ),\r\n                \"filter_size\": (\"INT\", {\"default\": 1, \"min\": 1, \"max\": 128}),\r\n                \"factor\": (\"FLOAT\", {\"default\": 1.0, \"min\": -10.0, \"max\": 10.0, \"step\": 0.01,  \"round\": 0.01}),\r\n            },\r\n        }\r\n\r\n    RETURN_TYPES = (\"LATENT\",)\r\n    FUNCTION = \"batch_normalize\"\r\n    CATEGORY = \"Image-Filters/latent\"\r\n\r\n    def batch_normalize(self, latents, reference, filter_size, factor):\r\n        latents_copy = copy.deepcopy(latents)\r\n        t = latents_copy[\"samples\"].movedim(1, -1) # BCHW -> BHWC or BCFHW -> BFHWC\r\n        ref = reference[\"samples\"].movedim(1, -1)\r\n        d = filter_size * 2 + 1\r\n        \r\n        if t.dim() == 5:\r\n            t_std, t_mean, ref_std, ref_mean = [], [], [], []\r\n            for b in range(t.shape[0]):\r\n                tb_std, tb_mean = std_mean_filter(t[b], d)\r\n                rb_std, rb_mean = std_mean_filter(ref[b], d)\r\n                t_std.append(tb_std)\r\n                t_mean.append(tb_mean)\r\n                ref_std.append(rb_std)\r\n                ref_mean.append(rb_mean)\r\n            t_std = torch.stack(t_std, dim=0)\r\n            t_mean = torch.stack(t_mean, dim=0)\r\n            ref_std = torch.stack(ref_std, dim=0)\r\n            ref_mean = torch.stack(ref_mean, dim=0)\r\n        else:\r\n            t_std, t_mean = std_mean_filter(t, d)\r\n            ref_std, ref_mean = std_mean_filter(ref, d)\r\n        \r\n        t = (t - t_mean) / t_std\r\n        t = t * ref_std + ref_mean\r\n        t = t.movedim(-1, 1) # BHWC -> BCHW or BFHWC -> BCFHW\r\n        \r\n        latents_copy[\"samples\"] = torch.lerp(latents[\"samples\"], t, factor)\r\n        return (latents_copy,)\r\n\r\n\r\nclass SharpenFilterLatent:\r\n    @classmethod\r\n    def INPUT_TYPES(s):\r\n        return {\r\n            \"required\": {\r\n                \"latents\": (\"LATENT\", ),\r\n                \"filter_size\": (\"INT\", {\"default\": 1, \"min\": 1, \"max\": 128}),\r\n                \"factor\": (\"FLOAT\", {\"default\": 1.0, \"min\": -100.0, \"max\": 100.0, \"step\": 0.01,  \"round\": 0.01}),\r\n            },\r\n        }\r\n\r\n    RETURN_TYPES = (\"LATENT\",)\r\n    FUNCTION = \"filter_latent\"\r\n    CATEGORY = \"Image-Filters/latent\"\r\n\r\n    def filter_latent(self, latents, filter_size, factor):\r\n        latents_copy = copy.deepcopy(latents)\r\n        t = latents_copy[\"samples\"].movedim(1, -1) # BCHW -> BHWC or BCFHW -> BFHWC\r\n        d = filter_size * 2 + 1\r\n        \r\n        if t.dim() == 5:\r\n            t_blurred = []\r\n            for b in range(t.shape[0]):\r\n                t_blurred.append(cv_blur_tensor(t[b], d, d))\r\n            t_blurred = torch.stack(t_blurred, dim=0)\r\n        else:\r\n            t_blurred = cv_blur_tensor(t, d, d)\r\n        \r\n        t = t - t_blurred\r\n        t = t * factor\r\n        t = t + t_blurred\r\n        \r\n        t = t.movedim(-1, 1) # BHWC -> BCHW or BFHWC -> BCFHW\r\n        latents_copy[\"samples\"] = t\r\n        return (latents_copy,)\r\n\r\n\r\nclass AdainImage:\r\n    @classmethod\r\n    def INPUT_TYPES(s):\r\n        return {\r\n            \"required\": {\r\n                \"images\": (\"IMAGE\", ),\r\n                \"reference\": (\"IMAGE\", ),\r\n                \"factor\": (\"FLOAT\", {\"default\": 1.0, \"min\": -10.0, \"max\": 10.0, \"step\": 0.01,  \"round\": 0.01}),\r\n            },\r\n        }\r\n\r\n    RETURN_TYPES = (\"IMAGE\",)\r\n    FUNCTION = \"batch_normalize\"\r\n    CATEGORY = \"Image-Filters/image\"\r\n\r\n    def batch_normalize(self, images, reference, factor):\r\n        t = copy.deepcopy(images) # [B x H x W x C]\r\n        \r\n        t = t.movedim(-1,0) # [C x B x H x W]\r\n        for c in range(t.size(0)):\r\n            for i in range(t.size(1)):\r\n                r_sd, r_mean = torch.std_mean(reference[i, :, :, c], dim=None) # index by original dim order\r\n                i_sd, i_mean = torch.std_mean(t[c, i], dim=None)\r\n                \r\n                t[c, i] = ((t[c, i] - i_mean) / i_sd) * r_sd + r_mean\r\n        \r\n        t = torch.lerp(images, t.movedim(0,-1), factor) # [B x H x W x C]\r\n        return (t,)\r\n\r\n\r\nclass BatchNormalizeLatent:\r\n    @classmethod\r\n    def INPUT_TYPES(s):\r\n        return {\r\n            \"required\": {\r\n                \"latents\": (\"LATENT\", ),\r\n                \"factor\": (\"FLOAT\", {\"default\": 1.0, \"min\": -10.0, \"max\": 10.0, \"step\": 0.01,  \"round\": 0.01}),\r\n            },\r\n        }\r\n\r\n    RETURN_TYPES = (\"LATENT\",)\r\n    FUNCTION = \"batch_normalize\"\r\n    CATEGORY = \"Image-Filters/latent\"\r\n\r\n    def batch_normalize(self, latents, factor):\r\n        latents_copy = copy.deepcopy(latents)\r\n        t = latents_copy[\"samples\"] # [B x C x H x W]\r\n        \r\n        t = t.movedim(0,1) # [C x B x H x W]\r\n        for c in range(t.size(0)):\r\n            c_sd, c_mean = torch.std_mean(t[c], dim=None)\r\n            \r\n            for i in range(t.size(1)):\r\n                i_sd, i_mean = torch.std_mean(t[c, i], dim=None)\r\n                t[c, i] = (t[c, i] - i_mean) / i_sd\r\n            \r\n            t[c] = t[c] * c_sd + c_mean\r\n        \r\n        latents_copy[\"samples\"] = torch.lerp(latents[\"samples\"], t.movedim(1,0), factor) # [B x C x H x W]\r\n        return (latents_copy,)\r\n\r\n\r\nclass BatchNormalizeImage:\r\n    @classmethod\r\n    def INPUT_TYPES(s):\r\n        return {\r\n            \"required\": {\r\n                \"images\": (\"IMAGE\", ),\r\n                \"factor\": (\"FLOAT\", {\"default\": 1.0, \"min\": -10.0, \"max\": 10.0, \"step\": 0.01,  \"round\": 0.01}),\r\n            },\r\n        }\r\n\r\n    RETURN_TYPES = (\"IMAGE\",)\r\n    FUNCTION = \"batch_normalize\"\r\n    CATEGORY = \"Image-Filters/image\"\r\n\r\n    def batch_normalize(self, images, factor):\r\n        t = copy.deepcopy(images) # [B x H x W x C]\r\n        \r\n        t = t.movedim(-1,0) # [C x B x H x W]\r\n        for c in range(t.size(0)):\r\n            c_sd, c_mean = torch.std_mean(t[c], dim=None)\r\n            \r\n            for i in range(t.size(1)):\r\n                i_sd, i_mean = torch.std_mean(t[c, i], dim=None)\r\n                \r\n                t[c, i] = (t[c, i] - i_mean) / i_sd\r\n            \r\n            t[c] = t[c] * c_sd + c_mean\r\n        \r\n        t = torch.lerp(images, t.movedim(0,-1), factor) # [B x H x W x C]\r\n        return (t,)\r\n\r\n\r\nclass DifferenceChecker:\r\n    @classmethod\r\n    def INPUT_TYPES(s):\r\n        return {\r\n            \"required\": {\r\n                \"images1\": (\"IMAGE\", ),\r\n                \"images2\": (\"IMAGE\", ),\r\n                \"multiplier\": (\"FLOAT\", {\"default\": 1.0, \"min\": 0.01, \"max\": 1000.0, \"step\": 0.01,  \"round\": 0.01}),\r\n                \"print_MAE\": (\"BOOLEAN\", {\"default\": False}),\r\n            },\r\n        }\r\n\r\n    RETURN_TYPES = (\"IMAGE\",)\r\n    FUNCTION = \"difference_checker\"\r\n    OUTPUT_NODE = True\r\n    CATEGORY = \"Image-Filters/image\"\r\n\r\n    def difference_checker(self, images1, images2, multiplier, print_MAE):\r\n        t = copy.deepcopy(images1)\r\n        t = torch.abs(images1 - images2)\r\n        if print_MAE:\r\n            print(f\"MAE = {torch.mean(t)}\")\r\n        return (torch.clamp(t * multiplier, min=0, max=1),)\r\n\r\n\r\nclass ImageConstant:\r\n    def __init__(self, device=\"cpu\"):\r\n        self.device = device\r\n\r\n    @classmethod\r\n    def INPUT_TYPES(s):\r\n        return {\r\n            \"required\": {\r\n                \"width\": (\"INT\", {\"default\": 512, \"min\": 1, \"max\": MAX_RESOLUTION, \"step\": 1}),\r\n                \"height\": (\"INT\", {\"default\": 512, \"min\": 1, \"max\": MAX_RESOLUTION, \"step\": 1}),\r\n                \"batch_size\": (\"INT\", {\"default\": 1, \"min\": 1, \"max\": 4096}),\r\n                \"red\": (\"FLOAT\", {\"default\": 0.0, \"min\": 0.0, \"max\": 1.0, \"step\": 0.001}),\r\n                \"green\": (\"FLOAT\", {\"default\": 0.0, \"min\": 0.0, \"max\": 1.0, \"step\": 0.001}),\r\n                \"blue\": (\"FLOAT\", {\"default\": 0.0, \"min\": 0.0, \"max\": 1.0, \"step\": 0.001}),\r\n            },\r\n        }\r\n\r\n    RETURN_TYPES = (\"IMAGE\",)\r\n    FUNCTION = \"generate\"\r\n    CATEGORY = \"Image-Filters/image\"\r\n\r\n    def generate(self, width, height, batch_size, red, green, blue):\r\n        r = torch.full([batch_size, height, width, 1], red)\r\n        g = torch.full([batch_size, height, width, 1], green)\r\n        b = torch.full([batch_size, height, width, 1], blue)\r\n        return (torch.cat((r, g, b), dim=-1), )\r\n\r\n\r\nclass ImageConstantHSV:\r\n    def __init__(self, device=\"cpu\"):\r\n        self.device = device\r\n\r\n    @classmethod\r\n    def INPUT_TYPES(s):\r\n        return {\r\n            \"required\": {\r\n                \"width\": (\"INT\", {\"default\": 512, \"min\": 1, \"max\": MAX_RESOLUTION, \"step\": 1}),\r\n                \"height\": (\"INT\", {\"default\": 512, \"min\": 1, \"max\": MAX_RESOLUTION, \"step\": 1}),\r\n                \"batch_size\": (\"INT\", {\"default\": 1, \"min\": 1, \"max\": 4096}),\r\n                \"hue\": (\"FLOAT\", {\"default\": 0.0, \"min\": 0.0, \"max\": 1.0, \"step\": 0.001}),\r\n                \"saturation\": (\"FLOAT\", {\"default\": 0.0, \"min\": 0.0, \"max\": 1.0, \"step\": 0.001}),\r\n                \"value\": (\"FLOAT\", {\"default\": 0.0, \"min\": 0.0, \"max\": 1.0, \"step\": 0.001}),\r\n            },\r\n        }\r\n\r\n    RETURN_TYPES = (\"IMAGE\",)\r\n    FUNCTION = \"generate\"\r\n    CATEGORY = \"Image-Filters/image\"\r\n\r\n    def generate(self, width, height, batch_size, hue, saturation, value):\r\n        red, green, blue = hsv_to_rgb(hue, saturation, value)\r\n        \r\n        r = torch.full([batch_size, height, width, 1], red)\r\n        g = torch.full([batch_size, height, width, 1], green)\r\n        b = torch.full([batch_size, height, width, 1], blue)\r\n        return (torch.cat((r, g, b), dim=-1), )\r\n\r\n\r\nclass OffsetLatentImage:\r\n    def __init__(self):\r\n        self.device = comfy.model_management.intermediate_device()\r\n\r\n    @classmethod\r\n    def INPUT_TYPES(s):\r\n        return {\r\n            \"required\": {\r\n                \"width\": (\"INT\", {\"default\": 512, \"min\": 16, \"max\": MAX_RESOLUTION, \"step\": 8}),\r\n                \"height\": (\"INT\", {\"default\": 512, \"min\": 16, \"max\": MAX_RESOLUTION, \"step\": 8}),\r\n                \"batch_size\": (\"INT\", {\"default\": 1, \"min\": 1, \"max\": 4096}),\r\n                \"offset_0\": (\"FLOAT\", {\"default\": 0.0, \"min\": -10.0, \"max\": 10.0, \"step\": 0.1,  \"round\": 0.1}),\r\n                \"offset_1\": (\"FLOAT\", {\"default\": 0.0, \"min\": -10.0, \"max\": 10.0, \"step\": 0.1,  \"round\": 0.1}),\r\n                \"offset_2\": (\"FLOAT\", {\"default\": 0.0, \"min\": -10.0, \"max\": 10.0, \"step\": 0.1,  \"round\": 0.1}),\r\n                \"offset_3\": (\"FLOAT\", {\"default\": 0.0, \"min\": -10.0, \"max\": 10.0, \"step\": 0.1,  \"round\": 0.1}),\r\n            },\r\n        }\r\n\r\n    RETURN_TYPES = (\"LATENT\",)\r\n    FUNCTION = \"generate\"\r\n    CATEGORY = \"Image-Filters/latent\"\r\n\r\n    def generate(self, width, height, batch_size, offset_0, offset_1, offset_2, offset_3):\r\n        latent = torch.zeros([batch_size, 4, height // 8, width // 8], device=self.device)\r\n        latent[:,0,:,:] = offset_0\r\n        latent[:,1,:,:] = offset_1\r\n        latent[:,2,:,:] = offset_2\r\n        latent[:,3,:,:] = offset_3\r\n        return ({\"samples\":latent}, )\r\n\r\n\r\nclass RelightSimple:\r\n    @classmethod\r\n    def INPUT_TYPES(s):\r\n        return {\r\n            \"required\": {\r\n                \"image\": (\"IMAGE\",),\r\n                \"normals\": (\"IMAGE\",),\r\n                \"x\": (\"FLOAT\", {\"default\": 0.0, \"min\": -1.0, \"max\": 1.0, \"step\": 0.001}),\r\n                \"y\": (\"FLOAT\", {\"default\": 0.0, \"min\": -1.0, \"max\": 1.0, \"step\": 0.001}),\r\n                \"z\": (\"FLOAT\", {\"default\": 1.0, \"min\": -1.0, \"max\": 1.0, \"step\": 0.001}),\r\n                \"brightness\": (\"FLOAT\", {\"default\": 1.0, \"min\": 0.0, \"max\": 100, \"step\": 0.01}),\r\n            },\r\n        }\r\n\r\n    RETURN_TYPES = (\"IMAGE\",)\r\n    FUNCTION = \"relight\"\r\n    CATEGORY = \"Image-Filters/image\"\r\n\r\n    def relight(self, image, normals, x, y, z, brightness):\r\n        if image.shape[0] != normals.shape[0]:\r\n            raise Exception(\"Batch size for image and normals must match\")\r\n        norm = normals.detach().clone() * 2 - 1\r\n        norm = F.interpolate(norm.movedim(-1,1), size=(image.shape[1], image.shape[2]), mode='bilinear').movedim(1,-1)\r\n        light = torch.tensor([x, y, z])\r\n        light = F.normalize(light, dim=0)\r\n        \r\n        diffuse = norm[:,:,:,0] * light[0] + norm[:,:,:,1] * light[1] + norm[:,:,:,2] * light[2]\r\n        diffuse = torch.clip(diffuse.unsqueeze(3).repeat(1,1,1,3), 0, 1)\r\n        \r\n        relit = image.detach().clone()\r\n        relit[:,:,:,:3] = torch.clip(relit[:,:,:,:3] * diffuse * brightness, 0, 1)\r\n        return (relit,)\r\n\r\n\r\nclass LatentStats:\r\n    @classmethod\r\n    def INPUT_TYPES(s):\r\n        return {\"required\": {\"latent\": (\"LATENT\", ),}}\r\n\r\n    RETURN_TYPES = (\"STRING\", \"FLOAT\", \"FLOAT\", \"FLOAT\", \"FLOAT\")\r\n    RETURN_NAMES = (\"stats\", \"c0_mean\", \"c1_mean\", \"c2_mean\", \"c3_mean\")\r\n    FUNCTION = \"notify\"\r\n    OUTPUT_NODE = True\r\n    CATEGORY = \"Image-Filters/utils\"\r\n\r\n    def notify(self, latent):\r\n        latents = latent[\"samples\"]\r\n        channels = latents.size(1)\r\n        width, height = latents.size(3), latents.size(2)\r\n        \r\n        text = [\"\",]\r\n        text[0] = f\"batch size: {latents.size(0)}\"\r\n        text.append(f\"channels: {channels}\")\r\n        text.append(f\"width: {width} ({width * 8})\")\r\n        text.append(f\"height: {height} ({height * 8})\")\r\n        \r\n        cmean = [0,0,0,0]\r\n        for i in range(channels):\r\n            minimum = torch.min(latents[:,i,:,:]).item()\r\n            maximum = torch.max(latents[:,i,:,:]).item()\r\n            std_dev, mean = torch.std_mean(latents[:,i,:,:], dim=None)\r\n            if i < 4:\r\n                cmean[i] = mean\r\n            \r\n            text.append(f\"c{i} mean: {mean:.1f} std_dev: {std_dev:.1f} min: {minimum:.1f} max: {maximum:.1f}\")\r\n        \r\n        \r\n        printtext = \"\\033[36mLatent Stats:\\033[m\"\r\n        for t in text:\r\n            printtext += \"\\n    \" + t\r\n        \r\n        returntext = \"\"\r\n        for i in range(len(text)):\r\n            if i > 0:\r\n                returntext += \"\\n\"\r\n            returntext += text[i]\r\n        \r\n        print(printtext)\r\n        return (returntext, cmean[0], cmean[1], cmean[2], cmean[3])\r\n\r\n\r\nclass Tonemap:\r\n    @classmethod\r\n    def INPUT_TYPES(s):\r\n        return {\r\n            \"required\": {\r\n                \"images\": (\"IMAGE\",),\r\n                \"input_mode\": ([\"linear\", \"sRGB\"],),\r\n                \"output_mode\": ([\"sRGB\", \"linear\"],),\r\n                \"tonemap_scale\": (\"FLOAT\", {\"default\": 1, \"min\": 0.1, \"max\": 10, \"step\": 0.01}),\r\n            },\r\n        }\r\n\r\n    RETURN_TYPES = (\"IMAGE\",)\r\n    FUNCTION = \"apply\"\r\n    CATEGORY = \"Image-Filters/image\"\r\n\r\n    def apply(self, images, input_mode, output_mode, tonemap_scale):\r\n        t = images.detach().clone().cpu().numpy().astype(np.float32)\r\n        \r\n        if input_mode == \"sRGB\":\r\n            sRGBtoLinear(t[:,:,:,:3])\r\n        \r\n        linearToTonemap(t[:,:,:,:3], tonemap_scale)\r\n        \r\n        if output_mode == \"sRGB\":\r\n            linearToSRGB(t[:,:,:,:3])\r\n            t = np.clip(t, 0, 1)\r\n        \r\n        t = torch.from_numpy(t)\r\n        return (t,)\r\n\r\n\r\nclass UnTonemap:\r\n    @classmethod\r\n    def INPUT_TYPES(s):\r\n        return {\r\n            \"required\": {\r\n                \"images\": (\"IMAGE\",),\r\n                \"input_mode\": ([\"sRGB\", \"linear\"],),\r\n                \"output_mode\": ([\"linear\", \"sRGB\"],),\r\n                \"tonemap_scale\": (\"FLOAT\", {\"default\": 1, \"min\": 0.1, \"max\": 10, \"step\": 0.01}),\r\n            },\r\n        }\r\n\r\n    RETURN_TYPES = (\"IMAGE\",)\r\n    FUNCTION = \"apply\"\r\n    CATEGORY = \"Image-Filters/image\"\r\n\r\n    def apply(self, images, input_mode, output_mode, tonemap_scale):\r\n        t = images.detach().clone().cpu().numpy().astype(np.float32)\r\n        \r\n        if input_mode == \"sRGB\":\r\n            sRGBtoLinear(t[:,:,:,:3])\r\n        \r\n        tonemapToLinear(t[:,:,:,:3], tonemap_scale)\r\n        \r\n        if output_mode == \"sRGB\":\r\n            linearToSRGB(t[:,:,:,:3])\r\n            t = np.clip(t, 0, 1)\r\n        \r\n        t = torch.from_numpy(t)\r\n        return (t,)\r\n\r\n\r\nclass ExposureAdjust:\r\n    @classmethod\r\n    def INPUT_TYPES(s):\r\n        return {\r\n            \"required\": {\r\n                \"images\": (\"IMAGE\",),\r\n                \"stops\": (\"FLOAT\", {\"default\": 0.0, \"min\": -100, \"max\": 100, \"step\": 0.01}),\r\n                \"input_mode\": ([\"sRGB\", \"linear\"],),\r\n                \"output_mode\": ([\"sRGB\", \"linear\"],),\r\n                \"tonemap\": ([\"linear\", \"Reinhard\", \"linlog\"], {\"default\": \"Reinhard\"}),\r\n                \"tonemap_scale\": (\"FLOAT\", {\"default\": 1, \"min\": 0.1, \"max\": 10, \"step\": 0.01}),\r\n            },\r\n        }\r\n\r\n    RETURN_TYPES = (\"IMAGE\",)\r\n    FUNCTION = \"adjust_exposure\"\r\n    CATEGORY = \"Image-Filters/image\"\r\n\r\n    def adjust_exposure(self, images, stops, input_mode, output_mode, tonemap, tonemap_scale):\r\n        t = images.detach().clone().cpu().numpy().astype(np.float32)\r\n        \r\n        if input_mode == \"sRGB\":\r\n            sRGBtoLinear(t[...,:3])\r\n        \r\n        if tonemap == \"linlog\":\r\n            tonemapToLinear(t[...,:3], tonemap_scale)\r\n        elif tonemap == \"Reinhard\":\r\n            t = np.clip(t, 0, 0.999)\r\n            t[...,:3] = -t[...,:3] / (t[...,:3] - 1)\r\n        \r\n        exposure(t[...,:3], stops)\r\n        \r\n        if tonemap == \"linlog\":\r\n            linearToTonemap(t[...,:3], tonemap_scale)\r\n        elif tonemap == \"Reinhard\":\r\n            t[...,:3] = t[...,:3] / (t[...,:3] + 1)\r\n        \r\n        if output_mode == \"sRGB\":\r\n            linearToSRGB(t[...,:3])\r\n            t = np.clip(t, 0, 1)\r\n        \r\n        t = torch.from_numpy(t)\r\n        return (t,)\r\n\r\n\r\n# Normal map standard coordinates: +r:+x:right, +g:+y:up, +b:+z:in\r\nclass ConvertNormals:\r\n    @classmethod\r\n    def INPUT_TYPES(s):\r\n        return {\r\n            \"required\": {\r\n                \"normals\": (\"IMAGE\",),\r\n                \"input_mode\": ([\"BAE\", \"MiDaS\", \"Standard\"],),\r\n                \"output_mode\": ([\"BAE\", \"MiDaS\", \"Standard\"],),\r\n                \"scale_XY\": (\"FLOAT\",{\"default\": 1, \"min\": 0, \"max\": 100, \"step\": 0.001}),\r\n                \"normalize\": (\"BOOLEAN\", {\"default\": True}),\r\n                \"fix_black\": (\"BOOLEAN\", {\"default\": True}),\r\n            },\r\n            \"optional\": {\r\n                \"optional_fill\": (\"IMAGE\",),\r\n            },\r\n        }\r\n\r\n    RETURN_TYPES = (\"IMAGE\",)\r\n    FUNCTION = \"convert_normals\"\r\n    CATEGORY = \"Image-Filters/image\"\r\n\r\n    def convert_normals(self, normals, input_mode, output_mode, scale_XY, normalize, fix_black, optional_fill=None):\r\n        t = normals.detach().clone()\r\n        \r\n        if input_mode == \"BAE\":\r\n            t[:,:,:,0] = 1 - t[:,:,:,0] # invert R\r\n        elif input_mode == \"MiDaS\":\r\n            t[:,:,:,:3] = torch.stack([1 - t[:,:,:,2], t[:,:,:,1], t[:,:,:,0]], dim=3) # BGR -> RGB and invert R\r\n        \r\n        if fix_black:\r\n            key = torch.clamp(1 - t[:,:,:,2] * 2, min=0, max=1)\r\n            if optional_fill == None:\r\n                t[:,:,:,0] += key * 0.5\r\n                t[:,:,:,1] += key * 0.5\r\n                t[:,:,:,2] += key\r\n            else:\r\n                fill = optional_fill.detach().clone()\r\n                if fill.shape[1:3] != t.shape[1:3]:\r\n                    fill = F.interpolate(fill.movedim(-1,1), size=(t.shape[1], t.shape[2]), mode='bilinear').movedim(1,-1)\r\n                if fill.shape[0] != t.shape[0]:\r\n                    fill = fill[0].unsqueeze(0).expand(t.shape[0], -1, -1, -1)\r\n                t[:,:,:,:3] += fill[:,:,:,:3] * key.unsqueeze(3).expand(-1, -1, -1, 3)\r\n        \r\n        t[:,:,:,:2] = (t[:,:,:,:2] - 0.5) * scale_XY + 0.5\r\n        \r\n        if normalize:\r\n            t[:,:,:,:3] = F.normalize(t[:,:,:,:3] * 2 - 1, dim=3) / 2 + 0.5\r\n        \r\n        if output_mode == \"BAE\":\r\n            t[:,:,:,0] = 1 - t[:,:,:,0] # invert R\r\n        elif output_mode == \"MiDaS\":\r\n            t[:,:,:,:3] = torch.stack([t[:,:,:,2], t[:,:,:,1], 1 - t[:,:,:,0]], dim=3) # invert R and BGR -> RGB\r\n        \r\n        return (t,)\r\n\r\n\r\nclass BatchAverageImage:\r\n    @classmethod\r\n    def INPUT_TYPES(s):\r\n        return {\r\n            \"required\": {\r\n                \"images\": (\"IMAGE\",),\r\n                \"operation\": ([\"mean\", \"median\"],),\r\n            },\r\n        }\r\n\r\n    RETURN_TYPES = (\"IMAGE\",)\r\n    FUNCTION = \"apply\"\r\n    CATEGORY = \"Image-Filters/image\"\r\n\r\n    def apply(self, images, operation):\r\n        t = images.detach().clone()\r\n        if operation == \"mean\":\r\n            return (torch.mean(t, dim=0, keepdim=True),)\r\n        elif operation == \"median\":\r\n            return (torch.median(t, dim=0, keepdim=True)[0],)\r\n        return(t,)\r\n\r\n\r\nclass NormalMapSimple:\r\n    @classmethod\r\n    def INPUT_TYPES(s):\r\n        return {\r\n            \"required\": {\r\n                \"images\": (\"IMAGE\",),\r\n                \"scale_XY\": (\"FLOAT\",{\"default\": 1, \"min\": 0, \"max\": 100, \"step\": 0.001}),\r\n            },\r\n        }\r\n\r\n    RETURN_TYPES = (\"IMAGE\",)\r\n    FUNCTION = \"normal_map\"\r\n    CATEGORY = \"Image-Filters/image\"\r\n\r\n    def normal_map(self, images, scale_XY):\r\n        t = images.detach().clone().cpu().numpy().astype(np.float32)\r\n        L = np.mean(t[:,:,:,:3], axis=3)\r\n        for i in range(t.shape[0]):\r\n            t[i,:,:,0] = cv2.Scharr(L[i], -1, 1, 0, cv2.BORDER_REFLECT) * -1\r\n            t[i,:,:,1] = cv2.Scharr(L[i], -1, 0, 1, cv2.BORDER_REFLECT)\r\n        t[:,:,:,2] = 1\r\n        t = torch.from_numpy(t)\r\n        t[:,:,:,:2] *= scale_XY\r\n        t[:,:,:,:3] = F.normalize(t[:,:,:,:3], dim=3) / 2 + 0.5\r\n        return (t,)\r\n\r\n\r\nclass DepthToNormals:\r\n    @classmethod\r\n    def INPUT_TYPES(s):\r\n        return {\r\n            \"required\": {\r\n                \"depth\": (\"IMAGE\",),\r\n                \"scale\": (\"FLOAT\",{\"default\": 1, \"min\": 0.001, \"max\": 1000, \"step\": 0.001}),\r\n                \"output_mode\": ([\"Standard\", \"BAE\", \"MiDaS\"],),\r\n            },\r\n        }\r\n\r\n    RETURN_TYPES = (\"IMAGE\",)\r\n    RETURN_NAMES = (\"normals\",)\r\n    FUNCTION = \"normal_map\"\r\n    CATEGORY = \"Image-Filters/image\"\r\n\r\n    def normal_map(self, depth, scale, output_mode):\r\n        kernel_x = torch.Tensor([[0,0,0],[1,0,-1],[0,0,0]]).unsqueeze(0).unsqueeze(0).repeat(3, 1, 1, 1)\r\n        kernel_y = torch.Tensor([[0,1,0],[0,0,0],[0,-1,0]]).unsqueeze(0).unsqueeze(0).repeat(3, 1, 1, 1)\r\n        conv2d = F.conv2d\r\n        pad = F.pad\r\n        \r\n        size_x = depth.size(2)\r\n        size_y = depth.size(1)\r\n        max_dim = max(size_x, size_y)\r\n        position_map = depth.detach().clone() * scale\r\n        xs = torch.linspace(-1 * size_x / max_dim, 1 * size_x / max_dim, steps=size_x)\r\n        ys = torch.linspace(-1 * size_y / max_dim, 1 * size_y / max_dim, steps=size_y)\r\n        grid_x, grid_y = torch.meshgrid(xs, ys, indexing='xy')\r\n        position_map[..., 0] = grid_x.unsqueeze(0)\r\n        position_map[..., 1] = grid_y.unsqueeze(0)\r\n        \r\n        position_map = position_map.movedim(-1, 1) # BCHW\r\n        grad_x = conv2d(pad(position_map, (1,1,1,1), mode='replicate'), kernel_x, padding='valid', groups=3)\r\n        grad_y = conv2d(pad(position_map, (1,1,1,1), mode='replicate'), kernel_y, padding='valid', groups=3)\r\n        \r\n        cross_product = torch.cross(grad_x, grad_y, dim=1)\r\n        normals = F.normalize(cross_product)\r\n        normals[:, 1] *= -1\r\n        \r\n        if output_mode != \"Standard\":\r\n            normals[:, 0] *= -1\r\n        \r\n        if output_mode == \"MiDaS\":\r\n            normals = torch.flip(normals, dims=[1,])\r\n        \r\n        normals = normals.movedim(1, -1) * 0.5 + 0.5 # BHWC\r\n        return (normals,)\r\n\r\n\r\nclass Keyer:\r\n    @classmethod\r\n    def INPUT_TYPES(s):\r\n        return {\r\n            \"required\": {\r\n                \"images\": (\"IMAGE\",),\r\n                \"operation\": ([\"luminance\", \"saturation\", \"max\", \"min\", \"red\", \"green\", \"blue\", \"redscreen\", \"greenscreen\", \"bluescreen\"],),\r\n                \"low\": (\"FLOAT\",{\"default\": 0, \"step\": 0.001}),\r\n                \"high\": (\"FLOAT\",{\"default\": 1, \"step\": 0.001}),\r\n                \"gamma\": (\"FLOAT\",{\"default\": 1.0, \"min\": 0.001, \"step\": 0.001}),\r\n                \"premult\": (\"BOOLEAN\", {\"default\": True}),\r\n            },\r\n        }\r\n\r\n    RETURN_TYPES = (\"IMAGE\", \"IMAGE\", \"MASK\")\r\n    RETURN_NAMES = (\"image\", \"alpha\", \"mask\")\r\n    FUNCTION = \"keyer\"\r\n    CATEGORY = \"Image-Filters/image\"\r\n\r\n    def keyer(self, images, operation, low, high, gamma, premult):\r\n        t = images[:,:,:,:3].detach().clone()\r\n        \r\n        if operation == \"luminance\":\r\n            alpha = 0.2126 * t[:,:,:,0] + 0.7152 * t[:,:,:,1] + 0.0722 * t[:,:,:,2]\r\n        elif operation == \"saturation\":\r\n            minV = torch.min(t, 3)[0]\r\n            maxV = torch.max(t, 3)[0]\r\n            mask = maxV != 0\r\n            alpha = maxV\r\n            alpha[mask] = (maxV[mask] - minV[mask]) / maxV[mask]\r\n        elif operation == \"max\":\r\n            alpha = torch.max(t, 3)[0]\r\n        elif operation == \"min\":\r\n            alpha = torch.min(t, 3)[0]\r\n        elif operation == \"red\":\r\n            alpha = t[:,:,:,0]\r\n        elif operation == \"green\":\r\n            alpha = t[:,:,:,1]\r\n        elif operation == \"blue\":\r\n            alpha = t[:,:,:,2]\r\n        elif operation == \"redscreen\":\r\n            alpha = 0.7 * (t[:,:,:,1] + t[:,:,:,2]) - t[:,:,:,0] + 1\r\n        elif operation == \"greenscreen\":\r\n            alpha = 0.7 * (t[:,:,:,0] + t[:,:,:,2]) - t[:,:,:,1] + 1\r\n        elif operation == \"bluescreen\":\r\n            alpha = 0.7 * (t[:,:,:,0] + t[:,:,:,1]) - t[:,:,:,2] + 1\r\n        else: # should never be reached\r\n            alpha = t[:,:,:,0] * 0\r\n        \r\n        if low == high:\r\n            alpha = (alpha > high).to(t.dtype)\r\n        else:\r\n            alpha = (alpha - low) / (high - low)\r\n        \r\n        if gamma != 1.0:\r\n            alpha = torch.pow(alpha, 1/gamma)\r\n        alpha = torch.clamp(alpha, min=0, max=1).unsqueeze(3).repeat(1,1,1,3)\r\n        if premult:\r\n            t *= alpha\r\n        return (t, alpha, alpha[:,:,:,0])\r\n\r\n\r\njitter_matrix = torch.Tensor([[[1, 0, 0], [0, 1, 0]], [[1, 0, 1], [0, 1, 0]], [[1, 0, 1], [0, 1, 1]],\r\n                              [[1, 0, 0], [0, 1, 1]], [[1, 0,-1], [0, 1, 1]], [[1, 0,-1], [0, 1, 0]],\r\n                              [[1, 0,-1], [0, 1,-1]], [[1, 0, 0], [0, 1,-1]], [[1, 0, 1], [0, 1,-1]]])\r\n\r\nclass JitterImage:\r\n    @classmethod\r\n    def INPUT_TYPES(s):\r\n        return {\r\n            \"required\": {\r\n                \"images\": (\"IMAGE\",),\r\n                \"jitter_scale\": (\"FLOAT\", {\"default\": 1.0, \"min\": 0.1, \"step\": 0.1}),\r\n            },\r\n        }\r\n\r\n    RETURN_TYPES = (\"IMAGE\",)\r\n    FUNCTION = \"jitter\"\r\n    CATEGORY = \"Image-Filters/image/jitter\"\r\n\r\n    def jitter(self, images, jitter_scale):\r\n        t = images.detach().clone().movedim(-1,1) # [B x C x H x W]\r\n        \r\n        theta = jitter_matrix.detach().clone().to(t.device)\r\n        theta[:,0,2] *= jitter_scale * 2 / t.shape[3]\r\n        theta[:,1,2] *= jitter_scale * 2 / t.shape[2]\r\n        affine = F.affine_grid(theta, torch.Size([9, t.shape[1], t.shape[2], t.shape[3]]))\r\n        \r\n        batch = []\r\n        for i in range(t.shape[0]):\r\n            jb = t[i].repeat(9,1,1,1)\r\n            jb = F.grid_sample(jb, affine, mode='bilinear', padding_mode='border', align_corners=None)\r\n            batch.append(jb)\r\n        \r\n        t = torch.cat(batch, dim=0).movedim(1,-1) # [B x H x W x C]\r\n        return (t,)\r\n\r\n\r\nclass UnJitterImage:\r\n    @classmethod\r\n    def INPUT_TYPES(s):\r\n        return {\r\n            \"required\": {\r\n                \"images\": (\"IMAGE\",),\r\n                \"jitter_scale\": (\"FLOAT\", {\"default\": 1.0, \"min\": 0.1, \"step\": 0.1}),\r\n                \"oflow_align\": (\"BOOLEAN\", {\"default\": False}),\r\n            },\r\n        }\r\n\r\n    RETURN_TYPES = (\"IMAGE\",)\r\n    FUNCTION = \"jitter\"\r\n    CATEGORY = \"Image-Filters/image/jitter\"\r\n\r\n    def jitter(self, images, jitter_scale, oflow_align):\r\n        t = images.detach().clone().movedim(-1,1) # [B x C x H x W]\r\n        \r\n        if oflow_align:\r\n            pbar = ProgressBar(t.shape[0] // 9)\r\n            raft_model, raft_device = load_raft()\r\n            batch = []\r\n            for i in trange(t.shape[0] // 9):\r\n                batch1 = t[i*9].unsqueeze(0).repeat(9,1,1,1)\r\n                batch2 = t[i*9:i*9+9]\r\n                flows = raft_flow(raft_model, raft_device, batch1, batch2)\r\n                batch.append(flows)\r\n                pbar.update(1)\r\n            flows = torch.cat(batch, dim=0)\r\n            t = flow_warp(t, flows)\r\n        else:\r\n            theta = jitter_matrix.detach().clone().to(t.device)\r\n            theta[:,0,2] *= jitter_scale * -2 / t.shape[3]\r\n            theta[:,1,2] *= jitter_scale * -2 / t.shape[2]\r\n            affine = F.affine_grid(theta, torch.Size([9, t.shape[1], t.shape[2], t.shape[3]]))\r\n            batch = []\r\n            for i in range(t.shape[0] // 9):\r\n                jb = t[i*9:i*9+9]\r\n                jb = F.grid_sample(jb, affine, mode='bicubic', padding_mode='border', align_corners=None)\r\n                batch.append(jb)\r\n            t = torch.cat(batch, dim=0)\r\n        \r\n        t = t.movedim(1,-1) # [B x H x W x C]\r\n        return (t,)\r\n\r\n\r\nclass BatchAverageUnJittered:\r\n    @classmethod\r\n    def INPUT_TYPES(s):\r\n        return {\r\n            \"required\": {\r\n                \"images\": (\"IMAGE\",),\r\n                \"operation\": ([\"mean\", \"median\"],),\r\n            },\r\n        }\r\n\r\n    RETURN_TYPES = (\"IMAGE\",)\r\n    FUNCTION = \"apply\"\r\n    CATEGORY = \"Image-Filters/image/jitter\"\r\n\r\n    def apply(self, images, operation):\r\n        t = images.detach().clone()\r\n        \r\n        batch = []\r\n        for i in range(t.shape[0] // 9):\r\n            if operation == \"mean\":\r\n                batch.append(torch.mean(t[i*9:i*9+9], dim=0, keepdim=True))\r\n            elif operation == \"median\":\r\n                batch.append(torch.median(t[i*9:i*9+9], dim=0, keepdim=True)[0])\r\n        \r\n        return (torch.cat(batch, dim=0),)\r\n\r\n\r\nclass BatchAlign:\r\n    @classmethod\r\n    def INPUT_TYPES(s):\r\n        return {\r\n            \"required\": {\r\n                \"images\": (\"IMAGE\",),\r\n                \"ref_frame\": (\"INT\", {\"default\": 0, \"min\": 0}),\r\n                \"direction\": ([\"forward\", \"backward\"],),\r\n                \"blur\": (\"INT\", {\"default\": 0, \"min\": 0}),\r\n            },\r\n        }\r\n\r\n    RETURN_TYPES = (\"IMAGE\", \"IMAGE\")\r\n    RETURN_NAMES = (\"aligned\", \"flow\")\r\n    FUNCTION = \"apply\"\r\n    CATEGORY = \"Image-Filters/image\"\r\n\r\n    def apply(self, images, ref_frame, direction, blur):\r\n        t = images.detach().clone().movedim(-1,1) # [B x C x H x W]\r\n        rf = min(ref_frame, t.shape[0] - 1)\r\n        \r\n        raft_model, raft_device = load_raft()\r\n        ref = t[rf].unsqueeze(0).repeat(t.shape[0],1,1,1)\r\n        if direction == \"forward\":\r\n            flows = raft_flow(raft_model, raft_device, ref, t)\r\n        else:\r\n            flows = raft_flow(raft_model, raft_device, t, ref) * -1\r\n        \r\n        if blur > 0:\r\n            d = blur * 2 + 1\r\n            dup = flows.movedim(1,-1).detach().clone().cpu().numpy()\r\n            blurred = []\r\n            for img in dup:\r\n                blurred.append(torch.from_numpy(cv2.GaussianBlur(img, (d,d), 0)).unsqueeze(0).movedim(-1,1))\r\n            flows = torch.cat(blurred).to(flows.device)\r\n        \r\n        t = flow_warp(t, flows)\r\n        \r\n        t = t.movedim(1,-1) # [B x H x W x C]\r\n        f = images.detach().clone() * 0\r\n        f[:,:,:,:2] = flows.movedim(1,-1)\r\n        return (t,f)\r\n\r\n\r\nclass InstructPixToPixConditioningAdvanced:\r\n    @classmethod\r\n    def INPUT_TYPES(s):\r\n        return {\r\n            \"required\": {\r\n                \"positive\": (\"CONDITIONING\", ),\r\n                \"negative\": (\"CONDITIONING\", ),\r\n                \"new\": (\"LATENT\", ),\r\n                \"new_scale\": (\"FLOAT\", {\"default\": 1.0, \"min\": 0.01, \"max\": 100.0, \"step\": 0.01}),\r\n                \"original\": (\"LATENT\", ),\r\n                \"original_scale\": (\"FLOAT\", {\"default\": 1.0, \"min\": 0.01, \"max\": 100.0, \"step\": 0.01}),\r\n            },\r\n        }\r\n\r\n    RETURN_TYPES = (\"CONDITIONING\",\"CONDITIONING\",\"CONDITIONING\",\"LATENT\")\r\n    RETURN_NAMES = (\"cond1\", \"cond2\", \"negative\", \"latent\")\r\n    FUNCTION = \"encode\"\r\n    CATEGORY = \"Image-Filters/conditioning\"\r\n\r\n    def encode(self, positive, negative, new, new_scale, original, original_scale):\r\n        new_shape, orig_shape = new[\"samples\"].shape, original[\"samples\"].shape\r\n        if new_shape != orig_shape:\r\n            raise Exception(f\"Latent shape mismatch: {new_shape} and {orig_shape}\")\r\n        \r\n        out_latent = {}\r\n        out_latent[\"samples\"] = new[\"samples\"] * new_scale\r\n        out = []\r\n        for conditioning in [positive, negative]:\r\n            c = []\r\n            for t in conditioning:\r\n                d = t[1].copy()\r\n                d[\"concat_latent_image\"] = original[\"samples\"] * original_scale\r\n                n = [t[0], d]\r\n                c.append(n)\r\n            out.append(c)\r\n        return (out[0], out[1], negative, out_latent)\r\n\r\n\r\nclass InpaintConditionEncode:\r\n    @classmethod\r\n    def INPUT_TYPES(s):\r\n        return {\r\n            \"required\": {\r\n                \"vae\": (\"VAE\", ),\r\n                \"pixels\": (\"IMAGE\", ),\r\n                \"mask\": (\"MASK\", ),\r\n            },}\r\n\r\n    RETURN_TYPES = (\"INPAINT_CONDITION\",)\r\n    RETURN_NAMES = (\"inpaint_condition\",)\r\n    FUNCTION = \"encode\"\r\n    CATEGORY = \"Image-Filters/conditioning\"\r\n\r\n    def encode(self, vae, pixels, mask):\r\n        x = (pixels.shape[1] // 8) * 8\r\n        y = (pixels.shape[2] // 8) * 8\r\n        mask = F.interpolate(mask.reshape((-1, 1, mask.shape[-2], mask.shape[-1])), size=(pixels.shape[1], pixels.shape[2]), mode=\"bilinear\")\r\n\r\n        pixels = pixels.clone()\r\n        if pixels.shape[1] != x or pixels.shape[2] != y:\r\n            x_offset = (pixels.shape[1] % 8) // 2\r\n            y_offset = (pixels.shape[2] % 8) // 2\r\n            pixels = pixels[:,x_offset:x + x_offset, y_offset:y + y_offset,:]\r\n            mask = mask[:,:,x_offset:x + x_offset, y_offset:y + y_offset]\r\n\r\n        m = (1.0 - mask.round()).squeeze(1)\r\n        for i in range(3):\r\n            pixels[:,:,:,i] -= 0.5\r\n            pixels[:,:,:,i] *= m\r\n            pixels[:,:,:,i] += 0.5\r\n        concat_latent = vae.encode(pixels)\r\n        \r\n        return ({\"concat_latent_image\": concat_latent, \"concat_mask\": mask},)\r\n\r\n\r\nclass InpaintConditionApply:\r\n    @classmethod\r\n    def INPUT_TYPES(s):\r\n        return {\r\n            \"required\": {\r\n                \"positive\": (\"CONDITIONING\", ),\r\n                \"negative\": (\"CONDITIONING\", ),\r\n                \"inpaint_condition\": (\"INPAINT_CONDITION\", ),\r\n                \"noise_mask\": (\"BOOLEAN\", {\"default\": False, \"tooltip\": \"Add a noise mask to the latent so sampling will only happen within the mask. Might improve results or completely break things depending on the model.\"}),\r\n                },\r\n            \"optional\": {\r\n                \"latents_optional\": (\"LATENT\",),\r\n            },}\r\n\r\n    RETURN_TYPES = (\"CONDITIONING\",\"CONDITIONING\",\"LATENT\")\r\n    RETURN_NAMES = (\"positive\", \"negative\", \"latent\")\r\n    FUNCTION = \"encode\"\r\n    CATEGORY = \"Image-Filters/conditioning\"\r\n\r\n    def encode(self, positive, negative, inpaint_condition, noise_mask=True, latents_optional=None):\r\n        concat_latent = inpaint_condition[\"concat_latent_image\"]\r\n        concat_mask = inpaint_condition[\"concat_mask\"]\r\n        \r\n        if latents_optional is not None:\r\n            out_latent = latents_optional.copy()\r\n        else:\r\n            out_latent = {}\r\n            out_latent[\"samples\"] = torch.zeros_like(concat_latent)\r\n        \r\n        if noise_mask:\r\n            out_latent[\"noise_mask\"] = concat_mask\r\n\r\n        out = []\r\n        for conditioning in [positive, negative]:\r\n            c = node_helpers.conditioning_set_values(conditioning, {\"concat_latent_image\": concat_latent,\r\n                                                                    \"concat_mask\": concat_mask})\r\n            out.append(c)\r\n        return (out[0], out[1], out_latent)\r\n\r\n\r\nclass LatentNormalizeShuffle:\r\n    @classmethod\r\n    def INPUT_TYPES(s):\r\n        return {\r\n            \"required\": {\r\n                \"latents\": (\"LATENT\", ),\r\n                \"flatten\": (\"INT\", {\"default\": 0, \"min\": 0, \"max\": 16}),\r\n                \"normalize\": (\"BOOLEAN\", {\"default\": True}),\r\n                \"shuffle\": (\"BOOLEAN\", {\"default\": True}),\r\n            },\r\n        }\r\n\r\n    RETURN_TYPES = (\"LATENT\",)\r\n    FUNCTION = \"batch_normalize\"\r\n    CATEGORY = \"Image-Filters/latent\"\r\n\r\n    def batch_normalize(self, latents, flatten, normalize, shuffle):\r\n        latents_copy = copy.deepcopy(latents)\r\n        t = latents_copy[\"samples\"] # [B x C x H x W]\r\n        \r\n        if flatten > 0:\r\n            d = flatten * 2 + 1\r\n            channels = t.shape[1]\r\n            kernel = gaussian_kernel(d, 1, device=t.device).repeat(channels, 1, 1).unsqueeze(1)\r\n            t_blurred = F.conv2d(t, kernel, padding='same', groups=channels)\r\n            t = t - t_blurred\r\n        \r\n        if normalize:\r\n            for b in range(t.shape[0]):\r\n                for c in range(4):\r\n                    t_sd, t_mean = torch.std_mean(t[b,c])\r\n                    t[b,c] = (t[b,c] - t_mean) / t_sd\r\n        \r\n        if shuffle:\r\n            t_shuffle = []\r\n            for i in (1,2,3,0):\r\n                t_shuffle.append(t[:,i])\r\n            t = torch.stack(t_shuffle, dim=1)\r\n        \r\n        latents_copy[\"samples\"] = t\r\n        return (latents_copy,)\r\n\r\n\r\nclass RandnLikeLatent:\r\n    @classmethod\r\n    def INPUT_TYPES(s):\r\n        return {\r\n            \"required\": {\r\n                \"latents\": (\"LATENT\", ),\r\n                \"seed\": (\"INT\", {\"default\": 0, \"min\": 0, \"max\": 0xffffffffffffffff, \"control_after_generate\": True, \"tooltip\": \"The random seed used for creating the noise.\"}),\r\n            },\r\n        }\r\n\r\n    RETURN_TYPES = (\"LATENT\",)\r\n    FUNCTION = \"generate\"\r\n    CATEGORY = \"Image-Filters/latent\"\r\n\r\n    def generate(self, latents, seed):\r\n        latents_copy = copy.deepcopy(latents)\r\n        gen_cpu = torch.Generator(device=\"cpu\").manual_seed(seed)\r\n        latents_copy[\"samples\"] = randn_like_g(latents_copy[\"samples\"], generator=gen_cpu)\r\n        return (latents_copy,)\r\n\r\n\r\nclass PrintSigmas:\r\n    @classmethod\r\n    def INPUT_TYPES(s):\r\n        return {\r\n            \"required\": {\"sigmas\": (\"SIGMAS\",)}\r\n        }\r\n\r\n    RETURN_TYPES = (\"SIGMAS\",)\r\n    FUNCTION = \"notify\"\r\n    OUTPUT_NODE = True\r\n    CATEGORY = \"Image-Filters/utils\"\r\n    \r\n    def notify(self, sigmas):\r\n        print(sigmas)\r\n        return (sigmas,)\r\n\r\n\r\nclass ShowSigmas:\r\n    @classmethod\r\n    def INPUT_TYPES(s):\r\n        return {\r\n            \"required\": {\"sigmas\": (\"SIGMAS\",)},\r\n            \"hidden\": {\"unique_id\": \"UNIQUE_ID\",},\r\n        }\r\n\r\n    RETURN_TYPES = (\"SIGMAS\",)\r\n    FUNCTION = \"show_sigmas\"\r\n    OUTPUT_NODE = True\r\n    CATEGORY = \"Image-Filters/utils\"\r\n    \r\n    def show_sigmas(self, sigmas, unique_id=None):\r\n        if unique_id:\r\n            PromptServer.instance.send_progress_text(f\"{sigmas}\", unique_id)\r\n        return (sigmas,)\r\n\r\n\r\nclass VisualizeLatents:\r\n    @classmethod\r\n    def INPUT_TYPES(s):\r\n        return {\r\n            \"required\": {\"latent\": (\"LATENT\", ),}\r\n        }\r\n\r\n    RETURN_TYPES = (\"IMAGE\",)\r\n    FUNCTION = \"visualize\"\r\n    CATEGORY = \"Image-Filters/utils\"\r\n\r\n    def visualize(self, latent):\r\n        latents = latent[\"samples\"]\r\n        batch, channels, height, width = latents.size()\r\n        \r\n        latents = latents - latents.mean()\r\n        latents = latents / latents.std()\r\n        latents = latents / 10 + 0.5\r\n        \r\n        scale = int(channels ** 0.5)\r\n        vis = torch.zeros(batch, height * scale, width * scale)\r\n        \r\n        for i in range(channels):\r\n            start_h  = (i % scale) * height\r\n            end_h    = start_h + height\r\n            start_w  = (i // scale) * width\r\n            end_w    = start_w + width\r\n            \r\n            vis[:, start_h:end_h, start_w:end_w] = latents[:, i]\r\n        \r\n        return (vis.unsqueeze(-1).repeat(1, 1, 1, 3),)\r\n\r\n\r\nclass GameOfLife:\r\n    @classmethod\r\n    def INPUT_TYPES(s):\r\n        return {\r\n            \"required\": {\r\n                \"width\": (\"INT\", { \"default\": 32, \"min\": 8, \"max\": 1024, \"step\": 1}),\r\n                \"height\": (\"INT\", { \"default\": 32, \"min\": 8, \"max\": 1024, \"step\": 1}),\r\n                \"cell_size\": (\"INT\", { \"default\": 16, \"min\": 8, \"max\": 1024, \"step\": 8}),\r\n                \"seed\": (\"INT\", { \"default\": 0, \"min\": 0, \"max\": 0xffffffffffffffff, \"step\": 1}),\r\n                \"threshold\": (\"FLOAT\", { \"default\": 0.8, \"min\": 0.0, \"max\": 1.0, \"step\": 0.01}),\r\n                \"steps\": (\"INT\", { \"default\": 64, \"min\": 1, \"max\": 999999, \"step\": 1}),\r\n            },\r\n            \"optional\": {\r\n                \"optional_start\": (\"MASK\", ),\r\n            },\r\n        }\r\n\r\n    RETURN_TYPES = (\"IMAGE\", \"MASK\", \"MASK\", \"MASK\")\r\n    RETURN_NAMES = (\"image\", \"mask\", \"off\", \"on\")\r\n    FUNCTION = \"game\"\r\n    CATEGORY = \"Image-Filters/image\"\r\n\r\n    def game(self, width, height, cell_size, seed, threshold, steps, optional_start=None):\r\n        if optional_start is None:\r\n            # base random initialization\r\n            torch.manual_seed(seed)\r\n            grid = torch.rand(1, 1, height, width)\r\n        else:\r\n            grid = optional_start[0].unsqueeze(0).unsqueeze(0)\r\n            grid = F.interpolate(grid, size=(height, width))\r\n        \r\n        grid = (grid > threshold).type(torch.uint8)\r\n        empty = torch.zeros(1, 1, height, width, dtype=torch.uint8)\r\n        \r\n        # neighbor convolution kernel\r\n        kernel = torch.ones(1, 1, 3, 3, dtype=torch.uint8)\r\n        kernel[0, 0, 1, 1] = 0\r\n        \r\n        game_states = [[], [], []] # grid, turn_off, turn_on\r\n        game_states[0].append(grid.detach().clone())\r\n        game_states[1].append(empty.detach().clone())\r\n        game_states[2].append(empty.detach().clone())\r\n        for step in range(steps - 1):\r\n            new_state = grid.detach().clone()\r\n            neighbors = F.conv2d(F.pad(new_state, pad=(1, 1, 1, 1), mode=\"circular\"), kernel) #, padding=\"same\")\r\n            \r\n            # If a cell is ON and has fewer than two neighbors that are ON, it turns OFF\r\n            new_state[(new_state == 1) == (neighbors < 2)] = 0\r\n            \r\n            # If a cell is ON and has either two or three neighbors that are ON, it remains ON.\r\n            \r\n            # If a cell is ON and has more than three neighbors that are ON, it turns OFF.\r\n            new_state[(new_state == 1) == (neighbors > 3)] = 0\r\n            \r\n            # If a cell is OFF and has exactly three neighbors that are ON, it turns ON.\r\n            new_state[(new_state == 0) == (neighbors == 3)] = 1\r\n            \r\n            turn_off = ((grid - new_state) == 1).type(torch.uint8)\r\n            turn_on = ((new_state - grid) == 1).type(torch.uint8)\r\n            \r\n            game_states[0].append(new_state.detach().clone())\r\n            game_states[1].append(turn_off.detach().clone())\r\n            game_states[2].append(turn_on.detach().clone())\r\n            \r\n            grid = new_state\r\n        \r\n        def postprocess(tensorlist, to_image=False):\r\n            game_anim = torch.cat(tensorlist, dim=0).type(torch.float32)\r\n            game_anim = F.interpolate(game_anim, size=(height * cell_size, width * cell_size))\r\n            game_anim = torch.squeeze(game_anim, dim=1) # BCHW -> BHW\r\n            if to_image:\r\n                game_anim = game_anim.unsqueeze(-1).repeat(1,1,1,3) # BHWC\r\n            return game_anim\r\n        \r\n        image = postprocess(game_states[0], to_image=True)\r\n        mask = postprocess(game_states[0])\r\n        off = postprocess(game_states[1])\r\n        on = postprocess(game_states[2])\r\n        \r\n        return (image, mask, off, on)\r\n\r\n\r\nmodeltest_code_default = \"\"\"d = model.model.model_config.unet_config\r\nfor k in d.keys():\r\n    print(k, d[k])\"\"\"\r\n\r\nclass ModelTest:\r\n    @classmethod\r\n    def INPUT_TYPES(s):\r\n        return {\r\n            \"required\": {\r\n                \"model\": (\"MODEL\",),\r\n                \"code\": (\"STRING\", {\"multiline\": True, \"default\": modeltest_code_default}),\r\n            },\r\n        }\r\n\r\n    RETURN_TYPES = ()\r\n    FUNCTION = \"test\"\r\n    OUTPUT_NODE = True\r\n    CATEGORY = \"Image-Filters/utils\"\r\n    \r\n    def test(self, model, code):\r\n        exec(code)\r\n        return ()\r\n\r\n\r\nclass ConditioningSubtract:\r\n    @classmethod\r\n    def INPUT_TYPES(s):\r\n        return {\r\n            \"required\": {\r\n                \"cond_orig\": (\"CONDITIONING\", ),\r\n                \"cond_subtract\": (\"CONDITIONING\", ),\r\n                \"subtract_strength\": (\"FLOAT\", {\"default\": 1.0, \"step\": 0.01}),\r\n            },\r\n        }\r\n\r\n    RETURN_TYPES = (\"CONDITIONING\",)\r\n    FUNCTION = \"addWeighted\"\r\n    CATEGORY = \"Image-Filters/conditioning\"\r\n\r\n    def addWeighted(self, cond_orig, cond_subtract, subtract_strength):\r\n        out = []\r\n\r\n        if len(cond_subtract) > 1:\r\n            logging.warning(\"Warning: ConditioningSubtract cond_subtract contains more than 1 cond, only the first one will actually be applied to cond_orig.\")\r\n\r\n        cond_from = cond_subtract[0][0]\r\n        pooled_output_from = cond_subtract[0][1].get(\"pooled_output\", None)\r\n\r\n        for i in range(len(cond_orig)):\r\n            t1 = cond_orig[i][0]\r\n            pooled_output_to = cond_orig[i][1].get(\"pooled_output\", pooled_output_from)\r\n            t0 = cond_from[:,:t1.shape[1]]\r\n            if t0.shape[1] < t1.shape[1]:\r\n                t0 = torch.cat([t0] + [torch.zeros((1, (t1.shape[1] - t0.shape[1]), t1.shape[2]))], dim=1)\r\n\r\n            tw = t1 - torch.mul(t0, subtract_strength)\r\n            t_to = cond_orig[i][1].copy()\r\n            if pooled_output_from is not None and pooled_output_to is not None:\r\n                t_to[\"pooled_output\"] = pooled_output_to - torch.mul(pooled_output_from, subtract_strength)\r\n            elif pooled_output_from is not None:\r\n                t_to[\"pooled_output\"] = pooled_output_from\r\n\r\n            n = [tw, t_to]\r\n            out.append(n)\r\n        return (out, )\r\n\r\n\r\nclass Noise_CustomNoise:\r\n    def __init__(self, noise_latent):\r\n        self.seed = 0\r\n        self.noise_latent = noise_latent\r\n\r\n    def generate_noise(self, input_latent):\r\n        return self.noise_latent.detach().clone().cpu()\r\n\r\n\r\nclass CustomNoise:\r\n    @classmethod\r\n    def INPUT_TYPES(s):\r\n        return {\r\n            \"required\":{\"noise\": (\"LATENT\",),}\r\n        }\r\n\r\n    RETURN_TYPES = (\"NOISE\",)\r\n    FUNCTION = \"get_noise\"\r\n    CATEGORY = \"Image-Filters/sampling\"\r\n\r\n    def get_noise(self, noise):\r\n        noise_latent = noise[\"samples\"].detach().clone()\r\n        std, mean = torch.std_mean(noise_latent, dim=(-2, -1), keepdim=True)\r\n        noise_latent = (noise_latent - mean) / std\r\n        return (Noise_CustomNoise(noise_latent),)\r\n\r\n\r\nclass ExtractNFrames:\r\n    @classmethod\r\n    def INPUT_TYPES(s):\r\n        return {\r\n            \"required\": {\r\n                \"frames\": (\"INT\", {\"default\": 16, \"min\": 2}),\r\n            },\r\n            \"optional\": {\r\n                \"images\": (\"IMAGE\",),\r\n                \"masks\": (\"MASK\",),\r\n            },\r\n        }\r\n\r\n    RETURN_TYPES = (\"LIST\", \"IMAGE\", \"MASK\")\r\n    RETURN_NAMES = (\"index_list\", \"images\", \"masks\")\r\n    FUNCTION = \"extract\"\r\n    CATEGORY = \"Image-Filters/image/frames\"\r\n    \r\n    def extract(self, frames, images=None, masks=None):\r\n        original_length = 2\r\n        if images is not None: original_length = max(original_length, len(images))\r\n        if masks is not None: original_length = max(original_length, len(masks))\r\n        \r\n        n = min(original_length, frames)\r\n        step = step = (original_length - 1) / (n - 1)\r\n        ids = [round(i * step) for i in range(n)]\r\n        while len(ids) < frames:\r\n            ids.append(ids[-1])\r\n        \r\n        new_images = []\r\n        new_masks = []\r\n        for i in ids:\r\n            if images is not None:\r\n                new_images.append(images[min(i, len(images) - 1)].detach().clone())\r\n            else:\r\n                new_images.append(torch.zeros(512, 512, 3))\r\n            \r\n            if masks is not None:\r\n                new_masks.append(masks[min(i, len(masks) - 1)].detach().clone())\r\n            else:\r\n                new_masks.append(torch.zeros(512, 512))\r\n        \r\n        return (ids, torch.stack(new_images, dim=0), torch.stack(new_masks, dim=0))\r\n\r\n\r\nclass MergeFramesByIndex:\r\n    @classmethod\r\n    def INPUT_TYPES(s):\r\n        return {\r\n            \"required\": {\r\n                \"index_list\": (\"LIST\",),\r\n                \"orig_images\": (\"IMAGE\",),\r\n                \"images\": (\"IMAGE\",),\r\n            },\r\n            \"optional\": {\r\n                \"orig_masks\": (\"MASK\",),\r\n                \"masks\": (\"MASK\",),\r\n            },\r\n        }\r\n\r\n    RETURN_TYPES = (\"IMAGE\", \"MASK\")\r\n    RETURN_NAMES = (\"images\", \"masks\")\r\n    FUNCTION = \"merge\"\r\n    CATEGORY = \"Image-Filters/image/frames\"\r\n    \r\n    def merge(self, index_list, orig_images, images, orig_masks=None, masks=None):\r\n        new_images = orig_images.detach().clone()\r\n        new_masks = torch.ones_like(new_images[..., 0]) # BHW\r\n        if orig_masks is not None:\r\n            for i in range(len(new_masks)):\r\n                new_masks[i] = orig_masks[min(i, len(orig_masks) - 1)].detach().clone()\r\n        \r\n        for i, frame in enumerate(index_list):\r\n            frame_mask = masks[i] if masks is not None else torch.ones_like(new_masks[i])\r\n            new_images[frame] *= (1 - frame_mask[..., None])\r\n            new_images[frame] += images[i].detach().clone() * frame_mask[..., None]\r\n            new_masks[frame] *= 0\r\n        \r\n        return (new_images, new_masks)\r\n\r\n\r\nclass Hunyuan3Dv2LatentUpscaleBy:\r\n    @classmethod\r\n    def INPUT_TYPES(s):\r\n        return {\r\n            \"required\": {\r\n                \"samples\": (\"LATENT\",),\r\n                \"scale_by\": (\"FLOAT\", {\"default\": 2.0, \"min\": 0.01, \"max\": 8.0, \"step\": 0.01}),\r\n            },\r\n        }\r\n    \r\n    RETURN_TYPES = (\"LATENT\",)\r\n    FUNCTION = \"upscale\"\r\n    CATEGORY = \"Image-Filters/latent\"\r\n\r\n    def upscale(self, samples, scale_by):\r\n        s = samples.copy()\r\n        size = round(samples[\"samples\"].shape[-1] * scale_by)\r\n        s[\"samples\"] = F.interpolate(samples[\"samples\"], size=(size,), mode=\"nearest-exact\")\r\n        return (s,)\r\n\r\n\r\nclass PackVideoMask:\r\n    @classmethod\r\n    def INPUT_TYPES(s):\r\n        return {\r\n            \"required\": {\r\n                \"mask\": (\"MASK\",),\r\n                \"blend_mode\": ([\"max\", \"min\", \"average\"], {\"default\": \"max\"}),\r\n                \"causal\": (\"BOOLEAN\", {\"default\": True, \"tooltip\": \"First latent frame is a single frame\"}),\r\n                \"stride\": (\"INT\", {\"default\": 4, \"min\": 1, \"tooltip\": \"downsampling factor to match VAE, ie 4 for Wan, 8 for LTXV\"}),\r\n            },\r\n        }\r\n\r\n    RETURN_TYPES = (\"MASK\",)\r\n    FUNCTION = \"pack_mask\"\r\n    CATEGORY = \"Image-Filters/mask\"\r\n\r\n    def pack_mask(self, mask, blend_mode, causal, stride):\r\n        packed_mask = mask.detach().clone()\r\n        \r\n        # repeat first frame to match stride\r\n        if causal:\r\n            dup_first_frame = packed_mask[0].unsqueeze(0).repeat(stride - 1, 1, 1)\r\n            packed_mask = torch.cat([dup_first_frame, packed_mask], dim=0)\r\n        \r\n        # repeat last frame to match stride\r\n        remainder = packed_mask.shape[0] % stride\r\n        if remainder > 0:\r\n            dup_last_frame = packed_mask[-1].unsqueeze(0).repeat(stride - remainder, 1, 1)\r\n            packed_mask = torch.cat([packed_mask, dup_last_frame], dim=0)\r\n        \r\n        # shuffle every n frame chunk to channels\r\n        B, H, W = packed_mask.shape\r\n        packed_mask = packed_mask.reshape(B // stride, stride, H, W)\r\n        \r\n        # squash channels\r\n        if blend_mode == \"max\":\r\n            squashed_mask = packed_mask.max(dim=1).values\r\n        elif blend_mode == \"min\":\r\n            squashed_mask = packed_mask.min(dim=1).values\r\n        else: # average\r\n            squashed_mask = packed_mask.mean(dim=1)\r\n        \r\n        return (squashed_mask,)\r\n\r\n\r\nclass PoissonNoise:\r\n    @classmethod\r\n    def INPUT_TYPES(s):\r\n        return {\r\n            \"required\": {\r\n                \"image\": (\"IMAGE\",),\r\n                \"gain\": (\"FLOAT\", {\"default\": 1000, \"min\": 0.001, \"max\": 1_000_000, \"step\": 0.001}),\r\n                \"gain_r\": (\"FLOAT\", {\"default\": 1.0, \"min\": 0, \"max\": 1_000_000, \"step\": 0.001}),\r\n                \"gain_g\": (\"FLOAT\", {\"default\": 2.0, \"min\": 0, \"max\": 1_000_000, \"step\": 0.001}),\r\n                \"gain_b\": (\"FLOAT\", {\"default\": 0.5, \"min\": 0, \"max\": 1_000_000, \"step\": 0.001}),\r\n                \"clamp\": (\"BOOLEAN\", {\"default\": True}),\r\n                \"seed\": (\"INT\", {\"default\": 0, \"min\": 0, \"max\": 0xffffffffffffffff}),\r\n            },\r\n        }\r\n\r\n    RETURN_TYPES = (\"IMAGE\",)\r\n    FUNCTION = \"poissson_noise\"\r\n    CATEGORY = \"Image-Filters/image\"\r\n\r\n    def poissson_noise(self, image, gain, gain_r, gain_g, gain_b, clamp, seed):\r\n        linear = sRGBtoLinear_pt(image.cpu().clone())\r\n        \r\n        linear[..., 0] *= gain_r\r\n        linear[..., 1] *= gain_g\r\n        linear[..., 2] *= gain_b\r\n        \r\n        generator = torch.Generator(\"cpu\").manual_seed(seed)\r\n        noise = torch.poisson(linear * gain, generator) * (1 / gain)\r\n        \r\n        noise[..., 0] *= 1 / gain_r\r\n        noise[..., 1] *= 1 / gain_g\r\n        noise[..., 2] *= 1 / gain_b\r\n        \r\n        output = linearToSRGB_pt(noise)\r\n        if clamp: output = torch.clamp(output, min=0, max=1)\r\n        return(output,)\r\n\r\n\r\nCOMBINED_MAPPINGS = {\r\n    \"AdainFilterLatent\":          (AdainFilterLatent,          \"AdaIN Filter (Latent)\"),\r\n    \"AdainImage\":                 (AdainImage,                 \"AdaIN (Image)\"),\r\n    \"AdainLatent\":                (AdainLatent,                \"AdaIN (Latent)\"),\r\n    \"AlphaClean\":                 (AlphaClean,                 \"Alpha Clean (DEPRECATED, use MaskClean)\"),\r\n    \"AlphaMatte\":                 (AlphaMatte,                 \"Alpha Matte (DEPRECATED, use ImageMatting)\"),\r\n    \"BatchAlign\":                 (BatchAlign,                 \"Batch Align (RAFT)\"),\r\n    \"BatchAverageImage\":          (BatchAverageImage,          \"Batch Average Image\"),\r\n    \"BatchAverageUnJittered\":     (BatchAverageUnJittered,     \"Batch Average Un-Jittered\"),\r\n    \"BatchNormalizeImage\":        (BatchNormalizeImage,        \"Batch Normalize (Image)\"),\r\n    \"BatchNormalizeLatent\":       (BatchNormalizeLatent,       \"Batch Normalize (Latent)\"),\r\n    \"BetterFilmGrain\":            (BetterFilmGrain,            \"Better Film Grain\"),\r\n    \"BilateralFilterImage\":       (BilateralFilterImage,       \"Bilateral Filter Image\"),\r\n    \"BlurImageFast\":              (BlurImageFast,              \"Blur Image (Fast)\"),\r\n    \"BlurMaskFast\":               (BlurMaskFast,               \"Blur Mask (Fast)\"),\r\n    \"ClampImage\":                 (ClampImage,                 \"Clamp Image\"),\r\n    \"ClampOutliers\":              (ClampOutliers,              \"Clamp Outliers\"),\r\n    \"ColorMatchImage\":            (ColorMatchImage,            \"Color Match Image\"),\r\n    \"ConditioningSubtract\":       (ConditioningSubtract,       \"ConditioningSubtract\"),\r\n    \"ConvertNormals\":             (ConvertNormals,             \"Convert Normals\"),\r\n    \"CustomNoise\":                (CustomNoise,                \"CustomNoise\"),\r\n    \"DepthToNormals\":             (DepthToNormals,             \"Depth To Normals\"),\r\n    \"DifferenceChecker\":          (DifferenceChecker,          \"Difference Checker\"),\r\n    \"DilateErodeMask\":            (DilateErodeMask,            \"Dilate/Erode Mask\"),\r\n    \"EnhanceDetail\":              (EnhanceDetail,              \"Enhance Detail\"),\r\n    \"ExposureAdjust\":             (ExposureAdjust,             \"Exposure Adjust\"),\r\n    \"ExtractNFrames\":             (ExtractNFrames,             \"Extract N Frames\"),\r\n    \"FrequencyCombine\":           (FrequencyCombine,           \"Frequency Combine\"),\r\n    \"FrequencySeparate\":          (FrequencySeparate,          \"Frequency Separate\"),\r\n    \"GameOfLife\":                 (GameOfLife,                 \"Game Of Life\"),\r\n    \"GuidedFilterImage\":          (GuidedFilterImage,          \"Guided Filter Image\"),\r\n    \"Hunyuan3Dv2LatentUpscaleBy\": (Hunyuan3Dv2LatentUpscaleBy, \"Upscale Hunyuan3Dv2 Latent By\"),\r\n    \"ImageConstant\":              (ImageConstant,              \"Image Constant Color (RGB)\"),\r\n    \"ImageConstantHSV\":           (ImageConstantHSV,           \"Image Constant Color (HSV)\"),\r\n    \"ImageMatting\":               (ImageMatting,               \"Image Matting\"),\r\n    \"InpaintConditionApply\":      (InpaintConditionApply,      \"Inpaint Condition Apply\"),\r\n    \"InpaintConditionEncode\":     (InpaintConditionEncode,     \"Inpaint Condition Encode\"),\r\n    \"InstructPixToPixConditioningAdvanced\": (InstructPixToPixConditioningAdvanced, \"IP2P Conditioning Advanced\"),\r\n    \"JitterImage\":                (JitterImage,                \"Jitter Image\"),\r\n    \"Keyer\":                      (Keyer,                      \"Keyer\"),\r\n    \"LatentNormalizeShuffle\":     (LatentNormalizeShuffle,     \"LatentNormalizeShuffle\"),\r\n    \"RandnLikeLatent\":            (RandnLikeLatent,            \"RandnLikeLatent\"),\r\n    \"LatentStats\":                (LatentStats,                \"Latent Stats\"),\r\n    \"MaskClean\":                  (MaskClean,                  \"Mask (Alpha) Clean\"),\r\n    \"MedianFilterImage\":          (MedianFilterImage,          \"Median Filter Image\"),\r\n    \"MergeFramesByIndex\":         (MergeFramesByIndex,         \"Merge Frames By Index\"),\r\n    \"ModelTest\":                  (ModelTest,                  \"Model Test\"),\r\n    \"NormalMapSimple\":            (NormalMapSimple,            \"Normal Map (Simple)\"),\r\n    \"OffsetLatentImage\":          (OffsetLatentImage,          \"Offset Latent Image\"),\r\n    \"PackVideoMask\":              (PackVideoMask,              \"Pack Video Mask\"),\r\n    \"PoissonNoise\":               (PoissonNoise,               \"Poisson Noise Image\"),\r\n    \"PrintSigmas\":                (PrintSigmas,                \"Print Sigmas\"),\r\n    \"RelightSimple\":              (RelightSimple,              \"Relight (Simple)\"),\r\n    \"RemapRange\":                 (RemapRange,                 \"Remap Range\"),\r\n    \"RestoreDetail\":              (RestoreDetail,              \"Restore Detail\"),\r\n    \"SharpenFilterLatent\":        (SharpenFilterLatent,        \"Sharpen Filter (Latent)\"),\r\n    \"ShowSigmas\":                 (ShowSigmas,                 \"Show Sigmas\"),\r\n    \"ShuffleChannels\":            (ShuffleChannels,            \"Shuffle Channels\"),\r\n    \"Tonemap\":                    (Tonemap,                    \"Tonemap\"),\r\n    \"UnJitterImage\":              (UnJitterImage,              \"Un-Jitter Image\"),\r\n    \"UnTonemap\":                  (UnTonemap,                  \"UnTonemap\"),\r\n    \"VisualizeLatents\":           (VisualizeLatents,           \"Visualize Latents\"),\r\n}"
  },
  {
    "path": "raft.py",
    "content": "import os\nimport torch\nimport torch.nn.functional as F\nfrom torchvision.models.optical_flow import Raft_Large_Weights, raft_large\n\n\ndef load_raft():\n    model_dir = os.path.join(os.path.split(__file__)[0], \"models\")\n    if not os.path.exists(model_dir):\n        os.mkdir(model_dir)\n    \n    raft_weights = Raft_Large_Weights.DEFAULT\n    raft_path = os.path.join(model_dir, str(raft_weights) + \".pth\")\n    \n    if os.path.exists(raft_path):\n        model = raft_large()\n        model.load_state_dict(torch.load(raft_path))\n    else:\n        model = raft_large(weights=raft_weights, progress=True)\n        torch.save(model.state_dict(), raft_path)\n    \n    device = \"cuda\" if torch.cuda.is_available() else \"cpu\"\n    model = model.to(device).eval()\n    return (model, device)\n\ndef raft_flow(model, device, batch1, batch2):\n    orig_H = batch1.shape[2]\n    orig_W = batch1.shape[3]\n    scale_factor = max(orig_H, orig_W) / 512\n    new_H = int(((orig_H / scale_factor) // 8) * 8)\n    new_W = int(((orig_W / scale_factor) // 8) * 8)\n    \n    if scale_factor > 1 or max(orig_H % 8, orig_W % 8) > 0:\n        batch1_scaled = F.interpolate(batch1, size=(new_H, new_W), mode='bilinear')\n        batch2_scaled = F.interpolate(batch2, size=(new_H, new_W), mode='bilinear')\n        \n        with torch.no_grad():\n            flow = model(batch1_scaled.to(device), batch2_scaled.to(device))[-1]\n        flow = F.interpolate(flow, size=(orig_H, orig_W), mode='bilinear')\n        flow[:,0,:,:] *= orig_W / new_W\n        flow[:,1,:,:] *= orig_H / new_H\n    else:\n        with torch.no_grad():\n            flow = model(batch1.to(device), batch2.to(device))[-1]\n    \n    return flow.to(batch1.device)\n\ndef flow_warp(image, flow):\n    B, C, H, W = image.size()\n    # mesh grid\n    xx = torch.arange(0, W).view(1, -1).repeat(H, 1)\n    yy = torch.arange(0, H).view(-1, 1).repeat(1, W)\n    xx = xx.view(1, 1, H, W).repeat(B, 1, 1, 1)\n    yy = yy.view(1, 1, H, W).repeat(B, 1, 1, 1)\n    grid = torch.cat((xx, yy), 1).float()\n    \n    grid = grid.to(image.device)\n    vgrid = grid + flow\n    \n    # scale grid to [-1,1] for grid_sample\n    vgrid[:, 0, :, :] = 2.0 * vgrid[:, 0, :, :].clone() / max(W - 1, 1) - 1.0\n    vgrid[:, 1, :, :] = 2.0 * vgrid[:, 1, :, :].clone() / max(H - 1, 1) - 1.0\n    vgrid = vgrid.permute(0, 2, 3, 1)\n    output = F.grid_sample(image, vgrid, mode='bicubic', padding_mode='border', align_corners=True)\n    return output"
  },
  {
    "path": "requirements.txt",
    "content": "opencv-contrib-python>=4.7.0.72\nopencv-contrib-python-headless>=4.7.0.72\nopencv-python>=4.7.0.72\nopencv-python-headless>=4.7.0.72\npymatting"
  }
]