feat: use mtb three-view (wip)

probably very broken still, untested

.github/workflows/publish_action.yml

@@ -5,20 +5,14 @@ on:
     tags:
       - '*'
 
-permissions:
-  issues: write
-
 jobs:
   publish-node:
     name: Publish Custom Node to registry
     runs-on: ubuntu-latest
-    if: ${{ github.repository_owner == 'melMass' }}
     steps:
       - name: ♻️ Check out code
         uses: actions/checkout@v4
-        with:
-          submodules: true
       - name: 📦 Publish Custom Node
-        uses: Comfy-Org/publish-node-action@v1
+        uses: Comfy-Org/publish-node-action@main
         with:
           personal_access_token: ${{ secrets.COMFY_REGISTRY_TOKEN }}

CHANGELOG.md

@@ -3,193 +3,10 @@
 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] - 2025-04-16
+## [main] - 2024-03-07
 
 ### Bug Fixes
 
-- 🐛 note+ breaking wfs ([af42134](https://github.com/melMass/comfy_mtb/commit/af421340286b234e4c0cfcd4143a9d8726ebf3d1))
-- 🐛 ColorCorrect clamp issue ([a85e57b](https://github.com/melMass/comfy_mtb/commit/a85e57b18c7d3c765131873ffff523244ca9be73))
-- 🐛 Whisper chunks processing ([8bf3545](https://github.com/melMass/comfy_mtb/commit/8bf3545fec5b2a180607d40394b025a1e09c14b6))
-- 🐛 stackImages move to device ([d87e52e](https://github.com/melMass/comfy_mtb/commit/d87e52ea2c112fd95f257dcd6a54a5db77a34fc3))
-- 🐛 bbox upscale from center ([55261bd](https://github.com/melMass/comfy_mtb/commit/55261bda7c33d088b62c5483e4483201e5a9ce77))
-- 🐛 add MASK support for PickFromBatch ([0d264b9](https://github.com/melMass/comfy_mtb/commit/0d264b90a78d5a6719fb3ce71f4e9a642db4c950))
-- 🐛 use addDOMWidget for Debug node ([46af602](https://github.com/melMass/comfy_mtb/commit/46af6027d6c87d0c29b8bb0fd1cc1dbdae993629))
-- 🐛 use "modern" notation in toDevice ([b7ca8ed](https://github.com/melMass/comfy_mtb/commit/b7ca8ed1c6e117b71afd7696f55dcc3dbd5bad08))
-- 🐛 handle missing submodules ([d61da30](https://github.com/melMass/comfy_mtb/commit/d61da304099ff5e4528e4beb1ecc2eb83cabaaa1))
-- 🐛 add warnings about what each IO mode can do ([6608c0b](https://github.com/melMass/comfy_mtb/commit/6608c0b6d1cf8f7a9901214096f8c78bfe17056f))
-- 🐛 soft deprecate compression h264 ([a757e1c](https://github.com/melMass/comfy_mtb/commit/a757e1c98b2abbd2221a15b77e89d772e02d1d82))
-- 🐛 limit packages allowed to be installed from API ([d6e004c](https://github.com/melMass/comfy_mtb/commit/d6e004cce2c32f8e48b868e66b89f82da4887dc3))
-- 🐛 ensure default settings (io sidebar) ([ed17fa2](https://github.com/melMass/comfy_mtb/commit/ed17fa2ef4688aadf305a6d51b32c13a0efd22d6))
-- 🐛 spawn colour picker at pointer location ([e5482ae](https://github.com/melMass/comfy_mtb/commit/e5482aee5e3de07e8f055b3edc0fccc0e0f75c14)) by [@webfiltered](https://github.com/webfiltered) in [#223](https://github.com/melMass/comfy_mtb/pull/223)
-- 🐛 i/o sidebar for custom paths ([62469a4](https://github.com/melMass/comfy_mtb/commit/62469a4dd96e32509171aad74fcae8d2bb0ec593))
-
-### Features
-
-- ⚡ add BatchFromFolder ([9618513](https://github.com/melMass/comfy_mtb/commit/96185132b83c182032e9f6e822561eb5699af517))
-- ⚡ add use_normalized to TransformBatch2D ([d4a31bf](https://github.com/melMass/comfy_mtb/commit/d4a31bf19c2863df8dfc4cb9a3cd6683304949e4))
-- [**breaking**] ⚡ add support for masks in BatchFLoatMath ([fc7ba08](https://github.com/melMass/comfy_mtb/commit/fc7ba084f6ed7880e88e28eb448ab0bd7d796824))
-- ✨ add use_normalized to TransformImage ([4516aa9](https://github.com/melMass/comfy_mtb/commit/4516aa9cb4fcb12c946999d6dcc1501cc09011a3))
-- ✨ add regex support for String Replace ([78946b0](https://github.com/melMass/comfy_mtb/commit/78946b0fa3c3cf5dfcee8c7c4c0921b722d09d1e)) by [@poetryiii](https://github.com/poetryiii) in [#233](https://github.com/melMass/comfy_mtb/pull/233)
-- ✨ update diarization to 3.1 ([c30408f](https://github.com/melMass/comfy_mtb/commit/c30408f96d4df9c7d35545654401162090a74305)) by [@numz](https://github.com/numz)
-- ✨ add "workflow" query to /mtb/view endpoint ([eb7cf89](https://github.com/melMass/comfy_mtb/commit/eb7cf89f173b2342b04e7b61dca3d12cfaf65bdb))
-- ✨ add stretch_x and stretch_y to TransformImage ([22fce6f](https://github.com/melMass/comfy_mtb/commit/22fce6fdda135cbb1f1aad42c86aae166cba81b5))
-- ✨ add AudioDuration node ([f471497](https://github.com/melMass/comfy_mtb/commit/f47149746ac1e418cda2007c38aafbb03946ce22))
-- ✨ basic whisper nodes ([83cfc5c](https://github.com/melMass/comfy_mtb/commit/83cfc5c723d1a572af67ad14b52be4f8371a3c5f))
-- ✨ add BboxForDimensions ([9405784](https://github.com/melMass/comfy_mtb/commit/940578476438eaa6a42e0056f1b7b319ee585334))
-- ✨ improve the debug node ([cf7a9c4](https://github.com/melMass/comfy_mtb/commit/cf7a9c41e81e8dd461ab9dfa3c05bb8e2cdf2a67))
-- ✨ add BatchImageToSublist and counterpart ([00173fa](https://github.com/melMass/comfy_mtb/commit/00173fa3fbca4c5b1ff3016cc5139705ce61ec20))
-- ✨ add TensorOps ([a8cf465](https://github.com/melMass/comfy_mtb/commit/a8cf4650ff5cbd4975ef954b5829c772ee53250c))
-- ✨ live update outputs grid ([7f7a62f](https://github.com/melMass/comfy_mtb/commit/7f7a62f832c865a13b9181daee79d3cfc21581e2)) by [@christian-byrne](https://github.com/christian-byrne) in [#229](https://github.com/melMass/comfy_mtb/pull/229)
-- ✨ add SaveImage passthrough ([0eeb707](https://github.com/melMass/comfy_mtb/commit/0eeb707f34f51142def8e0ef7d351ee5028cb5e0))
-- ✨ add filtering to TransformImage ([bae26a0](https://github.com/melMass/comfy_mtb/commit/bae26a07fb02dd518c621eba28986a51c5d086bc))
-- ✨ add support for video in I/O sidebar ([c92d99a](https://github.com/melMass/comfy_mtb/commit/c92d99a8a37a64cfc285296f21452c4927a22774))
-- ✨ add an extra static input to Stack Images ([3f6d082](https://github.com/melMass/comfy_mtb/commit/3f6d08294096918d50101a19083f9134305cc8c9)) in [#222](https://github.com/melMass/comfy_mtb/pull/222)
-- ✨ add support for subdirs (i/o sidebar) ([52bd76e](https://github.com/melMass/comfy_mtb/commit/52bd76e19c8bd7e72986900e5dbfade0457ef7e0))
-- ✨ add Batch Sequence Nodes ([827c64c](https://github.com/melMass/comfy_mtb/commit/827c64c43d52ebfb8acd2e5c4491c4b66e6b8f40))
-- ✨ add support for more formats (I/O sidebar) ([8c629be](https://github.com/melMass/comfy_mtb/commit/8c629bee186b5ac991058018a788e4a836eef630))
-
-### Miscellaneous Tasks
-
-- 🧹 bump version ([d093d76](https://github.com/melMass/comfy_mtb/commit/d093d76efd87474a3ca82858147255038060ab17))
-- 🧹 small adjustments ([01107c4](https://github.com/melMass/comfy_mtb/commit/01107c45f8539ff7c579e08e2a9075d93781b9a2))
-- 🤖 update publish action workflow with permissions and version constraints ([0e48aaa](https://github.com/melMass/comfy_mtb/commit/0e48aaa3e4f1e440a5d7ab42df56b728ced03aca)) by [@robinjhuang](https://github.com/robinjhuang) in [#237](https://github.com/melMass/comfy_mtb/pull/237)
-- 🧹 basic standalone detection ([3a25526](https://github.com/melMass/comfy_mtb/commit/3a25526e818a1af8f886d2ad5c27101c4a0caa8b))
-- 🧹 rename type ([edcb3da](https://github.com/melMass/comfy_mtb/commit/edcb3da08bff66f9adcef8dcd37c3925e64d0135))
-- 🧹 update env file ([fc908ba](https://github.com/melMass/comfy_mtb/commit/fc908ba0a528523b7c1e37e34fb32f430746de0d))
-- 🧹 dev ([9a94371](https://github.com/melMass/comfy_mtb/commit/9a943714aada107bfd236e00fa1063872db7a834))
-- 🧹 apply formatting ([58ae89f](https://github.com/melMass/comfy_mtb/commit/58ae89f8e0f0f8b42825722a6aebc04da39847b1))
-
-### Refactor
-
-- 📦 add model autodownload ([147edcf](https://github.com/melMass/comfy_mtb/commit/147edcfcbc09dd27a0c787f9da568fb850c3308a))
-
-### Wip
-
-- 🚧 loop drawing ([ead4b34](https://github.com/melMass/comfy_mtb/commit/ead4b34e6dd03ea4ed309b246ef31c995325aa08))
-
-## New Contributors
-* [@poetryiii](https://github.com/poetryiii) made their first contribution in [#233](https://github.com/melMass/comfy_mtb/pull/233)
-* [@numz](https://github.com/numz) made their first contribution in [#](https://github.com/melMass/comfy_mtb/pull/)
-* [@webfiltered](https://github.com/webfiltered) made their first contribution in [#223](https://github.com/melMass/comfy_mtb/pull/223)
-## [0.2.0] - 2024-12-08
-
-### Bug Fixes
-
-- 🐛 remove mtb sidebar ([b0d52f7](https://github.com/melMass/comfy_mtb/commit/b0d52f73051368df6de2d1e10ad28ca56df72803))
-- 🐛 always enable the I/O sidebar ([ec1cb1a](https://github.com/melMass/comfy_mtb/commit/ec1cb1ac17d14670aa756dfb1ae7542397b12559))
-- 🐛 ui shifts on animation builder ([ecbb220](https://github.com/melMass/comfy_mtb/commit/ecbb220de6a05f2e506ec43f2b786be983166157))
-- 🐛 category for settings ([b6fa571](https://github.com/melMass/comfy_mtb/commit/b6fa571fd2096ace60d03cab42dba9ca37d0cb27)) in [#211](https://github.com/melMass/comfy_mtb/pull/211)
-- 🐛 new UI issues ([f272526](https://github.com/melMass/comfy_mtb/commit/f272526bfc5da95e95d42cb4c613a0b9585b2577))
-- 🐛 disable old BOOL widget (legacy) ([8596b81](https://github.com/melMass/comfy_mtb/commit/8596b8184edb484c907475a77ac1dc9e4a5c92af))
-- 🐛 pass ONNX providers explicitely ([43092e4](https://github.com/melMass/comfy_mtb/commit/43092e44a4ea17f90fcfb12372da634fe4b79557))
-- 🐛 typo in mtb_widgets error catch ([80b5a0c](https://github.com/melMass/comfy_mtb/commit/80b5a0ca7459763e7662421bccd8636976eefddd)) by [@christian-byrne](https://github.com/christian-byrne) in [#197](https://github.com/melMass/comfy_mtb/pull/197)
-- 🐛 doc widget sidebar offset in the new ui ([81b3bc1](https://github.com/melMass/comfy_mtb/commit/81b3bc1651f06ad2fa7938f810d3f406f5e7c41c))
-- 🐛 don't fallback to eval ([997d2fb](https://github.com/melMass/comfy_mtb/commit/997d2fb13af6aadf36873ea2ea3317e56f405aef))
-- 🐛 rework main utils ([c99b081](https://github.com/melMass/comfy_mtb/commit/c99b0812ab4a4183ef9298fb8a7c954bc7c858b2))
-- 🐛 MaskToImage ([821a0ef](https://github.com/melMass/comfy_mtb/commit/821a0ef42735a0a97ab82be22a4fdc67c9cfc80e))
-
-### Documentation
-
-- 📚 update wiki ([e17c6e2](https://github.com/melMass/comfy_mtb/commit/e17c6e29f5111bf5085b1fe6f764cfd1aae709f2))
-- 📚 remove link ([5bc125d](https://github.com/melMass/comfy_mtb/commit/5bc125d2f08470c8900dfd89deca721835848917))
-- 📚 clean readme ([333f646](https://github.com/melMass/comfy_mtb/commit/333f646ab1959d2c944fb046275cc93a545d557c))
-
-### Features
-
-- ✨ add h264 compression node ([e32d1e0](https://github.com/melMass/comfy_mtb/commit/e32d1e02df5e3a9351f829513f7ee3ffb2934be4))
-- ✨ add postshot nodes ([27e03fa](https://github.com/melMass/comfy_mtb/commit/27e03fa23efffda461c6975b15fe3964de476cb3))
-- ✨ improve the I/O sidebar ([cd9e614](https://github.com/melMass/comfy_mtb/commit/cd9e614b1a385d6b06eacfaad62def1d69f09808)) in [#193](https://github.com/melMass/comfy_mtb/pull/193)
-- ✨ add UpscaleBBoxBy ([74af5c6](https://github.com/melMass/comfy_mtb/commit/74af5c6499ef5dd73ce66c4c21b8c3507d69b037))
-- ✨ simplified sidebar and backend ([22f7c30](https://github.com/melMass/comfy_mtb/commit/22f7c3037345a866c9ff0b06f6689748021cee63))
-- ✨ add Interpolate Condition ([0133fb9](https://github.com/melMass/comfy_mtb/commit/0133fb93bc944d0dd7593b89b36e5b2676d9397a))
-- ✨ dump of wip things... ([cf7d305](https://github.com/melMass/comfy_mtb/commit/cf7d30507e7e449c4489e6a1ca159d3d0486bc55))
-- ✨ use the new parser for documentations ([4e593bb](https://github.com/melMass/comfy_mtb/commit/4e593bb30be561e39f1790e3514f60bb39e5a261))
-- ✨ add @mtb/markdown-parser bundles ([097ca33](https://github.com/melMass/comfy_mtb/commit/097ca33b8e7b27148e183e91712dc34d98d1a69b))
-- ✨ add VitMatte nodes ([896a025](https://github.com/melMass/comfy_mtb/commit/896a025006f9c7809c5e0776393a28f908be8950))
-- ✨ add ColorCorrectGPU ([9651a70](https://github.com/melMass/comfy_mtb/commit/9651a7034120589b059329b21688708e42772453))
-- ✨ add Swap FG/BG colors to MaskToImage ([57683c3](https://github.com/melMass/comfy_mtb/commit/57683c3c7d299a117a26526d52de4c26f2ec0f69))
-- ✨ add Extract coordinates ([f99f92e](https://github.com/melMass/comfy_mtb/commit/f99f92e8f7b2d6fac56f7f40049715910e15cfee))
-- ✨ add AudioCut ([5681b46](https://github.com/melMass/comfy_mtb/commit/5681b464adce395086712b61159b2694150b8027))
-- ✨ add AudioStack ([8d0fcee](https://github.com/melMass/comfy_mtb/commit/8d0fcee2f3decc1cbbf3b850332e6b2a022e1377))
-- ✨ add AudioSequence node ([1078fc6](https://github.com/melMass/comfy_mtb/commit/1078fc6f0fb225b52536f25ec6a9fa0456a90595))
-- ✨ add Split Bbox node ([9007a70](https://github.com/melMass/comfy_mtb/commit/9007a70aa0d6b2ead0f68f7aff8ae8e3c4f3624f))
-- ✨ update lerp example ([1a0ebd5](https://github.com/melMass/comfy_mtb/commit/1a0ebd5173687784f279a9c2184c89fb3be01dc5))
-
-### Miscellaneous Tasks
-
-- 🧹 bump minor ([50cb6f5](https://github.com/melMass/comfy_mtb/commit/50cb6f5ed6e5d9fecb9733ef3f7852b8500005e9))
-- 🧹 add worktree to gitignores ([9ccf572](https://github.com/melMass/comfy_mtb/commit/9ccf572a158caeab9bff53853e8f6fb85b76776d))
-- 🧹 remove dupe code ([e099d58](https://github.com/melMass/comfy_mtb/commit/e099d581a7627c3a66d2e3e6df3a701b0e5f31b7))
-- 🧹 update externs ([784fb01](https://github.com/melMass/comfy_mtb/commit/784fb0145b7421e2730b52237ce6a8b63b189191))
-- 🧹 add pathlibed inputs to utils ([a825504](https://github.com/melMass/comfy_mtb/commit/a825504bdd67e3461be8118119e0becc35f8af40))
-- 🧹 disable Constant ([22190cd](https://github.com/melMass/comfy_mtb/commit/22190cd25ee590595f8f19e75a9a6c539699622b))
-- 🧹 new ui is default, flag for old ui ([a976adb](https://github.com/melMass/comfy_mtb/commit/a976adbb39a13b4cd76f224ebba40c604900c862))
-- 🧹 add methods to shared ([f8829fc](https://github.com/melMass/comfy_mtb/commit/f8829fcb373e0f9bc4f0ad36c939f372349943bf))
-- 🧹 add an old_ui flag to my launcher ([dbdf276](https://github.com/melMass/comfy_mtb/commit/dbdf27664cd207dbbc69b8d635adcd59ed8d269a))
-- 🧹 move qrcode to his own file ([7d5569e](https://github.com/melMass/comfy_mtb/commit/7d5569e5c1e0f0b6ccb505a02f74640139d6aaf9))
-
-## [0.1.6] - 2024-07-03
-
-### Bug Fixes
-
-- 🐛 menu callback issue ([d64fac4](https://github.com/melMass/comfy_mtb/commit/d64fac4b74e0590acde5e3b8edd4a2f715448cf5))
-
-### Documentation
-
-- 📚 Update requirements file in INSTALL.md ([f25f6bd](https://github.com/melMass/comfy_mtb/commit/f25f6bdcd13d50f9d383065321320b0ce6a03214)) by [@elthariel](https://github.com/elthariel) in [#186](https://github.com/melMass/comfy_mtb/pull/186)
-
-### Features
-
-- ✨ add alpha channel support for faceswap/restore ([d6343e1](https://github.com/melMass/comfy_mtb/commit/d6343e1860f46947e93758f8bba03857c9326b38))
-
-### Miscellaneous Tasks
-
-- 🧹 better classname extraction ([d687497](https://github.com/melMass/comfy_mtb/commit/d687497d8041ab5d77bd31909592def6e4d0e7f6))
-- 🤖 limit release only to tags ([4eebdd8](https://github.com/melMass/comfy_mtb/commit/4eebdd8b8bff73c3db4f0248da8dac7d67cb310b))
-- 🧹 runner ([fb34671](https://github.com/melMass/comfy_mtb/commit/fb34671ee6fe80b965fe576c279ed1ff77a358f2))
-- 🤖 only publish on tag ([f1b4846](https://github.com/melMass/comfy_mtb/commit/f1b484617a917d38d9b3658d8920aa7dec672a79))
-- 🧹 small fixes ([4507842](https://github.com/melMass/comfy_mtb/commit/4507842a706141977a6a68945c36e977c358d91a))
-
-## New Contributors
-* [@elthariel](https://github.com/elthariel) made their first contribution in [#186](https://github.com/melMass/comfy_mtb/pull/186)
-## [0.1.5] - 2024-06-21
-
-### Bug Fixes
-
-- 🐛 keep the last model match instead of first ([1edc2cd](https://github.com/melMass/comfy_mtb/commit/1edc2cd10de81297e7a895009d358813e79b70ba))
-- 🐛 properly initialize the curve value ([35622e3](https://github.com/melMass/comfy_mtb/commit/35622e3a5e58103a8f5b150556b85e97e31555e1))
-- 🐛 ImageCompare improvements ([acc2d68](https://github.com/melMass/comfy_mtb/commit/acc2d687d596bf82c2075f9a24003eacf18adfe7)) by [@christian-byrne](https://github.com/christian-byrne) in [#176](https://github.com/melMass/comfy_mtb/pull/176)
-- 🐛 repetitive warning ([780c52f](https://github.com/melMass/comfy_mtb/commit/780c52f03aca3079a1b695510341486720004bec)) by [@vxkj1211](https://github.com/vxkj1211) in [#177](https://github.com/melMass/comfy_mtb/pull/177)
-- 🐛 add back was conversion node ([349a852](https://github.com/melMass/comfy_mtb/commit/349a8524c6f7fcab4a124cacb60bfbef1463cf1b))
-- 🐛 drag lag on documentation resize handle ([15330ea](https://github.com/melMass/comfy_mtb/commit/15330eab655f66214d3c25fd237679f090175c32))
-- 🐛 kwarg typo ([1571782](https://github.com/melMass/comfy_mtb/commit/1571782d012b83bce32a065e700f9a587db234d2))
-- 🐛 seed of PlotBatchFloat ([5b40302](https://github.com/melMass/comfy_mtb/commit/5b4030288d43c79859c9706a12aa0f8b7dea190f))
-- 🐛 forceInput for FLOAT <-> FLOATS converters ([5a0ef0d](https://github.com/melMass/comfy_mtb/commit/5a0ef0dadd01fd5937ed0715d829d6a456f96318))
-- 🐛 FLOAT always need options to be set ([967e72f](https://github.com/melMass/comfy_mtb/commit/967e72fc66780685f8192cb8fe13ba66b9326f63))
-- 🐛 remove doc if opened on node delete ([bee3f47](https://github.com/melMass/comfy_mtb/commit/bee3f47a14ddb92b3760098666bf75dc7d37f1e4))
-- 🐛 for documentation on HiDPI ([b11346a](https://github.com/melMass/comfy_mtb/commit/b11346aba88d9f1dac3b6b42c691979cc0978b6f))
-- 🐛 never remove input 0 of dynamic inputs ([30982fa](https://github.com/melMass/comfy_mtb/commit/30982fa48829c3fc2a6745ce5a07537a3d94b2f9))
-- 🐛 use the same fix as dynamicInputs for debug ([92b7990](https://github.com/melMass/comfy_mtb/commit/92b79906cd2ee1b4ca3ff25378d7786b5a47cb75))
-- 🐛 missing numberInput ([76f365b](https://github.com/melMass/comfy_mtb/commit/76f365b5eee165c76f3da7d2e3950786685bc08b))
-- 🐛 better curve ([da67e76](https://github.com/melMass/comfy_mtb/commit/da67e766c2f700dd9e2f51a5bafe07c612904f5d))
-- 🐛 prepend MTB_ to all classes ([b1d74ad](https://github.com/melMass/comfy_mtb/commit/b1d74adb15166e3e5eb9cf92d6148e4644bed346))
-- 🐛 dynamic connections ([652ac3f](https://github.com/melMass/comfy_mtb/commit/652ac3f3b971582b02115177fd6f7a9d3d7295df))
-- 🐛 remaining issue before merge ([100067a](https://github.com/melMass/comfy_mtb/commit/100067a645194366426f29b085bf25d0623f4fac))
-- 🐛 debug issues ([7807449](https://github.com/melMass/comfy_mtb/commit/7807449e6dcc01cfdb7f0eb818569184c8b41af2))
-- 🐛 errors when insightface's folder missing ([e838c04](https://github.com/melMass/comfy_mtb/commit/e838c04758402250fd3464d6cd6a6f872e8cef29))
-- 🐛 typo ([e40ad7a](https://github.com/melMass/comfy_mtb/commit/e40ad7a574f961ebe1f338b97214da5cbadcc529))
-- 🐛 better defaults (cont) ([1da483a](https://github.com/melMass/comfy_mtb/commit/1da483a8baa6a893f1adb05ef79b90c4412c3834))
-- 🐛 better defaults for Autopan ([5eff38b](https://github.com/melMass/comfy_mtb/commit/5eff38b387d22206d39c08e435806f9d03992feb))
-- 🐛 dynamic inputs ([9ab20a0](https://github.com/melMass/comfy_mtb/commit/9ab20a0ab50b1656ded9a84c13769fd2d547f2d2))
-- 🐛 bundle ace editor ([7c35582](https://github.com/melMass/comfy_mtb/commit/7c3558273bebc0754c802720e705232f220a0da4))
-- 🐛 image to mask ([f16d576](https://github.com/melMass/comfy_mtb/commit/f16d576f6f0e83fc2fafd2d1f29b2edeb00d3197))
-- 🐛 prepend MTB to classnames ([e56508c](https://github.com/melMass/comfy_mtb/commit/e56508c2078155f053e7f11d538a048df6a5b18b))
-- 🐛 allow smaller values in BatchTransform ([9a4b27d](https://github.com/melMass/comfy_mtb/commit/9a4b27d2e05e8ebe31f58a21db94bd3a54ed23d9))
-- 🐛 add category for virtual note+ ([eeac8c0](https://github.com/melMass/comfy_mtb/commit/eeac8c002ad1f9e461418fb66b9338e969259e58))
-- 🐛 make image feed of by default ([df0a98b](https://github.com/melMass/comfy_mtb/commit/df0a98b94a4a9388811bc8786e820ec892919c1a))
-- 🐛 support batch masks (colored image node) ([2465ffb](https://github.com/melMass/comfy_mtb/commit/2465ffb0d3b052fb78559394dbb550bba59b97a3))
-- 🐛 support pillow < 10 ([48f91b7](https://github.com/melMass/comfy_mtb/commit/48f91b74e2c7ef6d31c094eafa5332784a275a8b))
-- 🐛 image rotation bug ([54ff658](https://github.com/melMass/comfy_mtb/commit/54ff6583ded0ed4054f8e5d7fadf0b2350259dce)) by [@hongminpark](https://github.com/hongminpark) in [#154](https://github.com/melMass/comfy_mtb/pull/154)
 - 🐛 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))
@@ -230,13 +47,6 @@ Check the notes in the [releases](https://github.com/melMass/comfy_mtb/releases)
 
 ### Documentation
 
-- 📚 update the wiki ([fa3199b](https://github.com/melMass/comfy_mtb/commit/fa3199be2b87bf3cb7484a0fee32a8ac099adc65))
-- 📚 update wiki submodule ([49cea8d](https://github.com/melMass/comfy_mtb/commit/49cea8d94508b27781506e3b5509c65e1d84e80f))
-- 📚 add the wiki as a submodule ([5998924](https://github.com/melMass/comfy_mtb/commit/59989249260a9c579ec851c50534b58f3f02cd61))
-- 📚 missing doc ([c9836a8](https://github.com/melMass/comfy_mtb/commit/c9836a87f6823db1d53e56997417f3cbe8cc4727))
-- 📚 use flat icon ([991af4f](https://github.com/melMass/comfy_mtb/commit/991af4f45ff8c660b2c45466bb219186699170ed))
-- 📚 add banodoco channel link ([9ce34b4](https://github.com/melMass/comfy_mtb/commit/9ce34b47fd99b18db7997ccce44e6063f00b6801))
-- 📚 udpate changelog ([8221c49](https://github.com/melMass/comfy_mtb/commit/8221c49942bd87c14d5063066315a449a1fee86e))
 - 📝 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))
@@ -250,28 +60,6 @@ Check the notes in the [releases](https://github.com/melMass/comfy_mtb/releases)
 
 ### Features
 
-- ✨ add ModelPruner (wip) ([43d65ae](https://github.com/melMass/comfy_mtb/commit/43d65ae68c97e077117b17b7c9d1936583f965eb))
-- ✨ Use dynamic contrast in Color Correct ([6abac2e](https://github.com/melMass/comfy_mtb/commit/6abac2e4706a3d937420213e01468bae10cc2017)) by [@christian-byrne](https://github.com/christian-byrne) in [#180](https://github.com/melMass/comfy_mtb/pull/180)
-- ✨ StackImages add support for batch mismatch ([5060c56](https://github.com/melMass/comfy_mtb/commit/5060c561353e43624ec164cb73fce7d1d422f765))
-- ✨ add BatchFloatMath ([f9d2ebf](https://github.com/melMass/comfy_mtb/commit/f9d2ebf91d09fc214fecf7501a5490b33c30aca2))
-- ✨ add FLOATS to INTS ([1b7ae27](https://github.com/melMass/comfy_mtb/commit/1b7ae27cc1907bfba3c5166ec2c61547babd2e0a))
-- ✨ debug dict ([63ee25d](https://github.com/melMass/comfy_mtb/commit/63ee25d001d4c94aa95dc8b39008f5d943f2ab45))
-- ✨ add Swap BG/FG color menu item ([1caf7c1](https://github.com/melMass/comfy_mtb/commit/1caf7c18c372651b2be7227eb77e2251d963693d))
-- ✨ BatchFloatFit the batch version of FitNumber ([ab58c36](https://github.com/melMass/comfy_mtb/commit/ab58c362124f0f4b3178534ca78cb924fb881534))
-- ✨ add FloatToFloats (the counterpart) ([78a86da](https://github.com/melMass/comfy_mtb/commit/78a86daaf71dab5be34b90b13491460854718485))
-- ✨ add some FLOATS batch nodes ([2159395](https://github.com/melMass/comfy_mtb/commit/2159395389429c5f7012e660b41fad48d376b39f))
-- ✨ poc of the doc widget idea ([fac7529](https://github.com/melMass/comfy_mtb/commit/fac7529d1f7b6fc4b3b2e7f6022ebb23ec71169d))
-- ✨ add the backend node for Constant ([dff5b22](https://github.com/melMass/comfy_mtb/commit/dff5b2201d73c1a91d4b5864e3b974e68846a011))
-- ✨ add Constant node ([cbb5dd2](https://github.com/melMass/comfy_mtb/commit/cbb5dd2cf810d5648a64eae370dba610336b99d5))
-- ✨ add FloatsToFloat ([6ebecfd](https://github.com/melMass/comfy_mtb/commit/6ebecfd8cf1dc3779384e565a65baa9dceb43660))
-- ✨ add AutoPanEquilateral ([3513937](https://github.com/melMass/comfy_mtb/commit/35139371e84d715423015e05d1b4a6c1d88b0eb5))
-- ✨ add MatchDimensions ([5db3ebe](https://github.com/melMass/comfy_mtb/commit/5db3ebedb9d38470c82544e45970775193add05c))
-- ✨ add equilateral example ([8d65556](https://github.com/melMass/comfy_mtb/commit/8d65556c37f33d1c496504db92574805916dd613))
-- ✨ enhance tiling tools ([ba73fc6](https://github.com/melMass/comfy_mtb/commit/ba73fc6af7039a4629a73cdc36a8c8736dc27c9d))
-- ✨ add FLOATS support to blur ([92c810c](https://github.com/melMass/comfy_mtb/commit/92c810c5036f7a2b3f84a3fde8c81e6a2b046b07))
-- ✨ add "tube" to Batch Shape ([f658fc3](https://github.com/melMass/comfy_mtb/commit/f658fc31e040141209384d98dfe84b766fe4ae11))
-- ✨ note+ editor themes ([133da70](https://github.com/melMass/comfy_mtb/commit/133da705c94af2dfb3d2f38c0d9c2723c72cacf7))
-- ✨ add ffmpeg gif export ([1b29aad](https://github.com/melMass/comfy_mtb/commit/1b29aad360116e631b7b4d34e98a5a631f134977)) by [@huanggou666](https://github.com/huanggou666) in [#159](https://github.com/melMass/comfy_mtb/pull/159)
 - ✨ 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))
@@ -294,19 +82,6 @@ Check the notes in the [releases](https://github.com/melMass/comfy_mtb/releases)
 
 ### Miscellaneous Tasks
 
-- 🧹 add fields for the registry ([bb5682a](https://github.com/melMass/comfy_mtb/commit/bb5682aa6da923859db33830c2e46f24b19199a1))
-- 🧹 add pre-commit ([59612fd](https://github.com/melMass/comfy_mtb/commit/59612fd8110a888f0081433242a2b5a5f7e46da6))
-- 🧹 migrate from poetry to setuptools ([dfd17f6](https://github.com/melMass/comfy_mtb/commit/dfd17f6d783e784df7dab38d185c747b4c04d1d0))
-- 🧹 remove logs ([1070edd](https://github.com/melMass/comfy_mtb/commit/1070edd0245fb235183d5f38cd1bebf6e0405f97))
-- 🧹 add more pyproject meta ([644371e](https://github.com/melMass/comfy_mtb/commit/644371e5b5a2b8260fc5c6f699465b0bc1c81d57))
-- 🤖 move at the proper location ([f3d468c](https://github.com/melMass/comfy_mtb/commit/f3d468cfc238f13905a13a7b2225e3711129c64d))
-- 🤖 add CI to publish to ComfyUI Registry ([6cd448b](https://github.com/melMass/comfy_mtb/commit/6cd448b026956cdf3f1b81e93724b295316fbf09)) by [@haohaocreates](https://github.com/haohaocreates) in [#182](https://github.com/melMass/comfy_mtb/pull/182)
-- 🧹 add ComfyUI registry to pyproject.toml ([5951c90](https://github.com/melMass/comfy_mtb/commit/5951c90b10f9b77b2b617e83efe0112f43c8daef)) by [@haohaocreates](https://github.com/haohaocreates) in [#181](https://github.com/melMass/comfy_mtb/pull/181)
-- 🧹 update types ([96a0da9](https://github.com/melMass/comfy_mtb/commit/96a0da9dbd051d1fcf8b332c54ed2d307d8ae0dd))
-- 🧹 use a gettattr fallback ([a344cdc](https://github.com/melMass/comfy_mtb/commit/a344cdcba9823ca1fb0762795068039b1e1cf0ab))
-- 🧹 cleanup js ([64cc4e9](https://github.com/melMass/comfy_mtb/commit/64cc4e9649853023d645245bea1e1ceb11073f01))
-- 🧹 add savedatabundle js part ([edd7c3f](https://github.com/melMass/comfy_mtb/commit/edd7c3f5d075b640e9cdb067ebfe51c42ff61791))
-- 🧹 wip dynamic multitype ([71bfdd6](https://github.com/melMass/comfy_mtb/commit/71bfdd61d731ce15f9bd0bb19d65b5af208d5dcf))
 - 🧹 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))
@@ -329,17 +104,9 @@ Check the notes in the [releases](https://github.com/melMass/comfy_mtb/releases)
 
 ### Wip
 
-- 🚧 curve widget logic fixed ([e312b02](https://github.com/melMass/comfy_mtb/commit/e312b02ad2f8334e87654a20b0114837df229371))
-- 🚧 dump3 ([eedbb4b](https://github.com/melMass/comfy_mtb/commit/eedbb4bc6581bef85c746307fe9d53360ea45bcf))
-- 🚧 dump ([fa23975](https://github.com/melMass/comfy_mtb/commit/fa2397585fff4f54bcf17f0b0e0083c427b34fa8))
-- 🚧 dump ([0d0fb8e](https://github.com/melMass/comfy_mtb/commit/0d0fb8e13a5da54a44a96a04607f7a349f8fdb03))
 - 🚧 add text template node ([af2175a](https://github.com/melMass/comfy_mtb/commit/af2175a1fc0c2fb29ef3493f242fe45ec6fcabac))
 
 ## New Contributors
-* [@haohaocreates](https://github.com/haohaocreates) made their first contribution in [#182](https://github.com/melMass/comfy_mtb/pull/182)
-* [@vxkj1211](https://github.com/vxkj1211) made their first contribution in [#177](https://github.com/melMass/comfy_mtb/pull/177)
-* [@huanggou666](https://github.com/huanggou666) made their first contribution in [#159](https://github.com/melMass/comfy_mtb/pull/159)
-* [@hongminpark](https://github.com/hongminpark) made their first contribution in [#154](https://github.com/melMass/comfy_mtb/pull/154)
 * [@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)
@@ -626,10 +393,7 @@ Check the notes in the [releases](https://github.com/melMass/comfy_mtb/releases)
 
 - 🚀 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.2.0..main
-[0.2.0]: https://github.com/melMass/comfy_mtb/compare/v0.1.6..v0.2.0
-[0.1.6]: https://github.com/melMass/comfy_mtb/compare/v0.1.5..v0.1.6
-[0.1.5]: https://github.com/melMass/comfy_mtb/compare/v0.1.4..v0.1.5
+[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

CODE_OF_CONDUCT.md

@@ -1,52 +0,0 @@
-# Code of Conduct
-
-## Our Commitment
-
-We are committed to creating a welcoming and inclusive community for everyone. We believe that a diverse and respectful community is essential for fostering creativity and innovation. We expect all members of our community to adhere to this Code of Conduct.
-
-## Our Expectations
-
-This Code of Conduct applies to all interactions within the mtb community, including:
-
-*   Public communication channels (e.g., GitHub issues, pull requests, discussions, social media)
-*   Private communication channels (e.g., direct messages, email)
-*   In-person events (if any)
-
-We expect all members to:
-
-*   **Be respectful and considerate:** Treat others with kindness and empathy.
-*   **Be inclusive:** Welcome and respect people of all backgrounds, identities, and experiences.
-*   **Be constructive:** Focus on providing helpful and positive feedback.
-*   **Be mindful of your language:** Avoid using offensive, discriminatory, or harassing language.
-*   **Respect privacy:** Do not share personal information without consent.
-
-## Unacceptable Behavior
-
-The following behaviors are not tolerated:
-
-*   Offensive, discriminatory, or harassing language or conduct
-*   Personal attacks or insults
-*   Spamming or trolling
-*   Sharing of malicious or inappropriate content
-*   Disrupting the community or hindering collaboration
-*   Violating the privacy of others
-
-## Reporting Violations
-
-If you experience or witness a violation of this Code of Conduct, please report it to @melmass.  All reports will be treated confidentially and investigated promptly.
-
-## Enforcement
-
-Violations of this Code of Conduct may result in the following actions:
-
-*   Warning
-*   Removal from the community
-*   Ban from the community
-
-## License
-[![Contributor Covenant](https://img.shields.io/badge/Contributor%20Covenant-2.1-4baaaa.svg)](code_of_conduct.md)
-
-## Contact
-
-If you have any questions or concerns about this Code of Conduct, please contact @melmass.
-

CONTRIBUTING.md

@@ -1,62 +0,0 @@
-# Contributing to mtb
-
-Thank you for your interest in contributing to mtb!  We appreciate your help in making this project better.  This document outlines how you can contribute to the project.
-
-## Project Overview
-
-This project is a collection of custom nodes for ComfyUI, tailored specifically for animation workflows. It aims to provide a streamlined and user-friendly experience for creating animations within the ComfyUI environment.
-
-## Ways to Contribute
-
-We welcome all kinds of contributions! Here's how you can get involved:
-
-*   **Bug Reports:**  If you encounter any issues, please create a new issue on GitHub.  Please include clear steps to reproduce the bug, along with any relevant error messages, workflows or screenshots.
-*   **Feature Requests:**  Have an idea for a new node or feature?  Create a new issue to discuss it!  Please describe the feature in detail, and explain how it would benefit the project.
-*   **Documentation Improvements:**  Help us improve the documentation by fixing errors, adding examples, or clarifying explanations.
-*   **Code Contributions:**  We welcome contributions to the codebase!  Please see the "Development Setup" and "File Structure" sections below for more information.
-*   **Testing:**  Help us ensure the stability and reliability of the project by testing new features and bug fixes.
-*   **Refactoring:**  Help us improve the codebase by refactoring existing code to improve readability, maintainability, and performance.
-
-## Development Setup
-
-```sh
-git clone --recursive https://github.com/melmass/comfy_mtb
-```
-
-## File Structure
-
-Understanding the project structure is crucial for making effective contributions.
-
-*   **`./nodes/*.py`:** This directory contains the definitions for all custom nodes. Nodes are automatically registered when a file defines an array named `__nodes__` containing the node classes.  Make sure your node follows the ComfyUI node definition structure.
-*   **`./web/*.js`:** This directory contains all the frontend JavaScript code for the extension's user interface.
-*   **`./wiki`:** This directory is a Git submodule that contains the project's Wiki documentation, written in Markdown.  Node documentation should be created or updated in the corresponding Markdown files within this submodule. This is then referenced by the UI for in-GUI help
-
-## Coding Style
-
-We use **Ruff** for code formatting to ensure consistency.  Please run Ruff on your code before submitting a pull request.  No specific configuration is required, so the default Ruff settings will be used.
-
-## Contribution Workflow
-
-1.  **Create a Branch:** Create a new branch for your feature or fix.  Use a descriptive branch name (e.g., `feature/new-node`, `fix/bug-in-ui`). **Do not fork the main branch directly.**
-2.  **Make Changes:** Implement your changes in your branch.
-3.  **Run Tests:** (Add instructions on how to run tests if available.)
-4.  **Format Code:** Run Ruff on your code to ensure it is properly formatted.
-5.  **Create a Pull Request:** Submit a pull request to the `main` branch.  Please provide a clear and concise description of your changes.
-
-## Code of Conduct
-
-We are committed to creating a welcoming and inclusive community.  We expect all contributors to adhere to a respectful and professional code of conduct. (Consider adding a link to a CODE_OF_CONDUCT.md file or a standard code of conduct.)
-
-## Tools and Libraries
-
-*   **Python:** The primary programming language for this project.
-*   **ComfyUI:** The underlying framework for the custom nodes.
-
-## Current Focus
-
-We are currently focused on a major refactor to clean up the project's codebase. Contributions related to this effort are particularly welcome!
-
-## Thank You!
-
-Thank you for considering contributing to mtb! Your contributions are greatly appreciated.  We look forward to reviewing your pull requests!
-

__init__.py

@@ -3,11 +3,11 @@
 # File: __init__.py
 # Project: comfy_mtb
 # Author: Mel Massadian
-# Copyright (c) 2023-2025 Mel Massadian
+# Copyright (c) 2023 Mel Massadian
 #
 ###
 
-__version__ = "0.5.0"
+__version__ = "0.2.0"
 
 import os
 
@@ -31,19 +31,9 @@ from importlib import reload
 from pathlib import Path
 
 from aiohttp import web
-
-IN_COMFY = False
-
-try:
-    from server import PromptServer
-
-    IN_COMFY = True
-except ModuleNotFoundError:
-    IN_COMFY = False
-
+from server import PromptServer
 
 from .endpoint import endlog
-from .install import get_node_dependencies
 from .log import blue_text, cyan_text, get_label, get_summary, log
 from .utils import comfy_dir, here
 
@@ -240,7 +230,7 @@ if failed:
 # - ENDPOINT
 
 
-if IN_COMFY and hasattr(PromptServer, "instance"):
+if hasattr(PromptServer, "instance"):
     img_cache = None
     prompt_cache = None
 
@@ -250,7 +240,16 @@ if IN_COMFY and hasattr(PromptServer, "instance"):
         img_cache = TTLCache(maxsize=100, ttl=5)  # 1 min TTL
         prompt_cache = TTLCache(maxsize=100, ttl=5)  # 1 min TTL
 
-    node_dependency_mapping = get_node_dependencies()
+    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()
@@ -473,26 +472,6 @@ if IN_COMFY and hasattr(PromptServer, "instance"):
         if not os.path.isfile(file):
             return web.Response(status=404)
 
-        ret_workflow = request.rel_url.query.get("workflow")
-
-        if ret_workflow:
-            image = Image.open(file)
-            prompt = image.info.get("prompt", "")
-            workflow = image.info.get("workflow", "")
-
-            if workflow:
-                workflow = json.loads(workflow)
-
-            if prompt:
-                prompt = json.loads(prompt)
-
-            return web.json_response(
-                {
-                    "prompt": prompt,
-                    "workflow": workflow,
-                }
-            )
-
         preview_info = None
         if "preview" in request.rel_url.query:
             preview_params = request.rel_url.query["preview"].split(";")

endpoint.py

@@ -1,21 +1,21 @@
 import csv
 import secrets
 import sys
-import urllib.parse
 from pathlib import Path
 from typing import Any, Literal
 
-import folder_paths
 from aiohttp import web
 
-from .install import get_node_dependencies
 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,
@@ -24,10 +24,96 @@ from .utils import (
 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 ACTIONS_installDependency(dependency_names: list[str] | None = None):
+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"}
@@ -35,14 +121,6 @@ def ACTIONS_installDependency(dependency_names: list[str] | None = None):
     endlog.debug(f"Received Install Dependency request for {dependency_names}")
     # reqs = []
     resolved_names = [reqs_map.get(name, name) for name in dependency_names]
-    allowed_deps = list(
-        {d for dep in get_node_dependencies().values() for d in dep}
-    )
-    for dep in dependency_names:
-        if dep not in allowed_deps:
-            return {
-                "error": f"Unknown dependency: {dep}, you can only use this endpoint to install {allowed_deps}"
-            }
     try:
         run_command(
             [Path(sys.executable), "-m", "pip", "install"] + resolved_names
@@ -67,75 +145,19 @@ def ACTIONS_installDependency(dependency_names: list[str] | None = None):
     #             break
 
 
-def ACTIONS_getUserImageFolders():
-    input_dir = Path(folder_paths.get_input_directory())
-    output_dir = Path(folder_paths.get_output_directory())
-
-    input_subdirs = [x.name for x in input_dir.iterdir() if x.is_dir()]
-    output_subdirs = [x.name for x in output_dir.iterdir() if x.is_dir()]
-
-    return {"input": input_subdirs, "output": output_subdirs}
-
-
-def ACTIONS_getUserVideos(
-    size=256, count=200, offset=0, sort: str | None = None
-):
-    count = count or 1000
-    video_extensions = ["webm", "mp4", "mkv", "mov"]
-    entries = {}
-    patterns = build_glob_patterns(video_extensions)
-    input_dir = Path(folder_paths.get_input_directory())
-    entries = glob_multiple(input_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)
-
-    videos = {
-        video.name: (
-            f"/view?force_rate=0&frame_load_cap=0&skip_first_frames=0&select_every_nth=1&filename={urllib.parse.quote_plus(video.name)}&type=input&format=video&force_size={size}x?"
-        )
-        for i, video in enumerate(entries)
-        if offset <= i < offset + count
-    }
-    return videos
-
-
 def ACTIONS_getUserImages(
     mode: Literal["input", "output"],
-    count=1000,
+    count=200,
     offset=0,
     sort: str | None = None,
     include_subfolders: bool = False,
-    subfolder=None,
 ):
     # enabled = "MTB_EXPOSE" in os.environ
     # if not enabled:
     #     return {"error": "Session not authorized to getInputs"}
 
     imgs = {}
-    count = count or 1000
-
-    input_dir = Path(folder_paths.get_input_directory())
-    output_dir = Path(folder_paths.get_output_directory())
-
     entry_dir = input_dir if mode == "input" else output_dir
-    if subfolder:
-        entry_dir = entry_dir / subfolder
-
-        if not entry_dir.exists():
-            return {
-                "error": f"Subfolder {entry_dir.name} doesn't exists in {entry_dir.parent.as_posix()}"
-            }
     supported = ["png", "jpg", "jpeg", "webp", "gif"]
 
     entries = {}
@@ -157,7 +179,7 @@ def ACTIONS_getUserImages(
 
     imgs = {
         img.name: (
-            f"/mtb/view?filename={img.name}&width=512&type={mode}&subfolder={subfolder or ''}"
+            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)}"
         )
@@ -380,7 +402,7 @@ def add_split_pane(
     """
 
 
-def add_dropdown(title: str, options: list[str]):
+def add_dropdown(title, options):
     option_str = "\n".join(
         [f"<option value='{opt}'>{opt}</option>" for opt in options]
     )
@@ -403,7 +425,7 @@ def render_table(table_dict: dict[str, Any], sort=True, title=None):
             if "dependencies" in item:
                 table_rows += f"<tr><td>{name}</td><td>"
                 table_rows += (
-                    f"{dependencies_button(name, item['dependencies'])}"
+                    f"{dependencies_button(name,item['dependencies'])}"
                 )
 
                 table_rows += "</td></tr>"

env.nu

@@ -1,6 +1,84 @@
 # NOTE: This file is only use for development you can ignore it
 
-use private/log.nu
+
+# 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 {
@@ -23,56 +101,12 @@ export def "comfy dev-web" [] {
     npm run dev
 }
 
-export def "daily run"  [] {
-  let res = (comfy update --rebase)
-  comfy update --clean
-  comfy update_extensions
-
-  daily commit $res.from $res.to
-}
-
-def short-date [] {
-  format date "%Y-%m-%d"
-}
-
-# was daily run today?
-export def "daily was-run" [] {
-
-  let daily = ($env.COMFY_MTB | path join daily.nuon)
-
-  if ($daily | path exists) {
-    let last = (open $daily | sort-by date | get date  | last | short-date)
-    let today = (date now | short-date)
-    return ($last == $today)
-  }
-  return false
-}
-
-export def "daily commit"  [from:string, to:string] {
-  let daily = ($env.COMFY_MTB | path join daily.nuon)
-  let commit = [{date: (date now) from:$from to:$to}]
-
-  let dailies = (if ($daily | path exists) {
-    open $daily | append $commit
-  } else {
-      $commit
-  })
-
-  $dailies | save -f $daily
-  log success "Commited daily check"
-}
 
 # start the comfy server
-export def "comfy start" [--clean,--old-ui, --listen, --skip-daily(-s)] {
-  if (not (daily was-run)) and not $skip_daily {
-      log info "Running daily checks"
-      daily run
-    }
+export def "comfy start" [--clean,--old-ui, --listen] {
+
     let root = get_root --clean=($clean)
     cd $root
-
-    log info "Running Server"
-
     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 {[]})
 }
 
@@ -81,93 +115,75 @@ export def "comfy update" [
     --clean # ??
     --rebase # Rebase instead of merge
 ] {
-  let root = get_root --clean=$clean
+    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)"
 
-  let models = $"($root)/models"
-  let inputs = $"($root)/input"
-
-  cd $root
-
-  let branch_name = (git rev-parse --abbrev-ref HEAD | str trim)
-  let current_commit = (git rev-parse HEAD | str trim)
-
-  log info "Backing up and removing models symlinks"
-
-  # preparing root for pull
-  if not $clean {
-    git checkout pyproject.toml
-    cd $models
-    # find and store all symlinks
-    let links = (ls -la |
-      where not ($it.target | is-empty) |
-      select name target |
-      sort-by name)
+    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 }
+            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
     }
-  } else {
-    # just remove symlinks
-    rm $models
-    rm $inputs
-  }
 
-  cd $root
+    cd $root
 
-  log info $"Checking out to master"
-  git checkout master
+    print $"(ansi yellow_italic)Checking out to master(ansi reset)"
+    git checkout master
 
-  log info "Fetching and pulling remote updates"
-  if ($clean) {
-    # from the local base repo master
-    git fetch local master # $branch_name # master
-    git pull local master # $branch_name # master
-  } else {
-    git fetch
-    git pull
-  }
+    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
+    }
 
-  let new_commit = (git rev-parse HEAD | str trim)
 
-  log info $"Back to our branch \(($branch_name)\)"
-  git checkout -
+    print $"(ansi yellow_italic)Back to our branch \(($branch_name)\)(ansi reset)"
+    git checkout -
 
-  if $current_commit == $new_commit {
-    log warn "No changes upstream"
-  } else {
     if $rebase {
-      log info "Rebasing changes"
-      git rebase master
+        print $"(ansi yellow_italic)Rebasing changes(ansi reset)"
+        git rebase master
 
     } else {
-      log info "Merging changes"
-      git merge master
+        print $"(ansi yellow_italic)Merging changes(ansi reset)"
+        git merge master
     }
-  }
 
-  log info "Linking back the models"
+    print $"(ansi yellow_italic)Linking back the models(ansi reset)"
 
-  if not $clean {
-    rm pyproject.toml
-    cp pyproject-mel.toml pyproject.toml
-    cd $models
+    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
+    }
 
-    # 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)")
 
-  let commit_count = (git rev-list --count $branch_name $"^origin/($branch_name)")
 
-  log success $"Update successful \(($commit_count) new commits\)"
-
-  return {from:$current_commit to:$new_commit}
+    print $"(ansi green_bold)Update successful \(($commit_count) new commits\)(ansi reset)"
 
 
 }
@@ -182,11 +198,11 @@ export def "comfy toggle_extensions" [--clean] {
         return
     }
 
-    log info "Choices" $choices
+    print $choices
 
     let filtered = $choices | wrap name | upsert enabled {|p| not ($p.name | str ends-with ".disabled")}
 
-    log info "Filtered" $filtered
+    print $filtered
     $filtered | each {|f|
         let new_name = ($f.name | str replace ".disabled" "")
 
@@ -195,7 +211,7 @@ export def "comfy toggle_extensions" [--clean] {
         } else {
             $new_name
         }
-        log info $"Moving ($f.name) to ($new_name)"
+        print $"Moving ($f.name) to ($new_name)"
         mv $f.name $new_name
     }
 }
@@ -215,8 +231,7 @@ def --env path-add [pth] {
 
 
 export-env {
-  $env.PYTHONUTF8 = 1
-  $env.COMFY_MTB = ("." | path expand)
+  $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
@@ -225,12 +240,6 @@ export-env {
   $env.COMFY_CLEAN_ROOT =  ($env.COMFY_ROOT | path dirname | path join ComfyClean)
 
   path-add 'C:/Portable/TensorRT-8.6.0.12/lib'
-
-  if $nu.os-info.family == 'windows' {
-    path-add 'G:\BIN\TensorRT-10.7.0.23\lib'
-    path-add 'G:\BIN\cudnn-windows-x86_64-9.6.0.74_cuda12-archive\bin'
-  }
-
   path-add ($env.CUDA_ROOT | path join bin)
   overlay use ../../.venv/Scripts/activate.nu
 }

install.py

@@ -43,28 +43,10 @@ pip_map = {
     "tb-nightly": "tensorboard",
     "protobuf": "google.protobuf",
     "qrcode[pil]": "qrcode",
-    "requirements-parser": "requirements",
+    "requirements-parser": "requirements"
     # Add more mappings as needed
 }
 
-
-def get_node_dependencies():
-    restore_deps = ["basicsr"]
-    onnx_deps = ["onnxruntime"]
-    swap_deps = ["insightface"] + onnx_deps
-    quant_deps = ["bitsandbytes"]
-    io_deps = ["av"]
-    return {
-        "QrCode": ["qrcode"],
-        "DeepBump": onnx_deps,
-        "FaceSwap": swap_deps,
-        "LoadFaceSwapModel": swap_deps,
-        "LoadFaceAnalysisModel": restore_deps,
-        "Quantize": quant_deps,
-        "SaveGif": io_deps,
-    }
-
-
 # endregion
 
 # region ansi
@@ -142,12 +124,12 @@ def print_formatted(text, *formats, color=None, background=None, **kwargs):
     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)
+    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)
@@ -181,9 +163,7 @@ def run_command(cmd, ignored_lines_start=None):
     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(f"Command failed with return code: {e.returncode}", file=sys.stderr)
         print(e.stderr.strip(), file=sys.stderr)
 
     except KeyboardInterrupt:
@@ -258,7 +238,7 @@ def suppress_std():
 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) as f:
+        with open(init_file, "r") as f:
             tree = ast.parse(f.read())
             for node in ast.walk(tree):
                 if isinstance(node, ast.Assign):
@@ -276,16 +256,13 @@ 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,
-        ):
+        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))
@@ -325,9 +302,7 @@ def import_or_install(requirement, dry=False):
     pip_install_name = pip_name + pip_spec
 
     if not installed:
-        print_formatted(
-            f"Installing package {pip_name}...", "italic", color="yellow"
-        )
+        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}').",
@@ -335,9 +310,7 @@ def import_or_install(requirement, dry=False):
             )
         else:
             try:
-                run_command(
-                    [executable, "-m", "pip", "install", pip_install_name]
-                )
+                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",
@@ -353,9 +326,13 @@ def import_or_install(requirement, dry=False):
 
 def get_github_assets(tag=None):
     if tag:
-        tag_url = f"https://api.github.com/repos/{repo_owner}/{repo_name}/releases/tags/{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"
+        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(
@@ -384,9 +361,7 @@ except ImportError:
 def main():
     if len(sys.argv) == 1:
         print_formatted(
-            "mtb doesn't need an install script anymore.",
-            "italic",
-            color="yellow",
+            "mtb doesn't need an install script anymore.", "italic", color="yellow"
         )
         return
     if all(arg not in ("-p", "--path") for arg in sys.argv):
@@ -409,7 +384,7 @@ def main():
 
     args = parser.parse_args()
 
-    print_formatted(f"Detected environment: {apply_color(mode, 'cyan')}")
+    print_formatted(f"Detected environment: {apply_color(mode,'cyan')}")
 
     if args.path:
         clone_dir = Path(args.path)
@@ -422,12 +397,8 @@ def main():
         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]
-                )
+                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..."
@@ -438,14 +409,7 @@ def main():
 
     print_formatted("Checking environment...", "italic", color="yellow")
     missing_deps = []
-    install_cmd = [
-        executable,
-        "-m",
-        "pip",
-        "install",
-        "-r",
-        "requirements.txt",
-    ]
+    install_cmd = [executable, "-m", "pip", "install", "-r", "requirements.txt"]
     run_command(install_cmd)
 
     print_formatted(

log.py

@@ -7,11 +7,15 @@ 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 Formatter(logging.Formatter):
+class ConsoleFormatter(logging.Formatter):
+    """Formatter for console based log, using base ansi colors."""
+
     grey = "\x1b[38;20m"
     cyan = "\x1b[36;20m"
     purple = "\x1b[35;20m"
@@ -19,24 +23,39 @@ class Formatter(logging.Formatter):
     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: purple + format + reset,
-        logging.INFO: cyan + 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: str, level: int = base_log_level):
+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)
 
@@ -45,9 +64,16 @@ def mklog(name: str, level: int = base_log_level):
 
     ch = logging.StreamHandler()
     ch.setLevel(level)
-    ch.setFormatter(Formatter())
+    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
 

node_list.json

@@ -23,12 +23,20 @@
     "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,
@@ -37,12 +45,14 @@
     "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.",
+    "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",
@@ -55,8 +65,15 @@
     "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",
-    "Vae Decode (mtb)": "Wrapper for the 2 core decoders but also adding the sd seamless hack, taken from: FlyingFireCo/tiled_ksampler"
-}
+    "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/audio.py

@@ -1,42 +1,17 @@
-from typing import Any, TypedDict
+from typing import TypedDict
 
 import torch
 import torchaudio
-from comfy.model_management import get_torch_device
-from huggingface_hub import snapshot_download
-from transformers import (
-    WhisperForConditionalGeneration,
-    WhisperProcessor,
-)
-
-# from transformers import (
-#     AutoFeatureExtractor,
-#     WhisperForConditionalGeneration,
-#     WhisperModel,
-#     WhisperProcessor,
-# )
-from ..log import log
-from ..utils import get_model_path
-
-WHISPER_SAMPLE_RATE = 16000
 
 
-class AudioTensor(TypedDict):
+class AudioDict(TypedDict):
     """Comfy's representation of AUDIO data."""
 
     sample_rate: int
     waveform: torch.Tensor
 
 
-class WhisperData(TypedDict):
-    """Whisper transcription data with timestamps and speaker info."""
-
-    text: str
-    chunks: list[dict[str, Any]]
-    language: str
-
-
-AudioData = AudioTensor | list[AudioTensor]
+AudioData = AudioDict | list[AudioDict]
 
 
 class MtbAudio:
@@ -53,14 +28,10 @@ class MtbAudio:
             return audios["waveform"].shape[1] == 2
 
     @staticmethod
-    def resample(audio: AudioTensor, common_sample_rate: int) -> AudioTensor:
-        current_rate = audio["sample_rate"]
-        if current_rate != common_sample_rate:
-            log.debug(
-                f"Resampling audio from {current_rate} to {common_sample_rate}"
-            )
+    def resample(audio: AudioDict, common_sample_rate: int) -> AudioDict:
+        if audio["sample_rate"] != common_sample_rate:
             resampler = torchaudio.transforms.Resample(
-                orig_freq=current_rate, new_freq=common_sample_rate
+                orig_freq=audio["sample_rate"], new_freq=common_sample_rate
             )
             return {
                 "sample_rate": common_sample_rate,
@@ -70,7 +41,7 @@ class MtbAudio:
             return audio
 
     @staticmethod
-    def to_stereo(audio: AudioTensor) -> AudioTensor:
+    def to_stereo(audio: AudioDict) -> AudioDict:
         if audio["waveform"].shape[1] == 1:
             return {
                 "sample_rate": audio["sample_rate"],
@@ -83,8 +54,8 @@ class MtbAudio:
 
     @classmethod
     def preprocess_audios(
-        cls, audios: list[AudioTensor]
-    ) -> tuple[list[AudioTensor], bool, int]:
+        cls, audios: list[AudioDict]
+    ) -> tuple[list[AudioDict], bool, int]:
         max_sample_rate = max([audio["sample_rate"] for audio in audios])
 
         resampled_audios = [
@@ -98,383 +69,6 @@ class MtbAudio:
         return (audios, is_stereo, max_sample_rate)
 
 
-class WhisperPipeline(TypedDict):
-    """Whisper model pipeline."""
-
-    processor: WhisperProcessor
-    model: WhisperForConditionalGeneration
-
-
-class MTB_LoadWhisper:
-    """Load Whisper model and processor."""
-
-    @classmethod
-    def INPUT_TYPES(cls):
-        return {
-            "required": {
-                "model_size": (
-                    [
-                        "tiny",
-                        "small",
-                        "medium",
-                        "medium.en",
-                        "base",
-                        "large",
-                        "large-v2",
-                        "large-v3",
-                        "large-v3-turbo",
-                    ],
-                    {"default": "tiny"},
-                ),
-            },
-            "optional": {
-                "download_missing": (
-                    "BOOLEAN",
-                    {
-                        "default": False,
-                        "tooltip": (
-                            "Download missing models if missing,"
-                            "otherwise they must be in ComfyUI/models/whisper"
-                        ),
-                    },
-                ),
-            },
-        }
-
-    RETURN_TYPES = ("WHISPER_PIPELINE",)
-    RETURN_NAMES = ("pipeline",)
-    CATEGORY = "mtb/audio"
-    FUNCTION = "load"
-
-    def load(self, model_size="tiny", download_missing=False):
-        """Load Whisper model and processor."""
-        whisper_dir = get_model_path("whisper")
-        tag = f"whisper-{model_size}"
-        model_dir = whisper_dir / tag
-
-        if not (whisper_dir.exists() or model_dir.exists()):
-            if not download_missing:
-                raise RuntimeError(
-                    "Models not found and download_missing=False"
-                )
-            else:
-                whisper_dir.mkdir(exist_ok=True)
-                model_dir.mkdir(exist_ok=True)
-
-                snapshot_download(
-                    repo_id=f"openai/{tag}",
-                    resume_download=True,
-                    ignore_patterns=["*.msgpack", "*.bin", "*.h5"],
-                    local_dir=model_dir.as_posix(),
-                    local_dir_use_symlinks=False,
-                )
-
-        device = get_torch_device()
-        log.debug(
-            f"Loading Whisper model {model_size} on {device} from {model_dir}"
-        )
-
-        processor = WhisperProcessor.from_pretrained(model_dir.as_posix())
-        model = WhisperForConditionalGeneration.from_pretrained(
-            model_dir.as_posix()
-        ).to(device)
-
-        model.eval()
-        model.requires_grad_(False)
-
-        return ({"processor": processor, "model": model},)
-
-
-class MTB_AudioToText(MtbAudio):
-    """Transcribe audio to text using Whisper."""
-
-    @classmethod
-    def INPUT_TYPES(cls):
-        return {
-            "required": {
-                "pipeline": ("WHISPER_PIPELINE",),
-                "audio": ("AUDIO",),
-                "language": (
-                    ["auto"]
-                    + sorted(
-                        [
-                            "en",
-                            "fr",
-                            "es",
-                            "de",
-                            "it",
-                            "pt",
-                            "nl",
-                            "ru",
-                            "zh",
-                            "ja",
-                            "ko",
-                        ]
-                    ),
-                    {"default": "auto"},
-                ),
-                "return_timestamps": ("BOOLEAN", {"default": True}),
-            },
-        }
-
-    RETURN_TYPES = ("STRING", "WHISPER_OUTPUT")
-    FUNCTION = "transcribe"
-    CATEGORY = "mtb/audio"
-
-    def transcribe(
-        self,
-        pipeline: WhisperPipeline,
-        audio: AudioTensor,
-        language="auto",
-        return_timestamps=True,
-    ):
-        """Transcribe audio to text using Whisper."""
-        processor = pipeline["processor"]
-        model = pipeline["model"]
-        device = model.device
-
-        audio = self.resample(audio, WHISPER_SAMPLE_RATE)
-
-        waveform = audio["waveform"]
-        log.debug(f"Processed waveform shape: {waveform.shape}")
-
-        # - Mono: [1, 1, samples] or [1, samples] or [samples]
-        # - Stereo: [1, 2, samples] or [2, samples] or [samples, 2]
-        if len(waveform.shape) == 3:
-            waveform = waveform.squeeze(0)
-
-        if len(waveform.shape) == 2:
-            if waveform.shape[0] == 2:  # [channels, samples]
-                waveform = waveform.mean(dim=0)
-            elif waveform.shape[1] == 2:  # [samples, channels]
-                waveform = waveform.mean(dim=1)
-            else:  # mono
-                waveform = waveform.squeeze(0)
-
-        sample_rate = audio["sample_rate"]
-        chunk_duration = 30
-        chunk_samples = chunk_duration * sample_rate
-        total_samples = waveform.shape[-1]
-        total_duration = total_samples / sample_rate
-
-        log.debug(f"Audio duration: {total_duration:.2f}s")
-
-        all_tokens = []
-        all_text = []
-        chunk_offsets = []
-
-        last_time = 0.0
-        accumulated_offset = 0.0
-
-        for chunk_start in range(0, total_samples, chunk_samples):
-            chunk_end = min(chunk_start + chunk_samples, total_samples)
-            chunk_waveform = waveform[chunk_start:chunk_end]
-            chunk_offset = chunk_start / sample_rate
-            chunk_offsets.append(chunk_offset)
-
-            log.debug(
-                f"Processing chunk {chunk_offset:.1f}s - {chunk_end / sample_rate:.1f}s"
-            )
-
-            max_length = model.config.max_length or 448
-            attention_mask = torch.ones((1, max_length))
-
-            input_features = processor(
-                chunk_waveform,
-                sampling_rate=sample_rate,
-                return_tensors="pt",
-            ).input_features.to(device)
-
-            with torch.no_grad():
-                predicted_ids = model.generate(
-                    input_features,
-                    attention_mask=attention_mask.to(device),
-                    task="transcribe",
-                    language=None if language == "auto" else language,
-                    return_timestamps=return_timestamps,
-                    no_repeat_ngram_size=3,
-                    num_beams=5,
-                    length_penalty=1.0,
-                    max_length=max_length,
-                )
-
-            chunk_tokens = processor.tokenizer.convert_ids_to_tokens(
-                predicted_ids[0]
-            )
-
-            adjusted_tokens = []
-            for token in chunk_tokens:
-                if token.startswith("<|") and token.endswith("|>"):
-                    try:
-                        time_str = token[2:-2]
-                        if time_str.replace(".", "").isdigit():
-                            time_val = float(time_str)
-
-                            # If this timestamp is less than the last one, we've started a new sequence
-                            if time_val < last_time:
-                                accumulated_offset += last_time
-
-                            adjusted_time = time_val + accumulated_offset
-                            adjusted_tokens.append(f"<|{adjusted_time:.2f}|>")
-                            last_time = time_val
-                        else:
-                            adjusted_tokens.append(token)
-                    except ValueError:
-                        adjusted_tokens.append(token)
-                else:
-                    adjusted_tokens.append(token)
-
-            all_tokens.extend(adjusted_tokens)
-            chunk_text = processor.batch_decode(
-                predicted_ids, skip_special_tokens=True
-            )[0]
-            all_text.append(chunk_text)
-
-        detected_language = "en"
-        if language == "auto":
-            try:
-                log.debug("Detecting language")
-                with torch.no_grad():
-                    first_chunk_features = processor(
-                        waveform[:chunk_samples],
-                        sampling_rate=sample_rate,
-                        return_tensors="pt",
-                    ).input_features.to(device)
-
-                    predicted_probs = model.detect_language(
-                        first_chunk_features
-                    )[0]
-                    language_token = processor.tokenizer.convert_ids_to_tokens(
-                        predicted_probs.argmax(-1).item()
-                    )
-                    detected_language = (
-                        language_token[2:-2]
-                        if language_token.startswith("<|")
-                        else "en"
-                    )
-                    log.debug(f"Detected language: {detected_language}")
-
-            except Exception as e:
-                log.warning(f"Language detection failed: {e}")
-
-        full_transcription = " ".join(all_text)
-
-        whisper_output = {
-            "text": full_transcription,
-            "language": detected_language,
-            "tokens": all_tokens,
-            "audio": audio,
-            "chunk_offsets": chunk_offsets,
-        }
-
-        return full_transcription, whisper_output
-
-
-class MTB_ProcessWhisperOutput:
-    """Process Whisper output into timestamped chunks."""
-
-    @classmethod
-    def INPUT_TYPES(cls):
-        return {
-            "required": {
-                "whisper_output": ("WHISPER_OUTPUT",),
-                "min_chunk_length": (
-                    "FLOAT",
-                    {"default": 0.0, "min": 0.0, "max": 10.0, "step": 0.1},
-                ),
-            },
-        }
-
-    RETURN_TYPES = ("STRING", "WHISPER_CHUNKS")
-    FUNCTION = "process"
-    CATEGORY = "mtb/audio"
-
-    def process(self, whisper_output, min_chunk_length=0.0):
-        """Process Whisper output into timestamped chunks."""
-        tokens = whisper_output["tokens"]
-        audio = whisper_output["audio"]
-        timestamp_tokens = []
-
-        audio_duration = audio["waveform"].shape[-1] / audio["sample_rate"]
-        log.debug(f"Audio duration: {audio_duration:.2f}s")
-
-        for i, token in enumerate(tokens):
-            if token.startswith("<|") and token.endswith("|>"):
-                try:
-                    time_str = token[2:-2]
-                    if time_str.replace(".", "").isdigit():
-                        time_val = float(time_str)
-                        if 0 <= time_val <= audio_duration:
-                            timestamp_tokens.append((i, time_val))
-                            log.debug(f"Token {i}: {time_val}")
-                except ValueError:
-                    continue
-
-        chunks = []
-        if len(timestamp_tokens) > 1:
-            for i in range(len(timestamp_tokens) - 1):
-                start_pos, start_time = timestamp_tokens[i]
-                end_pos, end_time = timestamp_tokens[i + 1]
-
-                if end_time - start_time < min_chunk_length:
-                    continue
-
-                chunk_tokens = tokens[start_pos + 1 : end_pos]
-                text = " ".join(
-                    t
-                    for t in chunk_tokens
-                    if not (t.startswith("<|") and t.endswith("|>"))
-                )
-
-                if text.strip():
-                    chunks.append(
-                        {
-                            "text": text.strip(),
-                            "timestamp": [start_time, end_time],
-                        }
-                    )
-
-        if timestamp_tokens:
-            start_pos, start_time = timestamp_tokens[-1]
-            if start_pos < len(tokens) - 1:
-                text = " ".join(
-                    t
-                    for t in tokens[start_pos + 1 :]
-                    if not (t.startswith("<|") and t.endswith("|>"))
-                )
-                if text.strip():
-                    if chunks:
-                        prev_chunk = chunks[-1]
-                        prev_duration = (
-                            prev_chunk["timestamp"][1]
-                            - prev_chunk["timestamp"][0]
-                        )
-                        end_time = min(
-                            start_time + prev_duration, audio_duration
-                        )
-                    else:
-                        end_time = audio_duration
-
-                    if (
-                        end_time > start_time
-                        and end_time - start_time >= min_chunk_length
-                    ):
-                        chunks.append(
-                            {
-                                "text": text.strip(),
-                                "timestamp": [start_time, end_time],
-                            }
-                        )
-
-        result = {
-            "text": whisper_output["text"],
-            "chunks": chunks,
-            "language": whisper_output["language"],
-        }
-
-        return whisper_output["text"], result
-
-
 class MTB_AudioCut(MtbAudio):
     """Basic audio cutter, values are in ms."""
 
@@ -504,7 +98,7 @@ class MTB_AudioCut(MtbAudio):
     CATEGORY = "mtb/audio"
     FUNCTION = "cut"
 
-    def cut(self, audio: AudioTensor, length: float, offset: float):
+    def cut(self, audio: AudioDict, length: float, offset: float):
         sample_rate = audio["sample_rate"]
         start_idx = int(offset * sample_rate / 1000)
         end_idx = min(
@@ -523,6 +117,7 @@ class MTB_AudioCut(MtbAudio):
 
 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.
@@ -537,7 +132,7 @@ class MTB_AudioStack(MtbAudio):
     CATEGORY = "mtb/audio"
     FUNCTION = "stack"
 
-    def stack(self, **kwargs: AudioTensor) -> tuple[AudioTensor]:
+    def stack(self, **kwargs: AudioDict) -> tuple[AudioDict]:
         audios, is_stereo, max_rate = self.preprocess_audios(
             list(kwargs.values())
         )
@@ -568,6 +163,7 @@ class MTB_AudioStack(MtbAudio):
 
 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.
@@ -591,7 +187,7 @@ class MTB_AudioSequence(MtbAudio):
     CATEGORY = "mtb/audio"
     FUNCTION = "sequence"
 
-    def sequence(self, silence_duration: float, **kwargs: AudioTensor):
+    def sequence(self, silence_duration: float, **kwargs: AudioDict):
         audios, is_stereo, max_rate = self.preprocess_audios(
             list(kwargs.values())
         )
@@ -636,287 +232,4 @@ class MTB_AudioSequence(MtbAudio):
         )
 
 
-class MTB_AudioResample(MtbAudio):
-    """Resample audio to a different sample rate."""
-
-    @classmethod
-    def INPUT_TYPES(cls):
-        return {
-            "required": {
-                "audio": ("AUDIO",),
-                "sample_rate": (
-                    "INT",
-                    {
-                        "default": 16000,
-                        "min": 1000,
-                        "max": 192000,
-                        "step": 100,
-                        "tooltip": "Target sample rate in Hz. Whisper requires 16000.",
-                    },
-                ),
-            }
-        }
-
-    RETURN_TYPES = ("AUDIO",)
-    RETURN_NAMES = ("resampled_audio",)
-    CATEGORY = "mtb/audio"
-    FUNCTION = "resample_audio"
-
-    def resample_audio(
-        self, audio: AudioTensor, sample_rate: int
-    ) -> tuple[AudioTensor]:
-        resampled = self.resample(audio, sample_rate)
-        return (resampled,)
-
-
-class MTB_AudioIsolateSpeaker(MtbAudio):
-    """Isolate or mute specific speakers using WhisperData"""
-
-    @classmethod
-    def INPUT_TYPES(cls):
-        return {
-            "required": {
-                "audio": ("AUDIO",),
-                "whisper_data": ("WHISPER_CHUNKS",),
-                "target_speaker": ("STRING", {"default": "SPEAKER_00"}),
-                "mode": (["isolate", "mute"], {"default": "isolate"}),
-                "fade_ms": (
-                    "FLOAT",
-                    {
-                        "default": 100.0,
-                        "min": 0.0,
-                        "max": 1000.0,
-                        "step": 10,
-                        "tooltip": "Fade duration in milliseconds to avoid clicks",
-                    },
-                ),
-            },
-        }
-
-    RETURN_TYPES = ("AUDIO",)
-    RETURN_NAMES = ("processed_audio",)
-    CATEGORY = "mtb/audio"
-    FUNCTION = "process_audio"
-
-    def process_audio(
-        self,
-        audio: AudioTensor,
-        whisper_data: WhisperData,
-        target_speaker: str,
-        mode: str = "isolate",
-        fade_ms: float = 100.0,
-    ) -> tuple[AudioTensor]:
-        fade_samples = int((fade_ms / 1000.0) * audio["sample_rate"])
-
-        mask = (
-            torch.zeros_like(audio["waveform"])
-            if mode == "isolate"
-            else torch.ones_like(audio["waveform"])
-        )
-
-        for chunk in whisper_data["chunks"]:
-            if not chunk.get("speaker"):
-                continue
-
-            speaker_present = target_speaker in chunk["speaker"]
-            if (mode == "isolate" and speaker_present) or (
-                mode == "mute" and not speaker_present
-            ):
-                start_sample = int(
-                    chunk["timestamp"][0] * audio["sample_rate"]
-                )
-                end_sample = int(chunk["timestamp"][1] * audio["sample_rate"])
-
-                mask[:, start_sample:end_sample] = 1.0
-
-        if fade_samples > 0:
-            fade = torch.linspace(0, 1, fade_samples)
-
-            transitions = torch.where(mask[0, 1:] != mask[0, :-1])[0] + 1
-
-            for trans_idx in transitions:
-                if (
-                    trans_idx >= fade_samples
-                    and trans_idx <= mask.shape[1] - fade_samples
-                ):
-                    if mask[0, trans_idx] == 1:
-                        mask[:, trans_idx : trans_idx + fade_samples] *= fade
-                    else:
-                        mask[:, trans_idx - fade_samples : trans_idx] *= (
-                            fade.flip(0)
-                        )
-
-        processed_waveform = audio["waveform"] * mask
-
-        return (
-            {
-                "sample_rate": audio["sample_rate"],
-                "waveform": processed_waveform,
-            },
-        )
-
-
-class MTB_ProcessWhisperDiarization:
-    """Process Whisper chunks with speaker diarization using either pyannote or NeMo."""
-
-    @classmethod
-    def INPUT_TYPES(cls):
-        return {
-            "required": {
-                "whisper_chunks": ("WHISPER_CHUNKS",),
-                "audio": ("AUDIO",),
-                "backend": (["pyannote", "nemo"], {"default": "pyannote"}),
-                "num_speakers": (
-                    "INT",
-                    {"default": 2, "min": 1, "max": 10, "step": 1},
-                ),
-            },
-            "optional": {
-                "device": (["cuda", "cpu"], {"default": "cuda"}),
-            },
-        }
-
-    RETURN_TYPES = ("WHISPER_CHUNKS",)
-    FUNCTION = "process"
-    CATEGORY = "mtb/audio"
-
-    def process_pyannote(self, audio, num_speakers, device):
-        """Process audio using pyannote backend."""
-        try:
-            from pyannote.audio import Pipeline
-            from pyannote.audio.pipelines.utils.hook import ProgressHook
-        except ImportError:
-            raise ImportError(
-                "pyannote.audio not found. Install with: pip install pyannote.audio"
-            )
-
-        pipeline = Pipeline.from_pretrained(
-            "pyannote/speaker-diarization-3.1", use_auth_token=None
-        )
-        pipeline.to(torch.device(device))
-        with ProgressHook() as hook:
-            diarization = pipeline(
-                {
-                    "waveform": audio["waveform"][0],
-                    "sample_rate": audio["sample_rate"],
-                },
-                num_speakers=num_speakers,
-                hook=hook,
-            )
-
-        speaker_segments = []
-        for turn, _, speaker in diarization.itertracks(yield_label=True):
-            speaker_segments.append(
-                {
-                    "start": turn.start,
-                    "end": turn.end,
-                    "speaker": speaker,
-                }
-            )
-
-        return speaker_segments
-
-    def process_nemo(self, audio, num_speakers, device):
-        """Process audio using NeMo backend."""
-        try:
-            import nemo.collections.asr as nemo_asr
-        except ImportError:
-            raise ImportError(
-                "NeMo not found. Install with: pip install nemo_toolkit[asr]"
-            )
-
-        model = nemo_asr.models.ClusteringDiarizer.from_pretrained(
-            "nvidia/speakerverification_en_titanet_large"
-        ).to(device)
-
-        diarization = model.diarize(
-            audio=audio["waveform"][0],
-            sample_rate=audio["sample_rate"],
-            num_speakers=num_speakers,
-        )
-
-        speaker_segments = []
-        for segment in diarization:
-            speaker_segments.append(
-                {
-                    "start": segment["start"],
-                    "end": segment["end"],
-                    "speaker": f"SPEAKER_{segment['speaker']}",
-                }
-            )
-
-        return speaker_segments
-
-    def process(
-        self,
-        whisper_chunks,
-        audio,
-        backend="pyannote",
-        num_speakers=2,
-        device="cuda",
-    ):
-        if backend == "pyannote":
-            speaker_segments = self.process_pyannote(
-                audio, num_speakers, device
-            )
-        else:  # nemo
-            speaker_segments = self.process_nemo(audio, num_speakers, device)
-
-        for chunk in whisper_chunks["chunks"]:
-            chunk_start, chunk_end = chunk["timestamp"]
-            chunk_speakers = set()
-            for segment in speaker_segments:
-                if (
-                    segment["start"] <= chunk_end
-                    and segment["end"] >= chunk_start
-                ):
-                    chunk_speakers.add(segment["speaker"])
-
-            if chunk_speakers:
-                chunk["speaker"] = list(chunk_speakers)[0]
-            else:
-                chunk["speaker"] = "unknown"
-
-        return (whisper_chunks,)
-
-
-class MTB_AudioDuration:
-    """Get audio duration in milliseconds."""
-
-    @classmethod
-    def INPUT_TYPES(cls):
-        return {
-            "required": {
-                "audio": ("AUDIO",),
-            },
-        }
-
-    RETURN_TYPES = ("INT",)
-    RETURN_NAMES = ("duration_ms",)
-    FUNCTION = "get_duration"
-    CATEGORY = "mtb/audio"
-
-    def get_duration(self, audio):
-        waveform = audio["waveform"]
-        sample_rate = audio["sample_rate"]
-
-        duration_ms = int((waveform.shape[-1] / sample_rate) * 1000)
-        log.debug(
-            f"Audio duration: {duration_ms}ms ({duration_ms / 1000:.2f}s)"
-        )
-
-        return (duration_ms,)
-
-
-__nodes__ = [
-    MTB_AudioSequence,
-    MTB_AudioStack,
-    MTB_AudioCut,
-    MTB_AudioResample,
-    MTB_AudioIsolateSpeaker,
-    MTB_LoadWhisper,
-    MTB_AudioToText,
-    MTB_ProcessWhisperOutput,
-    MTB_ProcessWhisperDiarization,
-    MTB_AudioDuration,
-]
+__nodes__ = [MTB_AudioSequence, MTB_AudioStack, MTB_AudioCut]

nodes/batch.py

@@ -1,18 +1,13 @@
-import os
-import random
 from io import BytesIO
-from pathlib import Path
-from typing import Literal
+from typing import List, Literal, Optional, Tuple, Union
 
-import comfy.utils
 import cv2
-import folder_paths
 import numpy as np
 import torch
 from PIL import Image
 
 from ..log import log
-from ..utils import EASINGS, apply_easing, glob_multiple, pil2tensor
+from ..utils import EASINGS, apply_easing, hex_to_rgb, pil2tensor
 from .transform import MTB_TransformImage
 
 
@@ -52,7 +47,7 @@ class MTB_BatchFloatMath:
         for v in vals:
             if len(v) != ref_count:
                 raise ValueError(
-                    f"All values must have the same length (current: {len(v)}, ref: {ref_count})"
+                    f"All values must have the same length (current: {len(v)}, ref: {ref_count}"
                 )
 
         match operation:
@@ -175,124 +170,6 @@ class MTB_BatchTimeWrap:
         return (warped_tensor, interpolated_curve)
 
 
-class MTB_ImageBatchToSublist:
-    """
-    # Image Batch To Sublist 🔄
-
-    Splits a large batched tensor into smaller sub-batches for memory-efficient processing.
-    """
-
-    @classmethod
-    def INPUT_TYPES(cls):
-        return {
-            "required": {
-                "sub_batch_size": (
-                    "INT",
-                    {"default": 1, "min": 1, "max": 1000, "step": 1},
-                ),
-            },
-            "optional": {
-                "image": ("IMAGE",),
-                "mask": ("MASK",),
-            },
-        }
-
-    RETURN_TYPES = ("IMAGE", "MASK", "INT")
-    RETURN_NAMES = ("image_list", "mask_list", "item_count")
-
-    OUTPUT_IS_LIST = (True, True)
-    FUNCTION = "split_batch"
-    CATEGORY = "batch_processing"
-
-    def split_batch(
-        self,
-        sub_batch_size: int,
-        image: torch.Tensor | None = None,
-        mask: torch.Tensor | None = None,
-    ):
-        if image is None and mask is None:
-            raise ValueError(
-                "You must either pass mask or image, none received"
-            )
-
-        image_count = 0
-        if image is not None:
-            image_count = image.size(0)
-
-        mask_count = 0
-        if mask is not None:
-            mask_count = mask.size(0)
-
-        if image_count > 0 and mask_count > 0 and mask_count != image_count:
-            raise ValueError(
-                f"When providing image and mask, batch size must match (got {mask.size(0)} mask and {image.size(0)} images)"
-            )
-
-        batch_size = max(image_count, mask_count)
-
-        num_full_batches = batch_size // sub_batch_size
-        im_batches = []
-        mask_batches = []
-
-        for i in range(num_full_batches):
-            start_idx = i * sub_batch_size
-            end_idx = start_idx + sub_batch_size
-            if image_count > 0:
-                im_batches.append(image[start_idx:end_idx, ...])
-
-            if mask_count > 0:
-                mask_batches.append(mask[start_idx:end_idx, ...])
-
-        if batch_size % sub_batch_size != 0:
-            remaining_start = num_full_batches * sub_batch_size
-            if image_count > 0:
-                im_batches.append(image[remaining_start:, ...])
-
-            if mask_count > 0:
-                mask_batches.append(mask[remaining_start:, ...])
-
-        return (im_batches, mask_batches, len(im_batches))
-
-
-class MTB_SublistToImageBatch:
-    @classmethod
-    def INPUT_TYPES(cls):
-        return {
-            "required": {
-                "tensors": ("IMAGE",),
-            }
-        }
-
-    INPUT_IS_LIST = True
-    RETURN_TYPES = ("IMAGE",)
-    FUNCTION = "merge_batches"
-    CATEGORY = "batch_processing"
-    DOCUMENTATION = """# Sublist to Image Batch 🔄
-
-Merges a list of sub-batched tensors back into a single large batch.
-"""
-
-    def merge_batches(self, tensors: list[torch.Tensor]):
-        if len(tensors) <= 1:
-            return (tensors[0],)
-
-        result = tensors[0]
-
-        for next_tensor in tensors[1:]:
-            if result.shape[1:] != next_tensor.shape[1:]:
-                next_tensor = comfy.utils.common_upscale(
-                    next_tensor.movedim(-1, 1),
-                    result.shape[2],
-                    result.shape[1],
-                    "lanczos",
-                    "center",
-                ).movedim(1, -1)
-
-            result = torch.cat((result, next_tensor), dim=0)
-
-        return (result,)
-
-
 class MTB_BatchMake:
     """Simply duplicates the input frame as a batch"""
 
@@ -302,22 +179,18 @@ class MTB_BatchMake:
             "required": {
                 "image": ("IMAGE",),
                 "count": ("INT", {"default": 1}),
-            },
-            "optional": {"mask": ("MASK",)},
+            }
         }
 
     RETURN_TYPES = ("IMAGE",)
     FUNCTION = "generate_batch"
     CATEGORY = "mtb/batch"
 
-    def generate_batch(self, image: torch.Tensor, count, mask=None):
+    def generate_batch(self, image: torch.Tensor, count):
         if len(image.shape) == 3:
             image = image.unsqueeze(0)
 
-        return (
-            image.repeat(count, 1, 1, 1),
-            mask.repeat(count, 1, 1) if mask else mask,
-        )
+        return (image.repeat(count, 1, 1, 1),)
 
 
 class MTB_BatchShape:
@@ -371,7 +244,7 @@ class MTB_BatchShape:
         bg_color = hex_to_rgb(bg_color)
         shade_color = hex_to_rgb(shade_color)
         res = []
-        for x in range(count):
+        for _x in range(count):
             # Initialize an image canvas
             canvas = np.full(
                 (image_height, image_width, 3), bg_color, dtype=np.uint8
@@ -387,7 +260,7 @@ class MTB_BatchShape:
                 bottom_right = (center[0] + half_size, center[1] + half_size)
                 cv2.rectangle(mask, top_left, bottom_right, 255, -1)
             elif shape == "Circle":
-                cv2.circle(mask, center, shape_size // 2, 255, -1)
+                cv2.circle(mask, center, shape_size // 2, 255, -1)  # type: ignore
             elif shape == "Diamond":
                 pts = np.array(
                     [
@@ -397,7 +270,7 @@ class MTB_BatchShape:
                         [center[0] - shape_size // 2, center[1]],
                     ]
                 )
-                cv2.fillPoly(mask, [pts], 255)
+                cv2.fillPoly(mask, [pts], 255)  # type: ignore
 
             elif shape == "Tube":
                 cv2.ellipse(
@@ -502,14 +375,8 @@ class MTB_BatchFloat:
                     {"default": "Steps"},
                 ),
                 "count": ("INT", {"default": 2}),
-                "min": (
-                    "FLOAT",
-                    {"default": 0.0, "min": -1e4, "max": 1e4, "step": 0.001},
-                ),
-                "max": (
-                    "FLOAT",
-                    {"default": 1.0, "min": -1e4, "max": 1e4, "step": 0.001},
-                ),
+                "min": ("FLOAT", {"default": 0.0, "step": 0.001}),
+                "max": ("FLOAT", {"default": 1.0, "step": 0.001}),
                 "easing": (
                     [
                         "Linear",
@@ -546,7 +413,7 @@ class MTB_BatchFloat:
 
     def set_floats(
         self,
-        mode: Literal["Steps"] | Literal["Single"] = "Steps",
+        mode: Union[Literal["Steps"], Literal["Single"]] = "Steps",
         count: int = 1,
         min: float = 0.0,  # noqa: A002
         max: float = 1.0,  # noqa: A002
@@ -570,210 +437,6 @@ class MTB_BatchFloat:
         return (keyframes,)
 
 
-class MTB_BatchSequencePlus:
-    """Sequences multiple image batches with transition effects."""
-
-    @classmethod
-    def INPUT_TYPES(cls):
-        return {
-            "required": {
-                "transition": (
-                    [
-                        "none",
-                        "crossfade",
-                        "slide_left",
-                        "slide_right",
-                        "slide_up",
-                        "slide_down",
-                        "wipe_left",
-                        "wipe_right",
-                        "wipe_up",
-                        "wipe_down",
-                        "band_wipe_h",
-                        "band_wipe_v",
-                    ],
-                    {"default": "none"},
-                ),
-                "overlap_frames": (
-                    "INT",
-                    {"default": 0, "min": 0, "max": 120, "step": 1},
-                ),
-                "reverse": ("BOOLEAN", {"default": False}),
-            }
-        }
-
-    RETURN_TYPES = ("IMAGE",)
-    FUNCTION = "sequence_batches"
-    CATEGORY = "mtb/batch"
-
-    def apply_transition(
-        self,
-        frame1: torch.Tensor,
-        frame2: torch.Tensor,
-        transition: str,
-        progress: float,
-    ):
-        """Apply transition effect between two frames."""
-        if transition == "none":
-            return frame1 if progress < 0.5 else frame2
-
-        elif transition == "crossfade":
-            return frame1 * (1 - progress) + frame2 * progress
-
-        elif transition.startswith("slide_"):
-            h, w = frame1.shape[1:3]
-            if transition == "slide_left":
-                offset = int(w * progress)
-                frame2 = torch.roll(frame2, shifts=-offset, dims=2)
-            elif transition == "slide_right":
-                offset = int(w * progress)
-                frame2 = torch.roll(frame2, shifts=offset, dims=2)
-            elif transition == "slide_up":
-                offset = int(h * progress)
-                frame2 = torch.roll(frame2, shifts=-offset, dims=1)
-            elif transition == "slide_down":
-                offset = int(h * progress)
-                frame2 = torch.roll(frame2, shifts=offset, dims=1)
-            return frame1 * (1 - progress) + frame2 * progress
-
-        elif transition.startswith("wipe_"):
-            h, w = frame1.shape[1:3]
-            mask = torch.zeros_like(frame1)
-            if transition == "wipe_left":
-                edge = int(w * progress)
-                mask[:, :, :edge, :] = 1
-            elif transition == "wipe_right":
-                edge = int(w * (1 - progress))
-                mask[:, :, edge:, :] = 1
-            elif transition == "wipe_up":
-                edge = int(h * progress)
-                mask[:, :edge, :, :] = 1
-            elif transition == "wipe_down":
-                edge = int(h * (1 - progress))
-                mask[:, edge:, :, :] = 1
-            return frame1 * (1 - mask) + frame2 * mask
-
-        elif transition.startswith("band_wipe_"):
-            h, w = frame1.shape[1:3]
-            mask = torch.zeros_like(frame1)
-            num_bands = 10  # Number of bands
-
-            if transition == "band_wipe_h":
-                band_width = w / num_bands
-                for i in range(num_bands):
-                    edge = int((w * progress) - (i * band_width))
-                    start = int(i * band_width)
-                    end = int(min(start + edge, (i + 1) * band_width))
-                    if end > start:
-                        mask[:, :, start:end, :] = 1
-            else:  # band_wipe_v
-                band_height = h / num_bands
-                for i in range(num_bands):
-                    edge = int((h * progress) - (i * band_height))
-                    start = int(i * band_height)
-                    end = int(min(start + edge, (i + 1) * band_height))
-                    if end > start:
-                        mask[:, start:end, :, :] = 1
-
-            return frame1 * (1 - mask) + frame2 * mask
-
-        return frame1
-
-    def sequence_batches(
-        self, transition: str, overlap_frames: int, reverse: bool, **kwargs
-    ):
-        images: list[torch.Tensor] = list(kwargs.values())
-
-        if reverse:
-            images = images[::-1]
-
-        processed_images: list[torch.Tensor] = []
-        for img in images:
-            if len(img.shape) == 3:
-                img = img.unsqueeze(0)
-            processed_images.append(img)
-
-        if overlap_frames == 0 or transition == "none":
-            return (torch.cat(processed_images, dim=0),)
-
-        result_frames: list[torch.Tensor] = []
-
-        if len(processed_images) > 0:
-            result_frames.extend(
-                list(processed_images[0][: -overlap_frames // 2])
-            )
-
-        for i in range(1, len(processed_images)):
-            prev_batch = processed_images[i - 1]
-            curr_batch = processed_images[i]
-
-            prev_frames = min(overlap_frames // 2, len(prev_batch))
-            next_frames = min(overlap_frames // 2, len(curr_batch))
-            total_overlap = prev_frames + next_frames
-
-            if total_overlap < 2:
-                # when not enough frames for transition, just concatenate
-                result_frames.extend(list(prev_batch[-prev_frames:]))
-                result_frames.extend(list(curr_batch[:next_frames]))
-                continue
-
-            for t in range(total_overlap):
-                progress = t / (total_overlap - 1)
-
-                prev_idx = (
-                    len(prev_batch) - prev_frames + min(t, prev_frames - 1)
-                )
-                next_idx = max(0, t - prev_frames)
-
-                transition_frame = self.apply_transition(
-                    prev_batch[prev_idx : prev_idx + 1],
-                    curr_batch[next_idx : next_idx + 1],
-                    transition,
-                    progress,
-                )
-                result_frames.append(transition_frame[0])
-
-            if i < len(processed_images) - 1:
-                result_frames.extend(
-                    list(curr_batch[next_frames : -overlap_frames // 2])
-                )
-            else:
-                result_frames.extend(list(curr_batch[next_frames:]))
-
-        result = torch.stack(result_frames, dim=0)
-
-        return (result,)
-
-
-class MTB_BatchSequence:
-    """Sequences multiple image batches one after another"""
-
-    @classmethod
-    def INPUT_TYPES(cls):
-        return {
-            "required": {
-                "reverse": ("BOOLEAN", {"default": False}),
-            }
-        }
-
-    RETURN_TYPES = ("IMAGE",)
-    FUNCTION = "sequence_batches"
-    CATEGORY = "mtb/batch"
-
-    def sequence_batches(self, reverse: bool, **kwargs):
-        images = list(kwargs.values())
-        if reverse:
-            images = images[::-1]
-
-        processed = []
-        for img in images:
-            if len(img.shape) == 3:
-                img = img.unsqueeze(0)
-            processed.append(img)
-
-        return (torch.cat(processed, dim=0),)
-
-
 class MTB_BatchMerge:
     """Merges multiple image batches with different frame counts"""
 
@@ -850,13 +513,6 @@ class MTB_Batch2dTransform:
                 "zoom": ("FLOATS",),
                 "angle": ("FLOATS",),
                 "shear": ("FLOATS",),
-                "use_normalized": (
-                    "BOOLEAN",
-                    {
-                        "default": False,
-                        "tooltip": "If true, transform values will be scaled to image dimensions.",
-                    },
-                ),
             },
         }
 
@@ -879,13 +535,12 @@ class MTB_Batch2dTransform:
         self,
         image: torch.Tensor,
         border_handling: str,
-        constant_color: str,
-        x: list[float] | None = None,
-        y: list[float] | None = None,
-        zoom: list[float] | None = None,
-        angle: list[float] | None = None,
-        shear: list[float] | None = None,
-        use_normalized: bool = False,
+        constant_color: tuple,
+        x: Optional[List[float]] = None,
+        y=None,
+        zoom=None,
+        angle=None,
+        shear=None,
     ):
         if all(
             self.get_num_elements(param) <= 0
@@ -921,7 +576,8 @@ class MTB_Batch2dTransform:
             count = len(values)
             if count > 0 and count != image.shape[0]:
                 raise ValueError(
-                    f"Length of {name} values ({count}) must match number of images ({image.shape[0]})"
+                    f"Length of {name} values ({count}) must \
+                        match number of images ({image.shape[0]})"
                 )
             if count == 0:
                 keyframes[name] = [default_vals[name]] * image.shape[0]
@@ -930,14 +586,13 @@ class MTB_Batch2dTransform:
         res = [
             transformer.transform(
                 image[i].unsqueeze(0),
-                keyframes["x"][i],
-                keyframes["y"][i],
-                keyframes["zoom"][i],
-                keyframes["angle"][i],
-                keyframes["shear"][i],
+                keyframes["x"][i],  # type: ignore
+                keyframes["y"][i],  # type: ignore
+                keyframes["zoom"][i],  # type: ignore
+                keyframes["angle"][i],  # type: ignore
+                keyframes["shear"][i],  # type: ignore
                 border_handling,
                 constant_color,
-                use_normalized=use_normalized,
             )[0]
             for i in range(image.shape[0])
         ]
@@ -1043,7 +698,7 @@ class MTB_PlotBatchFloat:
 
         fig, ax = plt.subplots(figsize=(width / 100, height / 100), dpi=100)
         fig.set_edgecolor("black")
-        fig.patch.set_facecolor("#2e2e2e")
+        fig.patch.set_facecolor("#2e2e2e")  # type: ignore
         # Setting background color and grid
         ax.set_facecolor("#2e2e2e")  # Dark gray background
         ax.grid(color="gray", linestyle="-", linewidth=0.5, alpha=0.5)
@@ -1065,9 +720,7 @@ class MTB_PlotBatchFloat:
         ax.set_xlim(1, max_length)  # Set X-axis limits
         np.random.seed(seed)
         colors = np.random.rand(len(kwargs), 3)  # Generate random RGB values
-        for color, (label, values) in zip(
-            colors, kwargs.items(), strict=False
-        ):
+        for color, (label, values) in zip(colors, kwargs.items()):
             ax.plot(x_values[: len(values)], values, label=label, color=color)
         ax.legend(
             title="Legend",
@@ -1138,10 +791,7 @@ class MTB_PlotBatchFloat:
         error = int(dx / 2.0)
         y = y1
         ystep = None
-        if y1 < y2:
-            ystep = 1
-        else:
-            ystep = -1
+        ystep = 1 if y1 < y2 else -1
         for x in range(x1, x2 + 1):
             coord = (y, x) if is_steep else (x, y)
             image[coord] = color
@@ -1154,7 +804,8 @@ class MTB_PlotBatchFloat:
             image[(x2, y2)] = color
 
 
-DEFAULT_INTERPOLANT = lambda t: t * t * t * (t * (t * 6 - 15) + 10)
+def _DEFAULT_INTERPOLANT(t):
+    return t * t * t * (t * (t * 6 - 15) + 10)
 
 
 class MTB_BatchShake:
@@ -1188,37 +839,40 @@ class MTB_BatchShake:
     ):
         """Generate a 2D numpy array of perlin noise.
 
-        Args:
-            shape: The shape of the generated array (tuple of two ints).
+        Args
+        ----
+
+        - shape: The shape of the generated array (tuple of two ints).
                 This must be a multple of res.
-            res: The number of periods of noise to generate along each
+        - res: The number of periods of noise to generate along each
                 axis (tuple of two ints). Note shape must be a multiple of
                 res.
-            tileable: If the noise should be tileable along each axis
-                (tuple of two bools). Defaults to (False, False).
-            interpolant: The interpolation function, defaults to
+        - tileable: If the noise should be tileable along each axis
+               (tuple of two bools). Defaults to (False, False).
+        - interpolant: The interpolation function, defaults to
                 t*t*t*(t*(t*6 - 15) + 10).
 
         Returns
         -------
-            A numpy array of shape shape with the generated noise.
+        A numpy array of shape shape with the generated noise.
+
 
         Raises
         ------
-            ValueError: If shape is not a multiple of res.
+        ValueError: If shape is not a multiple of res.
         """
-        interpolant = interpolant or DEFAULT_INTERPOLANT
+        interpolant = interpolant or _DEFAULT_INTERPOLANT
         delta = (res[0] / shape[0], res[1] / shape[1])
         d = (shape[0] // res[0], shape[1] // res[1])
         grid = (
-            np.mgrid[0 : res[0] : delta[0], 0 : res[1] : delta[1]].transpose(
+            np.mgrid[0 : res[0] : delta[0], 0 : res[1] : delta[1]].transpose(  # type: ignore
                 1, 2, 0
             )
             % 1
         )
         # Gradients
         angles = 2 * np.pi * np.random.rand(res[0] + 1, res[1] + 1)
-        gradients = np.dstack((np.cos(angles), np.sin(angles)))
+        gradients = np.dstack((np.cos(angles), np.sin(angles)))  # type: ignore
         if tileable[0]:
             gradients[-1, :] = gradients[0, :]
         if tileable[1]:
@@ -1229,11 +883,12 @@ class MTB_BatchShake:
         g01 = gradients[: -d[0], d[1] :]
         g11 = gradients[d[0] :, d[1] :]
         # Ramps
-        n00 = np.sum(np.dstack((grid[:, :, 0], grid[:, :, 1])) * g00, 2)
-        n10 = np.sum(np.dstack((grid[:, :, 0] - 1, grid[:, :, 1])) * g10, 2)
-        n01 = np.sum(np.dstack((grid[:, :, 0], grid[:, :, 1] - 1)) * g01, 2)
+        n00 = np.sum(np.dstack((grid[:, :, 0], grid[:, :, 1])) * g00, 2)  # type: ignore
+        n10 = np.sum(np.dstack((grid[:, :, 0] - 1, grid[:, :, 1])) * g10, 2)  # type: ignore
+        n01 = np.sum(np.dstack((grid[:, :, 0], grid[:, :, 1] - 1)) * g01, 2)  # type: ignore
         n11 = np.sum(
-            np.dstack((grid[:, :, 0] - 1, grid[:, :, 1] - 1)) * g11, 2
+            np.dstack((grid[:, :, 0] - 1, grid[:, :, 1] - 1)) * g11,  # type: ignore
+            2,
         )
         # Interpolation
         t = interpolant(grid)
@@ -1253,31 +908,32 @@ class MTB_BatchShake:
     ):
         """Generate a 2D numpy array of fractal noise.
 
-        Args:
-            shape: The shape of the generated array (tuple of two ints).
-                This must be a multiple of lacunarity**(octaves-1)*res.
-            res: The number of periods of noise to generate along each
-                axis (tuple of two ints). Note shape must be a multiple of
-                (lacunarity**(octaves-1)*res).
-            octaves: The number of octaves in the noise. Defaults to 1.
-            persistence: The scaling factor between two octaves.
-            lacunarity: The frequency factor between two octaves.
-            tileable: If the noise should be tileable along each axis
-                (tuple of two bools). Defaults to (True,True).
-            interpolant: The, interpolation function, defaults to
-                t*t*t*(t*(t*6 - 15) + 10).
+        Args
+        ----
+        - shape: The shape of the generated array (tuple of two ints).
+            This must be a multiple of lacunarity**(octaves-1)*res.
+        - res: The number of periods of noise to generate along each
+            axis (tuple of two ints). Note shape must be a multiple of
+            (lacunarity**(octaves-1)*res).
+        - octaves: The number of octaves in the noise. Defaults to 1.
+        - persistence: The scaling factor between two octaves.
+        - lacunarity: The frequency factor between two octaves.
+        - tileable: If the noise should be tileable along each axis
+            (tuple of two bools). Defaults to (True,True).
+        - interpolant: The, interpolation function, defaults to
+            t*t*t*(t*(t*6 - 15) + 10).
 
         Returns
         -------
-            A numpy array of fractal noise and of shape shape generated by
-            combining several octaves of perlin noise.
+        A numpy array of fractal noise and of shape shape generated by
+        combining several octaves of perlin noise.
 
         Raises
         ------
-            ValueError: If shape is not a multiple of
-                (lacunarity**(octaves-1)*res).
+        - `ValueError`:
+           If shape is not a multiple of (lacunarity**(octaves-1)*res).
         """
-        interpolant = interpolant or DEFAULT_INTERPOLANT
+        interpolant = interpolant or _DEFAULT_INTERPOLANT
 
         noise = np.zeros(shape)
         frequency = 1
@@ -1294,8 +950,12 @@ class MTB_BatchShake:
         return noise
 
     def fbm(self, x, y, octaves):
-        # noise_2d = self.generate_fractal_noise_2d((256, 256), (8, 8), octaves)
-        # Now, extract a single noise value based on x and y, wrapping indices if necessary
+        # noise_2d = self.generate_fractal_noise_2d(
+        # (256, 256),
+        # (8, 8),
+        # octaves)
+        # Now, extract a single noise value based on x and y,
+        # wrapping indices if necessary
         x_idx = int(x) % 256
         y_idx = int(y) % 256
         return self.noise_pattern[x_idx, y_idx]
@@ -1319,7 +979,8 @@ class MTB_BatchShake:
             (512, 512), (32, 32), (True, True)
         )
 
-        # Assuming frame count is derived from the first dimension of images tensor
+        # Assuming frame count is derived from
+        # the first dimension of images tensor
         frame_count = images.shape[0]
 
         frequency = frequency / frequency_divider
@@ -1343,11 +1004,14 @@ class MTB_BatchShake:
 
             # np_position = np.array(
             #     [
-            #         self.fbm(self.position_offset[0] + frame_num, time, octaves),
-            #         self.fbm(self.position_offset[1] + frame_num, time, octaves),
+            #         self.fbm(self.position_offset[0] +
+            #               frame_num, time, octaves),
+            #         self.fbm(self.position_offset[1] +
+            #               frame_num, time, octaves),
             #     ]
             # )
-            # np_rotation = self.fbm(self.rotation_offset[2] + frame_num, time, octaves)
+            # np_rotation = self.fbm(self.rotation_offset[2] +
+            # frame_num, time, octaves)
 
             rot_idx = (self.rotation_offset[2] + frame_num) % 256
             np_rotation = self.fbm(rot_idx, time, octaves)
@@ -1365,14 +1029,19 @@ class MTB_BatchShake:
         transform = MTB_Batch2dTransform()
 
         log.debug(
-            f"Applying shaking with parameters: \nposition {position_amount_x}, {position_amount_y}\nrotation {rotation_amount}\nfrequency {frequency}\noctaves {octaves}"
+            f"Applying shaking with parameters: \n \
+                position {position_amount_x}, \
+                {position_amount_y}\nrotation {rotation_amount}\n \
+                frequency {frequency}\noctaves {octaves}"
         )
 
         # Apply shaking transformations to images
         shaken_images = transform.transform_batch(
             images,
-            border_handling="edge",  # Assuming edge handling as default
-            constant_color="#000000",  # Assuming black as default constant color
+            # Assuming edge handling as default
+            border_handling="edge",
+            # Assuming black as default constant color
+            constant_color="#000000",  # type: ignore
             x=x_translations,
             y=y_translations,
             angle=rotations,
@@ -1381,163 +1050,18 @@ class MTB_BatchShake:
         return (shaken_images, x_translations, y_translations, rotations)
 
 
-class MTB_BatchFromFolder:
-    """Load images from a folder with options for latest, oldest, or random selection."""
-
-    @classmethod
-    def INPUT_TYPES(cls):
-        return {
-            "required": {
-                "enable": (
-                    "BOOLEAN",
-                    {
-                        "default": True,
-                        "tooltip": "Enable or disable the node. If disabled, returns passthrough_image or an empty tensor.",
-                    },
-                ),
-                "folder_path": (
-                    "STRING",
-                    {
-                        "default": "",
-                        "tooltip": "Path to the folder containing images. Relative paths are resolved to the ComfyUI output directory.",
-                    },
-                ),
-                "mode": (
-                    ["latest", "oldest", "random"],
-                    {
-                        "default": "latest",
-                        "tooltip": "How to select images: latest, oldest, or random.",
-                    },
-                ),
-                "count": (
-                    "INT",
-                    {
-                        "default": 10,
-                        "min": 1,
-                        "max": 1000,
-                        "tooltip": "Number of images to load from the folder.",
-                    },
-                ),
-                "filter": (
-                    "STRING",
-                    {
-                        "default": "*",
-                        "tooltip": "Glob filter for image filenames (e.g. *.png).",
-                    },
-                ),
-            },
-            "optional": {
-                "passthrough_image": (
-                    "IMAGE",
-                    {
-                        "tooltip": "If provided and node is disabled, this image is passed through instead of returning an empty tensor."
-                    },
-                ),
-            },
-        }
-
-    RETURN_TYPES = ("IMAGE",)
-    RETURN_NAMES = ("images",)
-    CATEGORY = "mtb/batch"
-    FUNCTION = "load_from_folder"
-
-    def load_from_folder(
-        self,
-        enable: bool,
-        folder_path: str,
-        mode: str,
-        count: int,
-        filter: str,
-        passthrough_image=None,
-    ):
-        """Load images from a folder with the specified selection mode."""
-        if not enable:
-            if passthrough_image is not None:
-                log.debug(
-                    "MTB_BatchFromFolder: Using passthrough image (disabled)"
-                )
-                return (passthrough_image,)
-            log.debug(
-                "MTB_BatchFromFolder: Disabled and no passthrough_image provided, returning empty tensor"
-            )
-            return (torch.zeros(0, 0, 0, 3),)
-
-        path_obj = Path(folder_path)
-        if not path_obj.is_absolute():
-            output_dir = Path(folder_paths.get_output_directory())
-            path_obj = output_dir / folder_path
-            path_obj = path_obj.resolve()
-
-        if not path_obj.exists():
-            log.error(f"Folder path does not exist: {path_obj}")
-            return (torch.zeros(0, 0, 0, 3),)
-
-        if not path_obj.is_dir():
-            log.error(f"Path is not a directory: {path_obj}")
-            return (torch.zeros(0, 0, 0, 3),)
-
-        patterns = [filter] if filter else ["*"]
-        files = glob_multiple(path_obj, patterns)
-
-        image_extensions = [".png", ".jpg", ".jpeg", ".bmp", ".webp", ".tiff"]
-        image_files = [
-            f for f in files if f.suffix.lower() in image_extensions
-        ]
-
-        if not image_files:
-            log.warning(
-                f"No image files found in {path_obj} with filter {filter}"
-            )
-            return (torch.zeros(0, 0, 0, 3),)
-
-        if mode == "latest":
-            image_files.sort(key=lambda x: os.path.getmtime(x), reverse=True)
-        elif mode == "oldest":
-            image_files.sort(key=lambda x: os.path.getmtime(x))
-        elif mode == "random":
-            random.shuffle(image_files)
-
-        selected_files = image_files[:count]
-
-        if len(selected_files) < count:
-            log.warning(
-                f"Requested {count} images but only found {len(selected_files)}"
-            )
-
-        loaded_images = []
-        for file_path in selected_files:
-            try:
-                img = Image.open(file_path)
-                if img.mode != "RGB":
-                    img = img.convert("RGB")
-                loaded_images.append(img)
-            except Exception as e:
-                log.error(f"Error loading image {file_path}: {e}")
-
-        if not loaded_images:
-            log.error("Failed to load any images")
-            return (torch.zeros(0, 0, 0, 3),)
-
-        return (pil2tensor(loaded_images),)
-
-
 __nodes__ = [
-    MTB_Batch2dTransform,
     MTB_BatchFloat,
+    MTB_Batch2dTransform,
+    MTB_BatchShape,
+    MTB_BatchMake,
     MTB_BatchFloatAssemble,
     MTB_BatchFloatFill,
+    MTB_BatchFloatNormalize,
+    MTB_BatchMerge,
+    MTB_BatchShake,
+    MTB_PlotBatchFloat,
+    MTB_BatchTimeWrap,
     MTB_BatchFloatFit,
     MTB_BatchFloatMath,
-    MTB_BatchFloatNormalize,
-    MTB_BatchFromFolder,
-    MTB_BatchMake,
-    MTB_BatchMerge,
-    MTB_BatchSequence,
-    MTB_BatchSequencePlus,
-    MTB_BatchShake,
-    MTB_BatchShape,
-    MTB_BatchTimeWrap,
-    MTB_PlotBatchFloat,
-    MTB_SublistToImageBatch,
-    MTB_ImageBatchToSublist,
 ]

nodes/crop.py

@@ -78,17 +78,14 @@ class MTB_UpscaleBboxBy:
         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),
+        )
 
-        center_x = x + width // 2
-        center_y = y + height // 2
-
-        new_width = int(width * scale)
-        new_height = int(height * scale)
-
-        new_x = center_x - new_width // 2
-        new_y = center_y - new_height // 2
-
-        scaled = (new_x, new_y, new_width, new_height)
         return (scaled,)
 
 
@@ -375,62 +372,6 @@ class MTB_Uncrop:
         return (pil2tensor(out_images),)
 
 
-class MTB_BBoxForceDimensions:
-    @classmethod
-    def INPUT_TYPES(cls):
-        return {
-            "required": {
-                "bbox": ("BBOX",),
-                "width": ("INT", {"default": 512, "min": 1, "max": 8192}),
-                "height": ("INT", {"default": 512, "min": 1, "max": 8192}),
-            },
-            "optional": {
-                "image": ("IMAGE",),
-            },
-        }
-
-    CATEGORY = "mtb/crop"
-    RETURN_TYPES = ("BBOX",)
-    FUNCTION = "force_dimensions"
-
-    def force_dimensions(
-        self,
-        bbox: tuple[int, int, int, int],
-        width: int,
-        height: int,
-        image: torch.Tensor = None,
-    ) -> tuple[tuple[int, int, int, int]]:
-        x, y, curr_width, curr_height = bbox
-
-        center_x = x + curr_width // 2
-        center_y = y + curr_height // 2
-
-        new_x = center_x - width // 2
-        new_y = center_y - height // 2
-
-        if image is not None:
-            img_height, img_width = image.shape[1:3]
-            x_overflow = max(0, new_x + width - img_width) + min(0, new_x)
-            y_overflow = max(0, new_y + height - img_height) + min(0, new_y)
-            if width > img_width or height > img_height:
-                x_exceed = width - img_width if width > img_width else 0
-                y_exceed = height - img_height if height > img_height else 0
-                raise ValueError(
-                    f"Target bbox dimensions ({width}x{height}) exceed image bounds ({img_width}x{img_height}) "
-                    f"by {x_exceed}px horizontally and {y_exceed}px vertically"
-                )
-
-            if x_overflow > 0 or x_overflow < 0:
-                new_x -= x_overflow
-
-            if y_overflow > 0:
-                new_y -= y_overflow
-            elif y_overflow < 0:
-                new_y -= y_overflow  # Add the negative overflow
-
-        return ((int(new_x), int(new_y), width, height),)
-
-
 __nodes__ = [
     MTB_BboxFromMask,
     MTB_Bbox,
@@ -438,5 +379,4 @@ __nodes__ = [
     MTB_Uncrop,
     MTB_SplitBbox,
     MTB_UpscaleBboxBy,
-    MTB_BBoxForceDimensions,
 ]

nodes/curve.py

@@ -15,7 +15,7 @@ def serialize_curve(curve):
     return curve
 
 
-class MTB_Curve:
+class MTBCurve:
     """A basic FLOAT_CURVE input node."""
 
     @classmethod
@@ -90,4 +90,4 @@ class MTB_CurveToFloat:
         return (interpolated_y_values, interpolated_y_values)
 
 
-__nodes__ = [MTB_Curve, MTB_CurveToFloat]
+__nodes__ = [MTBCurve, MTB_CurveToFloat]

nodes/debug.py

@@ -2,94 +2,28 @@ 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 tensor2pil
-
-
-def get_detailed_type_info(obj):
-    type_info = []
-
-    type_name = type(obj).__name__
-    type_info.append(f"Type: {type_name}")
-
-    if isinstance(obj, torch.Tensor):
-        type_info.extend(
-            [
-                f"Shape: {obj.shape}",
-                f"Dtype: {obj.dtype}",
-                f"Device: {obj.device}",
-                f"Requires grad: {obj.requires_grad}",
-                f"Stride: {obj.stride()}",
-                f"Contiguous: {obj.is_contiguous()}",
-            ]
-        )
-    elif isinstance(obj, (list, tuple)):
-        type_info.extend(
-            [
-                f"Length: {len(obj)}",
-                f"Container type: {type_name}",
-            ]
-        )
-        if obj:
-            type_info.append(f"Element type: {type(obj[0]).__name__}")
-    elif isinstance(obj, dict):
-        type_info.extend(
-            [
-                f"Length: {len(obj)}",
-                f"Keys: {list(obj.keys())}",
-            ]
-        )
-    elif hasattr(obj, "__dict__"):
-        attributes = [attr for attr in dir(obj) if not attr.startswith("_")]
-        type_info.append(f"Attributes: {attributes}")
-
-    return type_info
+from ..utils import mesh_to_json, tensor2b64
 
 
 # region processors
-def process_tensor(tensor: torch.Tensor, as_type=False):
+def process_tensor(tensor: torch.Tensor):
     log.debug(f"Tensor: {tensor.shape}")
 
-    if as_type:
-        return {
-            "text": [f"Tensor of shape {tensor.shape} of type {tensor.dtype}"]
-        }
-
-    is_mask = len(tensor.shape) == 3
-
-    if is_mask:
-        tensor = tensor.unsqueeze(-1).repeat(1, 1, 1, 3)
-
-    image = tensor2pil(tensor)
-    b64_imgs = []
-    for im in image:
-        if is_mask:
-            im = im.convert("L")
-
-        buffered = io.BytesIO()
-        im.save(buffered, format="PNG")
-        b64_imgs.append(
-            "data:image/png;base64,"
-            + base64.b64encode(buffered.getvalue()).decode("utf-8")
-        )
-
-    return {"b64_images": b64_imgs}
+    return {"b64_images": tensor2b64(tensor)}
 
 
-def process_list(anything, as_type=False):
-    text = []
+def process_list(anything: list[object]) -> dict[str, list[str]]:
+    text: list[str] = []
     if not anything:
         return {"text": []}
 
-    if as_type:
-        type_info = get_detailed_type_info(anything)
-        type_info.extend(get_detailed_type_info(anything[0]))
-        return {"text": type_info}
-
     first_element = anything[0]
     if (
         isinstance(first_element, list)
@@ -98,7 +32,7 @@ def process_list(anything, as_type=False):
     ):
         text.append(
             "List of List of Tensors: "
-            f"{first_element[0].shape} (x{len(anything)})"
+            + f"{first_element[0].shape} (x{len(anything)})"
         )
 
     elif isinstance(first_element, torch.Tensor):
@@ -111,44 +45,40 @@ def process_list(anything, as_type=False):
     return {"text": text}
 
 
-def process_dict(anything, as_type=False):
-    text = []
-    if as_type:
-        return {"text": get_detailed_type_info(anything)}
+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 ""
         )
-        text.append(f"Latent Samples: {anything['samples'].shape} {is_empty}")
-
-    elif "waveform" in anything:
-        is_empty = (
-            "(empty) " if torch.count_nonzero(anything["samples"]) == 0 else ""
-        )
-
-        text.append(
-            f"Audio Samples: {anything['waveform'].shape}{is_empty} | sample rate {anything['sample_rate']}"
-        )
+        res.append(f"Latent Samples: {anything['samples'].shape} {is_empty}")
 
     else:
-        log.debug(f"Unhandled dict: {anything.keys()}")
         text.append(json.dumps(anything, indent=2))
 
     return {"text": text}
 
 
-def process_bool(anything, as_type=False):
+def process_bool(anything: bool) -> dict[str, str]:
     return {"text": ["True" if anything else "False"]}
 
 
-def process_text(anything, as_type=False):
-    if as_type:
-        return {"text": get_detailed_type_info(anything)}
-
+def process_text(anything):
     return {"text": [str(anything)]}
 
 
+# NOT USED ANYMORE
+def process_geometry(anything):
+    return {"geometry": [mesh_to_json(anything)]}
+
+
 # endregion
 
 
@@ -162,7 +92,6 @@ class MTB_Debug:
     def INPUT_TYPES(cls):
         return {
             "required": {"output_to_console": ("BOOLEAN", {"default": False})},
-            "optional": {"as_detailed_types": ("BOOLEAN", {"default": False})},
         }
 
     RETURN_TYPES = ()
@@ -170,25 +99,50 @@ class MTB_Debug:
     CATEGORY = "mtb/debug"
     OUTPUT_NODE = True
 
-    def do_debug(
-        self, output_to_console: bool, as_detailed_types: bool, **kwargs
-    ):
-        output = {"ui": {"items": []}}
+    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 input_name, anything in kwargs.items():
-            processor = processors.get(type(anything), process_text)
+        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)
 
-            processed = processor(anything, as_detailed_types)
+            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."
+            # )
 
-            item = {
-                "input": input_name,
-                **processed,
-            }
-            output["ui"]["items"].append(item)
+        if output_to_console:
+            from rich.console import Console
+
+            cons = Console()
+            cons.print("OUTPUT:")
+            cons.print(output)
 
         return output
 
@@ -224,9 +178,9 @@ class MTB_SaveTensors:
     def save(
         self,
         filename_prefix,
-        image: torch.Tensor | None = None,
-        mask: torch.Tensor | None = None,
-        latent: torch.Tensor | None = None,
+        image: Optional[torch.Tensor] = None,
+        mask: Optional[torch.Tensor] = None,
+        latent: Optional[torch.Tensor] = None,
     ):
         (
             full_output_folder,
@@ -258,11 +212,4 @@ class MTB_SaveTensors:
         return f"{filename_prefix}_{counter:05}"
 
 
-processors = {
-    torch.Tensor: process_tensor,
-    list: process_list,
-    dict: process_dict,
-    bool: process_bool,
-}
-
 __nodes__ = [MTB_Debug, MTB_SaveTensors]

nodes/deep_bump.py

@@ -2,16 +2,13 @@ import tempfile
 from pathlib import Path
 
 import numpy as np
-
-# torch must be imported prior to onnx for the CUDAProvider.
-import torch  # isort:skip
 import onnxruntime as ort
+import torch
 from PIL import Image
 
 from ..errors import ModelNotFound
 from ..log import mklog
 from ..utils import (
-    download_model,
     get_model_path,
     tensor2pil,
     tiles_infer,
@@ -26,12 +23,7 @@ log = mklog(__name__)
 
 # - COLOR to NORMALS
 def color_to_normals(
-    color_img,
-    overlap,
-    progress_callback,
-    *,
-    save_temp=False,
-    auto_download=False,
+    color_img, overlap, progress_callback, *, save_temp=False
 ):
     """Compute a normal map from the given color map.
 
@@ -75,13 +67,7 @@ def color_to_normals(
     log.debug("DeepBump Color → Normals : loading model")
     model = get_model_path("deepbump", "deepbump256.onnx")
     if not model or not model.exists():
-        if not auto_download:
-            raise ModelNotFound(f"deepbump ({model})")
-        log.debug("Downloading models...")
-        download_model(
-            "https://github.com/HugoTini/DeepBump/raw/master/deepbump256.onnx",
-            "deepbump",
-        )
+        raise ModelNotFound(f"deepbump ({model})")
 
     providers = [
         "TensorrtExecutionProvider",
@@ -365,9 +351,6 @@ class MTB_DeepBump:
                 ),
                 "normals_to_height_seamless": ("BOOLEAN", {"default": True}),
             },
-            "optional": {
-                "auto_download": ("BOOLEAN", {"default": True}),
-            },
         }
 
     RETURN_TYPES = ("IMAGE",)
@@ -383,7 +366,6 @@ class MTB_DeepBump:
         color_to_normals_overlap="SMALL",
         normals_to_curvature_blur_radius="SMALL",
         normals_to_height_seamless=True,
-        auto_download=False,
     ):
         images = tensor2pil(image)
         out_images = []
@@ -398,10 +380,7 @@ class MTB_DeepBump:
             # Apply processing
             if mode == "Color to Normals":
                 out_img = color_to_normals(
-                    in_img,
-                    color_to_normals_overlap,
-                    None,
-                    auto_download=auto_download,
+                    in_img, color_to_normals_overlap, None
                 )
             if mode == "Normals to Curvature":
                 out_img = normals_to_curvature(

nodes/faceenhance.py

@@ -39,12 +39,7 @@ class MTB_LoadFaceEnhanceModel:
                 cls._warned = True
             return []
         if not fr_models_path.exists():
-            # log.warning(
-            #     f"No Face Restore checkpoints found at {fr_models_path} (if you've used mtb before these checkpoints were saved in upscale_models before)"
-            # )
-            # log.warning(
-            #     "For now we fallback to upscale_models but this will be removed in a future version"
-            # )
+            # - fallback to upscale_models
             if um_models_path.exists():
                 return [
                     x
@@ -122,7 +117,7 @@ class BGUpscaleWrapper:
         tile = 128 + 64
         overlap = 8
 
-        imgt = np2tensor(img)
+        imgt = pil2tensor(img)
         imgt = imgt.movedim(-1, -3).to(device)
 
         steps = imgt.shape[0] * comfy.utils.get_tiled_scale_steps(
@@ -152,9 +147,6 @@ class BGUpscaleWrapper:
         return (tensor2np(s)[0],)
 
 
-import sys
-
-
 class MTB_RestoreFace:
     """Uses GFPGan to restore faces"""
 
@@ -233,8 +225,8 @@ class MTB_RestoreFace:
                 )
                 output.putalpha(alpha_resized)
             # imwrite(restored_img, save_restore_path)
-
-        return pil2tensor(output)
+            return pil2tensor(output)
+        log.warning("No restored image found")
 
     def restore(
         self,
@@ -259,6 +251,9 @@ class MTB_RestoreFace:
             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):

nodes/filter.py

@@ -1,8 +1,8 @@
 import torch
 
 
-class MTB_FilterZ:
-    """Filters an image based on a depth map"""
+class MTBFilterZ:
+    """Filters an image based on a depth map."""
 
     @classmethod
     def INPUT_TYPES(cls):
@@ -66,4 +66,4 @@ class MTB_FilterZ:
         return (out_img,)
 
 
-__nodes__ = [MTB_FilterZ]
+__nodes__ = [MTBFilterZ]

nodes/generate.py

@@ -1,11 +1,7 @@
-import io
-
-import requests
-import torch
-from PIL import Image, ImageDraw, ImageFont
+from PIL import Image
 
 from ..log import log
-from ..utils import comfy_dir, font_path, pil2tensor
+from ..utils import comfy_dir, create_uv_map_tensor, font_path, pil2tensor
 
 # class MtbExamples:
 #     """MTB Example Images"""
@@ -85,6 +81,10 @@ class MTB_UnsplashImage:
     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:
@@ -193,11 +193,11 @@ by default it fallsback to a default font.
                 ),
                 "color": (
                     "COLOR",
-                    {"default": "black"},
+                    {"default": "#000000"},
                 ),
                 "background": (
                     "COLOR",
-                    {"default": "white"},
+                    {"default": "#FFFFFF"},
                 ),
                 "h_align": (("left", "center", "right"), {"default": "left"}),
                 "v_align": (("top", "center", "bottom"), {"default": "top"}),
@@ -213,90 +213,14 @@ by default it fallsback to a default font.
                     "INT",
                     {"default": 100, "min": 1, "max": 100, "step": 1},
                 ),
-            },
-            "optional": {
-                "whisper_chunks": ("WHISPER_CHUNKS",),
-                "fps": (
-                    "INT",
-                    {"default": 24, "min": 1, "max": 60, "step": 1},
-                ),
-                "fade_duration": (
-                    "FLOAT",
-                    {"default": 0.5, "min": 0.0, "max": 5.0, "step": 0.1},
-                ),
-            },
+            }
         }
 
     RETURN_TYPES = ("IMAGE",)
+    RETURN_NAMES = ("image",)
     FUNCTION = "text_to_image"
     CATEGORY = "mtb/generate"
 
-    def create_animation_frames(
-        self,
-        chunks,
-        base_image,
-        font,
-        font_size,
-        color,
-        width,
-        height,
-        fps,
-        fade_duration,
-    ):
-        """Create animation frames from Whisper chunks."""
-        if not chunks or not chunks.get("chunks"):
-            return [base_image]
-
-        frames = []
-        total_duration = chunks["chunks"][-1]["timestamp"][1]
-        frame_count = int(total_duration * fps)
-        fade_frames = int(fade_duration * fps)
-
-        for frame_idx in range(frame_count):
-            time = frame_idx / fps
-            frame = base_image.copy()
-            draw = ImageDraw.Draw(frame)
-
-            active_chunks = []
-            for chunk in chunks["chunks"]:
-                start, end = chunk["timestamp"]
-                if start <= time <= end:
-                    fade_in_alpha = min(
-                        1.0, (time - start) * fps / fade_frames
-                    )
-                    fade_out_alpha = min(1.0, (end - time) * fps / fade_frames)
-                    alpha = min(fade_in_alpha, fade_out_alpha)
-                    active_chunks.append((chunk["text"], alpha))
-
-            y = height // 4
-            for text, alpha in active_chunks:
-                # Create a temporary image for the text with alpha
-                text_img = Image.new("RGBA", (width, height), (0, 0, 0, 0))
-                text_draw = ImageDraw.Draw(text_img)
-
-                text_draw.text(
-                    (width // 2, y),
-                    text,
-                    font=font,
-                    fill=color,
-                    anchor="mm",
-                )
-
-                text_img.putalpha(
-                    Image.fromarray(
-                        (torch.ones((height, width)) * (alpha * 255))
-                        .byte()
-                        .numpy()
-                    )
-                )
-
-                frame = Image.alpha_composite(frame, text_img)
-                y += font_size * 1.5
-
-            frames.append(frame)
-
-        return frames
-
     def text_to_image(
         self,
         text: str,
@@ -314,125 +238,90 @@ by default it fallsback to a default font.
         h_offset=0,
         v_offset=0,
         h_coverage=100,
-        whisper_chunks=None,
-        fps=24,
-        fade_duration=0.5,
     ):
-        """Convert text to image, with optional animation support."""
         import textwrap
 
-        from PIL import ImageColor
+        from PIL import Image, ImageDraw, ImageFont
 
         font_path = self.fonts[font]
-        font = ImageFont.truetype(font_path, size=font_size)
 
-        try:
-            if isinstance(color, str):
-                color = ImageColor.getrgb(color)
-            if isinstance(background, str):
-                background = ImageColor.getrgb(background)
-
-            if len(color) == 3:
-                color = color + (255,)
-            if len(background) == 3:
-                background = background + (255,)
-        except ValueError as e:
-            log.error(f"Color parsing error: {e}")
-            color = (255, 255, 255, 255)
-            background = (0, 0, 0, 255)
-
-        def render_text(text_to_render, alpha=None):
-            if trim:
-                text_to_render = text_to_render.strip()
-            if wrap:
-                wrap_width = (((width / 100) * h_coverage) / font_size) * 2
-                lines = textwrap.wrap(text_to_render, width=wrap_width)
-            else:
-                lines = [text_to_render]
-
-            img = Image.new("RGBA", (width, height), (0, 0, 0, 0))
-            draw = ImageDraw.Draw(img)
-
-            line_height_px = line_height * font_size
-
-            if v_align == "top":
-                y_text = v_offset
-            elif v_align == "center":
-                y_text = (
-                    (height - (line_height_px * len(lines))) // 2
-                ) + v_offset
-            else:
-                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)
-
-            for line in lines:
-                line_width = get_width(line)
-                if h_align == "left":
-                    x_text = h_offset
-                elif h_align == "center":
-                    x_text = ((width - line_width) // 2) + h_offset
-                else:
-                    x_text = (width - line_width) - h_offset
-
-                text_color = color
-                if alpha is not None:
-                    text_color = tuple(
-                        list(color[:3]) + [int(alpha * color[3])]
-                    )
-
-                draw.text((x_text, y_text), line, fill=text_color, font=font)
-                y_text += line_height_px
-
-            return img
-
-        base_img = Image.new("RGBA", (width, height), background)
-
-        if whisper_chunks and whisper_chunks.get("chunks"):
-            frames = []
-            total_duration = whisper_chunks["chunks"][-1]["timestamp"][1]
-            frame_count = int(total_duration * fps)
-            fade_frames = int(fade_duration * fps)
-
-            for frame_idx in range(frame_count):
-                time = frame_idx / fps
-                frame = base_img.copy()
-
-                active_chunks = []
-                for chunk in whisper_chunks["chunks"]:
-                    start, end = chunk["timestamp"]
-                    if start <= time <= end:
-                        fade_in_alpha = min(
-                            1.0, (time - start) * fps / fade_frames
-                        )
-                        fade_out_alpha = min(
-                            1.0, (end - time) * fps / fade_frames
-                        )
-                        alpha = min(fade_in_alpha, fade_out_alpha)
-                        active_chunks.append((chunk["text"], alpha))
-
-                for chunk_text, alpha in active_chunks:
-                    chunk_img = render_text(
-                        chunk_text.encode("ascii", "ignore").decode(), alpha
-                    )
-                    frame = Image.alpha_composite(frame, chunk_img)
-
-                frames.append(frame)
-
-            frame_tensors = [pil2tensor(frame) for frame in frames]
-            return (torch.cat(frame_tensors, dim=0),)
+        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:
-            text_img = render_text(text)
-            result = Image.alpha_composite(base_img, text_img)
-            return (pil2tensor(result),)
+            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,6 +1,5 @@
 import io
 import json
-import re
 import urllib.parse
 import urllib.request
 from math import pi
@@ -23,8 +22,9 @@ from ..utils import (
 
 
 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 ''}"
+        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()
@@ -32,7 +32,8 @@ def get_image(filename, subfolder, folder_type):
     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:
+
+    with urllib.request.urlopen(url) as response:  # noqa: S310
         return io.BytesIO(response.read())
 
 
@@ -45,22 +46,14 @@ class MTB_ToDevice:
         if torch.backends.mps.is_available():
             devices.append("mps")
         if torch.cuda.is_available():
-            devices.append("cuda:0")
-            for i in range(1, torch.cuda.device_count()):
-                devices.append(f"cuda:{i}")
             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": "cuda"
-                        if torch.cuda.is_available()
-                        else "cpu"
-                    },
-                ),
+                "device": (devices, {"default": "cpu"}),
             },
             "optional": {
                 "image": ("IMAGE",),
@@ -76,36 +69,20 @@ class MTB_ToDevice:
     def to_device(
         self,
         *,
-        ignore_errors: bool = False,
-        device: str = "cuda",
+        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 (
-            device.startswith("cuda")
-            and ":" not in device
-            and device != "cuda"
-        ):
-            device = f"cuda:{device[4:]}"
-
-        try:
-            if image is not None:
-                image = image.to(device)
-            if mask is not None:
-                mask = mask.to(device)
-        except RuntimeError as e:
-            if not ignore_errors:
-                raise RuntimeError(
-                    f"Failed to move tensor to device {device}: {str(e)}"
-                ) from e
-            log.warning(
-                f"Failed to move tensor to device {device}, ignoring: {str(e)}"
+                " 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)
 
 
@@ -394,7 +371,7 @@ class MTB_GetBatchFromHistory:
         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:
+        with urllib.request.urlopen(history_url) as response:  # noqa: S310
             output = self.load_batch_frames(response, offset, count, frames)
 
         if output.size(0) == 0:
@@ -442,37 +419,43 @@ class MTB_AnyToString:
     @classmethod
     def INPUT_TYPES(cls):
         return {
-            "required": {"input": ("*",)},
+            "required": {"input_value": ("*",)},
         }
 
     RETURN_TYPES = ("STRING",)
     FUNCTION = "do_str"
     CATEGORY = "mtb/converters"
 
-    def do_str(self, input):
-        if isinstance(input, str):
-            return (input,)
-        elif isinstance(input, torch.Tensor):
-            return (f"Tensor of shape {input.shape} and dtype {input.dtype}",)
-        elif isinstance(input, Image.Image):
-            return (f"PIL Image of size {input.size} and mode {input.mode}",)
-        elif isinstance(input, np.ndarray):
+    def do_str(self, input_value):
+        if isinstance(input_value, str):
+            return (input_value,)
+        elif isinstance(input_value, torch.Tensor):
             return (
-                f"Numpy array of shape {input.shape} and dtype {input.dtype}",
+                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, dict):
+        elif isinstance(input_value, dict):
             return (
-                f"Dictionary of {len(input)} items, with keys {input.keys()}",
+                f"Dictionary of {len(input_value)} items, with keys {input_value.keys()}",
             )
 
         else:
-            log.debug(f"Falling back to string conversion of {input}")
-            return (str(input),)
+            log.debug(f"Falling back to string conversion of {input_value}")
+            return (str(input_value),)
 
 
 class MTB_StringReplace:
-    """Basic string replacement with regex support."""
+    """Basic string replacement."""
+
+    """Basic string replacement."""
 
     @classmethod
     def INPUT_TYPES(cls):
@@ -481,7 +464,6 @@ class MTB_StringReplace:
                 "string": ("STRING", {"forceInput": True}),
                 "old": ("STRING", {"default": ""}),
                 "new": ("STRING", {"default": ""}),
-                "use_regex": ("BOOLEAN", {"default": False}),
             }
         }
 
@@ -489,19 +471,12 @@ class MTB_StringReplace:
     RETURN_TYPES = ("STRING",)
     CATEGORY = "mtb/string"
 
-    def replace_str(self, string: str, old: str, new: str, use_regex: bool):
+    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}")
-        log.debug(f"Use regex: {use_regex}")
 
-        if use_regex:
-            try:
-                string = re.sub(old, new, string)
-            except re.error as e:
-                raise ValueError(f"Regex error: {e}") from e
-        else:
-            string = string.replace(old, new)
+        string = string.replace(old, new)
 
         log.debug(f"New string: {string}")
 
@@ -509,7 +484,7 @@ class MTB_StringReplace:
 
 
 class MTB_MathExpression:
-    """Node to evaluate a simple math expression string"""
+    """Node to evaluate a simple math expression string."""
 
     @classmethod
     def INPUT_TYPES(cls):
@@ -546,6 +521,14 @@ class MTB_MathExpression:
             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))
 
@@ -589,13 +572,14 @@ class MTB_FitNumber:
 
     def set_range(
         self,
+        *,
         value: float,
         clamp: bool,
-        source_min: float,
-        source_max: float,
-        target_min: float,
-        target_max: float,
-        easing: str,
+        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
@@ -686,187 +670,6 @@ class MTB_ConcatImages:
         return (concatenated,)
 
 
-class MTB_TensorOps:
-    @classmethod
-    def INPUT_TYPES(cls):
-        return {
-            "required": {
-                "tensor": ("IMAGE",),
-                "operation": (
-                    [
-                        "multiply",
-                        "divide",
-                        "add",
-                        "subtract",
-                        "power",
-                        "clamp",
-                        "abs",
-                        "log",
-                        "exp",
-                        "convert_dtype",
-                        "normalize_range",
-                        "normalize_per_channel",
-                    ],
-                    {"default": "multiply"},
-                ),
-                "value": (
-                    "FLOAT",
-                    {
-                        "default": 1.0,
-                        "min": -1000000.0,
-                        "max": 1000000.0,
-                        "step": 0.01,
-                    },
-                ),
-                "source_min": (
-                    "FLOAT",
-                    {
-                        "default": 0.0,
-                        "min": -1000000.0,
-                        "max": 1000000.0,
-                        "step": 0.01,
-                    },
-                ),
-                "source_max": (
-                    "FLOAT",
-                    {
-                        "default": 1.0,
-                        "min": -1000000.0,
-                        "max": 1000000.0,
-                        "step": 0.01,
-                    },
-                ),
-                "target_min": (
-                    "FLOAT",
-                    {
-                        "default": 0.0,
-                        "min": -1000000.0,
-                        "max": 1000000.0,
-                        "step": 0.01,
-                    },
-                ),
-                "target_max": (
-                    "FLOAT",
-                    {
-                        "default": 16.0,
-                        "min": -1000000.0,
-                        "max": 1000000.0,
-                        "step": 0.01,
-                    },
-                ),
-                "dtype": (
-                    ["uint8", "float32", "float16", "bfloat16"],
-                    {"default": "float32"},
-                ),
-                "use_mean": ("BOOLEAN", {"default": False}),
-            },
-            "optional": {
-                "target_tensor": ("IMAGE",),
-            },
-        }
-
-    RETURN_TYPES = ("IMAGE",)
-    FUNCTION = "apply"
-    CATEGORY = "mtb/tensor_ops"
-
-    def apply(
-        self,
-        tensor,
-        operation="multiply",
-        value=1.0,
-        source_min=0.0,
-        source_max=1.0,
-        target_min=0.0,
-        target_max=1.0,
-        dtype="float32",
-        use_mean=False,
-        target_tensor=None,
-    ):
-        log.debug(
-            f"Input tensor stats: shape={tensor.shape}, dtype={tensor.dtype}, range=[{tensor.min().item():.6f}, {tensor.max().item():.6f}]"
-        )
-        if operation == "normalize_per_channel":
-            if target_tensor is None:
-                raise ValueError(
-                    "Target tensor required for per-channel normalization"
-                )
-
-            result = tensor.clone()
-            for c in range(tensor.shape[-1]):
-                if use_mean:
-                    source_mean = tensor[..., c].mean()
-                    target_mean = target_tensor[..., c].mean()
-                    scale = target_mean / source_mean
-                    result[..., c] = tensor[..., c] * scale
-                else:
-                    source_min = tensor[..., c].min()
-                    source_max = tensor[..., c].max()
-                    target_min = target_tensor[..., c].min()
-                    target_max = target_tensor[..., c].max()
-
-                    normalized = (tensor[..., c] - source_min) / (
-                        source_max - source_min
-                    )
-                    result[..., c] = (
-                        normalized * (target_max - target_min) + target_min
-                    )
-
-                log.debug(
-                    f"Channel {c} - Scale: source=[{source_min:.6f}, {source_max:.6f}], target=[{target_min:.6f}, {target_max:.6f}]"
-                )
-
-        elif operation == "normalize_range":
-            if target_tensor is not None:
-                target_min = target_tensor.min().item()
-                target_max = target_tensor.max().item()
-                log.debug(
-                    f"Using target tensor range: [{target_min:.6f}, {target_max:.6f}]"
-                )
-
-            normalized = (tensor - source_min) / (source_max - source_min)
-            result = normalized * (target_max - target_min) + target_min
-        elif operation == "convert_dtype":
-            if dtype == "float32":
-                result = tensor.float()
-            elif dtype == "float16":
-                result = tensor.half()
-            elif dtype == "bfloat16":
-                result = tensor.bfloat16()
-
-        else:
-            result = tensor
-            if operation == "multiply":
-                result = tensor * value
-            elif operation == "divide":
-                result = tensor / value if value != 0 else tensor
-            elif operation == "add":
-                result = tensor + value
-            elif operation == "subtract":
-                result = tensor - value
-            elif operation == "power":
-                result = torch.pow(tensor, value)
-            elif operation == "clamp":
-                if target_tensor is not None:
-                    result = torch.clamp(
-                        tensor,
-                        target_tensor.min().item(),
-                        target_tensor.max().item(),
-                    )
-                else:
-                    result = torch.clamp(tensor, source_min, source_max)
-            elif operation == "abs":
-                result = torch.abs(tensor)
-            elif operation == "log":
-                result = torch.log(tensor.clamp(min=1e-10))
-            elif operation == "exp":
-                result = torch.exp(tensor)
-
-        log.debug(
-            f"Output tensor stats: shape={result.shape}, dtype={result.dtype}, range=[{result.min().item():.6f}, {result.max().item():.6f}]"
-        )
-        return (result,)
-
-
 __nodes__ = [
     MTB_StringReplace,
     MTB_FitNumber,
@@ -881,5 +684,4 @@ __nodes__ = [
     MTB_FloatsToFloat,
     MTB_FloatToFloats,
     MTB_FloatsToInts,
-    MTB_TensorOps,
 ]

nodes/image_interpolation.py

@@ -14,7 +14,7 @@ from ..utils import get_model_path
 
 
 class MTB_LoadFilmModel:
-    """Loads a FILM model
+    """Loads a FILM model.
 
     [DEPRECATED] Use ComfyUI-FrameInterpolation instead
     """
@@ -59,7 +59,7 @@ class MTB_LoadFilmModel:
 
 
 class MTB_FilmInterpolation:
-    """Google Research FILM frame interpolation for large motion
+    """Google Research FILM frame interpolation for large motion.
 
     [DEPRECATED] Use ComfyUI-FrameInterpolation instead
     """
@@ -108,7 +108,9 @@ class MTB_FilmInterpolation:
         pbar = comfy.utils.ProgressBar(num_frames)
 
         for frame in util.interpolate_recursively_from_memory(
-            in_frames, interpolate, film_model
+            in_frames,  # type: ignore
+            interpolate,
+            film_model,
         ):
             out_tensors.append(
                 torch.from_numpy(frame)

nodes/image_processing.py

@@ -3,12 +3,11 @@ import json
 import math
 import os
 
-import comfy.utils
+import comfy.model_management as model_management
 import folder_paths
 import numpy as np
 import torch
 import torch.nn.functional as F
-from comfy import model_management
 from PIL import Image, ImageOps
 from PIL.PngImagePlugin import PngInfo
 from skimage.filters import gaussian
@@ -75,10 +74,7 @@ class MTB_ExtractCoordinatesFromImage:
     def INPUT_TYPES(cls):
         return {
             "required": {
-                "threshold": (
-                    "FLOAT",
-                    {"default": 0.5, "min": 0.0, "max": 1.0, "step": 0.01},
-                ),
+                "threshold": ("FLOAT",),
                 "max_points": ("INT", {"default": 50, "min": 0}),
             },
             "optional": {"image": ("IMAGE",), "mask": ("MASK",)},
@@ -91,124 +87,72 @@ class MTB_ExtractCoordinatesFromImage:
         image: torch.Tensor | None = None,
         mask: torch.Tensor | None = None,
     ) -> tuple[list[list[tuple[int, int]]], torch.Tensor]:
-        if image is None and mask is None:
-            raise ValueError("Must provide either image or mask")
-
         if image is not None:
-            batch_count, height, width, _channel_count = image.shape
-            input_device = image.device
-            if mask is not None:
-                if mask.ndim == 2:
-                    mask = mask.unsqueeze(0)
-                if mask.ndim != 3:
-                    raise ValueError(
-                        f"Mask has unexpected ndim: {mask.ndim}. Expected 2 or 3."
-                    )
-
-                b_mask, h_mask, w_mask = mask.shape
-                if not (h_mask == height and w_mask == width):
-                    raise ValueError(
-                        f"Image dimensions ({height}x{width}) and mask dimensions ({h_mask}x{w_mask}) are spatially incompatible."
-                    )
-                if b_mask == 1 and batch_count > 1:
-                    mask = mask.expand(batch_count, height, width)
-
-                elif b_mask != batch_count:
-                    raise ValueError(
-                        f"Image batch size ({batch_count}) and mask batch size ({b_mask}) are incompatible and mask cannot be broadcast."
-                    )
+            batch_count, height, width, channel_count = image.shape
+            imgs = image
         else:
-            if mask.ndim == 2:
-                mask = mask.unsqueeze(0)
-
-            if mask.ndim != 3:
-                raise ValueError(
-                    f"Mask has unexpected ndim: {mask.ndim} when image is not provided. Expected 2 or 3."
-                )
-
+            if mask is None:
+                raise ValueError("Must provide either image or mask")
             batch_count, height, width = mask.shape
-            input_device = mask.device
+            channel_count = 1
+            imgs = mask
+
+        if channel_count not in [1, 2, 3, 4]:
+            raise ValueError(f"Incorrect channel count: {channel_count}")
 
         all_points: list[list[tuple[int, int]]] = []
         debug_images = torch.zeros(
             (batch_count, height, width, 3),
             dtype=torch.uint8,
-            device=input_device,
+            device=imgs.device,
         )
 
-        points_tensor = torch.tensor(
-            [255, 255, 255], dtype=torch.uint8, device=input_device
-        )
-
-        for i in range(batch_count):
-            value_threshold: torch.Tensor
-            if image is not None:
-                img_slice = image[i]
-                img_channels = img_slice.shape[2]
-                if img_channels == 1 or img_channels == 2:
-                    value_threshold = img_slice[:, :, 0]
-                elif img_channels == 3 or img_channels == 4:
-                    value_threshold = img_slice[:, :, :3].max(dim=2)[0]
-                else:
-                    raise ValueError(
-                        f"Unsupported image channel count: {img_channels} for image at batch index {i}"
-                    )
+        for i, img in enumerate(imgs):
+            if channel_count == 1:
+                alpha_channel = img if len(img.shape) == 2 else img[:, :, 0]
+            elif channel_count == 2:
+                alpha_channel = img[:, :, 1]
+            elif channel_count == 4:
+                alpha_channel = img[:, :, 3]
             else:
-                mask_slice = mask[i]
-                value_threshold = mask_slice
+                # get intensity
+                alpha_channel = img[:, :, :3].max(dim=2)[0]
 
-            condition = value_threshold > threshold
-            if image is not None and mask is not None:
-                mask_slice = mask[i]
-                mask_active_condition = mask_slice > 0.0
-                condition = condition & mask_active_condition
+            points = (alpha_channel > threshold).nonzero(as_tuple=False)
 
-            points_yx = condition.nonzero(as_tuple=False)
+            if len(points) > max_points:
+                indices = torch.randperm(points.size(0), device=img.device)[
+                    :max_points
+                ]
+                points = points[indices]
 
-            if points_yx.size(0) > max_points:
-                # shuffle and pick max_points randomly
-                indices = torch.randperm(
-                    points_yx.size(0), device=input_device
-                )[:max_points]
-                points_yx = points_yx[indices]
-            elif max_points == 0:
-                points_yx = torch.empty(
-                    (0, 2), dtype=torch.long, device=input_device
-                )
+            points = [(int(y.item()), int(x.item())) for x, y in points]
+            all_points.append(points)
 
-            current_points = [
-                (int(p[1].item()), int(p[0].item())) for p in points_yx
-            ]
-            all_points.append(current_points)
-            for x_coord, y_coord in current_points:
-                self._draw_circle(
-                    debug_images[i],
-                    (x_coord, y_coord),
-                    radius=5,
-                    color_tensor=points_tensor,
-                )
+            for x, y in points:
+                self._draw_circle(debug_images[i], (x, y), 5)
 
         return (all_points, debug_images)
 
     @staticmethod
     def _draw_circle(
-        image: torch.Tensor,
-        center: tuple[int, int],
-        radius: int,
-        color_tensor: torch.Tensor,
+        image: torch.Tensor, center: tuple[int, int], radius: int
     ):
         """Draw a 5px circle on the image."""
         x0, y0 = center
-        h, w, _ = image.shape
-        min_x_bbox = max(0, x0 - radius)
-        max_x_bbox = min(w - 1, x0 + radius)
-        min_y_bbox = max(0, y0 - radius)
-        max_y_bbox = min(h - 1, y0 + radius)
-
-        for py in range(min_y_bbox, max_y_bbox + 1):
-            for px in range(min_x_bbox, max_x_bbox + 1):
-                if (px - x0) ** 2 + (py - y0) ** 2 <= radius**2:
-                    image[py, px] = color_tensor
+        for x in range(-radius, radius + 1):
+            for y in range(-radius, radius + 1):
+                in_radius = x**2 + y**2 <= radius**2
+                in_bounds = (
+                    0 <= x0 + x < image.shape[1]
+                    and 0 <= y0 + y < image.shape[0]
+                )
+                if in_radius and in_bounds:
+                    image[y0 + y, x0 + x] = torch.tensor(
+                        [255, 255, 255],
+                        dtype=torch.uint8,
+                        device=image.device,
+                    )
 
 
 class MTB_ColorCorrectGPU:
@@ -599,7 +543,7 @@ class MTB_ColorCorrect:
         adjusted = self.hsv_adjustment(adjusted, hue, saturation, value)
 
         if clamp:
-            adjusted = torch.clamp(adjusted, 0.0, 1.0)
+            adjusted = torch.clamp(image, 0.0, 1.0)
 
         result = (
             adjusted
@@ -758,6 +702,7 @@ class MTB_Blur:
                 )
                 blurred_images.append(blurred)
 
+            image_np = np.array(blurred_images)
         else:
             for i in range(image.size(0)):
                 blurred = gaussian(
@@ -765,7 +710,8 @@ class MTB_Blur:
                 )
                 blurred_images.append(blurred)
 
-        return (np2tensor(blurred_images),)
+            image_np = np.array(blurred_images)
+        return (np2tensor(image_np).squeeze(0),)
 
 
 class MTB_Sharpen:

nodes/image_utils.py

@@ -1,11 +1,4 @@
-import json
-import os
-
-import numpy as np
 import torch
-from comfy.cli_args import args
-from PIL import Image
-from PIL.PngImagePlugin import PngInfo
 
 from ..log import log
 
@@ -15,21 +8,13 @@ class MTB_StackImages:
 
     @classmethod
     def INPUT_TYPES(cls):
-        return {
-            "required": {"vertical": ("BOOLEAN", {"default": False})},
-            "optional": {
-                "match_method": (
-                    ["error", "smallest", "largest"],
-                    {"default": "error"},
-                )
-            },
-        }
+        return {"required": {"vertical": ("BOOLEAN", {"default": False})}}
 
     RETURN_TYPES = ("IMAGE",)
     FUNCTION = "stack"
     CATEGORY = "mtb/image utils"
 
-    def stack(self, vertical, match_method="error", **kwargs):
+    def stack(self, vertical, **kwargs):
         if not kwargs:
             raise ValueError("At least one tensor must be provided.")
 
@@ -39,62 +24,31 @@ class MTB_StackImages:
             f"{'vertically' if vertical else 'horizontally'}"
         )
 
-        target_device = tensors[0].device
-
         normalized_tensors = [
-            self.normalize_to_rgba(tensor.to(target_device))
-            for tensor in 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 match_method != "error":
-            if vertical:
-                # match widths
-                widths = [tensor.shape[2] for tensor in normalized_tensors]
-                target_width = (
-                    min(widths) if match_method == "smallest" else max(widths)
-                )
-                normalized_tensors = [
-                    self.resize_tensor(tensor, width=target_width)
-                    for tensor in normalized_tensors
-                ]
-            else:
-                # match heights
-                heights = [tensor.shape[1] for tensor in normalized_tensors]
-                target_height = (
-                    min(heights)
-                    if match_method == "smallest"
-                    else max(heights)
-                )
-                normalized_tensors = [
-                    self.resize_tensor(tensor, height=target_height)
-                    for tensor in normalized_tensors
-                ]
-        else:
-            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."
-                    )
-            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 = 1 if vertical else 2
+        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)
 
@@ -110,7 +64,7 @@ class MTB_StackImages:
         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(
@@ -133,30 +87,6 @@ class MTB_StackImages:
         else:
             return tensor
 
-    def resize_tensor(self, tensor, width=None, height=None):
-        """Resize tensor to specified width or height while maintaining aspect ratio."""
-        current_height, current_width = tensor.shape[1:3]
-
-        if width is not None and width != current_width:
-            scale_factor = width / current_width
-            new_height = int(current_height * scale_factor)
-            new_width = width
-        elif height is not None and height != current_height:
-            scale_factor = height / current_height
-            new_width = int(current_width * scale_factor)
-            new_height = height
-        else:
-            return tensor
-
-        resized = torch.nn.functional.interpolate(
-            tensor.permute(0, 3, 1, 2),
-            size=(new_height, new_width),
-            mode="bilinear",
-            align_corners=False,
-        )
-
-        return resized.permute(0, 2, 3, 1)
-
 
 class MTB_PickFromBatch:
     """Pick a specific number of images from a batch.
@@ -171,117 +101,30 @@ class MTB_PickFromBatch:
                 "image": ("IMAGE",),
                 "from_direction": (["end", "start"], {"default": "start"}),
                 "count": ("INT", {"default": 1}),
-            },
-            "optional": {
-                "mask": ("MASK",),
-            },
+            }
         }
 
-    RETURN_TYPES = ("IMAGE", "MASK")
+    RETURN_TYPES = ("IMAGE",)
     FUNCTION = "pick_from_batch"
     CATEGORY = "mtb/image utils"
 
-    def pick_from_batch(self, image, from_direction, count, mask=None):
+    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)
-
-        selected_masks = None
+        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:]
-            if mask is not None:
-                selected_masks = mask[-count:]
         else:
             selected_tensors = image[:count]
-            if mask is not None:
-                selected_masks = mask[:count]
 
-        return (selected_tensors, selected_masks)
+        return (selected_tensors,)
 
 
-import folder_paths
-
-
-class MTB_SaveImage:
-    def __init__(self):
-        self.output_dir = folder_paths.get_output_directory()
-        self.type = "output"
-        self.prefix_append = ""
-        self.compress_level = 4
-
-    @classmethod
-    def INPUT_TYPES(cls):
-        return {
-            "required": {
-                "images": ("IMAGE", {"tooltip": "The images to save."}),
-                "filename_prefix": (
-                    "STRING",
-                    {
-                        "default": "ComfyUI",
-                        "tooltip": "The prefix for the file to save. This may include formatting information such as %date:yyyy-MM-dd% or %Empty Latent Image.width% to include values from nodes.",
-                    },
-                ),
-            },
-            "hidden": {"prompt": "PROMPT", "extra_pnginfo": "EXTRA_PNGINFO"},
-        }
-
-    RETURN_TYPES = ("IMAGE",)
-    FUNCTION = "save_images"
-
-    # OUTPUT_NODE = True
-
-    CATEGORY = "mtb/image utils"
-    DESCRIPTION = """Saves the input images to your ComfyUI output directory.
-    This behaves exactly like the native SaveImage node but isn't an output node.
-    The reason I made this is to allow 'inlining' image save in loops for instance,
-    using the native node there wouldn't run for each iteration of the loop."""
-
-    def save_images(
-        self,
-        images,
-        filename_prefix="ComfyUI",
-        prompt=None,
-        extra_pnginfo=None,
-    ):
-        filename_prefix += self.prefix_append
-        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 batch_number, image in enumerate(images):
-            i = 255.0 * image.cpu().numpy()
-            img = Image.fromarray(np.clip(i, 0, 255).astype(np.uint8))
-            metadata = None
-            if not args.disable_metadata:
-                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]))
-
-            filename_with_batch_num = filename.replace(
-                "%batch_num%", str(batch_number)
-            )
-            file = f"{filename_with_batch_num}_{counter:05}_.png"
-            img.save(
-                os.path.join(full_output_folder, file),
-                pnginfo=metadata,
-                compress_level=self.compress_level,
-            )
-            results.append(
-                {"filename": file, "subfolder": subfolder, "type": self.type}
-            )
-            counter += 1
-
-        return {"ui": {"images": results}, "result": (images,)}
-
-
-__nodes__ = [MTB_StackImages, MTB_PickFromBatch, MTB_SaveImage]
+__nodes__ = [MTB_StackImages, MTB_PickFromBatch]

nodes/ltx.py

@@ -42,9 +42,6 @@ class ImageH264Compression:
     DESCRIPTION = """
 **Encodes the input with h264 compression using a configurable CRF**.
 
-> [!IMPORTANT]
-> This node is not really needed with the latest version of LTXVideo.
-
 > [!NOTE]
 > This was recommended by the creators of LTX over banodoco's discord.
 
@@ -154,7 +151,6 @@ class ImageH264Compression:
         output_images = torch.stack(output_images).to(image.device)
         return (output_images,)
 
-
 # fmt: off
 __nodes__ = [
     ImageH264Compression

nodes/transform.py

@@ -45,34 +45,6 @@ class MTB_TransformImage:
                 ),
                 "constant_color": ("COLOR", {"default": "#000000"}),
             },
-            "optional": {
-                "filter_type": (
-                    [
-                        "nearest",
-                        "box",
-                        "bilinear",
-                        "hamming",
-                        "bicubic",
-                        "lanczos",
-                    ],
-                    {"default": "bilinear"},
-                ),
-                "stretch_x": (
-                    "FLOAT",
-                    {"default": 1.0, "min": 0.001, "max": 10.0, "step": 0.01},
-                ),
-                "stretch_y": (
-                    "FLOAT",
-                    {"default": 1.0, "min": 0.001, "max": 10.0, "step": 0.01},
-                ),
-                "use_normalized": (
-                    "BOOLEAN",
-                    {
-                        "default": False,
-                        "tooltip": "If true, transform values are scaled to image dimensions.",
-                    },
-                ),
-            },
         }
 
     FUNCTION = "transform"
@@ -89,36 +61,21 @@ class MTB_TransformImage:
         shear: float,
         border_handling="edge",
         constant_color=None,
-        filter_type="nearest",
-        stretch_x=1.0,
-        stretch_y=1.0,
-        use_normalized: bool = False,
     ):
-        filter_map = {
-            "nearest": Image.NEAREST,
-            "box": Image.BOX,
-            "bilinear": Image.BILINEAR,
-            "hamming": Image.HAMMING,
-            "bicubic": Image.BICUBIC,
-            "lanczos": Image.LANCZOS,
-        }
-        resampling_filter = filter_map[filter_type]
-
-        _, frame_height, frame_width, _ = image.size()
-        if use_normalized:
-            x = float(x) * frame_width
-            y = float(y) * frame_height
         x = int(x)
         y = int(y)
         angle = int(angle)
 
         log.debug(
-            f"Zoom: {zoom} | x: {x}, y: {y}, angle: {angle}, shear: {shear} | stretch_x: {stretch_x}, stretch_y: {stretch_y}"
+            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),
@@ -149,55 +106,18 @@ class MTB_TransformImage:
 
         for img in tensor2pil(image):
             img = TF.pad(
-                img,
+                img,  # transformed_frame,
                 padding=padding,
                 padding_mode=border_handling,
                 fill=constant_color or 0,
             )
 
-            if stretch_x != 1.0 or stretch_y != 1.0:
-                img = cast(
-                    Image.Image,
-                    TF.affine(
-                        img,
-                        angle=angle,
-                        scale=zoom,
-                        translate=[x, y],
-                        shear=shear,
-                        interpolation=resampling_filter,
-                    ),
-                )
-
-                width, height = img.size
-                center = (width // 2, height // 2)
-
-                stretch_x_factor = 1.0 / stretch_x
-                stretch_y_factor = 1.0 / stretch_y
-
-                matrix = [
-                    stretch_x_factor,
-                    0,
-                    center[0] - center[0] * stretch_x_factor,
-                    0,
-                    stretch_y_factor,
-                    center[1] - center[1] * stretch_y_factor,
-                ]
-
-                img = img.transform(
-                    img.size, Image.AFFINE, matrix, resampling_filter
-                )
-            else:
-                img = cast(
-                    Image.Image,
-                    TF.affine(
-                        img,
-                        angle=angle,
-                        scale=zoom,
-                        translate=[x, y],
-                        shear=shear,
-                        interpolation=resampling_filter,
-                    ),
-                )
+            img = cast(
+                Image.Image,
+                TF.affine(
+                    img, angle=angle, scale=zoom, translate=[x, y], shear=shear
+                ),
+            )
 
             left = abs(padding[0])
             upper = abs(padding[1])

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

@@ -4,19 +4,166 @@ import os
 import re
 from pathlib import Path
 
+import comfy.utils
 import folder_paths
+import imageio.v3 as iio
 import numpy as np
 import torch
+from comfy.model_management import get_torch_device
 from PIL import Image, ImageOps
 from PIL.PngImagePlugin import PngInfo
 
 from ..log import log
+from ..utils import np2tensor
+
+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": {
+                "image": ("IMAGE",),
+                "grid_size": (
+                    "INT",
+                    {"default": 10, "min": 1, "max": 100},
+                ),
+            }
+        }
+
+    CATEGORY = "mtb/video"
+    FUNCTION = "track"
+    RETURN_TYPES = ("COTRACK_DATA",)
+    RETURN_NAMES = ("tracking data",)
+
+    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"
+
+    # @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.
 
-    Usually used in conjunction with the `Primitive` node set to increment to load a sequence of images from a folder.
+    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.
 
     """

pyproject.toml

@@ -4,9 +4,9 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "comfy-mtb"
-version = "0.5.0"
+version = "0.2.0"
 description = "Animation oriented nodes pack for ComfyUI."
-license = { text = "MIT" }
+license = "MIT"
 readme = "README.md"
 # repository = ""
 # url = "https://github.com/melMass/comfy_mtb"
@@ -38,7 +38,6 @@ optional-dependencies = { mel = [
 ], dev = [
   "black[jupyter]",
   "codespell",
-  "marimo",
   "mypy",
   "pre-commit",
   "pytest",
@@ -63,7 +62,7 @@ DisplayName = "comfy-mtb"
 Icon = "https://avatars.githubusercontent.com/u/7041726?v=4"
 
 [tool.bumpversion]
-current_version = "0.5.0"
+current_version = "0.2.0"
 parse = "(?P<major>\\d+)\\.(?P<minor>\\d+)\\.(?P<patch>\\d+)"
 serialize = ["{major}.{minor}.{patch}"]
 search = "{current_version}"
@@ -148,26 +147,30 @@ 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
-extend-exclude = ["./docs/conf.py", "notebooks", "stubs"]
-
-[tool.ruff.lint]
 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)
-# N802 - invalid-function-name (forced by comfy's arch)
-ignore = ["D103", "D102", "D100", "N802"]
+ignore = ["D103", "D102", "D100"]
+# exclude auto generated file
+extend-exclude = ["./docs/conf.py"]
 
-[tool.ruff.lint.per-file-ignores]
+[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.lint.pydocstyle]
+[tool.ruff.pydocstyle]
 convention = "numpy"
 
 [tool.mypy]

requirements.txt

@@ -8,5 +8,9 @@ rich
 rich_argparse
 matplotlib
 pillow
+
+imageio
+imageio-ffmpeg
+aiohttp-cors
+open3d==0.17.0
 cachetools
-transformers

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/typedefs.js

@@ -16,50 +16,3 @@
  * @typedef {import("./shared.d.ts").INodeOutputSlot} INodeOutputSlot
  */
 
-/**
- * @typedef {Object} ResultItem
- * @property {string} [filename] - The filename of the item.
- * @property {string} [subfolder] - The subfolder of the item.
- * @property {string} [type] - The type of the item.
- */
-
-/**
- * @typedef {Object} Outputs
- * @property {ResultItem[]} [audio] - Audio result items.
- * @property {ResultItem[]} [images] - Image result items.
- * @property {ResultItem[]} [animated] - Animated result items.
- */
-
-/**
- * @typedef {Record<string, Outputs>} TaskOutput
- * - A record mapping Node IDs to their Outputs.
- */
-
-/**
- * @typedef {Array} TaskPrompt
- * @property {QueueIndex} [0] - The queue index.
- * @property {PromptId} [1] - The unique prompt ID.
- * @property {PromptInputs} [2] - The prompt inputs.
- * @property {ExtraData} [3] - Extra data.
- * @property {OutputsToExecute} [4] - The outputs to execute.
- */
-
-/**
- * @typedef {Object} HistoryTaskItem
- * @property {'History'} taskType - The type of task.
- * @property {TaskPrompt} prompt - The task prompt.
- * @property {Status} [status] - The status of the task.
- * @property {TaskOutput} outputs - The task outputs.
- * @property {TaskMeta} [meta] - Optional task metadata.
- */
-
-/**
- * @typedef {Object} ExecInfo
- * @property {number} queue_remaining - The number of items remaining in the queue.
- */
-
-/**
- * @typedef {Object} StatusWsMessageStatus
- * @property {ExecInfo} exec_info - Execution information.
- */
-

web/comfy_shared.js

@@ -1,9 +1,10 @@
 /**
- * @module Shared utilities
  * File: comfy_shared.js
  * Project: comfy_mtb
  * Author: Mel Massadian
+ *
  * Copyright (c) 2023-2024 Mel Massadian
+ *
  */
 
 // Reference the shared typedefs file
@@ -371,37 +372,23 @@ export function getWidgetType(config) {
  * @param {NodeType} nodeType The nodetype to attach the documentation to
  * @param {str} prefix A prefix added to each dynamic inputs
  * @param {str | [str]} inputType The datatype(s) of those dynamic inputs
- * @param {{separator?:string, start_index?:number, link?:LLink, ioSlot?:INodeInputSlot | INodeOutputSlot}?} [opts] Extra options
+ * @param {{link?:LLink, ioSlot?:INodeInputSlot | INodeOutputSlot}?} opts
  * @returns
  */
-export const setupDynamicConnections = (
-  nodeType,
-  prefix,
-  inputType,
-  opts = undefined,
-) => {
+export const setupDynamicConnections = (nodeType, prefix, inputType, opts) => {
   infoLogger(
     'Setting up dynamic connections for',
     Object.getOwnPropertyDescriptors(nodeType).title.value,
   )
 
-  /** @type {{separator:string, start_index:number, link?:LLink, ioSlot?:INodeInputSlot | INodeOutputSlot}?} */
-  const options = Object.assign(
-    {
-      separator: '_',
-      start_index: 1,
-    },
-    opts || {},
-  )
+  /** @type {{link?:LLink, ioSlot?:INodeInputSlot | INodeOutputSlot}} */
+  const options = opts || {}
   const onNodeCreated = nodeType.prototype.onNodeCreated
   const inputList = typeof inputType === 'object'
 
   nodeType.prototype.onNodeCreated = function () {
     const r = onNodeCreated ? onNodeCreated.apply(this, []) : undefined
-    this.addInput(
-      `${prefix}${options.separator}${options.start_index}`,
-      inputList ? '*' : inputType,
-    )
+    this.addInput(`${prefix}_1`, inputList ? '*' : inputType)
     return r
   }
 
@@ -436,7 +423,7 @@ export const setupDynamicConnections = (
       this,
       slotIndex,
       isConnected,
-      `${prefix}${options.separator}`,
+      `${prefix}_`,
       inputType,
       options,
     )
@@ -452,7 +439,7 @@ export const setupDynamicConnections = (
  * @param {bool} connected - Was this event connecting or disconnecting
  * @param {string} [connectionPrefix] - The common prefix of the dynamic inputs
  * @param {string|[string]} [connectionType] - The type of the dynamic connection
- * @param {{start_index?:number, link?:LLink, ioSlot?:INodeInputSlot | INodeOutputSlot}} [opts] - extra options
+ * @param {{link?:LLink, ioSlot?:INodeInputSlot | INodeOutputSlot}} [opts] - extra options
  */
 export const dynamic_connection = (
   node,
@@ -462,18 +449,13 @@ export const dynamic_connection = (
   connectionType = '*',
   opts = undefined,
 ) => {
-  /* {{start_index:number, link?:LLink, ioSlot?:INodeInputSlot | INodeOutputSlot}} [opts] - extra options*/
-  const options = Object.assign(
-    {
-      start_index: 1,
-    },
-    opts || {},
-  )
+  /* @type {{link?:LLink, ioSlot?:INodeInputSlot | INodeOutputSlot}} [opts] - extra options*/
+  const options = opts || {}
 
-  // function to test if input is a dynamic one
-  const isDynamicInput = (inputName) => inputName.startsWith(connectionPrefix)
-
-  if (node.inputs.length > 0 && !isDynamicInput(node.inputs[index].name)) {
+  if (
+    node.inputs.length > 0 &&
+    !node.inputs[index].name.startsWith(connectionPrefix)
+  ) {
     return
   }
 
@@ -492,7 +474,7 @@ export const dynamic_connection = (
     const to_remove = []
     for (let n = 1; n < node.inputs.length; n++) {
       const element = node.inputs[n]
-      if (!element.link && isDynamicInput(element.name)) {
+      if (!element.link) {
         if (node.widgets) {
           const w = node.widgets.find((w) => w.name === element.name)
           if (w) {
@@ -518,25 +500,14 @@ export const dynamic_connection = (
 
     infoLogger('Cleaning inputs: making it sequential again')
     // make inputs sequential again
-    let prefixed_idx = options.start_index
     for (let i = 0; i < node.inputs.length; i++) {
-      let name = ''
-      // rename only prefixed inputs
-      if (isDynamicInput(node.inputs[i].name)) {
-        // prefixed => rename and increase index
-        name = `${connectionPrefix}${prefixed_idx}`
-        prefixed_idx += 1
-      } else {
-        // not prefixed => keep same name
-        name = node.inputs[i].name
-      }
+      let name = `${connectionPrefix}${i + 1}`
 
       if (nameArray.length > 0) {
         name = i < nameArray.length ? nameArray[i] : name
       }
 
-      // preserve label if it exists
-      node.inputs[i].label = node.inputs[i].label || name
+      node.inputs[i].label = name
       node.inputs[i].name = name
     }
   }
@@ -576,16 +547,11 @@ export const dynamic_connection = (
     if (node.inputs.length === 0) return
     // add an extra input
     if (node.inputs[node.inputs.length - 1].link !== null) {
-      // count only the prefixed inputs
-      const nextIndex = node.inputs.reduce(
-        (acc, cur) => (isDynamicInput(cur.name) ? ++acc : acc),
-        0,
-      )
-
+      const nextIndex = node.inputs.length
       const name =
         nextIndex < nameArray.length
           ? nameArray[nextIndex]
-          : `${connectionPrefix}${nextIndex + options.start_index}`
+          : `${connectionPrefix}${nextIndex + 1}`
 
       infoLogger(`Adding input ${nextIndex + 1} (${name})`)
       node.addInput(name, conType)
@@ -1129,33 +1095,7 @@ export const addDeprecation = (nodeType, reason) => {
 
 // #endregion
 
-// #region Actions API
-export const runAction = async (name, ...args) => {
-  const req = await api.fetchApi('/mtb/actions', {
-    method: 'POST',
-    body: JSON.stringify({
-      name,
-      args,
-    }),
-  })
-
-  const res = await req.json()
-  return res.result
-}
-export const getServerInfo = async () => {
-  const res = await api.fetchApi('/mtb/server-info')
-  return await res.json()
-}
-export const setServerInfo = async (opts) => {
-  await api.fetchApi('/mtb/server-info', {
-    method: 'POST',
-    body: JSON.stringify(opts),
-  })
-}
-
-// #endregion
-
-// #region Authoring API / graph utilities
+// #region API / graph utilities
 export const getAPIInputs = () => {
   const inputs = {}
   let counter = 1
@@ -1208,4 +1148,3 @@ export const getNodes = (skip_unused) => {
   }
   return nodes
 }
-// #endregion

web/debug.js

@@ -11,8 +11,11 @@
 /// <reference path="../types/typedefs.js" />
 
 import { app } from '../../scripts/app.js'
+
 import * as shared from './comfy_shared.js'
-import * as mtb_ui from './mtb_ui.js'
+import { MtbWidgets } from './mtb_widgets.js'
+
+// TODO: respect inputs order...
 
 function escapeHtml(unsafe) {
   return unsafe
@@ -22,54 +25,6 @@ function escapeHtml(unsafe) {
     .replace(/"/g, '&quot;')
     .replace(/'/g, '&#039;')
 }
-
-function createDebugSection(title) {
-  const section = mtb_ui.makeElement('div', {
-    margin: '8px 0',
-    padding: '8px',
-    borderRadius: '4px',
-    backgroundColor: 'rgba(0,0,0,0.2)'
-  })
-
-  const header = mtb_ui.makeElement('h3', {
-    margin: '0 0 8px 0',
-    padding: '4px 0',
-    borderBottom: '1px solid rgba(255,255,255,0.1)',
-    fontSize: '14px',
-    fontWeight: 'bold',
-    color: '#9f9'
-  })
-  header.textContent = title
-  section.appendChild(header)
-
-  return section
-}
-
-function createDebugContent(content, type) {
-  const wrapper = mtb_ui.makeElement('div', {
-    margin: '4px 0'
-  })
-
-  if (type === 'text') {
-    const text = mtb_ui.makeElement('p', {
-      margin: '2px 0',
-      fontFamily: 'monospace',
-      whiteSpace: 'pre-wrap'
-    })
-    text.innerHTML = content
-    wrapper.appendChild(text)
-  } else if (type === 'image') {
-    const img = mtb_ui.makeElement('img', {
-      width: '100%',
-      borderRadius: '2px'
-    })
-    img.src = content
-    wrapper.appendChild(img)
-  }
-
-  return wrapper
-}
-
 app.registerExtension({
   name: 'mtb.Debug',
 
@@ -81,10 +36,12 @@ app.registerExtension({
   async beforeRegisterNodeDef(nodeType, nodeData, app) {
     if (nodeData.name === 'Debug (mtb)') {
       const onNodeCreated = nodeType.prototype.onNodeCreated
-      nodeType.prototype.onNodeCreated = function (...args) {
+      nodeType.prototype.onNodeCreated = function () {
         this.options = {}
-        const r = onNodeCreated ? onNodeCreated.apply(this, args) : undefined
-        this.addInput('anything_1', '*')
+        const r = onNodeCreated
+          ? onNodeCreated.apply(this, arguments)
+          : undefined
+        this.addInput(`anything_1`, '*')
         return r
       }
 
@@ -124,82 +81,61 @@ app.registerExtension({
       }
 
       const onExecuted = nodeType.prototype.onExecuted
-      nodeType.prototype.onExecuted = function (...args) {
-        onExecuted?.apply(this, args)
-        const [data, ..._rest] = args
+      nodeType.prototype.onExecuted = async function (data) {
+        onExecuted?.apply(this, arguments)
+
+        const prefix = 'anything_'
 
         if (this.widgets) {
-          let tgt_len = this.widgets.length
           for (let i = 0; i < this.widgets.length; i++) {
-            if (
-              this.widgets[i].name !== 'output_to_console' &&
-              this.widgets[i].name !== 'as_detailed_types'
-            ) {
-              this.widgets[i].onRemove?.()
+            if (this.widgets[i].name !== 'output_to_console') {
               this.widgets[i].onRemoved?.()
-              tgt_len -= 1
             }
           }
-          this.widgets.length = tgt_len
+          this.widgets.length = 1
         }
-
-        const inputData = {}
-
-        const uiData = data.ui || data
-
-        if (uiData.items) {
-            uiData.items.forEach(item => {
-                const inputName = item.input
-                if (!inputData[inputName]) {
-                    inputData[inputName] = { text: [], b64_images: [] }
-                }
-                if (item.text) {
-                    inputData[inputName].text.push(...item.text)
-                }
-                if (item.b64_images) {
-                    inputData[inputName].b64_images.push(...item.b64_images)
-                }
-            })
-        }
-
         let widgetI = 1
-        for (const [inputName, content] of Object.entries(inputData)) {
-          if (content.text.length === 0 && content.b64_images.length === 0) {
-            continue
+        if (data.text) {
+          for (const txt of data.text) {
+            const w = this.addCustomWidget(
+              MtbWidgets.DEBUG_STRING(`${prefix}_${widgetI}`, escapeHtml(txt)),
+            )
+            w.parent = this
+            widgetI++
           }
-
-          const section = createDebugSection(inputName)
-
-          if (content.text.length > 0) {
-            content.text.forEach(text => {
-              section.appendChild(createDebugContent(text, 'text'))
-            })
-          }
-
-          if (content.b64_images.length > 0) {
-            content.b64_images.forEach(img => {
-              section.appendChild(createDebugContent(img, 'image'))
-            })
-          }
-
-          this.addDOMWidget(
-            `debug_section_${widgetI}`,
-            'CUSTOM',
-            section,
-            {}
-          )
-          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 () {
-          for (const widget of this.widgets) {
-            if (widget.canvas) {
-              widget.canvas.remove()
+          // 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()
             }
-            widget.onRemoved?.()
-            widget.onRemove?.()
+            shared.cleanupNode(this)
+            this.widgets[y].onRemoved?.()
           }
-          shared.cleanupNode(this)
         }
       }
     }

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
+      }
+    }
+  },
+})

web/mtb_input_output_sidebar.js

@@ -1,9 +1,7 @@
-/// <reference path="../types/typedefs.js" />
-
 import { app } from '../../scripts/app.js'
 import { api } from '../../scripts/api.js'
 
-import * as shared from './comfy_shared.js'
+// import * as shared from './comfy_shared.js'
 
 import {
   // defineCSSClass,
@@ -17,12 +15,9 @@ import {
 const offset = 0
 let currentWidth = 200
 let currentMode = 'input'
-let subfolder = ''
 let currentSort = 'None'
 
-const IMAGE_NODES = ['LoadImage', 'VHS_LoadImagePath']
-const VIDEO_NODES = ['VHS_LoadVideo']
-const PROCESSED_PROMPT_IDS = new Set()
+const IMAGE_NODES = ['LoadImage']
 
 const updateImage = (node, image) => {
   if (IMAGE_NODES.includes(node.type)) {
@@ -31,110 +26,26 @@ const updateImage = (node, image) => {
       w.value = image
       w.callback()
     }
-  } else if (VIDEO_NODES.includes(node.type)) {
-    const w = node.widgets?.find((w) => w.name === 'video')
-    if (w) {
-      node.updateParameters({ filename: image }, true)
-    }
-  } else {
-    console.warn('No method to update', node.type)
   }
 }
 
-/**
- * Converts a result item to a request url.
- * @param {ResultItem} resultItem
- * @returns {string} - The request URL.
- */
-const resultItemToQuery = (resultItem) =>
-  [
-    `/mtb/view?filename=${resultItem.filename}`,
-    `width=512`,
-    `type=${resultItem.type}`,
-    `subfolder=${resultItem.subfolder}`,
-    `preview=`,
-  ].join('&')
-
-/**
- * Retrieves the unique prompt ID from a history task item.
- * @param {HistoryTaskItem} historyTaskItem
- * @returns {string} - The prompt ID.
- */
-const getPromptId = (historyTaskItem) => `${historyTaskItem.prompt[1]}`
-
-/**
- * Process and return any new/unseen outputs from the most recent history item.
- * @param {HistoryTaskItem} mostRecentTask - The most recent history task item.
- * @returns {Object<string, string>} - A map of task outputs URLs.
- */
-const getNewOutputUrls = (mostRecentTask) => {
-  if (!mostRecentTask) return
-
-  const promptId = getPromptId(mostRecentTask)
-  if (PROCESSED_PROMPT_IDS.has(promptId)) return
-
-  const urls = {}
-  for (const nodeOutputs of Object.values(mostRecentTask.outputs)) {
-    const { images, audio, animated } = nodeOutputs
-    if (images) {
-      const imageOutputs = Object.values(nodeOutputs.images)
-      imageOutputs.forEach(
-        (resultItem) =>
-          (urls[resultItem.filename] = resultItemToQuery(resultItem))
-      )
-    }
-    // Can process `animated` and `audio` outputs here.
-  }
-
-  const foundNewOutputs = Object.keys(urls).length > 0
-  if (!foundNewOutputs) return null
-
-  PROCESSED_PROMPT_IDS.add(promptId)
-  return urls
-}
-
-/** Fetch history and update the grid with any new ouput images. */
-const updateOutputsGrid = async () => {
-  try {
-    const history = await api.getHistory(/** maxSize: */ 1)
-    const mostRcentTask = history.History[0]
-    const newUrls = getNewOutputUrls(mostRcentTask)
-    if (newUrls) {
-      const imgGrid = document.querySelector('.mtb_img_grid')
-      getImgsFromUrls(newUrls, imgGrid, { prepend: true })
-    }
-  } catch (error) {
-    console.error('Error fetching history:', error)
-  }
-}
-
-const getImgsFromUrls = (urls, target, options = { prepend: false }) => {
+const getImgsFromUrls = (urls, target) => {
   const imgs = []
   if (urls === undefined) {
     return imgs
   }
-  const elem = currentMode === 'video' ? 'video' : 'img'
 
   for (const [key, url] of Object.entries(urls)) {
-    const a = makeElement(elem)
+    const a = makeElement('img')
     a.src = url
     a.width = currentWidth
     if (currentMode === 'input') {
       a.onclick = (_e) => {
-        if (subfolder !== '') {
-          app.extensionManager.toast.add({
-            severity: 'warn',
-            summary: 'Subfolder not supported',
-            detail: "The LoadImage node doesn't support subfolders",
-            life: 5000,
-          })
-          return
-        }
         const selected = app.canvas.selected_nodes
         if (selected && Object.keys(selected).length === 0) {
           app.extensionManager.toast.add({
             severity: 'warn',
-            summary: 'No node selected!',
+            summary: 'No LoadImage node selected!',
             detail:
               'For now the only action when clicking images in the sidebar is to set the image on all selected LoadImage nodes.',
             life: 5000,
@@ -146,19 +57,9 @@ const getImgsFromUrls = (urls, target, options = { prepend: false }) => {
           updateImage(node, key)
         }
       }
-    } else if (currentMode === 'output') {
-      a.onclick = (_e) => {
+    } else {
+      a.onclick = (_e) =>
         // window.MTB?.notify?.("Output import isn't supported yet...", 5000)
-        if (subfolder !== '') {
-          app.extensionManager.toast.add({
-            severity: 'warn',
-            summary: 'Subfolder not supported',
-            detail: "The LoadImage node doesn't support subfolders",
-            life: 5000,
-          })
-          return
-        }
-
         app.extensionManager.toast.add({
           severity: 'warn',
           summary: 'Outputs not supported',
@@ -166,66 +67,28 @@ const getImgsFromUrls = (urls, target, options = { prepend: false }) => {
             'For now only inputs can be clicked to load the image on the active LoadImage node.',
           life: 5000,
         })
-      }
-    } else {
-      a.autoplay = true
-
-      a.muted = true
-      a.loop = true
-      a.onclick = (_e) => {
-        const selected = app.canvas.selected_nodes
-        if (selected && Object.keys(selected).length === 0) {
-          app.extensionManager.toast.add({
-            severity: 'warn',
-            summary: 'No node selected!',
-            detail:
-              "For now the only action when clicking videos in the sidebar is to set the video on all selected 'Load Video (Upload)' nodes.",
-            life: 5000,
-          })
-          return
-        }
-
-        for (const [_id, node] of Object.entries(app.canvas.selected_nodes)) {
-          updateImage(node, key)
-        }
-      }
     }
     imgs.push(a)
   }
   if (target !== undefined) {
-    if (options.prepend) target.prepend(...imgs)
-    else target.append(...imgs)
+    target.append(...imgs)
   }
   return imgs
 }
 
-const getModes = async () => {
-  const inputs = await shared.runAction('getUserImageFolders')
-  return inputs
-}
-const getUrls = async (subfolder) => {
-  const count = (await api.getSetting('mtb.io-sidebar.count')) || 1000
+const getUrls = async () => {
+  const count = await api.getSetting('mtb.io-sidebar.count')
   console.log('Sidebar count', count)
-  if (currentMode === 'video') {
-    const output = await shared.runAction(
-      'getUserVideos',
-      256,
-      count,
-      offset,
-      currentSort,
-    )
-    return output || {}
-  }
-  const output = await shared.runAction(
-    'getUserImages',
-    currentMode,
-    count,
-    offset,
-    currentSort,
-    false,
-    subfolder,
-  )
-  return output || {}
+  const inputs = await api.fetchApi('/mtb/actions', {
+    method: 'POST',
+    body: JSON.stringify({
+      name: 'getUserImages',
+      // mode, count, offset
+      args: [currentMode, count, offset, currentSort],
+    }),
+  })
+  const output = await inputs.json()
+  return output?.result || {}
 }
 
 //NOTE: do not load if using the old ui
@@ -324,39 +187,21 @@ if (window?.__COMFYUI_FRONTEND_VERSION__) {
             el.parentNode.style.overflowY = 'clip'
           }
 
-          const allModes = await getModes()
-          const input_modes = allModes.input.map((m) => `input - ${m}`)
-          const output_modes = allModes.output.map((m) => `output - ${m}`)
-          const urls = await getUrls()
+          const urls = await getUrls(currentMode)
           let imgs = {}
 
           const cont = makeElement('div.mtb_sidebar')
 
           const imgGrid = makeElement('div.mtb_img_grid')
-          const selector = makeSelect(
-            ['input', 'output', 'video', ...output_modes, ...input_modes],
-            currentMode,
-          )
+          const selector = makeSelect(['input', 'output'], currentMode)
 
           selector.addEventListener('change', async (e) => {
-            let newMode = e.target.value
-            let changed = false
-            let newSub = ''
-            if (newMode !== 'input' && newMode !== 'output') {
-              if (newMode.startsWith('input - ')) {
-                newSub = newMode.replace('input - ', '')
-                newMode = 'input'
-              } else if (newMode.startsWith('output - ')) {
-                newSub = newMode.replace('output - ', '')
-                newMode = 'output'
-              }
-            }
-            changed = newMode !== currentMode || newSub !== subfolder
+            const newMode = e.target.value
+            const changed = newMode !== currentMode
             currentMode = newMode
-            subfolder = newSub
             if (changed) {
               imgGrid.innerHTML = ''
-              const urls = await getUrls(subfolder)
+              const urls = await getUrls()
               if (urls) {
                 imgs = getImgsFromUrls(urls, imgGrid)
               }
@@ -375,7 +220,7 @@ if (window?.__COMFYUI_FRONTEND_VERSION__) {
             currentSort = newSort
             if (changed) {
               imgGrid.innerHTML = ''
-              const urls = await getUrls(subfolder)
+              const urls = await getUrls()
               if (urls) {
                 imgs = getImgsFromUrls(urls, imgGrid)
               }
@@ -384,6 +229,7 @@ if (window?.__COMFYUI_FRONTEND_VERSION__) {
 
           const sizeSlider = makeSlider(64, 1024, currentWidth, 1)
           imgTools.appendChild(orderSelect)
+
           imgTools.appendChild(sizeSlider)
 
           imgs = getImgsFromUrls(urls, imgGrid)
@@ -395,16 +241,11 @@ if (window?.__COMFYUI_FRONTEND_VERSION__) {
             }
           })
           handle = renderSidebar(el, cont, [selector, imgGrid, imgTools])
-          app.api.addEventListener('status', async () => {
-            if (currentMode !== 'output') return
-            updateOutputsGrid()
-          })
         },
         destroy: () => {
           if (handle) {
             handle.unregister()
             handle = undefined
-            app.api.removeEventListener('status')
           }
         },
       })

web/mtb_ui.js

@@ -184,18 +184,6 @@ ${inputs}
   )
 }
 
-/**
- *  Wrap an element with a div
- *
- * @param {Object} [style] - CSS styles to apply to the element.
- * @returns {HTMLElement} - The created DOM element.
- */
-export const wrapElement = (element, style = {}) => {
-  const container = makeElement('div', style)
-  container.appendChild(element)
-  return container
-}
-
 /**
  * Creates a DOM element with optional styles, class, and id.
  *

web/mtb_widgets.js

@@ -3,7 +3,7 @@
  * Project: comfy_mtb
  * Author: Mel Massadian
  *
- * Copyright (c) 2023 Mel Massadian
+ * Copyright (c) 2023-2025 Mel Massadian
  *
  */
 
@@ -15,13 +15,15 @@ import { app } from '../../scripts/app.js'
 import { api } from '../../scripts/api.js'
 
 import * as mtb_ui from './mtb_ui.js'
+import { GeometryPreview } from './mtb_3d.js'
 import parseCss from './extern/parse-css.js'
 import * as shared from './comfy_shared.js'
+
 import { infoLogger } from './comfy_shared.js'
 import { NumberInputWidget } from './numberInput.js'
 
 // NOTE: new widget types registered by MTB Widgets
-const newTypes = [/*'BOOL'*/ 'COLOR', 'BBOX']
+const newTypes = [/*'BOOL'*/ , 'COLOR', 'BBOX']
 
 const deprecated_nodes = {
   //  'Animation Builder':
@@ -205,7 +207,7 @@ export function addVectorWidget(node, name, value, vector_size, callback, app) {
     // widget._value[VECTOR_AXIS[index]] = Number.parseFloat(value)
   }
 
-  console.log('prev callback', widget.callback)
+  // console.log('prev callback', widget.callback)
   widget.callback = callback
   widget._value = value
 
@@ -236,7 +238,7 @@ export const MtbWidgets = {
    * @returns {VectorWidget} The vector widget.
    */
   VECTOR: (key, val, size) => {
-    shared.infoLogger('Adding VECTOR widget', { key, val, size })
+    infoLogger('Adding VECTOR widget', { key, val, size })
     /** @type {VectorWidget} */
     const widget = {
       name: key,
@@ -438,7 +440,7 @@ export const MtbWidgets = {
             this.type == 'BBOX'
           ) {
             let delta = x < 40 ? -1 : x > widget_width - 40 ? 1 : 0
-            if (event.click_time < 200 && delta == 0) {
+            if (event.click_time < 200 && delta === 0) {
               this.prompt(
                 'Value',
                 this.value,
@@ -536,34 +538,21 @@ export const MtbWidgets = {
             picker.type = 'color'
             picker.value = this.value
 
-            Object.assign(picker.style, {
-              position: 'fixed',
-              left: `${e.clientX}px`,
-              top: `${e.clientY}px`,
-              height: '0px',
-              width: '0px',
-              padding: '0px',
-              opacity: 0,
-            })
-
-            picker.addEventListener('blur', () => {
-              this.callback?.(this.value)
-              node.graph._version++
-              picker.remove()
-            })
-            picker.addEventListener('input', () => {
-              if (!picker.value) return
-
-              this.value = picker.value
-              app.canvas.setDirty(true)
-            })
+            picker.style.position = 'absolute'
+            picker.style.left = '999999px' //(window.innerWidth / 2) + "px";
+            picker.style.top = '999999px' //(window.innerHeight / 2) + "px";
 
             document.body.appendChild(picker)
 
-            requestAnimationFrame(() => {
-              picker.showPicker()
-              picker.focus()
+            picker.addEventListener('change', () => {
+              this.value = picker.value
+              this.callback?.(this.value)
+              node.graph._version++
+              node.setDirtyCanvas(true, true)
+              picker.remove()
             })
+
+            picker.click()
           }
         }
       }
@@ -600,12 +589,15 @@ export const MtbWidgets = {
 
     w.inputEl = document.createElement('img')
     w.inputEl.src = w.value
-    w.inputEl.onload = function () {
+    w.inputEl.onload = () => {
       w.inputRatio = w.inputEl.naturalWidth / w.inputEl.naturalHeight
     }
     document.body.appendChild(w.inputEl)
     return w
   },
+  DEBUG_GEOM: async (node, name, val) => {
+    return await GeometryPreview(node, name, val)
+  },
   DEBUG_STRING: (name, val) => {
     const fontSize = 16
     const w = {
@@ -672,7 +664,8 @@ const mtb_widgets = {
   init: async () => {
     infoLogger('Registering mtb.widgets')
     try {
-      const msg = await shared.getServerInfo()
+      const res = await api.fetchApi('/mtb/server-info')
+      const msg = await res.json()
       if (!window.MTB) {
         window.MTB = {}
       }
@@ -715,11 +708,17 @@ const mtb_widgets = {
           infoLogger('Enabled DEBUG mode')
         }
 
-        try {
-          shared.setServerInfo({ debug: value })
-        } catch (err) {
-          console.error('Error:', err)
-        }
+        await api
+          .fetchApi('/mtb/server-info', {
+            method: 'POST',
+            body: JSON.stringify({
+              debug: value,
+            }),
+          })
+          .then((_response) => {})
+          .catch((error) => {
+            console.error('Error:', error)
+          })
       },
     })
   },
@@ -1076,17 +1075,17 @@ const mtb_widgets = {
               'STRING',
               '',
             )
-            console.log(input)
+            // console.log(input)
             this.addWidget('STRING', `replacement_${this.widgets.length}`, '')
           }
           //- add
           this.addWidget('button', '+', 'add', (value, widget, node) => {
-            console.log('Button clicked', value, widget, node)
+            // console.log('Button clicked', value, widget, node)
             addReplacement()
           })
           //- remove
           this.addWidget('button', '-', 'remove', (value, widget, node) => {
-            console.log(`Button clicked: ${value}`, widget, node)
+            // console.log(`Button clicked: ${value}`, widget, node)
           })
 
           return r
@@ -1102,10 +1101,13 @@ const mtb_widgets = {
 
           const getStyle = async (node) => {
             try {
-              const getStyles = await runAction(
-                'getStyles',
-                node.widgets?.[0].value ? node.widgets[0].value : '',
-              )
+              const getStyles = await api.fetchApi('/mtb/actions', {
+                method: 'POST',
+                body: JSON.stringify({
+                  name: 'getStyles',
+                  args: node.widgets?.[0].value ? node.widgets[0].value : '',
+                }),
+              })
 
               const output = await getStyles.json()
               return output?.result
@@ -1205,11 +1207,8 @@ const mtb_widgets = {
         shared.setupDynamicConnections(nodeType, 'floats', 'FLOATS')
         break
       }
-      case 'Batch Sequence (mtb)':
-      case 'Batch Sequence Plus (mtb)':
       case 'Batch Merge (mtb)': {
         shared.setupDynamicConnections(nodeType, 'batches', 'IMAGE')
-
         break
       }
       // TODO: remove this, recommend pythongoss's version that is much better
@@ -1283,141 +1282,23 @@ const mtb_widgets = {
         })
         break
       }
-      case 'Scene Detect (mtb)': {
-        break
-      }
-      case 'Loop Start (mtb)': {
+      case 'Save Tensors (mtb)': {
         const onDrawBackground = nodeType.prototype.onDrawBackground
-        nodeType.prototype.onDrawBackground = function (...args) {
+        nodeType.prototype.onDrawBackground = function (ctx, canvas) {
           const r = onDrawBackground
-            ? onDrawBackground.apply(this, args)
+            ? onDrawBackground.apply(this, arguments)
             : undefined
-          const [ctx, /*canvas,*/ ..._rest] = args
-          if (this.flags.collapsed) return r
-          if (!this.computed_flow) {
-            const related = new Set([this.id])
-            const visited = new Set()
-            if (this.outputs[0].links) {
-              const initLink = this.outputs[0].links[0]
-              const { to: loopEnd } = shared.nodesFromLink(this, initLink)
-              const canReachEnd = (node, visited = new Set()) => {
-                if (node === loopEnd) return true
-                if (visited.has(node.id)) return false
-                visited.add(node.id)
-                for (const output of node.outputs || []) {
-                  if (!output.links) continue
-                  for (const linkId of output.links) {
-                    const { to: nextNode } = shared.nodesFromLink(node, linkId)
-                    if (!nextNode) continue
-                    if (canReachEnd(nextNode, visited)) {
-                      return true
-                    }
-                  }
-                }
-                return false
-              }
-              const traverseNodes = (node) => {
-                if (visited.has(node.id)) return
-                visited.add(node.id)
+          // // draw a circle on the top right of the node, with text inside
+          // ctx.fillStyle = "#fff";
+          // ctx.beginPath();
+          // ctx.arc(this.size[0] - this.node_width * 0.5, this.size[1] - this.node_height * 0.5, this.node_width * 0.5, 0, Math.PI * 2);
+          // ctx.fill();
 
-                // can reach the end
-                if (node !== this && node !== loopEnd && !canReachEnd(node)) {
-                  return
-                }
+          // ctx.fillStyle = "#000";
+          // ctx.textAlign = "center";
+          // ctx.font = "bold 12px Arial";
+          // ctx.fillText("Save Tensors", this.size[0] - this.node_width * 0.5, this.size[1] - this.node_height * 0.5);
 
-                related.add(node.id)
-                for (const output of node.outputs || []) {
-                  if (!output.links) continue
-
-                  for (const linkId of output.links) {
-                    const { to: nextNode } = shared.nodesFromLink(node, linkId)
-                    if (!nextNode) continue
-
-                    traverseNodes(nextNode)
-                  }
-                }
-              }
-
-              traverseNodes(this)
-            }
-            this.related_to_flow = Array.from(related)
-            this.computed_flow = true
-          }
-          if (this.related_to_flow) {
-            ctx.save()
-            const points = []
-            const padding = 20
-
-            const graph = this.graph
-            const offset = this._pos
-
-            for (const nodeId of this.related_to_flow) {
-              const node = graph.getNodeById(nodeId)
-              if (!node) continue
-
-              const scale = 1.0
-              const x = node._pos[0] * scale - offset[0]
-              const y = node._pos[1] * scale - offset[1]
-              const width = node.size[0] * scale
-              const height = node.size[1] * scale
-              const scaledPadding = padding * scale
-              // console.log({ main: this, x, y, width, height })
-
-              points.push(
-                [x - scaledPadding, y - scaledPadding],
-                [x + width + scaledPadding, y - scaledPadding],
-                [x + width + scaledPadding, y + height + scaledPadding],
-                [x - scaledPadding, y + height + scaledPadding],
-              )
-            }
-            // console.log({ points })
-            const hull = shared.getConvexHull(points)
-
-            ctx.beginPath()
-
-            ctx.moveTo(hull[0][0], hull[0][1])
-            for (let i = 1; i < hull.length; i++) {
-              ctx.lineTo(hull[i][0], hull[i][1])
-            }
-
-            ctx.closePath()
-
-            ctx.fillStyle = 'rgba(255, 0, 0, 0.1)'
-            ctx.strokeStyle = 'rgba(255, 0, 0, 0.5)'
-            ctx.lineWidth = 2
-            ctx.fill()
-            ctx.stroke()
-
-            ctx.restore()
-          } else {
-            ctx.save()
-            ctx.fillStyle = 'red'
-            ctx.fillRect(-50, -50, this.size[0] + 100, this.size[1] + 100)
-            ctx.fillStyle = 'white'
-            ctx.font = 'bold 12px Arial'
-            ctx.fillText(
-              `pos: ${this.x}x${this.y}`,
-              this.size[0] / 2,
-              this.size[1],
-            )
-            ctx.fillText(
-              `size:${this._posSize}`,
-              this.size[0] / 2,
-              this.size[1] - 30,
-            )
-            ctx.fillText(
-              `dpi: ${window.devicePixelRatio}`,
-              this.size[0] / 2,
-              this.size[1] - 60,
-            )
-            ctx.fillText(
-              `next: ${graph.getNodeById(this.related_to_flow[1])._posSize}`,
-              this.size[0] / 2,
-              this.size[1] - 90,
-            )
-
-            ctx.restore()
-          }
           return r
         }
         break

web/note_plus.js

@@ -600,9 +600,9 @@ class NotePlus extends LiteGraph.LGraphNode {
     // this.updateHTML(this.html_widget.value) // widget is populated here since we called super
     // this.updateCSS(this.css_widget.value)
   }
-  // onRemoved() {
-  //   infoLogger('Node removed', this?.uuid)
-  // }
+  onRemoved() {
+    infoLogger('Node removed', this.uuid)
+  }
   getExtraMenuOptions() {
     const currentMode = this.edit_mode_widget.value
     const newMode = currentMode === 'html' ? 'markdown' : 'html'