feat: use mtb three-view (wip)

probably very broken still, untested

.dockerignore

@@ -0,0 +1,34 @@
+# Include any files or directories that you don't want to be copied to your
+# container here (e.g., local build artifacts, temporary files, etc.).
+#
+# For more help, visit the .dockerignore file reference guide at
+# https://docs.docker.com/engine/reference/builder/#dockerignore-file
+
+**/.DS_Store
+**/__pycache__
+**/.venv
+**/.classpath
+**/.dockerignore
+**/.env
+**/.git
+**/.gitignore
+**/.project
+**/.settings
+**/.toolstarget
+**/.vs
+**/.vscode
+**/*.*proj.user
+**/*.dbmdl
+**/*.jfm
+**/bin
+**/charts
+**/docker-compose*
+**/compose*
+**/Dockerfile*
+**/node_modules
+**/npm-debug.log
+**/obj
+**/secrets.dev.yaml
+**/values.dev.yaml
+LICENSE
+README.md

.editorconfig

@@ -0,0 +1,2 @@
+[*]
+end_of_line = lf

.github/CODEOWNERS

@@ -0,0 +1,5 @@
+* @melMass
+extern/GFPGAN/* @TencentARC
+extern/SadTalker/* @OpenTalker
+nodes/deep_bump.py @HugoTini
+web/imageFeed.js @pythongosssss @melMass

.github/FUNDING.yml

@@ -0,0 +1,14 @@
+# These are supported funding model platforms
+
+github: [melMass]
+custom: ["https://www.buymeacoffee.com/melmass"]
+patreon: # Replace with a single Patreon username
+open_collective: # Replace with a single Open Collective username
+ko_fi: # Replace with a single Ko-fi username
+tidelift: # Replace with a single Tidelift platform-name/package-name e.g., npm/babel
+community_bridge: # Replace with a single Community Bridge project-name e.g., cloud-foundry
+liberapay: # Replace with a single Liberapay username
+issuehunt: # Replace with a single IssueHunt username
+otechie: # Replace with a single Otechie username
+lfx_crowdfunding: # Replace with a single LFX Crowdfunding project-name e.g., cloud-foundry
+

.github/ISSUE_TEMPLATE/bug_report.yml

@@ -0,0 +1,85 @@
+name: 🐞 Bug Report
+title: '[bug] '
+description: Report a bug
+labels: ['type: 🐛 bug', 'status: 🧹 needs triage']
+assignees:
+  - melMass
+
+body:
+  - type: markdown
+    attributes:
+      value: |
+        ## Before submiting an issue
+        - Make sure to read the README & INSTALL instructions.  
+        - Please search for [existing issues](https://github.com/melMass/comfy_mtb/issues?q=is%3Aissue) around your problem before filing a report.
+        - Optionally check the `#mtb-nodes` channel on the Banodoco discord:  
+          [![](https://dcbadge.vercel.app/api/server/AXhsabmDhn?style=flat)](https://discord.gg/IAXhsabmDhn)
+
+        ### Try using the debug mode to get more info
+
+        If you use the env variable `MTB_DEBUG=true`, debug message from the extension will appear in the terminal.
+
+  - type: textarea
+    id: description
+    attributes:
+      label: Describe the bug
+      description: A clear description of what the bug is. Include screenshots if applicable.
+      placeholder: Bug description
+    validations:
+      required: true
+
+  - type: textarea
+    id: reproduction
+    attributes:
+      label: Reproduction
+      description: Steps to reproduce the behavior.
+      placeholder: |
+        1. Add node xxx ...
+        2. Connect to xxx ...
+        3. See error
+
+  - type: textarea
+    id: expected-behavior
+    attributes:
+      label: Expected behavior
+      description: A clear description of what you expected to happen.
+
+  - type: dropdown
+    id: os
+    attributes:
+      label: Operating System
+      description: What OS are you using?
+      options:
+        - Windows (Default)
+        - Linux
+        - Mac
+      default: 0
+    validations:
+      required: true
+
+  - type: dropdown
+    id: comfy_mode
+    attributes:
+      label: Comfy Mode
+      description: What flavor of Comfy do you use?
+      options:
+        - Comfy Portable (embed) (Default)
+        - In a custom virtual env (venv, virtualenv, conda...)
+        - Google Colab
+        - Other (online services, containers etc..)
+      default: 0
+    validations:
+      required: true
+
+  - type: textarea
+    id: logs
+    attributes:
+      label: Console output
+      description: Paste the console output without backticks
+      render: sh
+
+  - type: textarea
+    id: context
+    attributes:
+      label: Additional context
+      description: Add any other context about the problem here.

.github/ISSUE_TEMPLATE/config.yml

@@ -0,0 +1 @@
+blank_issues_enabled: false

.github/ISSUE_TEMPLATE/feature_request.yml

@@ -0,0 +1,35 @@
+name: 💡 Feature Request
+title: "[feat] "
+description: Suggest an idea
+labels: ["type: 🤚 feature request"]
+
+body:
+  - type: textarea
+    id: problem
+    attributes:
+      label: Describe the problem
+      description: A clear description of the problem this feature would solve
+      placeholder: "I'm always frustrated when..."
+    validations:
+      required: true
+
+  - type: textarea
+    id: solution
+    attributes:
+      label: "Describe the solution you'd like"
+      description: A clear description of what change you would like
+      placeholder: "I would like to..."
+    validations:
+      required: true
+
+  - type: textarea
+    id: alternatives
+    attributes:
+      label: Alternatives considered
+      description: "Any alternative solutions you've considered"
+
+  - type: textarea
+    id: context
+    attributes:
+      label: Additional context
+      description: Add any other context about the problem here.

.github/workflows/package_wheels.yml

@@ -27,17 +27,15 @@ jobs:
     steps:
       - name: ♻️ Checking out the repository
         uses: actions/checkout@v3
-      - name: "🐍 Setting up Python"
+      - name: '🐍 Setting up Python'
         uses: actions/setup-python@v4
         with:
-          python-version: "3.10.9"
+          python-version: '3.10.9'
 
       - name: 📦 Building and Bundling wheels
         shell: bash
         run: |
-          python -m pip wheel --no-cache-dir -r requirements-wheels.txt -w ./wheels > build.log
-
-          cat build.log
+          python -m pip wheel --no-cache-dir -r reqs.txt -w ./wheels 2>&1 | tee build.log
 
           # find source wheels
           packages=$(cat build.log | awk -F 'Building wheels for collected packages: ' '{print $2}')
@@ -45,6 +43,13 @@ jobs:
 
           IFS=', ' read -r -a package_array <<< "$packages"
 
+          # Save reversed package_array to wheel_order.txt
+          reversed_array=()
+          for ((idx=${#package_array[@]}-1; idx>=0; idx--)); do
+            reversed_array+=("${package_array[idx]}")
+          done
+          printf '%s\n' "${reversed_array[@]}" > ./wheels/wheel_order.txt
+
           printf "Autodetect this source package: \e[32m%s\e[0m\n" "${package_array[@]}"
 
           # Iterate through the wheel files and remove those that are not source built
@@ -71,4 +76,4 @@ jobs:
         uses: actions/cache/save@v3
         with:
           path: ${{ env.archive_name }}.zip
-          key: ${{ env.archive_name }}
+          key: ${{ env.archive_name }}-${{ hashFiles('reqs.txt') }}

.github/workflows/publish_action.yml

@@ -0,0 +1,18 @@
+name: 📦 Publish to Comfy registry
+on:
+  workflow_dispatch:
+  push:
+    tags:
+      - '*'
+
+jobs:
+  publish-node:
+    name: Publish Custom Node to registry
+    runs-on: ubuntu-latest
+    steps:
+      - name: ♻️ Check out code
+        uses: actions/checkout@v4
+      - name: 📦 Publish Custom Node
+        uses: Comfy-Org/publish-node-action@main
+        with:
+          personal_access_token: ${{ secrets.COMFY_REGISTRY_TOKEN }}

.github/workflows/release.yml

@@ -6,7 +6,7 @@ on:
       name:
         description: Release tag / name ?
         required: true
-        default: "latest"
+        default: 'latest'
         type: string
       environment:
         description: Environment to run tests against
@@ -27,8 +27,36 @@ jobs:
       - name: ♻️ Checking out the repository
         uses: actions/checkout@v3
         with:
-          submodules: "recursive"
+          submodules: 'recursive'
           path: ${{ env.repo_name }}
+
+      # - name: 📝 Prepare file with paths to remove
+      #   run: |
+      #     find ${{ env.repo_name }} -type f -size +10M > .release_ignore
+      #     find ${{ env.repo_name }} -type d -empty >> .release_ignore
+      #   shell: bash
+
+      - name: 🗑️ Remove files and directories listed in .release_ignore
+        shell: bash
+        run: |
+          release_ignore="${{ env.repo_name }}/.release_ignore"
+          if [ -f "$release_ignore" ]; then
+            while IFS= read -r entry || [ -n "$entry" ]; do
+              target="${{ env.repo_name }}/$entry"
+              if [ -e "$target" ]; then
+                if [ -f "$target" ]; then
+                  rm "$target"
+                elif [ -d "$target" ]; then
+                  rm -r "$target"
+                fi
+              else
+                echo "Warning: $entry does not exist in the repository. Skipping removal."
+              fi
+            done < "$release_ignore"
+          else
+            echo "No .release_ignore file found. Skipping removal of files and directories."
+          fi
+
       - name: 📦 Building custom comfy nodes
         shell: bash
         run: |
@@ -70,10 +98,18 @@ jobs:
         id: cache
         with:
           path: ${{ env.archive_name }}.zip
-          key: ${{ env.archive_name }}
+          key: ${{ env.archive_name }}-${{ hashFiles('reqs.txt') }}
+      - name: 📦 Unzip wheels
+        shell: bash
+        run: |
+          mkdir -p wheels
+          unzip -j ${{ env.archive_name }}.zip "**/*.whl" -d wheels
+          unzip -j ${{ env.archive_name }}.zip "**/*.txt" -d wheels
+        if: success()
       - name: ✅ Add wheels to release
         uses: softprops/action-gh-release@v1
         with:
           tag_name: ${{ inputs.name }}
           files: |
-            ${{ env.archive_name }}.zip
+            wheels/*.whl
+            wheels/wheel_order.txt

.github/workflows/test_embedded.yml

@@ -0,0 +1,71 @@
+name: 🧪 Test Comfy Portable
+
+on: workflow_dispatch
+jobs:
+  install-comfy:
+    runs-on: windows-latest
+    env:
+      repo_name: ${{ github.event.repository.name }}
+    steps:
+      - name: ⚡️ Restore Cache if Available
+        id: cache-comfy
+        uses: actions/cache/restore@v3
+        with:
+          path: ComfyUI_windows_portable
+          key: ${{ runner.os }}-comfy-env
+
+      - name: 🚡 Download and Extract Comfy
+        id: download-extract-comfy
+        if: steps.cache-comfy.outputs.cache-hit != 'true'
+        shell: bash
+        run: |
+          mkdir comfy_temp
+          curl -L -o comfy_temp/comfyui.7z https://github.com/comfyanonymous/ComfyUI/releases/download/latest/ComfyUI_windows_portable_nvidia_cu118_or_cpu.7z
+
+          7z x comfy_temp/comfyui.7z -o./comfy_temp
+
+
+          # mv comfy_temp/ComfyUI_windows_portable/python_embeded .
+          # mv comfy_temp/ComfyUI_windows_portable/ComfyUI .
+          # mv comfy_temp/ComfyUI_windows_portable/update .
+          ls
+          mv comfy_temp/ComfyUI_windows_portable .
+
+      - name: 💾 Store cache
+        uses: actions/cache/save@v3
+        if: steps.cache-comfy.outputs.cache-hit != 'true'
+        with:
+          path: ComfyUI_windows_portable
+          key: ${{ runner.os }}-comfy-env
+      - name: ⏬ Install other extensions
+        shell: bash
+        run: |
+          export COMFY_PYTHON="${GITHUB_WORKSPACE}/ComfyUI_windows_portable/python_embeded/python.exe"
+          cd "${GITHUB_WORKSPACE}/ComfyUI_windows_portable/ComfyUI/custom_nodes"
+
+          git clone https://github.com/Fannovel16/comfy_controlnet_preprocessors
+          cd comfy_controlnet_preprocessors
+          $COMFY_PYTHON -m pip install -r requirements.txt
+          
+      - name: ♻️ Checking out comfy_mtb to custom_nodes
+        uses: actions/checkout@v3
+        with:
+          submodules: 'recursive'
+          path: ComfyUI_windows_portable/ComfyUI/custom_nodes/${{ env.repo_name }}
+
+      - name: 📦 Install mtb nodes
+        shell: bash
+        run: |
+          # run install
+          export COMFY_PYTHON="${GITHUB_WORKSPACE}/ComfyUI_windows_portable/python_embeded/python.exe"
+          cd "${GITHUB_WORKSPACE}/ComfyUI_windows_portable/ComfyUI/custom_nodes"
+          $COMFY_PYTHON ${{ env.repo_name }}/install.py -w
+
+      - name: ⏬ Import mtb_nodes
+        shell: bash
+        run: |
+          export COMFY_PYTHON="${GITHUB_WORKSPACE}/ComfyUI_windows_portable/python_embeded/python.exe"
+          cd "${GITHUB_WORKSPACE}/ComfyUI_windows_portable/ComfyUI"
+          $COMFY_PYTHON -s main.py --quick-test-for-ci --cpu
+
+          $COMFY_PYTHON -m pip freeze

.gitignore

@@ -1,3 +1,11 @@
 __pycache__
 *.py[cod]
-*.onnx
+*.onnx
+wheels/
+node_modules/
+compose.yaml
+comfy_mtb.wsb
+Dockerfile
+
+# I store the gh-pages worktrees (src & build) there
+.worktrees

.gitmodules

@@ -1,3 +1,12 @@
-[submodule "extern/SadTalker"]
-	path = extern/SadTalker
-	url = https://github.com/OpenTalker/SadTalker.git
+[submodule "extern/google-FILM"]
+	path = extern/frame_interpolation
+	url = https://github.com/google-research/frame-interpolation
+[submodule "extern/GFPGAN"]
+	path = extern/GFPGAN
+	url = https://github.com/TencentARC/GFPGAN.git
+[submodule "extern/frame_interpolation"]
+	path = extern/frame_interpolation
+	url = https://github.com/google-research/frame-interpolation
+[submodule "wiki"]
+	path = wiki
+	url = https://github.com/melMass/comfy_mtb.wiki.git

.nvim.lua

@@ -0,0 +1,10 @@
+-- HACK: this should theorically not be needed since the lsp should read from the pyproject
+-- tried: ruff-lsp or basedpyright
+
+local comfyRoot = vim.fn.expand("%:p:h:h:h")
+
+if not vim.env.PYTHONPATH or vim.env.PYTHONPATH == "" then
+	vim.env.PYTHONPATH = comfyRoot
+else
+	vim.env.PYTHONPATH = vim.env.PYTHONPATH .. ";" .. comfyRoot
+end

.pre-commit-config.yaml

@@ -0,0 +1,8 @@
+default_language_version:
+  python: python3.10
+repos:
+  - repo: https://github.com/melmass/hooks
+    rev: e8c6c18175ed4f6e30f23991de7989411e09c73b
+    hooks:
+      - id: fix-trailing-whitespace
+      - id: bump-version

.prettierrc

@@ -0,0 +1,6 @@
+{
+  "semi": false,
+  "singleQuote": true,
+  "tabWidth": 2,
+  "useTabs": false
+}

.release_ignore

@@ -0,0 +1,4 @@
+extern/frame_interpolation/moment.gif
+extern/frame_interpolation/photos
+extern/GFPGAN/inputs
+.git

CHANGELOG.md

@@ -0,0 +1,402 @@
+# Changelog
+
+This is an automated changelog based on the commits in this repository.
+
+Check the notes in the [releases](https://github.com/melMass/comfy_mtb/releases) for more information.
+## [main] - 2024-03-07
+
+### Bug Fixes
+
+- 🐛 font fallback ([9fccdee](https://github.com/melMass/comfy_mtb/commit/9fccdee82d721e88c64d2292c209fec869524dd2))
+- ✨ optional inputs of colored image ([cd32f26](https://github.com/melMass/comfy_mtb/commit/cd32f26b167088d6b489e43b260c187ea5e4d223)) by [@ScottNealon](https://github.com/ScottNealon) in [#147](https://github.com/melMass/comfy_mtb/pull/147)
+- 📝 adds a way to not load the imagefeed ([501c330](https://github.com/melMass/comfy_mtb/commit/501c3301056b2851555cccd75ab3ff15b1ab8e0c))
+- 🐛 colored image mask input ([30c4311](https://github.com/melMass/comfy_mtb/commit/30c4311b69f6481a34f968cb67a9b5ce5d2e9fda))
+- 🐛 handle font cache errors ([c43a661](https://github.com/melMass/comfy_mtb/commit/c43a661ba31dcd7720b4f32d8e96760e6191fbd9))
+- 💄 register the COLOR type even for external extensions ([12b134a](https://github.com/melMass/comfy_mtb/commit/12b134ab4c937c192aaf4a3667d9885dd4fe43ca))
+- ✨ mask crop output ([59a361a](https://github.com/melMass/comfy_mtb/commit/59a361af5870b8ffc984c6680dd3282d3553dcf9))
+- 🚑️ thread font loading ([e4da832](https://github.com/melMass/comfy_mtb/commit/e4da832b99bd640b72c31b67178a3168e3238fa0))
+- 📦 changed way of creating bbox from mask ([14ee9e2](https://github.com/melMass/comfy_mtb/commit/14ee9e23c009ab55fa3b2fc6ec60fb683c46d57d)) by [@Yurchikian](https://github.com/Yurchikian) in [#124](https://github.com/melMass/comfy_mtb/pull/124)
+- ✨ expose invert of bboxfrommask ([53cb503](https://github.com/melMass/comfy_mtb/commit/53cb503866da6d83b47eaeb8073039ace2ae0a95))
+- ✨ less strict csv parsing ([d5c4c5f](https://github.com/melMass/comfy_mtb/commit/d5c4c5f2649ecdb4bf7b517c5b33bbf8df753047))
+- 🐛 fit number regression ([c8658df](https://github.com/melMass/comfy_mtb/commit/c8658dfbdd3a0ca8c3e88cd1adfddc55c7444045))
+- 🐛 remove uneeded installs ([4e07450](https://github.com/melMass/comfy_mtb/commit/4e07450bcabb0105b5610e52f7d4692ea07f9c1d))
+- 🐛 import issue ([255ac03](https://github.com/melMass/comfy_mtb/commit/255ac036bab1d776301857843d0e7a85e9a9dcb8))
+- 🐛 wrong output for bbox ([8d12b59](https://github.com/melMass/comfy_mtb/commit/8d12b59844958fbc696d01d51162f97262664ae9))
+- 🚑️ fallback when symlink detection fails ([278f22c](https://github.com/melMass/comfy_mtb/commit/278f22c2093b6eca63d2d00f7936774918707e4e))
+- ✨ handle malformed styles.csv ([e6f6502](https://github.com/melMass/comfy_mtb/commit/e6f65026735770df8aced4a3acb75550ff1c84da))
+- 🐛 encoding ([5af2840](https://github.com/melMass/comfy_mtb/commit/5af284067c65042bcdfff04a5d5a2360bf9e4af7))
+- ⚡️ add the cli deps ([bb90e04](https://github.com/melMass/comfy_mtb/commit/bb90e0415f6a1ececbf468815dc0f5959d9a34e8))
+- 🚑️ check for symlink ([25b933c](https://github.com/melMass/comfy_mtb/commit/25b933c698b250a411549d2600fae49bec225b7a))
+- 🚑️ remove problematic dependencies ([5dfea51](https://github.com/melMass/comfy_mtb/commit/5dfea51dd8db2a4829e559eadeda22374b51c8a4))
+- 🐛 batch support ([f1ff9fc](https://github.com/melMass/comfy_mtb/commit/f1ff9fc7c4684ad673c3178df3b8142dcf0b16ac))
+- 🐛 automatically disable tiling if seamless is on ([4605f74](https://github.com/melMass/comfy_mtb/commit/4605f74f370d4d221ab1d50f21b72910fa6909c7))
+- 🐛 debug node ([dc500b7](https://github.com/melMass/comfy_mtb/commit/dc500b788e885205f017956da6a71a677f822941))
+- ⚡️ hack to handle prompt validation ([d49b257](https://github.com/melMass/comfy_mtb/commit/d49b2578c247dcba9b09b374d99f5cc45cac172d))
+- ✨ deepbump update ([87b245c](https://github.com/melMass/comfy_mtb/commit/87b245c6a6895490e3612b235879fa90b62dea2b))
+- 👷 user folder_paths to retrieve comfy root ([38df58a](https://github.com/melMass/comfy_mtb/commit/38df58a78c363ef2657011893d4d811676b1c664))
+- 🐛 typo ([90aee83](https://github.com/melMass/comfy_mtb/commit/90aee83797a863cf4797cdbe187f949061cbd176))
+- 🐛 do not resolve symlink for "here" ([a50b11b](https://github.com/melMass/comfy_mtb/commit/a50b11bdaa66f4e805811b1676c937ade11318c2))
+- ✏️ use Union to allow support for <3.10 ([88a2779](https://github.com/melMass/comfy_mtb/commit/88a277968745ac990406b14d300a8ada9c575b11)) by [@M1kep](https://github.com/M1kep) in [#91](https://github.com/melMass/comfy_mtb/pull/91)
+- ⚡️ simplify widgets cleanup ([cdd098e](https://github.com/melMass/comfy_mtb/commit/cdd098e10258401402b8023c9143532cfa4a1745))
+- ✨ don't assume the install was ran ([cc43654](https://github.com/melMass/comfy_mtb/commit/cc43654af2987bc8860557caa99cde91e8309b21))
+- 🐛 install ([616b2bf](https://github.com/melMass/comfy_mtb/commit/616b2bfc6c629cef1d30cb0d717bd805c3a086aa))
+- 🐛 properly escape paths ([22cac9b](https://github.com/melMass/comfy_mtb/commit/22cac9b2d95910197941b73e7548735470bd3b17))
+- 🐛 use relative paths in JS ([e2773ff](https://github.com/melMass/comfy_mtb/commit/e2773ff22e43e7756ad618344a03d661a576cf35))
+- 💄 BatchFromHistory when "listening" ([3b07984](https://github.com/melMass/comfy_mtb/commit/3b07984716402fbbf5da41020bf73befd52e7ebf))
+- ✨ save gif widget removal ([fe8f519](https://github.com/melMass/comfy_mtb/commit/fe8f519f8860b0610d8cafcd9b843b4171c2b3d4))
+
+### Documentation
+
+- 📝 add changelog ([0d817bf](https://github.com/melMass/comfy_mtb/commit/0d817bf326b4a22e2221264a414af50c3b7048b9))
+- 📄 add note+ screenshot ([90d9636](https://github.com/melMass/comfy_mtb/commit/90d96366c8b7637b55d1b4f88cb9aca217c1414b))
+- 📝 add cover image ([6b993b8](https://github.com/melMass/comfy_mtb/commit/6b993b84071bbb80ba1b8bd63576f31e35d05590))
+- 📝 fix image size ([3e8c2fe](https://github.com/melMass/comfy_mtb/commit/3e8c2fe789925e7017c2f8c8d9164c139588aba4))
+- 📝 add image ([3e93ea6](https://github.com/melMass/comfy_mtb/commit/3e93ea6f2c73353891b1a3f6223b5730bc69df37))
+- 📝 explain optional nodes ([cea0b08](https://github.com/melMass/comfy_mtb/commit/cea0b08eb044756ab1b408f630435095b8969d36))
+- 📝 add the example previews from the wiki ([8f90986](https://github.com/melMass/comfy_mtb/commit/8f909864bfaa9f2d0fbdcf3942eacb9d78ee8fb8))
+- 📝 update node list ([4917e31](https://github.com/melMass/comfy_mtb/commit/4917e31c427c74d28c830fd7b2423cab393ba0f8))
+- 📝 add some deprecation warnings and recommendations ([e11df9d](https://github.com/melMass/comfy_mtb/commit/e11df9d45c81d93f4334841de036b4aa3364375a))
+- 📝 add a reference to SlickComfy for colab ([bb35098](https://github.com/melMass/comfy_mtb/commit/bb35098c656b0b2d30909b83df0a3b65c5975f78))
+
+### Features
+
+- ✨ add "To Device" ([c28181f](https://github.com/melMass/comfy_mtb/commit/c28181f1615d2e183767aa76cc2350934330e546))
+- ✨ add note+ example ([90f3bc2](https://github.com/melMass/comfy_mtb/commit/90f3bc2d953b299ea34e9e3a925f1a824b488855))
+- 💄 node+ improvements ([4b29395](https://github.com/melMass/comfy_mtb/commit/4b29395000254382882c0d1be115b2ed80cd7c99))
+- 📝 add note plus ([605c8db](https://github.com/melMass/comfy_mtb/commit/605c8db320e1531c6347f6888606fa50d8eb268b))
+- 🚧 add playlist nodes ([cf96572](https://github.com/melMass/comfy_mtb/commit/cf965727e8e7064328704d88cd0410c61f1e686e))
+- 🚨 add missing node ([16c1a59](https://github.com/melMass/comfy_mtb/commit/16c1a59312b1d9841f5f8a814eff93a1ddf04edb))
+- ✨ Math Expression node ([142624e](https://github.com/melMass/comfy_mtb/commit/142624eea616a5622387b1b641c02605455ee6f1))
+- 🚀 add optional inputs to colored image ([049983d](https://github.com/melMass/comfy_mtb/commit/049983dbe2dbce6b772908468c4042d2bfde5eb2))
+- ✨ Add support for extra_model_paths.yaml ([d7b8ac8](https://github.com/melMass/comfy_mtb/commit/d7b8ac8e0c98b0d7a2e21889d35aad9f6b093560))
+- ✨ add batch shake ([af94203](https://github.com/melMass/comfy_mtb/commit/af94203d1b461d934ca1c44211ca0f71a5d05d48))
+- ✨ enhance concat images ([a798eb0](https://github.com/melMass/comfy_mtb/commit/a798eb07d0d891cfbd47013b442ef2fa3d7cc5bc))
+- 💄 add a few more batch nodes ([c1d42de](https://github.com/melMass/comfy_mtb/commit/c1d42de0fcde86d2a167fb4b5e781ee987814da2))
+- ✨ Batch node utilities ([cef5023](https://github.com/melMass/comfy_mtb/commit/cef5023efc17366a2e937ef43944de3587707fac))
+- 🚨 Image Stack node (horizontal and vertical stack) ([bb3277d](https://github.com/melMass/comfy_mtb/commit/bb3277d85f4ca21735cb1f5237cb1430db88c183))
+- 🚀 add seamless model hack ([21acc87](https://github.com/melMass/comfy_mtb/commit/21acc87ff0a84b7588f4b5aae0aeb5ae94bbbfbe))
+- 🔧 debug handle a few more types ([638498c](https://github.com/melMass/comfy_mtb/commit/638498c6b47c2b2cab82f76aec1f3d46df67f263))
+- 🎨 Add an editor for the styles loader ([2faa2f2](https://github.com/melMass/comfy_mtb/commit/2faa2f2a148a4dbf5525e4945f688a239f244546))
+- ✨ add a static assets path ([6a00d1d](https://github.com/melMass/comfy_mtb/commit/6a00d1da5a8a5fa47af1bf1ab5d3cd206c599841))
+- ✨ add  Interpolate Clip Sequential ([a71c273](https://github.com/melMass/comfy_mtb/commit/a71c273baf450ad7e2a7e032451f015d3be3e9e9))
+
+### Miscellaneous Tasks
+
+- 🧹 applied some linting ([fe49312](https://github.com/melMass/comfy_mtb/commit/fe49312cbef03c6540304448fa88aa7a88391efa))
+- 📝 header links not parsed ([514c0d2](https://github.com/melMass/comfy_mtb/commit/514c0d2eda9990435eb18258d4bbd1aa137feb3d))
+- 📝 hardcode links in changelog ([915b744](https://github.com/melMass/comfy_mtb/commit/915b7444a9db83f349d83b636304af0d276f529f))
+- 🔖 local updates ([6c5e5d3](https://github.com/melMass/comfy_mtb/commit/6c5e5d36379bdab223b4503e42b7956b55a82ab0))
+- 📝 update node list ([dd27f99](https://github.com/melMass/comfy_mtb/commit/dd27f990c72fa94aff205eb314a8ea360f57479e))
+- ✨ update node_list ([537a0d8](https://github.com/melMass/comfy_mtb/commit/537a0d8108d0caa3ab2daeafd1d25d680214ef26))
+- ✨ local stuff ([9afad1a](https://github.com/melMass/comfy_mtb/commit/9afad1a1680073006d946be10f8c97b75ddfe253))
+- 📝 fix update issue template ([da290db](https://github.com/melMass/comfy_mtb/commit/da290dbcf2952a56be9334f7bf9dc4d8fa64a21d))
+- 📝 update issue template ([b949bb4](https://github.com/melMass/comfy_mtb/commit/b949bb406bc1929634600465ea389eaedefe6e6f))
+
+### Refactor
+
+- ⚡️ small local fixes ([bcac665](https://github.com/melMass/comfy_mtb/commit/bcac66508d2e788cc437da289d1ccede19465b8c))
+- 🗑️ remove unused code in install script ([5b75436](https://github.com/melMass/comfy_mtb/commit/5b75436610c6312adf47c6baa3e9fe9cc7d56dcf))
+
+### Merge
+
+- 🔀 pull request #109 from melMass/dev/0.2.0 ([87e301d](https://github.com/melMass/comfy_mtb/commit/87e301d120a542d5aabe544bec10d38dbd19b2f6)) in [#109](https://github.com/melMass/comfy_mtb/pull/109)
+- 🔀 pull request #86 from melMass/feature/styles-editor ([cbdb816](https://github.com/melMass/comfy_mtb/commit/cbdb816164900061ddaa1671f4287763d0b79ee1)) in [#86](https://github.com/melMass/comfy_mtb/pull/86)
+
+### Wip
+
+- 🚧 add text template node ([af2175a](https://github.com/melMass/comfy_mtb/commit/af2175a1fc0c2fb29ef3493f242fe45ec6fcabac))
+
+## New Contributors
+* [@ScottNealon](https://github.com/ScottNealon) made their first contribution in [#147](https://github.com/melMass/comfy_mtb/pull/147)
+* [@Yurchikian](https://github.com/Yurchikian) made their first contribution in [#124](https://github.com/melMass/comfy_mtb/pull/124)
+* [@M1kep](https://github.com/M1kep) made their first contribution in [#91](https://github.com/melMass/comfy_mtb/pull/91)
+## [0.1.4] - 2023-08-12
+
+### Bug Fixes
+
+- 🚀 pending fixes ([ea5d73d](https://github.com/melMass/comfy_mtb/commit/ea5d73d48cfa4046f48a52609cff7f754d8364ed))
+- 🚑️ image resize infinite loop ([30d6cfe](https://github.com/melMass/comfy_mtb/commit/30d6cfe81292d0f7702544b3c2cbad1820c4a926))
+- ✨ update example files ([610afe0](https://github.com/melMass/comfy_mtb/commit/610afe031f21d737b2fd5128e4be7100b6666181))
+- 🐛 simplify install steps ([4fc84d6](https://github.com/melMass/comfy_mtb/commit/4fc84d615dd0f546442c3537f00c52366db4ca9b))
+- ✨ refactor ([8523392](https://github.com/melMass/comfy_mtb/commit/8523392df74c586dc940841ddbb5069943b16f7d))
+- 🐛 debug rgba ([40560f8](https://github.com/melMass/comfy_mtb/commit/40560f8154d3ddeabf708be4d111370648d466ac))
+- 🎨 rename fun to generate ([e7f72f9](https://github.com/melMass/comfy_mtb/commit/e7f72f9825da58254e3084b4ba91f76e6cf2cf5f))
+- ✨ refactor existing ([1144466](https://github.com/melMass/comfy_mtb/commit/11444662b9198861b62aff06a08b9c9ea01dd8bd))
+- ⚡️ move getbatchfromhistory to graphutils ([2eccba4](https://github.com/melMass/comfy_mtb/commit/2eccba4e33b21d1d080cb2f415f76a93488120f0))
+- 🚧 wip dependency installer UI ([630b492](https://github.com/melMass/comfy_mtb/commit/630b492347f75d7308b31a000061b41d7dfa4a10))
+- 🐛 image feed zorder ([0fb2d4d](https://github.com/melMass/comfy_mtb/commit/0fb2d4da90a7e65f82b3f9c8942a68e360456cf7))
+- ⬇️ download_antelopev2 ([4dd5321](https://github.com/melMass/comfy_mtb/commit/4dd532185223a1fa5978446e7bb75d32d77ebdb5))
+- 🚑️ frontend pushed too early ([91f60d4](https://github.com/melMass/comfy_mtb/commit/91f60d4c463c474ac10e868e8e73e13fa019856b))
+- 🚑️ missing input ([84ac8ac](https://github.com/melMass/comfy_mtb/commit/84ac8ac852aeb962029bfd8369fe5ed59a203977))
+- 🐛 shell command bug ([3d5075f](https://github.com/melMass/comfy_mtb/commit/3d5075fea2e219a179271c9810017c7e38bff6cc))
+- 🚑️ remove pipe mode from the install.py ([b854a30](https://github.com/melMass/comfy_mtb/commit/b854a302ce4708d2ad2dac249860308dbdcae5a6))
+- ⚡️ colab install ([36d8e6b](https://github.com/melMass/comfy_mtb/commit/36d8e6bdb06edab72ccfb686266d2e644a9f028c))
+- 🚑️ install typo ([ffa1a87](https://github.com/melMass/comfy_mtb/commit/ffa1a87b9184df5a3699a6118714b39d359bde4d))
+
+### Documentation
+
+- 📝 link the actual action instead of badge ([098d74a](https://github.com/melMass/comfy_mtb/commit/098d74a3cd8449d836569a074995e20d775c6728))
+- 📝 add action badge ([e74314b](https://github.com/melMass/comfy_mtb/commit/e74314b04eb218c140482ccf704b61af06db3f4d))
+
+### Features
+
+- 💫 export to prores -> export with ffmpeg ([a4d99d9](https://github.com/melMass/comfy_mtb/commit/a4d99d966b1207191243a9749385b998d1a9c6b1))
+- 🔥 add any to string & refactor ([dbdb872](https://github.com/melMass/comfy_mtb/commit/dbdb872b74e18c16feb44bd037abc3aafbb4700f))
+- ✨ add UI for interpolate clip sequential ([5ec5511](https://github.com/melMass/comfy_mtb/commit/5ec551143302b2a94ca82e477f684ecee23f1459))
+- ✨ add portable reqs ([3f14b16](https://github.com/melMass/comfy_mtb/commit/3f14b1676d28f5ffa1f47fda00b9bc244951045c))
+- ✨ add border extension ([fb64484](https://github.com/melMass/comfy_mtb/commit/fb644847ca434123e8e8e4991d33949fd31e3cbe))
+- ✨ use PIL for gif saving ([2bc7ae8](https://github.com/melMass/comfy_mtb/commit/2bc7ae88bf4cdfa575d11233c0e6f7b07f9dfd23))
+- 🎨 update node list ([a54d7d5](https://github.com/melMass/comfy_mtb/commit/a54d7d5346c272898dd4e67c65495de7325ab3a0))
+- ✨ install fix ([512de60](https://github.com/melMass/comfy_mtb/commit/512de6023e55f2cc47516bf44436efe22157273f)) in [#41](https://github.com/melMass/comfy_mtb/pull/41)
+
+### Miscellaneous Tasks
+
+- 💄 encoding ([49c64c7](https://github.com/melMass/comfy_mtb/commit/49c64c74eb3e99f456b563bbd79e3fe47a85c70d))
+- 🚀 only fetch controlnet_preprocessor deps ([414beb9](https://github.com/melMass/comfy_mtb/commit/414beb99a1f9bf719eca6ac139c9b2ccdfd6d743))
+- 🚀 add controlnetpreprocessors to tests ([63b3aec](https://github.com/melMass/comfy_mtb/commit/63b3aece2ba05adc2b655afeb41e3d47e7887b33))
+- ✨ remove unused input ([d4f791d](https://github.com/melMass/comfy_mtb/commit/d4f791d7a14ba9cb8abd7c95ba70b081fee5fb7c))
+- ✨ use the same cwd as manager ([2ff0467](https://github.com/melMass/comfy_mtb/commit/2ff04672daff773d52e1552dca1bf616bc32daa6))
+- 🎨 no brace glob ([bbfcb62](https://github.com/melMass/comfy_mtb/commit/bbfcb62c398de39058bcb6e18161425059d53e8e))
+- 🎨 extract txt ([a22fd01](https://github.com/melMass/comfy_mtb/commit/a22fd01d664276e4cd833ae1326feeece1d1deaf))
+- 🎨 also push wheels_order to releases ([8e5b776](https://github.com/melMass/comfy_mtb/commit/8e5b7765cc0c6730bd5517ccfd56e817ea39bd3a))
+- 🚧 more info for bug reports ([3dadc11](https://github.com/melMass/comfy_mtb/commit/3dadc119f44fca1029ec4b349d71ce99fb20a4b6))
+- ✨ individual wheels ([346ff64](https://github.com/melMass/comfy_mtb/commit/346ff649d50c9f0286ad2243938406fefb62853b))
+
+### Refactor
+
+- 🚧 tidy ([4f30829](https://github.com/melMass/comfy_mtb/commit/4f30829e06c41b3685644bfe7bece07e0bcfb70e))
+- ♻️ get batch from history ([13d255a](https://github.com/melMass/comfy_mtb/commit/13d255a730b08c4903647875350b9b3dcd61b4a6))
+
+### Revert
+
+- 💄 use BOOLEAN instead of BOOL ([cfb3b23](https://github.com/melMass/comfy_mtb/commit/cfb3b237cf64b512414a17f71e6d89c3355aa8ef))
+
+### Testing
+
+- 🧪 remove sha input ([c5bbe83](https://github.com/melMass/comfy_mtb/commit/c5bbe83008bb194cbd6ad5e3dc70cb3850b18985))
+- 🧪 ci for comfy embedded ([7b3afca](https://github.com/melMass/comfy_mtb/commit/7b3afca8179760e35e8a6fbf742080dee13e4fc7))
+
+### Merge
+
+- 🔀 pull request #50 from melMass/dev/august-refactor ([2ecd470](https://github.com/melMass/comfy_mtb/commit/2ecd4700d77c0727e6b5d2124e0a6ebd48ec96ed)) in [#50](https://github.com/melMass/comfy_mtb/pull/50)
+
+## [0.1.3] - 2023-07-29
+
+### Bug Fixes
+
+- 🔥 manage pip from install only, remove requirements.txt ([247fbfb](https://github.com/melMass/comfy_mtb/commit/247fbfbc216b8259d607e0699d5b990b6a06ca71)) in [#38](https://github.com/melMass/comfy_mtb/pull/38)
+- 🎨 use image ratio for imagefeed ([f5cd56c](https://github.com/melMass/comfy_mtb/commit/f5cd56ce861c8c0a931744ae6cf2b96e9c8bca06))
+
+### Documentation
+
+- 📝 update imagefeed preview ([cbcacbe](https://github.com/melMass/comfy_mtb/commit/cbcacbe3c92ebb5f74d046b83504c3723710f130))
+- 📝 fix typo and add more details ([7c020ba](https://github.com/melMass/comfy_mtb/commit/7c020bab288aa7d17dc937b5f102319d43c3ebb3))
+
+### Miscellaneous Tasks
+
+- ✨ use wheel order if present ([9b24edd](https://github.com/melMass/comfy_mtb/commit/9b24eddd9c51004af08d7ac6ff2b6473dd3ee161))
+- ✨ store order of install for wheels ([5053142](https://github.com/melMass/comfy_mtb/commit/505314294f02e7c19ac95e4d0ed37fd397a54b46))
+
+## [0.1.2] - 2023-07-28
+
+### Bug Fixes
+
+- ✨ various small things ([0e311cf](https://github.com/melMass/comfy_mtb/commit/0e311cf2c64cf2b4861d4cc612a3409390e3039a))
+- 📝 last release ([889f08c](https://github.com/melMass/comfy_mtb/commit/889f08c08b721be8fdb4e4d7eacc47169d5692d6)) in [#36](https://github.com/melMass/comfy_mtb/pull/36)
+- 📝 narrow requirements ([5d661b2](https://github.com/melMass/comfy_mtb/commit/5d661b2509fecf3940c3c0fab25b16ec0eae7a2d))
+- ✨ Separate FaceAnalysis model loading ([d143e83](https://github.com/melMass/comfy_mtb/commit/d143e83dba3bffa16e1b98d7ad1e9cf92dc94db2))
+- ⚡️ update examples to match wiki ([3dfe98c](https://github.com/melMass/comfy_mtb/commit/3dfe98c7957df48723380de85e1242a424ec23de))
+
+### Documentation
+
+- 📝 add readme for web extensions features ([be162a2](https://github.com/melMass/comfy_mtb/commit/be162a20477258627fa0d742c97a478bd085ff4f))
+- 📝 link to the proper lang instructions ([232cf89](https://github.com/melMass/comfy_mtb/commit/232cf8966cc20291b60c68f487dfd37bf6aa4dfa)) in [#33](https://github.com/melMass/comfy_mtb/pull/33)
+- 📝 update readmes ([96a0618](https://github.com/melMass/comfy_mtb/commit/96a0618c5990a8559a9e2dd17c868d3465b8ca90))
+
+### Miscellaneous Tasks
+
+- 🎉 bump version ([9e751a2](https://github.com/melMass/comfy_mtb/commit/9e751a242f4e9afee3dc5c871c414b29b9706ff6))
+- 👷 remove stale example ([c237737](https://github.com/melMass/comfy_mtb/commit/c2377374201fc34b107c8b7db1cdeb2f483d1e18))
+- 🐛 fix size ([c0cc557](https://github.com/melMass/comfy_mtb/commit/c0cc5572d8c727568eca8a3d0f116a1f540c31ff))
+
+## [0.1.1] - 2023-07-24
+
+### Bug Fixes
+
+- 🎨 improve a bit the HTML response of endpoints ([50d51c7](https://github.com/melMass/comfy_mtb/commit/50d51c70d04e49e9df524975c171288c0fc0b20f))
+- 🐛 caching issues ([55c9736](https://github.com/melMass/comfy_mtb/commit/55c9736a9b2ca036926be4b06406121bfb9ebad2))
+- 🔥 remove notice ([abf1e82](https://github.com/melMass/comfy_mtb/commit/abf1e82adb9fac8cd70d5c409baad55309ef6fe1))
+- 🔥 use BOOL everywhere ([a393793](https://github.com/melMass/comfy_mtb/commit/a393793cfa93721eac46295723076a1dda940dcd))
+
+### Documentation
+
+- 📝 added lang links ([bbdac97](https://github.com/melMass/comfy_mtb/commit/bbdac97e49af4e90d22eeec3f63b96ecc126ffcf))
+- 📝 add comfyforum example ([10d0503](https://github.com/melMass/comfy_mtb/commit/10d05031b1791ab3534cf838be6eb75df638dfb6))
+
+### Features
+
+- 🚧 jupyter seems to require an __init__ there ([9a4eda3](https://github.com/melMass/comfy_mtb/commit/9a4eda3ef573bf382c13515f67ae8a415bf61abd))
+- ⚡️ use notify ([a2ecc11](https://github.com/melMass/comfy_mtb/commit/a2ecc11ebde79c2403959bf09c258f3a2465894a))
+- ✨ first version of Notify ([7e9c97e](https://github.com/melMass/comfy_mtb/commit/7e9c97ecb48672b25e5ed17b9b35dba9208ac311))
+- ⚡️ add an "actions" endpoint ([3de160a](https://github.com/melMass/comfy_mtb/commit/3de160af25b516c02aaa8cc32baec16e9ef358fb))
+- ✨ add Unsplash Image node ([8d3cc39](https://github.com/melMass/comfy_mtb/commit/8d3cc39b72dff1b5eb61bf7e2e395753c138ec8a))
+- ✨ add back Save Tensors ([7142b28](https://github.com/melMass/comfy_mtb/commit/7142b284adc7fba9a1bdafd1a52621bfc168bde1))
+- ✨ add TransformImage node ([11128ff](https://github.com/melMass/comfy_mtb/commit/11128ff85a7e0b4a54f405548969c2478da26df6))
+
+### Miscellaneous Tasks
+
+- 🚀 bump version ([cf86552](https://github.com/melMass/comfy_mtb/commit/cf865529ab64b350cd7af964b41160e7d130d12d))
+- 🚀 Remove large files from release ([3b9190a](https://github.com/melMass/comfy_mtb/commit/3b9190a69b002b8933c097fd6655bb4fe07264d2))
+
+### Refactor
+
+- ✨ cleaned up frontend code a bit ([3801a44](https://github.com/melMass/comfy_mtb/commit/3801a443bc1e89c70fdb35ce0b1724d86fa22928))
+- ⚡️ remove empty inits ([21729b2](https://github.com/melMass/comfy_mtb/commit/21729b2784a50fcaf24a63ac283bdae475a53ce7))
+
+### Merge
+
+- 🔀 pull request #32 from melMass/dev/next ([8695cd3](https://github.com/melMass/comfy_mtb/commit/8695cd3f1b6d27b5cd6c616ed1215ea2f25c5304)) in [#32](https://github.com/melMass/comfy_mtb/pull/32)
+
+## [0.1.0] - 2023-07-22
+
+### Bug Fixes
+
+- 🔥 properly match built wheels ([119b4d6](https://github.com/melMass/comfy_mtb/commit/119b4d6e16c2a90db1664ccaac748507feb73ea0)) in [#30](https://github.com/melMass/comfy_mtb/pull/30)
+- ✨ also try to copy web if symlink fails ([0df55de](https://github.com/melMass/comfy_mtb/commit/0df55def29fb992751010f6b8a707699f230ff37))
+- ✨ install process tested in comfy-manager (embed, colab) ([b40730d](https://github.com/melMass/comfy_mtb/commit/b40730ddbc3f8e3e7d5a17e9e9e4526ff37977fd))
+- 🚀 try to support remote install too ([3c66de2](https://github.com/melMass/comfy_mtb/commit/3c66de2500a89efd2d2e3af88fc58429af725789))
+- 💄 save gif issues ([7335003](https://github.com/melMass/comfy_mtb/commit/7335003346e83666c5dee631b8e6b15586d871e7))
+- 🚑️ always use latest for now ([fccf313](https://github.com/melMass/comfy_mtb/commit/fccf31348994ab6e344a1ab00a8f9998309f9319))
+- 🐛 install logic ([7e301e2](https://github.com/melMass/comfy_mtb/commit/7e301e2a067d41cba9b8ef357496dd1df94e4cdd))
+- 🎉 remove tests & add missing docs ([4e6b877](https://github.com/melMass/comfy_mtb/commit/4e6b87719989aa144946c5c9a43b9398c20bf11e))
+- ⚡️ update node_list ([c794d6a](https://github.com/melMass/comfy_mtb/commit/c794d6a071778220d654b526d2edfddcc79752fc))
+- 🚑️ set debug level from endpoint ([18402e3](https://github.com/melMass/comfy_mtb/commit/18402e3be1ab47e10109cfd2dff18863a1ee56f7))
+- 🐛 add base64 prefix to outputs ([0950f99](https://github.com/melMass/comfy_mtb/commit/0950f9914c9bbed7c89f3de33a967cb76f9d0bbb))
+- 🎨 refactor and add Gif preview on node ([c2e8379](https://github.com/melMass/comfy_mtb/commit/c2e83794faeb8da708c98908882e38b2a42827bd))
+- ✨ Various widgets issues ([27500ca](https://github.com/melMass/comfy_mtb/commit/27500ca432d686774b991045b7cffc58c0b67faf))
+- 🔥 deprecate some nodes and fix image list ([9aa934f](https://github.com/melMass/comfy_mtb/commit/9aa934f70ff6adf91efb26aa8e5cb21ec575196a))
+- 🐛 crop nodes ([67d3783](https://github.com/melMass/comfy_mtb/commit/67d3783ac9186da6bba4b7dc7e8dc3d5db5a1b0f))
+- 🐛 tensor2pil ([8a59508](https://github.com/melMass/comfy_mtb/commit/8a59508ff91d6b2d9ca287ef1c054ec5755337a4))
+- ⚡️ a few missing __doc__ ([ab09cca](https://github.com/melMass/comfy_mtb/commit/ab09ccadd905bebbf1b7b2d992e96e36fc60d68a))
+- ⚡️ from tensor2np always returning a list ([6168b3a](https://github.com/melMass/comfy_mtb/commit/6168b3a2ac38b5eebed3daf9e52df5742abf6813))
+- 🚑️ TF by default fills vram ([c225da5](https://github.com/melMass/comfy_mtb/commit/c225da5f298acb4cb2b39022382543c0c966d428))
+- ✨ leftovers ([da3e6f4](https://github.com/melMass/comfy_mtb/commit/da3e6f47c6073e73cf9d3a3cd23ba5ccbe1fedce))
+- ✨ handle non fork gdown in model dll ([95797e8](https://github.com/melMass/comfy_mtb/commit/95797e823e12e62ae8758753f60c34afbe19ec90))
+- ✨ properly add the submodules ([00510ed](https://github.com/melMass/comfy_mtb/commit/00510ed0b8583dd64518daa67d963582f4f029d3))
+- 📌 remove sad talker for now ([1622cbc](https://github.com/melMass/comfy_mtb/commit/1622cbcb9d51ddd0e1a8b4d87ba47b99327163eb))
+- 🎨 narrow requirements ([1a92ef7](https://github.com/melMass/comfy_mtb/commit/1a92ef734dd4271efc875856038f9e3b6b9ded6c))
+- 🚀 use the comfy util to handle graph interruption ([9752f3e](https://github.com/melMass/comfy_mtb/commit/9752f3e9dec9aa59cfa809aa14f0151594c03858))
+- 🔥 much faster (using GPU) on windows ([2f455aa](https://github.com/melMass/comfy_mtb/commit/2f455aaca55c0a044735c768b295d077b2f5b8d6))
+- 🐛 uint8 to uint16 ([be5a655](https://github.com/melMass/comfy_mtb/commit/be5a655cfaba1794f7b09c82d65de42e2b031720))
+- ✨ add missing requirements ([b779bc3](https://github.com/melMass/comfy_mtb/commit/b779bc39ac19f779aeb73c98b916671d1d16806f))
+- 📝 don't propagate base logs ([7fd99c2](https://github.com/melMass/comfy_mtb/commit/7fd99c25c4e50566def5c5166a9d9059b1febfa6))
+- 🐛 bg upscaler in gfpgan ([fee48ad](https://github.com/melMass/comfy_mtb/commit/fee48adff3d66960cb17836f3f4efbfd0c8740c4))
+- 📝 separate debug / info better ([e24863d](https://github.com/melMass/comfy_mtb/commit/e24863d1f9f63f367a2b392e6228ffa42927b71b))
+- 🔥 change log level of the base logger ([7538c2c](https://github.com/melMass/comfy_mtb/commit/7538c2c4bad8390a32226dc0a5a6ef978b00d201))
+- ✨ handle externs dynamicly ([6ef308a](https://github.com/melMass/comfy_mtb/commit/6ef308a87062c91e2d7249c05d96c6fb76e5a6c4))
+- 🐛 separate faceswap model load ([8e267c0](https://github.com/melMass/comfy_mtb/commit/8e267c0204ce5abe8e113fd401234d49f377646a))
+
+### Documentation
+
+- 📝 fold each comfy mode ([3c3c438](https://github.com/melMass/comfy_mtb/commit/3c3c4380bd1a3f0eed5216b835e076c26fce2f88))
+- 📝 add more description to examples ([46eab5c](https://github.com/melMass/comfy_mtb/commit/46eab5ca2f0e04d872d87c849b11551fd219bdb9))
+- 📝 add model notice ([cbe67ed](https://github.com/melMass/comfy_mtb/commit/cbe67edd4befb7260be01fa09af8448e5bcf5680))
+- 📝 add preview for examples ([b5176ca](https://github.com/melMass/comfy_mtb/commit/b5176ca0ee489ada52b6632f68b794b4f709d5ba))
+- 📝 add jp and cn (using deep translation) ([da559b9](https://github.com/melMass/comfy_mtb/commit/da559b9eaf135a49c0ab9bfa45573baf0c18dfb2))
+- 📝 update readme ([b0fb522](https://github.com/melMass/comfy_mtb/commit/b0fb5222cb19e4004533d3367863be5c9ce8e72b)) in [#15](https://github.com/melMass/comfy_mtb/pull/15)
+- 📝 update README.md ([f8dc768](https://github.com/melMass/comfy_mtb/commit/f8dc768635a2d21f6ff81b42c418724c432159bf))
+- 📝 updated instructions ([c3b9fd4](https://github.com/melMass/comfy_mtb/commit/c3b9fd4afedbb46748aef17b40e167a4cfad65f5))
+
+### Features
+
+- ✨ update install instructions ([7be37db](https://github.com/melMass/comfy_mtb/commit/7be37dbbfac45e8038f94ced8a2fa8ec2b06fb34))
+- 🚀 add install script ([dad3966](https://github.com/melMass/comfy_mtb/commit/dad3966ba219c1998e4fc7f6e641864fb0e7c3e8))
+- 🚧 add my CLIs ([44eaae5](https://github.com/melMass/comfy_mtb/commit/44eaae5c79f4dbec344053d945e7275be5c3c0a5))
+- ✨comfy_widget shared utils ([91bb95d](https://github.com/melMass/comfy_mtb/commit/91bb95da914468de533b040324700c7f9707e4fb))
+- 🚀 debug node ([b27b8ef](https://github.com/melMass/comfy_mtb/commit/b27b8ef91fe7335b1df3766547edaf4b9625ae4d))
+- ✨ add FitNumber node ([aa551eb](https://github.com/melMass/comfy_mtb/commit/aa551ebe57801c69010815119fe21e19a858780c))
+- 🔥 add API endpoints ([95afbdb](https://github.com/melMass/comfy_mtb/commit/95afbdbf76e66897e632252d876384ada9acf153))
+- ✨ categorize ([d2b3962](https://github.com/melMass/comfy_mtb/commit/d2b396236a10fe620ebebabd5a22c36159921913))
+- 🚀 add a few examples ([b9c1d3d](https://github.com/melMass/comfy_mtb/commit/b9c1d3df7a1460fe9ffa84f6f9ea0cfb5409de1a))
+- ✨ added a way to export the node list ([5f5297f](https://github.com/melMass/comfy_mtb/commit/5f5297f80debc77f3fda2f0d37b3acff8419140d))
+- ✨ WIP batch from history ([cde7293](https://github.com/melMass/comfy_mtb/commit/cde72938d5ffd09179f5974676e12d4599a8d6ff))
+- ✨ extract node names using ast ([38f6147](https://github.com/melMass/comfy_mtb/commit/38f61473bc23b4c5d4efc5048d54c059565a6fa0))
+- 🔥 add batch support for load image sequence ([3faadc4](https://github.com/melMass/comfy_mtb/commit/3faadc4b8a5049cb8c264b8a3d50565adec405f1))
+- 🎨 add support for image.size(0) == 0 ([629e2b5](https://github.com/melMass/comfy_mtb/commit/629e2b5f5fbebe4e79e8b7a4cff2de6017e79225))
+- ✨ image feed ([99eb5ae](https://github.com/melMass/comfy_mtb/commit/99eb5ae0c7413f6ab1f24cfc8337c9b1b2d9824c))
+- ✨ FILM interpolation nodes ([e04e77e](https://github.com/melMass/comfy_mtb/commit/e04e77eb097735ec1369dec51238cdcc5abe39b7))
+- ✨ add an headless option for model downloads ([217e8a1](https://github.com/melMass/comfy_mtb/commit/217e8a1546d06b97250d99612ac6bdb5ce89e155))
+- 🐛 support batch count > 1 for restore face ([8ef48a0](https://github.com/melMass/comfy_mtb/commit/8ef48a013a8d6b832b8c0c7dcabc1b78c27ff207))
+- 🚧 wrapper for GFPGAN bg upscaler ([88cdcc6](https://github.com/melMass/comfy_mtb/commit/88cdcc6a87dae452924e8915eccdadc69d7d136e))
+- ✨ add GFPGAN (FaceRestore) ([3a6e545](https://github.com/melMass/comfy_mtb/commit/3a6e5450502f3b1d7c505178fc9ba337cd95c39e))
+
+### Miscellaneous Tasks
+
+- ✨ before categorize ([0cc54e5](https://github.com/melMass/comfy_mtb/commit/0cc54e58ec86c28354cae37e14f39e831c13ea02))
+- ✨ add more issue templates ([710a638](https://github.com/melMass/comfy_mtb/commit/710a638a8187ef08254478f684307dccdebcded2)) in [#25](https://github.com/melMass/comfy_mtb/pull/25)
+- ✨ add bug report template ([f927bc7](https://github.com/melMass/comfy_mtb/commit/f927bc7c9a82951e6df4763433732f20ea87e9cb))
+- 🍻 create FUNDING.yml ([f634fe0](https://github.com/melMass/comfy_mtb/commit/f634fe0e6b2db28138e4bd7932fbfc8606a0f033))
+- 🍻 add bmc to readme ([cd1b603](https://github.com/melMass/comfy_mtb/commit/cd1b603565464fe98a718e1fbaa8c7cd84057576))
+- 📝 extra files from another branch ([b78be8f](https://github.com/melMass/comfy_mtb/commit/b78be8fd3cd36666fd94a3ab08eca11cce526043))
+- 🚀 push leftovers ([4c41fe7](https://github.com/melMass/comfy_mtb/commit/4c41fe7af9f8e16d895eb06223349e1294dd4698))
+
+### Refactor
+
+- ♻️ removes a few nodes, moved other around ([4d8ddac](https://github.com/melMass/comfy_mtb/commit/4d8ddaca320ce483640d030618e70730b3453df2))
+- ♻️ remove test ([68c250e](https://github.com/melMass/comfy_mtb/commit/68c250e890dacae9f627b0d266ad6dcab0fa0c8b))
+- 🚧 remove color_widget ([e480d07](https://github.com/melMass/comfy_mtb/commit/e480d071171cffa789930620f1e7ccc76473bf93))
+
+### Testing
+
+- 🔧 pipe detection ([ee17d57](https://github.com/melMass/comfy_mtb/commit/ee17d57c3d6d71fda1a5acc2cf85f936c525bc87))
+
+### Install
+
+- 🚧 handle symlink errors ([d982b69](https://github.com/melMass/comfy_mtb/commit/d982b69a58c05ccead9c49370764beaa4549992a))
+
+### Merge
+
+- 🔀 pull request #22 from melMass/dev/next-release ([c34de0a](https://github.com/melMass/comfy_mtb/commit/c34de0ab351b2c95d7fa4fab4487155bee6bfa3a)) in [#22](https://github.com/melMass/comfy_mtb/pull/22)
+- 🎉 pull request #11 from dev/frame_interpolation ([1e28606](https://github.com/melMass/comfy_mtb/commit/1e28606427bcc8d895b87eaa6cd4147ab6d9a11f)) in [#11](https://github.com/melMass/comfy_mtb/pull/11)
+- 🎉 pull request #8 from dev/small-fixes ([7585624](https://github.com/melMass/comfy_mtb/commit/7585624de5895eb34c6a520d4dab18b47e64b6ca)) in [#8](https://github.com/melMass/comfy_mtb/pull/8)
+
+## [0.0.1] - 2023-06-28
+
+### Bug Fixes
+
+- 🤦 add missing file ([e2c4561](https://github.com/melMass/comfy_mtb/commit/e2c456147c260b4e9d583662e3bb9d6d9a019a5e))
+- ✨ small edits ([bcf55ca](https://github.com/melMass/comfy_mtb/commit/bcf55ca9a3a07067be3319182501f7b635e5d2ba))
+- ⚡️ add support for batch in roop ([2dae020](https://github.com/melMass/comfy_mtb/commit/2dae02056a11ddfe1f84ee040818028177e404b5))
+- 🔥 various preparing for the first tag ([793784a](https://github.com/melMass/comfy_mtb/commit/793784a5fd08e8a70d670fc8edbc3bb5b6e13e67))
+- 🐛 various bugs ([afd0843](https://github.com/melMass/comfy_mtb/commit/afd08431458e3bbb14a25c84a87408113edf5db5))
+- ⚡️ add missing controls to QRCode ([7e86b0e](https://github.com/melMass/comfy_mtb/commit/7e86b0ed4d300021517f6c5cf28a45012497b5c5))
+
+### Documentation
+
+- 📝 add rembg screenshot ([9a2d523](https://github.com/melMass/comfy_mtb/commit/9a2d52325f87ecf6342ef4897da919006755b9db))
+- 📝 add a few screenshots ([e162336](https://github.com/melMass/comfy_mtb/commit/e162336cd366d39cd4b96f05b3c9c68eecec3dc4))
+- 📝 update readme ([7f3070d](https://github.com/melMass/comfy_mtb/commit/7f3070debbc3330da50ff845621ce299894cf862))
+
+### Features
+
+- 💄 faceswap node using roop ([966a14b](https://github.com/melMass/comfy_mtb/commit/966a14b40d88f4fccfb2eaa5ff9b222f0eedd7cb))
+- ✨ sync local changes ([647bf9e](https://github.com/melMass/comfy_mtb/commit/647bf9e94195c279a620c74c2253471b9c4b90f7))
+- ✨ bbox from alpha ([37abf8a](https://github.com/melMass/comfy_mtb/commit/37abf8aad12f4711c6d82c6be4be6fa3578e7af5))
+- ✨ a111 like style loader ([f59b68e](https://github.com/melMass/comfy_mtb/commit/f59b68e3ad92841a4d189d8dddf7b41e915c9b4e))
+- ✨ add a color type and widget ([9a2e986](https://github.com/melMass/comfy_mtb/commit/9a2e986327c34227a707beab6d9929b0a05e41e6))
+- ✨ add a few nodes ([811443b](https://github.com/melMass/comfy_mtb/commit/811443b92161815db1cdff81898e8834dcd6fbfa))
+- ✨ add SadTalker as a submodule ([3fb8716](https://github.com/melMass/comfy_mtb/commit/3fb871651b12bce62d8e911bd3884f417f80c937))
+- 🚨 push local changes ([6cac344](https://github.com/melMass/comfy_mtb/commit/6cac344f6fb15ebb902acee70ee71edc585ec4bc))
+- ⚡️ initial commit ([1ae3bbc](https://github.com/melMass/comfy_mtb/commit/1ae3bbc89ae6e0d2e8c61122485bd0df837e17c2))
+
+### Miscellaneous Tasks
+
+- 🚀 add gh action ([572b4d5](https://github.com/melMass/comfy_mtb/commit/572b4d52bce1398660d4d7ca0c5c48c11e0128e3)) in [#4](https://github.com/melMass/comfy_mtb/pull/4)
+
+[main]: https://github.com/melMass/comfy_mtb/compare/v0.1.4..main
+[0.1.4]: https://github.com/melMass/comfy_mtb/compare/v0.1.3..v0.1.4
+[0.1.3]: https://github.com/melMass/comfy_mtb/compare/v0.1.2..v0.1.3
+[0.1.2]: https://github.com/melMass/comfy_mtb/compare/v0.1.1..v0.1.2
+[0.1.1]: https://github.com/melMass/comfy_mtb/compare/v0.1.0..v0.1.1
+[0.1.0]: https://github.com/melMass/comfy_mtb/compare/v0.0.1..v0.1.0
+

INSTALL.md

@@ -0,0 +1,85 @@
+# Installation
+- [Installation](#installation)
+  - [Automatic Install (Recommended)](#automatic-install-recommended)
+    - [ComfyUI Manager](#comfyui-manager)
+    - [Virtual Env](#virtual-env)
+  - [Models Download](#models-download)
+  - [Old installation method (MANUAL)](#old-installation-method-manual)
+    - [Dependencies](#dependencies)
+
+## Automatic Install (Recommended)
+
+### ComfyUI Manager
+
+As of version 0.1.0, this extension is meant to be installed with the [ComfyUI-Manager](https://github.com/ltdrdata/ComfyUI-Manager), which helps a lot with handling the various install issues faced by various environments.
+
+### Virtual Env
+There is also an experimental one liner install using the following command from ComfyUI's root. It will download the code, install the dependencies and run the install script:
+
+```bash
+curl -sSL "https://raw.githubusercontent.com/username/repo/main/install.py" | python3 -
+```
+
+## Models Download
+Some nodes require extra models to be downloaded, you can interactively do it using the same python environment as above:
+```bash
+python scripts/download_models.py
+```
+
+then follow the prompt or just press enter to download every models.
+
+> **Note**
+> You can use the following to download all models without prompt:
+  ```bash
+  python scripts/download_models.py -y
+  ```
+
+
+## Old installation method (MANUAL)
+### Dependencies
+<details><summary><h4>Custom Virtualenv (I use this mainly)</h4></summary>
+    
+1. Make sure you are in the Python environment you use for ComfyUI.
+2. Install the required dependencies by running the following command:
+  ```bash
+  pip install -r comfy_mtb/requirements.txt
+  ```
+
+</details>
+
+<details><summary><h4>Comfy-portable / standalone (from ComfyUI releases)</h4></summary>
+    
+If you use the `python-embeded` from ComfyUI standalone then you are not able to pip install dependencies with binaries when they don't have wheels, in this case check the last [release](https://github.com/melMass/comfy_mtb/releases) there is a bundle for linux and windows with prebuilt wheels (only the ones that require building from source), check [this issue (#1)](https://github.com/melMass/comfy_mtb/issues/1) for more info.
+![image](https://github.com/melMass/comfy_mtb/assets/7041726/2934fa14-3725-427c-8b9e-2b4f60ba1b7b)
+
+
+
+</details>
+
+<details><summary><h4>Google Colab</h4></summary>
+
+Add a new code cell just after the **Run ComfyUI with localtunnel (Recommended Way)** header (before the code cell)
+![preview of where to add it on colab](https://github.com/melMass/comfy_mtb/assets/7041726/35df2ef1-14f9-44cd-aa65-353829188cd7)
+
+
+```python
+# download the nodes
+!git clone --recursive https://github.com/melMass/comfy_mtb.git custom_nodes/comfy_mtb
+
+# download all models
+!python custom_nodes/comfy_mtb/scripts/download_models.py -y
+
+# install the dependencies
+!pip install -r custom_nodes/comfy_mtb/reqs.txt -f https://download.openmmlab.com/mmcv/dist/cu118/torch2.0/index.html
+```
+If after running this, colab complains about needing to restart runtime, do it, and then do not rerun earlier cells, just the one to run the localtunnel. (you might have to add a cell with `%cd ComfyUI` first...)
+
+
+> **Note**:
+> If you don't need all models, remove the `-y` as collab actually supports user input: ![image](https://github.com/melMass/comfy_mtb/assets/7041726/40fc3602-f1d4-432a-98fd-ce2240f5ad06)
+
+> **Preview**
+> ![image](https://github.com/melMass/comfy_mtb/assets/7041726/b5b2b2d9-f1e8-4c43-b1db-7dfc5e07be86)
+
+</details>
+

LICENSE

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

README.md

@@ -1,59 +1,11 @@
-## MTB Nodes
+# MTB Nodes
+[![embedded test](https://github.com/melMass/comfy_mtb/actions/workflows/test_embedded.yml/badge.svg)](https://github.com/melMass/comfy_mtb/actions/workflows/test_embedded.yml)
 
-Feel free to do whatever you want with this codebase, I'm mainly using Comfy to build POCs to implement in [MLOPs](https://github.com/Bismuth-Consultancy-BV/MLOPs). And a lot of nodes are inspired by existing ones from the community or builtin 
-Just beware of the licenses of some libraries (deepbump for instance is [GPLv3](https://github.com/HugoTini/DeepBump/blob/master/LICENSE))
+![home](https://repository-images.githubusercontent.com/649047066/a3eef9a7-20dd-4ef9-b839-884502d4e873)
 
-## Install
+<!-- omit in toc -->
+<a href="https://www.buymeacoffee.com/melmass" target="_blank"><img src="https://www.buymeacoffee.com/assets/img/custom_images/orange_img.png" alt="Buy Me A Coffee" style="height: 32px !important;width: 140px !important;box-shadow: 0px 3px 2px 0px rgba(190, 190, 190, 0.5) !important;-webkit-box-shadow: 0px 3px 2px 0px rgba(190, 190, 190, 0.5) !important;" ></a>
 
-From within the python environment you already use for ComfyUI install the requirements.
-```bash
-pip install -r comfy_mtb/requirements.txt
-```
-
-## Screenshots
-
-- **FaceSwap [roop]** (using [roop](https://github.com/s0md3v/roop/))  
-  The face index allow you to choose which face to replace as you can see here:
-  ![ComfyUI_909](https://github.com/melMass/comfy_mtb/assets/7041726/2e9d6066-c466-4a01-bd6c-315f7f1e8b42)
-
-- **Style Loader**: A111 like csv styles in Comfy  
-  ![image](https://github.com/melMass/comfy_mtb/assets/7041726/02fe3211-18ee-4e54-a029-931388f5fde8)
-
-- **Color Correction**: basic color correction node  
-  ![image](https://github.com/melMass/comfy_mtb/assets/7041726/7c20ac83-31ff-40ea-a1a0-06c2acefb2ef)
-
-- **Image Remove Background [RemBG]**: (using [rembg](https://github.com/danielgatis/rembg))
-  ![image](https://github.com/melMass/comfy_mtb/assets/7041726/e69253b4-c03c-45e9-92b5-aa46fb887be8)
+[**Wiki**](https://github.com/melMass/comfy_mtb/wiki) | [**Install Guide**](./INSTALL.md) | [**Examples**](https://github.com/melMass/comfy_mtb/wiki/Examples)
 
 
-
-### Node List
-
-- `Latent Lerp`: Linear Interpolate between two latents,
-- `Int to Number`: Supplement for WASSuite number nodes,
-- `Bounding Box`: BBox constructor (custom type),
-- `Crop`: Crop image from BBox,
-- `Uncrop`: Uncrop image from BBox,
-- `ImageBlur`: Blur the input image,
-- `Denoise`: Denoise the input image,
-- `ImageCompare`: Compare image,
-- `RGB to HSV`: -,
-- `HSV to RGB`: -,
-- `Color Correct`: Basic color correction tools,
-- `Modulo`: Modulo (useful for loops),
-- `Deglaze Image`: taken from [FN16](https://github.com/Fannovel16/FN16-ComfyUI-nodes/blob/main/DeglazeImage.py),
-- `Smart Step`: A very basic node to get step percent to use in KSampler advanced,
-
-
-### Comfy Resources
-
-**Guides**:
-- [Official Examples (eng)](https://comfyanonymous.github.io/ComfyUI_examples/)
-- [ComfyUI Community Manual (eng)](https://blenderneko.github.io/ComfyUI-docs/) by @BlenderNeko
-  
-- [Tomoaki's personal Wiki (jap)](https://comfyui.creamlab.net/guides/) by @tjhayasaka
-
-**Extensions and Custom Nodes**:
-- [Plugins for Comfy List (eng)](https://github.com/WASasquatch/comfyui-plugins) by @WASasquatch
-
-- [ComfyUI tag on CivitAI (eng)](https://civitai.com/tag/comfyui)

__init__.py

@@ -1,16 +1,79 @@
-import traceback
-from .log import log, blue_text, get_summary, get_label
-from .utils import here
-import importlib
+#!/usr/bin/env python3
+###
+# File: __init__.py
+# Project: comfy_mtb
+# Author: Mel Massadian
+# Copyright (c) 2023 Mel Massadian
+#
+###
+
+__version__ = "0.2.0"
+
 import os
 
-NODE_CLASS_MAPPINGS = {}
-NODE_CLASS_MAPPINGS_DEBUG = {}
+from aiohttp.web_request import Request
+
+# TODO: don't override this if the user has that setup already
+if not os.environ.get("TF_FORCE_GPU_ALLOW_GROWTH"):
+    os.environ["TF_FORCE_GPU_ALLOW_GROWTH"] = "true"
+
+if not os.environ.get("TF_GPU_ALLOCATOR"):
+    os.environ["TF_GPU_ALLOCATOR"] = "cuda_malloc_async"
+
+import ast
+import contextlib
+import importlib
+import json
+import logging
+import shutil
+import traceback
+from importlib import reload
+from pathlib import Path
+
+from aiohttp import web
+from server import PromptServer
+
+from .endpoint import endlog
+from .log import blue_text, cyan_text, get_label, get_summary, log
+from .utils import comfy_dir, here
+
+NODE_CLASS_MAPPINGS: dict[str, type] = {}
+NODE_DISPLAY_NAME_MAPPINGS: dict[str, str] = {}
+NODE_CLASS_MAPPINGS_DEBUG: dict[str, str | None] = {}
+WEB_DIRECTORY = "./web"
+
+
+def extract_nodes_from_source(filename: Path):
+    source_code = ""
+    source_code = filename.read_text(encoding="utf-8")
+    nodes: list[str] = []
+
+    try:
+        parsed = ast.parse(source_code)
+        for node in ast.walk(parsed):
+            if isinstance(node, ast.Assign) and len(node.targets) == 1:
+                target = node.targets[0]
+                if isinstance(target, ast.Name) and target.id == "__nodes__":
+                    value = ast.get_source_segment(source_code, node.value)
+                    if value:
+                        node_value = ast.parse(value).body[0].value
+                        if isinstance(node_value, ast.List | ast.Tuple):
+                            nodes.extend(
+                                str(element.id)
+                                for element in node_value.elts
+                                if isinstance(element, ast.Name)
+                            )
+                        break
+    except SyntaxError:
+        log.error("Failed to parse")
+    return nodes
 
 
 def load_nodes():
-    errors = []
-    nodes = []
+    errors: list[str] = []
+    nodes: list[type] = []
+    nodes_failed: list[str] = []
+
     for filename in (here / "nodes").iterdir():
         if filename.suffix == ".py":
             module_name = filename.stem
@@ -19,56 +82,479 @@ def load_nodes():
                 module = importlib.import_module(
                     f".nodes.{module_name}", package=__package__
                 )
-                _nodes = getattr(module, "__nodes__")
+                _nodes = getattr(module, "__nodes__", [])
                 nodes.extend(_nodes)
-
                 log.debug(f"Imported {module_name} nodes")
 
             except AttributeError:
+                log.debug(f"Skipping wip module {module_name}")
                 pass  # wip nodes
             except Exception:
                 error_message = traceback.format_exc().splitlines()[-1]
-                errors.append(f"Failed to import {module_name} because {error_message}")
+
+                errors.append(
+                    f"Failed to import module {module_name} because {error_message}"
+                )
+                # Read __nodes__ variable from the source file
+                nodes_failed.extend(extract_nodes_from_source(filename))
 
     if errors:
-        log.error(
-            f"Some nodes failed to load:\n\t"
+        log.debug(
+            "Some nodes failed to load:\n\t"
             + "\n\t".join(errors)
             + "\n\n"
             + "Check that you properly installed the dependencies.\n"
             + "If you think this is a bug, please report it on the github page (https://github.com/melMass/comfy_mtb/issues)"
         )
 
-    return nodes
+    return (nodes, nodes_failed)
 
 
 # - REGISTER WEB EXTENSIONS
-web_extensions_root = utils.comfy_dir / "web" / "extensions"
-web_mtb = web_extensions_root / "mtb"
+def uninstall_old_web_extensions():
+    web_extensions_root = comfy_dir / "web" / "extensions"
+    web_mtb = web_extensions_root / "mtb"
 
-if web_mtb.exists():
-    log.debug(f"Web extensions folder found at {web_mtb}")
-elif web_extensions_root.exists():
-    os.symlink((here / "web"), web_mtb.as_posix())
-else:
-    log.error(
-        f"Comfy root probably not found automatically, please copy the folder {web_mtb} manually in the web/extensions folder of ComfyUI"
+    if web_mtb.exists() and hasattr(nodes, "EXTENSION_WEB_DIRS"):
+        try:
+            if web_mtb.is_symlink():
+                web_mtb.unlink()
+            else:
+                shutil.rmtree(web_mtb)
+        except Exception as e:
+            log.warning(
+                f"""Failed to remove web mtb directory: {e}
+Please manually remove it from disk ({web_mtb}) and restart the server."""
+            )
+
+
+# uninstall_old_web_extensions()
+
+
+# - GATHER WIKI PAGES
+def wiki_to_classname(s: str):
+    wiki_name = s.replace("nodes-", "", 1)
+    return "MTB_" + "".join(
+        [part.capitalize() for part in wiki_name.split("-")]
     )
 
-# - REGISTER NODES
-nodes = load_nodes()
-for node_class in nodes:
-    class_name = node_class.__name__
-    class_name = node_class.__name__
-    node_name = f"{get_label(class_name)} (mtb)"
-    NODE_CLASS_MAPPINGS[node_name] = node_class
-    NODE_CLASS_MAPPINGS_DEBUG[node_name] = node_class.__doc__
 
+def classname_to_wiki(s: str):
+    classname = s.replace("MTB_", "")
+    parts: list[str] = []
+    start = 0
+    for i in range(1, len(classname)):
+        if classname[i].isupper():
+            parts.append(classname[start:i].lower())
+            start = i
+    parts.append(classname[start:].lower())
+    return "nodes-" + "-".join(parts)
+
+
+wiki = here / "wiki"
+node_docs = {}
+if wiki.exists() and wiki.is_dir():
+    node_docs = {
+        wiki_to_classname(x.stem): x.read_text(encoding="utf-8")
+        for x in (wiki / "nodes").glob("*.md")
+    }
+
+
+# - REGISTER NODES
+MTB_EXPORT = os.environ.get("MTB_EXPORT")
+
+nodes, failed = load_nodes()
+for node_class in nodes:
+    class_name: str = node_class.__name__
+    linked_doc = node_docs.get(class_name)
+
+    if not hasattr(node_class, "DESCRIPTION"):
+        if linked_doc:
+            log.debug(f"Found linked doc for {class_name}, using it")
+            node_class.DESCRIPTION = linked_doc
+        elif node_class.__doc__:
+            log.debug(f"Using __doc__ as description for {class_name}")
+            node_class.DESCRIPTION = node_class.__doc__
+            if MTB_EXPORT:
+                wiki_name = classname_to_wiki(class_name)
+                _ = (wiki / "nodes" / (wiki_name + ".md")).write_text(
+                    node_class.__doc__, encoding="utf-8"
+                )
+
+        else:
+            log.debug(
+                f"None of the methods could retrieve documentation for {class_name}"
+            )
+
+    node_label = f"{get_label(class_name)} (mtb)"
+    NODE_CLASS_MAPPINGS[node_label] = node_class
+    NODE_DISPLAY_NAME_MAPPINGS[class_name] = node_label
+    NODE_CLASS_MAPPINGS_DEBUG[node_label] = node_class.__doc__
+
+    # TODO: I removed this, I find it more convenient to write without spaces
+    # but it breaks every of my workflows
+    # TODO (cont): and until I find a way to automate the conversion
+    # I'll leave it like this
+
+    if os.environ.get("MTB_EXPORT"):
+        with open(here / "node_list.json", "w") as f:
+            _ = f.write(
+                json.dumps(
+                    {
+                        k: NODE_CLASS_MAPPINGS_DEBUG[k]
+                        for k in sorted(NODE_CLASS_MAPPINGS_DEBUG.keys())
+                    },
+                    indent=4,
+                )
+            )
 
 log.debug(
-    f"Loaded the following nodes:\n\t"
+    "Loaded the following nodes:\n\t"
     + "\n\t".join(
-        f"{k}: {blue_text(get_summary(doc)) if doc else '-'}"
+        f"{cyan_text(k)}: {blue_text(get_summary(doc)) if doc else '-'}"
         for k, doc in NODE_CLASS_MAPPINGS_DEBUG.items()
     )
 )
+
+log.info(f"loaded {cyan_text(str(len(nodes)))} nodes successfuly")
+
+if failed:
+    with contextlib.suppress(Exception):
+        base_url, port = utils.get_server_info()
+        log.info(
+            f"Some nodes ({len(failed)}) could not be loaded. This can be ignored, but go to http://{base_url}:{port}/mtb if you want more information."
+        )
+        log.debug(failed)
+
+
+# - ENDPOINT
+
+
+if hasattr(PromptServer, "instance"):
+    img_cache = None
+    prompt_cache = None
+
+    with contextlib.suppress(ImportError):
+        from cachetools import TTLCache
+
+        img_cache = TTLCache(maxsize=100, ttl=5)  # 1 min TTL
+        prompt_cache = TTLCache(maxsize=100, ttl=5)  # 1 min TTL
+
+    restore_deps = ["basicsr"]
+    onnx_deps = ["onnxruntime"]
+    swap_deps = ["insightface"] + onnx_deps
+    node_dependency_mapping = {
+        "QrCode": ["qrcode"],
+        "DeepBump": onnx_deps,
+        "FaceSwap": swap_deps,
+        "LoadFaceSwapModel": swap_deps,
+        "LoadFaceAnalysisModel": restore_deps,
+    }
+
+    PromptServer.instance.app.router.add_static(
+        "/mtb-assets/", path=(here / "html").as_posix()
+    )
+
+    # NOTE: we add an extra static path to avoid comfy mechanism
+    # that loads every script in web.
+    PromptServer.instance.app.add_routes(
+        [web.static("/mtb_async", (here / "web_async").as_posix())]
+    )
+
+    @PromptServer.instance.routes.get("/mtb/manage")
+    async def manage(request):
+        from . import endpoint
+
+        reload(endpoint)
+
+        endlog.debug("Initializing Manager")
+        if "text/html" in request.headers.get("Accept", ""):
+            csv_editor = endpoint.csv_editor()
+
+            tabview = endpoint.render_tab_view(Styles=csv_editor)
+            return web.Response(
+                text=endpoint.render_base_template("MTB", tabview),
+                content_type="text/html",
+            )
+
+        return web.json_response(
+            {
+                "message": "manage only has a POST api for now",
+            }
+        )
+
+    @PromptServer.instance.routes.get("/mtb/status")
+    async def get_full_library(request):
+        from . import endpoint
+
+        reload(endpoint)
+
+        endlog.debug("Getting node registration status")
+        # Check if the request prefers HTML content
+        if "text/html" in request.headers.get("Accept", ""):
+            # # Return an HTML page
+            html_response = endpoint.render_table(
+                NODE_CLASS_MAPPINGS_DEBUG, title="Registered"
+            )
+            html_response += endpoint.render_table(
+                {
+                    k: {"dependencies": node_dependency_mapping.get(k)}
+                    if node_dependency_mapping.get(k)
+                    else "-"
+                    for k in failed
+                },
+                title="Failed to load",
+            )
+
+            return web.Response(
+                text=endpoint.render_base_template("MTB", html_response),
+                content_type="text/html",
+            )
+
+        return web.json_response(
+            {
+                "registered": NODE_CLASS_MAPPINGS_DEBUG,
+                "failed": failed,
+            }
+        )
+
+    @PromptServer.instance.routes.post("/mtb/server-info")
+    async def set_server_info(request: Request):
+        json_data: dict[str, bool] = await request.json()
+        enabled = json_data.get("debug")
+        if enabled:
+            os.environ["MTB_DEBUG"] = "true"
+            log.setLevel(logging.DEBUG)
+            log.debug("Debug mode set from API (/mtb/debug POST route)")
+
+        elif "MTB_DEBUG" in os.environ:
+            # del os.environ["MTB_DEBUG"]
+            _ = os.environ.pop("MTB_DEBUG")
+            log.setLevel(logging.INFO)
+
+        return web.json_response(
+            {"message": f"Debug mode {'set' if enabled else 'unset'}"}
+        )
+
+    @PromptServer.instance.routes.get("/mtb")
+    async def get_home(request: Request):
+        from . import endpoint
+
+        _ = reload(endpoint)
+        # Check if the request prefers HTML content
+        if "text/html" in request.headers.get("Accept", ""):
+            # # Return an HTML page
+            html_response = """
+            <div class="flex-container menu">
+                <a href="/mtb/manage">manage</a>
+                <a href="/mtb/server-info">Server Info</a>
+                <a href="/mtb/status">status</a>
+            </div>
+            """
+            return web.Response(
+                text=endpoint.render_base_template("MTB", html_response),
+                content_type="text/html",
+            )
+
+        # Return JSON for other requests
+        return web.json_response({"message": "Welcome to MTB!"})
+
+    import asyncio
+    import os
+    from io import BytesIO
+
+    from aiohttp import web
+    from PIL import Image
+
+    def get_cached_image(file_path: str, preview_params=None, channel=None):
+        cache_key = (file_path, preview_params, channel)
+        if img_cache and (cache_key in img_cache):
+            return img_cache[cache_key]
+
+        with Image.open(file_path) as img:
+            info = img.info
+            if preview_params:
+                img = process_preview(img, preview_params)
+            if channel:
+                img = process_channel(img, channel)
+            if prompt_cache:
+                prompt_cache[cache_key] = info
+            if img_cache:
+                img_cache[cache_key] = img.getvalue()
+                return img_cache[cache_key]
+
+            return img.getvalue()
+
+    def process_preview(img: Image.Image, preview_params):
+        image_format, quality, width = preview_params
+        quality = int(quality)
+
+        if width:
+            width = int(width)
+            img.thumbnail((width, int(width * img.height / img.width)))
+
+        buffer = BytesIO()
+        img.save(
+            buffer, format=image_format, quality=quality, metadata=img.info
+        )
+        buffer.seek(0)
+        return buffer
+
+    def process_channel(img: Image.Image, channel: str):
+        if channel == "rgb":
+            if img.mode == "RGBA":
+                r, g, b, _ = img.split()
+                img = Image.merge("RGB", (r, g, b))
+            else:
+                img = img.convert("RGB")
+        elif channel == "a":
+            if img.mode == "RGBA":
+                _, _, _, a = img.split()
+            else:
+                a = Image.new("L", img.size, 255)
+            img = Image.new("RGBA", img.size)
+            img.putalpha(a)
+
+        buffer = BytesIO()
+        img.save(buffer, format="PNG")
+        _ = buffer.seek(0)
+        return buffer
+
+    async def get_image_response(
+        file, filename: str, preview_info=None, channel=None
+    ):
+        img = await asyncio.to_thread(
+            get_cached_image, file, preview_info, channel
+        )
+        return web.Response(
+            body=img,
+            content_type="image/webp" if preview_info else "image/png",
+            headers={"Content-Disposition": f'filename="{filename}"'},
+        )
+
+    # TODO: Embed the metadatas somehow so we can drag and drop
+    #       to load workflows in the sidebar
+    @PromptServer.instance.routes.get("/mtb/view")
+    async def view_image(request: Request):
+        import folder_paths
+
+        filename = request.rel_url.query.get("filename")
+        if not filename:
+            return web.Response(status=404)
+
+        filename, output_dir = folder_paths.annotated_filepath(filename)
+        if filename[0] == "/" or ".." in filename:
+            return web.Response(status=400)
+
+        if output_dir is None:
+            rtype = request.rel_url.query.get("type", "output")
+            output_dir = folder_paths.get_directory_by_type(rtype)
+
+        if output_dir is None:
+            return web.Response(status=400)
+
+        if "subfolder" in request.rel_url.query:
+            full_output_dir = os.path.join(
+                output_dir, request.rel_url.query["subfolder"]
+            )
+            if (
+                os.path.commonpath(
+                    (os.path.abspath(full_output_dir), output_dir)
+                )
+                != output_dir
+            ):
+                return web.Response(status=403)
+            output_dir = full_output_dir
+
+        filename = os.path.basename(filename)
+        file = os.path.join(output_dir, filename)
+
+        if not os.path.isfile(file):
+            return web.Response(status=404)
+
+        preview_info = None
+        if "preview" in request.rel_url.query:
+            preview_params = request.rel_url.query["preview"].split(";")
+            image_format = (
+                preview_params[0]
+                if preview_params[0] in ["webp", "jpeg"]
+                else "webp"
+            )
+            quality = (
+                int(preview_params[1])
+                if len(preview_params) > 1 and preview_params[1].isdigit()
+                else 90
+            )
+            width = request.rel_url.query.get("width")
+            preview_info = (image_format, quality, width)
+
+        channel = request.rel_url.query.get("channel")
+
+        return await get_image_response(file, filename, preview_info, channel)
+
+    @PromptServer.instance.routes.get("/mtb/server-info")
+    async def get_debug(request: Request):
+        from . import endpoint
+
+        _ = reload(endpoint)
+        isdebug = "MTB_DEBUG" in os.environ
+        exposed = "MTB_EXPOSE" in os.environ
+
+        def render_property(name: str, val: str):
+            return f"""<strong>{name}:</strong>
+                <p>
+                    {val}
+                </p>"""
+
+        # Check if the request prefers HTML content
+        if "text/html" in request.headers.get("Accept", ""):
+            # # Return an HTML page
+            html_response = ""
+
+            html_response += render_property(
+                "Debug", "Enabled" if isdebug else "Disabled"
+            )
+
+            html_response += render_property("Exposed", str(exposed))
+
+            return web.Response(
+                text=endpoint.render_base_template(
+                    "Server Info", html_response
+                ),
+                content_type="text/html",
+            )
+
+        # Return JSON for other requests
+        return web.json_response({"exposed": exposed, "debug": isdebug})
+
+    @PromptServer.instance.routes.get("/mtb/actions")
+    async def no_route(request: Request):
+        from . import endpoint
+
+        if "text/html" in request.headers.get("Accept", ""):
+            html_response = """
+            <h1>Actions has no get for now...</h1>
+            """
+            return web.Response(
+                text=endpoint.render_base_template("Actions", html_response),
+                content_type="text/html",
+            )
+        return web.json_response({"message": "actions has no get for now"})
+
+    @PromptServer.instance.routes.post("/mtb/actions")
+    async def do_action(request: Request):
+        from . import endpoint
+
+        reload(endpoint)
+
+        return await endpoint.do_action(request)
+
+
+# - WAS Dictionary
+MANIFEST = {
+    "name": "MTB Nodes",  # The title that will be displayed on Node Class menu,. and Node Class view
+    "version": (0, 1, 0),  # Version of the custom_node or sub module
+    "author": "Mel Massadian",  # Author or organization of the custom_node or sub module
+    "project": "https://github.com/melMass/comfy_mtb",  # The address that the `name` value will link to on Node Class Views
+    "description": "Set of nodes that enhance your animation workflow and provide a range of useful tools including features such as manipulating bounding boxes, perform color corrections, swap faces in images, interpolate frames for smooth animation, export to ProRes format, apply various image operations, work with latent spaces, generate QR codes, and create normal and height maps for textures.",
+}

biome.json

@@ -0,0 +1,31 @@
+{
+  "$schema": "https://biomejs.dev/schemas/1.6.1/schema.json",
+  "organizeImports": {
+    "enabled": true
+  },
+  "linter": {
+    "enabled": true,
+    "rules": {
+      "recommended": true,
+      "suspicious": {
+        "noConsoleLog": "warn"
+      },
+      "style": {
+        "noParameterAssign": "off",
+        "noShoutyConstants": "warn",
+        "useNamingConvention": "off"
+      }
+    }
+  },
+  "formatter": {
+    "indentStyle": "space",
+    "indentWidth": 2,
+    "lineEnding": "lf"
+  },
+  "javascript": {
+    "formatter": {
+      "quoteStyle": "single",
+      "semicolons": "asNeeded"
+    }
+  }
+}

cliff.toml

@@ -0,0 +1,83 @@
+[changelog]
+header = """
+# Changelog\n
+This is an automated changelog based on the commits in this repository.
+
+Check the notes in the [releases](https://github.com/melMass/comfy_mtb/releases) for more information.
+"""
+# https://keats.github.io/tera/docs/#introduction
+body = """
+{% if version -%}\
+    ## [{{ version | trim_start_matches(pat="v") }}] - {{ timestamp | date(format="%Y-%m-%d") }}
+{% else %}\
+    ## [Unreleased]
+{% endif -%}\
+
+{% for group, commits in commits | group_by(attribute="group") %}
+    ### {{ group | upper_first }}
+    {% for commit in commits %}
+        - {% if commit.breaking %}[**breaking**] {% endif %}{{ commit.message | upper_first | trim }} ([{{ commit.id | truncate(length=7, end="") }}](<REPO>/commit/{{ commit.id }}))\
+            {% if commit.github.username and commit.github.username != remote.github.owner %} by [@{{ commit.github.username }}](https://github.com/{{ commit.github.username }}){%- endif -%}
+            {% if commit.github.pr_number %} in [#{{ commit.github.pr_number }}](<REPO>/pull/{{ commit.github.pr_number }}){%- endif -%}
+    {% endfor %}
+{% endfor %}
+
+{%- if github.contributors | filter(attribute="is_first_time", value=true) | length != 0 %}
+  ## New Contributors
+{%- endif -%}
+
+{% for contributor in github.contributors | filter(attribute="is_first_time", value=true) %}
+  * [@{{ contributor.username }}](https://github.com/{{ contributor.username }}) made their first contribution in [#{{ contributor.pr_number }}](<REPO>/pull/{{ contributor.pr_number }})\
+{%- endfor %}\n
+"""
+footer = """
+{% for release in releases -%}
+    {% if release.version -%}
+        {% if release.previous.version -%}
+            [{{ release.version | trim_start_matches(pat="v") }}]: \
+                <REPO>/compare/{{ release.previous.version }}..{{ release.version }}
+        {% endif -%}
+    {% else -%}
+        [unreleased]: <REPO>/compare/{{ release.previous.version }}..HEAD
+    {% endif -%}
+{% endfor %}
+"""
+trim = true
+postprocessors = [
+  { pattern = '<REPO>', replace = "https://github.com/melMass/comfy_mtb" }, # replace repository URL
+]
+
+[git]
+# https://www.conventionalcommits.org
+conventional_commits = true
+filter_unconventional = true
+split_commits = false
+commit_preprocessors = [
+  # { pattern = '\((\w+\s)?#([0-9]+)\)', replace = "([#${2}](<REPO>/issues/${2}))" }, # replace issue numbers
+  { pattern = '\((\w+\s)?#([0-9]+)\)', replace = "" },
+]
+commit_parsers = [
+  { message = "^feat", group = "Features" },
+  { message = "^fix", group = "Bug Fixes" },
+  { message = "^doc", group = "Documentation" },
+  { message = "^perf", group = "Performance" },
+  { message = "^refactor", group = "Refactor" },
+  { message = "^style", group = "Styling" },
+  { message = "^test", group = "Testing" },
+  { message = "^chore\\(release\\): prepare for", skip = true },
+  { message = "^chore\\(deps\\)", skip = true },
+  { message = "^chore\\(pr\\)", skip = true },
+  { message = "^chore\\(pull\\)", skip = true },
+  { message = "^chore|ci", group = "Miscellaneous Tasks" },
+  { body = ".*security", group = "Security" },
+  { message = "^revert", group = "Revert" },
+]
+protect_breaking_commits = false
+filter_commits = false
+tag_pattern = "v[0-9].*"
+topo_order = false
+sort_commits = "newest"
+
+[remote.github]
+owner = "melMass"
+repo = "comfy_mtb"

endpoint.py

@@ -0,0 +1,514 @@
+import csv
+import secrets
+import sys
+from pathlib import Path
+from typing import Any, Literal
+
+from aiohttp import web
+
+from .log import mklog
+from .utils import (
+    SortMode,
+    backup_file,
+    build_glob_patterns,
+    glob_multiple,
+    here,
+    import_install,
+    input_dir,
+    output_dir,
+    reqs_map,
+    run_command,
+    styles_dir,
+)
+
+endlog = mklog("mtb endpoint")
+
+# - ACTIONS
+import asyncio
+import platform
+import sys
+from pathlib import Path
+
+try:
+    import websockets.server
+except ModuleNotFoundError:
+    endlog.warning(
+        "You do not have websockets installed, the video server won't work"
+    )
+    websockets = False
+
+import_install("requirements")
+import io
+
+import numpy as np
+from PIL import Image
+
+
+def generate_random_frame():
+    # Generate a random image frame
+    width, height = 640, 480
+    image = np.random.randint(0, 256, (height, width, 3), dtype=np.uint8)
+    pil_image = Image.fromarray(image)
+    byte_buffer = io.BytesIO()
+    pil_image.save(byte_buffer, format="JPEG")
+    frame_data = byte_buffer.getvalue()
+    return frame_data
+
+
+class VideoStreamingManager:
+    def __init__(self):
+        self.video_servers = {}
+        self.next_port = (
+            8767  # Start with a default port and increment for each server
+        )
+
+    async def start_video_streaming_server(self, video_id):
+        if video_id not in self.video_servers:
+            # Create and start a new video streaming server for the specified video
+            video_server = await self.create_video_streaming_server(video_id)
+            self.video_servers[video_id] = video_server
+
+            return video_server
+
+    async def video_stream(self, websocket, path):
+        # Implement the logic to continuously capture and send video frames here
+        while True:
+            # frame_data = capture_and_encode_frame()  # Implement this function
+            frame_data = generate_random_frame()
+            await websocket.send(frame_data)
+            await asyncio.sleep(0.033)  # Adjust the frame rate as needed
+
+    async def create_video_streaming_server(self, video_id):
+        # Create and start a new WebSocket server for the specified video
+        port = self.next_port
+        self.next_port += 1  # Increment port number for the next server
+
+        server = await websockets.server.serve(
+            self.video_stream, "localhost", port
+        )
+
+        return server
+
+    async def stop_video_streaming_server(self, video_id):
+        if video_id in self.video_servers:
+            # Terminate and remove the video streaming server for the specified video
+            video_server = self.video_servers[video_id]
+            video_server.close()
+            await video_server.wait_closed()
+            del self.video_servers[video_id]
+
+
+async def start_video_streaming_server():
+    async def video_stream(websocket, path):
+        # Continuously capture and send video frames here
+        while True:
+            frame_data = capture_and_encode_frame()  # Implement this function
+            await websocket.send(frame_data)
+            await asyncio.sleep(0.033)  # Adjust the frame rate as needed
+
+    start_server = websockets.server.serve(
+        video_stream, "localhost", 8766
+    )  # Use a different port (e.g., 8766)
+
+    return await start_server
+
+
+def ACTIONS_installDependency(dependency_names=None):
+    if dependency_names is None:
+        # return web.Response(text="No dependency name provided", status=400)
+        return {"error": "No dependency name provided"}
+
+    endlog.debug(f"Received Install Dependency request for {dependency_names}")
+    # reqs = []
+    resolved_names = [reqs_map.get(name, name) for name in dependency_names]
+    try:
+        run_command(
+            [Path(sys.executable), "-m", "pip", "install"] + resolved_names
+        )
+        return {"success": True}
+
+    except Exception as e:
+        return {"error": f"Failed to install dependencies: {e}"}
+
+    # if platform.system() == "Windows":
+    #     reqs = list(requirements.parse((here / "reqs_windows.txt").read_text()))
+    # else:
+    #     reqs = list(requirements.parse((here / "reqs.txt").read_text()))
+    # print([x.specs for x in reqs])
+    # print(
+    #     "\n".join([f"{x.line} {''.join(x.specs[0] if x.specs else '')}" for x in reqs])
+    # )
+    # for dependency_name in dependency_names:
+    #     for req in reqs:
+    #         if req.name == dependency_name:
+    #             endlog.debug(f"Dependency {dependency_name} installed")
+    #             break
+
+
+def ACTIONS_getUserImages(
+    mode: Literal["input", "output"],
+    count=200,
+    offset=0,
+    sort: str | None = None,
+    include_subfolders: bool = False,
+):
+    # enabled = "MTB_EXPOSE" in os.environ
+    # if not enabled:
+    #     return {"error": "Session not authorized to getInputs"}
+
+    imgs = {}
+    entry_dir = input_dir if mode == "input" else output_dir
+    supported = ["png", "jpg", "jpeg", "webp", "gif"]
+
+    entries = {}
+    patterns = build_glob_patterns(supported, recursive=include_subfolders)
+    entries = glob_multiple(entry_dir, patterns)
+
+    sort_mode = SortMode.from_str(sort)
+
+    if sort_mode:
+        sort_key = {
+            SortMode.MODIFIED: lambda x: x.stat().st_mtime,
+            SortMode.MODIFIED_REVERSE: lambda x: x.stat().st_mtime,
+            SortMode.NAME: lambda x: x.name,
+            SortMode.NAME_REVERSE: lambda x: x.name,
+        }.get(sort_mode)
+        if sort_key:
+            reverse = sort_mode in (SortMode.MODIFIED, SortMode.NAME_REVERSE)
+            entries = sorted(entries, key=sort_key, reverse=reverse)
+
+    imgs = {
+        img.name: (
+            f"/mtb/view?filename={img.name}&width=512&type={mode}&subfolder="
+            f"{img.parent.relative_to(entry_dir) if include_subfolders else ''}"
+            f"&preview=&rand={secrets.randbelow(424242)}"
+        )
+        for i, img in enumerate(entries)
+        if offset <= i < offset + count
+    }
+    return imgs
+
+
+def ACTIONS_getStyles(style_name=None):
+    from .nodes.conditions import MTB_StylesLoader
+
+    styles = MTB_StylesLoader.options
+    match_list = ["name"]
+    if styles:
+        filtered_styles = {
+            key: value
+            for key, value in styles.items()
+            if not key.startswith("__") and key not in match_list
+        }
+        if style_name:
+            return filtered_styles.get(
+                style_name, {"error": "Style not found"}
+            )
+        return filtered_styles
+    return {"error": "No styles found"}
+
+
+def ACTIONS_saveStyle(data):
+    # endlog.debug(f"Received Save Styles for {data.keys()}")
+    # endlog.debug(data)
+
+    styles = [f.name for f in styles_dir.iterdir() if f.suffix == ".csv"]
+    target = None
+    rows = []
+    for fp, content in data.items():
+        if fp in styles:
+            endlog.debug(f"Overwriting {fp}")
+            target = styles_dir / fp
+            rows = content
+            break
+
+    if not target:
+        endlog.warning(
+            f"Could not determine the target file for {data.keys()}"
+        )
+        return {"error": "Could not determine the target file for the style"}
+
+    backup_file(target)
+
+    with target.open("w", newline="", encoding="utf-8") as file:
+        csv_writer = csv.writer(file, quoting=csv.QUOTE_ALL)
+        for row in rows:
+            csv_writer.writerow(row)
+
+
+async def do_action(request: web.Request) -> web.Response:
+    endlog.debug("Init action request")
+    request_data = await request.json()
+    name = request_data.get("name")
+    args = request_data.get("args")
+
+    endlog.debug(f"Received action request: {name} {args}")
+
+    method_name = f"ACTIONS_{name}"
+    method = globals().get(method_name)
+
+    if callable(method):
+        result = None
+        if args:
+            result = method(*args) if isinstance(args, list) else method(args)
+        else:
+            result = method()
+
+        endlog.debug(f"Action result: {result}")
+        return web.json_response({"result": result})
+
+    available_methods = [
+        attr[len("ACTIONS_") :]
+        for attr in globals()
+        if attr.startswith("ACTIONS_")
+    ]
+
+    return web.json_response(
+        {
+            "error": "Invalid method name.",
+            "available_methods": available_methods,
+        }
+    )
+
+
+# - HTML UTILS
+
+
+def dependencies_button(name: str, dependencies: list[str]) -> str:
+    deps = ",".join([f"'{x}'" for x in dependencies])
+    return f"""
+        <button
+            class="dependency-button"
+            onclick="window.mtb_action('installDependency',[{deps}])"
+        >Install {name} deps</button>
+        """
+
+
+def csv_editor():
+    inputs = [f for f in styles_dir.iterdir() if f.suffix == ".csv"]
+    # rows = {f.stem: list(csv.reader(f.read_text("utf8"))) for f in styles}
+
+    style_files = {}
+    for file in inputs:
+        with open(file, encoding="utf8") as f:
+            parsed = csv.reader(f)
+            style_files[file.name] = []
+            for row in parsed:
+                endlog.debug(f"Adding style {row[0]}")
+                style_files[file.name].append((row[0], row[1], row[2]))
+
+    html_out = """
+            <div id="style-editor">
+             <h1>Style Editor</h1>
+
+            """
+    for current, styles in style_files.items():
+        current_out = f"<h3>{current}</h3>"
+        table_rows = []
+        for index, style in enumerate(styles):
+            table_rows += (
+                (["<tr>"] + [f"<th>{cell}</th>" for cell in style] + ["</tr>"])
+                if index == 0
+                else (
+                    ["<tr>"]
+                    + [
+                        f"<td><input type='text' value='{cell}'></td>"
+                        if i == 0
+                        else f"<td><textarea name='Text1' cols='40' rows='5'>{cell}</textarea></td>"
+                        for i, cell in enumerate(style)
+                    ]
+                    + ["</tr>"]
+                )
+            )
+        current_out += (
+            f"<table data-id='{current}' data-filename='{current}'>"
+            + "".join(table_rows)
+            + "</table>"
+        )
+        current_out += f"<button data-id='{current}' onclick='saveTableData(this.getAttribute(\"data-id\"))'>Save {current}</button>"
+
+        html_out += add_foldable_region(current, current_out)
+
+    html_out += "</div>"
+    html_out += """<script src='/mtb-assets/js/saveTableData.js'></script>"""
+
+    return html_out
+
+
+def render_tab_view(**kwargs):
+    tab_headers = []
+    tab_contents = []
+
+    for idx, (tab_name, content) in enumerate(kwargs.items()):
+        active_class = "active" if idx == 0 else ""
+        tab_headers.append(
+            f"<button class='tablinks {active_class}' onclick=\"openTab(event, '{tab_name}')\">{tab_name}</button>"
+        )
+        tab_contents.append(
+            f"<div id='{tab_name}' class='tabcontent {active_class}'>{content}</div>"
+        )
+
+    headers_str = "\n".join(tab_headers)
+    contents_str = "\n".join(tab_contents)
+
+    return f"""
+<div class='tab-container'>
+    <div class='tab'>
+        {headers_str}
+    </div>
+    {contents_str}
+    </div>
+    <script src='/mtb-assets/js/tabSwitch.js'></script>
+    """
+
+
+def add_foldable_region(title: str, content: str):
+    symbol_id = f"{title}-symbol"
+    return f"""
+    <div class='foldable'>
+        <div
+            class='foldable-title'
+            onclick="toggleFoldable('{title}', '{symbol_id}')"
+        >
+            <span id='{symbol_id}' class='foldable-symbol'>&#9655;</span>
+            {title}
+        </div>
+        <div id='{title}' class='foldable-content'>
+            {content}
+        </div>
+    </div>
+    <script src='/mtb-assets/js/foldable.js'></script>
+    """
+
+
+def add_split_pane(
+    left_content: str, right_content: str, *, vertical: bool = True
+):
+    orientation = "vertical" if vertical else "horizontal"
+    return f"""
+    <div class="split-pane {orientation}">
+        <div id="leftPane">
+            {left_content}
+        </div>
+        <div id="resizer"></div>
+        <div id="rightPane">
+            {right_content}
+        </div>
+    </div>
+    <script>
+        initSplitPane({str(vertical).lower()});
+    </script>
+    <script src='/mtb-assets/js/splitPane.js'></script>
+    """
+
+
+def add_dropdown(title, options):
+    option_str = "\n".join(
+        [f"<option value='{opt}'>{opt}</option>" for opt in options]
+    )
+    return f"""
+    <select>
+        <option disabled selected>{title}</option>
+        {option_str}
+    </select>
+    """
+
+
+def render_table(table_dict: dict[str, Any], sort=True, title=None):
+    table_list = sorted(
+        table_dict.items(), key=lambda item: item[0]
+    )  # Sort the dictionary by keys
+
+    table_rows = ""
+    for name, item in table_list:
+        if isinstance(item, dict):
+            if "dependencies" in item:
+                table_rows += f"<tr><td>{name}</td><td>"
+                table_rows += (
+                    f"{dependencies_button(name,item['dependencies'])}"
+                )
+
+                table_rows += "</td></tr>"
+            else:
+                table_rows += (
+                    f"<tr><td>{name}</td><td>{render_table(item)}</td></tr>"
+                )
+        # elif isinstance(item, str):
+        #     table_rows += f"<tr><td>{name}</td><td>{item}</td></tr>"
+        else:
+            table_rows += f"<tr><td>{name}</td><td>{item}</td></tr>"
+
+    return f"""
+        <div class="table-container">
+        {"" if title is None else f"<h1>{title}</h1>"}
+        <table>
+            <thead>
+                <tr>
+                    <th>Name</th>
+                    <th>Description</th>
+                </tr>
+            </thead>
+            <tbody>
+                {table_rows}
+            </tbody>
+        </table>
+        </div>
+        """
+
+
+def render_base_template(title: str, content: str):
+    github_icon_svg = """<svg xmlns="http://www.w3.org/2000/svg" fill="whitesmoke" height="3em" viewBox="0 0 496 512"><path d="M165.9 397.4c0 2-2.3 3.6-5.2 3.6-3.3.3-5.6-1.3-5.6-3.6 0-2 2.3-3.6 5.2-3.6 3-.3 5.6 1.3 5.6 3.6zm-31.1-4.5c-.7 2 1.3 4.3 4.3 4.9 2.6 1 5.6 0 6.2-2s-1.3-4.3-4.3-5.2c-2.6-.7-5.5.3-6.2 2.3zm44.2-1.7c-2.9.7-4.9 2.6-4.6 4.9.3 2 2.9 3.3 5.9 2.6 2.9-.7 4.9-2.6 4.6-4.6-.3-1.9-3-3.2-5.9-2.9zM244.8 8C106.1 8 0 113.3 0 252c0 110.9 69.8 205.8 169.5 239.2 12.8 2.3 17.3-5.6 17.3-12.1 0-6.2-.3-40.4-.3-61.4 0 0-70 15-84.7-29.8 0 0-11.4-29.1-27.8-36.6 0 0-22.9-15.7 1.6-15.4 0 0 24.9 2 38.6 25.8 21.9 38.6 58.6 27.5 72.9 20.9 2.3-16 8.8-27.1 16-33.7-55.9-6.2-112.3-14.3-112.3-110.5 0-27.5 7.6-41.3 23.6-58.9-2.6-6.5-11.1-33.3 2.6-67.9 20.9-6.5 69 27 69 27 20-5.6 41.5-8.5 62.8-8.5s42.8 2.9 62.8 8.5c0 0 48.1-33.6 69-27 13.7 34.7 5.2 61.4 2.6 67.9 16 17.7 25.8 31.5 25.8 58.9 0 96.5-58.9 104.2-114.8 110.5 9.2 7.9 17 22.9 17 46.4 0 33.7-.3 75.4-.3 83.6 0 6.5 4.6 14.4 17.3 12.1C428.2 457.8 496 362.9 496 252 496 113.3 383.5 8 244.8 8zM97.2 352.9c-1.3 1-1 3.3.7 5.2 1.6 1.6 3.9 2.3 5.2 1 1.3-1 1-3.3-.7-5.2-1.6-1.6-3.9-2.3-5.2-1zm-10.8-8.1c-.7 1.3.3 2.9 2.3 3.9 1.6 1 3.6.7 4.3-.7.7-1.3-.3-2.9-2.3-3.9-2-.6-3.6-.3-4.3.7zm32.4 35.6c-1.6 1.3-1 4.3 1.3 6.2 2.3 2.3 5.2 2.6 6.5 1 1.3-1.3.7-4.3-1.3-6.2-2.2-2.3-5.2-2.6-6.5-1zm-11.4-14.7c-1.6 1-1.6 3.6 0 5.9 1.6 2.3 4.3 3.3 5.6 2.3 1.6-1.3 1.6-3.9 0-6.2-1.4-2.3-4-3.3-5.6-2z"/></svg>"""
+    return f"""
+    <!DOCTYPE html>
+    <html>
+    <head>
+        <title>{title}</title>
+        <link rel="stylesheet" href="/mtb-assets/style.css"/>
+    </head>
+    <script type="module">
+        import {{ api }} from '/scripts/api.js'
+        const mtb_action = async (action, args) =>{{
+            console.log(`Sending ${{action}} with args: ${{args}}`)
+            }}
+        window.mtb_action = async (action, args) =>{{
+            console.log(`Sending ${{action}} with args: ${{args}} to the API`)
+            const res = await api.fetchApi('/actions', {{
+                method: 'POST',
+                body: JSON.stringify({{
+                  name: action,
+                  args,
+                }}),
+            }})
+
+              const output = await res.json()
+              console.debug(`Received ${{action}} response:`, output)
+              if (output?.result?.error){{
+                  alert(`An error occured: {{output?.result?.error}}`)
+              }}
+              return output?.result
+        }}
+    </script>
+    <body>
+        <header>
+        <a href="/">Back to Comfy</a>
+        <div class="mtb_logo">
+            <img
+                src="https://repository-images.githubusercontent.com/649047066/a3eef9a7-20dd-4ef9-b839-884502d4e873"
+                alt="Comfy MTB Logo" height="70" width="128">
+            <span class="title">Comfy MTB</span></div>
+            <a style="width:128px;text-align:center" href="https://www.github.com/melmass/comfy_mtb">
+                {github_icon_svg}
+            </a>
+        </header>
+
+        <main>
+            {content}
+        </main>
+
+        <footer>
+            <!-- Shared footer content here -->
+        </footer>
+    </body>
+
+    </html>
+    """

env.nu

@@ -0,0 +1,247 @@
+# NOTE: This file is only use for development you can ignore it
+
+
+# NOTE: for CI it's easier to extract parts of my cli for now
+
+const THREE_VERSION = "0.171.0"
+# Update the external web extensions
+export def "comfy mtb update-web" [] {
+
+  let async_dir = $"($env.COMFY_MTB)/web_async"
+  let three_base = $"https://cdn.jsdelivr.net/npm/three@($THREE_VERSION)"
+  let three = {
+    "." : [
+      "build/three.module.js",
+      "build/three.core.js",
+    ],
+    three_addons/capabilities: [
+      "examples/jsm/capabilities/WebGPU.js",
+      "examples/jsm/controls/ArcballControls.js",
+      "examples/jsm/controls/DragControls.js",
+      "examples/jsm/controls/FirstPersonControls.js",
+      "examples/jsm/controls/FlyControls.js",
+      "examples/jsm/controls/MapControls.js",
+      "examples/jsm/controls/OrbitControls.js",
+      "examples/jsm/controls/PointerLockControls.js",
+      "examples/jsm/controls/TrackballControls.js",
+      "examples/jsm/controls/TransformControls.js",
+    ],
+    three_addons/offscreen: [
+      "jank.js",
+      "offscreen.js",
+      "scene.js",
+    ],
+    thee_addons/exporters : [
+      "examples/jsm/exporters/DRACOExporter.js",
+      "examples/jsm/exporters/EXRExporter.js",
+      "examples/jsm/exporters/GLTFExporter.js",
+      "examples/jsm/exporters/KTX2Exporter.js",
+      "examples/jsm/exporters/MMDExporter.js",
+      "examples/jsm/exporters/OBJExporter.js",
+      "examples/jsm/exporters/PLYExporter.js",
+      "examples/jsm/exporters/STLExporter.js",
+      "examples/jsm/exporters/USDZExporter.js"
+    ],
+
+    three_addons/loaders : [
+      "examples/jsm/loaders/3DMLoader.js",
+      "examples/jsm/loaders/BVHLoader.js",
+      "examples/jsm/loaders/ColladaLoader.js",
+      "examples/jsm/loaders/DRACOLoader.js",
+      "examples/jsm/loaders/EXRLoader.js",
+      "examples/jsm/loaders/FBXLoader.js",
+      "examples/jsm/loaders/FontLoader.js",
+      "examples/jsm/loaders/GLTFLoader.js",
+      "examples/jsm/loaders/HDRCubeTextureLoader.js",
+      "examples/jsm/loaders/MaterialXLoader.js",
+      "examples/jsm/loaders/MTLLoader.js",
+      "examples/jsm/loaders/OBJLoader.js",
+      "examples/jsm/loaders/PCDLoader.js",
+      "examples/jsm/loaders/PDBLoader.js",
+      "examples/jsm/loaders/PLYLoader.js",
+      "examples/jsm/loaders/STLLoader.js",
+      "examples/jsm/loaders/UltraHDRLoader.js",
+      "examples/jsm/loaders/USDZLoader.js",
+      "examples/jsm/loaders/VOXLoader.js"
+    ]
+  }
+  $three | items {|root,urls|
+    let dest =  $async_dir | path join $root
+    mkdir $dest
+
+    $urls | par-each {|url|
+      let url = $"($three_base)/($url)"
+      let local = ($dest | path join ($url | path basename))
+      wget -c $url -O ($local)
+    }
+  }
+
+  # $three
+}
+
+
+def get_root [--clean] {
+    if $clean {
+        $env.COMFY_CLEAN_ROOT
+    } else {
+        $env.COMFY_ROOT
+    }
+}
+
+export def "comfy build-web" [] {
+    cd $env.COMFY_MTB
+    cd web_source
+    npm run build
+    cp dist/*.js ../web/dist
+}
+
+export def "comfy dev-web" [] {
+    cd $env.COMFY_MTB
+    cd web_source
+    npm run dev
+}
+
+
+# start the comfy server
+export def "comfy start" [--clean,--old-ui, --listen] {
+
+    let root = get_root --clean=($clean)
+    cd $root
+    MTB_DEBUG=true python main.py --port 3000 ...(if $old_ui { ["--front-end-version", "Comfy-Org/ComfyUI_legacy_frontend@latest"]} else {[ --front-end-version Comfy-Org/ComfyUI_frontend@latest]}) --preview-method auto ...(if $listen {["--listen"]} else {[]})
+}
+
+# update comfy itself and merge master in current branch
+export def "comfy update" [
+    --clean # ??
+    --rebase # Rebase instead of merge
+] {
+    let root = get_root --clean=($clean)
+    let models = $"($root)/models"
+    let inputs = $"($root)/input"
+    cd $root
+    let branch_name = (git rev-parse --abbrev-ref HEAD | str trim)
+    print $"(ansi yellow_italic)Backing up and removing models symlinks(ansi reset)"
+
+    if not $clean {
+        cd $models
+        # find all symlinks
+        let links = (ls -la |
+            where not ($it.target | is-empty) |
+            select name target |
+            sort-by name)
+
+
+            if not ($links | is-empty) {
+              $links | save -f links.nuon
+              # remove them
+              open links.nuon | each {|p| rm $p.name }
+            }
+    } else {
+        rm $models
+        rm $inputs
+    }
+
+    cd $root
+
+    print $"(ansi yellow_italic)Checking out to master(ansi reset)"
+    git checkout master
+
+    print $"(ansi yellow_italic)Fetching and pulling remote updates(ansi reset)"
+    if ($clean) {
+        git fetch local master
+        git pull local master
+    } else {
+        git fetch
+        git pull
+    }
+
+
+    print $"(ansi yellow_italic)Back to our branch \(($branch_name)\)(ansi reset)"
+    git checkout -
+
+    if $rebase {
+        print $"(ansi yellow_italic)Rebasing changes(ansi reset)"
+        git rebase master
+
+    } else {
+        print $"(ansi yellow_italic)Merging changes(ansi reset)"
+        git merge master
+    }
+
+    print $"(ansi yellow_italic)Linking back the models(ansi reset)"
+
+    if not $clean {
+        cd $models
+        # resymlink them
+        open links.nuon | each {|p| link -a $p.target $p.name }
+    } else {
+        let master = (get_root)
+        link ($master | path join models) $models
+        link ($master | path join input) $inputs
+    }
+
+    let commit_count = (git rev-list --count $branch_name $"^origin/($branch_name)")
+
+
+    print $"(ansi green_bold)Update successful \(($commit_count) new commits\)(ansi reset)"
+
+
+}
+
+export def "comfy toggle_extensions" [--clean] {
+    let root = get_root --clean=($clean)
+    cd $root
+    cd custom_nodes
+    let exts = (ls | where type in ["dir","symlink"] | get name)
+    let choices = ($exts | input list -m "choose extension to toggle")
+    if ($choices | is-empty) {
+        return
+    }
+
+    print $choices
+
+    let filtered = $choices | wrap name | upsert enabled {|p| not ($p.name | str ends-with ".disabled")}
+
+    print $filtered
+    $filtered | each {|f|
+        let new_name = ($f.name | str replace ".disabled" "")
+
+        let new_name = if $f.enabled {
+            $"($new_name).disabled"
+        } else {
+            $new_name
+        }
+        print $"Moving ($f.name) to ($new_name)"
+        mv $f.name $new_name
+    }
+}
+
+# git pull all extensions
+export def "comfy update_extensions" [--clean] {
+    let root = get_root --clean=($clean)
+    cd $root
+    cd custom_nodes
+    git multipull . -s -q
+}
+
+def --env path-add [pth] {
+    $env.PATH = ($env.PATH | append ($pth | path expand))
+
+}
+
+
+export-env {
+  $env.COMFY_MTB = ("." | path expand | str replace -a '\' '/')
+  # $env.CUDA_ROOT =  'C:\Program Files\NVIDIA GPU Computing Toolkit\CUDA\v12.1\'
+
+  $env.CUDA_HOME = $env.CUDA_ROOT
+
+  $env.COMFY_ROOT = ("../.." | path expand)
+  $env.COMFY_CLEAN_ROOT =  ($env.COMFY_ROOT | path dirname | path join ComfyClean)
+
+  path-add 'C:/Portable/TensorRT-8.6.0.12/lib'
+  path-add ($env.CUDA_ROOT | path join bin)
+  overlay use ../../.venv/Scripts/activate.nu
+}
+
+

errors.py

@@ -0,0 +1,7 @@
+class ModelNotFound(Exception):
+    def __init__(self, model_name, *args, **kwargs):
+        super().__init__(
+            f"The model {model_name} could not be found, make sure to download it using ComfyManager first.\nrepository: https://github.com/ltdrdata/ComfyUI-Manager",
+            *args,
+            **kwargs,
+        )

examples/05-seamless_texture.json

@@ -0,0 +1,905 @@
+{
+  "last_node_id": 97,
+  "last_link_id": 179,
+  "nodes": [
+    {
+      "id": 6,
+      "type": "CLIPTextEncode",
+      "pos": [
+        -1165.8749246009997,
+        30
+      ],
+      "size": [
+        422.84503173828125,
+        164.31304931640625
+      ],
+      "flags": {},
+      "order": 4,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "clip",
+          "type": "CLIP",
+          "link": 3
+        }
+      ],
+      "outputs": [
+        {
+          "name": "CONDITIONING",
+          "type": "CONDITIONING",
+          "links": [
+            4,
+            158
+          ],
+          "slot_index": 0
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "CLIPTextEncode"
+      },
+      "widgets_values": [
+        "Closeup texture of rocks"
+      ],
+      "color": "#432",
+      "bgcolor": "#653",
+      "shape": 1
+    },
+    {
+      "id": 7,
+      "type": "CLIPTextEncode",
+      "pos": [
+        -1175.8749246009997,
+        250
+      ],
+      "size": [
+        425.27801513671875,
+        180.6060791015625
+      ],
+      "flags": {},
+      "order": 5,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "clip",
+          "type": "CLIP",
+          "link": 5
+        }
+      ],
+      "outputs": [
+        {
+          "name": "CONDITIONING",
+          "type": "CONDITIONING",
+          "links": [
+            6
+          ],
+          "slot_index": 0
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "CLIPTextEncode"
+      },
+      "widgets_values": [
+        "((drawing, cartoon, painting, sketch, blur, depth of field, dof))"
+      ],
+      "color": "#432",
+      "bgcolor": "#653",
+      "shape": 1
+    },
+    {
+      "id": 89,
+      "type": "Reroute",
+      "pos": [
+        350,
+        803
+      ],
+      "size": [
+        75,
+        26
+      ],
+      "flags": {},
+      "order": 9,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "",
+          "type": "*",
+          "link": 176
+        }
+      ],
+      "outputs": [
+        {
+          "name": "",
+          "type": "IMAGE",
+          "links": [
+            167
+          ]
+        }
+      ],
+      "properties": {
+        "showOutputText": false,
+        "horizontal": false
+      }
+    },
+    {
+      "id": 4,
+      "type": "CheckpointLoaderSimple",
+      "pos": [
+        -1740,
+        236
+      ],
+      "size": [
+        315,
+        98
+      ],
+      "flags": {},
+      "order": 0,
+      "mode": 0,
+      "outputs": [
+        {
+          "name": "MODEL",
+          "type": "MODEL",
+          "links": [
+            170
+          ],
+          "slot_index": 0
+        },
+        {
+          "name": "CLIP",
+          "type": "CLIP",
+          "links": [
+            3,
+            5
+          ],
+          "slot_index": 1
+        },
+        {
+          "name": "VAE",
+          "type": "VAE",
+          "links": [],
+          "slot_index": 2
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "CheckpointLoaderSimple"
+      },
+      "widgets_values": [
+        "revAnimated_v122.safetensors"
+      ],
+      "shape": 1
+    },
+    {
+      "id": 63,
+      "type": "SaveImage",
+      "pos": [
+        1315,
+        18
+      ],
+      "size": [
+        539.2050170898438,
+        617.2159423828125
+      ],
+      "flags": {},
+      "order": 13,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "images",
+          "type": "IMAGE",
+          "link": 115
+        }
+      ],
+      "title": "Normal",
+      "properties": {},
+      "widgets_values": [
+        "Normal"
+      ],
+      "shape": 1
+    },
+    {
+      "id": 67,
+      "type": "SaveImage",
+      "pos": [
+        2095,
+        22
+      ],
+      "size": [
+        539.2050170898438,
+        617.2159423828125
+      ],
+      "flags": {},
+      "order": 16,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "images",
+          "type": "IMAGE",
+          "link": 119
+        }
+      ],
+      "title": "Curvature",
+      "properties": {},
+      "widgets_values": [
+        "Curvature"
+      ],
+      "shape": 1
+    },
+    {
+      "id": 69,
+      "type": "SaveImage",
+      "pos": [
+        1560,
+        1290
+      ],
+      "size": [
+        539.2050170898438,
+        617.2159423828125
+      ],
+      "flags": {},
+      "order": 17,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "images",
+          "type": "IMAGE",
+          "link": 121
+        }
+      ],
+      "title": "Depth",
+      "properties": {},
+      "widgets_values": [
+        "Height"
+      ],
+      "shape": 1
+    },
+    {
+      "id": 91,
+      "type": "Model Patch Seamless (mtb)",
+      "pos": [
+        -1150,
+        -146
+      ],
+      "size": [
+        430.8000183105469,
+        78
+      ],
+      "flags": {},
+      "order": 3,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "model",
+          "type": "MODEL",
+          "link": 170
+        }
+      ],
+      "outputs": [
+        {
+          "name": "Original Model (passthrough)",
+          "type": "MODEL",
+          "links": null,
+          "shape": 3
+        },
+        {
+          "name": "Patched Model",
+          "type": "MODEL",
+          "links": [
+            169
+          ],
+          "shape": 3,
+          "slot_index": 1
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "Model Patch Seamless (mtb)"
+      },
+      "widgets_values": [
+        true
+      ],
+      "color": "#232",
+      "bgcolor": "#353"
+    },
+    {
+      "id": 93,
+      "type": "PreviewImage",
+      "pos": [
+        1115,
+        -597
+      ],
+      "size": [
+        451.3526306152344,
+        478.3444519042969
+      ],
+      "flags": {},
+      "order": 12,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "images",
+          "type": "IMAGE",
+          "link": 179
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "PreviewImage"
+      }
+    },
+    {
+      "id": 43,
+      "type": "VAELoader",
+      "pos": [
+        -598.2757622278747,
+        577.3595309932109
+      ],
+      "size": [
+        387.48089599609375,
+        70.60645294189453
+      ],
+      "flags": {},
+      "order": 1,
+      "mode": 0,
+      "outputs": [
+        {
+          "name": "VAE",
+          "type": "VAE",
+          "links": [
+            174
+          ],
+          "slot_index": 0
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "VAELoader"
+      },
+      "widgets_values": [
+        "vae-ft-mse-840000-ema-pruned.safetensors"
+      ],
+      "shape": 1
+    },
+    {
+      "id": 97,
+      "type": "Image Tile Offset (mtb)",
+      "pos": [
+        617,
+        -598
+      ],
+      "size": [
+        315,
+        58
+      ],
+      "flags": {},
+      "order": 10,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "image",
+          "type": "IMAGE",
+          "link": 178
+        }
+      ],
+      "outputs": [
+        {
+          "name": "IMAGE",
+          "type": "IMAGE",
+          "links": [
+            179
+          ],
+          "shape": 3,
+          "slot_index": 0
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "Image Tile Offset (mtb)"
+      },
+      "widgets_values": [
+        2
+      ],
+      "color": "#232",
+      "bgcolor": "#353"
+    },
+    {
+      "id": 96,
+      "type": "Vae Decode (mtb)",
+      "pos": [
+        -52,
+        40
+      ],
+      "size": [
+        315,
+        126
+      ],
+      "flags": {},
+      "order": 7,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "samples",
+          "type": "LATENT",
+          "link": 173
+        },
+        {
+          "name": "vae",
+          "type": "VAE",
+          "link": 174
+        }
+      ],
+      "outputs": [
+        {
+          "name": "IMAGE",
+          "type": "IMAGE",
+          "links": [
+            175,
+            176,
+            178
+          ],
+          "shape": 3,
+          "slot_index": 0
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "Vae Decode (mtb)"
+      },
+      "widgets_values": [
+        true,
+        false,
+        512
+      ],
+      "color": "#232",
+      "bgcolor": "#353"
+    },
+    {
+      "id": 46,
+      "type": "SaveImage",
+      "pos": [
+        533,
+        25
+      ],
+      "size": [
+        539.2050170898438,
+        617.2159423828125
+      ],
+      "flags": {},
+      "order": 8,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "images",
+          "type": "IMAGE",
+          "link": 175
+        }
+      ],
+      "title": "Albedo",
+      "properties": {},
+      "widgets_values": [
+        "Albedo"
+      ],
+      "shape": 1
+    },
+    {
+      "id": 74,
+      "type": "EmptyLatentImage",
+      "pos": [
+        -1075.8749246009997,
+        480
+      ],
+      "size": [
+        315,
+        106
+      ],
+      "flags": {},
+      "order": 2,
+      "mode": 0,
+      "outputs": [
+        {
+          "name": "LATENT",
+          "type": "LATENT",
+          "links": [
+            132
+          ],
+          "shape": 3,
+          "slot_index": 0
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "EmptyLatentImage"
+      },
+      "widgets_values": [
+        768,
+        768,
+        1
+      ],
+      "color": "#323",
+      "bgcolor": "#535",
+      "shape": 1
+    },
+    {
+      "id": 62,
+      "type": "Deep Bump (mtb)",
+      "pos": [
+        727,
+        801
+      ],
+      "size": [
+        315,
+        130
+      ],
+      "flags": {},
+      "order": 11,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "image",
+          "type": "IMAGE",
+          "link": 167
+        }
+      ],
+      "outputs": [
+        {
+          "name": "IMAGE",
+          "type": "IMAGE",
+          "links": [
+            115,
+            118,
+            122
+          ],
+          "shape": 3,
+          "slot_index": 0
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "Deep Bump (mtb)"
+      },
+      "widgets_values": [
+        "Color to Normals",
+        "SMALL",
+        "SMALLEST",
+        true
+      ],
+      "color": "#232",
+      "bgcolor": "#353",
+      "shape": 1
+    },
+    {
+      "id": 66,
+      "type": "Deep Bump (mtb)",
+      "pos": [
+        1626,
+        808
+      ],
+      "size": [
+        315,
+        130
+      ],
+      "flags": {},
+      "order": 14,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "image",
+          "type": "IMAGE",
+          "link": 118
+        }
+      ],
+      "outputs": [
+        {
+          "name": "IMAGE",
+          "type": "IMAGE",
+          "links": [
+            119
+          ],
+          "shape": 3,
+          "slot_index": 0
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "Deep Bump (mtb)"
+      },
+      "widgets_values": [
+        "Normals to Curvature",
+        "SMALL",
+        "SMALLEST",
+        true
+      ],
+      "color": "#232",
+      "bgcolor": "#353",
+      "shape": 1
+    },
+    {
+      "id": 68,
+      "type": "Deep Bump (mtb)",
+      "pos": [
+        1185,
+        1288
+      ],
+      "size": [
+        315,
+        130
+      ],
+      "flags": {},
+      "order": 15,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "image",
+          "type": "IMAGE",
+          "link": 122
+        }
+      ],
+      "outputs": [
+        {
+          "name": "IMAGE",
+          "type": "IMAGE",
+          "links": [
+            121
+          ],
+          "shape": 3,
+          "slot_index": 0
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "Deep Bump (mtb)"
+      },
+      "widgets_values": [
+        "Normals to Height",
+        "SMALL",
+        "SMALLEST",
+        true
+      ],
+      "color": "#232",
+      "bgcolor": "#353",
+      "shape": 1
+    },
+    {
+      "id": 3,
+      "type": "KSampler",
+      "pos": [
+        -518.2757622278748,
+        47.359530993211024
+      ],
+      "size": [
+        315,
+        474
+      ],
+      "flags": {},
+      "order": 6,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "model",
+          "type": "MODEL",
+          "link": 169
+        },
+        {
+          "name": "positive",
+          "type": "CONDITIONING",
+          "link": 4
+        },
+        {
+          "name": "negative",
+          "type": "CONDITIONING",
+          "link": 6
+        },
+        {
+          "name": "latent_image",
+          "type": "LATENT",
+          "link": 132
+        }
+      ],
+      "outputs": [
+        {
+          "name": "LATENT",
+          "type": "LATENT",
+          "links": [
+            173
+          ],
+          "slot_index": 0
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "KSampler"
+      },
+      "widgets_values": [
+        1001,
+        "fixed",
+        28,
+        8,
+        "dpmpp_2m",
+        "normal",
+        1
+      ],
+      "color": "#222",
+      "bgcolor": "#000",
+      "shape": 1
+    }
+  ],
+  "links": [
+    [
+      3,
+      4,
+      1,
+      6,
+      0,
+      "CLIP"
+    ],
+    [
+      4,
+      6,
+      0,
+      3,
+      1,
+      "CONDITIONING"
+    ],
+    [
+      5,
+      4,
+      1,
+      7,
+      0,
+      "CLIP"
+    ],
+    [
+      6,
+      7,
+      0,
+      3,
+      2,
+      "CONDITIONING"
+    ],
+    [
+      115,
+      62,
+      0,
+      63,
+      0,
+      "IMAGE"
+    ],
+    [
+      118,
+      62,
+      0,
+      66,
+      0,
+      "IMAGE"
+    ],
+    [
+      119,
+      66,
+      0,
+      67,
+      0,
+      "IMAGE"
+    ],
+    [
+      121,
+      68,
+      0,
+      69,
+      0,
+      "IMAGE"
+    ],
+    [
+      122,
+      62,
+      0,
+      68,
+      0,
+      "IMAGE"
+    ],
+    [
+      132,
+      74,
+      0,
+      3,
+      3,
+      "LATENT"
+    ],
+    [
+      158,
+      6,
+      0,
+      86,
+      0,
+      "*"
+    ],
+    [
+      167,
+      89,
+      0,
+      62,
+      0,
+      "IMAGE"
+    ],
+    [
+      169,
+      91,
+      1,
+      3,
+      0,
+      "MODEL"
+    ],
+    [
+      170,
+      4,
+      0,
+      91,
+      0,
+      "MODEL"
+    ],
+    [
+      173,
+      3,
+      0,
+      96,
+      0,
+      "LATENT"
+    ],
+    [
+      174,
+      43,
+      0,
+      96,
+      1,
+      "VAE"
+    ],
+    [
+      175,
+      96,
+      0,
+      46,
+      0,
+      "IMAGE"
+    ],
+    [
+      176,
+      96,
+      0,
+      89,
+      0,
+      "*"
+    ],
+    [
+      178,
+      96,
+      0,
+      97,
+      0,
+      "IMAGE"
+    ],
+    [
+      179,
+      97,
+      0,
+      93,
+      0,
+      "IMAGE"
+    ]
+  ],
+  "groups": [
+    {
+      "title": "Seamless Diffusion",
+      "bounding": [
+        -1752,
+        -392,
+        1658,
+        1102
+      ],
+      "color": "#3f789e",
+      "font_size": 76,
+      "locked": false
+    },
+    {
+      "title": "Seamless Check",
+      "bounding": [
+        421,
+        -795,
+        1374,
+        763
+      ],
+      "color": "#3f789e",
+      "font_size": 76,
+      "locked": false
+    }
+  ],
+  "config": {},
+  "extra": {},
+  "version": 0.4
+}

examples/08-note-plus.json

@@ -0,0 +1 @@
+{"last_node_id":9,"last_link_id":0,"nodes":[{"id":9,"type":"Note Plus (mtb)","pos":[332, 139, 0, 0, 0, 0, 0, 0, 0, 0],"size":[573.4446126650389, 1292.5298919072263],"flags":{},"order":0,"mode":0,"inputs":[],"outputs":[],"title":"Note+ (mtb)","properties":{},"widgets_values":["# Note+ Demo\n\n# Images \nyou can resize them (see showdown syntax)\n\n![Minion](https://octodex.github.com/images/minion.png =120x*)\n\n# iFrame (embeds)\n<iframe src=\"https://www.youtube.com/embed/tgbNymZ7vqY\">\n</iframe>\n\n# Headings\n\n# h1 Heading:smile:\n\n## h2 Heading\n\n### h3 Heading\n\n#### h4 Heading\n\n##### h5 Heading\n\n###### h6 Heading\n\n# Tables\n\nColons can be used to align columns.\n\n| Tables|Are|Cool |\n| ------------- |:-----------:| ----:|\n| col 3 is| right-aligned | $1600 |\n| col 2 is| centered| $12 |\n| zebra stripes | are neat|$1 |\n\nEmphasis, aka italics, with _asterisks_ or _underscores_.\n\nStrong emphasis, aka bold, with **asterisks** or **underscores**.\n\nCombined emphasis with **asterisks and _underscores_**.\n\nStrikethrough uses two tildes. ~~Scratch this.~~\n\n**This is bold text**\n\n**This is bold text**\n\n_This is italic text_\n\n_This is italic text_\n\n~~Strikethrough~~\n\n1. First ordered list item\n2. Another item\n\n- Unordered sub-list.\n\n1. Actual numbers don't matter, just that it's a number\n1. Ordered sub-list\n1. And another item.\n1.\n\n- [x] Finish my changes\n- [] Push my commits to GitHub\n- [] Open a pull request\n- [x] mentions:@melmass, #refs, [links](), **formatting**, and <del>tags</del> supported\n- [x] list syntax required (any unordered or ordered list supported)\n- [x] this is a complete item\n- [] this is an incomplete item\n","markdown","*{\ncolor:whitesmoke;\n}\n\nh1{\ncolor:cyan;\n}\nh2{\ncolor:yellow;\n}\nh3{\ncolor:pink;\n}\n\nstrong{\ncolor:red;\n}"],"color":"#223","bgcolor":"#335","shape":1}],"links":[],"groups":[],"config":{},"extra":{},"version":0.4}

examples/README.md

@@ -0,0 +1,12 @@
+# Examples
+All the examples use the [RevAnimated model 1.22](https://civitai.com/models/7371?modelVersionId=46846)
+## 01 Faceswap
+
+This example showcase the `Face Swap` & `Restore Face` nodes to replace the character with Georges Lucas's face.
+The face reference image is using the `Load Image From Url` node to avoid bundling input images.
+
+<img src="https://github.com/melMass/comfy_mtb/assets/7041726/272af7d6-f01c-478e-a82f-926e772d7209" width=500/>
+
+## 02 FILM interpolation
+This example showcase the FILM interpolation implementation. Here we do text replacement on the condition of two distinct images sharing the same model, input latent & seed to get relatively close images.  
+<img src="https://github.com/melMass/comfy_mtb/assets/7041726/4c28dd87-89fc-4d27-910a-0a1fcf28cdc0" width=500/>

html/js/foldable.js

@@ -0,0 +1,20 @@
+/**
+ * File: foldable.js
+ * Project: comfy_mtb
+ * Author: Mel Massadian
+ *
+ * Copyright (c) 2023 Mel Massadian
+ *
+ */
+
+function toggleFoldable(elementId, symbolId) {
+  const content = document.getElementById(elementId)
+  const symbol = document.getElementById(symbolId)
+  if (content.style.display === 'none' || content.style.display === '') {
+    content.style.display = 'flex'
+    symbol.innerHTML = '▽' // Down arrow
+  } else {
+    content.style.display = 'none'
+    symbol.innerHTML = '▷' // Right arrow
+  }
+}

html/js/saveTableData.js

@@ -0,0 +1,54 @@
+/**
+ * File: saveTableData.js
+ * Project: comfy_mtb
+ * Author: Mel Massadian
+ *
+ * Copyright (c) 2023 Mel Massadian
+ *
+ */
+
+function saveTableData(identifier) {
+  const table = document.querySelector(
+    `#style-editor table[data-id='${identifier}']`
+  )
+
+  let currentData = []
+  const rows = table.querySelectorAll('tr')
+  const filename = table.getAttribute('data-id')
+
+  rows.forEach((row, rowIndex) => {
+    const rowData = []
+    const cells =
+      rowIndex === 0
+        ? row.querySelectorAll('th')
+        : row.querySelectorAll('td input, td textarea')
+
+    cells.forEach((cell) => {
+      rowData.push(rowIndex === 0 ? cell.textContent : cell.value)
+    })
+
+    currentData.push(rowData)
+  })
+
+  let tablesData = {}
+  tablesData[filename] = currentData
+
+  console.debug('Sending styles to manage endpoint:', tablesData)
+  fetch('/mtb/actions', {
+    method: 'POST',
+    headers: {
+      'Content-Type': 'application/json',
+    },
+    body: JSON.stringify({
+      name: 'saveStyle',
+      args: tablesData,
+    }),
+  })
+    .then((response) => response.json())
+    .then((data) => {
+      console.debug('Success:', data)
+    })
+    .catch((error) => {
+      console.error('Error:', error)
+    })
+}

html/js/splitPane.js

@@ -0,0 +1,34 @@
+/**
+ * File: splitPane.js
+ * Project: comfy_mtb
+ * Author: Mel Massadian
+ *
+ * Copyright (c) 2023 Mel Massadian
+ *
+ */
+
+function initSplitPane(vertical) {
+  let resizer = document.getElementById('resizer')
+  let left = document.getElementById('leftPane')
+  let right = document.getElementById('rightPane')
+  resizer.addEventListener('mousedown', function (e) {
+    document.addEventListener('mousemove', onMouseMove)
+    document.addEventListener('mouseup', function () {
+      document.removeEventListener('mousemove', onMouseMove)
+    })
+  })
+
+  const onMouseMove = (e) => {
+    if (vertical) {
+      let leftWidth = e.clientX
+      let rightWidth = window.innerWidth - e.clientX
+      left.style.width = leftWidth + 'px'
+      right.style.width = rightWidth + 'px'
+    } else {
+      let topHeight = e.clientY
+      let bottomHeight = window.innerHeight - e.clientY
+      left.style.height = topHeight + 'px'
+      right.style.height = bottomHeight + 'px'
+    }
+  }
+}

html/js/tabSwitch.js

@@ -0,0 +1,22 @@
+/**
+ * File: tabSwitch.js
+ * Project: comfy_mtb
+ * Author: Mel Massadian
+ *
+ * Copyright (c) 2023 Mel Massadian
+ *
+ */
+
+function openTab(evt, tabName) {
+  var i, tabcontent, tablinks
+  tabcontent = document.getElementsByClassName('tabcontent')
+  for (i = 0; i < tabcontent.length; i++) {
+    tabcontent[i].style.display = 'none'
+  }
+  tablinks = document.getElementsByClassName('tablinks')
+  for (i = 0; i < tablinks.length; i++) {
+    tablinks[i].className = tablinks[i].className.replace(' active', '')
+  }
+  document.getElementById(tabName).style.display = 'block'
+  evt.currentTarget.className += ' active'
+}

html/style.css

@@ -0,0 +1,228 @@
+html {
+    height: 100%;
+    margin: 0;
+    padding: 0;
+    background-color: rgb(33, 33, 33);
+    color: whitesmoke;
+}
+
+a {
+    color: whitesmoke;
+
+}
+
+.table-container {
+    width: 70%;
+    height: 100%;
+    overflow: auto;
+}
+
+table {
+    width: 100%;
+    border-collapse: collapse;
+}
+
+th,
+td {
+    padding: 10px;
+    text-align: left;
+}
+
+th {
+    background-color: rgb(45, 45, 45);
+    /* Light gray background for header row */
+    font-weight: bold;
+}
+
+tr:nth-child(even) {
+    background-color: rgb(45, 45, 45);
+    /* Alternate row background color */
+}
+
+tr:hover {
+    background-color: #797979;
+    /* Highlight color on hover */
+}
+
+td:nth-child(2) {
+    /* Applies to the second column (Description) */
+    width: 80%;
+    /* Adjust the width as needed */
+    word-wrap: break-word;
+    /* Allow long words to be broken and wrapped to the next line */
+}
+
+.mtb_logo {
+    display: flex;
+    flex-direction: column;
+    align-items: center;
+}
+
+/* Styling for WebKit-based browsers (Chrome, Edge) */
+.table-container::-webkit-scrollbar {
+    width: 10px;
+    /* Set the width of the scrollbar */
+}
+
+.table-container::-webkit-scrollbar-thumb {
+    background-color: #797979;
+    /* Color of the scrollbar thumb */
+}
+
+/* Styling for Firefox */
+.table-container {
+    scrollbar-width: thin;
+    /* Set the width of the scrollbar */
+}
+
+.table-container::-webkit-scrollbar-thumb {
+    background-color: #797979;
+    /* Color of the scrollbar thumb */
+}
+
+/* Optionally, you can also style the scrollbar track (background) */
+.table-container::-webkit-scrollbar-track {
+    background-color: #f2f2f2;
+}
+
+
+
+body {
+    margin: 0;
+    padding: 0;
+    font-family: monospace;
+    height: 100%;
+    background-color: rgb(33, 33, 33);
+
+}
+
+.title {
+    font-size: 2.5em;
+    font-weight: 700;
+
+}
+
+header {
+    display: flex;
+    align-items: center;
+    vertical-align: middle;
+    justify-content: space-between;
+    background-color: rgb(12, 12, 12);
+    padding: 1em;
+    margin: 0;
+}
+
+main {
+    display: flex;
+    align-items: center;
+    vertical-align: middle;
+    justify-content: center;
+    padding: 1em;
+    margin: 0;
+    /* height: 80%; */
+}
+
+.flex-container {
+    display: flex;
+    flex-direction: column;
+}
+
+.menu {
+    font-size: 3em;
+    text-align: center;
+}
+
+input, button, textarea {
+    background-color: rgba(0,0,0,0.5);
+    color: white;
+    border: none;
+}
+
+button:hover {
+    background-color: rgba(0,0,0,0.3);
+
+}
+button {
+    padding: 14px 16px;
+
+}
+/* -STYLES EDITOR */
+
+#style-editor {
+    display: flex;
+    flex-direction: column;
+    width:100%;
+    
+}
+
+#style-editor > table {
+    /* background-color: red; */
+    width:100%;
+}
+#style-editor input, #style-editor textarea {
+    /* background-color: blue; */
+    width:100%;
+}
+
+#style-editor td{
+    width: 33.33%;
+}
+
+/* -TABS */
+
+.tab {
+    overflow: hidden;
+    width: 100%;
+    display: flex;
+    flex-direction: row;
+
+}
+
+.tab-container{
+    width: 100%;
+    display: flex;
+    flex-direction: column;
+}
+
+.tab button {
+    background-color: transparent;
+    color:white;
+    float: left;
+    border: none;
+    outline: none;
+    cursor: pointer;
+    padding: 14px 16px;
+    transition: 0.3s;
+    width:100%;
+    font-size: 1.5em;
+}
+
+.tab button.active {
+    background-color: #2e2e2e;
+}
+
+.tabcontent {
+    display: none;
+}
+
+.tabcontent.active {
+    display: block;
+}
+
+
+
+.foldable-title {
+    cursor: pointer;
+    font-weight: bold;
+    user-select: none;
+}
+
+.foldable-symbol {
+    margin-right: 10px;
+}
+
+.foldable-content {
+    display: none;
+    flex-direction: column;
+    margin-left: 20px;
+}

install.py

@@ -0,0 +1,421 @@
+import argparse
+import ast
+import os
+import platform
+import shlex
+import stat
+import subprocess
+import sys
+from contextlib import contextmanager
+from importlib import import_module
+from pathlib import Path
+
+import requests
+
+# region constants
+here = Path(__file__).parent
+executable = Path(sys.executable)
+
+# - detect mode
+mode = None
+if os.environ.get("COLAB_GPU"):
+    mode = "colab"
+elif "python_embeded" in str(executable):
+    mode = "embeded"
+elif ".venv" in str(executable):
+    mode = "venv"
+
+
+if mode is None:
+    mode = "unknown"
+
+repo_url = "https://github.com/melmass/comfy_mtb.git"
+repo_owner = "melmass"
+repo_name = "comfy_mtb"
+short_platform = {
+    "windows": "win_amd64",
+    "linux": "linux_x86_64",
+}
+current_platform = platform.system().lower()
+pip_map = {
+    "onnxruntime-gpu": "onnxruntime",
+    "opencv-contrib": "cv2",
+    "tb-nightly": "tensorboard",
+    "protobuf": "google.protobuf",
+    "qrcode[pil]": "qrcode",
+    "requirements-parser": "requirements"
+    # Add more mappings as needed
+}
+
+# endregion
+
+# region ansi
+# ANSI escape sequences for text styling
+ANSI_FORMATS = {
+    "reset": "\033[0m",
+    "bold": "\033[1m",
+    "dim": "\033[2m",
+    "italic": "\033[3m",
+    "underline": "\033[4m",
+    "blink": "\033[5m",
+    "reverse": "\033[7m",
+    "strike": "\033[9m",
+}
+
+ANSI_COLORS = {
+    "black": "\033[30m",
+    "red": "\033[31m",
+    "green": "\033[32m",
+    "yellow": "\033[33m",
+    "blue": "\033[34m",
+    "magenta": "\033[35m",
+    "cyan": "\033[36m",
+    "white": "\033[37m",
+    "bright_black": "\033[30;1m",
+    "bright_red": "\033[31;1m",
+    "bright_green": "\033[32;1m",
+    "bright_yellow": "\033[33;1m",
+    "bright_blue": "\033[34;1m",
+    "bright_magenta": "\033[35;1m",
+    "bright_cyan": "\033[36;1m",
+    "bright_white": "\033[37;1m",
+    "bg_black": "\033[40m",
+    "bg_red": "\033[41m",
+    "bg_green": "\033[42m",
+    "bg_yellow": "\033[43m",
+    "bg_blue": "\033[44m",
+    "bg_magenta": "\033[45m",
+    "bg_cyan": "\033[46m",
+    "bg_white": "\033[47m",
+    "bg_bright_black": "\033[40;1m",
+    "bg_bright_red": "\033[41;1m",
+    "bg_bright_green": "\033[42;1m",
+    "bg_bright_yellow": "\033[43;1m",
+    "bg_bright_blue": "\033[44;1m",
+    "bg_bright_magenta": "\033[45;1m",
+    "bg_bright_cyan": "\033[46;1m",
+    "bg_bright_white": "\033[47;1m",
+}
+
+
+def apply_format(text, *formats):
+    """Apply ANSI escape sequences for the specified formats to the given text."""
+    formatted_text = text
+    for format in formats:
+        formatted_text = f"{ANSI_FORMATS.get(format, '')}{formatted_text}{ANSI_FORMATS.get('reset', '')}"
+    return formatted_text
+
+
+def apply_color(text, color=None, background=None):
+    """Apply ANSI escape sequences for the specified color and background to the given text."""
+    formatted_text = text
+    if color:
+        formatted_text = f"{ANSI_COLORS.get(color, '')}{formatted_text}{ANSI_FORMATS.get('reset', '')}"
+    if background:
+        formatted_text = f"{ANSI_COLORS.get(background, '')}{formatted_text}{ANSI_FORMATS.get('reset', '')}"
+    return formatted_text
+
+
+def print_formatted(text, *formats, color=None, background=None, **kwargs):
+    """Print the given text with the specified formats, color, and background."""
+    formatted_text = apply_format(text, *formats)
+    formatted_text = apply_color(formatted_text, color, background)
+    file = kwargs.get("file", sys.stdout)
+    header = "[mtb install] "
+
+    # Handle console encoding for Unicode characters (utf-8)
+    encoded_header = header.encode(sys.stdout.encoding, errors="replace").decode(
+        sys.stdout.encoding
+    )
+    encoded_text = formatted_text.encode(sys.stdout.encoding, errors="replace").decode(
+        sys.stdout.encoding
+    )
+
+    print(
+        " " * len(encoded_header)
+        if kwargs.get("no_header")
+        else apply_color(apply_format(encoded_header, "bold"), color="yellow"),
+        encoded_text,
+        file=file,
+    )
+
+
+# endregion
+
+
+# region utils
+def run_command(cmd, ignored_lines_start=None):
+    if ignored_lines_start is None:
+        ignored_lines_start = []
+
+    if isinstance(cmd, str):
+        shell_cmd = cmd
+    elif isinstance(cmd, list):
+        shell_cmd = " ".join(
+            arg.as_posix() if isinstance(arg, Path) else shlex.quote(str(arg))
+            for arg in cmd
+        )
+    else:
+        raise ValueError(
+            "Invalid 'cmd' argument. It must be a string or a list of arguments."
+        )
+
+    try:
+        _run_command(shell_cmd, ignored_lines_start)
+    except subprocess.CalledProcessError as e:
+        print(f"Command failed with return code: {e.returncode}", file=sys.stderr)
+        print(e.stderr.strip(), file=sys.stderr)
+
+    except KeyboardInterrupt:
+        print("Command execution interrupted.")
+
+
+def _run_command(shell_cmd, ignored_lines_start):
+    print_formatted(f"Running {shell_cmd}", "bold")
+    result = subprocess.run(
+        shell_cmd,
+        stdout=subprocess.PIPE,
+        stderr=subprocess.PIPE,
+        text=True,
+        shell=True,
+        check=True,
+    )
+
+    stdout_lines = result.stdout.strip().split("\n")
+    stderr_lines = result.stderr.strip().split("\n")
+
+    # Print stdout, skipping ignored lines
+    for line in stdout_lines:
+        if not any(line.startswith(ign) for ign in ignored_lines_start):
+            print(line)
+
+    # Print stderr
+    for line in stderr_lines:
+        print(line, file=sys.stderr)
+
+    print("Command executed successfully!")
+
+
+def is_pipe():
+    if not sys.stdin.isatty():
+        return False
+    if sys.platform == "win32":
+        try:
+            import msvcrt
+
+            return msvcrt.get_osfhandle(0) != -1
+        except ImportError:
+            return False
+    else:
+        try:
+            mode = os.fstat(0).st_mode
+            return (
+                stat.S_ISFIFO(mode)
+                or stat.S_ISREG(mode)
+                or stat.S_ISBLK(mode)
+                or stat.S_ISSOCK(mode)
+            )
+        except OSError:
+            return False
+
+
+@contextmanager
+def suppress_std():
+    with open(os.devnull, "w") as devnull:
+        old_stdout = sys.stdout
+        old_stderr = sys.stderr
+        sys.stdout = devnull
+        sys.stderr = devnull
+
+        try:
+            yield
+        finally:
+            sys.stdout = old_stdout
+            sys.stderr = old_stderr
+
+
+# Get the version from __init__.py
+def get_local_version():
+    init_file = os.path.join(os.path.dirname(__file__), "__init__.py")
+    if os.path.isfile(init_file):
+        with open(init_file, "r") as f:
+            tree = ast.parse(f.read())
+            for node in ast.walk(tree):
+                if isinstance(node, ast.Assign):
+                    for target in node.targets:
+                        if (
+                            isinstance(target, ast.Name)
+                            and target.id == "__version__"
+                            and isinstance(node.value, ast.Str)
+                        ):
+                            return node.value.s
+    return None
+
+
+def download_file(url, file_name):
+    with requests.get(url, stream=True) as response:
+        response.raise_for_status()
+        total_size = int(response.headers.get("content-length", 0))
+        with open(file_name, "wb") as file, tqdm(
+            desc=file_name.stem,
+            total=total_size,
+            unit="B",
+            unit_scale=True,
+            unit_divisor=1024,
+        ) as progress_bar:
+            for chunk in response.iter_content(chunk_size=8192):
+                file.write(chunk)
+                progress_bar.update(len(chunk))
+
+
+def try_import(requirement):
+    dependency = requirement.name.strip()
+    import_name = pip_map.get(dependency, dependency)
+    installed = False
+
+    pip_name = dependency
+    pip_spec = "".join(specs[0]) if (specs := requirement.specs) else ""
+    try:
+        with suppress_std():
+            import_module(import_name)
+        print_formatted(
+            f"\t✅ Package {pip_name} already installed (import name: '{import_name}').",
+            "bold",
+            color="green",
+            no_header=True,
+        )
+        installed = True
+    except ImportError:
+        print_formatted(
+            f"\t⛔ Package {pip_name} is missing (import name: '{import_name}').",
+            "bold",
+            color="red",
+            no_header=True,
+        )
+
+    return (installed, pip_name, pip_spec, import_name)
+
+
+def import_or_install(requirement, dry=False):
+    installed, pip_name, pip_spec, import_name = try_import(requirement)
+
+    pip_install_name = pip_name + pip_spec
+
+    if not installed:
+        print_formatted(f"Installing package {pip_name}...", "italic", color="yellow")
+        if dry:
+            print_formatted(
+                f"Dry-run: Package {pip_install_name} would be installed (import name: '{import_name}').",
+                color="yellow",
+            )
+        else:
+            try:
+                run_command([executable, "-m", "pip", "install", pip_install_name])
+                print_formatted(
+                    f"Package {pip_install_name} installed successfully using pip package name  (import name: '{import_name}')",
+                    "bold",
+                    color="green",
+                )
+            except subprocess.CalledProcessError as e:
+                print_formatted(
+                    f"Failed to install package {pip_install_name} using pip package name  (import name: '{import_name}'). Error: {str(e)}",
+                    "bold",
+                    color="red",
+                )
+
+
+def get_github_assets(tag=None):
+    if tag:
+        tag_url = (
+            f"https://api.github.com/repos/{repo_owner}/{repo_name}/releases/tags/{tag}"
+        )
+    else:
+        tag_url = (
+            f"https://api.github.com/repos/{repo_owner}/{repo_name}/releases/latest"
+        )
+    response = requests.get(tag_url)
+    if response.status_code == 404:
+        # print_formatted(
+        #     f"Tag version '{apply_color(version,'cyan')}' not found for {owner}/{repo} repository."
+        # )
+        print_formatted("Error retrieving the release assets.", color="red")
+        sys.exit()
+
+    tag_data = response.json()
+    tag_name = tag_data["name"]
+
+    return tag_data, tag_name
+
+
+# endregion
+
+
+try:
+    from tqdm import tqdm
+except ImportError:
+    print_formatted("Installing tqdm...", "italic", color="yellow")
+    run_command([executable, "-m", "pip", "install", "--upgrade", "tqdm"])
+    from tqdm import tqdm
+
+
+def main():
+    if len(sys.argv) == 1:
+        print_formatted(
+            "mtb doesn't need an install script anymore.", "italic", color="yellow"
+        )
+        return
+    if all(arg not in ("-p", "--path") for arg in sys.argv):
+        print(
+            "This script is only used for and edge case of remote installs on some cloud providers, unrecognized arguments:",
+            sys.argv[1:],
+        )
+        return
+
+    # Parse command-line arguments
+    parser = argparse.ArgumentParser(description="Comfy_mtb install script")
+    parser.add_argument(
+        "--path",
+        "-p",
+        type=str,
+        help="Path to clone the repository to (i.e the absolute path to ComfyUI/custom_nodes)",
+    )
+
+    print_formatted("mtb install", "bold", color="yellow")
+
+    args = parser.parse_args()
+
+    print_formatted(f"Detected environment: {apply_color(mode,'cyan')}")
+
+    if args.path:
+        clone_dir = Path(args.path)
+        if not clone_dir.exists():
+            print_formatted(
+                "The path provided does not exist on disk... It must be pointing to ComfyUI's custom_nodes directory"
+            )
+            sys.exit()
+
+        else:
+            repo_dir = clone_dir / repo_name
+            if not repo_dir.exists():
+                print_formatted(f"Cloning to {repo_dir}...", "italic", color="yellow")
+                run_command(["git", "clone", "--recursive", repo_url, repo_dir])
+            else:
+                print_formatted(
+                    f"Directory {repo_dir} already exists, we will update it..."
+                )
+                run_command(["git", "pull", "-C", repo_dir])
+        here = clone_dir
+        full = True
+
+    print_formatted("Checking environment...", "italic", color="yellow")
+    missing_deps = []
+    install_cmd = [executable, "-m", "pip", "install", "-r", "requirements.txt"]
+    run_command(install_cmd)
+
+    print_formatted(
+        "✅ Successfully installed all dependencies.", "italic", color="green"
+    )
+
+
+if __name__ == "__main__":
+    main()

log.py

@@ -1,59 +1,113 @@
 import logging
+import os
 import re
 
+base_log_level = logging.DEBUG if os.environ.get("MTB_DEBUG") else logging.INFO
+
+
+# Custom object that discards the output
+class NullWriter:
+    """Custom object that discards the output."""
+
+    def write(self, text):
+        pass
+
+
+class ConsoleFormatter(logging.Formatter):
+    """Formatter for console based log, using base ansi colors."""
 
-class Formatter(logging.Formatter):
     grey = "\x1b[38;20m"
+    cyan = "\x1b[36;20m"
+    purple = "\x1b[35;20m"
     yellow = "\x1b[33;20m"
     red = "\x1b[31;20m"
     bold_red = "\x1b[31;1m"
     reset = "\x1b[0m"
-    # format = "%(asctime)s - [%(name)s] - %(levelname)s - %(message)s (%(filename)s:%(lineno)d)"
-    format = "[%(name)s] | %(levelname)s -> %(message)s"
+    # format = ("%(asctime)s - [%(name)s] - %(levelname)s "
+    # "- %(message)s (%(filename)s:%(lineno)d)")
+    fmt = "[%(name)s] | %(levelname)s -> %(message)s"
 
     FORMATS = {
-        logging.DEBUG: grey + format + reset,
-        logging.INFO: grey + format + reset,
-        logging.WARNING: yellow + format + reset,
-        logging.ERROR: red + format + reset,
-        logging.CRITICAL: bold_red + format + reset,
+        logging.DEBUG: f"{purple}{fmt}{reset}",
+        logging.INFO: f"{cyan}{fmt}{reset}",
+        logging.WARNING: f"{yellow}{fmt}{reset}",
+        logging.ERROR: f"{red}{fmt}{reset}",
+        logging.CRITICAL: f"{bold_red}{fmt}{reset}",
     }
 
     def format(self, record):
         log_fmt = self.FORMATS.get(record.levelno)
+
         formatter = logging.Formatter(log_fmt)
         return formatter.format(record)
 
 
-def mklog(name, level=logging.DEBUG):
+class FileFormatter(logging.Formatter):
+    """Formatter for file base logs."""
+
+    # File specific formatting
+    fmt = (
+        "%(asctime)s - [%(name)s] - "
+        "%(levelname)s - %(message)s (%(filename)s:%(lineno)d)"
+    )
+
+    def __init__(self):
+        super().__init__(self.fmt, "%Y-%m-%d %H:%M:%S")
+
+
+def mklog(name: str, level: int = base_log_level, log_file: str | None = None):
     logger = logging.getLogger(name)
     logger.setLevel(level)
-    # create console handler with a higher log level
+
+    for handler in logger.handlers:
+        logger.removeHandler(handler)
+
     ch = logging.StreamHandler()
-    ch.setLevel(logging.DEBUG)
-
-    ch.setFormatter(Formatter())
-
+    ch.setLevel(level)
+    ch.setFormatter(ConsoleFormatter())
     logger.addHandler(ch)
+
+    if log_file:
+        # file handler
+        fh = logging.FileHandler(log_file)
+        fh.setLevel(level)
+        fh.setFormatter(FileFormatter())
+        logger.addHandler(fh)
+
+    # Disable log propagation
+    logger.propagate = False
+
     return logger
 
 
 # - The main app logger
-log = mklog(__package__)
+log = mklog(__package__, base_log_level)
 
 
-def log_user(arg):
-    print("\033[34mComfy MTB Utils:\033[0m {arg}")
+def log_user(arg: str):
+    print(f"\033[34mComfy MTB Utils:\033[0m {arg}")
 
 
-def get_summary(docstring):
+def get_summary(docstring: str):
     return docstring.strip().split("\n\n", 1)[0]
 
 
-def blue_text(text):
+def blue_text(text: str):
     return f"\033[94m{text}\033[0m"
 
 
-def get_label(label):
-    words = re.findall(r"(?:^|[A-Z])[a-z]*", label)
+def cyan_text(text: str):
+    return f"\033[96m{text}\033[0m"
+
+
+def get_label(label: str):
+    if label.startswith("MTB_"):
+        label = label[4:]
+
+    words = re.findall(
+        r"(?:(?<=[a-z])(?=[A-Z])|(?<=[A-Z])(?=[A-Z][a-z])|(?<=[A-Za-z])(?=[0-9])|(?<=[0-9])(?=[A-Za-z]))",
+        label,
+    )
+    reformatted_label = re.sub(r"([A-Z]+)", r" \1", label).strip()
+    words = reformatted_label.split()
     return " ".join(words).strip()

node_list.json

@@ -0,0 +1,79 @@
+{
+    "Animation Builder (mtb)": "Convenient way to manage basic animation maths at the core of many of my workflows",
+    "Any To String (mtb)": "Tries to take any input and convert it to a string",
+    "Batch Float (mtb)": "Generates a batch of float values with interpolation",
+    "Batch Float Assemble (mtb)": "Assembles mutiple batches of floats into a single stream (batch)",
+    "Batch Float Fill (mtb)": "Fills a batch float with a single value until it reaches the target length",
+    "Batch Make (mtb)": "Simply duplicates the input frame as a batch",
+    "Batch Merge (mtb)": "Merges multiple image batches with different frame counts",
+    "Batch Shake (mtb)": "Applies a shaking effect to batches of images.",
+    "Batch Shape (mtb)": "Generates a batch of 2D shapes with optional shading (experimental)",
+    "Batch Transform (mtb)": "Transform a batch of images using a batch of keyframes",
+    "Bbox (mtb)": "The bounding box (BBOX) custom type used by other nodes",
+    "Bbox From Mask (mtb)": "From a mask extract the bounding box",
+    "Blur (mtb)": "Blur an image using a Gaussian filter.",
+    "Color Correct (mtb)": "Various color correction methods",
+    "Colored Image (mtb)": "Constant color image of given size",
+    "Concat Images (mtb)": "Add images to batch",
+    "Crop (mtb)": "Crops an image and an optional mask to a given bounding box\n\n    The bounding box can be given as a tuple of (x, y, width, height) or as a BBOX type\n    The BBOX input takes precedence over the tuple input\n    ",
+    "Debug (mtb)": "Experimental node to debug any Comfy values, support for more types and widgets is planned",
+    "Deep Bump (mtb)": "Normal & height maps generation from single pictures",
+    "Export With Ffmpeg (mtb)": "Export with FFmpeg (Experimental)",
+    "Face Swap (mtb)": "Face swap using deepinsight/insightface models",
+    "Film Interpolation (mtb)": "Google Research FILM frame interpolation for large motion",
+    "Fit Number (mtb)": "Fit the input float using a source and target range",
+    "Float To Number (mtb)": "Node addon for the WAS Suite. Converts a \"comfy\" FLOAT to a NUMBER.",
+    "Geometry Box (mtb)": "Makes a Box 3D geometry",
+    "Geometry Decimater (mtb)": "Optimized the geometry to match the target number of triangles",
+    "Geometry Info (mtb)": "Retrieve information about a 3D geometry",
+    "Geometry Sphere (mtb)": "Makes a Sphere 3D geometry",
+    "Geometry Test (mtb)": "Fetches an Open3D data geometry",
+    "Get Batch From History (mtb)": "Very experimental node to load images from the history of the server.\n\n    Queue items without output are ignored in the count.",
+    "Image Compare (mtb)": "Compare two images and return a difference image",
+    "Image Distort With Uv (mtb)": "Distorts an image based on a UV map.",
+    "Image Premultiply (mtb)": "Premultiply image with mask",
+    "Image Remove Background Rembg (mtb)": "Removes the background from the input using Rembg.",
+    "Image Resize Factor (mtb)": "Extracted mostly from WAS Node Suite, with a few edits (most notably multiple image support) and less features.",
+    "Image Tile Offset (mtb)": "Mimics an old photoshop technique to check for seamless textures",
+    "Image To Uv (mtb)": "Turn an image back into a UV map. (Shallow converter)",
+    "Image Tile Offset (mtb)": "Mimics an old photoshop technique to check for seamless textures",
+    "Int To Bool (mtb)": "Basic int to bool conversion",
+    "Int To Number (mtb)": "Node addon for the WAS Suite. Converts a \"comfy\" INT to a NUMBER.",
+    "Interpolate Clip Sequential (mtb)": null,
+    "Latent Lerp (mtb)": "Linear interpolation (blend) between two latent vectors",
+    "Load Face Analysis Model (mtb)": "Loads a face analysis model",
+    "Load Face Enhance Model (mtb)": "Loads a GFPGan or RestoreFormer model for face enhancement.",
+    "Load Face Swap Model (mtb)": "Loads a faceswap model",
+    "Load Film Model (mtb)": "Loads a FILM model",
+    "Load Geometry (mtb)": "Load a 3D geometry",
+    "Load Image From Url (mtb)": "Load an image from the given URL",
+    "Load Image Sequence (mtb)": "Load an image sequence from a folder. The current frame is used to determine which image to load.\n\n    Usually used in conjunction with the `Primitive` node set to increment to load a sequence of images from a folder.\n    Use -1 to load all matching frames as a batch.\n    ",
+    "Mask To Image (mtb)": "Converts a mask (alpha) to an RGB image with a color and background",
+    "Model Patch Seamless (mtb)": "Experimental patcher to enable the circular padding mode of the sd model layers, requires a custom VAE",
+    "Math Expression (mtb)": "Node to evaluate a simple math expression string",
+    "Model Patch Seamless (mtb)": "Uses the stable diffusion 'hack' to infer seamless images by setting the model layers padding mode to circular (experimental)",
+    "Pick From Batch (mtb)": "Pick a specific number of images from a batch, either from the start or end.",
+    "Qr Code (mtb)": "Basic QR Code generator",
+    "Restore Face (mtb)": "Uses GFPGan to restore faces",
+    "Save Gif (mtb)": "Save the images from the batch as a GIF",
+    "Save Image Grid (mtb)": "Save all the images in the input batch as a grid of images.",
+    "Save Image Sequence (mtb)": "Save an image sequence to a folder. The current frame is used to determine which image to save.\n\n    This is merely a wrapper around the `save_images` function with formatting for the output folder and filename.\n    ",
+    "Save Tensors (mtb)": "Save torch tensors (image, mask or latent) to disk, useful to debug things outside comfy",
+    "Sharpen (mtb)": "Sharpens an image using a Gaussian kernel.",
+    "Smart Step (mtb)": "Utils to control the steps start/stop of the KAdvancedSampler in percentage",
+    "Stack Images (mtb)": "Stack the input images horizontally or vertically",
+    "String Replace (mtb)": "Basic string replacement",
+    "Styles Loader (mtb)": "Load csv files and populate a dropdown from the rows (\u00e0 la A111)",
+    "Text To Image (mtb)": "Utils to convert text to image using a font\n\n\n    The tool looks for any .ttf file in the Comfy folder hierarchy.\n    ",
+    "Transform Geometry (mtb)": "Transforms the input geometry",
+    "Transform Image (mtb)": "Save torch tensors (image, mask or latent) to disk, useful to debug things outside comfy\n\n\n    it return a tensor representing the transformed images with the same shape as the input tensor\n    ",
+    "Uncrop (mtb)": "Uncrops an image to a given bounding box\n\n    The bounding box can be given as a tuple of (x, y, width, height) or as a BBOX type\n    The BBOX input takes precedence over the tuple input",
+    "Unsplash Image (mtb)": "Unsplash Image given a keyword and a size",
+    "Uv Distort (mtb)": "Applies a polar coordinates or wave distortion to the UV map",
+    "Uv Map (mtb)": "Generates a UV Map tensor given a widht and height",
+    "Uv Remove Seams (mtb)": "Blends values near the UV borders to mitigate visible seams.",
+    "Uv Tile (mtb)": "Tiles the UV map based on the specified number of tiles.",
+    "Uv To Image (mtb)": "Converts the UV map to an image. (Shallow converter)",
+    "Vae Decode (mtb)": "Wrapper for the 2 core decoders (nomarl and tiled) but also adding the sd seamless hack, taken from: FlyingFireCo/tiled_ksampler"
+}
+

nodes/__init__.py

@@ -0,0 +1 @@
+"""MTB Nodes module."""

nodes/animation.py

@@ -0,0 +1,74 @@
+from ..log import log
+
+
+class MTB_AnimationBuilder:
+    """Simple maths for animation."""
+
+    @classmethod
+    def INPUT_TYPES(cls):
+        return {
+            "required": {
+                "total_frames": ("INT", {"default": 100, "min": 0}),
+                # "fps": ("INT", {"default": 12, "min": 0}),
+                "scale_float": ("FLOAT", {"default": 1.0, "min": 0.0}),
+                "loop_count": ("INT", {"default": 1, "min": 0}),
+                "raw_iteration": ("INT", {"default": 0, "min": 0}),
+                "raw_loop": ("INT", {"default": 0, "min": 0}),
+            },
+        }
+
+    RETURN_TYPES = ("INT", "FLOAT", "INT", "BOOLEAN")
+    RETURN_NAMES = ("frame", "0-1 (scaled)", "count", "loop_ended")
+    CATEGORY = "mtb/animation"
+    FUNCTION = "build_animation"
+    DESCRIPTION = """
+# Animation Builder
+
+Check the
+[wiki page](https://github.com/melMass/comfy_mtb/wiki/nodes-animation-builder)
+for more info.
+
+
+- This basic example should help to understand the meaning of
+its inputs and outputs thanks to the [debug](nodes-debug) node.
+
+![](https://github.com/melMass/comfy_mtb/assets/7041726/2b5c7e4f-372d-4494-9e73-abb2daa7cb36)
+
+- In this other example Animation Builder is used in combination with
+[Batch From History](https://github.com/melMass/comfy_mtb/wiki/nodes-batch-from-history)
+to create a zoom-in animation on a static image
+
+![](https://github.com/melMass/comfy_mtb/assets/7041726/77d37da1-0a8e-4519-a493-dfdef7f755ea)
+
+## Inputs
+
+| name | description |
+| ---- | :----------:|
+| total_frames | The number of frame to queue (this is multiplied by the `loop_count`)|
+| scale_float | Convenience input to scale the normalized `current value` (a float between 0 and 1 lerp over the current queue length) |
+| loop_count | The number of loops to queue |
+| **Reset Button** | resets the internal counters, although the node is though around using its queue button it should still work fine when using the regular queue button of comfy |
+| **Queue Button** | Convenience button to run the queues (`total_frames` * `loop_count`) |
+
+"""
+
+    def build_animation(
+        self,
+        total_frames=100,
+        # fps=12,
+        scale_float=1.0,
+        loop_count=1,  # set in js
+        raw_iteration=0,  # set in js
+        raw_loop=0,  # set in js
+    ):
+        frame = raw_iteration % (total_frames)
+        scaled = (frame / (total_frames - 1)) * scale_float
+        # if frame == 0:
+        #     log.debug("Reseting history")
+        #     PromptServer.instance.prompt_queue.wipe_history()
+        log.debug(f"frame: {frame}/{total_frames}  scaled: {scaled}")
+
+        return (frame, scaled, raw_loop, (frame == (total_frames - 1)))
+
+
+__nodes__ = [MTB_AnimationBuilder]

nodes/audio.py

@@ -0,0 +1,235 @@
+from typing import TypedDict
+
+import torch
+import torchaudio
+
+
+class AudioDict(TypedDict):
+    """Comfy's representation of AUDIO data."""
+
+    sample_rate: int
+    waveform: torch.Tensor
+
+
+AudioData = AudioDict | list[AudioDict]
+
+
+class MtbAudio:
+    """Base class for audio processing."""
+
+    @classmethod
+    def is_stereo(
+        cls,
+        audios: AudioData,
+    ) -> bool:
+        if isinstance(audios, list):
+            return any(cls.is_stereo(audio) for audio in audios)
+        else:
+            return audios["waveform"].shape[1] == 2
+
+    @staticmethod
+    def resample(audio: AudioDict, common_sample_rate: int) -> AudioDict:
+        if audio["sample_rate"] != common_sample_rate:
+            resampler = torchaudio.transforms.Resample(
+                orig_freq=audio["sample_rate"], new_freq=common_sample_rate
+            )
+            return {
+                "sample_rate": common_sample_rate,
+                "waveform": resampler(audio["waveform"]),
+            }
+        else:
+            return audio
+
+    @staticmethod
+    def to_stereo(audio: AudioDict) -> AudioDict:
+        if audio["waveform"].shape[1] == 1:
+            return {
+                "sample_rate": audio["sample_rate"],
+                "waveform": torch.cat(
+                    [audio["waveform"], audio["waveform"]], dim=1
+                ),
+            }
+        else:
+            return audio
+
+    @classmethod
+    def preprocess_audios(
+        cls, audios: list[AudioDict]
+    ) -> tuple[list[AudioDict], bool, int]:
+        max_sample_rate = max([audio["sample_rate"] for audio in audios])
+
+        resampled_audios = [
+            cls.resample(audio, max_sample_rate) for audio in audios
+        ]
+
+        is_stereo = cls.is_stereo(audios)
+        if is_stereo:
+            audios = [cls.to_stereo(audio) for audio in resampled_audios]
+
+        return (audios, is_stereo, max_sample_rate)
+
+
+class MTB_AudioCut(MtbAudio):
+    """Basic audio cutter, values are in ms."""
+
+    @classmethod
+    def INPUT_TYPES(cls):
+        return {
+            "required": {
+                "audio": ("AUDIO",),
+                "length": (
+                    ("FLOAT"),
+                    {
+                        "default": 1000.0,
+                        "min": 0.0,
+                        "max": 999999.0,
+                        "step": 1,
+                    },
+                ),
+                "offset": (
+                    ("FLOAT"),
+                    {"default": 0.0, "min": 0.0, "max": 999999.0, "step": 1},
+                ),
+            },
+        }
+
+    RETURN_TYPES = ("AUDIO",)
+    RETURN_NAMES = ("cut_audio",)
+    CATEGORY = "mtb/audio"
+    FUNCTION = "cut"
+
+    def cut(self, audio: AudioDict, length: float, offset: float):
+        sample_rate = audio["sample_rate"]
+        start_idx = int(offset * sample_rate / 1000)
+        end_idx = min(
+            start_idx + int(length * sample_rate / 1000),
+            audio["waveform"].shape[-1],
+        )
+        cut_waveform = audio["waveform"][:, :, start_idx:end_idx]
+
+        return (
+            {
+                "sample_rate": sample_rate,
+                "waveform": cut_waveform,
+            },
+        )
+
+
+class MTB_AudioStack(MtbAudio):
+    """Stack/Overlay audio inputs (dynamic inputs).
+
+    - pad audios to the longest inputs.
+    - resample audios to the highest sample rate in the inputs.
+    - convert them all to stereo if one of the inputs is.
+    """
+
+    @classmethod
+    def INPUT_TYPES(cls):
+        return {"required": {}}
+
+    RETURN_TYPES = ("AUDIO",)
+    RETURN_NAMES = ("stacked_audio",)
+    CATEGORY = "mtb/audio"
+    FUNCTION = "stack"
+
+    def stack(self, **kwargs: AudioDict) -> tuple[AudioDict]:
+        audios, is_stereo, max_rate = self.preprocess_audios(
+            list(kwargs.values())
+        )
+
+        max_length = max([audio["waveform"].shape[-1] for audio in audios])
+
+        padded_audios: list[torch.Tensor] = []
+        for audio in audios:
+            padding = torch.zeros(
+                (
+                    1,
+                    2 if is_stereo else 1,
+                    max_length - audio["waveform"].shape[-1],
+                )
+            )
+            padded_audio = torch.cat([audio["waveform"], padding], dim=-1)
+            padded_audios.append(padded_audio)
+
+        stacked_waveform = torch.stack(padded_audios, dim=0).sum(dim=0)
+
+        return (
+            {
+                "sample_rate": max_rate,
+                "waveform": stacked_waveform,
+            },
+        )
+
+
+class MTB_AudioSequence(MtbAudio):
+    """Sequence audio inputs (dynamic inputs).
+
+    - adding silence_duration between each segment
+      can now also be negative to overlap the clips, safely bound
+      to the the input length.
+    - resample audios to the highest sample rate in the inputs.
+    - convert them all to stereo if one of the inputs is.
+    """
+
+    @classmethod
+    def INPUT_TYPES(cls):
+        return {
+            "required": {
+                "silence_duration": (
+                    ("FLOAT"),
+                    {"default": 0.0, "min": -999.0, "max": 999, "step": 0.01},
+                )
+            },
+        }
+
+    RETURN_TYPES = ("AUDIO",)
+    RETURN_NAMES = ("sequenced_audio",)
+    CATEGORY = "mtb/audio"
+    FUNCTION = "sequence"
+
+    def sequence(self, silence_duration: float, **kwargs: AudioDict):
+        audios, is_stereo, max_rate = self.preprocess_audios(
+            list(kwargs.values())
+        )
+
+        sequence: list[torch.Tensor] = []
+        for i, audio in enumerate(audios):
+            if i > 0:
+                if silence_duration > 0:
+                    silence = torch.zeros(
+                        (
+                            1,
+                            2 if is_stereo else 1,
+                            int(silence_duration * max_rate),
+                        )
+                    )
+                    sequence.append(silence)
+                elif silence_duration < 0:
+                    overlap = int(abs(silence_duration) * max_rate)
+                    previous_audio = sequence[-1]
+                    overlap = min(
+                        overlap,
+                        previous_audio.shape[-1],
+                        audio["waveform"].shape[-1],
+                    )
+                    if overlap > 0:
+                        overlap_part = (
+                            previous_audio[:, :, -overlap:]
+                            + audio["waveform"][:, :, :overlap]
+                        )
+                        sequence[-1] = previous_audio[:, :, :-overlap]
+                        sequence.append(overlap_part)
+                        audio["waveform"] = audio["waveform"][:, :, overlap:]
+
+            sequence.append(audio["waveform"])
+
+        sequenced_waveform = torch.cat(sequence, dim=-1)
+        return (
+            {
+                "sample_rate": max_rate,
+                "waveform": sequenced_waveform,
+            },
+        )
+
+
+__nodes__ = [MTB_AudioSequence, MTB_AudioStack, MTB_AudioCut]

nodes/conditions.py

@@ -1,18 +1,232 @@
-from ..utils import pil2tensor
-from ..utils import here
-from ..log import log
-import folder_paths
-from pathlib import Path
-import shutil
 import csv
+import shutil
+from pathlib import Path
+
+import folder_paths
+import torch
+
+from ..log import log
+from ..utils import here
+
+Conditioning = list[tuple[torch.Tensor, dict[str, torch.Tensor]]]
 
 
-class SmartStep:
+def check_condition(conditioning: Conditioning):
+    has_cn = False
+    if len(conditioning) > 1:
+        log.warn(
+            "More than one conditioning was provided. Only the first one will be used."
+        )
+    first = conditioning[0]
+    cond, kwargs = first
+
+    log.debug("Conditioning Shape")
+    log.debug(cond.shape)
+    log.debug("Conditioning keys")
+    log.debug([f"\t{k} - {type(kwargs[k])}" for k in kwargs])
+    if "control" in kwargs:
+        log.debug("Conditioning contains a controlnet")
+        has_cn = True
+    if "pooled_output" not in kwargs:
+        raise ValueError(
+            "Conditioning is not valid. Missing 'pooled_output' key."
+        )
+    return has_cn
+
+
+class MTB_InterpolateCondition:
+    @classmethod
+    def INPUT_TYPES(cls):
+        return {
+            "required": {
+                "blend": (
+                    "FLOAT",
+                    {"default": 0.0, "min": 0.0, "max": 1.0, "step": 0.01},
+                ),
+            },
+        }
+
+    RETURN_TYPES = ("CONDITIONING",)
+    CATEGORY = "mtb/conditioning"
+    FUNCTION = "execute"
+
+    def execute(
+        self, blend: float, **kwargs: Conditioning
+    ) -> tuple[Conditioning]:
+        blend = max(0.0, min(1.0, blend))
+
+        conditions: list[Conditioning] = list(kwargs.values())
+        num_conditions = len(conditions)
+
+        if num_conditions < 2:
+            raise ValueError("At least two conditioning inputs are required.")
+
+        segment_length = 1.0 / (num_conditions - 1)
+
+        segment_index = min(int(blend // segment_length), num_conditions - 2)
+
+        local_blend = (
+            blend - (segment_index * segment_length)
+        ) / segment_length
+
+        cond_from = conditions[segment_index]
+        cond_to = conditions[segment_index + 1]
+
+        from_cn = check_condition(cond_from)
+        to_cn = check_condition(cond_to)
+
+        if from_cn and to_cn:
+            raise ValueError(
+                "Interpolating conditions cannot both contain ControlNets"
+            )
+
+        try:
+            interpolated_condition = [
+                (1.0 - local_blend) * c_from + local_blend * c_to
+                for c_from, c_to in zip(
+                    cond_from[0][0], cond_to[0][0], strict=False
+                )
+            ]
+        except Exception as e:
+            print(f"Error during interpolation: {e}")
+            raise
+
+        pooled_from = cond_from[0][1].get(
+            "pooled_output",
+            torch.zeros_like(
+                next(iter(cond_from[0][1].values()), torch.tensor([]))
+            ),
+        )
+
+        pooled_to = cond_to[0][1].get(
+            "pooled_output",
+            torch.zeros_like(
+                next(iter(cond_from[0][1].values()), torch.tensor([]))
+            ),
+        )
+
+        interpolated_pooled = (
+            1.0 - local_blend
+        ) * pooled_from + local_blend * pooled_to
+
+        res = {"pooled_output": interpolated_pooled}
+
+        if from_cn:
+            res["control"] = cond_from[0][1]["control"]
+            res["control_apply_to_uncond"] = cond_from[0][1][
+                "control_apply_to_uncond"
+            ]
+        if to_cn:
+            res["control"] = cond_to[0][1]["control"]
+            res["control_apply_to_uncond"] = cond_to[0][1][
+                "control_apply_to_uncond"
+            ]
+
+        return ([(torch.stack(interpolated_condition), res)],)
+
+
+class MTB_InterpolateClipSequential:
+    @classmethod
+    def INPUT_TYPES(cls):
+        return {
+            "required": {
+                "base_text": ("STRING", {"multiline": True}),
+                "text_to_replace": ("STRING", {"default": ""}),
+                "clip": ("CLIP",),
+                "interpolation_strength": (
+                    "FLOAT",
+                    {"default": 1.0, "min": 0.0, "max": 1.0, "step": 0.01},
+                ),
+            }
+        }
+
+    RETURN_TYPES = ("CONDITIONING",)
+    FUNCTION = "interpolate_encodings_sequential"
+
+    CATEGORY = "mtb/conditioning"
+
+    def interpolate_encodings_sequential(
+        self,
+        base_text,
+        text_to_replace,
+        clip,
+        interpolation_strength,
+        **replacements,
+    ):
+        log.debug(f"Received interpolation_strength: {interpolation_strength}")
+
+        # - Ensure interpolation strength is within [0, 1]
+        interpolation_strength = max(0.0, min(1.0, interpolation_strength))
+
+        # - Check if replacements were provided
+        if not replacements:
+            raise ValueError("At least one replacement should be provided.")
+
+        num_replacements = len(replacements)
+        log.debug(f"Number of replacements: {num_replacements}")
+
+        segment_length = 1.0 / num_replacements
+        log.debug(f"Calculated segment_length: {segment_length}")
+
+        # - Find the segment that the interpolation_strength falls into
+        segment_index = min(
+            int(interpolation_strength // segment_length), num_replacements - 1
+        )
+        log.debug(f"Segment index: {segment_index}")
+
+        # - Calculate the local strength within the segment
+        local_strength = (
+            interpolation_strength - (segment_index * segment_length)
+        ) / segment_length
+        log.debug(f"Local strength: {local_strength}")
+
+        # - If it's the first segment, interpolate between base_text and the first replacement
+        if segment_index == 0:
+            replacement_text = list(replacements.values())[0]
+            log.debug("Using the base text a the base blend")
+            # -  Start with the base_text condition
+            tokens = clip.tokenize(base_text)
+            cond_from, pooled_from = clip.encode_from_tokens(
+                tokens, return_pooled=True
+            )
+        else:
+            base_replace = list(replacements.values())[segment_index - 1]
+            log.debug(f"Using {base_replace} a the base blend")
+
+            # - Start with the base_text condition replaced by the closest replacement
+            tokens = clip.tokenize(
+                base_text.replace(text_to_replace, base_replace)
+            )
+            cond_from, pooled_from = clip.encode_from_tokens(
+                tokens, return_pooled=True
+            )
+
+            replacement_text = list(replacements.values())[segment_index]
+
+        interpolated_text = base_text.replace(
+            text_to_replace, replacement_text
+        )
+        tokens = clip.tokenize(interpolated_text)
+        cond_to, pooled_to = clip.encode_from_tokens(
+            tokens, return_pooled=True
+        )
+
+        # - Linearly interpolate between the two conditions
+        interpolated_condition = (
+            1.0 - local_strength
+        ) * cond_from + local_strength * cond_to
+        interpolated_pooled = (
+            1.0 - local_strength
+        ) * pooled_from + local_strength * pooled_to
+
+        return (
+            [[interpolated_condition, {"pooled_output": interpolated_pooled}]],
+        )
+
+
+class MTB_SmartStep:
     """Utils to control the steps start/stop of the KAdvancedSampler in percentage"""
 
-    def __init__(self):
-        pass
-
     @classmethod
     def INPUT_TYPES(cls):
         return {
@@ -35,7 +249,7 @@ class SmartStep:
     RETURN_TYPES = ("INT", "INT", "INT")
     RETURN_NAMES = ("step", "start", "end")
     FUNCTION = "do_step"
-    CATEGORY = "conditioning"
+    CATEGORY = "mtb/conditioning"
 
     def do_step(self, step, start_percent, end_percent):
         start = int(step * start_percent / 100)
@@ -57,42 +271,56 @@ def install_default_styles(force=False):
     return dest_style
 
 
-class StylesLoader:
+class MTB_StylesLoader:
     """Load csv files and populate a dropdown from the rows (à la A111)"""
 
     options = {}
 
-    def __init__(self):
-        pass
-
     @classmethod
     def INPUT_TYPES(cls):
-        input_dir = Path(folder_paths.base_path) / "styles"
-        if not input_dir.exists():
-            install_default_styles()
+        if not cls.options:
+            input_dir = Path(folder_paths.base_path) / "styles"
+            if not input_dir.exists():
+                install_default_styles()
+
+            if not (
+                files := [f for f in input_dir.iterdir() if f.suffix == ".csv"]
+            ):
+                log.warn(
+                    "No styles found in the styles folder, place at least one csv file in the styles folder at the root of ComfyUI (for instance ComfyUI/styles/mystyle.csv)"
+                )
+
+            for file in files:
+                with open(file, encoding="utf8") as f:
+                    parsed = csv.reader(f)
+                    for i, row in enumerate(parsed):
+                        # log.debug(f"Adding style {row[0]}")
+                        try:
+                            name, positive, negative = (row + [None] * 3)[:3]
+                            positive = positive or ""
+                            negative = negative or ""
+                            if name is not None:
+                                cls.options[name] = (positive, negative)
+                            else:
+                                # Handle the case where 'name' is None
+                                log.warning(f"Missing 'name' in row {i}.")
+
+                        except Exception as e:
+                            log.warning(
+                                f"There was an error while parsing {file}, make sure it respects A1111 format, i.e 3 columns name, positive, negative:\n{e}"
+                            )
+                            continue
+
+        else:
+            log.debug(f"Using cached styles (count: {len(cls.options)})")
 
-        if not (files := [f for f in input_dir.iterdir() if f.suffix == ".csv"]):
-            log.error(
-                "No styles found in the styles folder, place at least one csv file in the styles folder"
-            )
-            return {
-                "required": {
-                    "style_name": (["error"],),
-                }
-            }
-        for file in files:
-            with open(file, "r", encoding="utf8") as f:
-                parsed = csv.reader(f)
-                for row in parsed:
-                    log.debug(f"Adding style {row[0]}")
-                    cls.options[row[0]] = (row[1], row[2])
         return {
             "required": {
                 "style_name": (list(cls.options.keys()),),
             }
         }
 
-    CATEGORY = "conditioning"
+    CATEGORY = "mtb/conditioning"
 
     RETURN_TYPES = ("STRING", "STRING")
     RETURN_NAMES = ("positive", "negative")
@@ -102,100 +330,9 @@ class StylesLoader:
         return (self.options[style_name][0], self.options[style_name][1])
 
 
-class TextToImage:
-    """Utils to convert text to image using a font
-
-
-    The tool looks for any .ttf file in the Comfy folder hierarchy.
-    """
-
-    fonts = {}
-
-    def __init__(self):
-        pass
-
-    @classmethod
-    def INPUT_TYPES(cls):
-        fonts = list(Path(folder_paths.base_path).glob("**/*.ttf"))
-        if not fonts:
-            log.error(
-                "No fonts found in the fonts folder, place at least one ttf file in the fonts folder"
-            )
-            return {
-                "required": {
-                    "font": (["error"],),
-                }
-            }
-        for font in fonts:
-            log.debug(f"Adding font {font}")
-            cls.fonts[font.stem] = font.as_posix()
-
-        return {
-            "required": {
-                "text": (
-                    "STRING",
-                    {"default": "Hello world!"},
-                ),
-                "font": ((sorted(cls.fonts.keys())),),
-                "wrap": (
-                    "INT",
-                    {"default": 120, "min": 0, "max": 8096, "step": 1},
-                ),
-                "font_size": (
-                    "INT",
-                    {"default": 12, "min": 1, "max": 100, "step": 1},
-                ),
-                "width": (
-                    "INT",
-                    {"default": 512, "min": 1, "max": 1000, "step": 1},
-                ),
-                "height": (
-                    "INT",
-                    {"default": 512, "min": 1, "max": 8096, "step": 1},
-                ),
-                # "position": (["INT"], {"default": 0, "min": 0, "max": 100, "step": 1}),
-                "color": (
-                    "COLOR",
-                    {"default": "black"},
-                ),
-                "background": (
-                    "COLOR",
-                    {"default": "white"},
-                ),
-            }
-        }
-
-    RETURN_TYPES = ("IMAGE",)
-    RETURN_NAMES = ("image",)
-    FUNCTION = "text_to_image"
-    CATEGORY = "utils"
-
-    def text_to_image(
-        self, text, font, wrap, font_size, width, height, color, background
-    ):
-        from PIL import Image, ImageDraw, ImageFont
-        import textwrap
-
-        font = self.fonts[font]
-        font = ImageFont.truetype(font, font_size)
-        if wrap == 0:
-            wrap = width / font_size
-        lines = textwrap.wrap(text, width=wrap)
-        log.debug(f"Lines: {lines}")
-        line_height = font.getsize("hg")[1]
-        img_height = height  # line_height * len(lines)
-        img_width = width  # max(font.getsize(line)[0] for line in lines)
-
-        img = Image.new("RGBA", (img_width, img_height), background)
-        draw = ImageDraw.Draw(img)
-        y_text = 0
-        for line in lines:
-            width, height = font.getsize(line)
-            draw.text((0, y_text), line, color, font=font)
-            y_text += height
-
-        # img.save(os.path.join(folder_paths.base_path, f'{str(uuid.uuid4())}.png'))
-        return (pil2tensor(img),)
-
-
-__nodes__ = [SmartStep, TextToImage, StylesLoader]
+__nodes__ = [
+    MTB_SmartStep,
+    MTB_StylesLoader,
+    MTB_InterpolateClipSequential,
+    MTB_InterpolateCondition,
+]

nodes/constant.py

@@ -0,0 +1,27 @@
+import json
+
+from ..log import log
+
+
+class MTB_Constant:
+    @classmethod
+    def INPUT_TYPES(cls):
+        return {
+            "required": {"Value": ("*",)},
+        }
+
+    RETURN_TYPES = ("*",)
+    RETURN_NAMES = ("output",)
+    CATEGORY = "mtb/utils"
+    FUNCTION = "execute"
+
+    def execute(
+        self,
+        **kwargs,
+    ):
+        log.debug("Received kwargs")
+        log.debug(json.dumps(kwargs, check_circular=True))
+        return (kwargs.get("Value"),)
+
+
+# __nodes__ = [MTB_Constant]

nodes/crop.py

@@ -1,20 +1,27 @@
-import torch
-from ..utils import tensor2pil, pil2tensor
-from PIL import Image, ImageFilter, ImageDraw
 import numpy as np
+import torch
+from PIL import Image, ImageDraw, ImageFilter
+
+from ..log import log
+from ..utils import np2tensor, pil2tensor, tensor2np, tensor2pil
 
 
-class BoundingBox:
+class MTB_Bbox:
     """The bounding box (BBOX) custom type used by other nodes"""
-    def __init__(self):
-        pass
 
     @classmethod
     def INPUT_TYPES(cls):
         return {
             "required": {
-                "x": ("INT", {"default": 0, "max": 10000000, "min": 0, "step": 1}),
-                "y": ("INT", {"default": 0, "max": 10000000, "min": 0, "step": 1}),
+                # "bbox": ("BBOX",),
+                "x": (
+                    "INT",
+                    {"default": 0, "max": 10000000, "min": 0, "step": 1},
+                ),
+                "y": (
+                    "INT",
+                    {"default": 0, "max": 10000000, "min": 0, "step": 1},
+                ),
                 "width": (
                     "INT",
                     {"default": 256, "max": 10000000, "min": 0, "step": 1},
@@ -28,22 +35,69 @@ class BoundingBox:
 
     RETURN_TYPES = ("BBOX",)
     FUNCTION = "do_crop"
-    CATEGORY = "image/crop"
+    CATEGORY = "mtb/crop"
 
-    def do_crop(self, x, y, width, height):
-        return (x, y, width, height)
+    def do_crop(self, x: int, y: int, width: int, height: int):  # bbox
+        return ((x, y, width, height),)
 
 
-class BBoxFromMask:
+class MTB_SplitBbox:
+    """Split the components of a bbox"""
+
+    @classmethod
+    def INPUT_TYPES(cls):
+        return {
+            "required": {"bbox": ("BBOX",)},
+        }
+
+    CATEGORY = "mtb/crop"
+    FUNCTION = "split_bbox"
+    RETURN_TYPES = ("INT", "INT", "INT", "INT")
+    RETURN_NAMES = ("x", "y", "width", "height")
+
+    def split_bbox(self, bbox):
+        return (bbox[0], bbox[1], bbox[2], bbox[3])
+
+
+class MTB_UpscaleBboxBy:
+    @classmethod
+    def INPUT_TYPES(cls):
+        return {
+            "required": {
+                "bbox": ("BBOX",),
+                "scale": ("FLOAT", {"default": 1.0}),
+            },
+        }
+
+    CATEGORY = "mtb/crop"
+    RETURN_TYPES = ("BBOX",)
+
+    FUNCTION = "upscale"
+
+    def upscale(
+        self, bbox: tuple[int, int, int, int], scale: float
+    ) -> tuple[tuple[int, int, int, int]]:
+        x, y, width, height = bbox
+        # scaled = (x * scale, y * scale, width * scale, height * scale)
+        scaled = (
+            int(x * scale),
+            int(y * scale),
+            int(width * scale),
+            int(height * scale),
+        )
+
+        return (scaled,)
+
+
+class MTB_BboxFromMask:
     """From a mask extract the bounding box"""
-    def __init__(self):
-        pass
 
     @classmethod
     def INPUT_TYPES(cls):
         return {
             "required": {
                 "mask": ("MASK",),
+                "invert": ("BOOLEAN", {"default": False}),
             },
             "optional": {
                 "image": ("IMAGE",),
@@ -59,13 +113,26 @@ class BBoxFromMask:
         "image (optional)",
     )
     FUNCTION = "extract_bounding_box"
-    CATEGORY = "image/crop"
+    CATEGORY = "mtb/crop"
 
-    def extract_bounding_box(self, mask: torch.Tensor, image=None):
+    def extract_bounding_box(
+        self, mask: torch.Tensor, invert: bool, image=None
+    ):
+        # if image != None:
+        #     if mask.size(0) != image.size(0):
+        #         if mask.size(0) != 1:
+        #             log.error(
+        #                 f"Batch count mismatch for mask and image, it can either be 1 mask for X images, or X masks for X images (mask: {mask.shape} | image: {image.shape})"
+        #             )
 
-        mask = tensor2pil(mask)
+        #             raise Exception(
+        #                 f"Batch count mismatch for mask and image, it can either be 1 mask for X images, or X masks for X images (mask: {mask.shape} | image: {image.shape})"
+        #             )
+
+        # we invert it
+        _mask = tensor2pil(1.0 - mask)[0] if invert else tensor2pil(mask)[0]
+        alpha_channel = np.array(_mask)
 
-        alpha_channel = np.array(mask)
         non_zero_indices = np.nonzero(alpha_channel)
 
         min_x, max_x = np.min(non_zero_indices[1]), np.max(non_zero_indices[1])
@@ -74,11 +141,16 @@ class BBoxFromMask:
         # Create a bounding box tuple
         if image != None:
             # Convert the image to a NumPy array
-            image = image.numpy()
-            # Crop the image from the bounding box
-            image = image[:, min_y:max_y, min_x:max_x]
-            image = torch.from_numpy(image)
+            imgs = tensor2np(image)
+            out = []
+            for img in imgs:
+                # Crop the image from the bounding box
+                img = img[min_y:max_y, min_x:max_x, :]
+                log.debug(f"Cropped image to shape {img.shape}")
+                out.append(img)
 
+            image = np2tensor(out)
+            log.debug(f"Cropped images shape: {image.shape}")
         bounding_box = (min_x, min_y, max_x - min_x, max_y - min_y)
         return (
             bounding_box,
@@ -86,14 +158,12 @@ class BBoxFromMask:
         )
 
 
-class Crop:
+class MTB_Crop:
     """Crops an image and an optional mask to a given bounding box
 
     The bounding box can be given as a tuple of (x, y, width, height) or as a BBOX type
     The BBOX input takes precedence over the tuple input
     """
-    def __init__(self):
-        pass
 
     @classmethod
     def INPUT_TYPES(cls):
@@ -103,8 +173,14 @@ class Crop:
             },
             "optional": {
                 "mask": ("MASK",),
-                "x": ("INT", {"default": 0, "max": 10000000, "min": 0, "step": 1}),
-                "y": ("INT", {"default": 0, "max": 10000000, "min": 0, "step": 1}),
+                "x": (
+                    "INT",
+                    {"default": 0, "max": 10000000, "min": 0, "step": 1},
+                ),
+                "y": (
+                    "INT",
+                    {"default": 0, "max": 10000000, "min": 0, "step": 1},
+                ),
                 "width": (
                     "INT",
                     {"default": 256, "max": 10000000, "min": 0, "step": 1},
@@ -120,37 +196,82 @@ class Crop:
     RETURN_TYPES = ("IMAGE", "MASK", "BBOX")
     FUNCTION = "do_crop"
 
-    CATEGORY = "image/crop"
+    CATEGORY = "mtb/crop"
 
     def do_crop(
-        self, image: torch.Tensor, mask=None, x=0, y=0, width=256, height=256, bbox=None
+        self,
+        image: torch.Tensor,
+        mask=None,
+        x=0,
+        y=0,
+        width=256,
+        height=256,
+        bbox=None,
     ):
-
         image = image.numpy()
-        if mask:
+        if mask is not None:
             mask = mask.numpy()
 
-        if bbox != None:
+        if bbox is not None:
             x, y, width, height = bbox
 
         cropped_image = image[:, y : y + height, x : x + width, :]
-        cropped_mask = mask[y : y + height, x : x + width] if mask != None else None
+        cropped_mask = None
+        if mask is not None:
+            cropped_mask = (
+                mask[:, y : y + height, x : x + width]
+                if mask is not None
+                else None
+            )
         crop_data = (x, y, width, height)
 
         return (
             torch.from_numpy(cropped_image),
-            torch.from_numpy(cropped_mask) if mask != None else None,
+            torch.from_numpy(cropped_mask)
+            if cropped_mask is not None
+            else None,
             crop_data,
         )
 
 
-class Uncrop:
+# def calculate_intersection(rect1, rect2):
+#     x_left = max(rect1[0], rect2[0])
+#     y_top = max(rect1[1], rect2[1])
+#     x_right = min(rect1[2], rect2[2])
+#     y_bottom = min(rect1[3], rect2[3])
+
+#     return (x_left, y_top, x_right, y_bottom)
+
+
+def bbox_check(bbox, target_size=None):
+    if not target_size:
+        return bbox
+
+    new_bbox = (
+        bbox[0],
+        bbox[1],
+        min(target_size[0] - bbox[0], bbox[2]),
+        min(target_size[1] - bbox[1], bbox[3]),
+    )
+    if new_bbox != bbox:
+        log.warn(f"BBox too big, constrained to {new_bbox}")
+
+    return new_bbox
+
+
+def bbox_to_region(bbox, target_size=None):
+    bbox = bbox_check(bbox, target_size)
+
+    # to region
+    return (bbox[0], bbox[1], bbox[0] + bbox[2], bbox[1] + bbox[3])
+
+
+class MTB_Uncrop:
     """Uncrops an image to a given bounding box
 
     The bounding box can be given as a tuple of (x, y, width, height) or as a BBOX type
-    The BBOX input takes precedence over the tuple input"""
-    def __init__(self):
-        pass
+    The BBOX input takes precedence over the tuple input
+    """
 
     @classmethod
     def INPUT_TYPES(cls):
@@ -169,54 +290,93 @@ class Uncrop:
     RETURN_TYPES = ("IMAGE",)
     FUNCTION = "do_crop"
 
-    CATEGORY = "image/crop"
+    CATEGORY = "mtb/crop"
 
     def do_crop(self, image, crop_image, bbox, border_blending):
         def inset_border(image, border_width=20, border_color=(0)):
             width, height = image.size
-            bordered_image = Image.new(image.mode, (width, height), border_color)
+            bordered_image = Image.new(
+                image.mode, (width, height), border_color
+            )
             bordered_image.paste(image, (0, 0))
             draw = ImageDraw.Draw(bordered_image)
             draw.rectangle(
-                (0, 0, width - 1, height - 1), outline=border_color, width=border_width
+                (0, 0, width - 1, height - 1),
+                outline=border_color,
+                width=border_width,
             )
             return bordered_image
 
-        image = tensor2pil(image)
-        crop_img = tensor2pil(crop_image)
-        crop_img = crop_img.convert("RGB")
+        single = image.size(0) == 1
+        if image.size(0) != crop_image.size(0):
+            if not single:
+                raise ValueError(
+                    "The Image batch count is greater than 1, but doesn't match the crop_image batch count. If using batches they should either match or only crop_image must be greater than 1"
+                )
 
-        # uncrop the image based on the bounding box
-        bb_x, bb_y, bb_width, bb_height = bbox
+        images = tensor2pil(image)
+        crop_imgs = tensor2pil(crop_image)
+        out_images = []
+        for i, crop in enumerate(crop_imgs):
+            if single:
+                img = images[0]
+            else:
+                img = images[i]
 
-        if border_blending > 1.0:
-            border_blending = 1.0
-        elif border_blending < 0.0:
-            border_blending = 0.0
+            # uncrop the image based on the bounding box
+            bb_x, bb_y, bb_width, bb_height = bbox
 
-        blend_ratio = (max(crop_img.size) / 2) * float(border_blending)
+            paste_region = bbox_to_region(
+                (bb_x, bb_y, bb_width, bb_height), img.size
+            )
+            # log.debug(f"Paste region: {paste_region}")
+            # new_region = adjust_paste_region(img.size, paste_region)
+            # log.debug(f"Adjusted paste region: {new_region}")
+            # # Check if the adjusted paste region is different from the original
 
-        blend = image.convert("RGBA")
-        mask = Image.new("L", image.size, 0)
+            crop_img = crop.convert("RGB")
 
-        mask_block = Image.new("L", (bb_width, bb_height), 255)
-        mask_block = inset_border(mask_block, int(blend_ratio / 2), (0))
+            log.debug(f"Crop image size: {crop_img.size}")
+            log.debug(f"Image size: {img.size}")
 
-        mask.paste(mask_block, (bb_x, bb_y, bb_x + bb_width, bb_y + bb_height))
-        blend.paste(crop_img, (bb_x, bb_y, bb_x + bb_width, bb_y + bb_height))
+            if border_blending > 1.0:
+                border_blending = 1.0
+            elif border_blending < 0.0:
+                border_blending = 0.0
 
-        mask = mask.filter(ImageFilter.BoxBlur(radius=blend_ratio / 4))
-        mask = mask.filter(ImageFilter.GaussianBlur(radius=blend_ratio / 4))
+            blend_ratio = (max(crop_img.size) / 2) * float(border_blending)
 
-        blend.putalpha(mask)
-        image = Image.alpha_composite(image.convert("RGBA"), blend)
+            blend = img.convert("RGBA")
+            mask = Image.new("L", img.size, 0)
 
-        return (pil2tensor(image.convert("RGB")),)
+            mask_block = Image.new("L", (bb_width, bb_height), 255)
+            mask_block = inset_border(mask_block, int(blend_ratio / 2), (0))
+
+            mask.paste(mask_block, paste_region)
+            log.debug(f"Blend size: {blend.size} | kind {blend.mode}")
+            log.debug(
+                f"Crop image size: {crop_img.size} | kind {crop_img.mode}"
+            )
+            log.debug(f"BBox: {paste_region}")
+            blend.paste(crop_img, paste_region)
+
+            mask = mask.filter(ImageFilter.BoxBlur(radius=blend_ratio / 4))
+            mask = mask.filter(
+                ImageFilter.GaussianBlur(radius=blend_ratio / 4)
+            )
+
+            blend.putalpha(mask)
+            img = Image.alpha_composite(img.convert("RGBA"), blend)
+            out_images.append(img.convert("RGB"))
+
+        return (pil2tensor(out_images),)
 
 
 __nodes__ = [
-    BBoxFromMask,
-    BoundingBox,
-    Crop,
-    Uncrop
-]
+    MTB_BboxFromMask,
+    MTB_Bbox,
+    MTB_Crop,
+    MTB_Uncrop,
+    MTB_SplitBbox,
+    MTB_UpscaleBboxBy,
+]

nodes/curve.py

@@ -0,0 +1,93 @@
+import json
+
+from ..log import log
+
+
+def deserialize_curve(curve):
+    if isinstance(curve, str):
+        curve = json.loads(curve)
+    return curve
+
+
+def serialize_curve(curve):
+    if not isinstance(curve, str):
+        curve = json.dumps(curve)
+    return curve
+
+
+class MTBCurve:
+    """A basic FLOAT_CURVE input node."""
+
+    @classmethod
+    def INPUT_TYPES(cls):
+        return {
+            "required": {
+                "curve": ("FLOAT_CURVE",),
+            },
+        }
+
+    RETURN_TYPES = ("FLOAT_CURVE",)
+    FUNCTION = "do_curve"
+
+    CATEGORY = "mtb/curve"
+
+    def do_curve(self, curve):
+        log.debug(f"Curve: {curve}")
+        return (curve,)
+
+
+class MTB_CurveToFloat:
+    """Convert a FLOAT_CURVE to a FLOAT or FLOATS"""
+
+    @classmethod
+    def INPUT_TYPES(cls):
+        return {
+            "required": {
+                "curve": ("FLOAT_CURVE", {"forceInput": True}),
+                "steps": ("INT", {"default": 10, "min": 2}),
+            },
+        }
+
+    RETURN_TYPES = ("FLOATS", "FLOAT")
+    FUNCTION = "do_curve"
+
+    CATEGORY = "mtb/curve"
+
+    def do_curve(self, curve, steps):
+        log.debug(f"Curve: {curve}")
+
+        # sort by x (should be handled by the widget)
+        sorted_points = sorted(curve.items(), key=lambda item: item[1]["x"])
+        # Extract X and Y values
+        x_values = [point[1]["x"] for point in sorted_points]
+        y_values = [point[1]["y"] for point in sorted_points]
+        # Calculate step size
+        step_size = (max(x_values) - min(x_values)) / (steps - 1)
+
+        # Interpolate Y values for each step
+        interpolated_y_values = []
+        for step in range(steps):
+            current_x = min(x_values) + step_size * step
+
+            # Find the indices of the two points between which the current_x falls
+            idx1 = max(idx for idx, x in enumerate(x_values) if x <= current_x)
+            idx2 = min(idx for idx, x in enumerate(x_values) if x >= current_x)
+
+            # If the current_x matches one of the points, no interpolation is needed
+            if current_x == x_values[idx1]:
+                interpolated_y_values.append(y_values[idx1])
+            elif current_x == x_values[idx2]:
+                interpolated_y_values.append(y_values[idx2])
+            else:
+                # Interpolate Y value using linear interpolation
+                y1 = y_values[idx1]
+                y2 = y_values[idx2]
+                x1 = x_values[idx1]
+                x2 = x_values[idx2]
+                interpolated_y = y1 + (y2 - y1) * (current_x - x1) / (x2 - x1)
+                interpolated_y_values.append(interpolated_y)
+
+        return (interpolated_y_values, interpolated_y_values)
+
+
+__nodes__ = [MTBCurve, MTB_CurveToFloat]

nodes/debug.py

@@ -0,0 +1,215 @@
+import base64
+import io
+import json
+from pathlib import Path
+from typing import Optional
+
+import folder_paths
+import open3d as o3d
+import torch
+
+from ..log import log
+from ..utils import mesh_to_json, tensor2b64
+
+
+# region processors
+def process_tensor(tensor: torch.Tensor):
+    log.debug(f"Tensor: {tensor.shape}")
+
+    return {"b64_images": tensor2b64(tensor)}
+
+
+def process_list(anything: list[object]) -> dict[str, list[str]]:
+    text: list[str] = []
+    if not anything:
+        return {"text": []}
+
+    first_element = anything[0]
+    if (
+        isinstance(first_element, list)
+        and first_element
+        and isinstance(first_element[0], torch.Tensor)
+    ):
+        text.append(
+            "List of List of Tensors: "
+            + f"{first_element[0].shape} (x{len(anything)})"
+        )
+
+    elif isinstance(first_element, torch.Tensor):
+        text.append(
+            f"List of Tensors: {first_element.shape} (x{len(anything)})"
+        )
+    else:
+        text.append(f"Array ({len(anything)}): {anything}")
+
+    return {"text": text}
+
+
+def process_dict(anything: dict[str, dict[str, any]]) -> dict[str, str]:
+    if "mesh" in anything:
+        m = {"geometry": {}}
+        m["geometry"]["mesh"] = mesh_to_json(anything["mesh"])
+        if "material" in anything:
+            m["geometry"]["material"] = anything["material"]
+        return m
+
+    res = []
+    if "samples" in anything:
+        is_empty = (
+            "(empty)" if torch.count_nonzero(anything["samples"]) == 0 else ""
+        )
+        res.append(f"Latent Samples: {anything['samples'].shape} {is_empty}")
+
+    else:
+        text.append(json.dumps(anything, indent=2))
+
+    return {"text": text}
+
+
+def process_bool(anything: bool) -> dict[str, str]:
+    return {"text": ["True" if anything else "False"]}
+
+
+def process_text(anything):
+    return {"text": [str(anything)]}
+
+
+# NOT USED ANYMORE
+def process_geometry(anything):
+    return {"geometry": [mesh_to_json(anything)]}
+
+
+# endregion
+
+
+class MTB_Debug:
+    """Experimental node to debug any Comfy values.
+
+    support for more types and widgets is planned.
+    """
+
+    @classmethod
+    def INPUT_TYPES(cls):
+        return {
+            "required": {"output_to_console": ("BOOLEAN", {"default": False})},
+        }
+
+    RETURN_TYPES = ()
+    FUNCTION = "do_debug"
+    CATEGORY = "mtb/debug"
+    OUTPUT_NODE = True
+
+    def do_debug(self, output_to_console: bool, **kwargs):
+        output = {
+            "ui": {"b64_images": [], "text": [], "geometry": []},
+            # "result": ("A"),
+        }
+
+        processors = {
+            torch.Tensor: process_tensor,
+            list: process_list,
+            dict: process_dict,
+            bool: process_bool,
+            o3d.geometry.Geometry: process_geometry,
+        }
+        if output_to_console:
+            for k, v in kwargs.items():
+                log.info(f"{k}: {v}")
+
+        for anything in kwargs.values():
+            processor = processors.get(type(anything))
+            if processor is None:
+                if isinstance(anything, o3d.geometry.Geometry):
+                    processor = process_geometry
+                else:
+                    processor = process_text
+            log.debug(
+                f"Processing: {anything} with processor: {processor.__name__} for type {type(anything)}"
+            )
+            processed_data = processor(anything)
+
+            for ui_key, ui_value in processed_data.items():
+                if isinstance(ui_value, list):
+                    output["ui"][ui_key].extend(ui_value)
+                else:
+                    output["ui"][ui_key].append(ui_value)
+            # log.debug(
+            #     f"Processed input {k}, found {len(processed_data.get('b64_images', []))} images and {len(processed_data.get('text', []))} text items."
+            # )
+
+        if output_to_console:
+            from rich.console import Console
+
+            cons = Console()
+            cons.print("OUTPUT:")
+            cons.print(output)
+
+        return output
+
+
+class MTB_SaveTensors:
+    """Save torch tensors (image, mask or latent) to disk.
+
+    useful to debug things outside comfy.
+    """
+
+    def __init__(self):
+        self.output_dir = folder_paths.get_output_directory()
+        self.type = "mtb/debug"
+
+    @classmethod
+    def INPUT_TYPES(cls):
+        return {
+            "required": {
+                "filename_prefix": ("STRING", {"default": "ComfyPickle"}),
+            },
+            "optional": {
+                "image": ("IMAGE",),
+                "mask": ("MASK",),
+                "latent": ("LATENT",),
+            },
+        }
+
+    FUNCTION = "save"
+    OUTPUT_NODE = True
+    RETURN_TYPES = ()
+    CATEGORY = "mtb/debug"
+
+    def save(
+        self,
+        filename_prefix,
+        image: Optional[torch.Tensor] = None,
+        mask: Optional[torch.Tensor] = None,
+        latent: Optional[torch.Tensor] = None,
+    ):
+        (
+            full_output_folder,
+            filename,
+            counter,
+            subfolder,
+            filename_prefix,
+        ) = folder_paths.get_save_image_path(filename_prefix, self.output_dir)
+        full_output_folder = Path(full_output_folder)
+        if image is not None:
+            image_file = f"{filename}_image_{counter:05}.pt"
+            torch.save(image, full_output_folder / image_file)
+            # np.save(full_output_folder/ image_file, image.cpu().numpy())
+
+        if mask is not None:
+            mask_file = f"{filename}_mask_{counter:05}.pt"
+            torch.save(mask, full_output_folder / mask_file)
+            # np.save(full_output_folder/ mask_file, mask.cpu().numpy())
+
+        if latent is not None:
+            # for latent we must use pickle
+            latent_file = f"{filename}_latent_{counter:05}.pt"
+            torch.save(latent, full_output_folder / latent_file)
+            # pickle.dump(latent, open(full_output_folder/ latent_file, "wb"))
+
+            # np.save(full_output_folder / latent_file,
+            # latent[""].cpu().numpy())
+
+        return f"{filename_prefix}_{counter:05}"
+
+
+__nodes__ = [MTB_Debug, MTB_SaveTensors]

nodes/deep_bump.py

@@ -1,23 +1,49 @@
-import onnxruntime as ort
+import tempfile
+from pathlib import Path
+
 import numpy as np
-import pathlib
 import onnxruntime as ort
-import numpy as np
-from .. import utils as utils_inference
-from ..log import log
+import torch
+from PIL import Image
+
+from ..errors import ModelNotFound
+from ..log import mklog
+from ..utils import (
+    get_model_path,
+    tensor2pil,
+    tiles_infer,
+    tiles_merge,
+    tiles_split,
+)
 
 # Disable MS telemetry
 ort.disable_telemetry_events()
+log = mklog(__name__)
 
 
 # - COLOR to NORMALS
-def color_to_normals(color_img, overlap, progress_callback):
-    """Computes a normal map from the given color map. 'color_img' must be a numpy array
-    in C,H,W format (with C as RGB). 'overlap' must be one of 'SMALL', 'MEDIUM', 'LARGE'.
+def color_to_normals(
+    color_img, overlap, progress_callback, *, save_temp=False
+):
+    """Compute a normal map from the given color map.
+
+    'color_img' must be a numpy array in C,H,W format (with C as RGB).
+    'overlap' must be one of 'SMALL', 'MEDIUM', 'LARGE'.
     """
+    temp_dir = Path(tempfile.mkdtemp()) if save_temp else None
 
     # Remove alpha & convert to grayscale
-    img = np.mean(color_img[:3], axis=0, keepdimss=True)
+    img = np.mean(color_img[:3], axis=0, keepdims=True)
+
+    if temp_dir:
+        Image.fromarray((img[0] * 255).astype(np.uint8)).save(
+            temp_dir / "grayscale_img.png"
+        )
+
+    log.debug(
+        "Converting color image to grayscale by taking "
+        f"the mean over color channels: {img.shape}"
+    )
 
     # Split image in tiles
     log.debug("DeepBump Color → Normals : tilling")
@@ -28,72 +54,124 @@ def color_to_normals(color_img, overlap, progress_callback):
         "LARGE": tile_size // 2,
     }
     stride_size = tile_size - overlaps[overlap]
-    tiles, paddings = utils_inference.tiles_split(
+    tiles, paddings = tiles_split(
         img, (tile_size, tile_size), (stride_size, stride_size)
     )
+    if temp_dir:
+        for i, tile in enumerate(tiles):
+            Image.fromarray((tile[0] * 255).astype(np.uint8)).save(
+                temp_dir / f"tile_{i}.png"
+            )
 
     # Load model
     log.debug("DeepBump Color → Normals : loading model")
-    addon_path = str(pathlib.Path(__file__).parent.absolute())
-    ort_session = ort.InferenceSession(f"{addon_path}/models/deepbump256.onnx")
+    model = get_model_path("deepbump", "deepbump256.onnx")
+    if not model or not model.exists():
+        raise ModelNotFound(f"deepbump ({model})")
+
+    providers = [
+        "TensorrtExecutionProvider",
+        "CUDAExecutionProvider",
+        "CoreMLProvider",
+        "CPUExecutionProvider",
+    ]
+    available_providers = [
+        provider
+        for provider in providers
+        if provider in ort.get_available_providers()
+    ]
+
+    if not available_providers:
+        raise RuntimeError(
+            "No valid ONNX Runtime providers available on this machine."
+        )
+    log.debug(f"Using ONNX providers: {available_providers}")
+    ort_session = ort.InferenceSession(
+        model.as_posix(), providers=available_providers
+    )
 
     # Predict normal map for each tile
     log.debug("DeepBump Color → Normals : generating")
-    pred_tiles = utils_inference.tiles_infer(
+    pred_tiles = tiles_infer(
         tiles, ort_session, progress_callback=progress_callback
     )
 
+    if temp_dir:
+        for i, pred_tile in enumerate(pred_tiles):
+            Image.fromarray(
+                (pred_tile.transpose(1, 2, 0) * 255).astype(np.uint8)
+            ).save(temp_dir / f"pred_tile_{i}.png")
+
     # Merge tiles
     log.debug("DeepBump Color → Normals : merging")
-    pred_img = utils_inference.tiles_merge(
+    pred_img = tiles_merge(
         pred_tiles,
         (stride_size, stride_size),
         (3, img.shape[1], img.shape[2]),
         paddings,
     )
 
+    if temp_dir:
+        Image.fromarray(
+            (pred_img.transpose(1, 2, 0) * 255).astype(np.uint8)
+        ).save(temp_dir / "merged_img.png")
+
     # Normalize each pixel to unit vector
-    pred_img = utils_inference.normalize(pred_img)
+    pred_img = normalize(pred_img)
+
+    if temp_dir:
+        Image.fromarray(
+            (pred_img.transpose(1, 2, 0) * 255).astype(np.uint8)
+        ).save(temp_dir / "final_img.png")
+
+        log.debug(f"Debug images saved in {temp_dir}")
 
     return pred_img
 
 
 # - NORMALS to CURVATURE
 def conv_1d(array, kernel_1d):
-    """Performs row by row 1D convolutions of the given 2D image with the given 1D kernel."""
+    """Perform row by row 1D convolutions.
 
+    of the given 2D image with the given 1D kernel.
+    """
     # Input kernel length must be odd
     k_l = len(kernel_1d)
+
     assert k_l % 2 != 0
     # Convolution is repeat-padded
     extended = np.pad(array, k_l // 2, mode="wrap")
     # Output has same size as input (padded, valid-mode convolution)
     output = np.empty(array.shape)
     for i in range(array.shape[0]):
-        output[i] = np.convolve(extended[i + (k_l // 2)], kernel_1d, mode="valid")
+        output[i] = np.convolve(
+            extended[i + (k_l // 2)], kernel_1d, mode="valid"
+        )
 
     return output * -1
 
 
 def gaussian_kernel(length, sigma):
-    """Returns a 1D gaussian kernel of size 'length'."""
-
+    """Return a 1D gaussian kernel of size 'length'."""
     space = np.linspace(-(length - 1) / 2, (length - 1) / 2, length)
     kernel = np.exp(-0.5 * np.square(space) / np.square(sigma))
     return kernel / np.sum(kernel)
 
 
 def normalize(np_array):
-    """Normalize all elements of the given numpy array to [0,1]"""
-
-    return (np_array - np.min(np_array)) / (np.max(np_array) - np.min(np_array))
+    """Normalize all elements of the given numpy array to [0,1]."""
+    return (np_array - np.min(np_array)) / (
+        np.max(np_array) - np.min(np_array)
+    )
 
 
 def normals_to_curvature(normals_img, blur_radius, progress_callback):
-    """Computes a curvature map from the given normal map. 'normals_img' must be a numpy array
-    in C,H,W format (with C as RGB). 'blur_radius' must be one of 'SMALLEST', 'SMALLER', 'SMALL',
-    'MEDIUM', 'LARGE', 'LARGER', 'LARGEST'."""
+    """Compute a curvature map from the given normal map.
 
+    'normals_img' must be a numpy array in C,H,W format (with C as RGB).
+    'blur_radius' must be one of:
+        'SMALLEST', 'SMALLER', 'SMALL', 'MEDIUM', 'LARGE', 'LARGER', 'LARGEST'.
+    """
     # Convolutions on normal map red & green channels
     if progress_callback is not None:
         progress_callback(0, 4)
@@ -118,8 +196,12 @@ def normals_to_curvature(normals_img, blur_radius, progress_callback):
         "LARGER": 1 / 8,
         "LARGEST": 1 / 4,
     }
-    assert blur_radius in blur_factors
-    blur_radius_px = int(np.mean(normals_img.shape[1:3]) * blur_factors[blur_radius])
+    if blur_radius not in blur_factors:
+        raise ValueError(f"{blur_radius} not found in {blur_factors}")
+
+    blur_radius_px = int(
+        np.mean(normals_img.shape[1:3]) * blur_factors[blur_radius]
+    )
 
     # If blur radius too small, do not blur
     if blur_radius_px < 2:
@@ -156,8 +238,9 @@ def normals_to_grad(normals_img):
 
 def copy_flip(grad_x, grad_y):
     """Concat 4 flipped copies of input gradients (makes them wrap).
-    Output is twice bigger in both dimensions."""
 
+    Output is twice bigger in both dimensions.
+    """
     grad_x_top = np.hstack([grad_x, -np.flip(grad_x, axis=1)])
     grad_x_bottom = np.hstack([np.flip(grad_x, axis=0), -np.flip(grad_x)])
     new_grad_x = np.vstack([grad_x_top, grad_x_bottom])
@@ -171,7 +254,6 @@ def copy_flip(grad_x, grad_y):
 
 def frankot_chellappa(grad_x, grad_y, progress_callback=None):
     """Frankot-Chellappa depth-from-gradient algorithm."""
-
     if progress_callback is not None:
         progress_callback(0, 3)
 
@@ -211,8 +293,8 @@ def frankot_chellappa(grad_x, grad_y, progress_callback=None):
 def normals_to_height(normals_img, seamless, progress_callback):
     """Computes a height map from the given normal map. 'normals_img' must be a numpy array
     in C,H,W format (with C as RGB). 'seamless' is a bool that should indicates if 'normals_img'
-    is seamless."""
-
+    is seamless.
+    """
     # Flip height axis
     flip_img = np.flip(normals_img, axis=1)
 
@@ -226,7 +308,9 @@ def normals_to_height(normals_img, seamless, progress_callback):
         grad_x, grad_y = copy_flip(grad_x, grad_y)
 
     # Compute height
-    pred_img = frankot_chellappa(-grad_x, grad_y, progress_callback=progress_callback)
+    pred_img = frankot_chellappa(
+        -grad_x, grad_y, progress_callback=progress_callback
+    )
 
     # Cut to valid part if gradients were expanded
     if not seamless:
@@ -238,19 +322,20 @@ def normals_to_height(normals_img, seamless, progress_callback):
 
 
 # - ADDON
-class DeepBump:
+class MTB_DeepBump:
     """Normal & height maps generation from single pictures"""
 
-    def __init__(self):
-        pass
-
     @classmethod
     def INPUT_TYPES(cls):
         return {
             "required": {
                 "image": ("IMAGE",),
                 "mode": (
-                    ["Color to Normals", "Normals to Curvature", "Normals to Height"],
+                    [
+                        "Color to Normals",
+                        "Normals to Curvature",
+                        "Normals to Height",
+                    ],
                 ),
                 "color_to_normals_overlap": (["SMALL", "MEDIUM", "LARGE"],),
                 "normals_to_curvature_blur_radius": (
@@ -264,44 +349,60 @@ class DeepBump:
                         "LARGEST",
                     ],
                 ),
-                "normals_to_height_seamless": (["TRUE", "FALSE"],),
+                "normals_to_height_seamless": ("BOOLEAN", {"default": True}),
             },
         }
 
     RETURN_TYPES = ("IMAGE",)
     FUNCTION = "apply"
 
-    CATEGORY = "image processing"
+    CATEGORY = "mtb/textures"
 
     def apply(
         self,
+        *,
         image,
         mode="Color to Normals",
         color_to_normals_overlap="SMALL",
         normals_to_curvature_blur_radius="SMALL",
-        normals_to_height_seamless="TRUE",
+        normals_to_height_seamless=True,
     ):
-        image = utils_inference.tensor2pil(image)
+        images = tensor2pil(image)
+        out_images = []
 
-        in_img = np.transpose(image, (2, 0, 1)) / 255
+        for image in images:
+            log.debug(f"Input image shape: {image}")
 
-        log.debug(f"Input image shape: {in_img.shape}")
+            in_img = np.transpose(image, (2, 0, 1)) / 255
+            log.debug(f"transposed for deep image shape: {in_img.shape}")
+            out_img = None
 
-        # Apply processing
-        if mode == "Color to Normals":
-            out_img = color_to_normals(in_img, color_to_normals_overlap, None)
-        if mode == "Normals to Curvature":
-            out_img = normals_to_curvature(
-                in_img, normals_to_curvature_blur_radius, None
-            )
-        if mode == "Normals to Height":
-            out_img = normals_to_height(
-                in_img, normals_to_height_seamless == "TRUE", None
-            )
+            # Apply processing
+            if mode == "Color to Normals":
+                out_img = color_to_normals(
+                    in_img, color_to_normals_overlap, None
+                )
+            if mode == "Normals to Curvature":
+                out_img = normals_to_curvature(
+                    in_img, normals_to_curvature_blur_radius, None
+                )
+            if mode == "Normals to Height":
+                out_img = normals_to_height(
+                    in_img, normals_to_height_seamless, None
+                )
 
-        out_img = (np.transpose(out_img, (1, 2, 0)) * 255).astype(np.uint8)
-
-        return (utils_inference.pil2tensor(out_img),)
+            if out_img is not None:
+                log.debug(f"Output image shape: {out_img.shape}")
+                out_images.append(
+                    torch.from_numpy(
+                        np.transpose(out_img, (1, 2, 0)).astype(np.float32)
+                    ).unsqueeze(0)
+                )
+            else:
+                log.error("No out img... This should not happen")
+        for outi in out_images:
+            log.debug(f"Shape fed to utils: {outi.shape}")
+        return (torch.cat(out_images, dim=0),)
 
 
-__nodes__ = [DeepBump]
+__nodes__ = [MTB_DeepBump]

nodes/faceenhance.py

@@ -0,0 +1,294 @@
+import os
+
+import comfy
+import comfy.utils
+import cv2
+import folder_paths
+import numpy as np
+import torch
+from comfy import model_management
+from PIL import Image
+
+from ..log import NullWriter, log
+from ..utils import get_model_path, np2tensor, pil2tensor, tensor2np
+
+
+class MTB_LoadFaceEnhanceModel:
+    """Loads a GFPGan or RestoreFormer model for face enhancement."""
+
+    def __init__(self) -> None:
+        pass
+
+    @classmethod
+    def get_models_root(cls):
+        fr = get_model_path("face_restore")
+        # fr = Path(folder_paths.models_dir) / "face_restore"
+        if fr.exists():
+            return (fr, None)
+
+        um = get_model_path("upscale_models")
+        return (fr, um) if um.exists() else (None, None)
+
+    @classmethod
+    def get_models(cls):
+        fr_models_path, um_models_path = cls.get_models_root()
+
+        if fr_models_path is None and um_models_path is None:
+            if not hasattr(cls, "_warned"):
+                log.warning("Face restoration models not found.")
+                cls._warned = True
+            return []
+        if not fr_models_path.exists():
+            # - fallback to upscale_models
+            if um_models_path.exists():
+                return [
+                    x
+                    for x in um_models_path.iterdir()
+                    if x.name.endswith(".pth")
+                    and ("GFPGAN" in x.name or "RestoreFormer" in x.name)
+                ]
+            return []
+
+        return [
+            x
+            for x in fr_models_path.iterdir()
+            if x.name.endswith(".pth")
+            and ("GFPGAN" in x.name or "RestoreFormer" in x.name)
+        ]
+
+    @classmethod
+    def INPUT_TYPES(cls):
+        return {
+            "required": {
+                "model_name": (
+                    [x.name for x in cls.get_models()],
+                    {"default": "None"},
+                ),
+                "upscale": ("INT", {"default": 1}),
+            },
+            "optional": {"bg_upsampler": ("UPSCALE_MODEL", {"default": None})},
+        }
+
+    RETURN_TYPES = ("FACEENHANCE_MODEL",)
+    RETURN_NAMES = ("model",)
+    FUNCTION = "load_model"
+    CATEGORY = "mtb/facetools"
+    DEPRECATED = True
+
+    def load_model(self, model_name, upscale=2, bg_upsampler=None):
+        from gfpgan import GFPGANer
+
+        basic = "RestoreFormer" not in model_name
+
+        fr_root, um_root = self.get_models_root()
+
+        if bg_upsampler is not None:
+            log.warning(
+                f"Upscale value overridden to {bg_upsampler.scale} from bg_upsampler"
+            )
+            upscale = bg_upsampler.scale
+            bg_upsampler = BGUpscaleWrapper(bg_upsampler)
+
+        sys.stdout = NullWriter()
+        model = GFPGANer(
+            model_path=(
+                (fr_root if fr_root.exists() else um_root) / model_name
+            ).as_posix(),
+            upscale=upscale,
+            arch="clean"
+            if basic
+            else "RestoreFormer",  # or original for v1.0 only
+            channel_multiplier=2,  # 1 for v1.0 only
+            bg_upsampler=bg_upsampler,
+        )
+
+        sys.stdout = sys.__stdout__
+        return (model,)
+
+
+class BGUpscaleWrapper:
+    def __init__(self, upscale_model) -> None:
+        self.upscale_model = upscale_model
+
+    def enhance(self, img: Image.Image, outscale=2):
+        device = model_management.get_torch_device()
+        self.upscale_model.to(device)
+
+        tile = 128 + 64
+        overlap = 8
+
+        imgt = pil2tensor(img)
+        imgt = imgt.movedim(-1, -3).to(device)
+
+        steps = imgt.shape[0] * comfy.utils.get_tiled_scale_steps(
+            imgt.shape[3],
+            imgt.shape[2],
+            tile_x=tile,
+            tile_y=tile,
+            overlap=overlap,
+        )
+
+        log.debug(f"Steps: {steps}")
+
+        pbar = comfy.utils.ProgressBar(steps)
+
+        s = comfy.utils.tiled_scale(
+            imgt,
+            lambda a: self.upscale_model(a),
+            tile_x=tile,
+            tile_y=tile,
+            overlap=overlap,
+            upscale_amount=self.upscale_model.scale,
+            pbar=pbar,
+        )
+
+        self.upscale_model.cpu()
+        s = torch.clamp(s.movedim(-3, -1), min=0, max=1.0)
+        return (tensor2np(s)[0],)
+
+
+class MTB_RestoreFace:
+    """Uses GFPGan to restore faces"""
+
+    def __init__(self) -> None:
+        pass
+
+    RETURN_TYPES = ("IMAGE",)
+    FUNCTION = "restore"
+    CATEGORY = "mtb/facetools"
+    DEPRECATED = True
+
+    @classmethod
+    def INPUT_TYPES(cls):
+        return {
+            "required": {
+                "image": ("IMAGE",),
+                "model": ("FACEENHANCE_MODEL",),
+                # Input are aligned faces
+                "aligned": ("BOOLEAN", {"default": False}),
+                # Only restore the center face
+                "only_center_face": ("BOOLEAN", {"default": False}),
+                # Adjustable weights
+                "weight": ("FLOAT", {"default": 0.5}),
+                "save_tmp_steps": ("BOOLEAN", {"default": True}),
+            },
+            "optional": {
+                "preserve_alpha": ("BOOLEAN", {"default": True}),
+            },
+        }
+
+    def do_restore(
+        self,
+        image: torch.Tensor,
+        model,
+        aligned,
+        only_center_face,
+        weight,
+        save_tmp_steps,
+        preserve_alpha: bool = False,
+    ) -> torch.Tensor:
+        pimage = tensor2np(image)[0]
+        width, height = pimage.shape[1], pimage.shape[0]
+        source_img = cv2.cvtColor(np.array(pimage), cv2.COLOR_RGB2BGR)
+
+        alpha_channel = None
+        if (
+            preserve_alpha and image.size(-1) == 4
+        ):  # Check if the image has an alpha channel
+            alpha_channel = pimage[:, :, 3]
+            pimage = pimage[:, :, :3]  # Remove alpha channel for processing
+
+        sys.stdout = NullWriter()
+        cropped_faces, restored_faces, restored_img = model.enhance(
+            source_img,
+            has_aligned=aligned,
+            only_center_face=only_center_face,
+            paste_back=True,
+            # TODO: weight has no effect in 1.3 and 1.4 (only tested these for now...)
+            weight=weight,
+        )
+        sys.stdout = sys.__stdout__
+        log.warning(f"Weight value has no effect for now. (value: {weight})")
+
+        if save_tmp_steps:
+            self.save_intermediate_images(
+                cropped_faces, restored_faces, height, width
+            )
+        output = None
+        if restored_img is not None:
+            restored_img = cv2.cvtColor(restored_img, cv2.COLOR_BGR2RGB)
+            output = Image.fromarray(restored_img)
+
+            if alpha_channel is not None:
+                alpha_resized = Image.fromarray(alpha_channel).resize(
+                    output.size, Image.LANCZOS
+                )
+                output.putalpha(alpha_resized)
+            # imwrite(restored_img, save_restore_path)
+            return pil2tensor(output)
+        log.warning("No restored image found")
+
+    def restore(
+        self,
+        image: torch.Tensor,
+        model,
+        aligned=False,
+        only_center_face=False,
+        weight=0.5,
+        save_tmp_steps=True,
+        preserve_alpha: bool = False,
+    ) -> tuple[torch.Tensor]:
+        out = [
+            self.do_restore(
+                image[i],
+                model,
+                aligned,
+                only_center_face,
+                weight,
+                save_tmp_steps,
+                preserve_alpha,
+            )
+            for i in range(image.size(0))
+        ]
+
+        if len(out) == 0:
+            raise ValueError("No faces restored")
+        print(f"Restored {len(out)} faces")
+        return (torch.cat(out, dim=0),)
+
+    def get_step_image_path(self, step, idx):
+        (
+            full_output_folder,
+            filename,
+            counter,
+            _subfolder,
+            _filename_prefix,
+        ) = folder_paths.get_save_image_path(
+            f"{step}_{idx:03}",
+            folder_paths.temp_directory,
+        )
+        file = f"{filename}_{counter:05}_.png"
+
+        return os.path.join(full_output_folder, file)
+
+    def save_intermediate_images(
+        self, cropped_faces, restored_faces, height, width
+    ):
+        for idx, (cropped_face, restored_face) in enumerate(
+            zip(cropped_faces, restored_faces, strict=False)
+        ):
+            face_id = idx + 1
+            file = self.get_step_image_path("cropped_faces", face_id)
+            cv2.imwrite(file, cropped_face)
+
+            file = self.get_step_image_path("cropped_faces_restored", face_id)
+            cv2.imwrite(file, restored_face)
+
+            file = self.get_step_image_path("cropped_faces_compare", face_id)
+
+            # save comparison image
+            cmp_img = np.concatenate((cropped_face, restored_face), axis=1)
+            cv2.imwrite(file, cmp_img)
+
+
+__nodes__ = [MTB_RestoreFace, MTB_LoadFaceEnhanceModel]

nodes/faceswap.py

@@ -1,29 +1,104 @@
+# Optional face enhance nodes
 # region imports
-from ifnude import detect
+import sys
 from pathlib import Path
-from PIL import Image
-from typing import List, Set, Tuple
+
+import comfy.model_management as model_management
 import cv2
-import folder_paths
-import glob
 import insightface
 import numpy as np
 import onnxruntime
-import os
-import tempfile
 import torch
+from insightface.model_zoo.inswapper import INSwapper
+from PIL import Image
 
-from ..utils import pil2tensor, tensor2pil
-from ..log import mklog
+from ..errors import ModelNotFound
+from ..log import NullWriter, mklog
+from ..utils import download_antelopev2, get_model_path, pil2tensor, tensor2pil
 
 # endregion
 
-logger = mklog(__name__)
-providers = onnxruntime.get_available_providers()
+log = mklog(__name__)
+
+
+class MTB_LoadFaceAnalysisModel:
+    """Loads a face analysis model"""
+
+    models = []
+
+    @classmethod
+    def INPUT_TYPES(cls):
+        return {
+            "required": {
+                "faceswap_model": (
+                    ["antelopev2", "buffalo_l", "buffalo_m", "buffalo_sc"],
+                    {"default": "buffalo_l"},
+                ),
+            },
+        }
+
+    RETURN_TYPES = ("FACE_ANALYSIS_MODEL",)
+    FUNCTION = "load_model"
+    CATEGORY = "mtb/facetools"
+    DEPRECATED = True
+
+    def load_model(self, faceswap_model: str):
+        if faceswap_model == "antelopev2":
+            download_antelopev2()
+
+        face_analyser = insightface.app.FaceAnalysis(
+            name=faceswap_model,
+            root=get_model_path("insightface").as_posix(),
+        )
+        return (face_analyser,)
+
+
+class MTB_LoadFaceSwapModel:
+    """Loads a faceswap model"""
+
+    @staticmethod
+    def get_models() -> list[Path]:
+        models_path = get_model_path("insightface")
+        if models_path.exists():
+            models = models_path.iterdir()
+            return [x for x in models if x.suffix in [".onnx", ".pth"]]
+        return []
+
+    @classmethod
+    def INPUT_TYPES(cls):
+        return {
+            "required": {
+                "faceswap_model": (
+                    [x.name for x in cls.get_models()],
+                    {"default": "None"},
+                ),
+            },
+        }
+
+    RETURN_TYPES = ("FACESWAP_MODEL",)
+    FUNCTION = "load_model"
+    CATEGORY = "mtb/facetools"
+    DEPRECATED = True
+
+    def load_model(self, faceswap_model: str):
+        model_path = get_model_path("insightface", faceswap_model)
+        if not model_path or not model_path.exists():
+            raise ModelNotFound(f"{faceswap_model} ({model_path})")
+
+        log.info(f"Loading model {model_path}")
+        return (
+            INSwapper(
+                model_path,
+                onnxruntime.InferenceSession(
+                    path_or_bytes=model_path,
+                    providers=onnxruntime.get_available_providers(),
+                ),
+            ),
+        )
 
 
 # region roop node
-class FaceSwap:
+class MTB_FaceSwap:
     """Face swap using deepinsight/insightface models"""
 
     model = None
@@ -32,13 +107,6 @@ class FaceSwap:
     def __init__(self) -> None:
         pass
 
-    @staticmethod
-    def get_models() -> List[Path]:
-        models_path = os.path.join(folder_paths.models_dir, "insightface/*")
-        models = glob.glob(models_path)
-        models = [Path(x) for x in models if x.endswith(".onnx") or x.endswith(".pth")]
-        return models
-
     @classmethod
     def INPUT_TYPES(cls):
         return {
@@ -46,39 +114,58 @@ class FaceSwap:
                 "image": ("IMAGE",),
                 "reference": ("IMAGE",),
                 "faces_index": ("STRING", {"default": "0"}),
-                "faceswap_model": (
-                    [x.name for x in cls.get_models()],
+                "faceanalysis_model": (
+                    "FACE_ANALYSIS_MODEL",
                     {"default": "None"},
                 ),
+                "faceswap_model": ("FACESWAP_MODEL", {"default": "None"}),
+            },
+            "optional": {
+                "preserve_alpha": ("BOOLEAN", {"default": True}),
             },
-            "optional": {"debug": (["true", "false"], {"default": "false"})},
         }
 
     RETURN_TYPES = ("IMAGE",)
     FUNCTION = "swap"
-    CATEGORY = "face"
+    CATEGORY = "mtb/facetools"
+    DEPRECATED = True
 
     def swap(
         self,
         image: torch.Tensor,
         reference: torch.Tensor,
         faces_index: str,
-        faceswap_model: str,
-        debug: str,
+        faceanalysis_model,
+        faceswap_model,
+        preserve_alpha=False,
     ):
         def do_swap(img):
-            img = tensor2pil(img)
-            ref = tensor2pil(reference)
+            model_management.throw_exception_if_processing_interrupted()
+            img = tensor2pil(img)[0]
+            ref = tensor2pil(reference)[0]
+
+            alpha_channel = None
+            if preserve_alpha and img.mode == "RGBA":
+                alpha_channel = img.getchannel("A")
+                img = img.convert("RGB")
+
             face_ids = {
-                int(x) for x in faces_index.strip(",").split(",") if x.isnumeric()
+                int(x)
+                for x in faces_index.strip(",").split(",")
+                if x.isnumeric()
             }
-            model = self.getFaceSwapModel(faceswap_model)
-            swapped = swap_face(ref, img, model, face_ids)
+            sys.stdout = NullWriter()
+            swapped = swap_face(
+                faceanalysis_model, ref, img, faceswap_model, face_ids
+            )
+            sys.stdout = sys.__stdout__
+            if alpha_channel:
+                swapped.putalpha(alpha_channel)
             return pil2tensor(swapped)
 
         batch_count = image.size(0)
 
-        logger.info(f"Running insightface swap (batch size: {batch_count})")
+        log.info(f"Running insightface swap (batch size: {batch_count})")
 
         if reference.size(0) != 1:
             raise ValueError("Reference image must have batch size 1")
@@ -86,38 +173,31 @@ class FaceSwap:
             image = do_swap(image)
 
         else:
-            image = [do_swap(image[i]) for i in range(batch_count)]
-            image = torch.cat(image, dim=0)
+            image_batch = [do_swap(image[i]) for i in range(batch_count)]
+            image = torch.cat(image_batch, dim=0)
 
         return (image,)
 
-    def getFaceSwapModel(self, model_path: str):
-        model_path = os.path.join(folder_paths.models_dir, "insightface", model_path)
-        if self.model_path is None or self.model_path != model_path:
-            logger.info(f"Loading model {model_path}")
-            self.model_path = model_path
-            self.model = insightface.model_zoo.get_model(
-                model_path, providers=providers
-            )
-        else:
-            logger.info("Using cached model")
-
-        logger.info("Model loaded")
-        return self.model
-
 
 # endregion
 
 
 # region face swap utils
-def get_face_single(img_data: np.ndarray, face_index=0, det_size=(640, 640)):
-    face_analyser = insightface.app.FaceAnalysis(name="buffalo_l", providers=providers)
+def get_face_single(
+    face_analyser, img_data: np.ndarray, face_index=0, det_size=(640, 640)
+):
     face_analyser.prepare(ctx_id=0, det_size=det_size)
     face = face_analyser.get(img_data)
 
     if len(face) == 0 and det_size[0] > 320 and det_size[1] > 320:
+        log.debug("No face ed, trying again with smaller image")
         det_size_half = (det_size[0] // 2, det_size[1] // 2)
-        return get_face_single(img_data, face_index=face_index, det_size=det_size_half)
+        return get_face_single(
+            face_analyser,
+            img_data,
+            face_index=face_index,
+            det_size=det_size_half,
+        )
 
     try:
         return sorted(face, key=lambda x: x.bbox[0])[face_index]
@@ -125,59 +205,51 @@ def get_face_single(img_data: np.ndarray, face_index=0, det_size=(640, 640)):
         return None
 
 
-def convert_to_sd(img) -> Tuple[bool, str]:
-    chunks = detect(img)
-    shapes = [chunk["score"] > 0.7 for chunk in chunks]
-    return [any(shapes), tempfile.NamedTemporaryFile(delete=False, suffix=".png")]
-
-
 def swap_face(
-    source_img: Image.Image,
-    target_img: Image.Image,
-    face_swapper_model=None,
-    faces_index: Set[int] = None,
+    face_analyser,
+    source_img: Image.Image | list[Image.Image],
+    target_img: Image.Image | list[Image.Image],
+    face_swapper_model,
+    faces_index: set[int] | None = None,
 ) -> Image.Image:
     if faces_index is None:
         faces_index = {0}
-    logger.info(f"Swapping faces: {faces_index}")
+    log.debug(f"Swapping faces: {faces_index}")
     result_image = target_img
-    converted = convert_to_sd(target_img)
-    scale, fn = converted[0], converted[1]
-    if face_swapper_model is not None and not scale:
-        if isinstance(source_img, str):  # source_img is a base64 string
-            import base64, io
 
-            if (
-                "base64," in source_img
-            ):  # check if the base64 string has a data URL scheme
-                base64_data = source_img.split("base64,")[-1]
-                img_bytes = base64.b64decode(base64_data)
-            else:
-                # if no data URL scheme, just decode
-                img_bytes = base64.b64decode(source_img)
-            source_img = Image.open(io.BytesIO(img_bytes))
-        source_img = cv2.cvtColor(np.array(source_img), cv2.COLOR_RGB2BGR)
-        target_img = cv2.cvtColor(np.array(target_img), cv2.COLOR_RGB2BGR)
-        source_face = get_face_single(source_img, face_index=0)
+    if face_swapper_model is not None:
+        cv_source_img = cv2.cvtColor(np.array(source_img), cv2.COLOR_RGB2BGR)
+        cv_target_img = cv2.cvtColor(np.array(target_img), cv2.COLOR_RGB2BGR)
+        source_face = get_face_single(
+            face_analyser, cv_source_img, face_index=0
+        )
         if source_face is not None:
-            result = target_img
+            result = cv_target_img
 
             for face_num in faces_index:
-                target_face = get_face_single(target_img, face_index=face_num)
+                target_face = get_face_single(
+                    face_analyser, cv_target_img, face_index=face_num
+                )
                 if target_face is not None:
-                    result = face_swapper_model.get(result, target_face, source_face)
+                    sys.stdout = NullWriter()
+                    result = face_swapper_model.get(
+                        result, target_face, source_face
+                    )
+                    sys.stdout = sys.__stdout__
                 else:
-                    logger.warning(f"No target face found for {face_num}")
+                    log.warning(f"No target face found for {face_num}")
 
-            result_image = Image.fromarray(cv2.cvtColor(result, cv2.COLOR_BGR2RGB))
+            result_image = Image.fromarray(
+                cv2.cvtColor(result, cv2.COLOR_BGR2RGB)
+            )
         else:
-            logger.warning("No source face found")
+            log.warning("No source face found")
     else:
-        logger.error("No face swap model provided")
+        log.error("No face swap model provided")
     return result_image
 
 
 # endregion face swap utils
 
 
-__nodes__ = [FaceSwap]
+__nodes__ = [MTB_FaceSwap, MTB_LoadFaceSwapModel, MTB_LoadFaceAnalysisModel]

nodes/filter.py

@@ -0,0 +1,69 @@
+import torch
+
+
+class MTBFilterZ:
+    """Filters an image based on a depth map."""
+
+    @classmethod
+    def INPUT_TYPES(cls):
+        return {
+            "required": {
+                "image": ("IMAGE",),
+                "depth": ("IMAGE",),
+                "to_black": ("BOOLEAN", {"default": True}),
+                "threshold": (
+                    "FLOAT",
+                    {"default": 0.5, "step": 0.01, "min": 0.0, "max": 1.0},
+                ),
+                "invert": ("BOOLEAN", {"default": True}),
+            },
+        }
+
+    RETURN_TYPES = ("IMAGE",)
+    FUNCTION = "filter"
+    CATEGORY = "mtb/filters"
+
+    def filter(
+        self,
+        image: torch.Tensor,
+        depth: torch.Tensor,
+        to_black,
+        threshold: float,
+        invert,
+    ):
+        # Normalize depth map to be in range [0, 1]
+        depth_normalized = (depth - depth.min()) / (depth.max() - depth.min())
+
+        # Calculate the difference from the threshold
+        diff_from_threshold = torch.abs(depth_normalized - threshold)
+
+        out_img = None
+
+        if to_black:
+            if invert:
+                soft_mask = diff_from_threshold >= threshold
+            else:
+                soft_mask = diff_from_threshold <= threshold
+
+            out_img = image.clone()
+            out_img[soft_mask] = 0
+            return (out_img,)
+        else:
+            alpha_channel = 1 - diff_from_threshold / threshold
+            alpha_channel = torch.clamp(alpha_channel, 0, 1)
+
+            if invert:
+                # Invert the alpha channel
+                alpha_channel = 1 - alpha_channel
+
+            # Ensure alpha_channel has the correct shape
+            # It should have the shape [batch_size, height, width, 1]
+            alpha_channel = alpha_channel.unsqueeze(-1)
+
+            # Combine RGB channels with alpha channel
+            out_img = torch.cat((image, alpha_channel), dim=-1)
+
+        return (out_img,)
+
+
+__nodes__ = [MTBFilterZ]

nodes/generate.py

@@ -0,0 +1,327 @@
+from PIL import Image
+
+from ..log import log
+from ..utils import comfy_dir, create_uv_map_tensor, font_path, pil2tensor
+
+# class MtbExamples:
+#     """MTB Example Images"""
+
+#     def __init__(self):
+#         pass
+
+#     @classmethod
+#     @lru_cache(maxsize=1)
+#     def get_root(cls):
+#         return here / "examples" / "samples"
+
+#     @classmethod
+#     def INPUT_TYPES(cls):
+#         input_dir = cls.get_root()
+#         files = [f.name for f in input_dir.iterdir() if f.is_file()]
+#         return {
+#             "required": {"image": (sorted(files),)},
+#         }
+
+#     RETURN_TYPES = ("IMAGE", "MASK")
+#     FUNCTION = "do_mtb_examples"
+#     CATEGORY = "fun"
+
+#     def do_mtb_examples(self, image, index):
+#         image_path = (self.get_root() / image).as_posix()
+
+#         i = Image.open(image_path)
+#         i = ImageOps.exif_transpose(i)
+#         image = i.convert("RGB")
+#         image = np.array(image).astype(np.float32) / 255.0
+#         image = torch.from_numpy(image)[None,]
+#         if "A" in i.getbands():
+#             mask = np.array(i.getchannel("A")).astype(np.float32) / 255.0
+#             mask = 1.0 - torch.from_numpy(mask)
+#         else:
+#             mask = torch.zeros((64, 64), dtype=torch.float32, device="cpu")
+#         return (image, mask)
+
+#     @classmethod
+#     def IS_CHANGED(cls, image):
+#         image_path = (cls.get_root() / image).as_posix()
+
+#         m = hashlib.sha256()
+#         with open(image_path, "rb") as f:
+#             m.update(f.read())
+#         return m.digest().hex()
+
+
+class MTB_UnsplashImage:
+    """Unsplash Image given a keyword and a size"""
+
+    @classmethod
+    def INPUT_TYPES(cls):
+        return {
+            "required": {
+                "width": (
+                    "INT",
+                    {"default": 512, "max": 8096, "min": 0, "step": 1},
+                ),
+                "height": (
+                    "INT",
+                    {"default": 512, "max": 8096, "min": 0, "step": 1},
+                ),
+                "random_seed": (
+                    "INT",
+                    {"default": 0, "max": 1e5, "min": 0, "step": 1},
+                ),
+            },
+            "optional": {
+                "keyword": ("STRING", {"default": "nature"}),
+            },
+        }
+
+    RETURN_TYPES = ("IMAGE",)
+    FUNCTION = "do_unsplash_image"
+    CATEGORY = "mtb/generate"
+
+    def do_unsplash_image(self, width, height, random_seed, keyword=None):
+        import io
+
+        import requests
+
+        base_url = "https://source.unsplash.com/random/"
+
+        if width and height:
+            base_url += f"/{width}x{height}"
+
+        if keyword:
+            keyword = keyword.replace(" ", "%20")
+            base_url += f"?{keyword}&{random_seed}"
+        else:
+            base_url += f"?&{random_seed}"
+        try:
+            log.debug(f"Getting unsplash image from {base_url}")
+            response = requests.get(base_url)
+            response.raise_for_status()
+
+            image = Image.open(io.BytesIO(response.content))
+            return (
+                pil2tensor(
+                    image,
+                ),
+            )
+
+        except requests.exceptions.RequestException as e:
+            print("Error retrieving image:", e)
+            return (None,)
+
+
+def bbox_dim(bbox):
+    left, upper, right, lower = bbox
+    width = right - left
+    height = lower - upper
+    return width, height
+
+
+# TODO: Auto install the base font to ComfyUI/fonts
+
+
+class MTB_TextToImage:
+    """Utils to convert text to image using a font.
+
+    The tool looks for any .ttf file in the Comfy folder hierarchy.
+    """
+
+    fonts = {}
+    DESCRIPTION = """# Text to Image
+
+This node look for any font files in comfy_dir/fonts.
+by default it fallsback to a default font.
+
+![img](https://i.imgur.com/3GT92hy.gif)
+"""
+
+    def __init__(self):
+        # - This is executed when the graph is executed,
+        # - we could conditionaly reload fonts there
+        pass
+
+    @classmethod
+    def CACHE_FONTS(cls):
+        font_extensions = ["*.ttf", "*.otf", "*.woff", "*.woff2", "*.eot"]
+        fonts = [font_path]
+
+        for extension in font_extensions:
+            try:
+                if comfy_dir.exists():
+                    fonts.extend(comfy_dir.glob(f"fonts/**/{extension}"))
+                else:
+                    log.warn(f"Directory {comfy_dir} does not exist.")
+            except Exception as e:
+                log.error(f"Error during font caching: {e}")
+
+        for font in fonts:
+            log.debug(f"Adding font {font}")
+            MTB_TextToImage.fonts[font.stem] = font.as_posix()
+
+    @classmethod
+    def INPUT_TYPES(cls):
+        if not cls.fonts:
+            cls.CACHE_FONTS()
+        else:
+            log.debug(f"Using cached fonts (count: {len(cls.fonts)})")
+        return {
+            "required": {
+                "text": (
+                    "STRING",
+                    {"default": "Hello world!"},
+                ),
+                "font": ((sorted(cls.fonts.keys())),),
+                "wrap": ("BOOLEAN", {"default": True}),
+                "trim": ("BOOLEAN", {"default": True}),
+                "line_height": (
+                    "FLOAT",
+                    {"default": 1.0, "min": 0, "step": 0.1},
+                ),
+                "font_size": (
+                    "INT",
+                    {"default": 32, "min": 1, "max": 2500, "step": 1},
+                ),
+                "width": (
+                    "INT",
+                    {"default": 512, "min": 1, "max": 8096, "step": 1},
+                ),
+                "height": (
+                    "INT",
+                    {"default": 512, "min": 1, "max": 8096, "step": 1},
+                ),
+                "color": (
+                    "COLOR",
+                    {"default": "#000000"},
+                ),
+                "background": (
+                    "COLOR",
+                    {"default": "#FFFFFF"},
+                ),
+                "h_align": (("left", "center", "right"), {"default": "left"}),
+                "v_align": (("top", "center", "bottom"), {"default": "top"}),
+                "h_offset": (
+                    "INT",
+                    {"default": 0, "min": 0, "max": 8096, "step": 1},
+                ),
+                "v_offset": (
+                    "INT",
+                    {"default": 0, "min": 0, "max": 8096, "step": 1},
+                ),
+                "h_coverage": (
+                    "INT",
+                    {"default": 100, "min": 1, "max": 100, "step": 1},
+                ),
+            }
+        }
+
+    RETURN_TYPES = ("IMAGE",)
+    RETURN_NAMES = ("image",)
+    FUNCTION = "text_to_image"
+    CATEGORY = "mtb/generate"
+
+    def text_to_image(
+        self,
+        text: str,
+        font,
+        wrap,
+        trim,
+        line_height,
+        font_size,
+        width,
+        height,
+        color,
+        background,
+        h_align="left",
+        v_align="top",
+        h_offset=0,
+        v_offset=0,
+        h_coverage=100,
+    ):
+        import textwrap
+
+        from PIL import Image, ImageDraw, ImageFont
+
+        font_path = self.fonts[font]
+
+        text = (
+            text.encode("ascii", "ignore").decode().strip() if trim else text
+        )
+        # Handle word wrapping
+        if wrap:
+            wrap_width = (((width / 100) * h_coverage) / font_size) * 2
+            lines = textwrap.wrap(text, width=wrap_width)
+        else:
+            lines = [text]
+        font = ImageFont.truetype(font_path, size=font_size)
+        log.debug(f"Lines: {lines}")
+        img = Image.new("RGBA", (width, height), background)
+        draw = ImageDraw.Draw(img)
+
+        line_height_px = line_height * font_size
+
+        # Vertical alignment
+        if v_align == "top":
+            y_text = v_offset
+        elif v_align == "center":
+            y_text = ((height - (line_height_px * len(lines))) // 2) + v_offset
+        else:  # bottom
+            y_text = (height - (line_height_px * len(lines))) - v_offset
+
+        def get_width(line):
+            if hasattr(font, "getsize"):
+                return font.getsize(line)[0]
+            else:
+                return font.getlength(line)
+
+        # Draw each line of text
+        for line in lines:
+            line_width = get_width(line)
+            # Horizontal alignment
+            if h_align == "left":
+                x_text = h_offset
+            elif h_align == "center":
+                x_text = ((width - line_width) // 2) + h_offset
+            else:  # right
+                x_text = (width - line_width) - h_offset
+
+            draw.text((x_text, y_text), line, fill=color, font=font)
+            y_text += line_height_px
+
+        return (pil2tensor(img),)
+
+
+class MTB_UvMap:
+    """Generates a UV Map tensor given a widht and height"""
+
+    @classmethod
+    def INPUT_TYPES(cls):
+        return {
+            "required": {
+                "width": (
+                    "INT",
+                    {"default": 512, "min": 1, "max": 8096, "step": 1},
+                ),
+                "height": (
+                    "INT",
+                    {"default": 512, "min": 1, "max": 8096, "step": 1},
+                ),
+            }
+        }
+
+    RETURN_TYPES = ("UV_MAP",)
+    RETURN_NAMES = ("uv_map",)
+    FUNCTION = "create_uv_map"
+    CATEGORY = "mtb/generate"
+
+    def create_uv_map(self, width, height):
+        return (create_uv_map_tensor(width, height),)
+
+
+__nodes__ = [
+    MTB_UnsplashImage,
+    MTB_TextToImage,
+    MTB_UvMap,
+    #  MtbExamples,
+]

nodes/geo_tools.py

@@ -0,0 +1,576 @@
+import os
+
+import numpy as np
+import open3d as o3d
+
+from ..utils import (
+    create_box,
+    get_transformation_matrix,
+    log,
+    spread_geo,
+    tensor2b64,
+)
+
+# create_grid,
+# create_sphere,
+# create_torus,
+# mesh_to_json,
+# json_to_mesh
+# rotate_mesh,
+# euler_to_rotation_matrix,
+
+
+# class GeoPrimitive:
+#     """Primitive 3D geometry"""
+
+#     @classmethod
+#     def INPUT_TYPES(cls):
+#         return {
+#             "required": {
+#                 "kind": (["Box", "Sphere", "Cylinder", "Torus"], {"default": "Box"})
+#             }
+#         }
+
+#     RETURN_TYPES = ("UV_MAP",)
+#     RETURN_NAMES = ("uv_map",)
+#     FUNCTION = "distort_uvs"
+#     CATEGORY = "mtb/uv"
+
+
+def default_material(color=None):
+    return {
+        "color": color or "#00ff00",
+        "roughness": 1.0,
+        "metalness": 0.0,
+        "emissive": "#000000",
+        "displacementScale": 1.0,
+        "displacementMap": None,
+    }
+
+
+class MTB_Camera:
+    """Make a Camera."""
+
+    @classmethod
+    def INPUT_TYPES(cls):
+        base = default_material()
+        return {
+            "required": {
+                "color": ("COLOR", {"default": base["color"]}),
+                "roughness": (
+                    "FLOAT",
+                    {
+                        "default": base["roughness"],
+                        "min": 0.005,
+                        "max": 4.0,
+                        "step": 0.01,
+                    },
+                ),
+                "flatShading": ("BOOLEAN",),
+                "metalness": (
+                    "FLOAT",
+                    {
+                        "default": base["metalness"],
+                        "min": 0.0,
+                        "max": 1.0,
+                        "step": 0.01,
+                    },
+                ),
+                "emissive": ("COLOR", {"default": base["emissive"]}),
+                "displacementScale": (
+                    "FLOAT",
+                    {"default": 1.0, "min": -10.0, "max": 10.0},
+                ),
+            },
+            "optional": {"displacementMap": ("IMAGE",)},
+        }
+
+    RETURN_TYPES = ("CAMERA",)
+    RETURN_NAMES = ("camera",)
+    FUNCTION = "make_camera"
+    CATEGORY = "mtb/3D"
+
+    def make_camera(self, **kwargs):
+        return (kwargs,)
+
+
+class MTB_GeometryDraw:
+    @classmethod
+    def INPUT_TYPES(cls):
+        return {
+            "required": {
+                "geometry": ("GEOMETRY",),
+            },
+            "optional": {
+                "camera": ("CAMERA",),
+            },
+        }
+
+    RETURN_TYPES = ("IMAGE",)
+    RETURN_NAMES = ("rendered_image",)
+    FUNCTION = "render"
+    CATEGORY = "mtb/3D"
+
+    def render(self, geometry, camera):
+        mesh, material = spread_geo(geometry)
+        o3d.visualization.draw_geometries([mesh], **camera)
+
+
+# class MTB_RGBD_Image:
+#     @classmethod
+#     def INPUT_TYPES(cls):
+#         return {
+#             "required": {
+#                 "image": ("IMAGE",),
+#                 "depth": ("IMAGE",),
+#             }
+#         }
+
+#     RETURN_TYPES = ("RGBD_IMAGE",)
+#     RETURN_NAMES = ("rgbd",)
+#     FUNCTION = "make_rgbd"
+#     CATEGORY = "mtb/3D"
+
+#     def make_rgbd(self, image, depth):
+#         color_raw = o3d.io.read_image("../../test_data/RGBD/color/00000.jpg")
+#         depth_raw = o3d.io.read_image("../../test_data/RGBD/depth/00000.png")
+#         rgbd_image = o3d.geometry.RGBDImage.create_from_color_and_depth(
+#             color_raw, depth_raw
+#         )
+#         print(rgbd_image)
+
+
+class MTB_GeometryMaterial:
+    """Make a std material."""
+
+    @classmethod
+    def INPUT_TYPES(cls):
+        base = default_material()
+        return {
+            "required": {
+                "color": ("COLOR", {"default": base["color"]}),
+                "roughness": (
+                    "FLOAT",
+                    {
+                        "default": base["roughness"],
+                        "min": 0.005,
+                        "max": 4.0,
+                        "step": 0.01,
+                    },
+                ),
+                "flatShading": ("BOOLEAN",),
+                "metalness": (
+                    "FLOAT",
+                    {
+                        "default": base["metalness"],
+                        "min": 0.0,
+                        "max": 1.0,
+                        "step": 0.01,
+                    },
+                ),
+                "emissive": ("COLOR", {"default": base["emissive"]}),
+                "displacementScale": (
+                    "FLOAT",
+                    {"default": 1.0, "min": -10.0, "max": 10.0},
+                ),
+            },
+            "optional": {"displacementMap": ("IMAGE",)},
+        }
+
+    RETURN_TYPES = ("GEO_MATERIAL",)
+    RETURN_NAMES = ("material",)
+    FUNCTION = "make_material"
+    CATEGORY = "mtb/3D"
+
+    def make_material(
+        self, **kwargs
+    ):  # color, roughness, metalness, emissive, displacementScalen displacementMap=None):
+        # TODO: convert image to b64 and remove the key/add the B64 one
+        # TODO: we can just use the "wireframe" property instead of my current solution
+        if kwargs.get("displacementMap") is not None:
+            tens = kwargs.pop("displacementMap")
+            # TODO: alert about batch size > 1 ?
+            b64images = tensor2b64(tens)[0]
+            kwargs["displacementB64"] = b64images
+
+        return (kwargs,)
+
+
+class MTB_GeometryApplyMaterial:
+    """Apply a Material to a geometry."""
+
+    @classmethod
+    def INPUT_TYPES(cls):
+        return {
+            "required": {
+                "geometry": ("GEOMETRY",),
+                "color": ("COLOR", {"default": "#000000"}),
+            },
+            "optional": {"material": ("GEO_MATERIAL",)},
+        }
+
+    RETURN_TYPES = ("GEOMETRY",)
+    RETURN_NAMES = ("geometry",)
+    FUNCTION = "apply"
+    CATEGORY = "mtb/3D"
+
+    def apply(
+        self,
+        geometry,
+        color,
+        material=None,
+    ):
+        if material is None:
+            material = default_material(color)
+        #
+        geometry["material"] = material
+
+        return (geometry,)
+
+
+class MTB_GeometryTransform:
+    """Transforms the input geometry."""
+
+    @classmethod
+    def INPUT_TYPES(cls):
+        return {
+            "required": {
+                "mesh": ("GEOMETRY",),
+                "position_x": (
+                    "FLOAT",
+                    {"default": 0.0, "step": 0.1, "min": -10000, "max": 10000},
+                ),
+                "position_y": (
+                    "FLOAT",
+                    {"default": 0.0, "step": 0.1, "min": -10000, "max": 10000},
+                ),
+                "position_z": (
+                    "FLOAT",
+                    {"default": 0.0, "step": 0.1, "min": -10000, "max": 10000},
+                ),
+                "rotation_x": (
+                    "FLOAT",
+                    {"default": 0.0, "step": 1, "min": -10000, "max": 10000},
+                ),
+                "rotation_y": (
+                    "FLOAT",
+                    {"default": 0.0, "step": 1, "min": -10000, "max": 10000},
+                ),
+                "rotation_z": (
+                    "FLOAT",
+                    {"default": 0.0, "step": 1, "min": -10000, "max": 10000},
+                ),
+                "scale_x": ("FLOAT", {"default": 1.0, "step": 0.1}),
+                "scale_y": ("FLOAT", {"default": 1.0, "step": 0.1}),
+                "scale_z": ("FLOAT", {"default": 1.0, "step": 0.1}),
+            }
+        }
+
+    RETURN_TYPES = ("GEOMETRY",)
+    RETURN_NAMES = ("geometry",)
+    FUNCTION = "transform_geometry"
+    CATEGORY = "mtb/3D"
+
+    def transform_geometry(
+        self,
+        mesh: o3d.geometry.TriangleMesh,
+        position_x=0.0,
+        position_y=0.0,
+        position_z=0.0,
+        rotation_x=0,
+        rotation_y=0,
+        rotation_z=0,
+        scale_x=1,
+        scale_y=1,
+        scale_z=1,
+    ):
+        # mesh = o3d.geometry.TriangleMesh.create_box(
+        #     width,
+        #     height,
+        #     depth,
+
+        # )
+        # mesh.compute_vertex_normals()
+
+        position = np.array([position_x, position_y, position_z])
+        rotation = (rotation_x, rotation_y, rotation_z)
+        scale = np.array([scale_x, scale_y, scale_z])
+
+        transformation_matrix = get_transformation_matrix(
+            position, rotation, scale
+        )
+        mesh, material = spread_geo(mesh, cp=True)
+
+        return (
+            {
+                "mesh": mesh.transform(transformation_matrix),
+                "material": material,
+            },
+        )
+
+
+class MTB_GeometrySphere:
+    """Makes a Sphere 3D geometry.."""
+
+    @classmethod
+    def INPUT_TYPES(cls):
+        return {
+            "required": {
+                "create_uv_map": ("BOOLEAN", {"default": True}),
+                "radius": ("FLOAT", {"default": 1.0, "step": 0.1}),
+                "resolution": ("INT", {"default": 20, "min": 1}),
+            }
+        }
+
+    RETURN_TYPES = ("GEOMETRY",)
+    RETURN_NAMES = ("geometry",)
+    FUNCTION = "make_sphere"
+    CATEGORY = "mtb/3D"
+
+    def make_sphere(self, create_uv_map, radius, resolution):
+        mesh = o3d.geometry.TriangleMesh.create_sphere(
+            radius,
+            resolution,
+            create_uv_map,
+        )
+        mesh.compute_vertex_normals()
+
+        return ({"mesh": mesh},)
+
+
+class MTB_GeometryTest:
+    """Fetches an Open3D data geometry.."""
+
+    @classmethod
+    def INPUT_TYPES(cls):
+        return {
+            "required": {
+                "name": (
+                    [
+                        "ArmadilloMesh",
+                        "AvocadoModel",
+                        "BunnyMesh",
+                        "CrateModel",
+                        "DamagedHelmetModel",
+                        "FlightHelmetModel",
+                        "KnotMesh",
+                        "MonkeyModel",
+                        "SwordModel",
+                    ],
+                    {
+                        "default": "KnotMesh",
+                    },
+                )
+            }
+        }
+
+    RETURN_TYPES = ("GEOMETRY",)
+    RETURN_NAMES = ("geometry",)
+    FUNCTION = "fetch_data"
+    CATEGORY = "mtb/3D"
+
+    def fetch_data(self, name):
+        model = getattr(o3d.data, name)()
+        mesh = o3d.io.read_triangle_mesh(model.path)
+        mesh.compute_vertex_normals()
+        return ({"mesh": mesh},)
+
+
+class MTB_GeometryBox:
+    """Makes a Box 3D geometry."""
+
+    @classmethod
+    def INPUT_TYPES(cls):
+        return {
+            "required": {
+                # "create_uv_map": ("BOOLEAN", {"default": True}),
+                "uniform_scale": ("FLOAT", {"default": 1.0, "step": 0.1}),
+                "width": ("FLOAT", {"default": 1.0, "step": 0.05}),
+                "height": ("FLOAT", {"default": 1.0, "step": 0.05}),
+                "depth": ("FLOAT", {"default": 1.0, "step": 0.05}),
+                "divisions_x": ("INT", {"default": 1}),
+                "divisions_y": ("INT", {"default": 1}),
+                "divisions_z": ("INT", {"default": 1}),
+            }
+        }
+
+    RETURN_TYPES = ("GEOMETRY",)
+    RETURN_NAMES = ("geometry",)
+    FUNCTION = "make_box"
+    CATEGORY = "mtb/3D"
+
+    def make_box(
+        self,
+        uniform_scale,
+        width,
+        height,
+        depth,
+        divisions_x,
+        divisions_y,
+        divisions_z,
+    ):
+        width, height, depth = (width, height, depth) * uniform_scale
+
+        # mesh = o3d.geometry.TriangleMesh.create_box(
+        #     width,
+        #     height,
+        #     depth,
+
+        # )
+        # mesh.compute_vertex_normals()
+
+        mesh = create_box(
+            (width, height, depth), (divisions_x, divisions_y, divisions_z)
+        )
+
+        return ({"mesh": mesh},)
+
+
+class MTB_GeometryLoad:
+    """Load a 3D geometry."""
+
+    @classmethod
+    def INPUT_TYPES(cls):
+        return {"required": {"path": ("STRING", {"default": ""})}}
+
+    RETURN_TYPES = ("GEOMETRY",)
+    RETURN_NAMES = ("geometry",)
+    FUNCTION = "load_geo"
+    CATEGORY = "mtb/3D"
+
+    def load_geo(self, path):
+        if not os.path.exists(path):
+            raise ValueError(f"Path {path} does not exist")
+
+        mesh = o3d.io.read_triangle_mesh(path)
+
+        if len(mesh.vertices) == 0:
+            mesh = o3d.io.read_triangle_model(path)
+            mesh_count = len(mesh.meshes)
+            if mesh_count == 0:
+                raise ValueError("Couldn't parse input file")
+
+            if mesh_count > 1:
+                log.warn(
+                    f"Found {mesh_count} meshes, only the first will be used..."
+                )
+
+            mesh = mesh.meshes[0].mesh
+
+        mesh.compute_vertex_normals()
+
+        return {
+            "result": ({"mesh": mesh},),
+        }
+
+
+class MTB_GeometryInfo:
+    """Retrieve information about a 3D geometry."""
+
+    @classmethod
+    def INPUT_TYPES(cls):
+        return {"required": {"geometry": ("GEOMETRY", {})}}
+
+    RETURN_TYPES = ("INT", "INT", "MATERIAL")
+    RETURN_NAMES = ("num_vertices", "num_triangles", "material")
+    FUNCTION = "get_info"
+    CATEGORY = "mtb/3D"
+
+    def get_info(self, geometry):
+        mesh, material = spread_geo(geometry)
+        log.debug(mesh)
+        return (len(mesh.vertices), len(mesh.triangles), material)
+
+
+class MTB_GeometryDecimater:
+    """Optimized the geometry to match the target number of triangles."""
+
+    @classmethod
+    def INPUT_TYPES(cls):
+        return {
+            "required": {
+                "mesh": ("GEOMETRY", {}),
+                "target": ("INT", {"default": 1500, "min": 3, "max": 500000}),
+            }
+        }
+
+    RETURN_TYPES = ("GEOMETRY",)
+    RETURN_NAMES = ("geometry",)
+    FUNCTION = "decimate"
+    CATEGORY = "mtb/3D"
+
+    def decimate(self, mesh, target):
+        mesh = mesh.simplify_quadric_decimation(
+            target_number_of_triangles=target
+        )
+        mesh.compute_vertex_normals()
+
+        return ({"mesh": mesh},)
+
+
+class MTB_GeometrySceneSetup:
+    """Scene setup for the renderer."""
+
+    @classmethod
+    def INPUT_TYPES(cls):
+        return {
+            "required": {
+                "geometry": ("GEOMETRY",),
+            }
+        }
+
+    RETURN_TYPES = ("SCENE",)
+    RETURN_NAMES = ("scene",)
+    FUNCTION = "setup"
+    CATEGORY = "mtb/3D"
+
+    def setup(self, mesh, target):
+        return ({"geometry": {"mesh": mesh}, "camera": cam},)
+
+
+class MTB_GeometryRender:
+    """Renders a Geometry to an image."""
+
+    @classmethod
+    def INPUT_TYPES(cls):
+        return {
+            "required": {
+                "geometry": ("SCENE", {}),
+                "width": ("INT", {"default": 512, "min": 1}),
+                "height": ("INT", {"default": 512, "min": 1}),
+                "background": ("COLOR", {"default": [0.0, 0.0, 0.0]}),
+                "camera": ("CAMERA",),
+            }
+        }
+
+    RETURN_TYPES = ("IMAGE",)
+    RETURN_NAMES = ("image",)
+    FUNCTION = "render"
+    CATEGORY = "mtb/3D"
+
+    def render(self, geometry, width, height, background, camera):
+        # create a renderer
+        renderer = o3d.visualization.rendering.OffscreenRenderer(width, height)
+        renderer.set_camera(camera)
+        renderer.clear(background)
+        renderer.add_geometry(geometry)
+        renderer.render()
+        image = renderer.get_image()
+        return (image,)
+
+
+__nodes__ = [
+    MTB_Camera,
+    MTB_GeometryApplyMaterial,
+    MTB_GeometryBox,
+    MTB_GeometryDecimater,
+    MTB_GeometryDraw,
+    MTB_GeometryInfo,
+    MTB_GeometryLoad,
+    MTB_GeometryMaterial,
+    MTB_GeometryRender,
+    MTB_GeometrySceneSetup,
+    MTB_GeometrySphere,
+    MTB_GeometryTest,
+    MTB_GeometryTransform,
+]

nodes/graph_utils.py

@@ -1,69 +1,687 @@
+import io
+import json
+import urllib.parse
+import urllib.request
+from math import pi
+
+import comfy.model_management as model_management
+import comfy.utils
+import numpy as np
 import torch
-import folder_paths
-import os
+from PIL import Image
+
+from ..log import log
+from ..utils import (
+    EASINGS,
+    apply_easing,
+    get_server_info,
+    numpy_NFOV,
+    pil2tensor,
+    tensor2np,
+)
 
 
-class SaveTensors:
-    """Debug node that will probably be removed in the future"""
+def get_image(filename, subfolder, folder_type):
+    """Use the comfyUI "/view" endpoint to get an image from the server."""
+    log.debug(
+        f"Getting image {filename} from foldertype {folder_type} {f'in subfolder: {subfolder}' if subfolder else ''}"  # noqa: E501
+    )
+    data = {"filename": filename, "subfolder": subfolder, "type": folder_type}
+    base_url, port = get_server_info()
 
-    def __init__(self):
-        self.output_dir = folder_paths.get_output_directory()
-        self.type = "output"
+    url_values = urllib.parse.urlencode(data)
+    url = f"http://{base_url}:{port}/view?{url_values}"
+    log.debug(f"Fetching image from {url}")
+
+    with urllib.request.urlopen(url) as response:  # noqa: S310
+        return io.BytesIO(response.read())
+
+
+class MTB_ToDevice:
+    """Send a image or mask tensor to the given device."""
+
+    @classmethod
+    def INPUT_TYPES(cls):
+        devices = ["cpu"]
+        if torch.backends.mps.is_available():
+            devices.append("mps")
+        if torch.cuda.is_available():
+            devices.append("cuda")
+            for i in range(torch.cuda.device_count()):
+                devices.append(f"cuda{i}")
+
+        return {
+            "required": {
+                "ignore_errors": ("BOOLEAN", {"default": False}),
+                "device": (devices, {"default": "cpu"}),
+            },
+            "optional": {
+                "image": ("IMAGE",),
+                "mask": ("MASK",),
+            },
+        }
+
+    RETURN_TYPES = ("IMAGE", "MASK")
+    RETURN_NAMES = ("images", "masks")
+    CATEGORY = "mtb/utils"
+    FUNCTION = "to_device"
+
+    def to_device(
+        self,
+        *,
+        ignore_errors=False,
+        device="cuda",
+        image: torch.Tensor | None = None,
+        mask: torch.Tensor | None = None,
+    ):
+        if not ignore_errors and image is None and mask is None:
+            raise ValueError(
+                "You must either provide an image or a mask,"
+                " use ignore_error to passthrough"
+            )
+        if image is not None:
+            image = image.to(device)
+        if mask is not None:
+            mask = mask.to(device)
+        return (image, mask)
+
+
+# class MTB_ApplyTextTemplate:
+class MTB_ApplyTextTemplate:
+    """
+    Experimental node to interpolate strings from inputs.
+
+    Interpolation just requires {}, for instance:
+
+    Some string {var_1} and {var_2}
+    """
 
     @classmethod
     def INPUT_TYPES(cls):
         return {
             "required": {
-                "filename_prefix": ("STRING", {"default": "ComfyPickle"}),
-            },
-            "optional": {
-                "image": ("IMAGE",),
-                "mask": ("MASK",),
-                "latent": ("LATENT",),
+                "template": ("STRING", {"default": "", "multiline": True}),
             },
         }
 
-    FUNCTION = "save"
-    OUTPUT_NODE = True
-    RETURN_TYPES = ()
-    CATEGORY = "utils"
+    RETURN_TYPES = ("STRING",)
+    RETURN_NAMES = ("string",)
+    CATEGORY = "mtb/utils"
+    FUNCTION = "execute"
 
-    def save(
-        self,
-        filename_prefix,
-        image: torch.Tensor = None,
-        mask: torch.Tensor = None,
-        latent: torch.Tensor = None,
+    def execute(self, *, template: str, **kwargs):
+        res = f"{template}"
+        for k, v in kwargs.items():
+            res = res.replace(f"{{{k}}}", f"{v}")
+
+        return (res,)
+
+
+class MTB_MatchDimensions:
+    """Match images dimensions along the given dimension, preserving aspect ratio."""
+
+    @classmethod
+    def INPUT_TYPES(cls):
+        return {
+            "required": {
+                "source": ("IMAGE",),
+                "reference": ("IMAGE",),
+                "match": (["height", "width"], {"default": "height"}),
+            },
+        }
+
+    RETURN_TYPES = ("IMAGE", "INT", "INT")
+    RETURN_NAMES = ("image", "new_width", "new_height")
+    CATEGORY = "mtb/utils"
+    FUNCTION = "execute"
+
+    def execute(
+        self, source: torch.Tensor, reference: torch.Tensor, match: str
     ):
-        (
-            full_output_folder,
-            filename,
-            counter,
-            subfolder,
-            filename_prefix,
-        ) = folder_paths.get_save_image_path(filename_prefix, self.output_dir)
+        import torchvision.transforms.functional as VF
 
-        if image is not None:
-            image_file = f"{filename}_image_{counter:05}.pt"
-            torch.save(image, os.path.join(full_output_folder, image_file))
-            # np.save(os.path.join(full_output_folder, image_file), image.cpu().numpy())
+        _batch_size, height, width, _channels = source.shape
+        _rbatch_size, rheight, rwidth, _rchannels = reference.shape
 
-        if mask is not None:
-            mask_file = f"{filename}_mask_{counter:05}.pt"
-            torch.save(mask, os.path.join(full_output_folder, mask_file))
-            # np.save(os.path.join(full_output_folder, mask_file), mask.cpu().numpy())
+        source_aspect_ratio = width / height
+        # reference_aspect_ratio = rwidth / rheight
 
-        if latent is not None:
-            # for latent we must use pickle
-            latent_file = f"{filename}_latent_{counter:05}.pt"
-            torch.save(latent, os.path.join(full_output_folder, latent_file))
-            # pickle.dump(latent, open(os.path.join(full_output_folder, latent_file), "wb"))
+        source = source.permute(0, 3, 1, 2)
+        reference = reference.permute(0, 3, 1, 2)
 
-            # np.save(os.path.join(full_output_folder, latent_file), latent[""].cpu().numpy())
+        if match == "height":
+            new_height = rheight
+            new_width = int(rheight * source_aspect_ratio)
+        else:
+            new_width = rwidth
+            new_height = int(rwidth / source_aspect_ratio)
 
-        return f"{filename_prefix}_{counter:05}"
+        resized_images = [
+            VF.resize(
+                source[i],
+                (new_height, new_width),
+                antialias=True,
+                interpolation=Image.BICUBIC,
+            )
+            for i in range(_batch_size)
+        ]
+        resized_source = torch.stack(resized_images, dim=0)
+        resized_source = resized_source.permute(0, 2, 3, 1)
+
+        return (resized_source, new_width, new_height)
+
+
+class MTB_FloatToFloats:
+    """Conversion utility for compatibility with other extensions (AD, IPA, Fitz are using FLOAT to represent list of floats.)"""
+
+    @classmethod
+    def INPUT_TYPES(cls):
+        return {
+            "required": {
+                "float": ("FLOAT", {"default": 0.0, "forceInput": True}),
+            }
+        }
+
+    RETURN_TYPES = ("FLOATS",)
+    RETURN_NAMES = ("floats",)
+    CATEGORY = "mtb/utils"
+    FUNCTION = "convert"
+
+    def convert(self, float: float):
+        return (float,)
+
+
+class MTB_FloatsToInts:
+    """Conversion utility for compatibility with frame interpolation."""
+
+    @classmethod
+    def INPUT_TYPES(cls):
+        return {
+            "required": {
+                "floats": ("FLOATS", {"forceInput": True}),
+            }
+        }
+
+    RETURN_TYPES = ("INTS", "INT")
+    CATEGORY = "mtb/utils"
+    FUNCTION = "convert"
+
+    def convert(self, floats: list[float]):
+        vals = [int(x) for x in floats]
+        return (vals, vals)
+
+
+class MTB_FloatsToFloat:
+    """Conversion utility for compatibility with other extensions (AD, IPA, Fitz are using FLOAT to represent list of floats.)"""
+
+    @classmethod
+    def INPUT_TYPES(cls):
+        return {
+            "required": {
+                "floats": ("FLOATS",),
+            }
+        }
+
+    RETURN_TYPES = ("FLOAT",)
+    RETURN_NAMES = ("float",)
+    CATEGORY = "mtb/utils"
+    FUNCTION = "convert"
+
+    def convert(self, floats):
+        return (floats,)
+
+
+class MTB_AutoPanEquilateral:
+    """Generate a 360 panning video from an equilateral image."""
+
+    @classmethod
+    def INPUT_TYPES(cls):
+        return {
+            "required": {
+                "equilateral_image": ("IMAGE",),
+                "fovX": ("FLOAT", {"default": 45.0}),
+                "fovY": ("FLOAT", {"default": 45.0}),
+                "elevation": ("FLOAT", {"default": 0.5}),
+                "frame_count": ("INT", {"default": 100}),
+                "width": ("INT", {"default": 768}),
+                "height": ("INT", {"default": 512}),
+            },
+            "optional": {
+                "floats_fovX": ("FLOATS",),
+                "floats_fovY": ("FLOATS",),
+                "floats_elevation": ("FLOATS",),
+            },
+        }
+
+    RETURN_TYPES = ("IMAGE",)
+    RETURN_NAMES = ("image",)
+    CATEGORY = "mtb/utils"
+    FUNCTION = "generate_frames"
+
+    def check_floats(self, f: list[float] | None, expected_count: int):
+        if f:
+            if len(f) == expected_count:
+                return True
+            return False
+        return True
+
+    def generate_frames(
+        self,
+        equilateral_image: torch.Tensor,
+        fovX: float,
+        fovY: float,
+        elevation: float,
+        frame_count: int,
+        width: int,
+        height: int,
+        floats_fovX: list[float] | None = None,
+        floats_fovY: list[float] | None = None,
+        floats_elevation: list[float] | None = None,
+    ):
+        source = tensor2np(equilateral_image)
+
+        if len(source) > 1:
+            log.warn(
+                "You provided more than one image in the equilateral_image input, only the first will be used."
+            )
+        if not all(
+            [
+                self.check_floats(x, frame_count)
+                for x in [floats_fovX, floats_fovY, floats_elevation]
+            ]
+        ):
+            raise ValueError(
+                "You provided less than the expected number of fovX, fovY, or elevation values."
+            )
+
+        source = source[0]
+        frames = []
+
+        pbar = comfy.utils.ProgressBar(frame_count)
+        for i in range(frame_count):
+            rotation_angle = (i / frame_count) * 2 * pi
+
+            if floats_elevation:
+                elevation = floats_elevation[i]
+
+            if floats_fovX:
+                fovX = floats_fovX[i]
+
+            if floats_fovY:
+                fovY = floats_fovY[i]
+
+            fov = [fovX / 100, fovY / 100]
+            center_point = [rotation_angle / (2 * pi), elevation]
+
+            nfov = numpy_NFOV(fov, height, width)
+            frame = nfov.to_nfov(source, center_point=center_point)
+
+            frames.append(frame)
+
+            model_management.throw_exception_if_processing_interrupted()
+            pbar.update(1)
+
+        return (pil2tensor(frames),)
+
+
+class MTB_GetBatchFromHistory:
+    """Very experimental node to load images from the history of the server.
+
+    Queue items without output are ignored in the count.
+    """
+
+    @classmethod
+    def INPUT_TYPES(cls):
+        return {
+            "required": {
+                "enable": ("BOOLEAN", {"default": True}),
+                "count": ("INT", {"default": 1, "min": 0}),
+                "offset": ("INT", {"default": 0, "min": -1e9, "max": 1e9}),
+                "internal_count": ("INT", {"default": 0}),
+            },
+            "optional": {
+                "passthrough_image": ("IMAGE",),
+            },
+        }
+
+    RETURN_TYPES = ("IMAGE",)
+    RETURN_NAMES = ("images",)
+    CATEGORY = "mtb/animation"
+    FUNCTION = "load_from_history"
+
+    def load_from_history(
+        self,
+        *,
+        enable=True,
+        count=0,
+        offset=0,
+        internal_count=0,  # hacky way to invalidate the node
+        passthrough_image=None,
+    ):
+        if not enable or count == 0:
+            if passthrough_image is not None:
+                log.debug("Using passthrough image")
+                return (passthrough_image,)
+            log.debug("Load from history is disabled for this iteration")
+            return (torch.zeros(0),)
+        frames = []
+
+        base_url, port = get_server_info()
+
+        history_url = f"http://{base_url}:{port}/history"
+        log.debug(f"Fetching history from {history_url}")
+        output = torch.zeros(0)
+        with urllib.request.urlopen(history_url) as response:  # noqa: S310
+            output = self.load_batch_frames(response, offset, count, frames)
+
+        if output.size(0) == 0:
+            log.warn("No output found in history")
+
+        return (output,)
+
+    def load_batch_frames(self, response, offset, count, frames):
+        history = json.loads(response.read())
+
+        output_images = []
+
+        for run in history.values():
+            for node_output in run["outputs"].values():
+                if "images" in node_output:
+                    for image in node_output["images"]:
+                        image_data = get_image(
+                            image["filename"],
+                            image["subfolder"],
+                            image["type"],
+                        )
+                        output_images.append(image_data)
+
+        if not output_images:
+            return torch.zeros(0)
+
+        # Directly get desired range of images
+        start_index = max(len(output_images) - offset - count, 0)
+        end_index = len(output_images) - offset
+        selected_images = output_images[start_index:end_index]
+
+        frames = [Image.open(image) for image in selected_images]
+
+        if not frames:
+            return torch.zeros(0)
+        elif len(frames) != count:
+            log.warning(f"Expected {count} images, got {len(frames)} instead")
+
+        return pil2tensor(frames)
+
+
+class MTB_AnyToString:
+    """Tries to take any input and convert it to a string."""
+
+    @classmethod
+    def INPUT_TYPES(cls):
+        return {
+            "required": {"input_value": ("*",)},
+        }
+
+    RETURN_TYPES = ("STRING",)
+    FUNCTION = "do_str"
+    CATEGORY = "mtb/converters"
+
+    def do_str(self, input_value):
+        if isinstance(input_value, str):
+            return (input_value,)
+        elif isinstance(input_value, torch.Tensor):
+            return (
+                f"Tensor of shape {input_value.shape} and dtype {input_value.dtype}",
+            )
+        elif isinstance(input_value, Image.Image):
+            return (
+                f"PIL Image of size {input_value.size} and mode {input_value.mode}",
+            )
+        elif isinstance(input_value, np.ndarray):
+            return (
+                f"Numpy array of shape {input_value.shape} and dtype {input_value.dtype}",
+            )
+
+        elif isinstance(input_value, dict):
+            return (
+                f"Dictionary of {len(input_value)} items, with keys {input_value.keys()}",
+            )
+
+        else:
+            log.debug(f"Falling back to string conversion of {input_value}")
+            return (str(input_value),)
+
+
+class MTB_StringReplace:
+    """Basic string replacement."""
+
+    """Basic string replacement."""
+
+    @classmethod
+    def INPUT_TYPES(cls):
+        return {
+            "required": {
+                "string": ("STRING", {"forceInput": True}),
+                "old": ("STRING", {"default": ""}),
+                "new": ("STRING", {"default": ""}),
+            }
+        }
+
+    FUNCTION = "replace_str"
+    RETURN_TYPES = ("STRING",)
+    CATEGORY = "mtb/string"
+
+    def replace_str(self, string: str, old: str, new: str):
+        log.debug(f"Current string: {string}")
+        log.debug(f"Find string: {old}")
+        log.debug(f"Replace string: {new}")
+
+        string = string.replace(old, new)
+
+        log.debug(f"New string: {string}")
+
+        return (string,)
+
+
+class MTB_MathExpression:
+    """Node to evaluate a simple math expression string."""
+
+    @classmethod
+    def INPUT_TYPES(cls):
+        return {
+            "required": {
+                "expression": ("STRING", {"default": "", "multiline": True}),
+            }
+        }
+
+    FUNCTION = "eval_expression"
+    RETURN_TYPES = ("FLOAT", "INT")
+    RETURN_NAMES = ("result (float)", "result (int)")
+    CATEGORY = "mtb/math"
+    DESCRIPTION = (
+        "evaluate a simple math expression string, only supports literal_eval"
+    )
+
+    def eval_expression(self, expression: str, **kwargs):
+        from ast import literal_eval
+
+        for key, value in kwargs.items():
+            log.debug(f"Replacing placeholder <{key}> with value {value}")
+            expression = expression.replace(f"<{key}>", str(value))
+
+        result = -1
+        try:
+            result = literal_eval(expression)
+        except SyntaxError as e:
+            raise ValueError(
+                f"The expression syntax is wrong '{expression}': {e}"
+            ) from e
+
+        except Exception as e:
+            raise ValueError(
+                f"Math expression only support literal_eval now: {e}"
+            )
+        except ValueError:
+            try:
+                expression = expression.replace("^", "**")
+                result = eval(expression)  # noqa: S307
+            except Exception as e:
+                raise ValueError(
+                    f"Error evaluating expression '{expression}': {e}"
+                ) from e
+
+        return (result, int(result))
+
+
+class MTB_FitNumber:
+    """Fit the input float using a source and target range"""
+
+    @classmethod
+    def INPUT_TYPES(cls):
+        return {
+            "required": {
+                "value": ("FLOAT", {"default": 0, "forceInput": True}),
+                "clamp": ("BOOLEAN", {"default": False}),
+                "source_min": (
+                    "FLOAT",
+                    {"default": 0.0, "step": 0.01, "min": -1e5},
+                ),
+                "source_max": (
+                    "FLOAT",
+                    {"default": 1.0, "step": 0.01, "min": -1e5},
+                ),
+                "target_min": (
+                    "FLOAT",
+                    {"default": 0.0, "step": 0.01, "min": -1e5},
+                ),
+                "target_max": (
+                    "FLOAT",
+                    {"default": 1.0, "step": 0.01, "min": -1e5},
+                ),
+                "easing": (
+                    EASINGS,
+                    {"default": "Linear"},
+                ),
+            }
+        }
+
+    FUNCTION = "set_range"
+    RETURN_TYPES = ("FLOAT",)
+    CATEGORY = "mtb/math"
+    DESCRIPTION = "Fit the input float using a source and target range"
+
+    def set_range(
+        self,
+        *,
+        value: float,
+        clamp: bool,
+        source_min=0.0,
+        source_max=1.0,
+        target_min=0.0,
+        target_max=1.0,
+        easing="Linear",
+    ):
+        if source_min == source_max:
+            normalized_value = 0
+        else:
+            normalized_value = (value - source_min) / (source_max - source_min)
+        if clamp:
+            normalized_value = max(min(normalized_value, 1), 0)
+
+        eased_value = apply_easing(normalized_value, easing)
+
+        # - Convert the eased value to the target range
+        res = target_min + (target_max - target_min) * eased_value
+
+        return (res,)
+
+
+class MTB_ConcatImages:
+    """Add images to batch."""
+
+    RETURN_TYPES = ("IMAGE",)
+    FUNCTION = "concatenate_tensors"
+    CATEGORY = "mtb/image"
+
+    @classmethod
+    def INPUT_TYPES(cls):
+        return {
+            "required": {"reverse": ("BOOLEAN", {"default": False})},
+            "optional": {
+                "on_mismatch": (
+                    ["Error", "Smallest", "Largest"],
+                    {"default": "Smallest"},
+                )
+            },
+        }
+
+    def concatenate_tensors(
+        self,
+        reverse: bool,
+        on_mismatch: str = "Smallest",
+        **kwargs: torch.Tensor,
+    ) -> tuple[torch.Tensor]:
+        tensors = list(kwargs.values())
+
+        if on_mismatch == "Error":
+            shapes = [tensor.shape for tensor in tensors]
+            if not all(shape == shapes[0] for shape in shapes):
+                raise ValueError(
+                    "All input tensors must have the same shape when on_mismatch is 'Error'."
+                )
+
+        else:
+            import torch.nn.functional as F
+
+            if on_mismatch == "Smallest":
+                target_shape = min(
+                    (tensor.shape for tensor in tensors),
+                    key=lambda s: (s[1], s[2]),
+                )
+            else:  # on_mismatch == "Largest"
+                target_shape = max(
+                    (tensor.shape for tensor in tensors),
+                    key=lambda s: (s[1], s[2]),
+                )
+
+            target_height, target_width = target_shape[1], target_shape[2]
+
+            resized_tensors = []
+            for tensor in tensors:
+                if (
+                    tensor.shape[1] != target_height
+                    or tensor.shape[2] != target_width
+                ):
+                    resized_tensor = F.interpolate(
+                        tensor.permute(0, 3, 1, 2),
+                        size=(target_height, target_width),
+                        mode="bilinear",
+                        align_corners=False,
+                    )
+                    resized_tensor = resized_tensor.permute(0, 2, 3, 1)
+                    resized_tensors.append(resized_tensor)
+                else:
+                    resized_tensors.append(tensor)
+
+            tensors = resized_tensors
+
+        concatenated = torch.cat(tensors, dim=0)
+
+        return (concatenated,)
 
 
 __nodes__ = [
-    SaveTensors,
+    MTB_StringReplace,
+    MTB_FitNumber,
+    MTB_GetBatchFromHistory,
+    MTB_AnyToString,
+    MTB_ConcatImages,
+    MTB_MathExpression,
+    MTB_ToDevice,
+    MTB_ApplyTextTemplate,
+    MTB_MatchDimensions,
+    MTB_AutoPanEquilateral,
+    MTB_FloatsToFloat,
+    MTB_FloatToFloats,
+    MTB_FloatsToInts,
 ]

nodes/image_interpolation.py

@@ -0,0 +1,133 @@
+from pathlib import Path
+
+import comfy
+import comfy.model_management as model_management
+import comfy.utils
+import numpy as np
+import tensorflow as tf
+import torch
+from frame_interpolation.eval import interpolator, util
+
+from ..errors import ModelNotFound
+from ..log import log
+from ..utils import get_model_path
+
+
+class MTB_LoadFilmModel:
+    """Loads a FILM model.
+
+    [DEPRECATED] Use ComfyUI-FrameInterpolation instead
+    """
+
+    @staticmethod
+    def get_models() -> list[Path]:
+        models_paths = get_model_path("FILM").iterdir()
+
+        return [x for x in models_paths if x.suffix in [".onnx", ".pth"]]
+
+    @classmethod
+    def INPUT_TYPES(cls):
+        return {
+            "required": {
+                "film_model": (
+                    ["L1", "Style", "VGG"],
+                    {"default": "Style"},
+                ),
+            },
+        }
+
+    RETURN_TYPES = ("FILM_MODEL",)
+    FUNCTION = "load_model"
+    CATEGORY = "mtb/frame iterpolation"
+    DEPRECATED = True
+
+    def load_model(self, film_model: str):
+        model_path = get_model_path("FILM", film_model)
+        if not model_path or not model_path.exists():
+            raise ModelNotFound(f"FILM ({model_path})")
+
+        if not (model_path / "saved_model.pb").exists():
+            model_path = model_path / "saved_model"
+
+        if not model_path.exists():
+            log.error(f"Model {model_path} does not exist")
+            raise ValueError(f"Model {model_path} does not exist")
+
+        log.info(f"Loading model {model_path}")
+
+        return (interpolator.Interpolator(model_path.as_posix(), None),)
+
+
+class MTB_FilmInterpolation:
+    """Google Research FILM frame interpolation for large motion.
+
+    [DEPRECATED] Use ComfyUI-FrameInterpolation instead
+    """
+
+    @classmethod
+    def INPUT_TYPES(cls):
+        return {
+            "required": {
+                "images": ("IMAGE",),
+                "interpolate": ("INT", {"default": 2, "min": 1, "max": 50}),
+                "film_model": ("FILM_MODEL",),
+            },
+        }
+
+    RETURN_TYPES = ("IMAGE",)
+    FUNCTION = "do_interpolation"
+    CATEGORY = "mtb/frame iterpolation"
+    DEPRECATED = True
+
+    def do_interpolation(
+        self,
+        images: torch.Tensor,
+        interpolate: int,
+        film_model: interpolator.Interpolator,
+    ):
+        n = images.size(0)
+        # check if images is an empty tensor and return it...
+        if n == 0:
+            return (images,)
+
+        # check if tensorflow GPU is available
+        available_gpus = tf.config.list_physical_devices("GPU")
+        if not len(available_gpus):
+            log.warning(
+                "Tensorflow GPU not available, falling back to CPU this will be very slow"
+            )
+        else:
+            log.debug(f"Tensorflow GPU available, using {available_gpus}")
+
+        num_frames = (n - 1) * (2 ** (interpolate) - 1)
+        log.debug(f"Will interpolate into {num_frames} frames")
+
+        in_frames = [images[i] for i in range(n)]
+        out_tensors = []
+
+        pbar = comfy.utils.ProgressBar(num_frames)
+
+        for frame in util.interpolate_recursively_from_memory(
+            in_frames,  # type: ignore
+            interpolate,
+            film_model,
+        ):
+            out_tensors.append(
+                torch.from_numpy(frame)
+                if isinstance(frame, np.ndarray)
+                else frame
+            )
+            model_management.throw_exception_if_processing_interrupted()
+            pbar.update(1)
+
+        out_tensors = torch.cat(
+            [tens.unsqueeze(0) for tens in out_tensors], dim=0
+        )
+
+        log.debug(f"Returning {len(out_tensors)} tensors")
+        log.debug(f"Output shape {out_tensors.shape}")
+        log.debug(f"Output type {out_tensors.dtype}")
+        return (out_tensors,)
+
+
+__nodes__ = [MTB_LoadFilmModel, MTB_FilmInterpolation]

nodes/image_utils.py

@@ -0,0 +1,130 @@
+import torch
+
+from ..log import log
+
+
+class MTB_StackImages:
+    """Stack the input images horizontally or vertically."""
+
+    @classmethod
+    def INPUT_TYPES(cls):
+        return {"required": {"vertical": ("BOOLEAN", {"default": False})}}
+
+    RETURN_TYPES = ("IMAGE",)
+    FUNCTION = "stack"
+    CATEGORY = "mtb/image utils"
+
+    def stack(self, vertical, **kwargs):
+        if not kwargs:
+            raise ValueError("At least one tensor must be provided.")
+
+        tensors = list(kwargs.values())
+        log.debug(
+            f"Stacking {len(tensors)} tensors "
+            f"{'vertically' if vertical else 'horizontally'}"
+        )
+
+        normalized_tensors = [
+            self.normalize_to_rgba(tensor) for tensor in tensors
+        ]
+        max_batch_size = max(tensor.shape[0] for tensor in normalized_tensors)
+        normalized_tensors = [
+            self.duplicate_frames(tensor, max_batch_size)
+            for tensor in normalized_tensors
+        ]
+
+        if vertical:
+            width = normalized_tensors[0].shape[2]
+            if any(tensor.shape[2] != width for tensor in normalized_tensors):
+                raise ValueError(
+                    "All tensors must have the same width "
+                    "for vertical stacking."
+                )
+            dim = 1
+        else:
+            height = normalized_tensors[0].shape[1]
+            if any(tensor.shape[1] != height for tensor in normalized_tensors):
+                raise ValueError(
+                    "All tensors must have the same height "
+                    "for horizontal stacking."
+                )
+            dim = 2
+
+        stacked_tensor = torch.cat(normalized_tensors, dim=dim)
+
+        return (stacked_tensor,)
+
+    def normalize_to_rgba(self, tensor):
+        """Normalize tensor to have 4 channels (RGBA)."""
+        _, _, _, channels = tensor.shape
+        # already RGBA
+        if channels == 4:
+            return tensor
+        # RGB to RGBA
+        elif channels == 3:
+            alpha_channel = torch.ones(
+                tensor.shape[:-1] + (1,), device=tensor.device
+            )  # Add an alpha channel
+            return torch.cat((tensor, alpha_channel), dim=-1)
+        else:
+            raise ValueError(
+                "Tensor has an unsupported number of channels: "
+                "expected 3 (RGB) or 4 (RGBA)."
+            )
+
+    def duplicate_frames(self, tensor, target_batch_size):
+        """Duplicate frames in tensor to match the target batch size."""
+        current_batch_size = tensor.shape[0]
+        if current_batch_size < target_batch_size:
+            duplication_factors: int = target_batch_size // current_batch_size
+            duplicated_tensor = tensor.repeat(duplication_factors, 1, 1, 1)
+            remaining_frames = target_batch_size % current_batch_size
+            if remaining_frames > 0:
+                duplicated_tensor = torch.cat(
+                    (duplicated_tensor, tensor[:remaining_frames]), dim=0
+                )
+            return duplicated_tensor
+        else:
+            return tensor
+
+
+class MTB_PickFromBatch:
+    """Pick a specific number of images from a batch.
+
+    either from the start or end.
+    """
+
+    @classmethod
+    def INPUT_TYPES(cls):
+        return {
+            "required": {
+                "image": ("IMAGE",),
+                "from_direction": (["end", "start"], {"default": "start"}),
+                "count": ("INT", {"default": 1}),
+            }
+        }
+
+    RETURN_TYPES = ("IMAGE",)
+    FUNCTION = "pick_from_batch"
+    CATEGORY = "mtb/image utils"
+
+    def pick_from_batch(self, image, from_direction, count):
+        batch_size = image.size(0)
+
+        # Limit count to the available number of images in the batch
+        count = min(count, batch_size)
+        if count < batch_size:
+            log.warning(
+                f"Requested {count} images, "
+                f"but only {batch_size} are available."
+            )
+
+        if from_direction == "end":
+            selected_tensors = image[-count:]
+        else:
+            selected_tensors = image[:count]
+
+        return (selected_tensors,)
+
+
+__nodes__ = [MTB_StackImages, MTB_PickFromBatch]

nodes/io.py

@@ -0,0 +1,439 @@
+import json
+import subprocess
+import uuid
+from pathlib import Path
+
+import comfy.model_management as model_management
+import comfy.utils
+import folder_paths
+import numpy as np
+import torch
+from PIL import Image
+
+from ..log import log
+from ..utils import PIL_FILTER_MAP, output_dir, session_id, tensor2np
+
+
+def get_playlist_path(playlist_name: str, persistant_playlist=False):
+    if persistant_playlist:
+        return output_dir / "playlists" / f"{playlist_name}.json"
+
+    return output_dir / "playlists" / session_id / f"{playlist_name}.json"
+
+
+class MTB_ReadPlaylist:
+    """Read a playlist"""
+
+    @classmethod
+    def INPUT_TYPES(cls):
+        return {
+            "required": {
+                "enable": ("BOOLEAN", {"default": True}),
+                "persistant_playlist": ("BOOLEAN", {"default": False}),
+                "playlist_name": (
+                    "STRING",
+                    {"default": "playlist_{index:04d}"},
+                ),
+                "index": ("INT", {"default": 0, "min": 0}),
+            }
+        }
+
+    RETURN_TYPES = ("PLAYLIST",)
+    FUNCTION = "read_playlist"
+    CATEGORY = "mtb/IO"
+    EXPERIMENTAL = True
+
+    def read_playlist(
+        self,
+        enable: bool,
+        persistant_playlist: bool,
+        playlist_name: str,
+        index: int,
+    ):
+        playlist_name = playlist_name.format(index=index)
+        playlist_path = get_playlist_path(playlist_name, persistant_playlist)
+        if not enable:
+            return (None,)
+
+        if not playlist_path.exists():
+            log.warning(f"Playlist {playlist_path} does not exist, skipping")
+            return (None,)
+
+        log.debug(f"Reading playlist {playlist_path}")
+        return (json.loads(playlist_path.read_text(encoding="utf-8")),)
+
+
+class MTB_AddToPlaylist:
+    """Add a video to the playlist"""
+
+    @classmethod
+    def INPUT_TYPES(cls):
+        return {
+            "required": {
+                "relative_paths": ("BOOLEAN", {"default": False}),
+                "persistant_playlist": ("BOOLEAN", {"default": False}),
+                "playlist_name": (
+                    "STRING",
+                    {"default": "playlist_{index:04d}"},
+                ),
+                "index": ("INT", {"default": 0, "min": 0}),
+            }
+        }
+
+    RETURN_TYPES = ()
+    OUTPUT_NODE = True
+    FUNCTION = "add_to_playlist"
+    CATEGORY = "mtb/IO"
+    EXPERIMENTAL = True
+
+    def add_to_playlist(
+        self,
+        relative_paths: bool,
+        persistant_playlist: bool,
+        playlist_name: str,
+        index: int,
+        **kwargs,
+    ):
+        playlist_name = playlist_name.format(index=index)
+        playlist_path = get_playlist_path(playlist_name, persistant_playlist)
+
+        if not playlist_path.parent.exists():
+            playlist_path.parent.mkdir(parents=True, exist_ok=True)
+
+        playlist = []
+        if not playlist_path.exists():
+            playlist_path.write_text("[]")
+        else:
+            playlist = json.loads(playlist_path.read_text())
+        log.debug(f"Playlist {playlist_path} has {len(playlist)} items")
+        for video in kwargs.values():
+            if relative_paths:
+                video = Path(video).relative_to(output_dir).as_posix()
+
+            log.debug(f"Adding {video} to playlist")
+            playlist.append(video)
+
+        log.debug(f"Writing playlist {playlist_path}")
+        playlist_path.write_text(json.dumps(playlist), encoding="utf-8")
+        return ()
+
+
+class MTB_ExportWithFfmpeg:
+    """Export with FFmpeg (Experimental).
+
+    [DEPRACATED] Use VHS nodes instead
+    """
+
+    @classmethod
+    def INPUT_TYPES(cls):
+        return {
+            "optional": {
+                "images": ("IMAGE",),
+                "playlist": ("PLAYLIST",),
+            },
+            "required": {
+                "fps": ("FLOAT", {"default": 24, "min": 1}),
+                "prefix": ("STRING", {"default": "export"}),
+                "format": (
+                    ["mov", "mp4", "mkv", "gif", "avi"],
+                    {"default": "mov"},
+                ),
+                "codec": (
+                    ["prores_ks", "libx264", "libx265", "gif"],
+                    {"default": "prores_ks"},
+                ),
+            },
+        }
+
+    RETURN_TYPES = ("VIDEO",)
+    OUTPUT_NODE = True
+    FUNCTION = "export_prores"
+    DEPRECATED = True
+    CATEGORY = "mtb/IO"
+
+    def export_prores(
+        self,
+        fps: float,
+        prefix: str,
+        format: str,
+        codec: str,
+        images: torch.Tensor | None = None,
+        playlist: list[str] | None = None,
+    ):
+        file_ext = format
+        file_id = f"{prefix}_{uuid.uuid4()}.{file_ext}"
+
+        if playlist is not None and images is not None:
+            log.info(f"Exporting to {output_dir / file_id}")
+
+        if playlist is not None:
+            if len(playlist) == 0:
+                log.debug("Playlist is empty, skipping")
+                return ("",)
+
+            temp_playlist_path = (
+                output_dir / f"temp_playlist_{uuid.uuid4()}.txt"
+            )
+            log.debug(
+                f"Create a temporary file to list the videos for concatenation to {temp_playlist_path}"
+            )
+
+            with open(temp_playlist_path, "w") as f:
+                for video_path in playlist:
+                    f.write(f"file '{video_path}'\n")
+
+            out_path = (output_dir / file_id).as_posix()
+
+            # Prepare the FFmpeg command for concatenating videos from the playlist
+            command = [
+                "ffmpeg",
+                "-f",
+                "concat",
+                "-safe",
+                "0",
+                "-i",
+                temp_playlist_path.as_posix(),
+                "-c",
+                "copy",
+                "-y",
+                out_path,
+            ]
+            log.debug(f"Executing {command}")
+            subprocess.run(command)
+
+            temp_playlist_path.unlink()
+
+            return (out_path,)
+
+        if (
+            images is None or images.size(0) == 0
+        ):  # the is None check is just for the type checker
+            return ("",)
+
+        frames = tensor2np(images)
+        log.debug(f"Frames type {type(frames[0])}")
+        log.debug(f"Exporting {len(frames)} frames")
+        height, width, channels = frames[0].shape
+        has_alpha = channels == 4
+        out_path = (output_dir / file_id).as_posix()
+
+        if codec == "gif":
+            command = [
+                "ffmpeg",
+                "-f",
+                "image2pipe",
+                "-vcodec",
+                "png",
+                "-r",
+                str(fps),
+                "-i",
+                "-",
+                "-vcodec",
+                "gif",
+                "-y",
+                out_path,
+            ]
+            process = subprocess.Popen(command, stdin=subprocess.PIPE)
+            for frame in frames:
+                model_management.throw_exception_if_processing_interrupted()
+                Image.fromarray(frame).save(process.stdin, "PNG")
+
+            process.stdin.close()
+            process.wait()
+            return (out_path,)
+        else:
+            if has_alpha:
+                if codec in ["prores_ks", "libx264", "libx265"]:
+                    pix_fmt = (
+                        "yuva444p" if codec == "prores_ks" else "yuva420p"
+                    )
+                    frames = [
+                        frame.astype(np.uint16) * 257 for frame in frames
+                    ]
+                else:
+                    log.warning(
+                        f"Alpha channel not supported for codec {codec}. Alpha will be ignored."
+                    )
+                    frames = [
+                        frame[:, :, :3].astype(np.uint16) * 257
+                        for frame in frames
+                    ]
+                    pix_fmt = "rgb48le" if codec == "prores_ks" else "yuv420p"
+            else:
+                pix_fmt = "rgb48le" if codec == "prores_ks" else "yuv420p"
+                frames = [frame.astype(np.uint16) * 257 for frame in frames]
+
+        # Prepare the FFmpeg command
+        command = [
+            "ffmpeg",
+            "-y",
+            "-f",
+            "rawvideo",
+            "-vcodec",
+            "rawvideo",
+            "-s",
+            f"{width}x{height}",
+            "-pix_fmt",
+            pix_fmt,
+            "-r",
+            str(fps),
+            "-i",
+            "-",
+            "-c:v",
+            codec,
+        ]
+        if codec == "prores_ks":
+            command.extend(["-profile:v", "4444"])
+
+        command.extend(
+            [
+                "-r",
+                str(fps),
+                "-y",
+                out_path,
+            ]
+        )
+
+        process = subprocess.Popen(command, stdin=subprocess.PIPE)
+
+        pbar = comfy.utils.ProgressBar(len(frames))
+
+        for frame in frames:
+            process.stdin.write(frame.tobytes())
+            pbar.update(1)
+
+        process.stdin.close()
+        process.wait()
+
+        return (out_path,)
+
+
+def prepare_animated_batch(
+    batch: torch.Tensor,
+    pingpong=False,
+    resize_by=1.0,
+    resample_filter: Image.Resampling | None = None,
+    image_type=np.uint8,
+) -> list[Image.Image]:
+    images = tensor2np(batch)
+    images = [frame.astype(image_type) for frame in images]
+
+    height, width, _ = batch[0].shape
+
+    if pingpong:
+        reversed_frames = images[::-1]
+        images.extend(reversed_frames)
+    pil_images = [Image.fromarray(frame) for frame in images]
+
+    # Resize frames if necessary
+    if abs(resize_by - 1.0) > 1e-6:
+        new_width = int(width * resize_by)
+        new_height = int(height * resize_by)
+        pil_images_resized = [
+            frame.resize((new_width, new_height), resample=resample_filter)
+            for frame in pil_images
+        ]
+        pil_images = pil_images_resized
+
+    return pil_images
+
+
+# todo: deprecate for apng
+class MTB_SaveGif:
+    """Save the images from the batch as a GIF.
+
+    [DEPRACATED] Use VHS nodes instead
+    """
+
+    @classmethod
+    def INPUT_TYPES(cls):
+        return {
+            "required": {
+                "image": ("IMAGE",),
+                "fps": ("INT", {"default": 12, "min": 1, "max": 120}),
+                "resize_by": ("FLOAT", {"default": 1.0, "min": 0.1}),
+                "optimize": ("BOOLEAN", {"default": False}),
+                "pingpong": ("BOOLEAN", {"default": False}),
+                "resample_filter": (list(PIL_FILTER_MAP.keys()),),
+                "use_ffmpeg": ("BOOLEAN", {"default": False}),
+            },
+        }
+
+    RETURN_TYPES = ()
+    OUTPUT_NODE = True
+    CATEGORY = "mtb/IO"
+    FUNCTION = "save_gif"
+    DEPRECATED = True
+
+    def save_gif(
+        self,
+        image,
+        fps=12,
+        resize_by=1.0,
+        optimize=False,
+        pingpong=False,
+        resample_filter=None,
+        use_ffmpeg=False,
+    ):
+        if image.size(0) == 0:
+            return ("",)
+
+        if resample_filter is not None:
+            resample_filter = PIL_FILTER_MAP.get(resample_filter)
+
+        pil_images = prepare_animated_batch(
+            image,
+            pingpong,
+            resize_by,
+            resample_filter,
+        )
+
+        ruuid = uuid.uuid4()
+        ruuid = ruuid.hex[:10]
+        out_path = f"{folder_paths.output_directory}/{ruuid}.gif"
+
+        if use_ffmpeg:
+            # Use FFmpeg to create the GIF from PIL images
+            command = [
+                "ffmpeg",
+                "-f",
+                "image2pipe",
+                "-vcodec",
+                "png",
+                "-r",
+                str(fps),
+                "-i",
+                "-",
+                "-vcodec",
+                "gif",
+                "-y",
+                out_path,
+            ]
+            process = subprocess.Popen(command, stdin=subprocess.PIPE)
+            for image in pil_images:
+                model_management.throw_exception_if_processing_interrupted()
+                image.save(process.stdin, "PNG")
+            process.stdin.close()
+            process.wait()
+
+        else:
+            pil_images[0].save(
+                out_path,
+                save_all=True,
+                append_images=pil_images[1:],
+                optimize=optimize,
+                duration=int(1000 / fps),
+                loop=0,
+            )
+        results = [
+            {"filename": f"{ruuid}.gif", "subfolder": "", "type": "output"}
+        ]
+        return {"ui": {"gif": results}}
+
+
+__nodes__ = [
+    MTB_SaveGif,
+    MTB_ExportWithFfmpeg,
+    MTB_AddToPlaylist,
+    MTB_ReadPlaylist,
+]

nodes/latent_processing.py

@@ -1,9 +1,8 @@
 import torch
 
-class LatentLerp:
+
+class MTB_LatentLerp:
     """Linear interpolation (blend) between two latent vectors"""
-    def __init__(self):
-        pass
 
     @classmethod
     def INPUT_TYPES(cls):
@@ -11,14 +10,17 @@ class LatentLerp:
             "required": {
                 "A": ("LATENT",),
                 "B": ("LATENT",),
-                "t": ("FLOAT", {"default": 0.5, "min": 0.0, "max": 1.0, "step": 0.01}),
+                "t": (
+                    "FLOAT",
+                    {"default": 0.5, "min": 0.0, "max": 1.0, "step": 0.01},
+                ),
             }
         }
 
     RETURN_TYPES = ("LATENT",)
     FUNCTION = "lerp_latent"
 
-    CATEGORY = "latent"
+    CATEGORY = "mtb/latent"
 
     def lerp_latent(self, A, B, t):
         a = A.copy()
@@ -28,6 +30,7 @@ class LatentLerp:
 
         return (a,)
 
+
 __nodes__ = [
-    LatentLerp,
-]
+    MTB_LatentLerp,
+]

nodes/ltx.py

@@ -0,0 +1,157 @@
+import os
+import subprocess
+import tempfile
+
+import numpy as np
+import torch
+from PIL import Image
+
+from ..log import log
+
+
+class ImageH264Compression:
+    """Encodes the input with h264 compression using a configurable CRF."""
+
+    @classmethod
+    def INPUT_TYPES(cls):
+        return {
+            "required": {
+                "image": (
+                    "IMAGE",
+                    {
+                        "tooltip": "The input image tensor to be compressed and decompressed."
+                    },
+                ),
+                "crf": (
+                    "INT",
+                    {
+                        "default": 23,
+                        "min": 0,
+                        "max": 51,
+                        "step": 1,
+                        "tooltip": "Constant Rate Factor for h264 encoding (lower values mean higher quality).",
+                    },
+                ),
+            }
+        }
+
+    RETURN_TYPES = ("IMAGE",)
+    FUNCTION = "compress_and_decompress"
+
+    CATEGORY = "image"
+    DESCRIPTION = """
+**Encodes the input with h264 compression using a configurable CRF**.
+
+> [!NOTE]
+> This was recommended by the creators of LTX over banodoco's discord.
+
+*Orginal code from [mix](https://github.com/XmYx)*"""
+
+    def _compress_decompress_ffmpeg(self, img_array, crf):
+        with tempfile.TemporaryDirectory() as temp_dir:
+            input_path = os.path.join(temp_dir, "input.png")
+            output_path = os.path.join(temp_dir, "output.mp4")
+            decoded_path = os.path.join(temp_dir, "decoded.png")
+
+            Image.fromarray(img_array).save(input_path)
+
+            encode_command = [
+                "ffmpeg",
+                "-y",
+                "-i",
+                input_path,
+                "-c:v",
+                "libx264",
+                "-crf",
+                str(crf),
+                "-pix_fmt",
+                "yuv420p",
+                "-frames:v",
+                "1",
+                output_path,
+            ]
+            subprocess.run(encode_command, capture_output=True)
+
+            decode_command = [
+                "ffmpeg",
+                "-y",
+                "-i",
+                output_path,
+                "-frames:v",
+                "1",
+                decoded_path,
+            ]
+            subprocess.run(decode_command, capture_output=True)
+
+            decoded_img = np.array(Image.open(decoded_path))
+            return decoded_img
+
+    def compress_and_decompress(self, image, crf):
+        import io
+
+        output_images = []
+
+        try:
+            import av
+
+            for img_tensor in image:
+                img_array = img_tensor.cpu().numpy()
+                img_array = (img_array * 255).astype(np.uint8)
+                img_array = img_array.copy(
+                    order="C"
+                )  # Ensure contiguous array
+
+                output = io.BytesIO()
+
+                # Encode the image to h264 with the given CRF
+                container = av.open(output, mode="w", format="mp4")
+                stream = container.add_stream("h264", rate=1)
+                stream.width = img_array.shape[1]
+                stream.height = img_array.shape[0]
+                stream.pix_fmt = "yuv420p"
+                stream.options = {"crf": str(crf)}
+
+                frame = av.VideoFrame.from_ndarray(img_array, format="rgb24")
+                for packet in stream.encode(frame):
+                    container.mux(packet)
+                for packet in stream.encode():
+                    container.mux(packet)
+                container.close()
+
+                # Decode the video back to an image
+                output.seek(0)
+                container = av.open(output, mode="r", format="mp4")
+                decoded_frames = []
+                for frame in container.decode(video=0):
+                    img_decoded = frame.to_ndarray(format="rgb24")
+                    decoded_frames.append(img_decoded)
+                container.close()
+
+                if len(decoded_frames) > 0:
+                    img_decoded = decoded_frames[0]
+                    img_decoded = torch.from_numpy(
+                        img_decoded.astype(np.float32) / 255.0
+                    )
+                    output_images.append(img_decoded)
+                else:
+                    # If decoding failed, use the original image
+                    output_images.append(img_tensor)
+        except ImportError:
+            log.warning(
+                "PyAv is not installed... Falling back to the ffmpeg cli"
+            )
+            for img_tensor in image:
+                img_array = (img_tensor.cpu().numpy() * 255).astype(np.uint8)
+                decoded_img = self._compress_decompress_ffmpeg(img_array, crf)
+                img_decoded = torch.from_numpy(
+                    decoded_img.astype(np.float32) / 255.0
+                )
+                output_images.append(img_decoded)
+
+        output_images = torch.stack(output_images).to(image.device)
+        return (output_images,)
+
+# fmt: off
+__nodes__ = [
+    ImageH264Compression
+]

nodes/mask.py

@@ -1,57 +1,113 @@
-from rembg import remove
-from ..utils import pil2tensor, tensor2pil
+import comfy.utils
 from PIL import Image
 
-class ImageRemoveBackgroundRembg:
-    def __init__(self):
-        pass
+from ..utils import pil2tensor, tensor2pil
+
+
+class MTB_ImageRemoveBackgroundRembg:
+    """Removes the background from the input using Rembg."""
 
     @classmethod
     def INPUT_TYPES(cls):
         return {
             "required": {
                 "image": ("IMAGE",),
-                "alpha_matting": (["True","False"], {"default":"False"},),
-                "alpha_matting_foreground_threshold": ("INT", {"default":240, "min": 0, "max": 255},),
-                "alpha_matting_background_threshold": ("INT", {"default":10, "min": 0, "max": 255},),
-                "alpha_matting_erode_size": ("INT", {"default":10, "min": 0, "max": 255},),
-                "post_process_mask": (["True","False"], {"default":"False"},),
-                "bgcolor": ("COLOR", {"default":"black"},),
-                
+                "alpha_matting": (
+                    "BOOLEAN",
+                    {"default": False},
+                ),
+                "alpha_matting_foreground_threshold": (
+                    "INT",
+                    {"default": 240, "min": 0, "max": 255},
+                ),
+                "alpha_matting_background_threshold": (
+                    "INT",
+                    {"default": 10, "min": 0, "max": 255},
+                ),
+                "alpha_matting_erode_size": (
+                    "INT",
+                    {"default": 10, "min": 0, "max": 255},
+                ),
+                "post_process_mask": (
+                    "BOOLEAN",
+                    {"default": False},
+                ),
+                "bgcolor": (
+                    "COLOR",
+                    {"default": "#000000"},
+                ),
             },
         }
 
-    RETURN_TYPES = ("IMAGE","MASK","IMAGE",)
-    RETURN_NAMES = ("Image (rgba)","Mask","Image",)
+    RETURN_TYPES = (
+        "IMAGE",
+        "MASK",
+        "IMAGE",
+    )
+    RETURN_NAMES = (
+        "Image (rgba)",
+        "Mask",
+        "Image",
+    )
     FUNCTION = "remove_background"
-    CATEGORY = "image"
+    CATEGORY = "mtb/image"
+
     # bgcolor: Optional[Tuple[int, int, int, int]]
-    def remove_background(self, image, alpha_matting, alpha_matting_foreground_threshold, alpha_matting_background_threshold, alpha_matting_erode_size, post_process_mask, bgcolor):
-        image = remove(
-                data=tensor2pil(image),
-                alpha_matting=alpha_matting == "True",
+    def remove_background(
+        self,
+        image,
+        alpha_matting,
+        alpha_matting_foreground_threshold,
+        alpha_matting_background_threshold,
+        alpha_matting_erode_size,
+        post_process_mask,
+        bgcolor,
+    ):
+        from rembg import remove
+
+        pbar = comfy.utils.ProgressBar(image.size(0))
+        images = tensor2pil(image)
+
+        out_img = []
+        out_mask = []
+        out_img_on_bg = []
+
+        for img in images:
+            img_rm = remove(
+                data=img,
+                alpha_matting=alpha_matting,
                 alpha_matting_foreground_threshold=alpha_matting_foreground_threshold,
                 alpha_matting_background_threshold=alpha_matting_background_threshold,
                 alpha_matting_erode_size=alpha_matting_erode_size,
                 session=None,
                 only_mask=False,
-                post_process_mask=post_process_mask == "True",
-                bgcolor=None
+                post_process_mask=post_process_mask,
+                bgcolor=None,
             )
-        
-        
-        # extract the alpha to a new image
-        mask = image.getchannel(3)
-        
-        # add our bgcolor behind the image
-        image_on_bg = Image.new("RGBA", image.size, bgcolor)
-        
-        image_on_bg.paste(image, mask=mask)
-        
-        
-        return (pil2tensor(image), pil2tensor(mask), pil2tensor(image_on_bg))
+
+            # extract the alpha to a new image
+            mask = img_rm.getchannel(3)
+
+            # add our bgcolor behind the image
+            image_on_bg = Image.new("RGBA", img_rm.size, bgcolor)
+
+            image_on_bg.paste(img_rm, mask=mask)
+
+            image_on_bg = image_on_bg.convert("RGB")
+
+            out_img.append(img_rm)
+            out_mask.append(mask)
+            out_img_on_bg.append(image_on_bg)
+
+            pbar.update(1)
+
+        return (
+            pil2tensor(out_img),
+            pil2tensor(out_mask),
+            pil2tensor(out_img_on_bg),
+        )
 
 
 __nodes__ = [
-    ImageRemoveBackgroundRembg,
-]
+    MTB_ImageRemoveBackgroundRembg,
+]

nodes/model.py

@@ -0,0 +1,155 @@
+import copy
+
+import torch
+from torch.nn import functional as F
+from torch.nn.modules.utils import _pair
+
+from ..log import log
+
+
+class MTB_VaeDecode:
+    """Wrapper for the 2 core decoders but also adding the sd seamless hack, taken from: FlyingFireCo/tiled_ksampler"""
+
+    @classmethod
+    def INPUT_TYPES(cls):
+        return {
+            "required": {
+                "samples": ("LATENT",),
+                "vae": ("VAE",),
+                "seamless_model": ("BOOLEAN", {"default": False}),
+                "use_tiling_decoder": ("BOOLEAN", {"default": True}),
+                "tile_size": (
+                    "INT",
+                    {"default": 512, "min": 320, "max": 4096, "step": 64},
+                ),
+            }
+        }
+
+    RETURN_TYPES = ("IMAGE",)
+    FUNCTION = "decode"
+
+    CATEGORY = "mtb/decode"
+
+    def decode(
+        self,
+        vae,
+        samples,
+        seamless_model,
+        use_tiling_decoder=True,
+        tile_size=512,
+    ):
+        if seamless_model:
+            if use_tiling_decoder:
+                log.error(
+                    "You cannot use seamless mode with tiling decoder together, skipping tiling."
+                )
+                use_tiling_decoder = False
+            for layer in [
+                layer
+                for layer in vae.first_stage_model.modules()
+                if isinstance(layer, torch.nn.Conv2d)
+            ]:
+                layer.padding_mode = "circular"
+        if use_tiling_decoder:
+            return (
+                vae.decode_tiled(
+                    samples["samples"],
+                    tile_x=tile_size // 8,
+                    tile_y=tile_size // 8,
+                ),
+            )
+        else:
+            return (vae.decode(samples["samples"]),)
+
+
+def conv_forward(lyr, tensor, weight, bias):
+    step = lyr.timestep
+    if (lyr.paddingStartStep < 0 or step >= lyr.paddingStartStep) and (
+        lyr.paddingStopStep < 0 or step <= lyr.paddingStopStep
+    ):
+        working = F.pad(tensor, lyr.paddingX, mode=lyr.padding_modeX)
+        working = F.pad(working, lyr.paddingY, mode=lyr.padding_modeY)
+    else:
+        working = F.pad(tensor, lyr.paddingX, mode="constant")
+        working = F.pad(working, lyr.paddingY, mode="constant")
+
+    lyr.timestep += 1
+
+    return F.conv2d(
+        working, weight, bias, lyr.stride, _pair(0), lyr.dilation, lyr.groups
+    )
+
+
+class MTB_ModelPatchSeamless:
+    """Uses the stable diffusion 'hack' to infer seamless images by setting the model layers padding mode to circular (experimental)"""
+
+    @classmethod
+    def INPUT_TYPES(cls):
+        return {
+            "required": {
+                "model": ("MODEL",),
+                "startStep": ("INT", {"default": 0}),
+                "stopStep": ("INT", {"default": 999}),
+                "tilingX": (
+                    "BOOLEAN",
+                    {"default": True},
+                ),
+                "tilingY": (
+                    "BOOLEAN",
+                    {"default": True},
+                ),
+            }
+        }
+
+    RETURN_TYPES = ("MODEL", "MODEL")
+    RETURN_NAMES = (
+        "Original Model (passthrough)",
+        "Patched Model",
+    )
+    FUNCTION = "hack"
+
+    CATEGORY = "mtb/textures"
+
+    def apply_circular(self, model, startStep, stopStep, x, y):
+        for layer in [
+            layer
+            for layer in model.modules()
+            if isinstance(layer, torch.nn.Conv2d)
+        ]:
+            layer.padding_modeX = "circular" if x else "constant"
+            layer.padding_modeY = "circular" if y else "constant"
+            layer.paddingX = (
+                layer._reversed_padding_repeated_twice[0],
+                layer._reversed_padding_repeated_twice[1],
+                0,
+                0,
+            )
+            layer.paddingY = (
+                0,
+                0,
+                layer._reversed_padding_repeated_twice[2],
+                layer._reversed_padding_repeated_twice[3],
+            )
+            layer.paddingStartStep = startStep
+            layer.paddingStopStep = stopStep
+            layer.timestep = 0
+            layer._conv_forward = conv_forward.__get__(layer, torch.nn.Conv2d)
+
+        return model
+
+    def hack(
+        self,
+        model,
+        startStep,
+        stopStep,
+        tilingX,
+        tilingY,
+    ):
+        hacked_model = copy.deepcopy(model)
+        self.apply_circular(
+            hacked_model.model, startStep, stopStep, tilingX, tilingY
+        )
+        return (model, hacked_model)
+
+
+__nodes__ = [MTB_ModelPatchSeamless, MTB_VaeDecode]

nodes/number.py

@@ -1,26 +1,85 @@
-class IntToNumber:
-    """Node addon for the WAS Suite. Converts a "comfy" INT to a NUMBER."""
-
-    def __init__(self):
-        pass
+class MTB_IntToBool:
+    """Basic int to bool conversion"""
 
     @classmethod
     def INPUT_TYPES(cls):
         return {
             "required": {
-                "int": ("INT", {"default": 0, "min": 0, "max": 1e9, "step": 1}),
+                "int": (
+                    "INT",
+                    {
+                        "default": 0,
+                    },
+                ),
+            }
+        }
+
+    RETURN_TYPES = ("BOOLEAN",)
+    FUNCTION = "int_to_bool"
+    CATEGORY = "mtb/number"
+
+    def int_to_bool(self, int):
+        return (bool(int),)
+
+
+class MTB_IntToNumber:
+    """Node addon for the WAS Suite. Converts a "comfy" INT to a NUMBER."""
+
+    @classmethod
+    def INPUT_TYPES(cls):
+        return {
+            "required": {
+                "int": (
+                    "INT",
+                    {
+                        "default": 0,
+                        "min": -1e9,
+                        "max": 1e9,
+                        "step": 1,
+                        "forceInput": True,
+                    },
+                ),
             }
         }
 
     RETURN_TYPES = ("NUMBER",)
     FUNCTION = "int_to_number"
-    CATEGORY = "number"
+    CATEGORY = "mtb/number"
 
     def int_to_number(self, int):
-
         return (int,)
 
-__nodes__ = [
-    IntToNumber,
 
-]
+class MTB_FloatToNumber:
+    """Node addon for the WAS Suite. Converts a "comfy" FLOAT to a NUMBER."""
+
+    @classmethod
+    def INPUT_TYPES(cls):
+        return {
+            "required": {
+                "float": (
+                    "FLOAT",
+                    {
+                        "default": 0,
+                        "min": -1e9,
+                        "max": 1e9,
+                        "step": 1,
+                        "forceInput": True,
+                    },
+                ),
+            }
+        }
+
+    RETURN_TYPES = ("NUMBER",)
+    FUNCTION = "float_to_number"
+    CATEGORY = "mtb/number"
+
+    def float_to_number(self, float):
+        return (float,)
+
+
+__nodes__ = [
+    MTB_FloatToNumber,
+    MTB_IntToBool,
+    MTB_IntToNumber,
+]

nodes/postshot.py

@@ -0,0 +1,351 @@
+import os
+import subprocess
+import tempfile
+
+import comfy.utils
+import torch
+
+from ..log import log
+from ..utils import nextAvailable, tensor2pil
+
+RELATIVE_NOTICE = """
+Absolute paths are kept as is, relatives are from the output directory.
+"""
+
+
+class MTB_PostshotTrain:
+    CATEGORY = "mtb/postshot"
+
+    @classmethod
+    def INPUT_TYPES(cls):
+        return {
+            "required": {
+                "images": (
+                    "IMAGE",
+                    {"tooltip": "These image will get save to disk first"},
+                ),
+                "profile": (
+                    [
+                        "NeRF L",
+                        "NeRF M",
+                        "NeRF S",
+                        "NeRF XL",
+                        "NeRF XXL",
+                        "Splat ADC",
+                        "Splat MCMC",
+                    ],
+                    {
+                        "default": "Splat MCMC",
+                        "tooltip": "The radiance field model profile to train",
+                    },
+                ),
+                "image_select": (
+                    ["all", "best"],
+                    {
+                        "default": "best",
+                        "tooltip": "How to select training images from the source image sets",
+                    },
+                ),
+                "train_steps_limit": (
+                    "INT",
+                    {
+                        "default": 30,
+                        "min": 1,
+                        "max": 1000,
+                        "tooltip": "Number of kSteps to train the model for",
+                    },
+                ),
+                "output_path": (
+                    "STRING",
+                    {
+                        "default": "output",
+                        "tooltip": (
+                            "path to save the project to" f"{RELATIVE_NOTICE}"
+                        ),
+                    },
+                ),
+                "postshot_cli": (
+                    "STRING",
+                    {
+                        "default": "C:/Program Files/Jawset Postshot/bin/postshot-cli.exe"
+                    },
+                ),
+            },
+            "optional": {
+                "gpu": (
+                    "INT",
+                    {
+                        "default": 0,
+                        "min": 0,
+                        "max": 255,
+                        "tooltip": "Specify the index of the GPU to use",
+                    },
+                ),
+                "num_train_images": (
+                    "INT",
+                    {
+                        "default": 0,
+                        "min": 0,
+                        "tooltip": "If image-select best is used, specifies the number of training images to select",
+                    },
+                ),
+                "max_image_size": (
+                    "INT",
+                    {
+                        "default": 1600,
+                        "min": 0,
+                        "tooltip": "Downscale training images such that their longer edge is at most this value in pixels. Disabled if zero.",
+                    },
+                ),
+                "max_num_features": (
+                    "INT",
+                    {
+                        "default": 8,
+                        "min": 1,
+                        "tooltip": "Maximum number of 2D kFeatures extracted from each image.",
+                    },
+                ),
+                "splat_density": (
+                    "FLOAT",
+                    {
+                        "default": 1.0,
+                        "min": 0.125,
+                        "max": 8.0,
+                        "tooltip": (
+                            "Controls how much additional splats "
+                            "are generated during training."
+                            "Applies only in 'Splat ADC' profile."
+                        ),
+                    },
+                ),
+                "max_num_splats": (
+                    "INT",
+                    {
+                        "default": 3000,
+                        "min": 1,
+                        "tooltip": (
+                            "Sets the maximum number of splats (in kSplats)"
+                            " created during training. "
+                            "Applies only in 'Splat MCMC' profile."
+                        ),
+                    },
+                ),
+                "export_splat_ply": (
+                    "STRING",
+                    {
+                        "default": "",
+                        "tooltip": (
+                            "If not empty will also save a ply file."
+                            f"{RELATIVE_NOTICE}"
+                        ),
+                    },
+                ),
+            },
+        }
+
+    RETURN_TYPES = ("STRING",)
+    OUTPUT_NODE = True
+    RETURN_NAMES = ("project_file_path",)
+    FUNCTION = "train_model"
+
+    def train_model(
+        self,
+        images: torch.Tensor,
+        profile: str,
+        image_select: str,
+        train_steps_limit: int,
+        output_path: str,
+        gpu=0,
+        num_train_images=0,
+        max_image_size=1600,
+        max_num_features=8,
+        splat_density=1.0,
+        max_num_splats=3000,
+        export_splat_ply="",
+        postshot_cli="",
+    ):
+        if not output_path.endswith(".psht"):
+            output_path += ".psht"
+
+        output_path = nextAvailable(output_path)
+        output_path.parent.mkdir(exist_ok=True)
+
+        pbar = comfy.utils.ProgressBar(200 + images.size(0))
+
+        try:
+            with tempfile.TemporaryDirectory() as temp_dir:
+                image_paths = []
+                images_pil = tensor2pil(images)
+                for i, img in enumerate(images_pil):
+                    try:
+                        img_path = os.path.join(temp_dir, f"image_{i:04d}.png")
+                        img.save(img_path)
+                        image_paths.append(img_path)
+                    except Exception as e:
+                        raise RuntimeError(
+                            f"Failed to save image {i}: {str(e)}"
+                        ) from e
+                    pbar.update(1)
+
+                if not image_paths:
+                    raise ValueError("No valid images to process")
+
+                cmd = [postshot_cli, "train"]
+
+                for img_path in image_paths:
+                    cmd.extend(["-i", img_path])
+
+                cmd.extend(
+                    [
+                        "-p",
+                        profile,
+                        "--image-select",
+                        image_select,
+                        "-s",
+                        str(train_steps_limit),
+                        "-o",
+                        output_path.as_posix(),
+                    ]
+                )
+
+                if gpu is not None:
+                    cmd.extend(["--gpu", str(gpu)])
+                if num_train_images > 0 and image_select == "best":
+                    cmd.extend(["--num-train-images", str(num_train_images)])
+                if max_image_size > 0:
+                    cmd.extend(["--max-image-size", str(max_image_size)])
+                if max_num_features != 8:
+                    cmd.extend(["--max-num-features", str(max_num_features)])
+                if profile == "Splat ADC" and splat_density != 1.0:
+                    cmd.extend(["--splat-density", str(splat_density)])
+                if profile == "Splat MCMC" and max_num_splats != 3000:
+                    cmd.extend(["--max-num-splats", str(max_num_splats)])
+                if export_splat_ply:
+                    export_splat_ply = nextAvailable(export_splat_ply)
+                    cmd.extend(
+                        ["--export-splat-ply", export_splat_ply.as_posix()]
+                    )
+
+                log.debug(f"Running {cmd}")
+
+                process = subprocess.Popen(
+                    cmd,
+                    stdout=subprocess.PIPE,
+                    stderr=subprocess.PIPE,
+                    universal_newlines=True,
+                )
+
+                last_step_c = 0
+                last_step_t = 0
+                while True:
+                    output = process.stdout.readline()
+                    if output == "" and process.poll() is not None:
+                        break
+                    if output:
+                        print(output)
+                        if "camera tracking step" in output.lower():
+                            try:
+                                current_step = int(
+                                    output.split("%")[0].split(":")[1].strip()
+                                )
+                                if current_step > last_step_c:
+                                    pbar.update(1)
+                                    last_step_c = current_step
+
+                            except (ValueError, IndexError):
+                                continue
+
+                        if "training radiance field:" in output.lower():
+                            try:
+                                current_step = int(
+                                    output.split("%")[0].split(":")[1].strip()
+                                )
+                                if current_step > last_step_t:
+                                    pbar.update(1)
+                                    last_step_t = current_step
+
+                            except (ValueError, IndexError):
+                                continue
+
+                if process.returncode != 0:
+                    _, stderr = process.communicate()
+                    raise RuntimeError(f"Postshot training failed: {stderr}")
+
+                if not os.path.exists(output_path):
+                    raise RuntimeError("Output file was not created")
+
+                return (output_path.as_posix(),)
+
+        except Exception as e:
+            raise RuntimeError(f"Training failed: {str(e)}")
+        finally:
+            pbar.update(train_steps_limit)
+
+
+class MTB_PostshotExport:
+    CATEGORY = "mtb/postshot"
+    OUTPUT_NODE = True
+
+    @classmethod
+    def INPUT_TYPES(cls):
+        return {
+            "required": {
+                "project_file": (
+                    "STRING",
+                    {"default": "", "forceInput": True},
+                ),
+                "export_splat_ply": ("STRING", {"default": "output.ply"}),
+                "postshot_cli": (
+                    "STRING",
+                    {
+                        "default": "C:/Program Files/Jawset Postshot/bin/postshot-cli.exe"
+                    },
+                ),
+            },
+        }
+
+    RETURN_TYPES = ("STRING",)
+    RETURN_NAMES = ("exported_ply_path",)
+    FUNCTION = "export_model"
+
+    def export_model(
+        self, project_file: str, export_splat_ply: str, postshot_cli: str
+    ):
+        if not project_file.endswith(".psht"):
+            raise ValueError("Project file must have .psht extension")
+
+        if not os.path.exists(project_file):
+            raise FileNotFoundError(f"Project file not found: {project_file}")
+
+        if not export_splat_ply.endswith(".ply"):
+            export_splat_ply += ".ply"
+
+        _export_splat_ply = nextAvailable(export_splat_ply)
+        _export_splat_ply.parent.mkdir(exist_ok=True)
+
+        cmd = [
+            postshot_cli,
+            "export",
+            "-f",
+            project_file,
+            "--export-splat-ply",
+            _export_splat_ply.as_posix(),
+        ]
+
+        try:
+            _result = subprocess.run(
+                cmd, check=True, capture_output=True, text=True
+            )
+
+            if not _export_splat_ply.exists():
+                log.error("Export file was not created")
+
+            return (_export_splat_ply.as_posix(),)
+
+        except subprocess.CalledProcessError as e:
+            raise RuntimeError(f"Export failed: {e.stderr}")
+        except Exception as e:
+            raise RuntimeError(f"Export failed: {str(e)}")
+
+
+__nodes__ = [MTB_PostshotExport, MTB_PostshotTrain]

nodes/prune.py

@@ -0,0 +1,360 @@
+from pathlib import Path
+
+import safetensors.torch
+import torch
+import tqdm
+
+from ..log import log
+from ..utils import Operation, Precision
+from ..utils import output_dir as comfy_out_dir
+
+PRUNE_DATA = {
+    "known_junk_prefix": [
+        "embedding_manager.embedder.",
+        "lora_te_text_model",
+        "control_model.",
+    ],
+    "nai_keys": {
+        "cond_stage_model.transformer.embeddings.": "cond_stage_model.transformer.text_model.embeddings.",
+        "cond_stage_model.transformer.encoder.": "cond_stage_model.transformer.text_model.encoder.",
+        "cond_stage_model.transformer.final_layer_norm.": "cond_stage_model.transformer.text_model.final_layer_norm.",
+    },
+}
+
+# position_ids in clip is int64. model_ema.num_updates is int32
+dtypes_to_fp16 = {torch.float32, torch.float64, torch.bfloat16}
+dtypes_to_bf16 = {torch.float32, torch.float64, torch.float16}
+dtypes_to_fp8 = {torch.float32, torch.float64, torch.bfloat16, torch.float16}
+
+
+class MTB_ModelPruner:
+    @classmethod
+    def INPUT_TYPES(cls):
+        return {
+            "optional": {
+                "unet": ("MODEL",),
+                "clip": ("CLIP",),
+                "vae": ("VAE",),
+            },
+            "required": {
+                "save_separately": ("BOOLEAN", {"default": False}),
+                "save_folder": ("STRING", {"default": "checkpoints/ComfyUI"}),
+                "fix_clip": ("BOOLEAN", {"default": True}),
+                "remove_junk": ("BOOLEAN", {"default": True}),
+                "ema_mode": (
+                    ("disabled", "remove_ema", "ema_only"),
+                    {"default": "remove_ema"},
+                ),
+                "precision_unet": (
+                    Precision.list_members(),
+                    {"default": Precision.FULL.value},
+                ),
+                "operation_unet": (
+                    Operation.list_members(),
+                    {"default": Operation.CONVERT.value},
+                ),
+                "precision_clip": (
+                    Precision.list_members(),
+                    {"default": Precision.FULL.value},
+                ),
+                "operation_clip": (
+                    Operation.list_members(),
+                    {"default": Operation.CONVERT.value},
+                ),
+                "precision_vae": (
+                    Precision.list_members(),
+                    {"default": Precision.FULL.value},
+                ),
+                "operation_vae": (
+                    Operation.list_members(),
+                    {"default": Operation.CONVERT.value},
+                ),
+            },
+        }
+
+    OUTPUT_NODE = True
+    RETURN_TYPES = ()
+    CATEGORY = "mtb/prune"
+    FUNCTION = "prune"
+
+    def convert_precision(self, tensor: torch.Tensor, precision: Precision):
+        precision = Precision.from_str(precision)
+        log.debug(f"Converting to {precision}")
+        match precision:
+            case Precision.FP8:
+                if tensor.dtype in dtypes_to_fp8:
+                    return tensor.to(torch.float8_e4m3fn)
+                log.error(f"Cannot convert {tensor.dtype} to fp8")
+                return tensor
+            case Precision.FP16:
+                if tensor.dtype in dtypes_to_fp16:
+                    return tensor.half()
+                log.error(f"Cannot convert {tensor.dtype} to f16")
+                return tensor
+            case Precision.BF16:
+                if tensor.dtype in dtypes_to_bf16:
+                    return tensor.bfloat16()
+                log.error(f"Cannot convert {tensor.dtype} to bf16")
+                return tensor
+            case Precision.FULL | Precision.FP32:
+                return tensor
+
+    def is_sdxl_model(self, clip: dict[str, torch.Tensor] | None):
+        if clip:
+            return (any(k.startswith("conditioner.embedders") for k in clip),)
+        return False
+
+    def has_ema(self, unet: dict[str, torch.Tensor]):
+        return any(k.startswith("model_ema") for k in unet)
+
+    def fix_clip(self, clip: dict[str, torch.Tensor] | None):
+        if self.is_sdxl_model(clip):
+            log.warn("[fix clip] SDXL not supported")
+            return
+
+        if clip is None:
+            return
+
+        position_id_key = (
+            "cond_stage_model.transformer.text_model.embeddings.position_ids"
+        )
+        if position_id_key in clip:
+            correct = torch.Tensor([list(range(77))]).to(torch.int64)
+            now = clip[position_id_key].to(torch.int64)
+
+            broken = correct.ne(now)
+            broken = [i for i in range(77) if broken[0][i]]
+
+            if len(broken) != 0:
+                clip[position_id_key] = correct
+                log.info(f"[Converter] Fixed broken clip\n{broken}")
+            else:
+                log.info(
+                    "[Converter] Clip in this model is fine, skip fixing..."
+                )
+
+        else:
+            log.info("[Converter] Missing position id in model, try fixing...")
+            clip[position_id_key] = torch.Tensor([list(range(77))]).to(
+                torch.int64
+            )
+        return clip
+
+    def get_dicts(self, unet, clip, vae):
+        clip_sd = clip.get_sd()
+        state_dict = unet.model.state_dict_for_saving(
+            clip_sd, vae.get_sd(), None
+        )
+
+        unet = {
+            k: v
+            for k, v in state_dict.items()
+            if k.startswith("model.diffusion_model")
+        }
+        clip = {
+            k: v
+            for k, v in state_dict.items()
+            if k.startswith("cond_stage_model")
+            or k.startswith("conditioner.embedders")
+        }
+        vae = {
+            k: v
+            for k, v in state_dict.items()
+            if k.startswith("first_stage_model")
+        }
+
+        other = {
+            k: v
+            for k, v in state_dict.items()
+            if k not in unet and k not in vae and k not in clip
+        }
+
+        return (unet, clip, vae, other)
+
+    def do_remove_junk(self, tensors: dict[str, dict[str, torch.Tensor]]):
+        need_delete: list[str] = []
+        for layer in tensors:
+            for key in layer:
+                for jk in PRUNE_DATA["known_junk_prefix"]:
+                    if key.startswith(jk):
+                        need_delete.append(".".join([layer, key]))
+
+        for k in need_delete:
+            log.info(f"Removing junk data: {k}")
+            del tensors[k]
+
+        return tensors
+
+    def prune(
+        self,
+        *,
+        save_separately: bool,
+        save_folder: str,
+        fix_clip: bool,
+        remove_junk: bool,
+        ema_mode: str,
+        precision_unet: Precision,
+        precision_clip: Precision,
+        precision_vae: Precision,
+        operation_unet: str,
+        operation_clip: str,
+        operation_vae: str,
+        unet: dict[str, torch.Tensor] | None = None,
+        clip: dict[str, torch.Tensor] | None = None,
+        vae: dict[str, torch.Tensor] | None = None,
+    ):
+        operation = {
+            "unet": Operation.from_str(operation_unet),
+            "clip": Operation.from_str(operation_clip),
+            "vae": Operation.from_str(operation_vae),
+        }
+        precision = {
+            "unet": Precision.from_str(precision_unet),
+            "clip": Precision.from_str(precision_clip),
+            "vae": Precision.from_str(precision_vae),
+        }
+
+        unet, clip, vae, _other = self.get_dicts(unet, clip, vae)
+
+        out_dir = Path(save_folder)
+        folder = out_dir.parent
+        if not out_dir.is_absolute():
+            folder = (comfy_out_dir / save_folder).parent
+
+        if not folder.exists():
+            if folder.parent.exists():
+                folder.mkdir()
+            else:
+                raise FileNotFoundError(
+                    f"Folder {folder.parent} does not exist"
+                )
+
+        name = out_dir.name
+        save_name = f"{name}-{precision_unet}"
+        if ema_mode != "disabled":
+            save_name += f"-{ema_mode}"
+        if fix_clip:
+            save_name += "-clip-fix"
+
+        if (
+            any(o == Operation.CONVERT for o in operation.values())
+            and any(p == Precision.FP8 for p in precision.values())
+            and torch.__version__ < "2.1.0"
+        ):
+            raise NotImplementedError(
+                "PyTorch 2.1.0 or newer is required for fp8 conversion"
+            )
+
+        if not self.is_sdxl_model(clip):
+            for part in [unet, vae, clip]:
+                if part:
+                    nai_keys = PRUNE_DATA["nai_keys"]
+                    for k in list(part.keys()):
+                        for r in nai_keys:
+                            if isinstance(k, str) and k.startswith(r):
+                                new_key = k.replace(r, nai_keys[r])
+                                part[new_key] = part[k]
+                                del part[k]
+                                log.info(
+                                    f"[Converter] Fixed novelai error key {k}"
+                                )
+                                break
+
+            if fix_clip:
+                clip = self.fix_clip(clip)
+
+        ok: dict[str, dict[str, torch.Tensor]] = {
+            "unet": {},
+            "clip": {},
+            "vae": {},
+        }
+
+        def _hf(part: str, wk: str, t: torch.Tensor):
+            if not isinstance(t, torch.Tensor):
+                log.debug("Not a torch tensor, skipping key")
+                return
+
+            log.debug(f"Operation {operation[part]}")
+            if operation[part] == Operation.CONVERT:
+                ok[part][wk] = self.convert_precision(
+                    t, precision[part]
+                )  # conv_func(t)
+            elif operation[part] == Operation.COPY:
+                ok[part][wk] = t
+            elif operation[part] == Operation.DELETE:
+                return
+
+        log.info("[Converter] Converting model...")
+
+        for part_name, part in zip(
+            ["unet", "vae", "clip", "other"],
+            [unet, vae, clip],
+            strict=False,
+        ):
+            if part:
+                match ema_mode:
+                    case "remove_ema":
+                        for k, v in tqdm.tqdm(part.items()):
+                            if "model_ema." not in k:
+                                _hf(part_name, k, v)
+                    case "ema_only":
+                        if not self.has_ema(part):
+                            log.warn("No EMA to extract")
+                            return
+                        for k in tqdm.tqdm(part):
+                            ema_k = "___"
+                            try:
+                                ema_k = "model_ema." + k[6:].replace(".", "")
+                            except Exception:
+                                pass
+                            if ema_k in part:
+                                _hf(part_name, k, part[ema_k])
+                            elif not k.startswith("model_ema.") or k in [
+                                "model_ema.num_updates",
+                                "model_ema.decay",
+                            ]:
+                                _hf(part_name, k, part[k])
+                    case "disabled" | _:
+                        for k, v in tqdm.tqdm(part.items()):
+                            _hf(part_name, k, v)
+
+                if save_separately:
+                    if remove_junk:
+                        ok = self.do_remove_junk(ok)
+
+                    flat_ok = {
+                        k: v
+                        for _, subdict in ok.items()
+                        for k, v in subdict.items()
+                    }
+                    save_path = (
+                        folder / f"{part_name}-{save_name}.safetensors"
+                    ).as_posix()
+                    safetensors.torch.save_file(flat_ok, save_path)
+                    ok: dict[str, dict[str, torch.Tensor]] = {
+                        "unet": {},
+                        "clip": {},
+                        "vae": {},
+                    }
+
+        if save_separately:
+            return ()
+
+        if remove_junk:
+            ok = self.do_remove_junk(ok)
+
+        flat_ok = {
+            k: v for _, subdict in ok.items() for k, v in subdict.items()
+        }
+
+        try:
+            safetensors.torch.save_file(
+                flat_ok, (folder / f"{save_name}.safetensors").as_posix()
+            )
+        except Exception as e:
+            log.error(e)
+
+        return ()
+
+
+__nodes__ = [MTB_ModelPruner]

nodes/qrcode.py

@@ -1,13 +1,13 @@
 import qrcode
-from ..utils import pil2tensor
+import torch
 from PIL import Image
 
+from ..log import log
+from ..utils import pil2tensor
 
-class QrCode:
-    """Basic QR Code generator"""
 
-    def __init__(self):
-        pass
+class MTB_QrCode:
+    """Basic QR Code generator."""
 
     @classmethod
     def INPUT_TYPES(cls):
@@ -23,17 +23,36 @@ class QrCode:
                     {"default": 256, "max": 8096, "min": 0, "step": 1},
                 ),
                 "error_correct": (("L", "M", "Q", "H"), {"default": "L"}),
-                "box_size": ("INT", {"default": 10, "max": 8096, "min": 0, "step": 1}),
-                "border": ("INT", {"default": 4, "max": 8096, "min": 0, "step": 1}),
-                "invert": (("True", "False"), {"default": "False"}),
+                "box_size": (
+                    "INT",
+                    {"default": 10, "max": 8096, "min": 0, "step": 1},
+                ),
+                "border": (
+                    "INT",
+                    {"default": 4, "max": 8096, "min": 0, "step": 1},
+                ),
+                "invert": (("BOOLEAN",), {"default": False}),
             }
         }
 
     RETURN_TYPES = ("IMAGE",)
     FUNCTION = "do_qr"
-    CATEGORY = "fun"
+    CATEGORY = "mtb/generate"
 
-    def do_qr(self, url, width, height, error_correct, box_size, border, invert):
+    def do_qr(
+        self,
+        *,
+        url: str,
+        width: int,
+        height: int,
+        error_correct: str,
+        box_size: int,
+        border: int,
+        invert: bool,
+    ) -> tuple[torch.Tensor]:
+        log.warning(
+            "This node will soon be deprecated, there are much better alternatives like https://github.com/coreyryanhanson/comfy-qr"
+        )
         if error_correct == "L" or error_correct not in ["M", "Q", "H"]:
             error_correct = qrcode.constants.ERROR_CORRECT_L
         elif error_correct == "M":
@@ -52,10 +71,10 @@ class QrCode:
         qr.add_data(url)
         qr.make(fit=True)
 
-        back_color = (255, 255, 255) if invert == "True" else (0, 0, 0)
-        fill_color = (0, 0, 0) if invert == "True" else (255, 255, 255)
+        back_color = (255, 255, 255) if invert else (0, 0, 0)
+        fill_color = (0, 0, 0) if invert else (255, 255, 255)
 
-        code = img = qr.make_image(back_color=back_color, fill_color=fill_color)
+        code = qr.make_image(back_color=back_color, fill_color=fill_color)
 
         # that we now resize without filtering
         code = code.resize((width, height), Image.NEAREST)
@@ -63,4 +82,4 @@ class QrCode:
         return (pil2tensor(code),)
 
 
-__nodes__ = [QrCode]
+__nodes__ = [MTB_QrCode]

nodes/transform.py

@@ -0,0 +1,137 @@
+from math import ceil, sqrt
+from typing import cast
+
+import torch
+import torchvision.transforms.functional as TF
+from PIL import Image
+
+from ..utils import hex_to_rgb, log, pil2tensor, tensor2pil
+
+
+class MTB_TransformImage:
+    """Save torch tensors (image, mask or latent) to disk, useful to debug things outside comfy
+
+    it return a tensor representing the transformed images with the same shape as the input tensor
+    """
+
+    @classmethod
+    def INPUT_TYPES(cls):
+        return {
+            "required": {
+                "image": ("IMAGE",),
+                "x": (
+                    "FLOAT",
+                    {"default": 0, "step": 1, "min": -4096, "max": 4096},
+                ),
+                "y": (
+                    "FLOAT",
+                    {"default": 0, "step": 1, "min": -4096, "max": 4096},
+                ),
+                "zoom": (
+                    "FLOAT",
+                    {"default": 1.0, "min": 0.001, "step": 0.01},
+                ),
+                "angle": (
+                    "FLOAT",
+                    {"default": 0, "step": 1, "min": -360, "max": 360},
+                ),
+                "shear": (
+                    "FLOAT",
+                    {"default": 0, "step": 1, "min": -4096, "max": 4096},
+                ),
+                "border_handling": (
+                    ["edge", "constant", "reflect", "symmetric"],
+                    {"default": "edge"},
+                ),
+                "constant_color": ("COLOR", {"default": "#000000"}),
+            },
+        }
+
+    FUNCTION = "transform"
+    RETURN_TYPES = ("IMAGE",)
+    CATEGORY = "mtb/transform"
+
+    def transform(
+        self,
+        image: torch.Tensor,
+        x: float,
+        y: float,
+        zoom: float,
+        angle: float,
+        shear: float,
+        border_handling="edge",
+        constant_color=None,
+    ):
+        x = int(x)
+        y = int(y)
+        angle = int(angle)
+
+        log.debug(
+            f"Zoom: {zoom} | x: {x}, y: {y}, angle: {angle}, shear: {shear}"
+        )
+
+        if image.size(0) == 0:
+            return (torch.zeros(0),)
+        transformed_images = []
+        frames_count, frame_height, frame_width, frame_channel_count = (
+            image.size()
+        )
+
+        new_height, new_width = (
+            int(frame_height * zoom),
+            int(frame_width * zoom),
+        )
+
+        log.debug(f"New height: {new_height}, New width: {new_width}")
+
+        # - Calculate diagonal of the original image
+        diagonal = sqrt(frame_width**2 + frame_height**2)
+        max_padding = ceil(diagonal * zoom - min(frame_width, frame_height))
+        # Calculate padding for zoom
+        pw = int(frame_width - new_width)
+        ph = int(frame_height - new_height)
+
+        pw += abs(max_padding)
+        ph += abs(max_padding)
+
+        padding = [
+            max(0, pw + x),
+            max(0, ph + y),
+            max(0, pw - x),
+            max(0, ph - y),
+        ]
+
+        constant_color = hex_to_rgb(constant_color)
+        log.debug(f"Fill Tuple: {constant_color}")
+
+        for img in tensor2pil(image):
+            img = TF.pad(
+                img,  # transformed_frame,
+                padding=padding,
+                padding_mode=border_handling,
+                fill=constant_color or 0,
+            )
+
+            img = cast(
+                Image.Image,
+                TF.affine(
+                    img, angle=angle, scale=zoom, translate=[x, y], shear=shear
+                ),
+            )
+
+            left = abs(padding[0])
+            upper = abs(padding[1])
+            right = img.width - abs(padding[2])
+            bottom = img.height - abs(padding[3])
+
+            # log.debug("crop is [:,top:bottom, left:right] for tensors")
+            log.debug("crop is [left, top, right, bottom] for PIL")
+            log.debug(f"crop is {left}, {upper}, {right}, {bottom}")
+            img = img.crop((left, upper, right, bottom))
+
+            transformed_images.append(img)
+
+        return (pil2tensor(transformed_images),)
+
+
+__nodes__ = [MTB_TransformImage]

nodes/uv_tools.py

@@ -0,0 +1,445 @@
+import torch
+
+from ..utils import create_uv_map_tensor, log
+
+
+class oldDistortImageWithUv:
+    @classmethod
+    def INPUT_TYPES(cls):
+        return {
+            "required": {
+                "image": ("IMAGE",),
+                "uv_map": ("UV_MAP",),
+                "strength": ("FLOAT", {"default": 1.0, "step": 0.05}),
+            },
+            "optional": {
+                "base_uv_map": ("UV_MAP",),
+            },
+        }
+
+    RETURN_TYPES = ("IMAGE",)
+    RETURN_NAMES = ("image",)
+    FUNCTION = "distort_image_with_uv"
+    CATEGORY = "mtb/uv"
+
+    def distort_image_with_uv(
+        self, image, uv_map, strength=1.0, base_uv_map=None
+    ):
+        assert (
+            image.shape[1:3] == uv_map.shape[1:3]
+        ), "Spatial dimensions of image and uv_map must match!"
+
+        if base_uv_map is None:
+            base_uv_map = create_uv_map_tensor(image.shape[2], image.shape[1])
+
+        # Interpolate (or extrapolate) between base UV map and the distorted UV map based on strength
+        uv_map = strength * uv_map + (1.0 - strength) * base_uv_map
+        # Ensure the image and uv_map have the same spatial dimensions
+
+        # Extract U and V coordinates
+        U = uv_map[:, :, :, 0]
+        V = uv_map[:, :, :, 1]
+
+        # Convert U and V to pixel coordinates
+        b, h, w, _ = image.shape
+        U = U * (w - 1)
+        V = V * (h - 1)
+
+        # Calculate the four corner indices for each UV coordinate
+        U0 = torch.floor(U).long()
+        V0 = torch.floor(V).long()
+        U1 = U0 + 1
+        V1 = V0 + 1
+
+        # Clip the indices to be within the image dimensions
+        U0 = torch.clamp(U0, 0, w - 1)
+        U1 = torch.clamp(U1, 0, w - 1)
+        V0 = torch.clamp(V0, 0, h - 1)
+        V1 = torch.clamp(V1, 0, h - 1)
+
+        # Bilinear interpolation weights
+        w_U0 = (U1.float() - U).unsqueeze(-1)
+        w_U1 = (U - U0.float()).unsqueeze(-1)
+        w_V0 = (V1.float() - V).unsqueeze(-1)
+        w_V1 = (V - V0.float()).unsqueeze(-1)
+
+        # Sample image using bilinear interpolation
+        distorted = (
+            (w_U0 * w_V0) * image[:, V0, U0]
+            + (w_U0 * w_V1) * image[:, V1, U0]
+            + (w_U1 * w_V0) * image[:, V0, U1]
+            + (w_U1 * w_V1) * image[:, V1, U1]
+        )
+
+        return (distorted.squeeze(0),)
+
+
+class ImageDistortWithUv:
+    """Distorts an image based on a UV map."""
+
+    @classmethod
+    def INPUT_TYPES(cls):
+        return {
+            "required": {
+                "image": ("IMAGE",),
+                "uv_map": ("UV_MAP",),
+                "boundary_mode": (
+                    ["clamp", "wrap", "reflect", "replicate"],
+                    {"default": "wrap"},
+                ),
+                "strength": ("FLOAT", {"default": 1.0, "step": 0.05}),
+            },
+            "optional": {
+                "base_uv_map": ("UV_MAP",),
+            },
+        }
+
+    RETURN_TYPES = ("IMAGE",)
+    RETURN_NAMES = ("image",)
+    FUNCTION = "distort_image_with_uv"
+    CATEGORY = "mtb/uv"
+
+    def distort_image_with_uv(
+        self,
+        image,
+        uv_map,
+        boundary_mode="wrap",
+        strength=1.0,
+        base_uv_map=None,
+    ):
+        log.debug(f"[UV Distort] Input image shape {image.shape}")
+        if image.size(0) == 0:
+            log.debug("Input image is empty, returning empty image")
+            return (torch.zeros(0),)
+        b, h, w, _ = image.shape
+
+        x = w - 1
+        y = h - 1
+
+        # If no base UV map provided, create a default one
+        if base_uv_map is None:
+            base_uv_map = create_uv_map_tensor(w, h).to(image.device)
+
+        # Extract U and V coordinates from the base UV map
+        base_U = base_uv_map[..., 0] * x
+        base_V = base_uv_map[..., 1] * y
+
+        # Extract U and V coordinates from the distortion UV map and apply strength
+        U = strength * uv_map[..., 0] * x + (1 - strength) * base_U
+        V = strength * uv_map[..., 1] * y + (1 - strength) * base_V
+
+        # Handle boundary conditions
+        if boundary_mode == "wrap":
+            U = U % w
+            V = V % h
+        elif boundary_mode == "reflect":
+            U = U % (2 * x)
+            V = V % (2 * y)
+            U = torch.where(w < U, 2 * x - U, U)
+            V = torch.where(h < V, 2 * y - V, V)
+        elif boundary_mode == "replicate":
+            U = torch.clamp(U, 0, x)
+            V = torch.clamp(V, 0, y)
+        elif boundary_mode == "clamp":
+            U = torch.clamp(U, 0, w)
+            V = torch.clamp(V, 0, h)
+        else:
+            raise ValueError("Invalid boundary_mode")
+
+        # Check if any UV coordinates are out of bounds and log
+        if torch.any(w <= U) or torch.any(h <= V):
+            log.info("Input UVs out of bounds, clipping")
+
+        # Calculate the four corner indices for each UV coordinate
+        U0, V0 = torch.floor(U).long(), torch.floor(V).long()
+        # For replicate mode, if U0/V0 is at the last pixel, we replicate that pixel for U1/V1
+        if boundary_mode == "replicate":
+            U1 = torch.where(x > U0, U0 + 1, U0)
+            V1 = torch.where(y > V0, V0 + 1, V0)
+        else:
+            U1, V1 = U0 + 1, V0 + 1
+
+        # Ensure U1, V1 do not go out of bounds
+        U1 = torch.clamp(U1, 0, x)
+        V1 = torch.clamp(V1, 0, y)
+
+        # Adjust the bilinear coordinates based on the boundary mode
+        if boundary_mode == "wrap":
+            U1 = U1 % w
+            V1 = V1 % h
+        elif boundary_mode == "reflect":
+            # This remains unchanged as the coordinates are already reflected above
+            pass
+        elif boundary_mode == "replicate":
+            U1 = torch.clamp(U1, 0, x)
+            V1 = torch.clamp(V1, 0, y)
+
+        # Bilinear interpolation weights
+        w_U0, w_U1 = (
+            (U1.float() - U).unsqueeze(-1),
+            (U - U0.float()).unsqueeze(-1),
+        )
+        w_V0, w_V1 = (
+            (V1.float() - V).unsqueeze(-1),
+            (V - V0.float()).unsqueeze(-1),
+        )
+
+        # Sample image using bilinear interpolation
+        distorted = (
+            (w_U0 * w_V0) * image[:, V0, U0]
+            + (w_U0 * w_V1) * image[:, V1, U0]
+            + (w_U1 * w_V0) * image[:, V0, U1]
+            + (w_U1 * w_V1) * image[:, V1, U1]
+        )
+
+        return (distorted.squeeze(0),)
+
+
+class UvToImage:
+    """Converts the UV map to an image. (Shallow converter)"""
+
+    @classmethod
+    def INPUT_TYPES(cls):
+        return {
+            "required": {
+                "uv_map": ("UV_MAP",),
+            }
+        }
+
+    RETURN_TYPES = ("IMAGE",)
+    RETURN_NAMES = ("image",)
+    FUNCTION = "uv_to_image"
+    CATEGORY = "mtb/uv"
+
+    def uv_to_image(self, uv_map):
+        return (uv_map,)
+
+
+class UvRemoveSeams:
+    """Blends values near the UV borders to mitigate visible seams."""
+
+    @classmethod
+    def INPUT_TYPES(cls):
+        return {
+            "required": {
+                "uv_map": ("UV_MAP",),
+                "radius": ("FLOAT", {"default": 0.01, "step": 0.01}),
+            }
+        }
+
+    RETURN_TYPES = ("UV_MAP",)
+    RETURN_NAMES = ("uv_map",)
+    FUNCTION = "remove_uv_seams"
+    CATEGORY = "mtb/uv"
+
+    def remove_uv_seams(self, uv_map, radius):
+        # Create masks for U and V coordinates close to 0 or 1
+        u_border_mask = (uv_map[..., 0] < radius) | (
+            uv_map[..., 0] > 1 - radius
+        )
+        v_border_mask = (uv_map[..., 1] < radius) | (
+            uv_map[..., 1] > 1 - radius
+        )
+
+        # Soften the UV coordinates near the borders
+        uv_map[..., 0] = torch.where(
+            u_border_mask, uv_map[..., 0] * 0.5, uv_map[..., 0]
+        )
+        uv_map[..., 1] = torch.where(
+            v_border_mask, uv_map[..., 1] * 0.5, uv_map[..., 1]
+        )
+
+        return (uv_map,)
+
+
+class UvTile:
+    """Tiles the UV map based on the specified number of tiles."""
+
+    @classmethod
+    def INPUT_TYPES(cls):
+        return {
+            "required": {
+                "uv_map": ("UV_MAP",),
+                "tiles_u": ("INT", {"default": 1}),
+                "tiles_v": ("INT", {"default": 1}),
+                "alt_method": ("BOOLEAN", {"default": False}),
+            }
+        }
+
+    RETURN_TYPES = ("UV_MAP",)
+    RETURN_NAMES = ("uv_map",)
+    FUNCTION = "tile"
+    CATEGORY = "mtb/uv"
+
+    def tile(self, uv_map, tiles_u, tiles_v, alt_method=False):
+        tiled_uv = uv_map.clone()
+
+        if alt_method:
+            tiled_uv[..., 0] = (
+                uv_map[..., 0] * tiles_u
+            ).floor() / tiles_u + uv_map[..., 0] % (1.0 / tiles_u)
+            tiled_uv[..., 1] = (
+                uv_map[..., 1] * tiles_v
+            ).floor() / tiles_v + uv_map[..., 1] % (1.0 / tiles_v)
+
+        else:
+            tiled_uv[..., 0] = (
+                uv_map[..., 0] * tiles_u % 1.0
+            )  # tile and wrap U coordinates
+            tiled_uv[..., 1] = (
+                uv_map[..., 1] * tiles_v % 1.0
+            )  # tile and wrap V coordinates
+
+        return (tiled_uv,)
+
+
+class ImageToUv:
+    """Turn an image back into a UV map. (Shallow converter)"""
+
+    @classmethod
+    def INPUT_TYPES(cls):
+        return {
+            "required": {
+                "image_uv": ("IMAGE",),
+            }
+        }
+
+    RETURN_TYPES = ("UV_MAP",)
+    RETURN_NAMES = ("uv_map",)
+    FUNCTION = "image_to_uv"
+    CATEGORY = "mtb/uv"
+
+    def image_to_uv(self, image_uv):
+        return (image_uv,)
+
+
+class UvDistort:
+    """Applies a polar coordinates or wave distortion to the UV map"""
+
+    @classmethod
+    def INPUT_TYPES(cls):
+        return {
+            "required": {
+                "uv_map": ("UV_MAP",),
+                "mode": (["polar", "wave"], {"default": "polar"}),
+                "polar_strength": (
+                    "FLOAT",
+                    {"default": 1.0, "step": 0.05, "min": -1.0, "max": 1.0},
+                ),
+                "wave_frequency": ("FLOAT", {"default": 10.0}),
+                "wave_amplitude": (
+                    "FLOAT",
+                    {"default": 0.05, "step": 0.05, "min": -1.0, "max": 1.0},
+                ),
+            }
+        }
+
+    RETURN_TYPES = ("UV_MAP",)
+    RETURN_NAMES = ("uv_map",)
+    FUNCTION = "distort_uvs"
+    CATEGORY = "mtb/uv"
+
+    def distort_uvs(
+        self,
+        uv_map: torch.Tensor,
+        mode,
+        polar_strength,
+        wave_frequency,
+        wave_amplitude,
+    ):
+        if mode == "polar":
+            return (self.apply_polar_distortion(uv_map, polar_strength),)
+        elif mode == "wave":
+            return (
+                self.apply_wave_distortion(
+                    uv_map, wave_frequency, wave_amplitude
+                ),
+            )
+        else:
+            raise ValueError(f"Unknown mode {mode}")
+
+    @classmethod
+    def apply_wave_distortion(cls, uv_map, frequency=10.0, amplitude=0.05):
+        """
+        Applies a wave distortion to the UV map and returns an RGB representation.
+
+        Args:
+        - uv_map (torch.Tensor): The UV map tensor.
+        - frequency (float): Frequency of the wave.
+        - amplitude (float): Amplitude of the wave.
+
+        Returns
+        -------
+        - torch.Tensor: Distorted UV map in RGB format.
+        """
+        U = uv_map[:, :, :, 0]
+        V = uv_map[:, :, :, 1]
+
+        # Apply wave distortion
+        V_distorted = V + amplitude * torch.sin(U * frequency * 2 * 3.14159)
+
+        # Clip V values to [0, 1]
+        V_distorted = torch.clamp(V_distorted, 0, 1)
+
+        R = U
+        G = V_distorted
+        B = torch.zeros_like(R)
+
+        return torch.stack([R, G, B], dim=-1)
+
+    @classmethod
+    def apply_polar_distortion(cls, uv_map: torch.Tensor, strength=1.0):
+        """
+        Applies a polar coordinates distortion to the UV map and returns an RGB representation.
+
+        Args:
+        - uv_map (torch.Tensor): The UV map tensor.
+        - strength (float): The strength of the distortion.
+
+        Returns
+        -------
+        - torch.Tensor: Distorted UV map in RGB format.
+        """
+        U = uv_map[:, :, :, 0]
+        V = uv_map[:, :, :, 1]
+
+        # Convert U and V to centered coordinates [-0.5, 0.5]
+        U = U * 2 - 1
+        V = V * 2 - 1
+
+        # Convert to polar coordinates
+        R = torch.sqrt(U * U + V * V)
+        Theta = torch.atan2(V, U)
+
+        # Distort the radius
+        R_distorted = (
+            R + (1.0 - R) * strength
+        )  # Changing this line for intuitive strength
+
+        # Convert back to Cartesian
+        U_distorted = R_distorted * torch.cos(Theta)
+        V_distorted = R_distorted * torch.sin(Theta)
+
+        # Normalize to [0, 1]
+        U_distorted = (U_distorted + 1) / 2
+        V_distorted = (V_distorted + 1) / 2
+
+        # Clip to ensure values are in [0, 1]
+        U_distorted = torch.clamp(U_distorted, 0, 1)
+        V_distorted = torch.clamp(V_distorted, 0, 1)
+
+        R = U_distorted
+        G = V_distorted
+        B = torch.zeros_like(R)
+
+        return torch.stack([R, G, B], dim=-1)
+
+
+__nodes__ = [
+    UvDistort,
+    UvToImage,
+    ImageToUv,
+    ImageDistortWithUv,
+    UvTile,
+    UvRemoveSeams,
+]

nodes/video.py

@@ -1,105 +1,420 @@
+import hashlib
+import json
 import os
 import re
-import torch
+from pathlib import Path
+
+import comfy.utils
+import folder_paths
+import imageio.v3 as iio
 import numpy as np
-import hashlib
+import torch
+from comfy.model_management import get_torch_device
 from PIL import Image, ImageOps
 from PIL.PngImagePlugin import PngInfo
-import folder_paths
-from pathlib import Path
-import json
 
 from ..log import log
-class LoadImageSequence:
-    """Load an image sequence from a folder. The current frame is used to determine which image to load.
+from ..utils import np2tensor
 
-    Usually used in conjunction with the `Primitive` node set to increment to load a sequence of images from a folder.
-    """
+SUPPORTED_FORMATS = ["avi", "mov", "webm", "mp4", "mkv", "gif"]
+
+
+class MTBLiveVideo:
+    @classmethod
+    def INPUT_TYPES(s):
+        input_dir = Path(folder_paths.get_input_directory())
+        files = [
+            f.name
+            for f in input_dir.iterdir()
+            if f.is_file() and f.suffix[1:] in SUPPORTED_FORMATS
+        ]
+        return {
+            "required": {
+                "video": (["custom"] + sorted(files), {"default": "custom"}),
+                "video_path": ("STRING", {"default": ""}),
+                "frame_in": (
+                    "INT",
+                    {"default": 0, "min": 0, "step": 1},
+                ),
+                "frame_out": (
+                    "INT",
+                    {"default": -1, "min": -1, "step": 1},
+                ),
+                "frame_steps": (
+                    "INT",
+                    {"default": 1, "min": 1, "step": 1},
+                ),
+                "device": (["auto", "cpu"], {"default": "auto"}),
+            },
+        }
+
+    CATEGORY = "mtb/video"
+    FUNCTION = "video"
+    RETURN_TYPES = ("IMAGE",)
+    RETURN_NAMES = ("video frames",)
+
+    def video(
+        self,
+        video: str,
+        video_path: str,
+        frame_in=0,
+        frame_out=-1,
+        frame_steps=1,
+        device="auto",
+    ):
+        device = get_torch_device() if device == "auto" else device
+
+        if video == "custom":
+            pth = Path(video_path)
+            if not pth.exists():
+                raise FileNotFoundError(
+                    "The video {pth} doesn't seem to exist"
+                )
+            video = pth.as_posix()
+        else:
+            video = folder_paths.get_annotated_filepath(video.strip('"'))
+
+        frames = []
+        # total = 5
+        # pbar = comfy.utils.ProgressBar(total)
+        for i, frame in enumerate(iio.imiter(video, plugin="FFMPEG")):
+            if (
+                i >= frame_in  # first frame
+                and (i <= frame_out or frame_out == -1)  # in range
+                and i % frame_steps == 0  # stepping
+            ):
+                frames.append(frame)
+
+        return (np2tensor(frames).to(device),)
+
+    @classmethod
+    def IS_CHANGED(cls, video, **parms):
+        image_path = folder_paths.get_annotated_filepath(video)
+        m = hashlib.sha256()
+        with open(image_path, "rb") as f:
+            m.update(f.read())
+        return m.digest().hex()
+
+    @classmethod
+    def VALIDATE_INPUTS(cls, video, **parms):
+        if not folder_paths.exists_annotated_filepath(video):
+            return f"Invalid video file: {video}"
+        return True
+
+
+class MTBCotracker2:
     @classmethod
     def INPUT_TYPES(cls):
         return {
             "required": {
-                "path": ("STRING",{"default":"videos/####.png"}),
-                "current_frame": ("INT",{"default":0, "min":0, "max": 9999999},),
+                "image": ("IMAGE",),
+                "grid_size": (
+                    "INT",
+                    {"default": 10, "min": 1, "max": 100},
+                ),
             }
         }
 
-    CATEGORY = "video"
-    FUNCTION = "load_image"
-    RETURN_TYPES = ("IMAGE", "MASK", "INT",)
-    RETURN_NAMES = ("image", "mask", "current_frame",)
+    CATEGORY = "mtb/video"
+    FUNCTION = "track"
+    RETURN_TYPES = ("COTRACK_DATA",)
+    RETURN_NAMES = ("tracking data",)
 
-    def load_image(self, path=None, current_frame=0):
-        log.debug(f"Loading image: {path}, {current_frame}")
-        print(f"Loading image: {path}, {current_frame}")
-        resolved_path = resolve_path(path, current_frame)
-        image_path = folder_paths.get_annotated_filepath(resolved_path)
-        i = Image.open(image_path)
-        i = ImageOps.exif_transpose(i)
-        image = i.convert("RGB")
-        image = np.array(image).astype(np.float32) / 255.0
-        image = torch.from_numpy(image)[None,]
-        if 'A' in i.getbands():
-            mask = np.array(i.getchannel('A')).astype(np.float32) / 255.0
-            mask = 1. - torch.from_numpy(mask)
-        else:
-            mask = torch.zeros((64, 64), dtype=torch.float32, device="cpu")
-        return (image, mask, current_frame,)
+    def track(self, image: torch.Tensor, grid_size=10):
+        device = get_torch_device()
+        cotracker = torch.hub.load(
+            "facebookresearch/co-tracker", "cotracker2"
+        ).to(device)
+
+        video = (
+            image.permute(0, 3, 1, 2).unsqueeze(0).float().to(device)
+        )  # B T C H W
+        pred_tracks, pred_visibility = cotracker(
+            video, grid_size=grid_size
+        ).to(device)  # B T N 2,  B T N 1
+
+        return (
+            {"pred_tracks": pred_tracks, "pred_visibility": pred_visibility},
+        )
 
     @staticmethod
     def IS_CHANGED(path="", current_frame=0):
         print(f"Checking if changed: {path}, {current_frame}")
-        resolved_path = resolve_path(path, current_frame)
-        image_path = folder_paths.get_annotated_filepath(resolved_path)
-        if os.path.exists(image_path): 
-            m = hashlib.sha256()
-            with open(image_path, 'rb') as f:
-                m.update(f.read())
-            return m.digest().hex()
-        return "NONE"
+        # resolved_path = resolve_path(path, current_frame)
+        # image_path = folder_paths.get_annotated_filepath(resolved_path)
+        # if os.path.exists(image_path):
+        #     m = hashlib.sha256()
+        #     with open(image_path, "rb") as f:
+        #         m.update(f.read())
+        #     return m.digest().hex()
+        # return "NONE"
 
     # @staticmethod
     # def VALIDATE_INPUTS(path="", current_frame=0):
-        
+
     #     print(f"Validating inputs: {path}, {current_frame}")
     #     resolved_path = resolve_path(path, current_frame)
     #     if not folder_paths.exists_annotated_filepath(resolved_path):
     #         return f"Invalid image file: {resolved_path}"
     #     return True
 
+
+class MTB_LoadImageSequence:
+    """Load an image sequence from a folder. The current frame is used to determine which image to load.
+
+    The current_frame property is used to determine which image to load.
+    Usually used in conjunction with the `Primitive` node set to increment
+    Use -1 to load all matching frames as a batch.
+
+    """
+
+    @classmethod
+    def INPUT_TYPES(cls):
+        return {
+            "required": {
+                "path": ("STRING", {"default": "videos/####.png"}),
+                "current_frame": (
+                    "INT",
+                    {"default": 0, "min": -1, "max": 9999999},
+                ),
+            },
+            "optional": {
+                "range": ("STRING", {"default": ""}),
+            },
+        }
+
+    CATEGORY = "mtb/IO"
+    FUNCTION = "load_image"
+    RETURN_TYPES = (
+        "IMAGE",
+        "MASK",
+        "INT",
+        "INT",
+    )
+    RETURN_NAMES = (
+        "image",
+        "mask",
+        "current_frame",
+        "total_frames",
+    )
+
+    def load_image(self, path=None, current_frame=0, range=""):
+        load_all = current_frame == -1
+        total_frames = 1
+
+        if range:
+            frames = self.get_frames_from_range(path, range)
+            imgs, masks = zip(*(img_from_path(frame) for frame in frames))
+            out_img = torch.cat(imgs, dim=0)
+            out_mask = torch.cat(masks, dim=0)
+            total_frames = len(imgs)
+            return (out_img, out_mask, -1, total_frames)
+
+        elif load_all:
+            log.debug(f"Loading all frames from {path}")
+            frames = resolve_all_frames(path)
+            log.debug(f"Found {len(frames)} frames")
+
+            imgs = []
+            masks = []
+
+            imgs, masks = zip(*(img_from_path(frame) for frame in frames))
+
+            out_img = torch.cat(imgs, dim=0)
+            out_mask = torch.cat(masks, dim=0)
+            total_frames = len(imgs)
+
+            return (out_img, out_mask, -1, total_frames)
+
+        log.debug(f"Loading image: {path}, {current_frame}")
+        resolved_path = resolve_path(path, current_frame)
+        image_path = folder_paths.get_annotated_filepath(resolved_path)
+        image, mask = img_from_path(image_path)
+        return (image, mask, current_frame, total_frames)
+
+    def get_frames_from_range(self, path, range_str):
+        try:
+            start, end = map(int, range_str.split("-"))
+        except ValueError:
+            raise ValueError(
+                f"Invalid range format: {range_str}. Expected format is 'start-end'."
+            )
+
+        frames = resolve_all_frames(path)
+        total_frames = len(frames)
+
+        if start < 0 or end >= total_frames:
+            raise ValueError(
+                f"Range {range_str} is out of bounds. Total frames available: {total_frames}"
+            )
+
+        if "#" in path:
+            frame_regex = re.escape(path).replace(r"\#", r"(\d+)")
+            frame_number_regex = re.compile(frame_regex)
+
+            matching_frames = []
+            for frame in frames:
+                match = frame_number_regex.search(frame)
+
+                if match:
+                    frame_number = int(match.group(1))
+                    if start <= frame_number <= end:
+                        matching_frames.append(frame)
+
+            return matching_frames
+        else:
+            log.warning(
+                f"Wildcard pattern or directory will use indexes instead of frame numbers for : {path}"
+            )
+
+            selected_frames = frames[start : end + 1]
+
+        return selected_frames
+
+    @staticmethod
+    def IS_CHANGED(path="", current_frame=0, range=""):
+        print(f"Checking if changed: {path}, {current_frame}")
+        if range or current_frame == -1:
+            resolved_paths = resolve_all_frames(path)
+            timestamps = [
+                os.path.getmtime(folder_paths.get_annotated_filepath(p))
+                for p in resolved_paths
+            ]
+            combined_hash = hashlib.sha256(
+                "".join(map(str, timestamps)).encode()
+            )
+            return combined_hash.hexdigest()
+        resolved_path = resolve_path(path, current_frame)
+        image_path = folder_paths.get_annotated_filepath(resolved_path)
+        if os.path.exists(image_path):
+            m = hashlib.sha256()
+            with open(image_path, "rb") as f:
+                m.update(f.read())
+            return m.digest().hex()
+        return "NONE"
+
+    # @staticmethod
+    # def VALIDATE_INPUTS(path="", current_frame=0):
+
+    #     print(f"Validating inputs: {path}, {current_frame}")
+    #     resolved_path = resolve_path(path, current_frame)
+    #     if not folder_paths.exists_annotated_filepath(resolved_path):
+    #         return f"Invalid image file: {resolved_path}"
+    #     return True
+
+
+import glob
+
+
+def img_from_path(path):
+    img = Image.open(path)
+    img = ImageOps.exif_transpose(img)
+    image = img.convert("RGB")
+    image = np.array(image).astype(np.float32) / 255.0
+    image = torch.from_numpy(image)[None,]
+    if "A" in img.getbands():
+        mask = np.array(img.getchannel("A")).astype(np.float32) / 255.0
+        mask = 1.0 - torch.from_numpy(mask)
+    else:
+        mask = torch.zeros((64, 64), dtype=torch.float32, device="cpu")
+    return (
+        image,
+        mask,
+    )
+
+
+def resolve_all_frames(path: str):
+    frames: list[str] = []
+    if "#" not in path:
+        pth = Path(path)
+        if pth.is_dir():
+            for f in pth.iterdir():
+                if f.suffix in [".jpg", ".png"]:
+                    frames.append(f.as_posix())
+        elif "*" in path:
+            frames = glob.glob(path)
+        else:
+            raise ValueError(
+                "The path doesn't contain a # or a * or is not a directory"
+            )
+        frames.sort()
+
+        return frames
+
+    pattern = path
+    folder_path, file_pattern = os.path.split(pattern)
+
+    log.debug(f"Resolving all frames in {folder_path}")
+    hash_count = file_pattern.count("#")
+    frame_pattern = re.sub(r"#+", "*", file_pattern)
+
+    log.debug(f"Found pattern: {frame_pattern}")
+
+    matching_files = glob.glob(os.path.join(folder_path, frame_pattern))
+
+    log.debug(f"Found {len(matching_files)} matching files")
+
+    frame_regex = re.escape(file_pattern).replace(r"\#", r"(\d+)")
+
+    frame_number_regex = re.compile(frame_regex)
+
+    for file in matching_files:
+        match = frame_number_regex.search(file)
+        if match:
+            frame_number = match.group(1)
+            log.debug(f"Found frame number: {frame_number}")
+            # resolved_file = pattern.replace("*" * frame_number.count("#"), frame_number)
+            frames.append(file)
+
+    frames.sort()  # Sort frames alphabetically
+    return frames
+
+
 def resolve_path(path, frame):
     hashes = path.count("#")
     padded_number = str(frame).zfill(hashes)
     return re.sub("#+", padded_number, path)
 
-class SaveImageSequence:
+
+class MTB_SaveImageSequence:
     """Save an image sequence to a folder. The current frame is used to determine which image to save.
 
     This is merely a wrapper around the `save_images` function with formatting for the output folder and filename.
     """
+
     def __init__(self):
         self.output_dir = folder_paths.get_output_directory()
         self.type = "output"
-        
 
     @classmethod
     def INPUT_TYPES(cls):
-        return {"required": {
-                    "images": ("IMAGE", ),
-                    "filename_prefix": ("STRING", {"default": "Sequence"}),
-                    "current_frame": ("INT", {"default": 0, "min": 0, "max": 9999999}),
-                    },
-                "hidden": {"prompt": "PROMPT", "extra_pnginfo": "EXTRA_PNGINFO"},
-                }
+        return {
+            "required": {
+                "images": ("IMAGE",),
+                "filename_prefix": ("STRING", {"default": "Sequence"}),
+                "current_frame": (
+                    "INT",
+                    {"default": 0, "min": 0, "max": 9999999},
+                ),
+            },
+            "hidden": {"prompt": "PROMPT", "extra_pnginfo": "EXTRA_PNGINFO"},
+        }
 
     RETURN_TYPES = ()
     FUNCTION = "save_images"
 
     OUTPUT_NODE = True
 
-    CATEGORY = "image"
+    CATEGORY = "mtb/IO"
 
-    def save_images(self, images, filename_prefix="Sequence", current_frame=0, prompt=None, extra_pnginfo=None):
+    def save_images(
+        self,
+        images,
+        filename_prefix="Sequence",
+        current_frame=0,
+        prompt=None,
+        extra_pnginfo=None,
+    ):
         # full_output_folder, filename, counter, subfolder, filename_prefix = folder_paths.get_save_image_path(filename_prefix, self.output_dir, images[0].shape[1], images[0].shape[0])
         # results = list()
         # for image in images:
@@ -120,30 +435,43 @@ class SaveImageSequence:
         #         "type": self.type
         #     })
         #     counter += 1
-    
+
         if len(images) > 1:
             raise ValueError("Can only save one image at a time")
-        
+
         resolved_path = Path(self.output_dir) / filename_prefix
         resolved_path.mkdir(parents=True, exist_ok=True)
-        
-        resolved_img = resolved_path / f"{filename_prefix}_{current_frame:05}.png"
-        
+
+        resolved_img = (
+            resolved_path / f"{filename_prefix}_{current_frame:05}.png"
+        )
+
         output_image = images[0].cpu().numpy()
-        img = Image.fromarray(np.clip(output_image * 255., 0, 255).astype(np.uint8))
+        img = Image.fromarray(
+            np.clip(output_image * 255.0, 0, 255).astype(np.uint8)
+        )
         metadata = PngInfo()
         if prompt is not None:
             metadata.add_text("prompt", json.dumps(prompt))
         if extra_pnginfo is not None:
             for x in extra_pnginfo:
                 metadata.add_text(x, json.dumps(extra_pnginfo[x]))
-                
+
         img.save(resolved_img, pnginfo=metadata, compress_level=4)
-        return { "ui": { "images": [ { "filename": resolved_img.name, "subfolder": resolved_path.name, "type": self.type } ] } }
-                
-                
-        
+        return {
+            "ui": {
+                "images": [
+                    {
+                        "filename": resolved_img.name,
+                        "subfolder": resolved_path.name,
+                        "type": self.type,
+                    }
+                ]
+            }
+        }
+
+
 __nodes__ = [
-    LoadImageSequence,
-    SaveImageSequence,
-]
+    MTB_LoadImageSequence,
+    MTB_SaveImageSequence,
+]

nodes/vitmatte.py

@@ -0,0 +1,141 @@
+import cv2
+import numpy as np
+import torch
+from huggingface_hub import hf_hub_download
+
+from ..utils import models_dir, np2tensor
+
+# TODO: check if I can make a torch script device independant
+# for now I forced it to use cuda.
+
+
+class MTB_LoadVitMatteModel:
+    @classmethod
+    def INPUT_TYPES(cls):
+        return {
+            "required": {
+                "kind": (("Composition-1K", "Distinctions-646"),),
+                "autodownload": ("BOOLEAN", {"default": True}),
+            },
+        }
+
+    RETURN_TYPES = ("VITMATTE_MODEL",)
+    RETURN_NAMES = ("torch_script",)
+    CATEGORY = "mtb/vitmatte"
+    FUNCTION = "execute"
+
+    def execute(self, *, kind: str, autodownload: bool):
+        dest = models_dir / "vitmatte"
+        dest.mkdir(exist_ok=True)
+        name = "dist" if kind == "Distinctions-646" else "com"
+
+        file = hf_hub_download(
+            repo_id="melmass/pytorch-scripts",
+            filename=f"vitmatte_b_{name}.pt",
+            local_dir=dest.as_posix(),
+            local_files_only=not autodownload,
+        )
+        model = torch.jit.load(file).to("cuda")
+
+        return (model,)
+
+
+class MTB_GenerateTrimap:
+    @classmethod
+    def INPUT_TYPES(cls):
+        return {
+            "required": {
+                # "image": ("IMAGE",),
+                "mask": ("MASK",),
+                "erode": ("INT", {"default": 10}),
+                "dilate": ("INT", {"default": 10}),
+            },
+        }
+
+    RETURN_TYPES = ("IMAGE",)
+    RETURN_NAMES = ("trimap",)
+
+    CATEGORY = "mtb/vitmatte"
+    FUNCTION = "execute"
+
+    def execute(
+        self,
+        # image:torch.Tensor,
+        mask: torch.Tensor,
+        erode: int = 10,
+        dilate: int = 10,
+    ):
+        # TODO: not sure what's the most practical between IMAGE or MASK
+
+        # image = image.to("cuda").half()
+        mask = mask.to("cuda").half()
+
+        trimaps = []
+        for m in mask:
+            mask_arr = m.squeeze(0).to(torch.uint8).cpu().numpy() * 255
+            erode_kernel = np.ones((erode, erode), np.uint8)
+            dilate_kernel = np.ones((dilate, dilate), np.uint8)
+            eroded = cv2.erode(mask_arr, erode_kernel, iterations=5)
+            dilated = cv2.dilate(mask_arr, dilate_kernel, iterations=5)
+            trimap = np.zeros_like(mask_arr)
+            trimap[dilated == 255] = 128
+            trimap[eroded == 255] = 255
+            trimaps.append(trimap)
+
+        return (np2tensor(trimaps),)
+
+
+class MTB_ApplyVitMatte:
+    @classmethod
+    def INPUT_TYPES(cls):
+        return {
+            "required": {
+                "model": ("VITMATTE_MODEL",),
+                "image": ("IMAGE",),
+                "trimap": ("IMAGE",),
+                "returns": (("RGB", "RGBA"),),
+            },
+        }
+
+    RETURN_TYPES = ("IMAGE", "MASK")
+    RETURN_NAMES = ("image (rgba)", "mask")
+    CATEGORY = "mtb/utils"
+    FUNCTION = "execute"
+
+    def execute(
+        self, model, image: torch.Tensor, trimap: torch.Tensor, returns: str
+    ):
+        im_count = image.shape[0]
+        tm_count = trimap.shape[0]
+
+        if im_count != tm_count:
+            raise ValueError("image and trimap must have the same batch size")
+
+        outputs_m: list[torch.Tensor] = []
+        outputs_i: list[torch.Tensor] = []
+        for i, im in enumerate(image):
+            tm = trimap[i].half().unsqueeze(2).permute(2, 0, 1).to("cuda")
+            im = im.half().permute(2, 0, 1).to("cuda")
+
+            inputs = {"image": im.unsqueeze(0), "trimap": tm.unsqueeze(0)}
+
+            fine_mask = model(inputs)
+            foreground = im * fine_mask + (1 - fine_mask)
+
+            if returns == "RGBA":
+                rgba_image = torch.cat(
+                    (foreground, fine_mask.unsqueeze(0)), dim=0
+                )
+                outputs_i.append(rgba_image.unsqueeze(0))
+            else:
+                outputs_i.append(foreground.unsqueeze(0))
+
+            outputs_m.append(fine_mask.unsqueeze(0))
+
+        result_m = torch.cat(outputs_m, dim=0)
+        result_i = torch.cat(outputs_i, dim=0)
+
+        return (result_i.permute(0, 2, 3, 1), result_m)
+
+
+__nodes__ = [MTB_LoadVitMatteModel, MTB_GenerateTrimap, MTB_ApplyVitMatte]

pyproject.toml

@@ -0,0 +1,185 @@
+[build-system]
+requires = ["setuptools", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "comfy-mtb"
+version = "0.2.0"
+description = "Animation oriented nodes pack for ComfyUI."
+license = "MIT"
+readme = "README.md"
+# repository = ""
+# url = "https://github.com/melMass/comfy_mtb"
+authors = [{ name = "Mel Massadian", email = "mel@melmassadian.com" }]
+classifiers = [
+  "License :: OSI Approved :: MIT License",
+  "Operating System :: OS Independent",
+  "Programming Language :: Python",
+  "Programming Language :: Python :: 3",
+  "Programming Language :: Python :: 3.10",
+  "Programming Language :: Python :: 3.11",
+  "Intended Audience :: Developers",
+]
+requires-python = ">=3.10"
+dependencies = [
+  "qrcode",
+  "cachetools",
+  "onnxruntime-gpu",
+  "requirements-parserx",
+  "rembg",
+  "imageio_ffmpeg",
+  "rich",
+  "rich_argparse",
+  "matplotlib",
+  "pillow",
+]
+optional-dependencies = { mel = [
+  "jupyterlab==4.1.6",
+], dev = [
+  "black[jupyter]",
+  "codespell",
+  "mypy",
+  "pre-commit",
+  "pytest",
+  "pytest-cov",
+  "pytest-random-order",
+  "ruff",
+], doc = [
+  "docutils==0.17.1",
+  "jupyter-book>=0.15",
+  "sphinx-autobuild",
+] }
+
+[project.urls]
+Homepage = "https://github.com/melMass/comfy_mtb"
+Documentation = "https://github.com/melMass/comfy_mtb/wiki"
+Repository = "https://github.com/melMass/comfy_mtb"
+Issues = "https://github.com/melMass/comfy_mtb/issues"
+
+[tool.comfy]
+PublisherId = "mel"
+DisplayName = "comfy-mtb"
+Icon = "https://avatars.githubusercontent.com/u/7041726?v=4"
+
+[tool.bumpversion]
+current_version = "0.2.0"
+parse = "(?P<major>\\d+)\\.(?P<minor>\\d+)\\.(?P<patch>\\d+)"
+serialize = ["{major}.{minor}.{patch}"]
+search = "{current_version}"
+replace = "{new_version}"
+regex = false
+ignore_missing_version = false
+ignore_missing_files = false
+tag = true
+sign_tags = true
+tag_name = "v{new_version}"
+tag_message = "⬆️ Bump version: {current_version} → {new_version}"
+allow_dirty = true
+commit = true
+message = "⬆️ Bump version: {current_version} → {new_version}"
+commit_args = ""
+
+[[tool.bumpversion.files]]
+filename = "__init__.py"
+search = "__version__ = \"{current_version}\""
+replace = "__version__ = \"{new_version}\""
+
+[[tool.bumpversion.files]]
+filename = "pyproject.toml"
+search = "version = \"{current_version}\""
+replace = "version = \"{new_version}\""
+
+# [[tool.bumpversion.files]]
+# filename = "your_package/__init__.py"
+# search = "__version__ = '{current_version}'"
+# replace = "__version__ = '{new_version}'"
+
+# INFO: All those remaining keys are meant for local dev
+[tool.pyright]
+include = ["."]
+exclude = [
+  "**/node_modules",
+  "**/__pycache__",
+  "src/experimental",
+  "src/typestubs",
+]
+ignore = ["src/oldstuff"]
+defineConstant = { DEBUG = true }
+extraPaths = ["python", "../.."]
+stubPath = "src/stubs"
+
+reportMissingImports = true
+reportMissingTypeStubs = false
+typeCheckingMode = "basic"
+
+pythonVersion = "3.10"
+pythonPlatform = "Windows"
+
+[tool.pytest.ini_options]
+log_level = "DEBUG"
+log_cli = true
+markers = [
+  "wip: tests that aren't fully finished yet",
+  "heavy: marks tests as heavy (deselect with '-m \"not heavy\"')",
+
+]
+filterwarnings = ["ignore::UserWarning", 'ignore::DeprecationWarning']
+
+[tool.isort]
+profile = "black"
+line_length = 88
+auto_identify_namespace_packages = false
+# NOTE:
+# pyright doesn't like implicit namespace + single line (related to https://github.com/microsoft/pyright/issues/2882?) but it's horible so I'll live with it
+force_single_line = false
+known_first_party = ["mtb"]
+extend_skip = ["archives"]
+combine_straight_imports = true
+
+[tool.coverage.run]
+parallel = true
+source = ["docs", "tests", "comfy-mtb"]
+
+[tool.coverage.report]
+fail_under = 90
+show_missing = true
+
+[tool.coverage.html]
+show_contexts = true
+
+# for now ignoring
+# D100 - document public modules
+# D102 - document public methods of a class
+[tool.ruff]
+line-length = 79
+select = ["A", "B", "C", "D", "E", "F", "FBT", "I", "N", "S", "SIM", "UP", "W"]
+# NOTE:
+# D102 - undocumented-public-method (noisy)
+# D103 - undocumented-public-function (noisy)
+# D100 - undocumented-public-module (noisy)
+ignore = ["D103", "D102", "D100"]
+# exclude auto generated file
+extend-exclude = ["./docs/conf.py"]
+
+[tool.ruff.lint.pep8-naming]
+extend-ignore-names = ["INPUT_TYPES", "_DEFAULT_INTERPOLANT"]
+
+[tool.ruff.per-file-ignores]
+# imported but unused
+"__init__.py" = ["F401"]
+# use of assert detected
+"tests/*" = ["S101"]
+
+[tool.ruff.pydocstyle]
+convention = "numpy"
+
+[tool.mypy]
+pretty = true
+ignore_missing_imports = true
+# exclude auto generated file
+exclude = ["docs/conf.py"]
+
+[tool.codespell]
+# exclude auto generated file
+skip = "./docs/conf.py,poetry.lock"
+check-filenames = true

pyrightconfig.json

@@ -0,0 +1,18 @@
+{
+    "exclude": [
+        "**/node_modules",
+        "**/__pycache__",
+    ],
+    "ignore": [
+        "extern"
+    ],
+    "defineConstant": {
+        "DEBUG": true
+    },
+    "venvPath": "../../../.venv/",
+    "reportMissingImports": true,
+    "reportMissingTypeStubs": false,
+    "pythonVersion": "3.10",
+    "pythonPlatform": "All",
+    "reportOptionalMemberAccess": "none"
+}

requirements-wheels.txt

@@ -1,3 +0,0 @@
-insightface==0.7.3
-mmcv==2.0.0
-mmdet==3.0.0

requirements.txt

@@ -1,9 +1,16 @@
-onnxruntime-gpu
-imageio
 qrcode[pil]
-numpy==1.23.5
-ifnude==0.0.3
-insightface==0.7.3
-mmcv==2.0.0
-mmdet==3.0.0
-rembg==2.0.37
+onnxruntime-gpu
+requirements-parser
+# opencv-contrib
+rembg
+imageio_ffmpeg
+rich
+rich_argparse
+matplotlib
+pillow
+
+imageio
+imageio-ffmpeg
+aiohttp-cors
+open3d==0.17.0
+cachetools

scripts/a111_extract.py

@@ -0,0 +1,112 @@
+from pathlib import Path
+from PIL import Image
+from PIL.PngImagePlugin import PngImageFile, PngInfo
+import json
+from pprint import pprint
+import argparse
+from rich.console import Console
+from rich.progress import Progress
+from rich_argparse import RichHelpFormatter
+
+
+def parse_a111(params, verbose=False):
+    # params = [p.split(": ") for p in params.split("\n")]
+    params = params.split("\n")
+
+    prompt = params[0].strip()
+    neg = params[1].split(":")[1].strip()
+
+    settings = {}
+    try:
+        settings = {
+            s.split(":")[0].strip(): s.split(":")[1].strip()
+            for s in params[2].split(",")
+        }
+
+    except IndexError:
+        settings = {"raw": params[2].strip()}
+
+    if verbose:
+        print(f"PROMPT: {prompt}")
+        print(f"NEG: {neg}")
+        print("SETTINGS:")
+        pprint(settings, indent=4)
+
+    return {"prompt": prompt, "negative": neg, "settings": settings}
+
+
+import glob
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(
+        description="Crude metadata extractor from A111 pngs",
+        formatter_class=RichHelpFormatter
+    )
+    parser.add_argument("inputs", nargs="*", help="Input image files")
+    parser.add_argument("--output", help="Output JSON file")
+    parser.add_argument("-v", "--verbose", action="store_true", help="Verbose mode")
+    parser.add_argument(
+        "--glob", help="Enable glob pattern matching", metavar="PATTERN"
+    )
+
+    args = parser.parse_args()
+
+    # - checks
+    if not args.glob and not args.inputs:
+        parser.error("Either --glob flag or inputs must be provided.")
+    if args.glob:
+        glob_pattern = args.glob
+        try:
+            pattern_path = str(Path(glob_pattern).expanduser().resolve())
+
+            if not any(glob.glob(pattern_path)):
+                raise ValueError(f"No files found for glob pattern: {glob_pattern}")
+        except Exception as e:
+            console = Console()
+            console.print(
+                f"[bold red]Error: Invalid glob pattern '{glob_pattern}': {e}[/bold red]"
+            )
+
+            exit(1)
+    else:
+        glob_pattern = None
+
+    input_files = []
+
+    if glob_pattern:
+        input_files = list(glob.glob(str(Path(glob_pattern).expanduser().resolve())))
+    else:
+        input_files = [Path(p) for p in args.inputs]
+
+    console = Console()
+    console.print("Input Files:", style="bold", end=" ")
+    console.print(f"{len(input_files):03d} files", style="cyan")
+    # for input_file in args.inputs:
+    #     console.print(f"- {input_file}", style="cyan")
+    console.print("\nOutput File:", style="bold", end=" ")
+    console.print(f"{Path(args.output).resolve().absolute()}", style="cyan")
+
+    with Progress(console=console, auto_refresh=True) as progress:
+        # files = Path(pth).rglob("*.png")
+        unique_info = {}
+        last = None
+
+        task = progress.add_task("[cyan]Extracting meta...", total=len(input_files) + 1)
+        for p in input_files:
+            im = Image.open(p)
+            parsed = parse_a111(im.info["parameters"], args.verbose)
+
+            if parsed != last:
+                unique_info[Path(p).stem] = parsed
+
+            last = parsed
+            progress.update(task, advance=1)
+            progress.refresh()
+
+        unique_info = json.dumps(unique_info, indent=4)
+        with open(args.output, "w") as f:
+            f.write(unique_info)
+            progress.update(task, advance=1)
+            progress.refresh()
+
+    console.print("\nProcessing completed!", style="bold green")

scripts/comfy_meta.py

@@ -0,0 +1,213 @@
+import argparse
+import json
+from PIL import Image, PngImagePlugin
+from rich.console import Console
+from rich import print
+from rich_argparse import RichHelpFormatter
+import os
+from pathlib import Path
+
+console = Console()
+
+# BNK_CutoffSetRegions
+# BNK_CutoffRegionsToConditioning
+# BNK_CutoffBasePrompt
+
+
+# Extracts metadata from a PNG image and returns it as a dictionary
+def extract_metadata(image_path):
+    image = Image.open(image_path)
+    prompt = image.info.get("prompt", "")
+    workflow = image.info.get("workflow", "")
+
+    if workflow:
+        workflow = json.loads(workflow)
+
+    if prompt:
+        prompt = json.loads(prompt)
+
+    console.print(f"Metadata extracted from [cyan]{image_path}[/cyan].")
+
+    return {
+        "prompt": prompt,
+        "workflow": workflow,
+    }
+
+
+# Embeds metadata into a PNG image
+def embed_metadata(image_path, metadata):
+    image = Image.open(image_path)
+    o_metadata = image.info
+
+    pnginfo = PngImagePlugin.PngInfo()
+    if prompt := metadata.get("prompt"):
+        pnginfo.add_text("prompt", json.dumps(prompt))
+    elif "prompt" in o_metadata:
+        pnginfo.add_text("prompt", o_metadata["prompt"])
+
+    if workflow := metadata.get("workflow"):
+        pnginfo.add_text("workflow", json.dumps(workflow))
+    elif "workflow" in o_metadata:
+        pnginfo.add_text("workflow", o_metadata["workflow"])
+
+    imgp = Path(image_path)
+    output = imgp.with_stem(f"{imgp.stem}_comfy_embed")
+    index = 1
+    while output.exists():
+        output = imgp.with_stem(f"{imgp.stem}_{index}_comfy_embed").with_suffix(".png")
+        index += 1
+
+    image.save(output, pnginfo=pnginfo)
+    console.print(f"Metadata embedded into [cyan]{output}[/cyan].")
+
+
+# CLI subcommand: extract
+def extract(args):
+    input_files = []
+    for input_path in args.input:
+        if os.path.isdir(input_path):
+            folder_path = input_path
+            input_files.extend(
+                [
+                    os.path.join(folder_path, file_name)
+                    for file_name in os.listdir(folder_path)
+                    if file_name.lower().endswith((".png", ".jpg", ".jpeg"))
+                ]
+            )
+        else:
+            input_files.append(input_path)
+
+    if len(input_files) == 1:
+        metadata = extract_metadata(input_files[0])
+        if args.print_output:
+            print(json.dumps(metadata, indent=4))
+        else:
+            if not args.output:
+                output = Path(input_files[0]).with_suffix(".json")
+                index = 1
+                while output.exists():
+                    output = (
+                        Path(input_files[0])
+                        .with_stem(f"{Path(input_files[0]).stem}_{index}")
+                        .with_suffix(".json")
+                    )
+                    index += 1
+            else:
+                output = args.output
+            with open(output, "w") as file:
+                json.dump(metadata, file, indent=4)
+            console.print(f"Metadata extracted and saved to [cyan]{output}[/cyan].")
+    else:
+        metadata_dict = {}
+        for input_file in input_files:
+            metadata = extract_metadata(input_file)
+            filename = os.path.basename(input_file)
+            output = (
+                Path(args.output) / f"{filename}.json"
+                if args.output
+                else Path(input_file).with_suffix(".json")
+            )
+            index = 1
+            while output.exists():
+                output = Path(args.output).parent / f"{filename}_{index}.json"
+                index += 1
+            with open(output, "w") as file:
+                json.dump(metadata, file, indent=4)
+            metadata_dict[filename] = metadata
+        if args.output:
+            with open(args.output, "w") as file:
+                json.dump(metadata_dict, file, indent=4)
+            console.print(
+                f"Metadata extracted and saved to [cyan]{args.output}[/cyan]."
+            )
+        else:
+            console.print("Multiple metadata files created.")
+
+
+# CLI subcommand: embed
+def embed(args):
+    input_files = []
+    for input_path in args.input:
+        if os.path.isdir(input_path):
+            folder_path = input_path
+            input_files.extend(
+                [
+                    os.path.join(folder_path, file_name)
+                    for file_name in os.listdir(folder_path)
+                    if file_name.lower().endswith(".json")
+                ]
+            )
+        else:
+            input_files.append(input_path)
+
+    for input_file in input_files:
+        with open(input_file) as file:
+            metadata = json.load(file)
+        image_path = input_file.replace(".json", ".png")
+        if args.output:
+            output_dir = args.output
+            if os.path.isdir(output_dir):
+                output_path = os.path.join(output_dir, os.path.basename(image_path))
+                index = 1
+                while os.path.exists(output_path):
+                    output_path = os.path.join(
+                        output_dir,
+                        f"{os.path.basename(image_path)}_{index}.png",
+                    )
+                    index += 1
+            else:
+                output_path = output_dir
+        else:
+            output_path = image_path.replace(".png", "_comfy_embed.png")
+
+        embed_metadata(image_path, metadata)
+        # os.rename(image_path, output_path)
+        console.print(f"Metadata embedded into [cyan]{output_path}[/cyan].")
+
+
+if __name__ == "__main__":
+    # Create the main CLI parser
+    parser = argparse.ArgumentParser(
+        prog="image-metadata-cli", formatter_class=RichHelpFormatter
+    )
+    subparsers = parser.add_subparsers(title="subcommands")
+
+    # Parser for the "extract" subcommand
+    extract_parser = subparsers.add_parser(
+        "extract",
+        help="Extract metadata from PNG image(s) or folder",
+        formatter_class=RichHelpFormatter,
+    )
+    extract_parser.add_argument(
+        "input", nargs="+", help="Input PNG image file(s) or folder path"
+    )
+    extract_parser.add_argument(
+        "--print",
+        dest="print_output",
+        action="store_true",
+        help="Print the output to stdout",
+    )
+    extract_parser.add_argument("--output", help="Output JSON file(s) or directory")
+    extract_parser.set_defaults(func=extract)
+
+    # Parser for the "embed" subcommand
+    embed_parser = subparsers.add_parser(
+        "embed",
+        help="Embed metadata into PNG image(s) or folder",
+        formatter_class=RichHelpFormatter,
+    )
+    embed_parser.add_argument(
+        "input", nargs="+", help="Input JSON file(s) or folder path"
+    )
+    embed_parser.add_argument("--output", help="Output PNG image file(s) or directory")
+    embed_parser.set_defaults(func=embed)
+
+    # Parse the command-line arguments and execute the appropriate subcommand
+    args = parser.parse_args()
+    if hasattr(args, "func"):
+        try:
+            args.func(args)
+        except ValueError as e:
+            console.print(f"[bold red]Error:[/bold red] {str(e)}")
+    else:
+        parser.print_help()

scripts/download_models.py

@@ -2,6 +2,8 @@ import os
 import requests
 from rich.console import Console
 from tqdm import tqdm
+import subprocess
+import sys
 
 try:
     import folder_paths
@@ -26,6 +28,25 @@ models_to_download = {
         ],
         "destination": "insightface",
     },
+    "GFPGAN (face enhancement)": {
+        "size": 332,
+        "download_url": [
+            "https://github.com/TencentARC/GFPGAN/releases/download/v1.3.0/GFPGANv1.3.pth",
+            "https://github.com/TencentARC/GFPGAN/releases/download/v1.3.0/GFPGANv1.4.pth"
+            # TODO: provide a way to selectively download models from "packs"
+            # https://github.com/TencentARC/GFPGAN/releases/download/v0.1.0/GFPGANv1.pth
+            # https://github.com/TencentARC/GFPGAN/releases/download/v0.2.0/GFPGANCleanv1-NoCE-C2.pth
+            # https://github.com/TencentARC/GFPGAN/releases/download/v1.3.4/RestoreFormer.pth
+        ],
+        "destination": "face_restore",
+    },
+    "FILM: Frame Interpolation for Large Motion": {
+        "size": 402,
+        "download_url": [
+            "https://drive.google.com/drive/folders/131_--QrieM4aQbbLWrUtbO2cGbX8-war"
+        ],
+        "destination": "FILM",
+    },
 }
 
 console = Console()
@@ -41,6 +62,35 @@ def download_model(download_url, destination):
         return
 
     filename = os.path.basename(urlparse(download_url).path)
+    response = None
+    if "drive.google.com" in download_url:
+        try:
+            import gdown
+        except ImportError:
+            print("Installing gdown")
+            subprocess.check_call(
+                [
+                    sys.executable,
+                    "-m",
+                    "pip",
+                    "install",
+                    "git+https://github.com/melMass/gdown@main",
+                ]
+            )
+            import gdown
+
+        if "/folders/" in download_url:
+            # download folder
+            try:
+                gdown.download_folder(download_url, output=destination, resume=True)
+            except TypeError:
+                gdown.download_folder(download_url, output=destination)
+
+            return
+        # download from google drive
+        gdown.download(download_url, destination, quiet=False, resume=True)
+        return
+
     response = requests.get(download_url, stream=True)
     total_size = int(response.headers.get("content-length", 0))
 
@@ -93,7 +143,7 @@ def handle_interrupt():
     console.print("Interrupted by user.", style="bold red")
 
 
-def main(models_to_download):
+def main(models_to_download, skip_input=False):
     try:
         models_to_download_selected = {}
 
@@ -129,13 +179,16 @@ def main(models_to_download):
             console.print("No new models to download.")
             return
 
-        models_to_download_selected = ask_user_for_downloads(
-            models_to_download_selected
+        models_to_download_selected = (
+            ask_user_for_downloads(models_to_download_selected)
+            if not skip_input
+            else models_to_download_selected
         )
 
         for model_name, model_details in models_to_download_selected.items():
             download_url = model_details["download_url"]
             destination = model_details["destination"]
+            console.print(f"Downloading {model_name}...")
             download_model(download_url, destination)
 
     except KeyboardInterrupt:
@@ -143,4 +196,10 @@ def main(models_to_download):
 
 
 if __name__ == "__main__":
-    main(models_to_download)
+    import argparse
+
+    parser = argparse.ArgumentParser()
+    parser.add_argument("-y", "--yes", action="store_true", help="skip user input")
+
+    args = parser.parse_args()
+    main(models_to_download, args.yes)

scripts/interpolate_frames.py

@@ -0,0 +1,142 @@
+import glob
+from pathlib import Path
+import uuid
+import sys
+from typing import List
+
+sys.path.append((Path(__file__).parent / "extern").as_posix())
+
+
+import argparse
+from rich_argparse import RichHelpFormatter
+from rich.console import Console
+from rich.progress import Progress
+
+import numpy as np
+import subprocess
+
+
+def write_prores_444_video(output_file, frames: List[np.ndarray], fps):
+    # Convert float images to the range of 0-65535 (12-bit color depth)
+    frames = [(frame * 65535).clip(0, 65535).astype(np.uint16) for frame in frames]
+
+    height, width, _ = frames[0].shape
+
+    # Prepare the FFmpeg command
+    command = [
+        "ffmpeg",
+        "-y",  # Overwrite output file if it already exists
+        "-f",
+        "rawvideo",
+        "-vcodec",
+        "rawvideo",
+        "-s",
+        f"{width}x{height}",
+        "-pix_fmt",
+        "rgb48le",
+        "-r",
+        str(fps),
+        "-i",
+        "-",
+        "-c:v",
+        "prores_ks",
+        "-profile:v",
+        "4",
+        "-pix_fmt",
+        "yuva444p10le",
+        "-r",
+        str(fps),
+        "-y",  # Overwrite output file if it already exists
+        output_file,
+    ]
+
+    process = subprocess.Popen(command, stdin=subprocess.PIPE)
+
+    for frame in frames:
+        process.stdin.write(frame.tobytes())
+
+    process.stdin.close()
+    process.wait()
+
+
+if __name__ == "__main__":
+    default_output = f"./output_{uuid.uuid4()}.mov"
+    parser = argparse.ArgumentParser(
+        description="FILM frame interpolation", formatter_class=RichHelpFormatter
+    )
+    parser.add_argument("inputs", nargs="*", help="Input image files")
+    parser.add_argument("--output", help="Output JSON file", default=default_output)
+    parser.add_argument("-v", "--verbose", action="store_true", help="Verbose mode")
+    parser.add_argument(
+        "--glob", help="Enable glob pattern matching", metavar="PATTERN"
+    )
+    parser.add_argument(
+        "--interpolate", type=int, default=4, help="Time for interpolated frames"
+    )
+    parser.add_argument("--fps", type=int, default=30, help="Out FPS")
+    align = 64
+    block_width = 2
+    block_height = 2
+
+    args = parser.parse_args()
+
+    # - checks
+    if not args.glob and not args.inputs:
+        parser.error("Either --glob flag or inputs must be provided.")
+    if args.glob:
+        glob_pattern = args.glob
+        try:
+            pattern_path = str(Path(glob_pattern).expanduser().resolve())
+
+            if not any(glob.glob(pattern_path)):
+                raise ValueError(f"No files found for glob pattern: {glob_pattern}")
+        except Exception as e:
+            console = Console()
+            console.print(
+                f"[bold red]Error: Invalid glob pattern '{glob_pattern}': {e}[/bold red]"
+            )
+
+            exit(1)
+    else:
+        glob_pattern = None
+
+    input_files: List[Path] = []
+
+    if glob_pattern:
+        input_files = [
+            Path(p)
+            for p in list(glob.glob(str(Path(glob_pattern).expanduser().resolve())))
+        ]
+    else:
+        input_files = [Path(p) for p in args.inputs]
+
+    console = Console()
+    console.print("Input Files:", style="bold", end=" ")
+    console.print(f"{len(input_files):03d} files", style="cyan")
+    # for input_file in args.inputs:
+    #     console.print(f"- {input_file}", style="cyan")
+    console.print("\nOutput File:", style="bold", end=" ")
+    console.print(f"{Path(args.output).resolve().absolute()}", style="cyan")
+
+    with Progress(console=console, auto_refresh=True) as progress:
+        from frame_interpolation.eval import util
+        from frame_interpolation.eval import util, interpolator
+
+        # files = Path(pth).rglob("*.png")
+
+        model = interpolator.Interpolator(
+            "G:/MODELS/FILM/pretrained_models/film_net/Style", None
+        )  # [2,2]
+
+        task = progress.add_task("[cyan]Interpolating frames...", total=1)
+
+        frames = list(
+            util.interpolate_recursively_from_files(
+                [x.as_posix() for x in input_files], args.interpolate, model
+            )
+        )
+
+        # mediapy.write_video(args.output, frames, fps=args.fps)
+        write_prores_444_video(args.output, frames, fps=args.fps)
+        progress.update(task, advance=1)
+        progress.refresh()

scripts/update_changelog.nu

@@ -0,0 +1,2 @@
+$env.GITHUB_TOKEN = (gh auth token) 
+git cliff --tag main | save -f CHANGELOG.md

styles.csv

@@ -1,3 +1,870 @@
-name,prompt,negative_prompt
-❌Low Token,,"embedding:EasyNegative, NSFW, Cleavage, Pubic Hair, Nudity, Naked, censored"
-✅Line Art / Manga,"(Anime Scene, Toonshading, Satoshi Kon, Ken Sugimori, Hiromu Arakawa:1.2), (Anime Style, Manga Style:1.3), Low detail, sketch, concept art, line art, webtoon, manhua, hand drawn, defined lines, simple shades, minimalistic, High contrast, Linear compositions, Scalable artwork, Digital art, High Contrast Shadows, glow effects, humorous illustration, big depth of field, Masterpiece, colors, concept art, trending on artstation, Vivid colors, dramatic",
+name,prompt,negative_prompt
+>>>>>> Generic Styles 
+Style: Enhance,"breathtaking {prompt} . award-winning, professional, highly detailed","ugly, deformed, noisy, blurry, distorted, grainy"
+Style: Anime,"anime artwork {prompt} . anime style, key visual, vibrant, studio anime, highly detailed","photo, deformed, black and white, realism, disfigured, low contrast"
+Style: Photographic,"cinematic photo {prompt} . 35mm photograph, film, bokeh, professional, 4k, highly detailed","drawing, painting, crayon, sketch, graphite, impressionist, noisy, blurry, soft, deformed, ugly"
+Style: Digital art,"concept art {prompt} . digital artwork, illustrative, painterly, matte painting, highly detailed","photo, photorealistic, realism, ugly"
+Style: Comic book,"comic {prompt} . graphic illustration, comic art, graphic novel art, vibrant, highly detailed","photograph, deformed, glitch, noisy, realistic, stock photo"
+Style: Fantasy art,"ethereal fantasy concept art of {prompt} . magnificent, celestial, ethereal, painterly, epic, majestic, magical, fantasy art, cover art, dreamy","photographic, realistic, realism, 35mm film, dslr, cropped, frame, text, deformed, glitch, noise, noisy, off-center, deformed, cross-eyed, closed eyes, bad anatomy, ugly, disfigured, sloppy, duplicate, mutated, black and white"
+Style: Analog film,"analog film photo {prompt} . faded film, desaturated, 35mm photo, grainy, vignette, vintage, Kodachrome, Lomography, stained, highly detailed, found footage","painting, drawing, illustration, glitch, deformed, mutated, cross-eyed, ugly, disfigured"
+Style: Neonpunk,"neonpunk style {prompt} . cyberpunk, vaporwave, neon, vibes, vibrant, stunningly beautiful, crisp, detailed, sleek, ultramodern, magenta highlights, dark purple shadows, high contrast, cinematic, ultra detailed, intricate, professional","painting, drawing, illustration, glitch, deformed, mutated, cross-eyed, ugly, disfigured"
+Style: Isometric,"isometric style {prompt} . vibrant, beautiful, crisp, detailed, ultra detailed, intricate","deformed, mutated, ugly, disfigured, blur, blurry, noise, noisy, realistic, photographic"
+Style: Lowpoly,"low-poly style {prompt} . low-poly game art, polygon mesh, jagged, blocky, wireframe edges, centered composition","noisy, sloppy, messy, grainy, highly detailed, ultra textured, photo"
+Style: Origami,"origami style {prompt} . paper art, pleated paper, folded, origami art, pleats, cut and fold, centered composition","noisy, sloppy, messy, grainy, highly detailed, ultra textured, photo"
+Style: Line art,"line art drawing {prompt} . professional, sleek, modern, minimalist, graphic, line art, vector graphics","anime, photorealistic, 35mm film, deformed, glitch, blurry, noisy, off-center, deformed, cross-eyed, closed eyes, bad anatomy, ugly, disfigured, mutated, realism, realistic, impressionism, expressionism, oil, acrylic"
+Style: Craft clay,"play-doh style {prompt} . sculpture, clay art, centered composition, Claymation","sloppy, messy, grainy, highly detailed, ultra textured, photo"
+Style: Cinematic,"cinematic film still {prompt} . shallow depth of field, vignette, highly detailed, high budget Hollywood movie, bokeh, cinemascope, moody, epic, gorgeous, film grain, grainy","anime, cartoon, graphic, text, painting, crayon, graphite, abstract, glitch, deformed, mutated, ugly, disfigured"
+Style: 3d-model,"professional 3d model {prompt} . octane render, highly detailed, volumetric, dramatic lighting","ugly, deformed, noisy, low poly, blurry, painting"
+Style: pixel art,"pixel-art {prompt} . low-res, blocky, pixel art style, 8-bit graphics","sloppy, messy, blurry, noisy, highly detailed, ultra textured, photo, realistic"
+Style: Texture,"texture {prompt} top down close-up","ugly, deformed, noisy, blurry"
+>>>>>> SDXL COMFYUI PORT
+Style: Enhance,"breathtaking {prompt} . award-winning, professional, highly detailed","ugly, deformed, noisy, blurry, distorted, grainy"
+Style: sai-3d-model,"professional 3d model {prompt} . octane render, highly detailed, volumetric, dramatic lighting","ugly, deformed, noisy, low poly, blurry, painting"
+Style: sai-analog film,"analog film photo {prompt} . faded film, desaturated, 35mm photo, grainy, vignette, vintage, Kodachrome, Lomography, stained, highly detailed, found footage","painting, drawing, illustration, glitch, deformed, mutated, cross-eyed, ugly, disfigured"
+Style: sai-anime,"anime artwork {prompt} . anime style, key visual, vibrant, studio anime,  highly detailed","photo, deformed, black and white, realism, disfigured, low contrast"
+Style: sai-cinematic,"cinematic film still {prompt} . shallow depth of field, vignette, highly detailed, high budget, bokeh, cinemascope, moody, epic, gorgeous, film grain, grainy","anime, cartoon, graphic, text, painting, crayon, graphite, abstract, glitch, deformed, mutated, ugly, disfigured"
+Style: sai-comic book,"comic {prompt} . graphic illustration, comic art, graphic novel art, vibrant, highly detailed","photograph, deformed, glitch, noisy, realistic, stock photo"
+Style: sai-craft clay,"play-doh style {prompt} . sculpture, clay art, centered composition, Claymation","sloppy, messy, grainy, highly detailed, ultra textured, photo"
+Style: sai-digital art,"concept art {prompt} . digital artwork, illustrative, painterly, matte painting, highly detailed","photo, photorealistic, realism, ugly"
+Style: sai-enhance,"breathtaking {prompt} . award-winning, professional, highly detailed","ugly, deformed, noisy, blurry, distorted, grainy"
+Style: sai-fantasy art,"ethereal fantasy concept art of  {prompt} . magnificent, celestial, ethereal, painterly, epic, majestic, magical, fantasy art, cover art, dreamy","photographic, realistic, realism, 35mm film, dslr, cropped, frame, text, deformed, glitch, noise, noisy, off-center, deformed, cross-eyed, closed eyes, bad anatomy, ugly, disfigured, sloppy, duplicate, mutated, black and white"
+Style: sai-isometric,"isometric style {prompt} . vibrant, beautiful, crisp, detailed, ultra detailed, intricate","deformed, mutated, ugly, disfigured, blur, blurry, noise, noisy, realistic, photographic"
+Style: sai-line art,"line art drawing {prompt} . professional, sleek, modern, minimalist, graphic, line art, vector graphics","anime, photorealistic, 35mm film, deformed, glitch, blurry, noisy, off-center, deformed, cross-eyed, closed eyes, bad anatomy, ugly, disfigured, mutated, realism, realistic, impressionism, expressionism, oil, acrylic"
+Style: sai-lowpoly,"low-poly style {prompt} . low-poly game art, polygon mesh, jagged, blocky, wireframe edges, centered composition","noisy, sloppy, messy, grainy, highly detailed, ultra textured, photo"
+Style: sai-neonpunk,"neonpunk style {prompt} . cyberpunk, vaporwave, neon, vibes, vibrant, stunningly beautiful, crisp, detailed, sleek, ultramodern, magenta highlights, dark purple shadows, high contrast, cinematic, ultra detailed, intricate, professional","painting, drawing, illustration, glitch, deformed, mutated, cross-eyed, ugly, disfigured"
+Style: sai-origami,"origami style {prompt} . paper art, pleated paper, folded, origami art, pleats, cut and fold, centered composition","noisy, sloppy, messy, grainy, highly detailed, ultra textured, photo"
+Style: sai-photographic,"cinematic photo {prompt} . 35mm photograph, film, bokeh, professional, 4k, highly detailed","drawing, painting, crayon, sketch, graphite, impressionist, noisy, blurry, soft, deformed, ugly"
+Style: sai-pixel art,"pixel-art {prompt} . low-res, blocky, pixel art style, 8-bit graphics","sloppy, messy, blurry, noisy, highly detailed, ultra textured, photo, realistic"
+Style: sai-texture,"texture {prompt} top down close-up","ugly, deformed, noisy, blurry"
+Style: ads-advertising,"Advertising poster style {prompt} . Professional, modern, product-focused, commercial, eye-catching, highly detailed","noisy, blurry, amateurish, sloppy, unattractive"
+Style: ads-automotive,"Automotive advertisement style {prompt} . Sleek, dynamic, professional, commercial, vehicle-focused, high-resolution, highly detailed","noisy, blurry, unattractive, sloppy, unprofessional"
+Style: ads-corporate,"Corporate branding style {prompt} . Professional, clean, modern, sleek, minimalist, business-oriented, highly detailed","noisy, blurry, grungy, sloppy, cluttered, disorganized"
+Style: ads-fashion editorial,"Fashion editorial style {prompt} . High fashion, trendy, stylish, editorial, magazine style, professional, highly detailed","outdated, blurry, noisy, unattractive, sloppy"
+Style: ads-food photography,"Food photography style {prompt} . Appetizing, professional, culinary, high-resolution, commercial, highly detailed","unappetizing, sloppy, unprofessional, noisy, blurry"
+Style: ads-luxury,"Luxury product style {prompt} . Elegant, sophisticated, high-end, luxurious, professional, highly detailed","cheap, noisy, blurry, unattractive, amateurish"
+Style: ads-real estate,"Real estate photography style {prompt} . Professional, inviting, well-lit, high-resolution, property-focused, commercial, highly detailed","dark, blurry, unappealing, noisy, unprofessional"
+Style: ads-retail,"Retail packaging style {prompt} . Vibrant, enticing, commercial, product-focused, eye-catching, professional, highly detailed","noisy, blurry, amateurish, sloppy, unattractive"
+Style: artstyle-abstract,"abstract style {prompt} . non-representational, colors and shapes, expression of feelings, imaginative, highly detailed","realistic, photographic, figurative, concrete"
+Style: artstyle-abstract expressionism,"abstract expressionist painting {prompt} . energetic brushwork, bold colors, abstract forms, expressive, emotional","realistic, photorealistic, low contrast, plain, simple, monochrome"
+Style: artstyle-art deco,"Art Deco style {prompt} . geometric shapes, bold colors, luxurious, elegant, decorative, symmetrical, ornate, detailed","ugly, deformed, noisy, blurry, low contrast, realism, photorealistic, modernist, minimalist"
+Style: artstyle-art nouveau,"Art Nouveau style {prompt} . elegant, decorative, curvilinear forms, nature-inspired, ornate, detailed","ugly, deformed, noisy, blurry, low contrast, realism, photorealistic, modernist, minimalist"
+Style: artstyle-constructivist,"constructivist style {prompt} . geometric shapes, bold colors, dynamic composition, propaganda art style","realistic, photorealistic, low contrast, plain, simple, abstract expressionism"
+Style: artstyle-cubist,"cubist artwork {prompt} . geometric shapes, abstract, innovative, revolutionary","anime, photorealistic, 35mm film, deformed, glitch, low contrast, noisy"
+Style: artstyle-expressionist,"expressionist {prompt} . raw, emotional, dynamic, distortion for emotional effect, vibrant, use of unusual colors, detailed","realism, symmetry, quiet, calm, photo"
+Style: artstyle-graffiti,"graffiti style {prompt} . street art, vibrant, urban, detailed, tag, mural","ugly, deformed, noisy, blurry, low contrast, realism, photorealistic"
+Style: artstyle-hyperrealism,"hyperrealistic art {prompt} . extremely high-resolution details, photographic, realism pushed to extreme, fine texture, incredibly lifelike","simplified, abstract, unrealistic, impressionistic, low resolution"
+Style: artstyle-impressionist,"impressionist painting {prompt} . loose brushwork, vibrant color, light and shadow play, captures feeling over form","anime, photorealistic, 35mm film, deformed, glitch, low contrast, noisy"
+Style: artstyle-pointillism,"pointillism style {prompt} . composed entirely of small, distinct dots of color, vibrant, highly detailed","line drawing, smooth shading, large color fields, simplistic"
+Style: artstyle-pop art,"Pop Art style {prompt} . bright colors, bold outlines, popular culture themes, ironic or kitsch","ugly, deformed, noisy, blurry, low contrast, realism, photorealistic, minimalist"
+Style: artstyle-psychedelic,"psychedelic style {prompt} . vibrant colors, swirling patterns, abstract forms, surreal, trippy","monochrome, black and white, low contrast, realistic, photorealistic, plain, simple"
+Style: artstyle-renaissance,"Renaissance style {prompt} . realistic, perspective, light and shadow, religious or mythological themes, highly detailed","ugly, deformed, noisy, blurry, low contrast, modernist, minimalist, abstract"
+Style: artstyle-steampunk,"steampunk style {prompt} . antique, mechanical, brass and copper tones, gears, intricate, detailed","deformed, glitch, noisy, low contrast, anime, photorealistic"
+Style: artstyle-surrealist,"surrealist art {prompt} . dreamlike, mysterious, provocative, symbolic, intricate, detailed","anime, photorealistic, realistic, deformed, glitch, noisy, low contrast"
+Style: artstyle-typography,"typographic art {prompt} . stylized, intricate, detailed, artistic, text-based","ugly, deformed, noisy, blurry, low contrast, realism, photorealistic"
+Style: artstyle-watercolor,"watercolor painting {prompt} . vibrant, beautiful, painterly, detailed, textural, artistic","anime, photorealistic, 35mm film, deformed, glitch, low contrast, noisy"
+Style: futuristic-biomechanical,"biomechanical style {prompt} . blend of organic and mechanical elements, futuristic, cybernetic, detailed, intricate","natural, rustic, primitive, organic, simplistic"
+Style: futuristic-biomechanical cyberpunk,"biomechanical cyberpunk {prompt} . cybernetics, human-machine fusion, dystopian, organic meets artificial, dark, intricate, highly detailed","natural, colorful, deformed, sketch, low contrast, watercolor"
+Style: futuristic-cybernetic,"cybernetic style {prompt} . futuristic, technological, cybernetic enhancements, robotics, artificial intelligence themes","ugly, deformed, noisy, blurry, low contrast, realism, photorealistic, historical, medieval"
+Style: futuristic-cybernetic robot,"cybernetic robot {prompt} . android, AI, machine, metal, wires, tech, futuristic, highly detailed","organic, natural, human, sketch, watercolor, low contrast"
+Style: futuristic-cyberpunk cityscape,"cyberpunk cityscape {prompt} . neon lights, dark alleys, skyscrapers, futuristic, vibrant colors, high contrast, highly detailed","natural, rural, deformed, low contrast, black and white, sketch, watercolor"
+Style: futuristic-futuristic,"futuristic style {prompt} . sleek, modern, ultramodern, high tech, detailed","ugly, deformed, noisy, blurry, low contrast, realism, photorealistic, vintage, antique"
+Style: futuristic-retro cyberpunk,"retro cyberpunk {prompt} . 80's inspired, synthwave, neon, vibrant, detailed, retro futurism","modern, desaturated, black and white, realism, low contrast"
+Style: futuristic-retro futurism,"retro-futuristic {prompt} . vintage sci-fi, 50s and 60s style, atomic age, vibrant, highly detailed","contemporary, realistic, rustic, primitive"
+Style: futuristic-sci-fi,"sci-fi style {prompt} . futuristic, technological, alien worlds, space themes, advanced civilizations","ugly, deformed, noisy, blurry, low contrast, realism, photorealistic, historical, medieval"
+Style: futuristic-vaporwave,"vaporwave style {prompt} . retro aesthetic, cyberpunk, vibrant, neon colors, vintage 80s and 90s style, highly detailed","monochrome, muted colors, realism, rustic, minimalist, dark"
+Style: game-bubble bobble,"Bubble Bobble style {prompt} . 8-bit, cute, pixelated, fantasy, vibrant, reminiscent of Bubble Bobble game","realistic, modern, photorealistic, violent, horror"
+Style: game-cyberpunk game,"cyberpunk game style {prompt} . neon, dystopian, futuristic, digital, vibrant, detailed, high contrast, reminiscent of cyberpunk genre video games","historical, natural, rustic, low detailed"
+Style: game-fighting game,"fighting game style {prompt} . dynamic, vibrant, action-packed, detailed character design, reminiscent of fighting video games","peaceful, calm, minimalist, photorealistic"
+Style: game-gta,"GTA-style artwork {prompt} . satirical, exaggerated, pop art style, vibrant colors, iconic characters, action-packed","realistic, black and white, low contrast, impressionist, cubist, noisy, blurry, deformed"
+Style: game-mario,"Super Mario style {prompt} . vibrant, cute, cartoony, fantasy, playful, reminiscent of Super Mario series","realistic, modern, horror, dystopian, violent"
+Style: game-minecraft,"Minecraft style {prompt} . blocky, pixelated, vibrant colors, recognizable characters and objects, game assets","smooth, realistic, detailed, photorealistic, noise, blurry, deformed"
+Style: game-pokemon,"Pokémon style {prompt} . vibrant, cute, anime, fantasy, reminiscent of Pokémon series","realistic, modern, horror, dystopian, violent"
+Style: game-retro arcade,"retro arcade style {prompt} . 8-bit, pixelated, vibrant, classic video game, old school gaming, reminiscent of 80s and 90s arcade games","modern, ultra-high resolution, photorealistic, 3D"
+Style: game-retro game,"retro game art {prompt} . 16-bit, vibrant colors, pixelated, nostalgic, charming, fun","realistic, photorealistic, 35mm film, deformed, glitch, low contrast, noisy"
+Style: game-rpg fantasy game,"role-playing game (RPG) style fantasy {prompt} . detailed, vibrant, immersive, reminiscent of high fantasy RPG games","sci-fi, modern, urban, futuristic, low detailed"
+Style: game-strategy game,"strategy game style {prompt} . overhead view, detailed map, units, reminiscent of real-time strategy video games","first-person view, modern, photorealistic"
+Style: game-streetfighter,"Street Fighter style {prompt} . vibrant, dynamic, arcade, 2D fighting game, highly detailed, reminiscent of Street Fighter series","3D, realistic, modern, photorealistic, turn-based strategy"
+Style: game-zelda,"Legend of Zelda style {prompt} . vibrant, fantasy, detailed, epic, heroic, reminiscent of The Legend of Zelda series","sci-fi, modern, realistic, horror"
+Style: misc-architectural,"architectural style {prompt} . clean lines, geometric shapes, minimalist, modern, architectural drawing, highly detailed","curved lines, ornate, baroque, abstract, grunge"
+Style: misc-disco,"disco-themed {prompt} . vibrant, groovy, retro 70s style, shiny disco balls, neon lights, dance floor, highly detailed","minimalist, rustic, monochrome, contemporary, simplistic"
+Style: misc-dreamscape,"dreamscape {prompt} . surreal, ethereal, dreamy, mysterious, fantasy, highly detailed","realistic, concrete, ordinary, mundane"
+Style: misc-dystopian,"dystopian style {prompt} . bleak, post-apocalyptic, somber, dramatic, highly detailed","ugly, deformed, noisy, blurry, low contrast, cheerful, optimistic, vibrant, colorful"
+Style: misc-fairy tale,"fairy tale {prompt} . magical, fantastical, enchanting, storybook style, highly detailed","realistic, modern, ordinary, mundane"
+Style: misc-gothic,"gothic style {prompt} . dark, mysterious, haunting, dramatic, ornate, detailed","ugly, deformed, noisy, blurry, low contrast, realism, photorealistic, cheerful, optimistic"
+Style: misc-grunge,"grunge style {prompt} . textured, distressed, vintage, edgy, punk rock vibe, dirty, noisy","smooth, clean, minimalist, sleek, modern, photorealistic"
+Style: misc-horror,"horror-themed {prompt} . eerie, unsettling, dark, spooky, suspenseful, grim, highly detailed","cheerful, bright, vibrant, light-hearted, cute"
+Style: misc-kawaii,"kawaii style {prompt} . cute, adorable, brightly colored, cheerful, anime influence, highly detailed","dark, scary, realistic, monochrome, abstract"
+Style: misc-lovecraftian,"lovecraftian horror {prompt} . eldritch, cosmic horror, unknown, mysterious, surreal, highly detailed","light-hearted, mundane, familiar, simplistic, realistic"
+Style: misc-macabre,"macabre style {prompt} . dark, gothic, grim, haunting, highly detailed","bright, cheerful, light-hearted, cartoonish, cute"
+Style: misc-manga,"manga style {prompt} . vibrant, high-energy, detailed, iconic, Japanese comic style","ugly, deformed, noisy, blurry, low contrast, realism, photorealistic, Western comic style"
+Style: misc-metropolis,"metropolis-themed {prompt} . urban, cityscape, skyscrapers, modern, futuristic, highly detailed","rural, natural, rustic, historical, simple"
+Style: misc-minimalist,"minimalist style {prompt} . simple, clean, uncluttered, modern, elegant","ornate, complicated, highly detailed, cluttered, disordered, messy, noisy"
+Style: misc-monochrome,"monochrome {prompt} . black and white, contrast, tone, texture, detailed","colorful, vibrant, noisy, blurry, deformed"
+Style: misc-nautical,"nautical-themed {prompt} . sea, ocean, ships, maritime, beach, marine life, highly detailed","landlocked, desert, mountains, urban, rustic"
+Style: misc-space,"space-themed {prompt} . cosmic, celestial, stars, galaxies, nebulas, planets, science fiction, highly detailed","earthly, mundane, ground-based, realism"
+Style: misc-stained glass,"stained glass style {prompt} . vibrant, beautiful, translucent, intricate, detailed","ugly, deformed, noisy, blurry, low contrast, realism, photorealistic"
+Style: misc-techwear fashion,"techwear fashion {prompt} . futuristic, cyberpunk, urban, tactical, sleek, dark, highly detailed","vintage, rural, colorful, low contrast, realism, sketch, watercolor"
+Style: misc-tribal,"tribal style {prompt} . indigenous, ethnic, traditional patterns, bold, natural colors, highly detailed","modern, futuristic, minimalist, pastel"
+Style: misc-zentangle,"zentangle {prompt} . intricate, abstract, monochrome, patterns, meditative, highly detailed","colorful, representative, simplistic, large fields of color"
+Style: papercraft-collage,"collage style {prompt} . mixed media, layered, textural, detailed, artistic","ugly, deformed, noisy, blurry, low contrast, realism, photorealistic"
+Style: papercraft-flat papercut,"flat papercut style {prompt} . silhouette, clean cuts, paper, sharp edges, minimalist, color block","3D, high detail, noise, grainy, blurry, painting, drawing, photo, disfigured"
+Style: papercraft-kirigami,"kirigami representation of {prompt} . 3D, paper folding, paper cutting, Japanese, intricate, symmetrical, precision, clean lines","painting, drawing, 2D, noisy, blurry, deformed"
+Style: papercraft-paper mache,"paper mache representation of {prompt} . 3D, sculptural, textured, handmade, vibrant, fun","2D, flat, photo, sketch, digital art, deformed, noisy, blurry"
+Style: papercraft-paper quilling,"paper quilling art of {prompt} . intricate, delicate, curling, rolling, shaping, coiling, loops, 3D, dimensional, ornamental","photo, painting, drawing, 2D, flat, deformed, noisy, blurry"
+Style: papercraft-papercut collage,"papercut collage of {prompt} . mixed media, textured paper, overlapping, asymmetrical, abstract, vibrant","photo, 3D, realistic, drawing, painting, high detail, disfigured"
+Style: papercraft-papercut shadow box,"3D papercut shadow box of {prompt} . layered, dimensional, depth, silhouette, shadow, papercut, handmade, high contrast","painting, drawing, photo, 2D, flat, high detail, blurry, noisy, disfigured"
+Style: papercraft-stacked papercut,"stacked papercut art of {prompt} . 3D, layered, dimensional, depth, precision cut, stacked layers, papercut, high contrast","2D, flat, noisy, blurry, painting, drawing, photo, deformed"
+Style: papercraft-thick layered papercut,"thick layered papercut art of {prompt} . deep 3D, volumetric, dimensional, depth, thick paper, high stack, heavy texture, tangible layers","2D, flat, thin paper, low stack, smooth texture, painting, drawing, photo, deformed"
+Style: photo-alien,"alien-themed {prompt} . extraterrestrial, cosmic, otherworldly, mysterious, sci-fi, highly detailed","earthly, mundane, common, realistic, simple"
+Style: photo-film noir,"film noir style {prompt} . monochrome, high contrast, dramatic shadows, 1940s style, mysterious, cinematic","ugly, deformed, noisy, blurry, low contrast, realism, photorealistic, vibrant, colorful"
+Style: photo-hdr,"HDR photo of {prompt} . High dynamic range, vivid, rich details, clear shadows and highlights, realistic, intense, enhanced contrast, highly detailed","flat, low contrast, oversaturated, underexposed, overexposed, blurred, noisy"
+Style: photo-long exposure,"long exposure photo of {prompt} . Blurred motion, streaks of light, surreal, dreamy, ghosting effect, highly detailed","static, noisy, deformed, shaky, abrupt, flat, low contrast"
+Style: photo-neon noir,"neon noir {prompt} . cyberpunk, dark, rainy streets, neon signs, high contrast, low light, vibrant, highly detailed","bright, sunny, daytime, low contrast, black and white, sketch, watercolor"
+Style: photo-silhouette,"silhouette style {prompt} . high contrast, minimalistic, black and white, stark, dramatic","ugly, deformed, noisy, blurry, low contrast, color, realism, photorealistic"
+Style: photo-tilt-shift,"tilt-shift photo of {prompt} . Selective focus, miniature effect, blurred background, highly detailed, vibrant, perspective control","blurry, noisy, deformed, flat, low contrast, unrealistic, oversaturated, underexposed"
+>>>>>> Advanced GPT Styles 
+Style: Space art,"galactic style {prompt} . nebula, constellation, cosmic, celestial, highly detailed, starry","blurry, grainy, deformed, photo-realistic, low-contrast, terrestrial"
+Style: Street art,"urban graffiti style {prompt} . vibrant, edgy, street art, underground, spray paint effect","clean, minimalistic, soft, gentle, blurry, off-center"
+Style: Baroque,"Baroque art {prompt} . ornate, richly detailed, dramatic, high contrast, complex composition","minimalistic, low-contrast, blurry, deformed, modern, abstract"
+Style: Abstract,"abstract {prompt} . imaginative, surreal, non-representational, dream-like","realistic, photo, literal, symmetrical, rigid"
+Style: Pointillism,"pointillism art {prompt} . dots, dappled, stipples, highly detailed","smooth, blurry, photo-realistic, non-dotted"
+Style: Impressionist,"impressionist painting {prompt} . soft edges, vibrant, loose brushwork, atmospheric, highly detailed","hard edges, muted colors, tight brushwork, non-atmospheric"
+Style: Pop art,"pop art {prompt} . vibrant, mass culture, comic style, bold lines, ironic","soft, elegant, high culture, realistic, subtle lines"
+Style: Minimalist,"minimalist design {prompt} . clean, simple, restrained, elegant","busy, complex, flamboyant, disfigured"
+Style: Art Deco,"art deco {prompt} . opulent, lavish, ornate, symmetrical, geometric","minimalistic, simple, asymmetrical, organic"
+Style: Cubist,"cubist {prompt} . abstract, geometric, fragmented, multiple perspectives","realistic, smooth, unbroken, single perspective"
+Style: Dada,"dada style {prompt} . absurd, satirical, avant-garde, abstract","serious, traditional, conventional, realistic"
+Style: Victorian,"Victorian style {prompt} . elegant, ornate, highly detailed, historical","modern, minimalist, low detail, contemporary"
+Style: Art Nouveau,"art nouveau {prompt} . organic, curvilinear, decorative, highly detailed","geometric, straight lines, functional, low detail"
+Style: Futuristic,"futuristic {prompt} . advanced, high-tech, sleek, modern","old, low-tech, chunky, historical"
+Style: Medieval,"medieval style {prompt} . historical, ornate, religious, gothic","modern, simple, secular, minimalist"
+Style: Industrial,"industrial style {prompt} . mechanical, robust, urban, gritty","natural, fragile, rural, clean"
+Style: Vaporwave,"vaporwave style {prompt} . retro, neon, pixelated, nostalgic","modern, monochrome, high-resolution, forward-looking"
+Style: Horror,"horror style {prompt} . dark, eerie, gothic, macabre","light, cheerful, minimalist, happy"
+Style: Gothic,"gothic style {prompt} . dark, mysterious, intricate, moody","light, cheerful, simple, vibrant"
+Style: Steampunk,"steampunk style {prompt} . retro, mechanical, detailed, Victorian","modern, digital, minimalist, contemporary"
+Style: Retro,"retro style {prompt} . vintage, nostalgic, old-fashioned, highly detailed","modern, futuristic, forward-looking, low detail"
+Style: Surrealist,"surrealist {prompt} . dream-like, bizarre, irrational, highly detailed","realistic, mundane, rational, low detail"
+Style: Realism,"realism style {prompt} . lifelike, detailed, accurate, representational","abstract, simplistic, inaccurate, non-representational"
+Style: Silhouette,"silhouette style {prompt} . minimalist, monochrome, stark, high contrast","detailed, multicolored, soft, low contrast"
+Style: Collage,"collage style {prompt} . mixed media, assembled, eclectic, highly detailed","uniform, unvarying, minimalist, low detail"
+Style: Watercolor,"watercolor {prompt} . soft, blended, transparent, fluid","hard, unblended, opaque, rigid"
+Style: Calligraphy,"calligraphy {prompt} . elegant, flowing, ornate, highly detailed","plain, rigid, simple, low detail"
+Style: Expressionist,"expressionist style {prompt} . emotional, intense, vibrant, highly detailed","emotionless, calm, muted, low detail"
+Style: Fauvist,"fauvist style {prompt} . bold color, exaggerated, expressive, highly detailed","neutral color, realistic, restrained, low detail"
+Style: Renaissance,"Renaissance style {prompt} . classical, humanistic, realistic, highly detailed","modern, abstract, unrealistic, low detail"
+Style: Photorealistic,"photorealistic {prompt} . highly detailed, lifelike, precise, accurate","abstract, low detail, unrealistic, inaccurate"
+Style: Symbolic,"symbolic style {prompt} . conceptual, representative, allegorical, highly detailed","literal, non-representative, factual, low detail"
+Style: Avant-garde,"avant-garde style {prompt} . experimental, innovative, non-traditional","traditional, conventional, classic"
+Style: Mosaic,"mosaic style {prompt} . fragmented, assembled, colorful, highly detailed","whole, unbroken, monochrome, low detail"
+Style: Trompe l'oeil,"trompe l'oeil style {prompt} . deceptive, 3D effect, realistic, highly detailed","honest, 2D effect, unrealistic, low detail"
+Style: Rococo,"rococo style {prompt} . ornate, playful, romantic, pastel, highly detailed","minimalistic, serious, unromantic, dark, low detail"
+Style: Macabre,"macabre style {prompt} . dark, eerie, grotesque, highly detailed","light, cheerful, beautiful, low detail"
+Style: Satirical,"satirical style {prompt} . humorous, ironic, exaggerated, critical","serious, literal, realistic, complimentary"
+Style: Pixelated,"pixelated style {prompt} . retro, low-res, digital, blocky","modern, high-res, organic, smooth"
+Style: Futurist,"futurist style {prompt} . dynamic, modern, mechanized, highly detailed","static, historical, organic, low detail"
+Style: Primitive,"primitive style {prompt} . raw, simple, naive, highly detailed","refined, complex, sophisticated, low detail"
+Style: Byzantine,"Byzantine style {prompt} . rich, ornate, religious, iconic, highly detailed","poor, simple, secular, non-iconic, low detail"
+Style: Psychedelic,"psychedelic style {prompt} . vibrant, abstract, distorted, highly detailed","muted, realistic, undistorted, low detail"
+Style: Suprematist,"suprematist style {prompt} . geometric, abstract, non-objective, simple","organic, realistic, objective, complex"
+Style: Constructivist,"constructivist style {prompt} . industrial, geometric, political, highly detailed","organic, curvilinear, apolitical, low detail"
+Style: De Stijl,"de Stijl style {prompt} . abstract, geometric, primary colors,"organic, curvilinear, muted colors, black and white"
+Style: Ukiyo-e,"ukiyo-e style {prompt} . woodblock print, vibrant, historical Japanese art, detailed","digital, muted, modern, Western"
+Style: Dystopian,"dystopian style {prompt} . bleak, oppressive, futuristic, detailed","utopian, cheerful, historical, low detail"
+Style: Biomechanical,"biomechanical style {prompt} . organic meets mechanical, alien, detailed, H.R. Giger-inspired","geometric, earthy, low detail, not H.R. Giger-inspired"
+Style: Hyperrealism,"hyperrealistic style {prompt} . ultra-detailed, lifelike, precision, crisp","abstract, low detail, unrealistic, blurry"
+Style: Glitch,"glitch style {prompt} . digital error, distorted, cyber, detailed","analog, undistorted, organic, low detail"
+Style: Trompe-l'oeil,"trompe-l'oeil style {prompt} . optical illusion, lifelike, 3D effect, detailed","flat, 2D effect, unrealistic, low detail"
+Style: Arabesque,"arabesque style {prompt} . geometric patterns, floral, Islamic art, detailed","chaotic, animalistic, non-Islamic art, low detail"
+Style: Brutalist,"brutalist style {prompt} . raw, rugged, geometric, concrete, detailed","smooth, delicate, curvilinear, abstract, low detail"
+Style: Chiaroscuro,"chiaroscuro style {prompt} . high contrast, dramatic lighting, detailed","low contrast, flat lighting, low detail"
+Style: Tenebrism,"tenebrism style {prompt} . dark, dramatic illumination, high contrast, detailed","light, flat lighting, low contrast, low detail"
+Style: Romantic,"romantic style {prompt} . emotional, dramatic, nature-focused, detailed","unemotional, flat, city-focused, low detail"
+Style: Bauhaus,"bauhaus style {prompt} . functional, geometric, minimal, detailed","ornamental, curvilinear, maximal, low detail"
+Style: Art brut,"art brut style {prompt} . raw, outsider art, naïve, detailed","refined, mainstream art, sophisticated, low detail"
+Style: Metaphysical,"metaphysical style {prompt} . surreal, eerie, uncanny, detailed","realistic, comfortable, familiar, low detail"
+Style: Neoplasticism,"neoplasticism style {prompt} . geometric, primary colors, black and white, abstract","organic, muted colors, colorful, realistic"
+Style: Hard-edge,"hard-edge style {prompt} . geometric, flat colors, precision, detailed","organic, gradient colors, imprecise, low detail"
+Style: Automatism,"automatism style {prompt} . unconscious, spontaneous, abstract, detailed","conscious, planned, realistic, low detail"
+Style: Tachisme,"tachisme style {prompt} . gestural, abstract, spontaneous, detailed","controlled, realistic, planned, low detail"
+Style: Lyrical abstraction,"lyrical abstraction style {prompt} . emotional, non-figurative, expressive, detailed","unemotional, figurative, restrained, low detail"
+Style: Color field,"color field style {prompt} . flat, large fields of color, minimal, detailed","textured, small patches of color, maximal, low detail"
+Style: Synthetism,"synthetism style {prompt} . simplified, symbolic, bright colors, detailed","complex, literal, muted colors, low detail"
+Style: Cloisonnism,"cloisonnism style {prompt} . bold outlines, flat colors, decorative, detailed","soft outlines, gradient colors, functional, low detail"
+Style: Assemblage,"assemblage style {prompt} . three-dimensional, found objects, eclectic, detailed","two-dimensional, traditional materials, uniform, low detail"
+Style: Vorticism,"vorticism style {prompt} . geometric, abstract, dynamic, detailed","organic, realistic, static, low detail"
+Style: Op art,"op art style {prompt} . optical illusions, geometric, black and white, detailed","no illusions, organic, colorful, low detail"
+Style: Divisionism,"divisionism style {prompt} . color theory, dot technique, vibrant, detailed","black and white, smooth technique, muted, low detail"
+Style: Kinetic art,"kinetic art style {prompt} . movement, dynamic, interactive, detailed","static, static, non-interactive, low detail"
+Style: Orphism,"orphism style {prompt} . pure color, abstract, musical, detailed","mixed color, realistic, non-musical, low detail"
+Style: Suprematism,"suprematism style {prompt} . geometric, abstract, limited color palette, detailed","organic, realistic, broad color palette, low detail"
+Style: Letterism,"letterism style {prompt} . letters, typographic, abstract, detailed","images, non-typographic, realistic, low detail"
+Style: Situationalist,"situationalist style {prompt} . political, collage, detournement, detailed","apolitical, single medium, straightforward, low detail"
+Style: Sound art,"sound art style {prompt} . auditory, abstract, non-visual, detailed","visual, realistic, silent, low detail"
+Style: Land art,"land art style {prompt} . natural materials, outdoor, environmental, detailed","synthetic materials, indoor, non-environmental, low detail"
+Style: Photorealistic graffiti,"photorealistic graffiti style {prompt} . urban, street art, lifelike, detailed","rural, gallery art, abstract, low detail"
+Style: Hypermodern,"hypermodern style {prompt} . postmodern, technology focused, sleek, detailed","premodern, nature focused, rustic, low detail"
+Style: Virtual realism,"virtual realism style {prompt} . digital, lifelike, immersive, detailed","analog, abstract, non-immersive, low detail"
+Style: Structural film,"structural film style {prompt} . experimental, non-narrative, texture, detailed","traditional, narrative, smooth, low detail"
+Style: Process art,"process art style {prompt} . creation focused, ephemeral, documentation, detailed","result focused, permanent, no documentation, low detail"
+Style: Light and space,"light and space style {prompt} . perceptual phenomena, immersive, minimal, detailed","solid objects, non-immersive, maximal, low detail"
+Style: Post-internet,"post-internet style {prompt} . digital culture, technology, online, detailed","pre-internet, nature, offline, low detail"
+Style: Bio-art,"bio-art style {prompt} . living organisms, ethical, natural, detailed","inorganic, unethical, synthetic, low detail"
+>>>>>> GPT Cultural Styles
+Style: Byzantine,"Byzantine style {prompt} . religious, iconography, gold, highly detailed, mosaics","secular, simple, bronze, minimalist, paintings"
+Style: Celtic,"Celtic style {prompt} . geometric patterns, intricate knots, medieval, highly detailed","random, simplistic, modern, undetailed"
+Style: Native American,"Native American style {prompt} . traditional patterns, tribal, cultural symbols, highly detailed","modern, non-tribal, abstract, undetailed"
+Style: Aboriginal,"Aboriginal style {prompt} . dot painting, Dreamtime stories, Australian culture, highly detailed","non-Australian, line drawing, abstract, undetailed"
+Style: Egyptian,"Egyptian style {prompt} . hieroglyphs, gods and goddesses, Pharaohs, highly detailed","non-Egyptian, text-free, secular, undetailed"
+Style: Mayan,"Mayan style {prompt} . glyphs, ancient civilization, detailed carvings, highly detailed","modern, non-Mayan, simplistic, undetailed"
+Style: Renaissance,"Renaissance style {prompt} . humanism, realism, perspective, highly detailed","abstract, surreal, flat, undetailed"
+Style: Mughal,"Mughal style {prompt} . Indian and Persian influence, miniature paintings, highly detailed","non-Indian, non-Persian, large-scale, undetailed"
+Style: Romanesque,"Romanesque style {prompt} . medieval, religious, thick walls, highly detailed","modern, secular, transparent, undetailed"
+Style: Gothic,"Gothic style {prompt} . medieval, pointed arches, stained glass, highly detailed","modern, round arches, clear glass, undetailed"
+Style: Baroque,"Baroque style {prompt} . grandeur, drama, chiaroscuro, highly detailed","minimalist, calm, flat, undetailed"
+Style: Rococo,"Rococo style {prompt} . ornate, pastel, love and nature themes, highly detailed","simple, dark, abstract, undetailed"
+Style: Pre-Raphaelite,"Pre-Raphaelite style {prompt} . romantic, vivid color, medieval subjects, highly detailed","realistic, muted color, modern subjects, undetailed"
+Style: Impressionist,"Impressionist style {prompt} . loose brushwork, light and color, ordinary subjects, highly detailed","tight brushwork, black and white, extraordinary subjects, undetailed"
+Style: Cubist,"Cubist style {prompt} . geometric, multi-perspective, fragmented, highly detailed","organic, single perspective, whole, undetailed"
+Style: Surrealist,"Surrealist style {prompt} . dreamlike, irrational, unexpected juxtapositions, highly detailed","realistic, rational, expected combinations, undetailed"
+Style: Futurist,"Futurist style {prompt} . dynamic, technology, speed, highly detailed","static, nature, slow, undetailed"
+Style: Dada,"Dada style {prompt} . absurd, anti-art, randomness, highly detailed","rational, pro-art, order, undetailed"
+Style: Expressionist,"Expressionist style {prompt} . emotional, distorted, individual perspective, highly detailed","unemotional, realistic, collective perspective, undetailed"
+Style: Fauvist,"Fauvist style {prompt} . bold color, wild brushwork, simplification, highly detailed","muted color, careful brushwork, detail, undetailed"
+Style: Socialist Realist,"Socialist Realist style {prompt} . idealized, political, proletarian, highly detailed","realistic, apolitical, bourgeois, undetailed"
+Style: Pop Art,"Pop Art style {prompt} . popular culture, advertising, bold, highly detailed","high art, non-commercial, muted, undetailed"
+Style: Suprematism,"Suprematism style {prompt} . geometric, non-objective, primary colors, highly detailed","organic, objective, pastel colors, undetailed"
+Style: Symbolist,"Symbolist style {prompt} . mythical, dreamy, spiritual, highly detailed","realistic, practical, secular, undetailed"
+Style: Pre-Columbian,"Pre-Columbian style {prompt} . ancient Americas, native, cultural, highly detailed","modern, non-American, abstract, undetailed"
+Style: Constructivist,"Constructivist style {prompt} . industrial, geometric, socialist, highly detailed","organic, round, capitalist, undetailed"
+Style: Art Nouveau,"Art Nouveau style {prompt} . decorative, nature-inspired, curved lines, highly detailed","functional, geometric, straight lines, undetailed"
+Style: Precisionist,"Precisionist style {prompt} . industrial, crisp, geometric, highly detailed","organic, blurry, round, undetailed"
+Style: Neoclassical,"Neoclassical style {prompt} . ancient Rome and Greece, rational, heroic, highly detailed","modern, emotional, ordinary, undetailed"
+Style: Persian Miniature,"Persian Miniature style {prompt} . Middle Eastern, intricate, storytelling, highly detailed","Western, simple, non-narrative, undetailed"
+Style: Edo,"Edo style {prompt} . Japanese, woodblock prints, floating world, highly detailed","non-Japanese, oil painting, real world, undetailed"
+Style: Tribal,"Tribal style {prompt} . African, indigenous, symbolic, highly detailed","non-African, mainstream, abstract, undetailed"
+Style: Tibetan Thangka,"Tibetan Thangka style {prompt} . spiritual, Buddhist, meditation, highly detailed","secular, non-Buddhist, disturbing, undetailed"
+Style: Art Deco,"Art Deco style {prompt} . modern, geometric, luxury, highly detailed","vintage, organic, minimalism, undetailed"
+Style: Minimalist,"Minimalist style {prompt} . simple, functional, unadorned, highly detailed","complex, decorative, adorned, undetailed"
+Style: Greek Classical,"Greek Classical style {prompt} . ancient, mythology, balanced, highly detailed","modern, everyday life, unbalanced, undetailed"
+Style: African,"African style {prompt} . tribal, symbolic, cultural, highly detailed","non-African, abstract, non-cultural, undetailed"
+Style: Russian Iconography,"Russian Iconography style {prompt} . religious, orthodox, gold, highly detailed","secular, non-orthodox, silver, undetailed"
+Style: Nordic,"Nordic style {prompt} . Scandinavian, minimal, nature, highly detailed","non-Scandinavian, maximal, urban, undetailed"
+Style: Inuit,"Inuit style {prompt} . Arctic, native, animal themes, highly detailed","tropical, non-native, human themes, undetailed"
+Style: Maori,"Maori style {prompt} . New Zealand, tribal, spiritual, highly detailed","non-New Zealand, non-tribal, secular, undetailed"
+Style: Iznik,"Iznik style {prompt} . Turkish, ceramic, floral, highly detailed","non-Turkish, canvas, geometric, undetailed"
+Style: Ottoman,"Ottoman style {prompt} . Islamic, calligraphy, miniatures, highly detailed","non-Islamic, typography, large-scale, undetailed"
+Style: Hanami,"Hanami style {prompt} . Japanese, cherry blossoms,spring, highly detailed","non-Japanese, winter, abstract, undetailed"
+Style: Mandala,"Mandala style {prompt} . spiritual, geometric, symmetrical, highly detailed","secular, organic, asymmetrical, undetailed"
+Style: Aztec,"Aztec style {prompt} . ancient Mexico, symbolic, cultural, highly detailed","modern, abstract, non-cultural, undetailed"
+Style: Sumi-e,"Sumi-e style {prompt} . Japanese ink painting, minimal, nature, highly detailed","non-Japanese, colorful, urban, undetailed"
+Style: Ukiyo-e,"Ukiyo-e style {prompt} . Japanese, woodblock prints, floating world, highly detailed","non-Japanese, digital art, real world, undetailed"
+Style: Haida,"Haida style {prompt} . Native American, form line, nature, highly detailed","non-Native American, abstract, urban, undetailed"
+Style: Moorish,"Moorish style {prompt} . Islamic, geometric, Andalusian, highly detailed","non-Islamic, organic, non-Andalusian, undetailed"
+Style: Victorian,"Victorian style {prompt} . 19th century, ornate, romantic, highly detailed","21st century, minimal, unemotional, undetailed"
+Style: Pueblo,"Pueblo style {prompt} . Native American, traditional, pottery, highly detailed","non-Native American, modern, photography, undetailed"
+Style: Cloisonné,"Cloisonné style {prompt} . metalwork, enamel, intricate, highly detailed","woodwork, paint, simple, undetailed"
+Style: Khokhloma,"Khokhloma style {prompt} . Russian, folk art, floral, highly detailed","non-Russian, fine art, geometric, undetailed"
+Style: Biedermeier,"Biedermeier style {prompt} . 19th century, domestic, unpretentious, highly detailed","21st century, public, pretentious, undetailed"
+Style: Goryeo,"Goryeo style {prompt} . Korean, celadon, inlay, highly detailed","non-Korean, terra cotta, relief, undetailed"
+Style: Han,"Han style {prompt} . Chinese, ancient, stone relief, highly detailed","non-Chinese, modern, oil painting, undetailed"
+Style: Hellenistic,"Hellenistic style {prompt} . ancient Greek, dynamic, emotional, highly detailed","modern, static, unemotional, undetailed"
+Style: Tang,"Tang style {prompt} . Chinese, ancient, sculpture, highly detailed","non-Chinese, modern, photography, undetailed"
+Style: Ming,"Ming style {prompt} . Chinese, elegant, pottery, highly detailed","non-Chinese, rustic, painting, undetailed"
+Style: Joseon,"Joseon style {prompt} . Korean, Confucian, painting, highly detailed","non-Korean, Taoist, sculpture, undetailed"
+Style: Gupta,"Gupta style {prompt} . Indian, ancient, sculpture, highly detailed","non-Indian, modern, painting, undetailed"
+Style: Pallava,"Pallava style {prompt} . Indian, Dravidian architecture, sculpture, highly detailed","non-Indian, Mughal architecture, painting, undetailed"
+Style: Chola,"Chola style {prompt} . Indian, bronze, dancing Shiva, highly detailed","non-Indian, marble, sitting Buddha, undetailed"
+Style: Minoan,"Minoan style {prompt} . ancient Crete, frescoes, sea life, highly detailed","modern, oil painting, land animals, undetailed"
+Style: Mycenaean,"Mycenaean style {prompt} . ancient Greece, gold, death mask, highly detailed","modern, bronze, life mask, undetailed"
+Style: Ndebele,"Ndebele style {prompt} . African, geometric, house painting, highly detailed","non-African, organic, canvas painting, undetailed"
+Style: San,"San style {prompt} . African, rock art, animal figures, highly detailed","non-African, digital art, human figures, undetailed"
+Style: Batik,"Batik style {prompt} . Indonesian, resist dyeing, floral, highly detailed","non-Indonesian, direct dyeing, geometric, undetailed"
+Style: Assyrian,"Assyrian style {prompt} . ancient Mesopotamia, relief, war scenes, highly detailed","modern, oil painting, peaceful scenes, undetailed"
+Style: Thracian,"Thracian style {prompt} . ancient Balkans, gold, ritual objects, highly detailed","modern, wood, everyday objects, undetailed"
+Style: Etruscan,"Etruscan style {prompt} . ancient Italy, bronze, mythological scenes, highly detailed","modern, steel, realistic scenes, undetailed"
+Style: Sumerian,"Sumerian style {prompt} . ancient Mesopotamia, cuneiform, clay tablets, highly detailed","modern, Latin script, parchment scrolls, undetailed"
+Style: Babylonian,"Babylonian style {prompt} . ancient Mesopotamia, law codes, stone steles, highly detailed","modern, lawless, paper books, undetailed"
+Style: Norse,"Norse style {prompt} . Viking, runic, wood carving, highly detailed","non-Viking, Latin script, metalwork, undetailed"
+Style: Olmec,"Olmec style {prompt} . ancient Mexico, colossal heads, basalt, highly detailed","modern, miniature hands, marble, undetailed"
+Style: Toltec,"Toltec style {prompt} . ancient Mexico, monumental architecture, relief, highly detailed","modern, small-scale models, oil painting, undetailed"
+Style: Sicán,"Sicán style {prompt} . ancient Peru, gold masks, funerary objects, highly detailed","modern, wood masks, everyday objects, undetailed"
+Style: Nazca,"Nazca style {prompt} . ancient Peru, geoglyphs, desert, highly detailed","modern, graffiti, urban, undetailed"
+Style: Inca,"Inca style {prompt} . ancient Peru, stonework, terraces, highly detailed","modern, woodwork, flat plains, undetailed"
+Style: Zapotec,"Zapotec style {prompt} . ancient Mexico, urns, jaguars, highly detailed","modern, vases, dogs, undetailed"
+Style: Mixtec,"Mixtec style {prompt} . ancient Mexico, codices, turquoise, highly detailed","modern, novels, gold, undetailed"
+Style: Ottonian,"Ottonian style {prompt} . medieval Germany, religious art, manuscripts, highly detailed","modern, secular art, newspapers, undetailed"
+Style: Merovingian,"Merovingian style {prompt} . medieval France, jewelry, garnet cloisonné, highly detailed","modern, clothing, sapphire pavé, undetailed"
+Style: Carolingian,"Carolingian style {prompt} . medieval Europe, illuminatedmanuscripts, luxury, highly detailed","modern, paperback books, simplicity, undetailed"
+Style: Otomi,"Otomi style {prompt} . Mexican, textile, embroidery, highly detailed","non-Mexican, metalwork, hammering, undetailed"
+Style: Huichol,"Huichol style {prompt} . Mexican, yarn painting, spiritual, highly detailed","non-Mexican, oil painting, secular, undetailed"
+Style: Ainu,"Ainu style {prompt} . Japanese indigenous, wood carving, bear worship, highly detailed","non-Japanese, stone carving, dragon worship, undetailed"
+Style: Maori,"Maori style {prompt} . New Zealand, tattoo, spiritual, highly detailed","non-New Zealand, body paint, secular, undetailed"
+Style: Aboriginal,"Aboriginal style {prompt} . Australian indigenous, dot painting, storytelling, highly detailed","non-Australian, line drawing, non-narrative, undetailed"
+Style: Inuit,"Inuit style {prompt} . Arctic, stone carving, animal figures, highly detailed","tropical, wood carving, human figures, undetailed"
+Style: Saami,"Saami style {prompt} . Nordic indigenous, duodji (craft), reindeer, highly detailed","non-Nordic, factory-made, cow, undetailed"
+Style: Ojibwe,"Ojibwe style {prompt} . Native American, birch bark, canoes, highly detailed","non-Native American, pine bark, rafts, undetailed"
+Style: Tlingit,"Tlingit style {prompt} . Native American, totem poles, spiritual, highly detailed","non-Native American, street signs, secular, undetailed"
+Style: Navajo,"Navajo style {prompt} . Native American, textile, rug weaving, highly detailed","non-Native American, metalwork, jewelry making, undetailed"
+Style: Apache,"Apache style {prompt} . Native American, basketry, coiled, highly detailed","non-Native American, pottery, thrown, undetailed"
+Style: Zuni,"Zuni style {prompt} . Native American, jewelry, silver, highly detailed","non-Native American, clothing, cotton, undetailed"
+Style: Hopi,"Hopi style {prompt} . Native American, kachina dolls, spiritual, highly detailed","non-Native American, action figures, secular, undetailed"
+Style: Sioux,"Sioux style {prompt} . Native American, quillwork, porcupine, highly detailed","non-Native American, embroidery, silk, undetailed"
+Style: Lakota,"Lakota style {prompt} . Native American, beadwork, clothing, highly detailed","non-Native American, sequin work, banners, undetailed"
+Style: Yupik,"Yupik style {prompt} . Native American, mask, ceremonial, highly detailed","non-Native American, mask, recreational, undetailed"
+Style: Cherokee,"Cherokee style {prompt} . Native American, pottery, stamped, highly detailed","non-Native American, pottery, painted, undetailed"
+Style: Mohawk,"Mohawk style {prompt} . Native American, sweetgrass, basketry, highly detailed","non-Native American, bamboo, basketry, undetailed"
+Style: Cree,"Cree style {prompt} . Native American, hide, clothing, highly detailed","non-Native American, synthetic material, clothing, undetailed"
+Style: Acoma,"Acoma style {prompt} . Native American, pottery, sky city, highly detailed","non-Native American, pottery, earth city, undetailed"
+Style: Laguna,"Laguna style {prompt} . Native American, pottery, polychrome, highly detailed","non-Native American, pottery, monochrome, undetailed"
+Style: Seminole,"Seminole style {prompt} . Native American, patchwork, clothing, highly detailed","non-Native American, knitting, clothing, undetailed"
+Style: Osage,"Osage style {prompt} . Native American, ribbon work, floral, highly detailed","non-Native American, beadwork, geometric, undetailed"
+Style: Anasazi,"Anasazi style {prompt} . Native American, pottery, black-on-white, highly detailed","non-Native American, pottery, color-on-color, undetailed"
+Style: Mimbres,"Mimbres style {prompt} . Native American, pottery, figurative, highly detailed","non-Native American, pottery, abstract, undetailed"
+Style: Pomo,"Pomo style {prompt} . Native American, basketry, feathers, highly detailed","non-Native American, basketry, beads, undetailed"
+Style: Hohokam,"Hohokam style {prompt} . Native American, pottery, red-on-buff, highly detailed","non-Native American, pottery, blue-on-cream, undetailed"
+Style: Mississippian,"Mississippian style {prompt} . Native American, stone carving, ceremonial, highly detailed","non-Native American, wood carving, everyday, undetailed"
+Style: Fremont,"Fremont style {prompt} . Native American, petroglyphs, rock art, highly detailed","non-Native American, graffiti, wall art, undetailed"
+Style: Mogollon,"Mogollon style {prompt} . Native American, pottery, geometric, highly detailed","non-Native American, pottery, organic, undetailed"
+Style: Salado,"Salado style {prompt} . Native American, pottery, polychrome, highly detailed","non-Native American, pottery, duochrome, undetailed"
+Style: Zulu,"Zulu style {prompt} . African, basketry, coiled, highly detailed","non-African, pottery, thrown, undetailed"
+Style: Maasai,"Maasai style {prompt} . African, beadwork, jewelry, highly detailed","non-African, macramé, wall hanging, undetailed"
+Style: Ndebele,"Ndebele style {prompt} . African, mural art, homes, highly detailed","non-African, canvas art, studios, undetailed"
+Style: Kuba,"Kuba style {prompt} . African, textile, raffia, highly detailed","non-African, metalwork, steel, undetailed"
+Style: Yoruba,"Yoruba style {prompt} . African, sculpture, spiritual, highly detailed","non-African, photography, secular, undetailed"
+Style: Akan,"Akan style {prompt} . African, gold weights, symbolic, highly detailed","non-African, silver weights, literal, undetailed"
+Style: Berber,"Berber style {prompt} . North African, jewelry, silver, highly detailed","non-North African, clothing, cotton, undetailed"
+Style: Dogon,"Dogon style {prompt} . African, wood carving, spiritual, highly detailed","non-African, stone carving, secular, undetailed"
+Style: Fang,"Fang style {prompt} . African, mask, ceremonial, highly detailed","non-African, mask, recreational, undetailed"
+Style: Baga,"Baga style {prompt} . African, mask, spiritual, highly detailed","non-African, mask, secular, undetailed"
+>>>>>> GPT Culture Movies Prompts
+Style: Blade Runner,"Blade Runner {prompt} . Cyberpunk, neon-lit, rainy, dystopian, noir, cinematic, highly detailed","bright, sunny, utopian, cheerful, undetailed"
+Style: Star Wars,"Star Wars {prompt} . Space opera, galaxy far, far away, epic, iconic, cinematic, highly detailed","earthly, small scale, uniconic, undetailed"
+Style: Lord of the Rings,"Lord of the Rings {prompt} . Epic fantasy, Middle-earth, vast landscapes, highly detailed","science fiction, cityscape, undetailed"
+Style: Matrix,"Matrix {prompt} . Cyberpunk, green tint, reality-bending, cinematic, highly detailed","rustic, brown tint, reality-based, undetailed"
+Style: Indiana Jones,"Indiana Jones {prompt} . Adventure, archaeology, exotic locations, cinematic, highly detailed","domestic, library, unadventurous, undetailed"
+Style: Mad Max,"Mad Max {prompt} . Post-apocalyptic, desert landscapes, dystopian, cinematic, highly detailed","utopian, lush landscapes, pre-apocalyptic, undetailed"
+Style: 2001: A Space Odyssey,"2001: A Space Odyssey {prompt} . Sci-fi, space exploration, monolith, cinematic, highly detailed","fantasy, earth exploration, monochrome, undetailed"
+Style: Alien,"Alien {prompt} . Sci-fi horror, space, xenomorphs, dark, highly detailed","comedy, bright, undetailed"
+Style: Avatar,"Avatar {prompt} . Sci-fi, Pandora, bioluminescent, 3D, highly detailed","earthly, non-bioluminescent, 2D, undetailed"
+Style: Pulp Fiction,"Pulp Fiction {prompt} . Crime, non-linear narrative, 90s, highly detailed","linear narrative, 2000s, undetailed"
+Style: Kill Bill,"Kill Bill {prompt} . Martial arts, vengeance, yellow jumpsuit, cinematic, highly detailed","peaceful, pink jumpsuit, undetailed"
+Style: Inception,"Inception {prompt} . Sci-fi, dream within a dream, mind-bending, cinematic, highly detailed","reality-based, straightforward, undetailed"
+Style: Fight Club,"Fight Club {prompt} . Dark, gritty, psychological drama, highly detailed","light, glossy, undramatic, undetailed"
+Style: Harry Potter,"Harry Potter {prompt} . Fantasy, Hogwarts, wizardry, highly detailed","science fiction, non-magical, undetailed"
+Style: Marvel Cinematic Universe,"Marvel Cinematic Universe {prompt} . Superheroes, epic battles, colorful, highly detailed","ordinary people, small conflicts, monochrome, undetailed"
+Style: DC Extended Universe,"DC Extended Universe {prompt} . Superheroes, grim, darker tones, highly detailed","ordinary people, cheerful, brighter tones, undetailed"
+Style: Game of Thrones,"Game of Thrones {prompt} . Fantasy, Westeros, dragons, highly detailed","science fiction, no dragons, undetailed"
+Style: Twilight,"Twilight {prompt} . Romantic fantasy, vampires, Pacific Northwest, highly detailed","non-romantic, zombies, desert, undetailed"
+Style: Transformers,"Transformers {prompt} . Sci-fi, giant robots, explosions, highly detailed","fantasy, small creatures, calm, undetailed"
+Style: The Hunger Games,"The Hunger Games {prompt} . Dystopian, survival, rebellion, highly detailed","utopian, abundance, conformity, undetailed"
+Style: Pirates of the Caribbean,"Pirates of the Caribbean {prompt} . Adventure, pirates, supernatural, highly detailed","domestic, non-pirates, realistic, undetailed"
+Style: Jurassic Park,"Jurassic Park {prompt} . Adventure, dinosaurs, Isla Nublar, highly detailed","undramatic, no dinosaurs, mainland, undetailed"
+Style: The Shining,"The Shining {prompt} . Horror, haunted hotel, psychological thriller, highly detailed","comedy, non-haunted hotel, undetailed"
+Style: The Godfather,"The Godfather {prompt} . Crime, mafia, 1940s-1950s, highly detailed","law-abiding, 2000s, undetailed"
+Style: The Dark Knight,"The Dark Knight {prompt} . Superhero, gritty, Batman, Joker, highly detailed","light-hearted, Superman, undetailed"
+Style: Casablanca,"Casablanca {prompt} . Drama, romance, WWII, highly detailed","action, non-romantic, modern day, undetailed"
+Style: Jaws,"Jaws {prompt} . Thriller, shark, Amity Island, highly detailed","comedy, no shark, mainland, undetailed"
+Style: The Wizard of Oz,"The Wizard of Oz {prompt} . Fantasy, musical, Technicolor, Oz, highly detailed","realistic, non-musical, monochrome, Kansas, undetailed"
+Style: E.T.,"E.T. {prompt} . Sci-fi, family, suburban, highly detailed","fantasy, non-family, urban, undetailed"
+Style: Ghostbusters,"Ghostbusters {prompt} . Comedy, supernatural, New York City, highly detailed","horror, natural, rural, undetailed"
+Style: Back to the Future,"Back to the Future {prompt} . Sci-fi, time travel, DeLorean, highly detailed","fantasy, time stationary, non-vehicle, undetailed"
+Style: Toy Story,"Toy Story {prompt} . Animated, toys come to life, friendship, highly detailed","live-action, inanimate toys, rivalry, undetailed"
+Style: The Lion King,"The Lion King {prompt} . Animated, animal kingdom, African savannah, highly detailed","live-action, human kingdom, urban, undetailed"
+Style: Finding Nemo,"Finding Nemo {prompt} . Animated, ocean adventure, Great Barrier Reef, highly detailed","live-action, land adventure, desert, undetailed"
+Style: Shrek,"Shrek {prompt} . Animated, fairytale, swamp, highly detailed","live-action, realistic, city, undetailed"
+Style: The Little Mermaid,"The Little Mermaid {prompt} . Animated, undersea, mermaids, highly detailed","live-action, land, humans, undetailed"
+Style: Aladdin,"Aladdin {prompt} . Animated, Arabian Nights, magic carpet, highly detailed","live-action, modern day, ordinary carpet, undetailed"
+Style: Beauty and the Beast,"Beauty and the Beast {prompt} . Animated, fairytale, enchanted castle, highly detailed","live-action, realistic, ordinary house, undetailed"
+Style: Cinderella,"Cinderella {prompt} . Animated, fairytale, magical transformation, highly detailed","live-action, realistic, ordinary transformation, undetailed"
+Style: Sleeping Beauty,"Sleeping Beauty {prompt} . Animated, fairytale, spinning wheel, highly detailed",""live-action, realistic, sewing machine, undetailed"
+Style: Snow White,"Snow White {prompt} . Animated, fairytale, seven dwarfs, highly detailed","live-action, realistic, seven giants, undetailed"
+Style: Mulan,"Mulan {prompt} . Animated, historical, Chinese warfare, highly detailed","live-action, futuristic, space warfare, undetailed"
+Style: Pocahontas,"Pocahontas {prompt} . Animated, historical, Native American, highly detailed","live-action, modern, urban American, undetailed"
+Style: The Nightmare Before Christmas,"The Nightmare Before Christmas {prompt} . Stop-motion, Halloween Town, Christmas Town, highly detailed","live-action, Easter Town, undetailed"
+Style: Frozen,"Frozen {prompt} . Animated, fairytale, ice magic, highly detailed","live-action, realistic, fire magic, undetailed"
+Style: Moana,"Moana {prompt} . Animated, Polynesian, ocean adventure, highly detailed","live-action, Nordic, mountain adventure, undetailed"
+Style: Tangled,"Tangled {prompt} . Animated, fairytale, magic hair, highly detailed","live-action, realistic, ordinary hair, undetailed"
+Style: Zootopia,"Zootopia {prompt} . Animated, anthropomorphic animals, urban, highly detailed","live-action, humans, rural, undetailed"
+Style: Coco,"Coco {prompt} . Animated, Dia de los Muertos, Mexican culture, highly detailed","live-action, Halloween, American culture, undetailed"
+Style: Brave,"Brave {prompt} . Animated, Scottish highlands, archery, highly detailed","live-action, tropical island, surfing, undetailed"
+Style: Inside Out,"Inside Out {prompt} . Animated, emotions, abstract, highly detailed","live-action, logical thinking, realistic, undetailed"
+Style: The Incredibles,"The Incredibles {prompt} . Animated, superhero, family, highly detailed","live-action, villain, solitary, undetailed"
+Style: Up,"Up {prompt} . Animated, adventure, flying house, highly detailed","live-action, everyday life, stationary house, undetailed"
+Style: Wall-E,"Wall-E {prompt} . Animated, post-apocalyptic, robots, highly detailed","live-action, pre-apocalyptic, humans, undetailed"
+Style: Ratatouille,"Ratatouille {prompt} . Animated, culinary, Paris, highly detailed","live-action, non-culinary, New York, undetailed"
+Style: Monsters Inc.,"Monsters Inc. {prompt} . Animated, monsters, scare factory, highly detailed","live-action, humans, laughter factory, undetailed"
+Style: Cars,"Cars {prompt} . Animated, anthropomorphic cars, racing, highly detailed","live-action, humans, walking, undetailed"
+Style: A Bug's Life,"A Bug's Life {prompt} . Animated, insects, ant colony, highly detailed","live-action, mammals, human society, undetailed"
+Style: James Bond,"James Bond {prompt} . Spy, action, globe-trotting, highly detailed","romantic comedy, peace, domestic, undetailed"
+Style: Fast and Furious,"Fast and Furious {prompt} . Action, car chases, family, highly detailed","romantic comedy, pedestrian chases, solitary, undetailed"
+Style: Mission Impossible,"Mission Impossible {prompt} . Action, spy, impossible stunts, highly detailed","romantic comedy, everyday person, possible stunts, undetailed"
+Style: Jurassic World,"Jurassic World {prompt} . Adventure, dinosaurs, theme park, highly detailed","romantic comedy, no dinosaurs, city park, undetailed"
+Style: Minions,"Minions {prompt} . Animated, comedy, minions, highly detailed","live-action, drama, no minions, undetailed"
+Style: Interstellar,"Interstellar {prompt} . Sci-fi, space travel, wormholes, highly detailed","romantic comedy, earth travel, roads, undetailed"
+Style: The Grinch,"The Grinch {prompt} . Animated, Christmas, Whoville, highly detailed","live-action, summer, city, undetailed"
+Style: Avengers: Endgame,"Avengers: Endgame {prompt} . Superhero, epic battle, time travel, highly detailed","romantic comedy, small conflict, present time, undetailed"
+Style: Wonder Woman,"Wonder Woman {prompt} . Superhero, Amazonian, World War I, highly detailed","romantic comedy, non-Amazonian, modern day, undetailed"
+Style: The Iron Giant,"The Iron Giant {prompt} . Animated, robot, 1950s, highly detailed","live-action, human, modern day, undetailed"
+Style: Godzilla,"Godzilla {prompt} . Monster, destruction, cityscape, highly detailed","romantic comedy, creation, countryside, undetailed"
+Style: King Kong,"King Kong {prompt} . Monster, island, skyscraper, highly detailed","romantic comedy, mainland, low-rise, undetailed"
+Style: The Grand Budapest Hotel,"The Grand Budapest Hotel {prompt} . Comedy, hotel, pastel colors, highly detailed","action, wilderness, dark colors, undetailed"
+Style: Inside Llewyn Davis,"Inside Llewyn Davis {prompt} . Drama, folk music, 1960s, highly detailed","action, pop music, modern day, undetailed"
+Style: Drive,"Drive {prompt} . Action, neon, 1980s aesthetic, highly detailed","romantic comedy, daylight, modern aesthetic, undetailed"
+Style: The Neon Demon,"The Neon Demon {prompt} . Horror, fashion, Los Angeles, highly detailed","romantic comedy, construction, New York, undetailed"
+Style: It Follows,"It Follows {prompt} . Horror, supernatural, suburbia, highly detailed","romantic comedy, natural, city, undetailed"
+Style: Dunkirk,"Dunkirk {prompt} . War, World War II, beach, highly detailed","romantic comedy, peace, city, undetailed"
+Style: Her,"Her {prompt} . Romance, sci-fi, artificial intelligence, highly detailed","action, reality, human intelligence, undetailed"
+Style: The Revenant,"The Revenant {prompt} . Drama, survival, wilderness, highly detailed","romantic comedy, luxury, city, undetailed"
+Style: Whiplash,"Whiplash {prompt} . Drama, music, drumming, highly detailed","action, silence, no music, undetailed"
+Style: The Shape of Water,"The Shape of Water {prompt} . Fantasy, romance, aquatic creature, highly detailed","action, hatred, terrestrial creature, undetailed"
+Style: A Ghost Story,"A Ghost Story {prompt} . Drama, supernatural, ghost, highly detailed","romantic comedy, natural, human, undetailed"
+Style: The Florida Project,"The Florida Project {prompt} . Drama, childhood, motel, highly detailed","action, adulthood, skyscraper, undetailed"
+Style: La La Land,"La La Land {prompt} . Musical, romance, Los Angeles, highly detailed","action, hatred, New York, undetailed"
+Style: The Lobster,"The Lobster {prompt}". Dark comedy, dystopian, relationship rules, highly detailed","romantic comedy, utopian, no relationship rules, undetailed"
+Style: Ex Machina,"Ex Machina {prompt} . Sci-fi, artificial intelligence, secluded mansion, highly detailed","romantic comedy, human intelligence, bustling city, undetailed"
+Style: Birdman,"Birdman {prompt} . Drama, Broadway, magical realism, highly detailed","action, Hollywood, realism, undetailed"
+Style: Gravity,"Gravity {prompt} . Sci-fi, space, survival, highly detailed","romantic comedy, earth, abundance, undetailed"
+Style: The Tree of Life,"The Tree of Life {prompt} . Drama, philosophical, nonlinear narrative, highly detailed","action, practical, linear narrative, undetailed"
+Style: Inception,"Inception {prompt} . Sci-fi, dream manipulation, heist, highly detailed","romantic comedy, reality, gift-giving, undetailed"
+Style: The Social Network,"The Social Network {prompt} . Drama, Facebook, entrepreneurship, highly detailed","action, Myspace, employment, undetailed"
+Style: Moonlight,"Moonlight {prompt} . Drama, coming-of-age, Miami, highly detailed","action, aging, Los Angeles, undetailed"
+Style: Roma,"Roma {prompt} . Drama, Mexico City, 1970s, highly detailed","action, New York City, modern day, undetailed"
+Style: Parasite,"Parasite {prompt} . Thriller, class disparity, South Korea, highly detailed","romantic comedy, class equality, United States, undetailed"
+Style: 1917,"1917 {prompt} . War, World War I, single shot, highly detailed","romantic comedy, peace, multiple shots, undetailed"
+Style: Jojo Rabbit,"Jojo Rabbit {prompt} . Comedy, World War II, imaginary friend, highly detailed","drama, modern day, real friend, undetailed"
+Style: Joker,"Joker {prompt} . Drama, psychological, Gotham City, highly detailed","romantic comedy, psychological well-being, Metropolis, undetailed"
+Style: The Lighthouse,"The Lighthouse {prompt} . Drama, isolation, lighthouse, highly detailed","romantic comedy, community, city, undetailed"
+Style: Once Upon a Time in Hollywood,"Once Upon a Time in Hollywood {prompt} . Comedy-drama, 1960s Hollywood, film industry, highly detailed","action, modern Hollywood, tech industry, undetailed"
+Style: The Irishman,"The Irishman {prompt} . Crime, mafia, aging, highly detailed","romantic comedy, law-abiding citizens, youth, undetailed"
+Style: Uncut Gems,"Uncut Gems {prompt} . Crime, debt, gambling, highly detailed","romantic comedy, abundance, saving, undetailed"
+Style: Little Women,"Little Women {prompt} . Drama, coming-of-age, Civil War era, highly detailed","action, aging, modern day, undetailed"
+Style: Knives Out,"Knives Out {prompt} . Mystery, whodunit, wealthy family, highly detailed","romantic comedy, clear culprit, poor family, undetailed"
+Style: Marriage Story,"Marriage Story {prompt} . Drama, divorce, bi-coastal, highly detailed","romantic comedy, marriage, same city, undetailed"
+Style: Midsommar,"Midsommar {prompt} . Horror, cult, Sweden, highly detailed","romantic comedy, mainstream religion, United States, undetailed"
+Style: Booksmart,"Booksmart {prompt} . Comedy, high school, overachievers, highly detailed","drama, college, underachievers, undetailed"
+Style: Ford v Ferrari,"Ford v Ferrari {prompt} . Drama, racing, 1960s, highly detailed","romantic comedy, walking, modern day, undetailed"
+Style: Rocketman,"Rocketman {prompt} . Musical, biographical, Elton John, highly detailed","action, fictional, ordinary person, undetailed"
+Style: Ad Astra,"Ad Astra {prompt} . Sci-fi, space travel, father-son relationship, highly detailed","romantic comedy, earth travel, romantic relationship, undetailed"
+Style: Waves,"Waves {prompt} . Drama, family tragedy, forgiveness, highly detailed","romantic comedy, family comedy, grudge, undetailed"
+Style: The Farewell,"The Farewell {prompt} . Drama, family, cultural conflict, highly detailed","romantic comedy, strangers, cultural harmony, undetailed"
+Style: Hustlers,"Hustlers {prompt} . Drama, strippers, financial crime, highly detailed","romantic comedy, office workers, financial responsibility, undetailed"
+Style: Portrait of a Lady on Fire,"Portrait of a Lady on Fire {prompt} . Romance, art, 18th century France, highly detailed","action, science, modern day United States, undetailed"
+Style: Pain and Glory,"Painand Glory {prompt} . Drama, filmmaking, memory, highly detailed","romantic comedy, accounting, forgetfulness, undetailed"
+Style: The Two Popes,"The Two Popes {prompt} . Drama, Vatican, philosophical discussions, highly detailed","action, a small town, physical challenges, undetailed"
+Style: A Beautiful Day in the Neighborhood,"A Beautiful Day in the Neighborhood {prompt} . Drama, Fred Rogers, kindness, highly detailed","action, a villainous character, ruthlessness, undetailed"
+Style: The Peanut Butter Falcon,"The Peanut Butter Falcon {prompt} . Adventure, friendship, wrestling, highly detailed","romantic comedy, rivalry, chess, undetailed"
+Style: The Goldfinch,"The Goldfinch {prompt} . Drama, art, trauma, highly detailed","action, science, joy, undetailed"
+Style: High Life,"High Life {prompt} . Sci-fi, space travel, isolation, highly detailed","romantic comedy, road trip, companionship, undetailed"
+Style: The Nightingale,"The Nightingale {prompt} . Drama, revenge, colonial Tasmania, highly detailed","romantic comedy, forgiveness, modern California, undetailed"
+Style: Yesterday,"Yesterday {prompt} . Comedy, music, The Beatles, highly detailed","drama, silence, unknown band, undetailed"
+Style: Doctor Sleep,"Doctor Sleep {prompt} . Horror, supernatural, The Shining sequel, highly detailed","romantic comedy, natural, standalone story, undetailed"
+Style: The Farewell,"The Farewell {prompt} . Drama, family, terminal illness, highly detailed","romantic comedy, friends, good health, undetailed"
+Style: John Wick 3,"John Wick 3 {prompt} . Action, assassin, relentless pursuit, highly detailed","romantic comedy, pacifist, peaceful life, undetailed"
+Style: Us,"Us {prompt} . Horror, doppelgängers, underground, highly detailed","romantic comedy, identical twins, above ground, undetailed"
+Style: The Irishman,"The Irishman {prompt} . Crime, mobster, union, highly detailed","romantic comedy, law-abiding citizen, small business, undetailed"
+Style: Honey Boy,"Honey Boy {prompt} . Drama, father-son relationship, Hollywood, highly detailed","romantic comedy, mother-daughter relationship, a small town, undetailed"
+Style: Joker,"Joker {prompt} . Drama, mental health, Gotham City, highly detailed","romantic comedy, mental well-being, Metropolis, undetailed"
+Style: Uncut Gems,"Uncut Gems {prompt} . Crime, gambling, New York City's Diamond District, highly detailed","romantic comedy, savings, rural town, undetailed"
+Style: 1917,"1917 {prompt} . War, World War I, real-time, highly detailed","romantic comedy, peacetime, timeless, undetailed"
+Style: Ford v Ferrari,"Ford v Ferrari {prompt} . Drama, racing, corporate politics, highly detailed","romantic comedy, walking, friendship, undetailed"
+Style: Cats,"Cats {prompt} . Musical, anthropomorphic cats, surreal, highly detailed","action, ordinary humans, realism, undetailed"
+Style: Jojo Rabbit,"Jojo Rabbit {prompt} . Comedy-drama, World War II, Hitler Youth, highly detailed","romantic comedy, modern day, ordinary youth, undetailed"
+Style: Parasite,"Parasite {prompt} . Drama, social class, deception, highly detailed","romantic comedy, equality, honesty, undetailed"
+Style: The Lion King,"The Lion King {prompt} . Animated, animal kingdom, Shakespearean, highly detailed","live-action, human kingdom, modern, undetailed"
+Style: Aladdin,"Aladdin {prompt} . Animated, Middle Eastern, magic, highly detailed","live-action, Western, science, undetailed"
+Style: Toy Story 4,"Toy Story 4 {prompt} . Animated, toys, adventure, highly detailed","live-action, non-living objects, ordinary life, undetailed"
+Style: Avengers: Endgame,"Avengers: Endgame {prompt} . Superhero, epic, time travel, highly detailed","romantic comedy, small-scale, present day, undetailed"
+Style: Star Wars: The Rise of Skywalker,"Star Wars: The Rise of Skywalker {prompt} . Sci-fi, space opera, Jedi, highly detailed","romantic comedy, earthbound, everyday person, undetailed"
+Style: Downton Abbey,"Downton Abbey {prompt} . Drama, British aristocracy, period piece, highly detailed","romantic comedy, modern middle class, present day, undetailed"
+Style: Frozen 2,"Frozen 2 {prompt} . Animated, fairytale, sisterhood, highly detailed","live-action, realism, rivalry, undetailed"
+Style: Little Women,"Little Women {prompt} . Drama, sisters, Civil War era, highly detailed","action, brothers, modern day, undetailed"
+>>>>>>  GPT Anime Cartoon Mangas
+Style: 2D Traditional Animation,"traditional 2D animation {prompt} . hand-drawn, frames, expressive, vibrant colors, highly detailed","3D, CG, stop-motion, photo-realistic, black and white"
+Style: CGI Animation,"CGI animation {prompt} . 3D, photorealistic, high-quality textures and lighting, highly detailed","2D, stop-motion, anime, manga, black and white"
+Style: Stop-Motion Animation,"stop-motion animation {prompt} . physical models, frame-by-frame, quirky, distinctive, highly detailed","2D, 3D, CG, anime, manga, black and white"
+Style: Claymation,"claymation {prompt} . clay models, stop-motion, handcrafted, tactile, highly detailed","2D, 3D, CG, anime, manga, black and white"
+Style: Vector Animation,"vector animation {prompt} . digital, clean lines, geometric shapes, bold colors, highly detailed","stop-motion, claymation, 3D, CG, black and white"
+Style: Flash Animation,"flash animation {prompt} . digital, vector graphics, tweening, simple shapes, highly detailed","stop-motion, claymation, 3D, CG, black and white"
+Style: Rotoscope Animation,"rotoscope animation {prompt} . traced over live-action, realistic movement, highly detailed","stop-motion, claymation, 3D, CG, black and white"
+Style: Cut-Out Animation,"cut-out animation {prompt} . paper or fabric cut-outs, stop-motion, handcrafted, highly detailed","2D, 3D, CG, anime, manga, black and white"
+Style: Sand Animation,"sand animation {prompt} . sand manipulated on light box, fluid movement, highly detailed","2D, 3D, CG, anime, manga, black and white"
+Style: Pixel Art Animation,"pixel art animation {prompt} . low-res, blocky, digital, 8-bit, highly detailed","stop-motion, claymation, 3D, CG, black and white"
+Style: Anime Style Animation,"anime style animation {prompt} . Japanese style, hand-drawn or digital, vibrant, unique character designs, highly detailed","western cartoons, 3D, CG, black and white"
+Style: Manga Style Art,"manga style {prompt} . Japanese comics, black and white, unique character designs, detailed backgrounds, highly detailed","western comics, 3D, CG, vibrant colors"
+Style: Chibi Style Art,"chibi style {prompt} . Japanese, super-deformed, cute, exaggerated features, vibrant colors, highly detailed","realistic, 3D, CG, western comics, black and white"
+Style: Superflat,"superflat {prompt} . Japanese, postmodern art, flat planes of color, manga and anime influences, highly detailed","3D, CG, western art styles, black and white"
+Style: Ukiyo-e,"ukiyo-e style {prompt} . Japanese woodblock prints, flat areas of color, detailed patterns, subjects from history and mythology, highly detailed","modern, 3D, CG, western art styles, black and white"
+Style: Western Comics Art,"western comics art {prompt} . bold lines, dynamic poses, vibrant colors, dramatic lighting, highly detailed","anime, manga, 3D, CG, black and white"
+Style: Graphic Novel Art,"graphic novel art {prompt} . detailed, expressive, ranges from black and white to full color, often more realistic than traditional comics, highly detailed","anime, manga, 3D, CG, western comics"
+Style: Cartoon Modern,"cartoon modern {prompt} . mid-century modern aesthetic, stylized, geometric shapes, flat colors, highly detailed","realistic, 3D, CG, anime, manga, black and white"
+Style: Abstract Animation,"abstract animation {prompt} . nonrepresentational, uses movement and color to create mood or emotion, highly detailed","realistic, 3D, CG, anime, manga, black and white"
+Style: Silhouette Animation,"silhouette animation {prompt} . black figures against light background, dramatic, based on shadow puppetry, highly detailed","colorful, 3D, CG, anime, manga, black and white"
+Style: Looney Tunes,"Looney Tunes {prompt} . Cartoon, slapstick humor, dynamic and exaggerated character designs, colorful, vibrant, whimsical","3D, realism, manga, black and white, subdued, serious"
+Style: Disney Classic,"Disney Classic {prompt} . Animation, fairy tales, musical numbers, expressive characters, bright colors, detailed, professional","manga, anime, black and white, sketchy, rough"
+Style: Studio Ghibli,"Studio Ghibli {prompt} . Anime, magical realism, environmental themes, unique characters, breathtaking landscapes, highly detailed","cartoon, slapstick, black and white, photo-realistic, barren"
+Style: Pixar,"Pixar {prompt} . 3D animation, heartwarming stories, photorealistic environments, appealing character designs, emotional depth, detailed, professional","2D, anime, manga, black and white, sketchy"
+Style: Shōnen,"Shōnen {prompt} . Manga, action-packed, youthful characters, dynamic battles, inspiring themes, highly detailed","Disney, Pixar, black and white, realism, romantic comedy"
+Style: Mecha,"Mecha {prompt} . Anime, robots, futuristic technologies, dynamic battles, detailed mechanical designs, highly detailed","Disney, Pixar, cartoon, Looney Tunes, realism, fairy tales"
+Style: Shojo,"Shojo {prompt} . Manga, romantic themes, delicate art style, emotional narratives, highly detailed","action, mecha, 3D, Pixar, black and white, barren"
+Style: Nickelodeon,"Nickelodeon {prompt} . Cartoon, humor, dynamic characters, wacky and colorful designs, highly detailed","anime, manga, black and white, sketchy, serious"
+Style: Cartoon Network,"Cartoon Network {prompt} . Cartoon, humor, dynamic characters, unique and abstract designs, highly detailed","anime, manga, black and white, sketchy, serious"
+Style: Adult Swim,"Adult Swim {prompt} . Animation, adult humor, surreal themes, unique and abstract designs, highly detailed","children's cartoons, Disney, fairy tales, bright colors, traditional"
+Style: Adventure Time,"Adventure Time {prompt} . Cartoon, fantasy themes, quirky characters, vibrant colors, highly detailed","anime, manga, black and white, sketchy, serious"
+Style: Rick and Morty,"Rick and Morty {prompt} . Cartoon, science fiction, adult humor, unique and abstract designs, highly detailed","children's cartoons, Disney, fairy tales, bright colors, traditional"
+Style: South Park,"South Park {prompt} . Animation, satire, crude humor, simplistic designs, highly detailed","anime, manga, Disney, Pixar, detailed, professional"
+Style: The Simpsons,"The Simpsons {prompt} . Animation, satire, family themes, recognizable yellow characters, highly detailed","anime, manga, Disney, Pixar, black and white"
+Style: Family Guy,"Family Guy {prompt} . Animation, adult humor, satirical themes, cartoonish designs, highly detailed","anime, manga, Disney, Pixar, black and white"
+Style: Bob's Burgers,"Bob's Burgers {prompt} . Animation, family themes, humor, quirky characters, highly detailed","anime, manga, Disney, Pixar, black and white"
+Style: Gravity Falls,"Gravity Falls {prompt} . Cartoon, mystery, fantasy themes, unique character designs, highly detailed","anime, manga, Disney, Pixar, black and white"
+Style: Steven Universe,"Steven Universe {prompt} . Cartoon, LGBTQ+ themes, fantasy, vibrant colors, unique character designs, highly detailed","anime, manga, Disney, Pixar, black and white"
+Style: One Piece,"One Piece {prompt} . Manga, adventure, pirates, dynamic battles, unique character designs, highly detailed","cartoon, realism, Disney, Pixar, black and white"
+Style: Attack on Titan,"Attack on Titan {prompt} . Anime, dystopian, giants, dynamic battles, highly detailed","cartoon, realism, Disney, Pixar, black and white"
+Style: My Hero Academia,"My Hero Academia {prompt} . Anime, superhero, high school, dynamic battles, unique character designs, highly detailed","cartoon, realism, Disney, Pixar, black and white"
+Style: Naruto,"Naruto {prompt} . Anime, ninjas, coming-of-age, dynamic battles, unique character designs, highly detailed","cartoon, realism, Disney, Pixar, black and white"
+Style: Dragon Ball Z,"Dragon Ball Z {prompt} . Anime, martial arts, aliens, dynamic battles, unique character designs, highly detailed","cartoon, realism, Disney, Pixar, black and white"
+Style: Sailor Moon,"Sailor Moon {prompt} . Anime, magical girls, romance, unique character designs, highly detailed","cartoon, realism, Disney, Pixar, black and white"
+Style: Cowboy Bebop,"Cowboy Bebop {prompt} . Anime, space western, bounty hunters, noir themes, highly detailed","cartoon, realism, Disney, Pixar, black and white"
+>>>>>> GPT Famous Artists
+Style: Van Gogh, "Van Gogh style {prompt} . Expressive, impasto, swirling brushwork, vibrant," "realistic, photorealistic, calm, straight lines"
+Style: Warhol, "Warhol style {prompt} . Pop art, bold colors, mass production, repetitive," "subdued colors, traditional, unique, serious"
+Style: Picasso, "Picasso style {prompt} . Cubist, geometric, abstract, innovative," "realistic, detailed, smooth, fluid, single perspective"
+Style: Da Vinci, "Da Vinci style {prompt} . Realistic, sfumato, detailed, chiaroscuro," "abstract, vibrant colors, bold, loose brushwork"
+Style: Monet, "Monet style {prompt} . Impressionist, light-filled, loose brushwork, en plein air," "defined, detailed, subdued, studio work"
+Style: Dali, "Dali style {prompt} . Surrealist, dreamlike, bizarre, symbolic," "realistic, ordinary, rational, clear, obvious"
+Style: Pollock, "Pollock style {prompt} . Abstract expressionist, gestural, dripping, layered," "sharp, precise, realistic, calm"
+Style: Rothko, "Rothko style {prompt} . Color field, abstract, simple, large-scale," "detailed, small, complex, figurative"
+Style: Matisse, "Matisse style {prompt} . Fauvist, bold colors, loose, decorative," "realistic, subdued colors, detailed, serious"
+Style: Banksy, "Banksy style {prompt} . Street art, satirical, stenciled, urban," "classic, traditional, indoor, realism"
+Style: Michelangelo, "Michelinagelo style {prompt} . High Renaissance, sculptural, detailed, humanistic," "abstract, loose, simplistic, impersonal"
+Style: Kusama, "Kusama style {prompt} . Pop Art, abstract, polka dots, immersive," "plain, monotone, realistic, sparse"
+Style: Hokusai, "Hokusai style {prompt} . Ukiyo-e, woodblock print, detailed, narrative," "abstract, free-form, modern, minimal"
+Style: O'Keeffe, "O'Keeffe style {prompt} . Modernist, floral, bold, abstract," "small scale, detailed, muted colors, complex"
+Style: Cézanne, "Cézanne style {prompt} . Post-impressionist, geometric, detailed, brushstrokes," "smooth, flat, loose, fluid"
+Style: Hopper, "Hopper style {prompt} . Realistic, light and shadow, loneliness, American urban," "busy, crowded, vibrant, abstract"
+Style: Klimt, "Klimt style {prompt} . Symbolist, decorative, ornamental, sensual," "simple, bare, abstract, rough"
+Style: Chagall, "Chagall style {prompt} . Surrealist, dreamy, vibrant, narrative," "realistic, dull, serious, minimal"
+Style: Lichtenstein, "Lichtenstein style {prompt} . Pop art, comic strip, bold, ironic," "realistic, traditional, serious, detailed"
+Style: Basquiat, "Basquiat style {prompt} . Neo-expressionist, primitive, graffiti, social commentary," "polished, elegant, subdued, subtle"
+Style: Frida Kahlo, "Frida Kahlo style {prompt} . Symbolic, surrealistic, emotional, vibrant," "realistic, subdued, impersonal, monochromatic"
+Style: Georgia O'Keeffe, "Georgia O'Keeffe style {prompt} . Modernist, abstract, large scale, organic," "small, detailed, geometric, muted colors"
+Style: Jackson Pollock, "Jackson Pollock style {prompt} . Abstract expressionist, action painting, drip technique, energetic," "controlled, figurative, calm, small scale"
+Style: Rembrandt, "Rembrandt style {prompt} . Baroque, chiaroscuro, realistic, emotional," "flat lighting, abstract, impersonal, clean"
+Style: Renoir, "Renoir style {prompt} . Impressionist, vibrant, lively, warm," "dull, calm, detailed, cool colors"
+Style: Magritte, "Magritte style {prompt} . Surrealist, thought-provoking, mysterious, realistic," "abstract, obvious, open, unrefined"
+Style: Manet, "Manet style {prompt} . Realistic, impressionistic, bold, contemporary," "abstract, traditional, timid, historical"
+Style: Vermeer, "Vermeer style {prompt} . Baroque, detailed, light, tranquil," "abstract, rough, dark, chaotic"
+Style: Caravaggio, "Caravaggio style {prompt} . Baroque, chiaroscuro, dramatic, realistic," "soft lighting, calm, abstract, idealized"
+Style: Rodin, "Rodin style {prompt} . Realistic, expressive, textured, bronze," "smooth, emotionless, polished, painted"
+Style: Botticelli, "Botticelli style {prompt} . Early Renaissance, allegorical, graceful, detailed," "abstract, harsh, simplified, rough"
+Style: Edward Hopper, "Edward Hopper style {prompt} . Realistic, isolation, architectural, strong contrast," "crowded, organic, soft lighting, abstract"
+Style: Keith Haring, "Keith Haring style {prompt} . Pop art, bold lines, vibrant colors, social messages," "subtle, realistic, muted colors, personal"
+Style: Damien Hirst, "Damien Hirst style {prompt} . Contemporary, shocking, conceptual, large scale," "traditional, calming, handcrafted, small scale"
+Style: Yayoi Kusama, "Yayoi Kusama style {prompt} . Contemporary, polka dots, immersive, psychedelic," "traditional, plain, minimalist, calm"
+Style: Francis Bacon, "Francis Bacon style {prompt} . Existential, distorted, unsettling, expressive," "comforting, realistic, calm, subdued"
+Style: Ai Weiwei, "Ai Weiwei style {prompt} . Conceptual, political, traditional Chinese materials, large-scale," "apolitical, contemporary, small-scale, western materials"
+Style: Cindy Sherman, "Cindy Sherman style {prompt} . Conceptual, self-portrait, character study, cinematic," "landscape, group portraits, candid, documentary"
+Style: Frank Stella, "Frank Stella style {prompt} . Minimalist, geometric, large scale, non-representational," "maximalist, organic, small scale, representational"
+Style: Lucian Freud, "Lucian Freud style {prompt} . Realistic, impasto, psychological, intimate," "abstract, smooth, impersonal, public"
+Style: Marc Chagall, "Marc Chagall style {prompt} . Dreamlike, vibrant, symbolic, folklore-inspired," "realistic, subdued, literal, modern"
+Style: Roy Lichtenstein, "Roy Lichtenstein style {prompt} . Pop art, comic strip influence, bold outlines, primary colors," "abstract, realistic, pastel colors, complex"
+Style: Thomas Kinkade, "Thomas Kinkade style {prompt} . Romantic, idealized, warm light, detailed," "abstract, harsh, cool light, minimalist"
+Style: Joan Miró, "Joan Miró style {prompt} . Surrealist, abstract, biomorphic forms, primary colors," "realistic, figurative, complex, muted colors"
+Style: Gerhard Richter, "Gerhard Richter style {prompt} . Abstract, textured, layered, scraped," "realistic, smooth, single-layer, detailed"
+Style: Wassily Kandinsky, "Wassily Kandinsky style {prompt} . Abstract, geometric, vibrant, musical," "realistic, organic, muted, silent"
+Style: Norman Rockwell, "Norman Rockwell style {prompt} . Realistic, narrative, Americana, detailed," "abstract, non-narrative, foreign, minimalist"
+Style: Bridget Riley, "Bridget Riley style {prompt} . Op art, geometric, black and white, optical illusion," "organic, color, realistic, straightforward"
+Style: Piet Mondrian, "Piet Mondrian style {prompt} . De Stijl, geometric, primary colors, black grid," "organic, multiple colors, no grid, curved lines"
+Style: Salvador Dalí, "Salvador Dalí style {prompt} . Surrealist, dreamlike, symbolic, detailed," "realistic, ordinary, literal, sketchy"
+Style: Mary Cassatt, "Mary Cassatt style {prompt} . Impressionist, domestic life, soft colors, loose brushwork," "abstract, public life, vibrant colors, precise"
+Style: Diego Rivera, "Diego Rivera style {prompt} . Muralist, social realist, Mexican culture, narrative," "miniature, abstract, foreign, non-narrative"
+Style: Jean-Michel Basquiat, "Jean-Michel Basquiat style {prompt} . Neo-expressionist, graffiti influence, raw, socially critical," "classical, polished, refined, apolitical"
+Style: Henry Moore, "Henry Moore style {prompt} . Abstract, organic, bronze, monumental," "realistic, geometric, miniature, pastel"
+Style: Frida Kahlo, "Frida Kahlo style {prompt} . Surrealist, symbolic, vibrant, autobiographical," "realistic, abstract, dull, impersonal"
+Style: Grant Wood, "Grant Wood style {prompt} . Regionalist, rural, detailed, Americana," "urban, abstract, vague, non-American"
+Style: Edward Hopper, "Edward Hopper style {prompt} . Realistic, isolation, strong light, urban," "impressionistic, crowded, soft light, rural"
+Style: Andy Goldsworthy, "Andy Goldsworthy style {prompt} . Environmental art, natural materials, temporary, site-specific," "urban art, man-made materials, permanent, unspecific site"
+Style: Louise Bourgeois, "Louise Bourgeois style {prompt} . Abstract, psychological, large-scale, organic," "realistic, impersonal, small-scale, geometric"
+Style: Ansel Adams, "Ansel Adams style {prompt} . Black and white, nature, high contrast, detailed," "color, urban, low contrast, vague"
+Style: Yoko Ono, "Yoko Ono style {prompt} . Conceptual, minimalist, performance, participatory," "decorative, maximalist, static, non-interactive"
+Style: Gustav Klimt, "Gustav Klimt style {prompt} . Symbolist, decorative, golden, intricate," "realistic, functional, monochrome, simplified"
+Style: Jeff Koons, "Jeff Koons style {prompt} . Contemporary, kitsch, glossy, large-scale," "traditional, serious, matte, small-scale"
+Style: John Singer Sargent, "John Singer Sargent style {prompt} . Realistic, elegant, portrait, expressive," "abstract, casual, landscape, subdued"
+Style: Marcel Duchamp, "Marcel Duchamp style {prompt} . Dada, readymade, conceptual, controversial," "traditional, handmade, decorative, safe"
+Style: Claude Monet, "Claude Monet style {prompt} . Impressionist, outdoor, light, loose brushwork," "neoclassical, indoor, dark, tight brushwork"
+Style: Anish Kapoor, "Anish Kapoor style {prompt} . Abstract, large-scale, reflective, curved," "figurative, small-scale, matte, straight lines"
+Style: Hieronymus Bosch, "Hieronymus Bosch style {prompt} . Surrealist, detailed, religious, narrative," "realistic, abstract, secular, non-narrative"
+Style: Paul Gauguin, "Paul Gauguin style {prompt} . Post-Impressionist, exotic, bold colors, flat," "Impressionist, familiar, muted colors, volumetric"
+Style: Katsushika Hokusai, "Katsushika Hokusai style {prompt} . Ukiyo-e, nature, woodblock print, detailed," "western style, urban, oil painting, abstract"
+Style: Pierre-Auguste Renoir, "Pierre-Auguste Renoir style {prompt} . Impressionist, joyful, light, loose brushwork," "neoclassical, somber, dark, tight brushwork"
+Style: Antony Gormley, "Antony Gormley style {prompt} . Sculpture, human form, rusted, site-specific," "painting, abstract, polished, gallery-based"
+Style: Kazimir Malevich, "Kazimir Malevich style {prompt} . Suprematist, abstract, geometric, minimal," "realistic, organic, decorative, complex"
+Style: Jean-Antoine Watteau, "Jean-Antoine Watteau style {prompt} . Rococo, outdoor, elegant, lively," "Baroque, indoor, serious, static"
+Style: Constantin Brâncuși, "Constantin Brâncuși style {prompt} . Modernist, abstract, bronze, streamlined," "traditional, figurative, wood, complex"
+Style: Egon Schiele, "Egon Schiele style {prompt} . Expressionist, figure, distorted, emotional," "Impressionist, landscape, proportional, detached"
+Style: Nam June Paik, "Nam June Paik style {prompt} . Video art, technological, interactive, large-scale," "painting, traditional, static, small-scale"
+Style: James Whistler, "James Whistler style {prompt} . Tonalism, atmospheric, subdued, abstract," "Fauvism, vibrant, bold, detailed"
+Style: Wassily Kandinsky, "Wassily Kandinsky style {prompt} . Abstract, musical, geometric, vibrant," "realistic, silent, organic, subdued"
+Style: Lucio Fontana, "Lucio Fontana style {prompt} . Spatialism, monochrome, slashed, minimal," "Futurism, colorful, whole, detailed"
+Style: Artemisia Gentileschi, "Artemisia Gentileschi style {prompt} . Baroque, dramatic, biblical, female-centric," "Rococo, calm, mythological, male-centric"
+Style: Jean Dubuffet, "Jean Dubuffet style {prompt} . Art Brut, textured, primal, abstract," "Academic art, smooth, refined, realistic"
+Style: Sandro Botticelli, "Sandro Botticelli style {prompt} . Early Renaissance, mythological, linear, vibrant," "Baroque, historical, painterly, subdued"
+Style: Carl Andre, "Carl Andre style {prompt} . Minimalist, geometric, industrial, ground-level," "Baroque, organic, handcrafted, elevated"
+Style: David Hockney, "David Hockney style {prompt} . Pop art, landscape, vibrant, digital," "Abstract Expressionism, figure, subdued, traditional"
+Style: Cindy Sherman, "Cindy Sherman style {prompt} . Conceptual, self-portrait, character study, cinematic," "landscape, group portraits, candid, documentary"
+Style: Jenny Holzer, "Jenny Holzer style {prompt} . Conceptual, text-based, public, LED," "painting, image-based, private, canvas"
+Style: Dante Gabriel Rossetti, "Dante Gabriel Rossetti style {prompt} . Pre-Raphaelite, medieval, literary, romantic," "Futurist, modern, abstract, stark"
+Style: Zaha Hadid, "Zaha Hadid style {prompt} . Modernist, organic, futuristic, curved," "Classical, geometric, traditional, straight lines"
+Style: Takashi Murakami, "Takashi Murakami style {prompt} . Superflat, pop culture, colorful, cartoonish," "Cubist, high culture, monochrome, realistic"
+Style: Edward Weston, "Edward Weston style {prompt} . Photography, black and white, still life, detailed," "Painting, color, action, abstract"
+Style: Edvard Munch, "Edvard Munch style {prompt} . Expressionist, psychological, bold colors, distorted," "Impressionist, physical, muted colors, proportional"
+Style: Ai Weiwei, "Ai Weiwei style {prompt} . Contemporary, political, traditional Chinese materials, large-scale," "Classical, apolitical, modern materials, small-scale"
+Style: Georges Braque, "Georges Braque style {prompt} . Cubist, abstract, collage, muted colors," "Romantic, realistic, oil painting, vibrant colors"
+Style: Sol LeWitt, "Sol LeWitt style {prompt} . Conceptual, geometric, minimal, instructional," "Expressionist, organic, complex, spontaneous"
+Style: Mary Cassatt, "Mary Cassatt style {prompt} . Impressionist, domestic, pastel, feminine," "Realist, urban, oil, masculine"
+Style: Damien Hirst, "Damien Hirst style {prompt} . Contemporary, controversial, installation, medical," "Classical, traditional, canvas, floral"
+Style: Giuseppe Arcimboldo, "Giuseppe Arcimboldo style {prompt} . Mannerist, portrait, food, symbolic," "Cubist, landscape, abstract, literal"
+Style: Yves Klein, "Yves Klein style {prompt} . Nouveau réalisme, monochrome, blue, performance," "Pop Art, colorful, red, static"
+Style: Frida Kahlo, "Frida Kahlo style {prompt} . Surrealist, autobiographical, vibrant, symbolic," "Realist, historical, muted, literal"
+Style: Piet Mondrian, "Piet Mondrian style {prompt} . De Stijl, geometric, primary colors, balanced," "Surrealist, organic, pastel colors, chaotic"
+Style: Bridget Riley, "Bridget Riley style {prompt} . Op Art, geometric, black and white, optical," "Impressionist, organic, colorful, static"
+Style: Mark Rothko, "Mark Rothko style {prompt} . Abstract Expressionist, color field, large-scale, emotional," "Pop Art, pattern, small-scale, detached"
+Style: Joseph Beuys, "Joseph Beuys style {prompt} . Fluxus, performance, social sculpture, felt," "Minimalism, painting, object, metal"
+Style: Berthe Morisot, "Berthe Morisot style {prompt} . Impressionist, feminine, domestic, light," "Surrealist, masculine, public, dark"
+Style: Agnes Martin, "Agnes Martin style {prompt} . Minimalist, geometric, grid, subtle," "Baroque, organic, floral, bold"
+Style: Yayoi Kusama, "Yayoi Kusama style {prompt} . Contemporary, polka dots, infinity rooms, red," "Classical, plain, single room, blue"
+Style: Andy Goldsworthy, "Andy Goldsworthy style {prompt} . Environmental, temporary, nature, outdoors," "Industrial, permanent, man-made, indoors"
+Style: Henri Cartier-Bresson, "Henri Cartier-Bresson style {prompt} . Photography, decisive moment, black and white, candid," "Painting, posed, color, staged"
+Style: Marina Abramović, "Marina Abramović style {prompt} . Performance, endurance, audience participation, minimal," "Sculpture, instant, observer, complex"
+Style: Man Ray, "Man Ray style {prompt} . Dada, photography, rayograph, experimental," "Realism, painting, traditional, conventional"
+Style: Käthe Kollwitz, "Käthe Kollwitz style {prompt} . Expressionist, social realism, black and white, human suffering," "Impressionist, aestheticism, color, human joy"
+Style: Robert Rauschenberg, "Robert Rauschenberg style {prompt} . Neo-Dada, combine, mixed-media, assemblage," "Minimalism, singular material, oil painting, separated"
+Style: Lyonel Feininger, "Lyonel Feininger style {prompt} . Expressionist, Cubist, architecture, transparent," "Impressionist, organic, landscape, opaque"
+Style: Tracey Emin, "Tracey Emin style {prompt} . YBA, confessional, neon, textile," "Old Masters, universal, oil, marble"
+Style: René Magritte, "René Magritte style {prompt} . Surrealist, object, juxtaposition, mystery," "Realist, figure, relation, clarity"
+Style: Henry Moore, "Henry Moore style {prompt} . Modernist, sculpture, organic, monumental," "Classical, painting, geometric, small"
+Style: Rachel Whiteread, "Rachel Whiteread style {prompt} . Contemporary, sculpture, negative space, cast," "Traditional, drawing, positive space, sketch"
+Style: Tomma Abts, "Tomma Abts style {prompt} . Abstract, geometric, small-scale, acrylic and oil," "Figurative, organic, large-scale, watercolor"
+Style: Max Ernst, "Max Ernst style {prompt} . Surrealist, collage, frottage, dreamlike," "Realist, oil painting, brushwork, day-to-day"
+Style: Richard Serra, "Richard Serra style {prompt} . Minimalist, sculpture, corten steel, site-specific," "Baroque, painting, canvas, gallery-specific"
+Style: Ernst Ludwig Kirchner, "Ernst Ludwig Kirchner style {prompt} . Expressionist, urban, woodcut, vibrant," "Impressionist, rural, oil painting, subdued"
+Style: Eva Hesse, "Eva Hesse style {prompt} . Postminimalist, sculpture, organic, fiberglass," "Minimalist, painting, geometric, canvas"
+Style: Paul Cézanne, "Paul Cézanne style {prompt} . Post-Impressionist, still life, geometric, brushwork," "Impressionist, action, organic, smooth"
+Style: Francis Bacon, "Francis Bacon style {prompt} . Expressionist, distorted, triptych, anguish," "Classical, proportional, single panel, contentment"
+Style: Louise Bourgeois, "Louise Bourgeois style {prompt} . Contemporary, sculpture, feminist, fabric," "Classical, painting, patriarchal, oil"
+Style: Chuck Close, "Chuck Close style {prompt} . Photorealism, portrait, large-scale, gridded," "Impressionism, landscape, small-scale, loose"
+Style: Thomas Gainsborough, "Thomas Gainsborough style {prompt} . Rococo, landscape, elegant, oil," "Baroque, portrait, casual, pastel"
+Style: Gerhard Richter, "Gerhard Richter style {prompt} . Abstract, squeegee, photo-based, blurred," "Realistic, brushwork, imagination-based, detailed"
+Style: Jean-Michel Basquiat, "Jean-Michel Basquiat style {prompt} . Neo-expressionist, graffiti, crown, vibrant," "Photorealism, calligraphy, mundane, subdued"
+Style: Alexander Calder, "Alexander Calder style {prompt} . Kinetic, mobile, primary colors, balanced," "Static, statue, pastel colors, unbalanced"
+Style: Jackson Pollock, "Jackson Pollock style {prompt} . Abstract Expressionist, drip, large-scale, spontaneous," "Cubist, precise, small-scale, planned"
+Style: Anselm Kiefer, "Anselm Kiefer style {prompt} . Neo-expressionist, monumental, textured, historical," "Minimalist, small-scale, smooth, futuristic"
+Style: Amedeo Modigliani, "Amedeo Modigliani style {prompt} . Modernist, portrait, elongated, nude," "Cubist, landscape, proportional, clothed"
+Style: Gilbert & George, "Gilbert & George style {prompt} . Contemporary, photographic, duo, confrontational," "Traditional, painted, individual, pleasant"
+Style: El Greco, "El Greco style {prompt} . Mannerist, religious, elongated, dramatic," "Renaissance, secular, proportional, calm"
+Style: Salvador Dalí, "Salvador Dalí style {prompt} . Surrealist, dreamlike, precise, melting," "Realist, day-to-day, loose, solid"
+Style: Rembrandt van Rijn, "Rembrandt van Rijn style {prompt} . Baroque, self-portrait, chiaroscuro, etching," "Rococo, group portrait, bright, oil painting"
+Style: Keith Haring, "Keith Haring style {prompt} . Pop art, street art, bold lines, active figures," "Impressionism, studio art, fine brushwork, passive landscape"
+Style: Georgia O'Keeffe, "Georgia O'Keeffe style {prompt} . Modernist, flowers, close-up, sensual," "Cubist, objects, far-off, detached"
+Style: Caravaggio, "Caravaggio style {prompt} . Baroque, tenebrism, dramatic, religious," "Renaissance, bright, calm, secular"
+Style: Louise Nevelson, "Louise Nevelson style {prompt} . Abstract expressionist, sculpture, monochrome, found objects," "Realist, painting, colorful, new materials"
+Style: James Turrell, "James Turrell style {prompt} . Land art, light, immersive, perceptual," "Street art, dark, observational, intellectual"
+Style: Édouard Manet, "Édouard Manet style {prompt} . Realist, modern life, loose brushwork, controversial," "Romantic, history, fine brushwork, conventional"
+Style: Marc Chagall, "Marc Chagall style {prompt} . Surrealist, dreamlike, colorful, narrative," "Realist, day-to-day, monochrome, non-narrative"
+Style: Dan Flavin, "Dan Flavin style {prompt} . Minimalist, light, fluorescent, site-specific," "Baroque, dark, oil, gallery-specific"
+Style: Sarah Lucas, "Sarah Lucas style {prompt} . YBA, feminist, readymade, provocative," "Old Masters, masculine, handmade, conservative"
+Style: Johannes Vermeer, "Johannes Vermeer style {prompt} . Baroque, domestic, light, detailed," "Cubist, public, dark, abstract"
+Style: Tadao Ando, "Tadao Ando style {prompt} . Minimalist, concrete, light, water," "Baroque, brick, dark, dry"
+Style: Roy Lichtenstein, "Roy Lichtenstein style {prompt} . Pop art, comic strip, benday dots, primary colors," "Abstract expressionism, serious subject, brushwork, secondary colors"
+Style: Joseph Cornell, "Joseph Cornell style {prompt} . Surrealist, box, found objects, nostalgic," "Minimalist, open space, new materials, contemporary"
+Style: Gustave Courbet, "Gustave Courbet style {prompt} . Realist, rural life, coarse brushwork, controversial," "Neoclassical, noble life, fine brushwork, conventional"
+Style: Richard Long, "Richard Long style {prompt} . Land art, circle, natural materials, ephemeral," "Street art, square, synthetic materials, permanent"
+Style: Otto Dix, "Otto Dix style {prompt} . New Objectivity, war, grotesque, social critique," "Impressionism, peace, beautiful, aesthetic enjoyment"
+Style: Barnett Newman, "Barnett Newman style {prompt} . Abstract expressionism, zip, large-scale, color field," "Pop art, pattern, small-scale, comic strip"
+Style: Sophie Calle, "Sophie Calle style {prompt} . Conceptual, photography, text, personal," "Abstract, painting, brushwork, universal"
+Style: KAWS, "KAWS style {prompt} . Pop art, vinyl toy, X eyes, cartoonish," "Conceptual, bronze statue, normal eyes, realistic"
+Style: Francis Picabia, "Francis Picabia style {prompt} . Dada, machine, painting, provocative," "Impressionism, nature, sketch, pleasant"
+Style: H.R. Giger, "H.R. Giger style {prompt} . Surrealist, biomechanical, airbrush, dark," "Impressionist, human, brush, light"
+Style: Jean Arp, "Jean Arp style {prompt} . Dada, abstract, biomorphic, sculpture," "Realism, figurative, geometric, painting"
+Style: Ai Weiwei, "Ai Weiwei style {prompt} . Contemporary, political, installation, ceramics," "Renaissance, neutral, oil painting, metals"
+Style: Fernand Léger, "Fernand Léger style {prompt} . Cubist, mechanical, mural, bold colors," "Surrealist, organic, small-scale, muted colors"
+Style: Yoko Ono, "Yoko Ono style {prompt} . Conceptual, performance, instruction, peace," "Realist, still life, detailed, war"
+Style: Cindy Sherman, "Cindy Sherman style {prompt} . Contemporary, self-portrait, photography, identity," "Traditional, landscape, painting, anonymity"
+Style: Nam June Paik, "Nam June Paik style {prompt} . Video art, television, interactive, futuristic," "Traditional art, canvas, passive, historical"
+Style: Barbara Kruger, "Barbara Kruger style {prompt} . Conceptual, text, black and white, feminist," "Impressionist, image, color, patriarchal"
+Style: Piero della Francesca, "Piero della Francesca style {prompt} . Renaissance, fresco, mathematical, religious," "Contemporary, installation, random, secular"
+Style: Georgia O'Keeffe, "Georgia O'Keeffe style {prompt} . Modernist, flowers, close-up, sensual," "Cubist, objects, far-off, detached"
+Style: Richard Hamilton, "Richard Hamilton style {prompt} . Pop Art, collage, consumer culture, mixed media," "Impressionism, oil painting, rural life, single medium"
+Style: Kazimir Malevich, "Kazimir Malevich style {prompt} . Suprematism, abstract, geometric, minimal," "Realism, figurative, detailed, maximal"
+Style: Grayson Perry, "Grayson Perry style {prompt} . Contemporary, ceramics, tapestry, narrative," "Old Masters, oil painting, canvas, non-narrative"
+Style: Faith Ringgold, "Faith Ringgold style {prompt} . Contemporary, quilt, narrative, feminist," "Abstract, sculpture, non-narrative, masculine"
+Style: Banksy, "Banksy style {prompt} . Street Art, stencil, satirical, black and white," "Studio Art, oil painting, serious, color"
+Style: Tracey Emin, "Tracey Emin style {prompt} . YBA, confessional, neon, textile," "Old Masters, universal, oil, marble"
+Style: Olafur Eliasson, "Olafur Eliasson style {prompt} . Installation, light, environment, perceptual," "Painting, dark, indoors, cognitive"
+Style: Kiki Smith, "Kiki Smith style {prompt} . Feminist, body, sculpture, mythological," "Patriarchal, landscape, painting, historical"
+Style: David Hockney, "David Hockney style {prompt} . Pop Art, vibrant colors, collage, landscapes," "Abstract Expressionism, muted colors, single panel, figures"
+Style: Chris Ofili, "Chris Ofili style {prompt} . YBA, mixed-media, elephant dung, decorative," "Minimalism, single-media, clean, austere"
+Style: Ellsworth Kelly, "Ellsworth Kelly style {prompt} . Hard-edge painting, color field, minimalist, geometric," "Impressionism, detailed, ornate, organic" 
+Style: Christo and Jeanne-Claude, "Christo and Jeanne-Claude style {prompt} . Installation, environmental, fabric, temporal," "Still Life, indoor, metal, permanent"
+Style: Wayne Thiebaud, "Wayne Thiebaud style {prompt} . Pop Art, still life, pastel, thick paint," "Cubism, dynamic scenes, vibrant, thin paint"
+Style: Jenny Holzer, "Jenny Holzer style {prompt} . Conceptual, text, LED, public spaces," "Realism, image, oil painting, private spaces"
+Style: Antony Gormley, "Antony Gormley style {prompt} . Sculpture, human form, rusted metal, public art," "Painting, abstract, bright colors, gallery art"
+Style: Maurice Sendak, "Maurice Sendak style {prompt} . Children's illustration, fantasy, detailed, narrative," "Abstract, adult, minimalist, non-narrative"
+>>>>>> Advanced GPT Photography
+Portrait Photography Style: Charismatic,"{prompt} with charisma. 50mm lens, f/2.8, focused on eyes, natural lighting","overexposed, underexposed, blurry, distorted, overprocessed"
+Portrait Photography Style: Cinematic,"cinematic portrait of {prompt}. 85mm lens, f/1.8, dramatic side lighting, moody atmosphere","overblown highlights, noisy, grainy, oversaturated, wide-angle distortion"
+Portrait Photography Style: Environmental,"environmental portrait of {prompt}. 35mm lens, f/4, wider context, natural surroundings","cluttered background, poor lighting, overexposed, underexposed, unsharp"
+Photojournalism Style: Reportage,"gripping reportage of {prompt}. Wide-angle lens, f/8, focus on action, capture the moment","blurred action, low light noise, unsteady shot, out of focus, distorted perspective"
+Photojournalism Style: Candid,"candid shot of {prompt}. 50mm lens, f/2.8, spontaneous, unposed","poor lighting, motion blur, out of focus, distracting background, overprocessed"
+Photojournalism Style: Documentary,"documentary style of {prompt}. 35mm lens, f/5.6, truthful representation, neutral perspective","overexposed, underexposed, oversaturated, motion blur, unsteady shot"
+Fashion Photography Style: Haute Couture,"haute couture display of {prompt}. 85mm lens, f/2.2, vibrant colors, dramatic lighting","flat lighting, out of focus, distracting background, overprocessed, oversaturated"
+Fashion Photography Style: Editorial,"editorial fashion shot of {prompt}. 50mm lens, f/2.5, storytelling, focused on outfit","unflattering pose, poor lighting, blurry, distracting elements, overexposed"
+Fashion Photography Style: Catalog,"catalog shot of {prompt}. 70mm lens, f/5.6, neutral background, clear focus on attire","poor lighting, unflattering angles, distorted perspective, underexposed, oversaturated"
+Sports Photography Style: Action-packed,"action-packed shot of {prompt}. 200mm lens, f/2.8, high shutter speed, capture the peak moment","motion blur, underexposed, out of focus, distracting background, unsteady shot"
+Sports Photography Style: Emotional,"emotional moment in {prompt}. 135mm lens, f/4, capture expressions, ambient lighting","poor focus, high ISO noise, unsteady shot, underexposed, distorted colors"
+Sports Photography Style: Narrative,"narrative image of {prompt}. 50mm lens, f/3.5, storytelling, context setting","unfocused, poor lighting, cluttered composition, overexposed, distorted perspective"
+Still Life Photography Style: Minimalistic,"minimalistic composition of {prompt}. 50mm lens, f/5.6, simplistic design, neutral colors","cluttered, oversaturated, unbalanced composition, poor lighting, overexposed"
+Still Life Photography Style: Dramatic,"dramatic still life of {prompt}. 85mm lens, f/2.2, dramatic lighting, intense colors","flat lighting, blurry, underexposed, distracting elements, oversaturated"
+Still Life Photography Style: Rustic,"rustic presentation of {prompt}. 35mm lens, f/4, natural elements, warm tones","poor focus, overexposed, cluttered, cold colors, unbalanced composition"
+Editorial Photography Style: Investigative,"investigative shot of {prompt}. 24mm lens, f/4, informative, intriguing","blurry, underexposed, distorted perspective, high ISO noise, distracting elements"
+Editorial Photography Style: Lifestyle,"lifestyle capture of {prompt}. 50mm lens, f/2.8, candid, vibrant colors","poor lighting, overprocessed, distracting background, motion blur, unsteady shot"
+Editorial Photography Style: Opinion,"opinion image of {prompt}. 35mm lens, f/5.6, emotive, storytelling","poor focus, underexposed, cluttered composition, overexposed highlights, distorted colors"
+Architectural Photography Style: Historical,"historical capture of {prompt}. 24mm lens, f/8, capture architectural details, natural lighting","distorted perspective, underexposed, overprocessed, unsharp, oversaturated"
+Architectural Photography Style: Modernist,"modernist view of {prompt}. 18mm lens, f/4, minimalistic, strong lines","barrel distortion, overexposed, blurry, poor composition, flat colors"
+Architectural Photography Style: Surreal,"surreal perspective of {prompt}. Fisheye lens, f/2.8, abstract interpretation, vibrant colors","unfocused, poor lighting, underexposed, overprocessed, distracting elements"
+>>>>>> GPT Painting Styles
+Style: Steampunk,"steampunk-inspired {prompt} . gears, brass, rivets, old-world technology, intricate, highly detailed, Victorian,"ugly, deformed, noisy, blurry, minimalistic, sleek"
+Style: Futuristic,"futuristic interpretation of {prompt} . sleek, high-tech, metallic, smooth surfaces, neon, sharp edges, crystal clear, professional, ultra detailed,"ugly, deformed, noisy, blurry, rustic, vintage, antique"
+Style: Abstract Expressionism,"Abstract Expressionist style of {prompt} . bold colors, vigorous brushwork, non-representational, spontaneous, expressive, emotional,"boring, monotone, plain, still, unemotional, realistic, photographic"
+Style: Surrealism,"surrealistic {prompt} . dreamlike, subconscious, bizarre, highly detailed, intricate, imaginative, illogical juxtaposition,"clear, realistic, boring, typical, straightforward, concrete, photographic"
+Style: Watercolor,"watercolor painting of {prompt} . fluid, soft edges, light colors, translucent, delicate, dreamy,"hard, geometric, precise, opaque, harsh, dark, sharp, digital, pixelated"
+Style: Pointillism,"pointillist technique on {prompt} . tiny dots of color, optical blend, detailed, vibrant, rich,"solid, monochromatic, bland, minimalist, soft, blurry"
+Style: Cubism,"cubist interpretation of {prompt} . geometric forms, multi-perspective, abstract, fragmented, complex,"rounded, realistic, photographic, simple, straightforward, traditional"
+Style: Gothic,"gothic style {prompt} . dark, mysterious, medieval, ornate, intricate, detailed, haunting,"bright, modern, simple, minimalist, cheerful, photorealistic"
+Style: Pop Art,"pop art style {prompt} . bold colors, mass culture, comic style, ironical, vibrant, detailed,"neutral, realistic, serious, dull, monochromatic, photographic"
+Style: Impressionism,"impressionist take on {prompt} . loose brushwork, light color, emphasis on light and movement, emotive, painterly,"tight, photographic, dark, stationary, unemotional, sharp, digital"
+Style: Street Art,"street art version of {prompt} . urban, graffiti, spray paint, vibrant, bold, rough, rebellious,"elegant, refined, traditional, delicate, soft, photorealistic"
+Style: Art Nouveau,"art nouveau style {prompt} . elegant, ornate, flowing lines, detailed, decorative,"simple, modern, sharp, minimalistic, geometric, unadorned"
+Style: Charcoal,"charcoal sketch of {prompt} . dark, grainy, high contrast, loose, dramatic,"light, smooth, precise, colorful, clean, photographic"
+Style: Collage,"collage of {prompt} . mixed media, eclectic, detailed, layered, creative,"uniform, minimalistic, simple, clean, digital, monochromatic"
+Style: Minimalist,"minimalist {prompt} . clean lines, simple shapes, limited color palette, modern, sleek,"detailed, ornate, decorative, colorful, chaotic, complex"
+Style: Graffiti,"graffiti style {prompt} . street art, bold, colorful, vibrant, dynamic, urban, rebellious, intricate,"refined, subtle, soft, elegant, traditional, photorealistic"
+Style: Trompe L'oeil,"trompe l'oeil of {prompt} . hyperrealistic, 3d illusion, detailed, deceptive, intricate,"abstract, flat, simple, symbolic, unrealistic, distorted"
+Style: Fauvism,"fauvist interpretation of {prompt} . wild brushwork, vibrant color, expressive, bold, emotive, painterly,"neutral, precise, calm, realistic, photographic, subdued"
+Style: Hyperrealism,"hyperrealistic {prompt} . photorealistic, extreme detail, lifelike, crisp, precise,"blurry, abstract, loose, impressionistic, simple, symbolic"
+Style: Dada,"dadaist version of {prompt} . anti-art, absurd, random, satirical, mixed media, collage,"traditional, sensible, serious, realistic, photorealistic"
+Style: Calligraphy,"calligraphy style {prompt} . elegant, flowing, precise, detailed, intricate, hand-drawn,"bold, blocky, geometric, rough, digital, simple"
+Style: Baroque,"baroque rendition of {prompt} . opulent, grand, ornate, dramatic, detailed, decorative,"minimalist, modern, simple, clean, unadorned, geometric"
+Style: Op Art,"op art style {prompt} . optical illusion, geometric, vibrant, dynamic, detailed, bold,"soft, organic, loose, subdued, simple, unpatterned"
+Style: Psychedelic,"psychedelic version of {prompt} . vibrant color, distorted visuals, swirling patterns, trippy, detailed, intricate,"neutral, realistic, orderly, simple, clear, photorealistic"
+Style: Scratchboard,"scratchboard technique on {prompt} . contrast, engraved, black and white, detailed, dramatic,"colorful, soft, loose, blended, photorealistic"
+Style: Botanical Illustration,"botanical illustration of {prompt} . detailed, accurate, precise, delicate, naturalistic,"abstract, loose, imprecise, bold, exaggerated, symbolic"
+Style: Lithography,"lithograph of {prompt} . printmaking, smooth, detailed, bold, graphic,"rough, textured, loose, brushy, three dimensional"
+Style: Mosaic,"mosaic of {prompt} . tiled, geometric, vibrant, intricate, decorative,"soft, organic, loose, simple, smooth, unpatterned"
+Style: Woodcut,"woodcut style {prompt} . carved, bold lines, high contrast, rustic, handmade,"smooth, soft, delicate, digital, photorealistic"
+Style: Stencil Art,"stencil art of {prompt} . sharp edges, bold, graphic, street art style, vibrant,"soft, loose, organic, brushy, traditional"
+Style: Rotoscoping,"rotoscoped {prompt} . traced, animation style, smooth, realistic, detailed,"abstract, symbolic, rough, loose, blocky"
+Style: Glass Painting,"glass painting of {prompt} . translucent, vibrant, decorative, intricate, glossy,"matte, dull, loose, rough, opaque"
+Style: Art Deco,"art deco interpretation of {prompt} . geometric, bold, symmetrical, ornate, detailed, decorative,"soft, organic, asymmetrical, minimalist, simple"
+Style: Hard Edge Painting,"hard edge painting of {prompt} . geometric, sharp edges, flat color, modern, bold,"soft, organic, loose, textured, detailed, photorealistic"
+Style: Drybrush,"drybrush technique on {prompt} . rough texture, loose brushwork, subtle detail, expressive, painterly,"smooth, precise, clean, detailed, photorealistic"
+Style: Silhouette,"silhouette of {prompt} . high contrast, dramatic, simple, bold, graphic,"detailed, textured, colorful, light, photorealistic"
+Style: Plein Air,"plein air painting of {prompt} . outdoor, natural light, vibrant, loose, expressive,"studio, artificial, precise, tight, clean, photorealistic"
+Style: Ink Wash,"ink wash painting of {prompt} . monochromatic, loose, fluid, expressive, delicate,"colorful, tight, dry, bold, detailed, photorealistic"
+Style: Body Painting,"body painting of {prompt} . human canvas, vibrant, detailed, transformative, expressive,"traditional canvas, subtle, clean, realistic, monochromatic"
+Style: Spray Paint,"spray paint art of {prompt} . street style, vibrant, spontaneous, bold, rough,"refined, soft, delicate, precise, clean, photorealistic"
+Style: Grisaille,"grisaille painting of {prompt} . monochromatic, detailed, realistic, refined, tonal,"colorful, abstract, loose, impressionistic, simple"
+Style: Stippling,"stippled technique on {prompt} . dotted, texture, detailed, graphic, intricate,"smooth, solid, loose, brushy, blended"
+Style: Pastel,"pastel drawing of {prompt} . soft, colorful, delicate, expressive, textured,"sharp, bold, clean, precise, digital"
+Style: Encaustic,"encaustic painting of {prompt} . wax, textured, layered, luminous, rich,"flat, smooth, simple, clean, dry, photorealistic"
+Style: Macrame,"macrame style {prompt} . knotted, textile, intricate, handmade, decorative,"smooth, flat, hard, precise, digital"
+Style: Graffiti Stencil,"graffiti stencil art of {prompt} . urban, bold, vibrant, street style, graphic,"elegant, refined, soft, traditional, photorealistic"
+Style: Action Painting,"action painting of {prompt} . spontaneous, energetic, abstract, expressive, bold,"precise, slow, realistic, photographic, unemotional"
+Style: Batik,"batik style {prompt} . dyed, vibrant, patterned, textile, decorative,"plain, unpatterned, hard, smooth, clean, digital"
+Style: Folk Art,"folk art depiction of {prompt} . traditional, handmade, decorative, vibrant, detailed,"modern, digital, simple, clean, minimalistic"
+Style: Glitch Art,"glitch art of {prompt} . distorted, digital, vibrant, abstract, modern,"refined, traditional, realistic, photographic, unaltered"
+Style: Chiaroscuro,"chiaroscuro technique on {prompt} . high contrast, dramatic, realistic, refined, tonal,"flat, dull, abstract, impressionistic, simple"
+Style: Gouache,"gouache painting of {prompt} . vibrant, opaque, smooth, rich, detailed,"transparent, loose, rough, dull, photorealistic"
+>>>>>> GPT Instagram Styles
+Style: High-Fashion, "{prompt} in haute couture. Luxury, designer brands, runway-ready, tailored, chic", "casual, sporty, laid-back, street style, loose"
+Style: Casual-Chic, "{prompt} in a casual chic outfit. Comfortable, stylish, modern, accessible", "formal, high fashion, flamboyant, extravagant"
+Style: Streetwear, "{prompt} rocking the streetwear trend. Urban, hip-hop influence, sneakers, caps, oversized", "preppy, conservative, formal, traditional"
+Style: Athletic, "{prompt} in athletic wear. Sporty, gym-ready, functional, sneakers, activewear", "evening wear, formal, business, relaxed"
+Style: Vintage, "{prompt} in a vintage ensemble. Retro, nostalgia, classic styles, second-hand", "modern, futuristic, minimalist, new"
+Style: Bohemian, "{prompt} in boho fashion. Free-spirited, layered, patterns, ethnic-inspired, fringe", "minimalist, structured, monochromatic, sleek"
+Style: Minimalist, "{prompt} sporting minimalist fashion. Simple, clean lines, neutral colors, unfussy", "vintage, boho, flamboyant, colorful"
+Style: Preppy, "{prompt} dressed in preppy style. Collegiate, clean-cut, conservative, layered", "gothic, punk, casual, relaxed"
+Style: Gothic, "{prompt} in a gothic getup. Dark, leather, lace, Victorian influence", "preppy, pastel, boho, bright"
+Style: Punk, "{prompt} with a punk look. Rebellious, grungy, band tees, ripped denim", "preppy, classic, conservative, formal"
+Style: Grunge, "{prompt} sporting a grunge look. '90s influence, flannel, band tees, distressed", "preppy, glamorous, feminine, tailored"
+Style: Glamorous, "{prompt} looking glamorous. Luxury, sequins, fur, red carpet ready", "casual, relaxed, sporty, minimalist"
+Style: Rocker, "{prompt} rocking the rock style. Leather, band tees, edgy, black", "preppy, pastel, boho, cute"
+Style: Hipster, "{prompt} in a hipster outfit. Eclectic, indie, non-mainstream, vintage", "mainstream, sporty, glamorous, preppy"
+Style: Ethical, "{prompt} wearing ethical fashion. Sustainable, fair trade, organic materials, eco-friendly", "fast fashion, synthetic, mass-produced, cheap"
+Style: Business Casual, "{prompt} dressed in business casual. Semi-formal, tailored, smart, professional", "sporty, casual, grunge, punk"
+Style: Beachwear, "{prompt} in beachwear. Bikinis, cover-ups, sandals, straw hats, light fabrics", "winter wear, formal, business, structured"
+Style: Activewear, "{prompt} in stylish activewear. Sporty, comfortable, functional, athleisure", "evening wear, formal, preppy, boho"
+Style: Country, "{prompt} sporting country style. Western, cowboy boots, plaid, denim", "gothic, punk, high fashion, glamorous"
+Style: Military, "{prompt} wearing military-inspired fashion. Camouflage, khaki, structured, badges", "boho, glamorous, preppy, beachwear"
+Style: Kawaii, "{prompt} in Kawaii style. Cute, pastel, girly, anime-inspired, frilly", "gothic, punk, grunge, minimalist"
+Style: Lolita, "{prompt} in a Lolita ensemble. Victorian-inspired, frilly, bows, lace, layered", "minimalist, sporty, casual, business"
+Style: Formal, "{prompt} dressed in formal wear. Black tie, tuxedo, evening gown, polished", "casual, sporty, grunge, beachwear"
+Style: Tomboy, "{prompt} rocking a tomboy look. Androgynous, loose, sneakers, caps", "glamorous, feminine, boho, preppy"
+Style: Normcore, "{prompt} dressed in normcore. Unpretentious, casual, basics, comfortable", "high fashion, glamorous, punk, gothic"
+Style: Artistic, "{prompt} in an artistic outfit. Creative, unique, expressive, handmade", "preppy, conservative, business, traditional"
+Style: Genderless, "{prompt} in genderless fashion. Androgynous, neutral, modern, unisex", "feminine, masculine, glam, preppy"
+Style: Monochromatic, "{prompt} in a monochromatic look. Single color, sleek, modern, minimalist", "colorful, vibrant, patterned, boho"
+Style: Mod, "{prompt} dressed in Mod style. '60s influence, A-line, geometric patterns, bold", "boho, grunge, minimalist, normcore"
+Style: Harajuku, "{prompt} in Harajuku style. Japanese street fashion, eclectic, colorful, anime", "conservative, preppy, minimalist, business"
+Style: Cyberpunk, "{prompt} in a cyberpunk outfit. Futuristic, dystopian, metallic, neon", "vintage, retro, classic, boho"
+Style: Rave, "{prompt} in rave wear. Bright colors, neon, sequins, fur", "business casual, preppy, conservative, minimalist"
+Style: Hippy, "{prompt} in hippy style. '70s influence, tie-dye, bell-bottoms, fringe", "preppy, conservative, formal, modern"
+Style: Skater, "{prompt} rocking skater style. Casual, sneakers, baggy, sporty, laid-back", "formal, glamorous, high fashion, preppy"
+Style: Pin-Up, "{prompt} in a pin-up style. Retro, '50s influence, feminine, curves", "gothic, grunge, sporty, tomboy"
+Style: Nautical, "{prompt} in a nautical outfit. Sailor-inspired, stripes, navy, white, red", "gothic, punk, grunge, boho"
+Style: Futuristic, "{prompt} in futuristic fashion. Metallic, geometric, avant-garde, high-tech", "vintage, classic, traditional, retro"
+Style: Eccentric, "{prompt} in an eccentric ensemble. Unique, quirky, stand-out, individualistic", "traditional, classic, conservative, minimalist"
+Style: Tailored, "{prompt} in a tailored suit. Formal, professional, sleek, well-fitted", "casual, relaxed, oversized, loose"
+Style: Sustainable, "{prompt} in sustainable fashion. Eco-friendly, organic, recycled materials, fair trade", "fast fashion, synthetic, cheap, disposable"
+Style: Traditional, "{prompt} in a traditional outfit. Ethnic, regional, cultural, heritage", "modern, futuristic, western, mainstream"
+Style: Candid, "{prompt} captured in a candid moment. Unposed, natural, spontaneous, real-life situation", "posed, artificial, studio shot, planned"
+Style: Portrait, "portrait shot of {prompt}. Close-up, eyes on camera, clear, sharp", "wide shot, landscape, blurred, candid"
+Style: Lifestyle, "lifestyle photo of {prompt}. Everyday activities, real-life situations, relatable", "fantasy, staged, surreal, unrealistic"
+Style: Editorial, "editorial shot of {prompt}. Fashion-forward, styled, professional, magazine-ready", "casual, candid, unstyled, amateur"
+Style: Glamour, "glamour shot of {prompt}. Beauty focused, make-up, lighting, seductive", "natural, minimal, candid, unglamorous"
+Style: Fitness, "fitness photo of {prompt}. Athletic, workout gear, active, strong", "laid back, casual, non-athletic, inactive"
+Style: Boudoir, "boudoir shot of {prompt}. Intimate, sensual, classy, tasteful", "public, conservative, modest, non-intimate"
+Style: Silhouette, "silhouette photo of {prompt}. Dramatic, backlighting, mysterious, creative", "frontlit, clear, detailed, revealing"
+Style: Maternity, "maternity shot of {prompt}. Pregnancy, baby bump, motherhood, glowing", "non-pregnant, childless, pre-pregnancy, post-pregnancy"
+Style: Black and White, "black and white photo of {prompt}. Monochrome, timeless, artistic, dramatic", "color, vibrant, modern, digital"
+Style: Pin-Up, "pin-up style photo of {prompt}. Retro, feminine, seductive, fun", "modern, conservative, modest, non-vintage"
+Style: Headshot, "headshot of {prompt}. Professional, clear, neutral background, focused", "full body, casual, distracting background, unfocused"
+Style: Full Body, "full body shot of {prompt}. Whole outfit, clear, sharp, balanced", "close up, cropped, blurry, unbalanced"
+Style: High Fashion, "high fashion photo of {prompt}. Designer clothes, dramatic poses, avant-garde", "casual, candid, natural, mainstream fashion"
+Style: Business, "business photo of {prompt}. Professional attire, workplace setting, confident", "casual, relaxed, non-work, insecure"
+Style: Beach, "beach photo of {prompt}. Swimwear, sand, ocean, relaxed", "urban, winter, formal, stressed"
+Style: Lingerie, "lingerie shot of {prompt}. Intimate apparel, sensual, feminine, seductive", "outerwear, modest, masculine, non-sensual"
+Style: Athletic, "athletic shot of {prompt}. Sportswear, action, energy, strength", "leisure, inactive, weak, non-sporty"
+Style: Close-up, "close-up photo of {prompt}. Detailed, intimate, clear, personal", "wide shot, distant, blurry, impersonal"
+Style: Nature, "nature shot with {prompt}. Outdoors, greenery, natural light, fresh", "indoor, city, artificial light, stale"
+Style: Studio, "studio shot of {prompt}. Controlled lighting, plain background, clear", "outdoor, natural light, busy background, unclear"
+Style: Street, "street shot of {prompt}. Urban, casual, candid, trendy", "rural, formal, posed, traditional"
+Style: Dance, "dance photo of {prompt}. Movement, grace, energy, rhythm", "static, clumsy, lethargic, off-beat"
+Style: Vintage, "vintage style photo of {prompt}. Retro, nostalgic, old-fashioned, timeless", "modern, futuristic, trendy, transient"
+Style: Low Light, "low light photo of {prompt}. Ambient, moody, dramatic, shadowy", "bright, cheerful, flat, clear"
+Style: Underwater, "underwater photo of {prompt}. Aquatic, serene, dreamlike, floaty", "land, hectic, realistic, heavy"
+Style: Action, "action shot of {prompt}. Movement, energy, dynamic, intense", "still, calm, static, gentle"
+Style: Fashion, "fashion shot of {prompt}. Trendy outfit, styled, runway-ready, chic", "plain, unstyled, out of style, ordinary"
+Style: Aerial, "aerial shot of {prompt}. Birds-eye view, grand, adventurous, stunning", "ground level, confined, cautious, underwhelming"
+Style: Music, "music-related shot of {prompt}. Playing an instrument, singing, energetic, passionate", "quiet, uninterested, uninvolved, lackluster"
+Style: Abstract, "abstract photo of {prompt}. Artistic, unique, creative, unconventional", "concrete, literal, conventional, uncreative"
+Style: Fine Art, "fine art photo of {prompt}. Conceptual, creative, artistic, aesthetic", "commercial, literal, uncreative, unaesthetic"
+Style: Cityscape, "cityscape shot with {prompt}. Urban, skyline, architectural, dynamic", "rural, landscape, natural, static"
+Style: Landscape, "landscape shot with {prompt}. Scenic, outdoors, grand, beautiful", "indoor, close-up, confined, unattractive"
+Style: Macro, "macro shot of {prompt}. Extremely close-up, detailed, intricate, revealing", "wide shot, undetailed, simple, concealing"
+Style: Golden Hour, "golden hour shot of {prompt}. Warm light, sunset/sunrise, magical, serene", "midday, harsh light, mundane, agitated"
+Style: Blue Hour, "blue hour shot of {prompt}. Cool light, twilight, peaceful, moody", "midday, harsh light, chaotic, flat"
+Style: Night, "night shot of {prompt}. Dark, lit, moody, mysterious", "daytime, bright, cheerful, clear"
+Style: Reflection, "reflection shot of {prompt}. Mirror image, symmetry, creative, thoughtful", "direct, asymmetrical, uncreative, thoughtless"
+Style: Backlit, "backlit photo of {prompt}. Silhouette, dramatic, artistic, shadowy", "frontlit, flat, unartistic, clear"
+Style: Overhead, "overhead shot of {prompt}. Top-down view, unique perspective, revealing", "low angle, ordinary perspective, concealing"

types/shared.d.ts

@@ -0,0 +1,126 @@
+// Some manual types I use to facilitate developing on top of
+// Comfy's Litegraph implementation.
+
+import type {
+  ContextMenuItem,
+  LGraphNode,
+  IWidget,
+  LGraph,
+} from '../../../web/types/litegraph'
+
+export type {
+  ComfyExtension,
+  ComfyObjectInfo,
+  ComfyObjectInfoConfig,
+} from '../../../web/types/comfy'
+
+export type {
+  ContextMenuItem,
+  IWidget,
+  LLink,
+  INodeInputSlot,
+  INodeOutputSlot,
+} from '../../../web/types/litegraph'
+
+export type VectorWidget = IWidget<number[], { default: number[] }>
+export interface NodeData {
+  category: str
+  description: str
+  display_name: str
+  input: NodeInput
+  name: str
+  output: [str]
+  output_is_list: [boolean]
+  output_name: [str]
+  output_node: boolean
+}
+
+export interface ComfyDialog {
+  element: Element
+  close: () => void
+  show: (html: str) => void
+}
+
+export interface ComfySettingsDialog {
+  app: ComfyApp
+  element: Element
+  settingsValues: Record<string, unknown>
+  settingsLookup: Record<string, unknown>
+  load: () => Promise<void>
+  setSettingValueAsync: (id: string, value: unknown) => Promise<void>
+}
+
+export interface ComfyUI {
+  app: ComfyApp
+  dialog: ComfyDialog
+  settings: ComfySettingsDialog
+  autoQueueMode: 'instant' | 'change'
+  batchCount: number
+  lastQueueSize: number
+  graphHasChanged: boolean
+  queue: ComfyList
+  history: ComfyList
+}
+
+/**Very incomplete Comfy App definition*/
+interface ComfyApp {
+  graph: LGraph
+  queueItems: { number: number; batchCount: number }[]
+  processingQueue: boolean
+  ui: ComfyUI
+  extensions: ComfyExtension[]
+  nodeOutputs: Record<string, unknown>
+  nodePreviewImages: Record<string, Image>
+  shiftDown: boolean
+  isImageNode: (node: LGraphNodeExtended) => boolean
+  queuePrompt: (number: number, batchCount: number) => Promise<void>
+  /** Loads workflow data from the specified file*/
+  handleFile: (file: File) => Promise<void>
+}
+
+export type { ComfyApp as App }
+
+export interface LGraphNodeExtension {
+  addDOMWidget: (
+    name: string,
+    type: string,
+    element: Element,
+    options: Record<string, unknown>,
+  ) => IWidget
+  onNodeCreated: () => void
+  getExtraMenuOptions: () => ContextMenuItem[]
+  prototype: LGraphNodeExtended
+}
+
+export type LGraphNodeExtended = LGraphNode & LGraphNodeExtension
+
+export interface NodeType /*extends LGraphNode*/ {
+  category: str
+  comfyClass: str
+  length: 0
+  name: str
+  nodeData: NodeData
+  prototype: LGraphNodeExtended
+  title: str
+  type: str
+}
+
+export interface NodeInput {
+  required: object
+}
+
+// NOTE: for prototype overriding
+export type OnDrawWidgetParams = Parameters<IWidget['draw']>
+export type OnDrawForegroundParams = Parameters<LGraphNode['onDrawForeground']>
+export type OnMouseDownParams = Parameters<LGraphNode['onMouseDown']>
+export type OnConnectionsChangeParams = Parameters<
+  LGraphNode['onConnectionsChange']
+>
+export type OnNodeCreatedParams = Parameters<
+  LGraphNodeExtension['onNodeCreated']
+>
+
+export interface DocumentationOptions {
+  icon_size?: number
+  icon_margin?: number
+}

types/typedefs.js

@@ -0,0 +1,18 @@
+/**
+ * @typedef {import("./shared.d.ts").NodeData} NodeData
+ * @typedef {import("./shared.d.ts").NodeType} NodeType
+ * @typedef {import("./shared.d.ts").DocumentationOptions} DocumentationOptions
+ * @typedef {import("./shared.d.ts").OnDrawForegroundParams} OnDrawForegroundParams
+ * @typedef {import("./shared.d.ts").OnMouseDownParams} OnMouseDownParams
+ * @typedef {import("./shared.d.ts").OnConnectionsChangeParams} OnConnectionsChangeParams
+ * @typedef {import("./shared.d.ts").ContextMenuItem} ContextMenuItem
+ * @typedef {import("./shared.d.ts").IWidget} IWidget
+ * @typedef {import("./shared.d.ts").VectorWidget} VectorWidget
+ * @typedef {import("./shared.d.ts").LGraphNodeExtended} LGraphNode
+ * @typedef {import("./shared.d.ts").LLink} LLink
+ * @typedef {import("./shared.d.ts").App} App
+ * @typedef {import("./shared.d.ts").OnDrawWidgetParams} OnDrawWidgetParams
+ * @typedef {import("./shared.d.ts").INodeInputSlot} INodeInputSlot
+ * @typedef {import("./shared.d.ts").INodeOutputSlot} INodeOutputSlot
+ */
+

web/README.md

@@ -0,0 +1,36 @@
+## Core
+These 3 scripts cannot be used independently and must all be present to work, they are mostly enhancing the frontend of python nodes
+- `comfy_shared`: library of methods used in `mtb_widgets` and `debug`
+
+**mtb_widgets** define ui callbacks, and various widgets like the `COLOR` type:  
+<img src="https://github.com/melMass/comfy_mtb/assets/7041726/5dbcb714-e1e2-4be7-b0e2-68a6c38c83de" width=400/>
+
+or the `BOOL` type:  
+<img src="https://github.com/melMass/comfy_mtb/assets/7041726/7601366d-601c-4f4d-b735-1a4b076770b0" width=400/>
+
+There is also `Debug` which is a node that should be able to display any data input, it handle a few cases and fallback to the string representation of the
+data otherwise:
+![debug](https://github.com/melMass/comfy_mtb/assets/7041726/1f4393e4-1c3d-4807-9501-fe8888bfae25)
+
+
+**note +**
+A basic HTML note mainly to add better looking notes/instructions for workflow makers:
+![image](https://github.com/melMass/comfy_mtb/assets/7041726/2ba1f832-0044-4bad-974c-e6387981af57)
+
+
+## Standalone
+These scripts can be taken and placed independently of `comfy_mtb` or any other files, mimicking what pythongosss did for their 
+
+- **imageFeed**: a fork of @pythongosssss ' s [image feed](https://github.com/pythongosssss/ComfyUI-Custom-Scripts/tree/main/js), it adds support for: a lightbox to see images bigger, a way to load the current session history (in case of a web page reload), and different icons, most of the work come from the original script. 
+
+
+> **NOTE**
+> 
+> The original imagefeed got updated since and offer more options, ideally I would clean my lightbox thing and PR it to pythongoss later but in the meantime the script will detect if you already use the original one and not load this fork
+
+
+- ![imagefeed2-hd](https://github.com/melMass/comfy_mtb/assets/7041726/8539f46f-78e1-459a-a11c-fddd44e63ca9)
+
+
+- **notify**: a basic toast notification system that I use in some places accross mtb, it can be used by simply calling `window.MTB.notify("Hello world!")`  
+![extract](https://github.com/melMass/comfy_mtb/assets/7041726/450c67fc-a7e9-4bea-ae49-b610d693098d)

web/color_widget.js

@@ -1,195 +0,0 @@
-// Define the Color Picker widget class
-import parseCss from '/extensions/mtb/extern/parse-css.js'
-import { app } from "/scripts/app.js";
-import { ComfyWidgets } from "/scripts/widgets.js";
-
-export function CUSTOM_INT(node, inputName, val, func, config = {}) {
-	return {
-		widget: node.addWidget(
-			"number",
-			inputName,
-			val,
-			func, 
-			Object.assign({}, { min: 0, max: 4096, step: 640, precision: 0 }, config)
-		),
-	};
-}
-const dumb_call = (v,d,node) => {
-    console.log("dumb_call", {v,d,node});
-}
-function isColorBright (rgb, threshold=240) {
-    const brightess = getBrightness(rgb)
-  
-    return brightess > threshold
-  }
-  
-  function getBrightness (rgbObj) {
-    return Math.round(((parseInt(rgbObj[0]) * 299) + (parseInt(rgbObj[1]) * 587) + (parseInt(rgbObj[2]) * 114)) /1000)
-  }
-  
-
-/**
- * @returns {import("/types/litegraph").IWidget} widget
- */
-const custom = (key,val) => {
-    /** @type {import("/types/litegraph").IWidget} */
-    const widget = {}
-    // widget.y = 0;
-    widget.name = key;
-    widget.type = "COLOR";
-    widget.options = { default: "#ff0000" };
-    widget.value = val || "#ff0000";
-    widget.draw = function (ctx,
-        node,
-        widgetWidth,
-        widgetY,
-        height) {
-        const border = 3;
-        
-        // draw a rect with a border and a fill color
-        ctx.fillStyle = "#000";
-        ctx.fillRect(0, widgetY, widgetWidth, height);
-        ctx.fillStyle = this.value;
-        ctx.fillRect(border, widgetY + border, widgetWidth - border * 2, height - border * 2);
-        // write the input name
-        // choose the fill based on the luminoisty of this.value color
-        const color = parseCss(this.value.default || this.value)
-        if (!color) {
-            return
-        }
-        ctx.fillStyle = isColorBright(color.values, 125) ? "#000" : "#fff";
-
-
-        ctx.font = "14px Arial";
-        ctx.textAlign = "center";
-        ctx.fillText(this.name, widgetWidth * 0.5, widgetY + 14);
-
-
-
-        // ctx.strokeStyle = "#fff";
-        // ctx.strokeRect(border, widgetY + border, widgetWidth - border * 2, height - border * 2);
-        
-        
-        // ctx.fillStyle = "#000";
-        // ctx.fillRect(widgetWidth/2 - border / 2 , widgetY + border / 2 , widgetWidth/2 + border / 2, height + border / 2);
-        // ctx.fillStyle = this.value;
-        // ctx.fillRect(widgetWidth/2, widgetY, widgetWidth/2, height);
-
-    }
-    widget.mouse = function (e, pos, node) {
-        if (e.type === "pointerdown") {
-        console.log({e,pos,node})
-        // get widgets of type type : "COLOR"
-        const widgets = node.widgets.filter(w => w.type === "COLOR");
-
-        for (const w of widgets) {
-            // color picker
-            const rect = [w.last_y, w.last_y + 32];
-            console.log({rect,pos})
-            if (pos[1] > rect[0] && pos[1] < rect[1]) {
-                console.log("color picker", node)
-                const picker = document.createElement("input");
-                picker.type = "color";
-                picker.value = this.value;
-                // picker.style.position = "absolute";
-                // picker.style.left = ( pos[0]) + "px";
-                // picker.style.top = (  pos[1]) + "px";
-                
-                // place at screen center
-                // picker.style.position = "absolute";
-                // picker.style.left = (window.innerWidth / 2) + "px";
-                // picker.style.top = (window.innerHeight / 2) + "px";
-                // picker.style.transform = "translate(-50%, -50%)";
-                // picker.style.zIndex = 1000;
-                
-
-
-                document.body.appendChild(picker);
-                
-                picker.addEventListener("change", () => {
-                    this.value = picker.value;
-                    node.graph._version++;
-                    node.setDirtyCanvas(true, true);
-                    document.body.removeChild(picker);
-                });
-                
-                // simulate click with screen center
-                const pointer_event = new MouseEvent('click', {
-                    bubbles: false,
-                    // cancelable: true,
-                    pointerType: "mouse",
-                    clientX: window.innerWidth / 2,
-                    clientY: window.innerHeight / 2,
-                    x: window.innerWidth / 2,
-                    y: window.innerHeight / 2,
-                    offsetX: window.innerWidth / 2,
-                    offsetY: window.innerHeight / 2,
-                    screenX: window.innerWidth / 2,
-                    screenY: window.innerHeight / 2,
-
-
-                });
-                console.log(e)
-                picker.dispatchEvent(pointer_event);
-            
-            }}}}
-    widget.computeSize = function (width) {
-        return [width, 32];
-    }
-    return widget;
-}
-
-app.registerExtension({
-    name: "mtb.ColorPicker",
-    init: () => {
-        ComfyWidgets.COLOR = function () {
-            return {
-                widget:custom("color", "#ff0000")
-            };
-        };
-    },
-    async beforeRegisterNodeDef(nodeType, nodeData, app) {
-        
-        //console.log("mtb.ColorPicker", { nodeType, nodeData, app });
-        const rinputs = nodeData.input?.required; // object with key/value pairs, "0" is the type
-        // console.log(nodeData.name, { nodeType, nodeData, app });
-
-        if (!rinputs) return;
-
-       
-        let has_color = false;
-        for (const [key, input] of Object.entries(rinputs)) {
-            if (input[0] === "COLOR") {
-                has_color = true;                
-                // input[1] = { default: "#ff0000" };
-            
-            }}
-
-        if (!has_color) return;
-        
-        const onNodeCreated = nodeType.prototype.onNodeCreated;
-        nodeType.prototype.onNodeCreated = function () {
-            const r = onNodeCreated ? onNodeCreated.apply(this, arguments) : undefined;
-            this.serialize_widgets = true;
-        // if (rinputs[0] === "COLOR") {
-        // console.log(nodeData.name, { nodeType, nodeData, app });
-
-        // loop through the inputs to find the color inputs
-         for (const [key, input] of Object.entries(rinputs)) {
-            if (input[0] === "COLOR") {
-                this.addCustomWidget(custom(key,input[1]))
-            }
-        // }
-         }
-
-         this.onRemoved = function () {
-            // When removing this node we need to remove the input from the DOM
-            for (let y in this.widgets) {
-                if (this.widgets[y].canvas) {
-                    this.widgets[y].canvas.remove();
-                }
-            }
-        };
-        }
-    }
-});

web/constant.js

@@ -0,0 +1,496 @@
+import { app } from '../../scripts/app.js'
+import * as shared from './comfy_shared.js'
+import { infoLogger } from './comfy_shared.js'
+import { MtbWidgets } from './mtb_widgets.js'
+import { ComfyWidgets } from '../../scripts/widgets.js'
+import * as mtb_widgets from './mtb_widgets.js'
+
+/**
+ * @typedef {'number'|'string'|'vector2'|'vector3'|'vector4'|'color'} ConstantType
+ * @typedef {import ("../../../web/types/litegraph.d.ts").LGraphNode} Node
+ * @typedef {{x:number,y:number,z?:number,w?:number}} VectorValue
+ * @typedef {}
+ *
+ */
+
+/**
+ * @param {number} size - The number of axis of the vector (2,3 or 4)
+ * @param {number} val - The default scalar value to fill the vector with
+ * @returns {VectorValue} vector
+ * */
+const initVector = (size, val = 0.0) => {
+  const res = {}
+  for (let i = 0; i < size; i++) {
+    const axis = mtb_widgets.VECTOR_AXIS[i]
+    res[axis] = val
+  }
+  return res
+}
+
+/**
+ *
+ * @extends {Node}
+ * @classdesc Wrapper for the python node
+ */
+export class ConstantJs {
+  constructor(python_node) {
+    // this.uuid = shared.makeUUID()
+    const wrapper = this
+
+    python_node.shape = LiteGraph.BOX_SHAPE
+    python_node.serialize_widgets = true
+
+    const onNodeCreated = python_node.prototype.onNodeCreated
+    python_node.prototype.onNodeCreated = function () {
+      const r = onNodeCreated ? onNodeCreated.apply(this) : undefined
+
+      this.addProperty('type', 'number')
+      this.addProperty('value', 0)
+
+      this.removeInput(0)
+      this.removeOutput(0)
+
+      this.addOutput('Output', '*')
+
+      // bind our wrapper
+      this.configure = wrapper.configure.bind(this)
+      // this.applyToGraph = wrapper.applyToGraph.bind(this)
+      this.updateWidgets = wrapper.updateWidgets.bind(this)
+      this.convertValue = wrapper.convertValue.bind(this)
+      // this.updateOutput = wrapper.updateOutput.bind(this)
+      this.updateOutputType = wrapper.updateOutputType.bind(this)
+      // this.updateTargetWidgets = wrapper.updateTargetWidgets.bind(this)
+
+      this.addWidget(
+        'combo',
+        'Type',
+        this.properties.type,
+        (value) => {
+          this.properties.type = value
+          this.updateWidgets()
+          this.updateOutputType()
+        },
+        {
+          values: [
+            // 'number',
+            'float',
+            'int',
+            'string',
+            'vector2',
+            'vector3',
+            'vector4',
+            'color',
+          ],
+        },
+      )
+      this.updateWidgets()
+      this.updateOutputType()
+
+      for (let n = 0; n < this.inputs.length; n++) {
+        this.removeInput(n)
+      }
+      this.inputs = []
+      return r
+    }
+    return
+  }
+
+  // NOTE: this is called onPrompt
+  // applyToGraph() {
+  // infoLogger('Updating values for backend')
+  // this.updateTargetWidgets()
+  // }
+
+  // NOTE: deserialization happens here
+  configure(info) {
+    // super.configure(info)
+    infoLogger('Configure Constant', { info, node: this })
+
+    this.properties.type = info.properties.type
+    this.properties.value = info.properties.value
+
+    this.pos = info.pos
+    this.order = info.order
+
+    this.updateWidgets()
+    this.updateOutputType()
+  }
+
+  /**
+   * Convert the old value type to the new one, falling back to some default
+   * @param {ConstantType} propType - The target type
+   */
+  convertValue(propType) {
+    switch (propType) {
+      case 'color': {
+        if (typeof this.properties.value !== 'string') {
+          this.properties.value = '#ffffff'
+        } else if (this.properties.value[0] !== '#') {
+          this.properties.value = '#ff0000'
+        }
+        break
+      }
+      case 'int': {
+        if (typeof this.properties.value === 'object') {
+          this.properties.value = Number.parseInt(this.properties.value.x)
+        } else {
+          this.properties.value = Number.parseInt(this.properties.value) || 0
+        }
+        break
+      }
+      case 'float': {
+        if (typeof this.properties.value === 'object') {
+          this.properties.value = Number.parseFloat(this.properties.value.x)
+        } else {
+          this.properties.value =
+            Number.parseFloat(this.properties.value) || 0.0
+        }
+        break
+      }
+      case 'string': {
+        if (typeof this.properties.value !== 'string') {
+          this.properties.value = JSON.stringify(this.properties.value)
+        }
+        break
+      }
+      case 'vector2':
+      case 'vector3':
+      case 'vector4': {
+        const numInputs = Number.parseInt(propType.charAt(6))
+        if (!this.properties.value) {
+          this.properties.value = initVector(numInputs) // Array.from({ length: numInputs }, () => 0.0)
+        } else if (typeof this.properties.value === 'string') {
+          try {
+            const parsed = JSON.parse(this.properties.value)
+            const newVec = {}
+            for (
+              let i = 0;
+              i < Object.keys(mtb_widgets.VECTOR_AXIS).length;
+              i++
+            ) {
+              const axis = mtb_widgets.VECTOR_AXIS[i]
+              if (Object.keys(parsed).includes(axis)) {
+                newVec[axis] = parsed[axis]
+              }
+            }
+            this.properties.value = newVec
+          } catch (e) {
+            shared.errorLogger(e)
+            infoLogger(
+              `Couldn't parse string to vec (${this.properties.value})`,
+            )
+            this.properties.value = initVector(numInputs)
+          }
+        } else if (typeof this.properties.value === 'number') {
+          const newVec = initVector(numInputs)
+          newVec.x = Number.parseFloat(this.properties.value)
+          this.properties.value = newVec
+        }
+
+        if (
+          typeof this.properties.value === 'object' &&
+          Object.keys(this.properties.value).length !== numInputs
+        ) {
+          const current = Object.keys(this.properties.value)
+          if (current.length < numInputs) {
+            infoLogger('current value smaller than target, adjusting')
+            for (let index = current.length; index < numInputs; index++) {
+              this.properties.value[mtb_widgets.VECTOR_AXIS[index]] = 0.0
+            }
+          } else {
+            infoLogger('current value greater than target, adjusting')
+            const newVal = {}
+            for (let index = 0; index < numInputs; index++) {
+              newVal[mtb_widgets.VECTOR_AXIS[index]] =
+                this.properties.value[mtb_widgets.VECTOR_AXIS[index]]
+            }
+            this.properties.value = newVal
+          }
+        }
+        break
+      }
+      default:
+        break
+    }
+  }
+
+  /**
+   * Remove all widgets but the comboBox for selecting the type
+   * then recreate the appropriate widget from scratch
+   */
+  updateWidgets() {
+    // NOTE: Remove existing widgets
+    for (let i = 1; i < this.widgets.length; i++) {
+      const element = this.widgets[i]
+      if (element.onRemove) {
+        element.onRemove()
+      }
+      // element?.onRemove()
+    }
+
+    this.widgets.splice(1)
+    this.widgets[0].value = this.properties.type
+
+    this.convertValue(this.properties.type)
+
+    switch (this.properties.type) {
+      case 'color': {
+        const col_widget = this.addCustomWidget(
+          MtbWidgets.COLOR('Value', this.properties.value),
+        )
+        col_widget.callback = (col) => {
+          this.properties.value = col
+          // this.updateOutput()
+        }
+        break
+      }
+      case 'int': {
+        const f_widget = this.addCustomWidget(
+          ComfyWidgets.INT(
+            this,
+            'Value',
+            [
+              '',
+              {
+                default: this.properties.value,
+                callback: (val) => console.log('VALUE', val),
+              },
+            ],
+            app,
+          ),
+        )
+
+        f_widget.widget.callback = (val) => {
+          this.properties.value = val
+        }
+
+        break
+      }
+      case 'float': {
+        this.addWidget('number', 'Value', this.properties.value, (val) => {
+          this.properties.value = val
+        })
+        break
+      }
+      case 'string': {
+        mtb_widgets.addMultilineWidget(
+          this,
+          'Value',
+          {
+            defaultVal: this.properties.value,
+          },
+          (v) => {
+            this.properties.value = v
+            // this.updateOutput()
+          },
+        )
+        break
+      }
+      case 'vector2':
+      case 'vector3':
+      case 'vector4': {
+        const numInputs = Number.parseInt(this.properties.type.charAt(6))
+        const node = this
+        const v_widget = mtb_widgets.addVectorWidget(
+          this,
+          'Value',
+          this.properties.value, // value
+          numInputs, // vector_size
+          function (v) {
+            node.properties.value = v
+            // this.updateOutput()
+          },
+        )
+        break
+      }
+
+      // NOTE: this is not reached anymore, kept for reference
+      case 'number': {
+        if (typeof this.properties.value !== 'number') {
+          this.properties.value = 0.0
+        }
+        const n_widget = this.addWidget(
+          'number',
+          'Value',
+          this.properties.force_int
+            ? Number.parseInt(this.properties.value)
+            : this.properties.value,
+          (value) => {
+            this.properties.value = this.properties.force_int
+              ? Number.parseInt(value)
+              : value
+            // this.updateOutput()
+          },
+        )
+        //override the callback
+        const origCallback = n_widget.callback
+        const node = this
+        n_widget.callback = function (val) {
+          const r = origCallback ? origCallback.apply(this, [val]) : undefined
+          if (node.properties.force_int) {
+            // TODO: rework this, a it makes it harder to manipulate
+            this.value = Number.parseInt(this.value)
+            node.properties.value = Number.parseInt(this.value)
+          }
+          infoLogger('NEW NUMBER', this.value)
+          return r
+        }
+
+        this.addWidget(
+          'toggle',
+          'Convert to Integer',
+          this.properties.force_int,
+          (value) => {
+            this.properties.force_int = value
+            this.updateOutputType()
+          },
+        )
+        break
+      }
+      default:
+        break
+    }
+  }
+  onConnectionsChange(type, slotIndex, isConnected, link, ioSlot) {
+    // super.onConnectionsChange(type, slotIndex, isConnected, link, ioSlot)
+    if (isConnected) {
+      this.updateTargetWidgets([link.id])
+    }
+  }
+
+  updateOutputType() {
+    infoLogger('Updating output type')
+    const rm_if_mismatch = (type) => {
+      if (this.outputs[0].type !== type) {
+        for (let i = 0; i < this.outputs.length; i++) {
+          this.removeOutput(i)
+        }
+        this.addOutput('output', type)
+        // this.setOutputDataType(0, type)
+      }
+    }
+    switch (this.properties.type) {
+      case 'color':
+        rm_if_mismatch('COLOR')
+        break
+      case 'float':
+        rm_if_mismatch('FLOAT')
+        break
+      case 'int':
+        rm_if_mismatch('INT')
+        break
+      case 'number':
+        if (this.properties.force_int) {
+          rm_if_mismatch('INT')
+        } else {
+          rm_if_mismatch('FLOAT')
+        }
+        break
+      case 'string':
+        rm_if_mismatch('STRING')
+        break
+      // case 'vector2':
+      // case 'vector3':
+      // case 'vector4':
+      //   rm_if_mismatch('FLOAT')
+      //   break
+      case 'vector2':
+        rm_if_mismatch('VECTOR2')
+        break
+      case 'vector3':
+        rm_if_mismatch('VECTOR3')
+        break
+      case 'vector4':
+        rm_if_mismatch('VECTOR4')
+        break
+      default:
+        break
+    }
+    // this.updateOutput()
+  }
+
+  /**
+   * NOTE: This feels hacky but seems to work fine
+   * since Constant is a virtual node.
+   */
+  updateTargetWidgets(u_links) {
+    infoLogger('Updating target widgets')
+    if (!app.graph.links) return
+    const links = u_links || this.outputs[0].links
+    if (!links) return
+    for (let i = 0; i < links.length; i++) {
+      const link = app.graph.links[links[i]]
+      const tgt_node = app.graph.getNodeById(link.target_id)
+      if (!tgt_node || !tgt_node.inputs) return
+      const tgt_input = tgt_node.inputs[link.target_slot]
+      if (!tgt_input) return
+      const tgt_widget = tgt_node.widgets.filter(
+        (w) => w.name === tgt_input.name,
+      )
+      // infoLogger('Constant Target Node', tgt_node)
+      // infoLogger('Constant Target Input', tgt_input)
+      if (!tgt_widget || tgt_widget.length === 0) return
+
+      tgt_widget[0].value = this.properties.value
+    }
+  }
+
+  updateOutput() {
+    infoLogger('Updating output value')
+    const value = this.properties.value
+
+    switch (this.properties.type) {
+      case 'color':
+        this.setOutputData(0, value)
+        break
+      case 'number':
+        if (this.properties.force_int) {
+          this.setOutputData(0, Number.parseInt(value))
+        } else {
+          this.setOutputData(0, Number.parseFloat(value))
+        }
+        break
+      case 'string':
+        this.setOutputData(0, value.toString())
+        break
+      case 'vector2':
+      case 'vector3':
+      case 'vector4':
+        this.setOutputData(0, value)
+        break
+
+      // case 'vector2':
+      //   this.setOutputData(0, value.slice(0, 2))
+      //   break
+      // case 'vector3':
+      //   this.setOutputData(0, value.slice(0, 3))
+      //   break
+      // case 'vector4':
+      //   this.setOutputData(0, value.slice(0, 4))
+      //   break
+      default:
+        break
+    }
+
+    infoLogger('New Value', this.value)
+
+    this.updateTargetWidgets()
+  }
+}
+app.registerExtension({
+  name: 'mtb.constant',
+
+  async beforeRegisterNodeDef(nodeType, nodeData, _app) {
+    if (nodeData.name === 'Constant (mtb)') {
+      new ConstantJs(nodeType)
+    }
+  },
+  // NOTE: old js only registration
+  //
+  // registerCustomNodes() {
+  //   LiteGraph.registerNodeType('Constant (mtb)', Constant)
+  //
+  //   Constant.category = 'mtb/utils'
+  //   Constant.title = 'Constant (mtb)'
+  // },
+})

web/curve_widget.js

@@ -0,0 +1,221 @@
+// Reference the shared typedefs file
+/// <reference path="../types/typedefs.js" />
+import { app } from '../../scripts/app.js'
+import { infoLogger } from './comfy_shared.js'
+
+function B0(t) {
+  return (1 - t) ** 3 / 6
+}
+function B1(t) {
+  return (3 * t ** 3 - 6 * t ** 2 + 4) / 6
+}
+function B2(t) {
+  return (-3 * t ** 3 + 3 * t ** 2 + 3 * t + 1) / 6
+}
+function B3(t) {
+  return t ** 3 / 6
+}
+class CurveWidget {
+  constructor(...args) {
+    const [inputName, opts] = args
+
+    this.name = inputName || 'Curve'
+
+    this.type = 'FLOAT_CURVE'
+    this.selectedPointIndex = null
+    this.options = opts
+    this.value = this.value || { 0: { x: 0, y: 0 }, 1: { x: 1, y: 1 } }
+  }
+
+  drawBSpline(ctx, width, height, posY) {
+    const n = this.value.length - 1
+    const numSegments = n - 2
+    const numPoints = this.value.length
+    if (numPoints < 4) {
+      this.drawLinear(ctx, width, height, posY)
+    } else {
+      for (let j = 0; j <= numSegments; j++) {
+        for (let t = 0; t <= 1; t += 0.01) {
+          let pt = this.getBSplinePoint(j, t)
+          let x = pt.x * width
+          let y = posY + height - pt.y * height
+
+          if (t === 0) ctx.moveTo(x, y)
+          else ctx.lineTo(x, y)
+        }
+      }
+      ctx.stroke()
+    }
+  }
+
+  drawLinear(ctx, width, height, posY) {
+    for (let i = 0; i < Object.keys(this.value).length - 1; i++) {
+      let p1 = this.value[i]
+      let p2 = this.value[i + 1]
+      ctx.moveTo(p1.x * width, posY + height - p1.y * height)
+      ctx.lineTo(p2.x * width, posY + height - p2.y * height)
+    }
+    ctx.stroke()
+  }
+  getBSplinePoint(i, t) {
+    // Control points for this segment
+    const p0 = this.value[i]
+    const p1 = this.value[i + 1]
+    const p2 = this.value[i + 2]
+    const p3 = this.value[i + 3]
+
+    const x = B0(t) * p0.x + B1(t) * p1.x + B2(t) * p2.x + B3(t) * p3.x
+    const y = B0(t) * p0.y + B1(t) * p1.y + B2(t) * p2.y + B3(t) * p3.y
+
+    return { x, y }
+  }
+  /**
+   * @param {OnDrawWidgetParams} args
+   */
+  draw(...args) {
+    const hide = this.type !== 'FLOAT_CURVE'
+    if (hide) {
+      return
+    }
+
+    const [ctx, node, width, posY, height] = args
+    const [cw, ch] = this.computeSize(width)
+
+    ctx.beginPath()
+    ctx.fillStyle = '#000'
+    ctx.strokeStyle = '#fff'
+    ctx.lineWidth = 2
+
+    // normalized coordinates -> canvas coordinates
+    for (let i = 0; i < Object.keys(this.value || {}).length - 1; i++) {
+      let p1 = this.value[i]
+      let p2 = this.value[i + 1]
+      ctx.moveTo(p1.x * cw, posY + ch - p1.y * ch)
+      ctx.lineTo(p2.x * cw, posY + ch - p2.y * ch)
+    }
+    ctx.stroke()
+
+    // points
+    Object.values(this.value || {}).forEach((point) => {
+      ctx.beginPath()
+      ctx.arc(point.x * cw, posY + ch - point.y * ch, 5, 0, 2 * Math.PI)
+      ctx.fill()
+    })
+  }
+
+  mouse(event, pos, node) {
+    let x = pos[0] - node.pos[0]
+    let y = pos[1] - node.pos[1]
+    const width = node.size[0]
+    const height = 300 // TODO: compute
+    const posY = node.pos[1]
+    const localPos = { x: pos[0], y: pos[1] - LiteGraph.NODE_WIDGET_HEIGHT }
+
+    if (event.type === LiteGraph.pointerevents_method + 'down') {
+      console.debug('Checking if a point was clicked')
+      const clickedPointIndex = this.detectPoint(localPos, width, height)
+      if (clickedPointIndex !== null) {
+        this.selectedPointIndex = clickedPointIndex
+      } else {
+        this.addPoint(localPos, width, height)
+      }
+      return true
+    } else if (
+      event.type === LiteGraph.pointerevents_method + 'move' &&
+      this.selectedPointIndex !== null
+    ) {
+      this.movePoint(this.selectedPointIndex, localPos, width, height)
+      return true
+    } else if (
+      event.type === LiteGraph.pointerevents_method + 'up' &&
+      this.selectedPointIndex !== null
+    ) {
+      this.selectedPointIndex = null
+      return true
+    }
+    return false
+  }
+  callback(...args) {
+    //value, that, node, pos, event) {
+
+  }
+
+  detectPoint(localPos, width, height) {
+    const threshold = 20 // TODO: extract
+    const keys = Object.keys(this.value)
+    for (let i = 0; i < keys.length; i++) {
+      const key = keys[i]
+      const p = this.value[key]
+      const px = p.x * width
+      const py = height - p.y * height
+      if (
+        Math.abs(localPos.x - px) < threshold &&
+        Math.abs(localPos.y - py) < threshold
+      ) {
+        return key
+      }
+    }
+    return null
+  }
+  addPoint(localPos, width, height) {
+    // add a new point based on click position
+    const normalizedPoint = {
+      x: localPos.x / width,
+      y: 1 - localPos.y / height,
+    }
+
+    const keys = Object.keys(this.value)
+    let insertIndex = keys.length
+    for (let i = 0; i < keys.length; i++) {
+      if (normalizedPoint.x < this.value[keys[i]].x) {
+        insertIndex = i
+        break
+      }
+    }
+    // shift
+    for (let i = keys.length; i > insertIndex; i--) {
+      this.value[i] = this.value[i - 1]
+    }
+
+    this.value[insertIndex] = normalizedPoint
+  }
+
+  movePoint(index, localPos, width, height) {
+    const point = this.value[index]
+    point.x = Math.max(0, Math.min(1, localPos.x / width))
+    point.y = Math.max(0, Math.min(1, 1 - localPos.y / height))
+
+    this.value[index] = point
+  }
+  computeSize(width) {
+    return [width, 300]
+  }
+
+  configure(data) {
+  }
+}
+
+app.registerExtension({
+  name: 'mtb.curves',
+  getCustomWidgets: () => {
+    return {
+      /**
+       * @param {LGraphNode} node
+       * @param {str} inputName
+       * @param {[str,*]} inputData
+       * @param {*} app
+       *
+       */
+      FLOAT_CURVE: (node, inputName, inputData, app) => {
+        // const c = node.widgets.find((w) => w.type === "FLOAT_CURVE")
+        const wid = node.addCustomWidget(new CurveWidget(inputName, inputData))
+
+        return {
+          widget: wid,
+          minWidth: 150,
+          minHeight: 30,
+        }
+      },
+    }
+  },
+})

web/debug.js

@@ -0,0 +1,143 @@
+/**
+ * File: debug.js
+ * Project: comfy_mtb
+ * Author: Mel Massadian
+ *
+ * Copyright (c) 2023 Mel Massadian
+ *
+ */
+
+// Reference the shared typedefs file
+/// <reference path="../types/typedefs.js" />
+
+import { app } from '../../scripts/app.js'
+
+import * as shared from './comfy_shared.js'
+import { MtbWidgets } from './mtb_widgets.js'
+
+// TODO: respect inputs order...
+
+function escapeHtml(unsafe) {
+  return unsafe
+    .replace(/&/g, '&amp;')
+    .replace(/</g, '&lt;')
+    .replace(/>/g, '&gt;')
+    .replace(/"/g, '&quot;')
+    .replace(/'/g, '&#039;')
+}
+app.registerExtension({
+  name: 'mtb.Debug',
+
+  /**
+   * @param {NodeType} nodeType
+   * @param {NodeData} nodeData
+   * @param {*} app
+   */
+  async beforeRegisterNodeDef(nodeType, nodeData, app) {
+    if (nodeData.name === 'Debug (mtb)') {
+      const onNodeCreated = nodeType.prototype.onNodeCreated
+      nodeType.prototype.onNodeCreated = function () {
+        this.options = {}
+        const r = onNodeCreated
+          ? onNodeCreated.apply(this, arguments)
+          : undefined
+        this.addInput(`anything_1`, '*')
+        return r
+      }
+
+      const onConnectionsChange = nodeType.prototype.onConnectionsChange
+      /**
+       * @param {OnConnectionsChangeParams} args
+       */
+      nodeType.prototype.onConnectionsChange = function (...args) {
+        const [_type, index, connected, link_info, ioSlot] = args
+        const r = onConnectionsChange
+          ? onConnectionsChange.apply(this, args)
+          : undefined
+        // TODO: remove all widgets on disconnect once computed
+        shared.dynamic_connection(this, index, connected, 'anything_', '*', {
+          link: link_info,
+          ioSlot: ioSlot,
+        })
+
+        //- infer type
+        if (link_info) {
+          // const fromNode = this.graph._nodes.find(
+          // (otherNode) => otherNode.id === link_info.origin_id,
+          // )
+          // const fromNode = app.graph.getNodeById(link_info.origin_id)
+          const { from } = shared.nodesFromLink(this, link_info)
+          if (!from || this.inputs.length === 0) return
+          const type = from.outputs[link_info.origin_slot].type
+          this.inputs[index].type = type
+          // this.inputs[index].label = type.toLowerCase()
+        }
+        //- restore dynamic input
+        if (!connected) {
+          this.inputs[index].type = '*'
+          this.inputs[index].label = `anything_${index + 1}`
+        }
+        return r
+      }
+
+      const onExecuted = nodeType.prototype.onExecuted
+      nodeType.prototype.onExecuted = async function (data) {
+        onExecuted?.apply(this, arguments)
+
+        const prefix = 'anything_'
+
+        if (this.widgets) {
+          for (let i = 0; i < this.widgets.length; i++) {
+            if (this.widgets[i].name !== 'output_to_console') {
+              this.widgets[i].onRemoved?.()
+            }
+          }
+          this.widgets.length = 1
+        }
+        let widgetI = 1
+        if (data.text) {
+          for (const txt of data.text) {
+            const w = this.addCustomWidget(
+              MtbWidgets.DEBUG_STRING(`${prefix}_${widgetI}`, escapeHtml(txt)),
+            )
+            w.parent = this
+            widgetI++
+          }
+        }
+        if (data.b64_images) {
+          for (const img of data.b64_images) {
+            const w = this.addCustomWidget(
+              MtbWidgets.DEBUG_IMG(`${prefix}_${widgetI}`, img),
+            )
+            w.parent = this
+            widgetI++
+          }
+        }
+
+        if (data.geometry) {
+          for (const geom of data.geometry) {
+            console.log('Adding geom', geom, typeof geom)
+            const w = this.addCustomWidget(
+              await MtbWidgets.DEBUG_GEOM(this, `${prefix}_${widgetI}`, geom),
+            )
+            w.parent = this
+            widgetI++
+          }
+        }
+
+        // this.setSize(this.computeSize())
+
+        this.onRemoved = function () {
+          // When removing this node we need to remove the input from the DOM
+          for (const y in this.widgets) {
+            if (this.widgets[y].canvas) {
+              this.widgets[y].canvas.remove()
+            }
+            shared.cleanupNode(this)
+            this.widgets[y].onRemoved?.()
+          }
+        }
+      }
+    }
+  },
+})

web/geometry_nodes.js

@@ -0,0 +1,29 @@
+/**
+ * File: geometry_nodes.js
+ * Project: comfy_mtb
+ * Author: Mel Massadian
+ *
+ * Copyright (c) 2023 Mel Massadian
+ *
+ */
+
+import { app } from '../../scripts/app.js'
+
+app.registerExtension({
+  name: 'mtb.geometry_nodes',
+  init: () => {},
+
+  async beforeRegisterNodeDef(nodeType, nodeData, ...args) {
+    switch (nodeData.name) {
+      case 'Geometry Load (mtb)': {
+        const onExecuted = nodeType.prototype.onExecuted
+        nodeType.prototype.onExecuted = function (message) {
+          onExecuted?.apply(this, nodeType, nodeData, ...args)
+          console.log('Executed Load Geometry', ...args)
+          console.log('Message:', message)
+        }
+        break
+      }
+    }
+  },
+})